コード例 #1
0
 /**
  * Gets all the root user groups in Silverpeas.
  *
  * @param ddManager the manager of domain drivers in use in Silverpeas.
  * @return an array of root user groups.
  * @throws AdminException if an error occurs while getting the root groups.
  */
 public Group[] getAllRootGroups(DomainDriverManager ddManager) throws AdminException {
   try {
     ddManager.getOrganizationSchema();
     GroupRow[] rows = ddManager.getOrganization().group.getAllRootGroups();
     Group[] rootGroups;
     if (rows != null) {
       rootGroups = new Group[rows.length];
       for (int i = 0; i < rows.length; i++) {
         rootGroups[i] = groupRow2Group(rows[i]);
         setDirectUsersOfGroup(ddManager, rootGroups[i]);
       }
     } else {
       rootGroups = new Group[0];
     }
     return rootGroups;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getAllRootGroupIds",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_ALL_ROOT_GROUP_IDS",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #2
0
 /**
  * Get Silverpeas admin organization
  *
  * @param ddManager
  * @return an array of AdminGroupInst containing the organization
  * @throws AdminException
  */
 public AdminGroupInst[] getAdminOrganization(DomainDriverManager ddManager)
     throws AdminException {
   try {
     ddManager.getOrganizationSchema();
     String[] asGroupIds = this.getAllGroupIds(ddManager);
     Group[] aGroup = new Group[asGroupIds.length];
     for (int nI = 0; nI < asGroupIds.length; nI++) {
       aGroup[nI] = this.getGroup(ddManager, asGroupIds[nI]);
     }
     // Search the root groups
     ArrayList<Integer> alRoot = new ArrayList<Integer>();
     for (int nI = 0; nI < aGroup.length; nI++) {
       if (aGroup[nI].getSuperGroupId() == null) {
         alRoot.add(nI);
       }
     }
     AdminGroupInst[] aAdminGroupInst = new AdminGroupInst[alRoot.size()];
     for (int nI = 0; nI < alRoot.size(); nI++) {
       aAdminGroupInst[nI] = new AdminGroupInst();
       aAdminGroupInst[nI].setGroup(aGroup[alRoot.get(nI)]);
       aAdminGroupInst[nI].setChildrenAdminGroupInst(
           this.getChildrenGroupInst(ddManager, aAdminGroupInst[nI].getGroup().getId(), aGroup));
     }
     return aAdminGroupInst;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getAdminOrganization",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_ADMIN_ORGANIZATION",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #3
0
  /**
   * /** Check if the given group exists
   *
   * @param ddManager
   * @param sName
   * @return true if a group with the given name
   * @throws AdminException
   */
  public boolean isGroupExist(DomainDriverManager ddManager, String sName) throws AdminException {
    try {
      ddManager.getOrganizationSchema();

      // build GroupRow to search
      GroupRow searchedGroup = new GroupRow();
      searchedGroup.specificId = null;
      searchedGroup.name = sName;
      searchedGroup.description = null;

      // search for group
      GroupRow[] group = ddManager.getOrganization().group.getAllMatchingGroups(searchedGroup);

      return (group.length > 0);
    } catch (Exception e) {
      throw new AdminException(
          "GroupManager.isGroupExist",
          SilverpeasException.ERROR,
          "admin.EX_ERR_IS_GROUP_EXIST",
          "group name: '" + sName + "'",
          e);
    } finally {
      ddManager.releaseOrganizationSchema();
    }
  }
コード例 #4
0
  /**
   * @param groupId
   * @return Group[]
   */
  @Override
  public Group[] getGroups(String groupId) throws Exception {
    Group[] groups = null;

    try {
      // Set the OrganizationSchema (if not already done)
      getOrganizationSchema();

      // Get the user information
      GroupRow gr = getOrganization().group.getGroup(idAsInt(groupId));
      if (gr == null) {
        throw new AdminException(
            "DomainDriverManager.getGroups",
            SilverpeasException.ERROR,
            "admin.EX_ERR_GROUP_NOT_FOUND",
            "group Id: '" + groupId + "'");
      }

      // Get a DomainDriver instance
      DomainDriver domainDriver = this.getDomainDriver(gr.domainId);

      // Get Groups of Group from specific domain
      groups = domainDriver.getGroups(gr.specificId);
    } catch (AdminException e) {
      throw new AdminException(
          "DomainDriverManager.getGroups",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_GROUPS",
          "father group Id: '" + groupId + "'",
          e);
    } finally {
      releaseOrganizationSchema();
    }
    return groups;
  }
コード例 #5
0
  /**
   * Get group information with the given id from Silverpeas
   *
   * @param ddManager
   * @param sGroupId
   * @return
   * @throws AdminException
   */
  public Group getGroup(DomainDriverManager ddManager, String sGroupId) throws AdminException {
    try {
      ddManager.getOrganizationSchema();
      GroupRow gr = ddManager.getOrganization().group.getGroup(idAsInt(sGroupId));

      Group group = new Group();

      if (gr != null) {
        group.setId(idAsString(gr.id));
        group.setSpecificId(gr.specificId);
        group.setDomainId(idAsString(gr.domainId));
        group.setSuperGroupId(idAsString(gr.superGroupId));
        group.setName(gr.name);
        group.setDescription(gr.description);
        group.setRule(gr.rule);
      }
      // Get the selected users for this group
      setDirectUsersOfGroup(ddManager, group);

      return group;
    } catch (Exception e) {
      throw new AdminException(
          "GroupManager.getGroup",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_GROUP",
          "group Id: '" + sGroupId + "'",
          e);
    } finally {
      ddManager.releaseOrganizationSchema();
    }
  }
コード例 #6
0
  /**
   * Get group information with the given group name
   *
   * @param ddManager
   * @param sGroupName
   * @param sDomainFatherId
   * @return
   * @throws AdminException
   */
  public Group getGroupByNameInDomain(
      DomainDriverManager ddManager, String sGroupName, String sDomainFatherId)
      throws AdminException {
    try {
      ddManager.getOrganizationSchema();
      Group group = ddManager.getGroupByNameInDomain(sGroupName, sDomainFatherId);

      if (group != null) {
        String specificId = group.getSpecificId();
        GroupRow gr =
            ddManager
                .getOrganization()
                .group
                .getGroupBySpecificId(idAsInt(sDomainFatherId), specificId);
        if (gr != null) {
          group.setId(idAsString(gr.id));
          // Get the selected users for this group
          setDirectUsersOfGroup(ddManager, group);
        } else {
          return null;
        }
      }
      return group;
    } catch (Exception e) {
      throw new AdminException(
          "GroupManager.getGroupByNameInDomain",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_GROUP",
          "group Name: '" + sGroupName + "'",
          e);
    } finally {
      ddManager.releaseOrganizationSchema();
    }
  }
コード例 #7
0
  /**
   * Delete the group with the given Id The delete is apply recursively to the sub-groups
   *
   * @param ddManager
   * @param group
   * @param onlyInSilverpeas
   * @return
   * @throws AdminException
   */
  public String deleteGroupById(
      DomainDriverManager ddManager, Group group, boolean onlyInSilverpeas) throws AdminException {
    try {
      ddManager.getOrganizationSchema();
      if (group.getDomainId() != null && !onlyInSilverpeas) {
        ddManager.deleteGroup(group.getId());
      }
      // Delete the group node from Silverpeas
      ddManager.getOrganization().group.removeGroup(idAsInt(group.getId()));

      // Delete index of group information
      ddManager.unindexGroup(group.getId());

      return group.getId();
    } catch (Exception e) {
      SynchroReport.error(
          "GroupManager.deleteGroupById()",
          "problème lors de la suppression du groupe " + group.getName() + " - " + e.getMessage(),
          null);
      throw new AdminException(
          "GroupManager.deleteGroupById",
          SilverpeasException.ERROR,
          "admin.EX_ERR_DELETE_GROUP",
          "group Id: '" + group.getId() + "'",
          e);
    } finally {
      ddManager.releaseOrganizationSchema();
    }
  }
コード例 #8
0
 /**
  * @param ddManager
  * @param sDomainId
  * @return
  * @throws AdminException
  */
 public Group[] getRootGroupsOfDomain(DomainDriverManager ddManager, String sDomainId)
     throws AdminException {
   try {
     // Get organization
     ddManager.getOrganizationSchema();
     // Get groups of domain from Silverpeas database
     GroupRow[] grs =
         ddManager.getOrganization().group.getAllRootGroupsOfDomain(idAsInt(sDomainId));
     // Convert GroupRow objects in Group Object
     Group[] groups = new Group[grs.length];
     for (int nI = 0; nI < grs.length; nI++) {
       groups[nI] = groupRow2Group(grs[nI]);
       // Get the selected users for this group
       setDirectUsersOfGroup(ddManager, groups[nI]);
     }
     return groups;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getRootGroupsOfDomain",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_GROUPS_OF_DOMAIN",
         "domain Id: '" + sDomainId + "'",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #9
0
  /**
   * Delete given user from Silverpeas
   *
   * @param userId user Id
   * @throws Exception
   */
  @Override
  public void deleteUser(String userId) throws Exception {
    try {
      // Set the OrganizationSchema (if not already done)
      getOrganizationSchema();

      // Get the user information
      UserRow ur = getOrganization().user.getUser(idAsInt(userId));
      if (ur == null) {
        throw new AdminException(
            "DomainDriverManager.deleteUser",
            SilverpeasException.ERROR,
            "admin.EX_ERR_USER_NOT_FOUND",
            "user Id: '" + userId + "'");
      }
      // Get a DomainDriver instance
      DomainDriver domainDriver = this.getDomainDriver(ur.domainId);
      // Get User detail from specific domain
      domainDriver.deleteUser(ur.specificId);
      // Delete index to given user
      unindexUser(userId);
    } catch (AdminException e) {
      throw new AdminException(
          "DomainDriverManager.deleteUser",
          SilverpeasException.ERROR,
          "admin.EX_ERR_DELETE_USER",
          "user Id: '" + userId + "'",
          e);
    } finally {
      releaseOrganizationSchema();
    }
  }
コード例 #10
0
 /** Start a new transaction */
 @Override
 public void startTransaction(boolean bAutoCommit) {
   try {
     getOrganizationSchema();
     inTransaction = !bAutoCommit;
   } catch (AdminException ex) {
     throw new UtilException("DomainDriverManager", "startTransaction", ex);
   }
 }
コード例 #11
0
  @Override
  public UserFull getUserFull(String userId) throws Exception {
    UserFull uf = null;
    try {
      // Set the OrganizationSchema (if not already done)
      getOrganizationSchema();
      // Get the user information
      UserRow ur = getOrganization().user.getUser(idAsInt(userId));
      if (ur == null) {
        throw new AdminException(
            "DomainDriverManager.getUser",
            SilverpeasException.ERROR,
            "admin.EX_ERR_USER_NOT_FOUND",
            "user Id: '" + userId + "'");
      }
      // Get a DomainDriver instance
      DomainDriver domainDriver = this.getDomainDriver(ur.domainId);
      // Get User detail from specific domain
      try {
        uf = domainDriver.getUserFull(ur.specificId);
      } catch (AdminException e) {
        SilverTrace.error(
            "admin",
            "DomainDriverManager.getUser",
            "admin.MSG_ERR_GET_USER",
            "user Id: '" + userId + "', domain Id: '" + ur.domainId + "'",
            e);
        uf = new UserFull(domainDriver);
        uf.setLogin(ur.login);
        uf.setFirstName(ur.firstName);
        uf.setLastName(ur.lastName);
        uf.seteMail(ur.eMail);
      }

      // Fill silverpeas info of user details
      uf.setLogin(ur.login);
      uf.setId(userId);
      uf.setSpecificId(ur.specificId);
      uf.setDomainId(idAsString(ur.domainId));
      uf.setAccessLevel(ur.accessLevel);
      uf.setLoginQuestion(ur.loginQuestion);
      uf.setLoginAnswer(ur.loginAnswer);
    } catch (AdminException e) {
      throw new AdminException(
          "DomainDriverManager.getUser",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_USER",
          "user Id: '" + userId + "', domain Id: '" + userId + "'",
          e);
    } finally {
      releaseOrganizationSchema();
    }
    return uf;
  }
コード例 #12
0
 public GroupRow[] getAllGroupOfDomain(String domainId) throws Exception {
   try {
     getOrganizationSchema();
     return getOrganization().group.getAllGroupsOfDomain(Integer.parseInt(domainId));
   } catch (AdminException e) {
     throw new AdminException(
         "DomainDriverManager.getGroupIdsOfDomain",
         SilverpeasException.ERROR,
         "admin.admin.MSG_ERR_GET_ALL_GROUPS",
         "domainId = " + domainId,
         e);
   } finally {
     releaseOrganizationSchema();
   }
 }
コード例 #13
0
 public String[] getUserIdsOfDomain(String domainId) throws Exception {
   getOrganizationSchema();
   try {
     return getOrganization().user.getUserIdsOfDomain(Integer.parseInt(domainId));
   } catch (AdminException e) {
     throw new AdminException(
         "DomainDriverManager.getUser",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_USERS",
         "domainId = " + domainId,
         e);
   } finally {
     releaseOrganizationSchema();
   }
 }
コード例 #14
0
 /**
  * Remove a user from a group
  *
  * @param ddManager
  * @param sUserId
  * @param sGroupId
  * @throws AdminException
  */
 public void removeUserFromGroup(DomainDriverManager ddManager, String sUserId, String sGroupId)
     throws AdminException {
   try {
     ddManager.getOrganizationSchema();
     ddManager.getOrganization().group.removeUserFromGroup(idAsInt(sUserId), idAsInt(sGroupId));
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.removeUserFromGroup",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_USER_GROUPS",
         "User Id: '" + sUserId + "' GroupId = '" + sGroupId + "'",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #15
0
 /**
  * Get the Silverpeas group id of group qualified by given specific Id and domain id
  *
  * @param ddManager
  * @param sSpecificId
  * @param sDomainId
  * @return
  * @throws AdminException
  */
 public String getGroupIdBySpecificIdAndDomainId(
     DomainDriverManager ddManager, String sSpecificId, String sDomainId) throws AdminException {
   try {
     ddManager.getOrganizationSchema();
     GroupRow gr =
         ddManager.getOrganization().group.getGroupBySpecificId(idAsInt(sDomainId), sSpecificId);
     return idAsString(gr.id);
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getGroupIdBySpecificIdAndDomain",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_GROUP",
         "group specific Id: '" + sSpecificId + "', domain Id: '" + sDomainId + "'",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #16
0
 /**
  * Get the all the root groups id available in Silverpeas
  *
  * @param ddManager
  * @return
  * @throws AdminException
  */
 public String[] getAllRootGroupIds(DomainDriverManager ddManager) throws AdminException {
   try {
     ddManager.getOrganizationSchema();
     String[] asGroupIds = ddManager.getOrganization().group.getAllRootGroupIds();
     if (asGroupIds != null) {
       return asGroupIds;
     }
     return ArrayUtil.EMPTY_STRING_ARRAY;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getAllRootGroupIds",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_ALL_ROOT_GROUP_IDS",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #17
0
  public String[] searchGroupsIds(
      DomainDriverManager ddManager,
      boolean isRootGroup,
      String componentId,
      String[] aProfileId,
      Group modelGroup)
      throws AdminException {
    try {
      // Get organization
      ddManager.getOrganizationSchema();
      GroupRow model = group2GroupRow(modelGroup);
      // The Ids could be equal to -1 !!!! Put it to -2 if null
      if (!StringUtil.isDefined(modelGroup.getId())) {
        model.id = -2;
      }
      if (!StringUtil.isDefined(modelGroup.getDomainId())) {
        model.domainId = -2;
      }
      if (!StringUtil.isDefined(modelGroup.getSuperGroupId())) {
        model.superGroupId = -2;
      }

      int[] aRoleId = null;
      if (aProfileId != null) {
        aRoleId = new int[aProfileId.length];
        for (int i = 0; i < aProfileId.length; i++) {
          aRoleId[i] = idAsInt(aProfileId[i]);
        }
      }
      // Get groups
      return ddManager
          .getOrganization()
          .group
          .searchGroupsIds(isRootGroup, idAsInt(componentId), aRoleId, model);
    } catch (Exception e) {
      throw new AdminException(
          "GroupManager.searchGroupsIdsInGroup",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_GROUPS_OF_DOMAIN",
          e);
    } finally {
      ddManager.releaseOrganizationSchema();
    }
  }
コード例 #18
0
 /**
  * Get the groups of domain
  *
  * @param ddManager
  * @param sDomainId
  * @return
  * @throws AdminException
  */
 public Group[] getGroupsOfDomain(DomainDriverManager ddManager, String sDomainId)
     throws AdminException {
   try {
     // Get organization
     ddManager.getOrganizationSchema();
     SynchroReport.info(
         "GroupManager.getGroupsOfDomain()",
         "Recherche des groupes du domaine LDAP dans la base...",
         null);
     // Get groups of domain from Silverpeas database
     GroupRow[] grs = ddManager.getOrganization().group.getAllGroupsOfDomain(idAsInt(sDomainId));
     // Convert GroupRow objects in Group Object
     Group[] groups = new Group[grs.length];
     for (int nI = 0; nI < grs.length; nI++) {
       groups[nI] = groupRow2Group(grs[nI]);
       SynchroReport.debug(
           "GroupManager.getGroupsOfDomain()",
           "Groupe trouvé no : "
               + Integer.toString(nI)
               + ", specificID : "
               + groups[nI].getSpecificId()
               + ", desc. : "
               + groups[nI].getDescription(),
           null);
     }
     SynchroReport.info(
         "GroupManager.getGroupsOfDomain()",
         "Récupération de " + grs.length + " groupes du domaine LDAP dans la base",
         null);
     return groups;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getGroupsOfDomain",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_GROUPS_OF_DOMAIN",
         "domain Id: '" + sDomainId + "'",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #19
0
 /**
  * Get the all the direct sub groups id of a given group
  *
  * @param ddManager
  * @param superGroupId
  * @return
  * @throws AdminException
  */
 public String[] getAllSubGroupIds(DomainDriverManager ddManager, String superGroupId)
     throws AdminException {
   try {
     ddManager.getOrganizationSchema();
     String[] asGroupIds =
         ddManager.getOrganization().group.getDirectSubGroupIds(idAsInt(superGroupId));
     if (asGroupIds != null) {
       return asGroupIds;
     }
     return ArrayUtil.EMPTY_STRING_ARRAY;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getAllSubGroupIds",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_CHILDREN_GROUP_IDS",
         "father group Id: '" + superGroupId + "'",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #20
0
 /**
  * @param ddManager
  * @return
  * @throws AdminException
  */
 public Group[] getSynchronizedGroups(DomainDriverManager ddManager) throws AdminException {
   try {
     // Get organization
     ddManager.getOrganizationSchema();
     // Get groups of domain from Silverpeas database
     GroupRow[] grs = ddManager.getOrganization().group.getSynchronizedGroups();
     // Convert GroupRow objects in Group Object
     Group[] groups = new Group[grs.length];
     for (int nI = 0; nI < grs.length; nI++) {
       groups[nI] = groupRow2Group(grs[nI]);
     }
     return groups;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getRootGroupsOfDomain",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_GROUPS_OF_DOMAIN",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #21
0
  /**
   * return group with given group name in domain
   *
   * @param groupName
   * @return Group
   */
  public Group getGroupByNameInDomain(String groupName, String domainId) throws Exception {
    try {
      // Set the OrganizationSchema (if not already done)
      getOrganizationSchema();

      // Get a DomainDriver instance
      DomainDriver domainDriver = this.getDomainDriver(idAsInt(domainId));

      // Get the group information without id and userId[]
      return domainDriver.getGroupByName(groupName);

    } catch (AdminException e) {
      throw new AdminException(
          "DomainDriverManager.getGroupByNameInDomain",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_GROUP",
          "group Name: '" + groupName + "'",
          e);
    } finally {
      releaseOrganizationSchema();
    }
  }
コード例 #22
0
  /**
   * @param domainId
   * @return
   * @throws Exception
   */
  public Group[] getAllRootGroups(String domainId) throws Exception {
    Group[] groups = null;

    try {
      // Set the OrganizationSchema (if not already done)
      getOrganizationSchema();
      // Get a DomainDriver instance
      DomainDriver domainDriver = this.getDomainDriver(idAsInt(domainId));
      // Get Group from specific domain
      groups = domainDriver.getAllRootGroups();
    } catch (AdminException e) {
      throw new AdminException(
          "DomainDriverManager.getAllRootGroups",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_ALL_ROOT_GROUPS",
          "domain Id: '" + domainId + "'",
          e);
    } finally {
      releaseOrganizationSchema();
    }
    return groups;
  }
コード例 #23
0
  /** @return Domain[] */
  public Domain[] getAllDomains() throws AdminException {
    Domain[] valret = null;
    int i;

    try {
      // Set the OrganizationSchema (if not already done)
      getOrganizationSchema();

      // Get the domain information
      DomainRow[] drs = getOrganization().domain.getAllDomains();
      if ((drs == null) || (drs.length <= 0)) {
        throw new AdminException(
            "DomainDriverManager.getAllDomains",
            SilverpeasException.ERROR,
            "admin.EX_ERR_NO_DOMAIN_FOUND");
      }

      valret = new Domain[drs.length];
      for (i = 0; i < drs.length; i++) {
        valret[i] = new Domain();
        valret[i].setId(java.lang.Integer.toString(drs[i].id));
        valret[i].setName(drs[i].name);
        valret[i].setDescription(drs[i].description);
        valret[i].setDriverClassName(drs[i].className);
        valret[i].setPropFileName(drs[i].propFileName);
        valret[i].setAuthenticationServer(drs[i].authenticationServer);
        valret[i].setTheTimeStamp(drs[i].theTimeStamp);
      }
    } catch (AdminPersistenceException e) {
      throw new AdminException(
          "DomainDriverManager.getAllDomains",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_ALL_DOMAINS",
          e);
    } finally {
      releaseOrganizationSchema();
    }
    return valret;
  }
コード例 #24
0
 /**
  * Get the direct groups id containing a user
  *
  * @param ddManager
  * @param sUserId
  * @return
  * @throws AdminException
  */
 public String[] getDirectGroupsOfUser(DomainDriverManager ddManager, String sUserId)
     throws AdminException {
   try {
     ddManager.getOrganizationSchema();
     GroupRow[] grs = ddManager.getOrganization().group.getDirectGroupsOfUser(idAsInt(sUserId));
     // Convert GroupRow objects in Group Object
     String[] groups = new String[grs.length];
     for (int nI = 0; nI < grs.length; nI++) {
       groups[nI] = idAsString(grs[nI].id);
     }
     return groups;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getDirectGroupsOfUser",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_USER_GROUPS",
         "User Id: '" + sUserId + "'",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #25
0
  /**
   * @param domainId
   * @return String
   */
  public Domain getDomain(String domainId) throws Exception {
    Domain valret = null;

    try {
      // Set the OrganizationSchema (if not already done)
      getOrganizationSchema();

      // Get the domain information
      DomainRow dr = getOrganization().domain.getDomain(idAsInt(domainId));
      if (dr == null) {
        throw new AdminException(
            "DomainDriverManager.getDomain",
            SilverpeasException.ERROR,
            "admin.EX_ERR_DOMAIN_NOT_FOUND",
            "domain Id: '" + domainId + "'");
      }

      valret = new Domain();
      valret.setId(Integer.toString(dr.id));
      valret.setName(dr.name);
      valret.setDescription(dr.description);
      valret.setDriverClassName(dr.className);
      valret.setPropFileName(dr.propFileName);
      valret.setAuthenticationServer(dr.authenticationServer);
      valret.setTheTimeStamp(dr.theTimeStamp);
      valret.setSilverpeasServerURL(dr.silverpeasServerURL);
    } catch (AdminPersistenceException e) {
      throw new AdminException(
          "DomainDriverManager.getDomain",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_DOMAIN",
          "domain id: '" + domainId + "'",
          e);
    } finally {
      releaseOrganizationSchema();
    }
    return valret;
  }
コード例 #26
0
  /**
   * Get the path from root to a given group
   *
   * @param ddManager
   * @param groupId
   * @return
   * @throws AdminException
   */
  public List<String> getPathToGroup(DomainDriverManager ddManager, String groupId)
      throws AdminException {
    try {
      ddManager.getOrganizationSchema();
      List<String> path = new ArrayList<String>();
      GroupRow superGroup = ddManager.getOrganization().group.getSuperGroup(idAsInt(groupId));
      while (superGroup != null) {
        path.add(0, idAsString(superGroup.id));
        superGroup = ddManager.getOrganization().group.getSuperGroup(superGroup.id);
      }

      return path;
    } catch (Exception e) {
      throw new AdminException(
          "GroupManager.getPathToGroup",
          SilverpeasException.ERROR,
          "admin.EX_ERR_GET_PATH_TO_GROUP",
          "groupId = " + groupId,
          e);
    } finally {
      ddManager.releaseOrganizationSchema();
    }
  }
コード例 #27
0
 /**
  * @param ddManager
  * @param sDomainId
  * @return
  * @throws AdminException
  */
 public String[] getRootGroupIdsOfDomain(DomainDriverManager ddManager, String sDomainId)
     throws AdminException {
   try {
     // Get organization
     ddManager.getOrganizationSchema();
     // Get groups of domain from Silverpeas database
     String[] groupIds =
         ddManager.getOrganization().group.getAllRootGroupIdsOfDomain(idAsInt(sDomainId));
     if (groupIds != null) {
       return groupIds;
     }
     return ArrayUtil.EMPTY_STRING_ARRAY;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.getRootGroupIdsOfDomain",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_GROUPS_OF_DOMAIN",
         "domain Id: '" + sDomainId + "'",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #28
0
  /**
   * @param groupId
   * @throws Exception
   */
  @Override
  public void deleteGroup(String groupId) throws Exception {
    try {
      // Set the OrganizationSchema (if not already done)
      getOrganizationSchema();

      // Get the group information
      GroupRow gr = getOrganization().group.getGroup(idAsInt(groupId));
      if (gr == null) {
        throw new AdminException(
            "DomainDriverManager.deleteGroup",
            SilverpeasException.ERROR,
            "admin.EX_ERR_GROUP_NOT_FOUND",
            "group Id: '" + groupId + "'");
      }

      // Get a DomainDriver instance
      DomainDriver domainDriver = this.getDomainDriver(gr.domainId);

      // Get Group detail from specific domain
      domainDriver.deleteGroup(gr.specificId);

      // Delete index to given group
      unindexGroup(groupId);

    } catch (AdminException e) {
      throw new AdminException(
          "DomainDriverManager.deleteGroup",
          SilverpeasException.ERROR,
          "admin.EX_ERR_DELETE_GROUP",
          "group Id: '" + groupId + "'",
          e);
    } finally {
      releaseOrganizationSchema();
    }
  }
コード例 #29
0
 /**
  * @param ddManager
  * @param modelGroup
  * @param isAnd
  * @return
  * @throws AdminException
  */
 public Group[] searchGroups(DomainDriverManager ddManager, Group modelGroup, boolean isAnd)
     throws AdminException {
   try {
     // Get organization
     ddManager.getOrganizationSchema();
     GroupRow model = group2GroupRow(modelGroup);
     // The Ids could be equal to -1 !!!! Put it to -2 if null
     if (!StringUtil.isDefined((modelGroup.getId()))) {
       model.id = -2;
     }
     if (!StringUtil.isDefined(modelGroup.getDomainId())) {
       model.domainId = -2;
     }
     if (!StringUtil.isDefined(modelGroup.getSuperGroupId())) {
       model.superGroupId = -2;
     }
     // Get groups
     GroupRow[] grs = ddManager.getOrganization().group.searchGroups(model, isAnd);
     // Convert GroupRow objects in Group Object
     Group[] groups = new Group[grs.length];
     for (int nI = 0; nI < grs.length; nI++) {
       groups[nI] = groupRow2Group(grs[nI]);
       // Get the selected users for this group
       setDirectUsersOfGroup(ddManager, groups[nI]);
     }
     return groups;
   } catch (Exception e) {
     throw new AdminException(
         "GroupManager.searchGroups",
         SilverpeasException.ERROR,
         "admin.EX_ERR_GET_GROUPS_OF_DOMAIN",
         e);
   } finally {
     ddManager.releaseOrganizationSchema();
   }
 }
コード例 #30
0
  /**
   * Update the given group
   *
   * @param ddManager
   * @param group
   * @param onlyInSilverpeas
   * @return
   * @throws AdminException
   */
  public String updateGroup(DomainDriverManager ddManager, Group group, boolean onlyInSilverpeas)
      throws AdminException {
    ArrayList<String> alRemUsers = new ArrayList<String>();
    ArrayList<String> alAddUsers = new ArrayList<String>();

    if (group == null
        || !StringUtil.isDefined(group.getName())
        || !StringUtil.isDefined(group.getId())) {
      if (group != null) {
        SynchroReport.error(
            "GroupManager.updateGroup()",
            "Problème lors de maj du groupe "
                + group.getSpecificId()
                + " dans la base, ce groupe n'a pas de nom",
            null);
      }
      return "";
    }
    try {
      ddManager.getOrganizationSchema();
      if (group.getDomainId() != null && !onlyInSilverpeas) {
        ddManager.updateGroup(group);
      }
      // Get the group id
      String sGroupId = group.getId();
      String strInfoSycnhro;
      if (group.getSuperGroupId() != null) {
        strInfoSycnhro =
            "Maj du groupe "
                + group.getName()
                + " (père="
                + getGroup(ddManager, group.getSuperGroupId()).getSpecificId()
                + ") dans la base (table ST_Group)...";
      } else {
        strInfoSycnhro =
            "Maj du groupe "
                + group.getName()
                + " (groupe racine) dans la base (table ST_Group)...";
      }
      SynchroReport.info("GroupManager.updateGroup()", strInfoSycnhro, null);
      // Update the group node
      GroupRow gr = group2GroupRow(group);
      ddManager.getOrganization().group.updateGroup(gr);

      // index group information
      ddManager.indexGroup(gr);

      // Update the users if necessary
      SynchroReport.info(
          "GroupManager.updateGroup()",
          "Maj éventuelle des relations du groupe "
              + group.getName()
              + " avec les utilisateurs qui y sont directement inclus (tables ST_Group_User_Rel)",
          null);
      String[] asOldUsersId =
          ddManager.getOrganization().user.getDirectUserIdsOfGroup(idAsInt(sGroupId));

      // Compute the remove users list
      String[] asNewUsersId = group.getUserIds();
      for (String anAsOldUsersId : asOldUsersId) {
        boolean bFound = false;
        for (String anAsNewUsersId : asNewUsersId) {
          if (anAsOldUsersId.equals(anAsNewUsersId)) {
            bFound = true;
          }
        }

        if (!bFound) {
          alRemUsers.add(anAsOldUsersId);
        }
      }

      // Compute the add users list
      for (String anAsNewUsersId : asNewUsersId) {
        boolean bFound = false;
        for (String anAsOldUsersId : asOldUsersId) {
          if (anAsNewUsersId.equals(anAsOldUsersId)) {
            bFound = true;
          }
        }

        if (!bFound) {
          alAddUsers.add(anAsNewUsersId);
        }
      }
      // Remove the users that are not in this group anymore
      for (String alRemUser : alRemUsers) {
        ddManager
            .getOrganization()
            .group
            .removeUserFromGroup(idAsInt(alRemUser), idAsInt(sGroupId));
      }

      // Add the new users of the group
      for (String alAddUser : alAddUsers) {
        ddManager.getOrganization().group.addUserInGroup(idAsInt(alAddUser), idAsInt(sGroupId));
      }

      SynchroReport.info(
          "GroupManager.updateGroup()",
          "Groupe : "
              + group.getName()
              + ", ajout de "
              + alAddUsers.size()
              + " nouveaux utilisateurs, suppression de "
              + alRemUsers.size()
              + " utilisateurs",
          null);
      return sGroupId;
    } catch (Exception e) {
      SynchroReport.error(
          "GroupManager.updateGroup()",
          "problème lors de la maj du groupe " + group.getName() + " - " + e.getMessage(),
          null);
      throw new AdminException(
          "GroupManager.updateGroup",
          SilverpeasException.ERROR,
          "admin.EX_ERR_UPDATE_GROUP",
          "group Id: '" + group.getId() + "'",
          e);
    } finally {
      ddManager.releaseOrganizationSchema();
    }
  }