--- /dev/null
+/*****************************************************************************
+ * Copyright Igor Barma, Eric Brun, Alexandre Desoubeaux, Christian Martel,
+ * (2 décembre 2008)
+ *
+ * Ce logiciel est un programme informatique servant à l'évaluation des
+ * compétences.
+ *
+ * Ce logiciel est régi par la licence CeCILL soumise au droit français et
+ * respectant les principes de diffusion des logiciels libres. Vous pouvez
+ * utiliser, modifier et/ou redistribuer ce programme sous les conditions
+ * de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
+ * sur le site "http://www.cecill.info".
+ *
+ * En contrepartie de l'accessibilité au code source et des droits de copie,
+ * de modification et de redistribution accordés par cette licence, il n'est
+ * offert aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons,
+ * seule une responsabilité restreinte pèse sur l'auteur du programme, le
+ * titulaire des droits patrimoniaux et les concédants successifs.
+ *
+ * A cet égard l'attention de l'utilisateur est attirée sur les risques
+ * associés au chargement, à l'utilisation, à la modification et/ou au
+ * développement et à la reproduction du logiciel par l'utilisateur étant
+ * donné sa spécificité de logiciel libre, qui peut le rendre complexe à
+ * manipuler et qui le réserve donc à des développeurs et des professionnels
+ * avertis possédant des connaissances informatiques approfondies. Les
+ * utilisateurs sont donc invités à charger et tester l'adéquation du
+ * logiciel à leurs besoins dans des conditions permettant d'assurer la
+ * sécurité de leurs systèmes et ou de leurs données et, plus généralement,
+ * à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
+ *
+ * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
+ * pris connaissance de la licence CeCILL, et que vous en avez accepté les
+ * termes.
+ *******************************************************************************/
+package com.pentila.evalcomp.synchronization;
+
+import java.io.InputStream;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.StringTokenizer;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import com.pentila.evalcomp.domain.Group;
+import com.pentila.evalcomp.domain.User;
+import com.pentila.evalcomp.ldap.ILdapTools;
+
+/**
+ * The Class ImportAnnuaire.
+ */
+public class ImportAnnuaire {
+
+ /** The roles. */
+ private String[] roles;
+
+ /** The special groups. */
+ private Set<String> specialGroups = new HashSet<String>();
+
+ /** The ldap. */
+ private ILdapTools ldap;
+
+ /** The logger. */
+ org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(ImportAnnuaire.class);
+
+ /**
+ * Instantiates a new import annuaire.
+ */
+ public ImportAnnuaire() {
+ }
+
+ /**
+ * Adds the users in group.
+ *
+ * @param g
+ * the g
+ * @param u
+ * the u
+ */
+ private void addUsersInGroup(Group g, Set<User> u) {
+ if (g != null && g.getUid() != null && u != null && u.size() > 0) {
+ for (User x : u) {
+ if (!this.contains(g.getUsers(), x)) {
+ g.getUsers().add(x);
+ }
+ }
+ }
+ }
+
+ /**
+ * Contains.
+ *
+ * @param set
+ * the set
+ * @param u
+ * the u
+ *
+ * @return true, if successful
+ */
+ private boolean contains(Set<User> set, User u) {
+ boolean retVal = false;
+ for (User i : set) {
+ if (i.equals(u)) {
+ retVal = true;
+ break;
+
+ }
+ }
+ return retVal;
+ }
+
+ /**
+ * Do job.
+ *
+ * @param lu
+ * the lu
+ * @param lg
+ * the lg
+ */
+ private void doJob(Set<User> lu, Set<Group> lg) {
+ for (User u : lu) {
+ try {
+ ldap.add(u);
+ } catch (Exception e) {
+
+ }
+ }
+ for (Group g : lg) {
+ try {
+ ldap.add(g);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ }
+
+ /**
+ * Fix.
+ *
+ * @param u
+ * the u
+ * @param value
+ * the value
+ * @param attrName
+ * the attr name
+ */
+ private void fix(User u, String value, String attrName) {
+ if (attrName.equals("firstname")) {
+ u.setFirstname(value);
+ } else if (attrName.equals("lastname")) {
+ u.setLastname(value);
+ } else if (attrName.equals("mail")) {
+ u.setEmail(value);
+ } else if (attrName.equals("statut")) {
+ //
+ } else if (attrName.equals("exportKey")) {
+ //
+ } else if (attrName.equals("pwd")) {
+
+ if (value.startsWith("{CLEARTEXT}:")) {
+ value = value.split("\\{CLEARTEXT\\}:")[1];
+ value = ldap.getEncodedPassword(value);
+ }else{
+ value = "{SHA}" + value;
+ }
+ u.setPassword(value);
+ } else if (attrName.equals("uid")) {
+ u.setUid(value);
+ }
+ }
+
+ /**
+ * Gets the special groups.
+ *
+ * @param doc
+ * the doc
+ * @param groupList
+ * the group list
+ *
+ * @return the special groups
+ */
+ private void getSpecialGroups(Document doc, Set<Group> groupList) {
+ Group group;
+ User dummy;
+ this.setspecialGroups();
+ NodeList list = doc.getElementsByTagName("group");
+ for (int x = 0; x < list.getLength(); x++) {
+ if (list.item(x).hasAttributes()) {
+ String gruid = list.item(x).getAttributes().getNamedItem("uid")
+ .getNodeValue();
+ if (/*
+ * gruid.equals("GI") || gruid.equals("GT") ||
+ * gruid.equals("GP")
+ */
+ this.isSpecialGroup(gruid)) {
+ group = new Group();
+
+ NodeList tags = list.item(x).getChildNodes();
+ for (int i = 0; i < tags.getLength(); i++) {
+ if (tags.item(i).getNodeName().equals("name")) {
+ group.setUid(/* gruid + " " + */tags.item(i)
+ .getTextContent().trim());
+ } else if (tags.item(i).getNodeName().equals(
+ "description")) {
+ group.setDescription(tags.item(i).getTextContent()
+ .trim());
+ } else if (tags.item(i).getNodeName()
+ .equals("userlist")) {
+ NodeList users = tags.item(i).getChildNodes();
+ for (int k = 0; k < users.getLength(); k++) {
+ if (users.item(k).getNodeName().equals("user")) {
+ dummy = new User();
+ dummy.setUid(users.item(k).getTextContent()
+ .trim());
+ group.getUsers().add(dummy);
+ }
+ }
+ }
+ }
+ groupList.add(group);
+ }
+ }
+ }
+ }
+
+ /**
+ * Groups.
+ *
+ * @param doc
+ * the doc
+ * @param groupList
+ * the group list
+ */
+ private void groups(Document doc, Set<Group> groupList) {
+ Group group = new Group();
+ Group subgroup = new Group();
+ User dummy = new User();
+ Set<User> ul = new HashSet<User>();
+
+ NodeList list = doc.getElementsByTagName("tag");
+ if (list != null && list.getLength() > 0) {
+ for (int i = 0; i < list.getLength(); i++) {
+ ul = new HashSet<User>();
+ group = new Group();
+ NodeList userList = list.item(i).getChildNodes();
+ for (int k = 0; k < userList.getLength(); k++) {
+ if (userList.item(k).getNodeName().equals("user")) {
+
+ dummy = new User();
+ dummy.setUid(userList.item(k).getTextContent());
+ ul.add(dummy);
+ }
+ }
+ if (ul.size() == 0) {
+ continue;
+ }
+
+
+ Node currentGroup = list.item(i).getParentNode()
+ .getParentNode();
+
+
+ NodeList nl = currentGroup.getChildNodes();
+ for (int x = 0; x < nl.getLength(); x++) {
+ if (nl.item(x).getNodeName().equals("name")) {
+
+ String newuid = nl.item(x).getTextContent();
+ newuid = newuid.trim();
+ newuid = newuid.replaceAll("\\\\", "");
+ newuid = newuid.replaceAll("/", "");
+ group.setUid(newuid);
+ continue;
+ }
+ if (nl.item(x).getNodeName().equals("parent")
+ && !nl.item(x).getTextContent().equals("")
+ && nl.item(x).getTextContent() != null) {
+
+ continue;
+ }
+ if (nl.item(x).getNodeName().equals("description")) {
+
+ continue;
+ }
+ }
+ subgroup = new Group();
+ subgroup.setUid(group.getUid()
+ + "_"
+ + list.item(i).getAttributes().getNamedItem("name")
+ .getNodeValue());
+ this.addUsersInGroup(subgroup, ul);
+ groupList.add(subgroup);
+ }
+ }
+ }
+
+ /**
+ * Import annuaire.
+ *
+ * @param annuaireStream
+ * the annuaire stream
+ *
+ * @return true, if import annuaire
+ */
+ public boolean importAnnuaire(InputStream annuaireStream) {
+ Set<Group> groupList = new HashSet<Group>();
+ Set<User> userList = new HashSet<User>();
+ boolean retVal = true;
+ try {
+ // BufferedReader bf = new BufferedReader(new
+ // InputStreamReader(System.in));
+ // String xmlFile = "annuaire.xml";
+ // File file = new File(xmlFile);
+ // if (file.exists()) {
+ if (annuaireStream != null) {
+ // Create a factory
+ DocumentBuilderFactory factory = DocumentBuilderFactory
+ .newInstance();
+ // Use the factory to create a builder
+ DocumentBuilder builder = factory.newDocumentBuilder();
+ Document doc = builder.parse(annuaireStream);
+ // Get a list of all elements in the document
+
+ this.users(doc, userList);
+ this.groups(doc, groupList);
+ this.getSpecialGroups(doc, groupList);
+ this.doJob(userList, groupList);
+ } else {
+ System.out.print("File not found!");
+ retVal = false;
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ retVal = false;
+ }
+
+ return retVal;
+ }
+
+ /**
+ * Checks if is special group.
+ *
+ * @param specialGroup
+ * the special group
+ *
+ * @return true, if is special group
+ */
+ private boolean isSpecialGroup(String specialGroup) {
+ boolean retVal = false;
+
+ if (specialGroups.contains(specialGroup)) {
+ retVal = true;
+ }
+ return retVal;
+ }
+
+ /**
+ * Sets the ldap.
+ *
+ * @param ldap
+ * the ldap to set
+ */
+ public void setLdap(ILdapTools ldap) {
+ this.ldap = ldap;
+ }
+
+ /**
+ * Sets the roles.
+ *
+ * @param roles
+ * the roles to set
+ */
+ public void setRoles(String[] roles) {
+ this.roles = roles;
+ }
+
+ /**
+ * Setspecial groups.
+ */
+ private void setspecialGroups() {
+ if (roles != null) {
+ StringTokenizer str;
+ for (String roleGroupList : roles) {
+ str = new StringTokenizer(roleGroupList);
+ if (str != null && str.hasMoreTokens()) {
+ str.nextToken(","); // evita role name
+ while (str.hasMoreTokens()) {
+ String separator = str.nextToken(",");// gets group name
+ if (separator != null && separator.length() > 0) {
+ specialGroups.add(separator);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Users.
+ *
+ * @param doc
+ * the doc
+ * @param userList
+ * the user list
+ */
+ private void users(Document doc, Set<User> userList) {
+ NodeList list = doc.getElementsByTagName("users");
+ for (int i = 0; i < list.getLength(); i++) {
+ Element element = (Element) list.item(i);
+ NodeList nl = element.getChildNodes();
+
+ for (int k = 0; k < nl.getLength(); k++) {
+ Node usr = nl.item(k);
+ NodeList ul = usr.getChildNodes();
+
+ NamedNodeMap nnm = usr.getAttributes();
+ User u = new User();
+ String uid = null;
+ if (nnm != null) {
+ uid = nnm.getNamedItem("uid").getNodeValue();
+ this.fix(u, uid, "uid");
+ for (int x = 0; x < ul.getLength(); x++) {
+ this.fix(u, ul.item(x).getTextContent(), ul.item(x)
+ .getNodeName());
+ }
+ userList.add(u);
+ }
+ }
+ }
+ }
+
+}