Coverage Report

Coverage Report - org.kuali.rice.kim.document.IdentityManagementRoleDocument

Classes in this File

Line Coverage

Branch Coverage

Complexity

IdentityManagementRoleDocument

0/217

0/104

2.294

IdentityManagementRoleDocument$RoleMemberMetaDataType

0/19

0/12

2.294

 /**
  * Copyright 2005-2011 The Kuali Foundation
  *
  * Licensed under the Educational Community License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.opensource.org/licenses/ecl2.php
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.kuali.rice.kim.document;
 
 import org.apache.commons.lang.StringUtils;
 import org.kuali.rice.kew.framework.postprocessor.DocumentRouteStatusChange;
 import org.kuali.rice.kim.api.KimConstants;
 import org.kuali.rice.kim.api.responsibility.ResponsibilityService;
 import org.kuali.rice.kim.api.services.KimApiServiceLocator;
 import org.kuali.rice.kim.api.type.KimAttributeField;
 import org.kuali.rice.kim.api.type.KimType;
 import org.kuali.rice.kim.bo.ui.KimDocumentRoleMember;
 import org.kuali.rice.kim.bo.ui.KimDocumentRolePermission;
 import org.kuali.rice.kim.bo.ui.KimDocumentRoleQualifier;
 import org.kuali.rice.kim.bo.ui.KimDocumentRoleResponsibility;
 import org.kuali.rice.kim.bo.ui.KimDocumentRoleResponsibilityAction;
 import org.kuali.rice.kim.bo.ui.RoleDocumentDelegation;
 import org.kuali.rice.kim.bo.ui.RoleDocumentDelegationMember;
 import org.kuali.rice.kim.bo.ui.RoleDocumentDelegationMemberQualifier;
 import org.kuali.rice.kim.impl.responsibility.ResponsibilityInternalService;
 import org.kuali.rice.kim.impl.services.KimImplServiceLocator;
 import org.kuali.rice.kim.impl.type.IdentityManagementTypeAttributeTransactionalDocument;
 import org.kuali.rice.kim.service.KIMServiceLocatorInternal;
 import org.kuali.rice.kim.web.struts.form.IdentityManagementRoleDocumentForm;
 import org.kuali.rice.krad.service.SequenceAccessorService;
 import org.springframework.util.AutoPopulatingList;
 
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 
 
 /**
  * This is a description of what this class does - bhargavp don't forget to fill this in. 
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  *
  */
 public class IdentityManagementRoleDocument extends IdentityManagementTypeAttributeTransactionalDocument {
 
         private static final long serialVersionUID = 1L;
         // principal data
         protected String roleId;
         protected String roleTypeId;
         protected String roleTypeName;
         protected String roleNamespace = "";
         protected String roleName = "";
         protected String roleDescription = "";
 
         protected boolean active = true;
 
         protected boolean editing;
         
         protected List<KimDocumentRolePermission> permissions = new AutoPopulatingList(KimDocumentRolePermission.class);
         protected List<KimDocumentRoleResponsibility> responsibilities = new AutoPopulatingList(KimDocumentRoleResponsibility.class);
         protected List<KimDocumentRoleMember> members = new AutoPopulatingList(KimDocumentRoleMember.class);
         private List<RoleDocumentDelegationMember> delegationMembers = new AutoPopulatingList(RoleDocumentDelegationMember.class);
         private List<RoleDocumentDelegation> delegations = new AutoPopulatingList(RoleDocumentDelegation.class);
         
         transient private ResponsibilityService responsibilityService;
         transient private ResponsibilityInternalService responsibilityInternalService;
 
         public IdentityManagementRoleDocument() {
         }
 
         /**
          * @return the active
          */
         public boolean isActive() {
                 return this.active;
         }
 
         /**
          * @param active the active to set
          */
         public void setActive(boolean active) {
                 this.active = active;
         }
 
         /**
          * @param roleId the roleId to set
          */
         public void setRoleId(String roleId) {
                 this.roleId = roleId;
         }
 
         /**
          * @return the roleName
          */
         public String getRoleName() {
                 return this.roleName;
         }
 
         /**
          * @param roleName the roleName to set
          */
         public void setRoleName(String roleName) {
                 this.roleName = roleName;
         }
 
         /**
          * @return the roleDescription
          */
         public String getRoleDescription() {
                 return this.roleDescription;
         }
 
         /**
          * @param roleDescription the roleDescription to set
          */
         public void setRoleDescription(String roleDescription) {
                 this.roleDescription = roleDescription;
         }
 
         /**
          * @return the roleNamespace
          */
         public String getRoleNamespace() {
                 return this.roleNamespace;
         }
 
         /**
          * @param roleNamespace the roleNamespace to set
          */
         public void setRoleNamespace(String roleNamespace) {
                 this.roleNamespace = roleNamespace;
         }
 
         /**
          * @return the roleTypeId
          */
         public String getRoleTypeId() {
                 return this.roleTypeId;
         }
 
         /**
          * @param roleTypeId the roleTypeId to set
          */
         public void setRoleTypeId(String roleTypeId) {
                 this.roleTypeId = roleTypeId;
         }
 
         /**
          * @return the roleTypeName
          */
         public String getRoleTypeName() {
                 if ( roleTypeName == null ) {
                         if ( kimType != null ) {
                                 roleTypeName = kimType.getName();
                         } else if ( roleTypeId != null ) {
                                 setKimType( KimApiServiceLocator.getKimTypeInfoService().getKimType(roleTypeId) );
                         if ( kimType != null ) {
                                 roleTypeName = kimType.getName();
                         }
                         }
                 }
                 return this.roleTypeName;
         }
 
         /**
          * @param roleTypeName the roleTypeName to set
          */
         public void setRoleTypeName(String roleTypeName) {
                 this.roleTypeName = roleTypeName;
         }
 
         /**
          * @return the delegationMembers
          */
         public List<RoleDocumentDelegationMember> getDelegationMembers() {
                 return this.delegationMembers;
         }
 
         /**
          * @param delegationMembers the delegationMembers to set
          */
         public void setDelegationMembers(
                         List<RoleDocumentDelegationMember> delegationMembers) {
                 this.delegationMembers = delegationMembers;
         }
 
         /**
          * @return the permissions
          */
         public List<KimDocumentRolePermission> getPermissions() {
                 return this.permissions;
         }
 
         /**
          * @param permissions the permissions to set
          */
         public void setPermissions(List<KimDocumentRolePermission> permissions) {
                 this.permissions = permissions;
         }
 
         /**
          * @return the responsibilities
          */
         public List<KimDocumentRoleResponsibility> getResponsibilities() {
                 return this.responsibilities;
         }
 
         /**
          * @param responsibilities the responsibilities to set
          */
         public void setResponsibilities(
                         List<KimDocumentRoleResponsibility> responsibilities) {
                 this.responsibilities = responsibilities;
         }
 
         /**
          * @return the members
          */
         public List<KimDocumentRoleMember> getMembers() {
                 return this.members;
         }
 
     public enum RoleMemberMetaDataType implements Comparator<KimDocumentRoleMember>{
         MEMBER_ID("memberId"),
         MEMBER_NAME("memberName"),
         FULL_MEMBER_NAME("memberFullName");
 
         private final String attributeName;
 
         RoleMemberMetaDataType(String anAttributeName) {
             this.attributeName = anAttributeName;
         }
 
         public String getAttributeName() {
             return attributeName;
         }
 
         @Override
         public int compare(KimDocumentRoleMember m1, KimDocumentRoleMember m2) {
             if (m1 == null && m2 == null) {
                 return 0;
             } else if (m1 == null) {
                 return -1;
             } else if (m2 == null) {
                 return 1;
             }
             if (this.getAttributeName().equals(MEMBER_ID.getAttributeName())) {
                 return m1.getMemberId().compareToIgnoreCase(m2.getMemberId());
             }
             else if (this.getAttributeName().equals(FULL_MEMBER_NAME.getAttributeName())) {
                 return m1.getMemberFullName().compareToIgnoreCase(m2.getMemberFullName());
             }
             return m1.getMemberName().compareToIgnoreCase(m2.getMemberName());
         }
     }
 
     public void setMemberMetaDataTypeToSort(Integer columnNumber)
         {
            switch( columnNumber )
            {
                case 1:
                    this.memberMetaDataType = RoleMemberMetaDataType.MEMBER_ID;
                    break;
                case 2:
                    this.memberMetaDataType = RoleMemberMetaDataType.MEMBER_NAME;
                    break;
                case 3:
                    this.memberMetaDataType = RoleMemberMetaDataType.FULL_MEMBER_NAME;
                    break;
                default:
                    this.memberMetaDataType = RoleMemberMetaDataType.MEMBER_NAME;
                    break;
            }
         }
 
     protected RoleMemberMetaDataType memberMetaDataType = RoleMemberMetaDataType.MEMBER_NAME;
 
     public RoleMemberMetaDataType getMemberMetaDataType() {
         return memberMetaDataType;
     }
 
     public void setMemberMetaDataType(RoleMemberMetaDataType memberMetaDataType) {
         this.memberMetaDataType = memberMetaDataType;
     }
 
         /**
          * @return the members
          */
         public KimDocumentRoleMember getMember(String roleMemberId) {
                 if(StringUtils.isEmpty(roleMemberId)) {return null;}
                 for(KimDocumentRoleMember roleMember: getMembers()){
                         if(roleMemberId.equals(roleMember.getRoleMemberId())) {
                                 return roleMember;
             }
                 }
                 return null;
         }
 
         /**
          * @param members the members to set
          */
         public void setMembers(List<KimDocumentRoleMember> members) {
                 this.members = members;
         }
 
         public void addResponsibility(KimDocumentRoleResponsibility roleResponsibility){
                 if(!getResponsibilityInternalService().areActionsAtAssignmentLevelById(roleResponsibility.getResponsibilityId())) {
                         roleResponsibility.getRoleRspActions().add(getNewRespAction(roleResponsibility));
                 }
                getResponsibilities().add(roleResponsibility);
         }
 
         protected KimDocumentRoleResponsibilityAction getNewRespAction(KimDocumentRoleResponsibility roleResponsibility){
                 KimDocumentRoleResponsibilityAction roleRspAction = new KimDocumentRoleResponsibilityAction();
                 roleRspAction.setKimResponsibility(roleResponsibility.getKimResponsibility());
                 roleRspAction.setRoleResponsibilityId(roleResponsibility.getRoleResponsibilityId());                        
                 return roleRspAction;
         }
         
         public void addDelegationMember(RoleDocumentDelegationMember newDelegationMember){
                 getDelegationMembers().add(newDelegationMember);
         }
 
         /**
          * @param member the members to set
          */
         public void addMember(KimDocumentRoleMember member) {
                 SequenceAccessorService sas = getSequenceAccessorService();
                 Long nextSeq = sas.getNextAvailableSequenceNumber(
                                 KimConstants.SequenceNames.KRIM_ROLE_MBR_ID_S, 
                                 KimDocumentRoleMember.class);
                 String roleMemberId = nextSeq.toString();
                 member.setRoleMemberId(roleMemberId);
                 setupMemberRspActions(member);
                getMembers().add(member);
         }
 
         public KimDocumentRoleMember getBlankMember() {
                 KimDocumentRoleMember member = new KimDocumentRoleMember();
                 KimDocumentRoleQualifier qualifier;
                 if(getDefinitions()!=null){
                         for(KimAttributeField key : getDefinitions()) {
                         qualifier = new KimDocumentRoleQualifier();
                         qualifier.setKimAttrDefnId(getKimAttributeDefnId(key));
                         member.getQualifiers().add(qualifier);
                 }
                 }
                setupMemberRspActions(member);
                return member;
         }
 
         public RoleDocumentDelegationMember getBlankDelegationMember() {
                 RoleDocumentDelegationMember member = new RoleDocumentDelegationMember();
                 RoleDocumentDelegationMemberQualifier qualifier;
                 if(getDefinitions()!=null){
                         for(KimAttributeField key : getDefinitions()) {
                                 qualifier = new RoleDocumentDelegationMemberQualifier();
                                 setAttrDefnIdForDelMemberQualifier(qualifier, key);
                         member.getQualifiers().add(qualifier);
                 }
                 }
                return member;
         }
 
     public void setupMemberRspActions(KimDocumentRoleMember member) {
             member.getRoleRspActions().clear();
         for (KimDocumentRoleResponsibility roleResp: getResponsibilities()) {
                 if (getResponsibilityInternalService().areActionsAtAssignmentLevelById(roleResp.getResponsibilityId())) {
                         KimDocumentRoleResponsibilityAction action = new KimDocumentRoleResponsibilityAction();
                         action.setRoleResponsibilityId("*");
                         action.setRoleMemberId(member.getRoleMemberId());
                         member.getRoleRspActions().add(action);
                         break;
                 }                
         }
     }
 
     public void updateMembers(IdentityManagementRoleDocumentForm roleDocumentForm){
             for(KimDocumentRoleMember member: roleDocumentForm.getRoleDocument().getMembers()){
                     roleDocumentForm.getRoleDocument().setupMemberRspActions(member);
             }
     }
     
     public void updateMembers(KimDocumentRoleResponsibility newResponsibility){
             for(KimDocumentRoleMember member: getMembers()){
                     setupMemberRspActions(newResponsibility, member);
             }
     }
     
     public void setupMemberRspActions(KimDocumentRoleResponsibility roleResp, KimDocumentRoleMember member) {
             if ((member.getRoleRspActions()==null || member.getRoleRspActions().size()<1) && getResponsibilityInternalService().areActionsAtAssignmentLevelById(roleResp.getResponsibilityId())) {
                     KimDocumentRoleResponsibilityAction action = new KimDocumentRoleResponsibilityAction();
                     action.setRoleResponsibilityId("*");
                     action.setRoleMemberId(member.getRoleMemberId());
                     if(member.getRoleRspActions()==null) {
                             member.setRoleRspActions(new ArrayList<KimDocumentRoleResponsibilityAction>());
             }
                     member.getRoleRspActions().add(action);
             }                
     }
     
     protected void setAttrDefnIdForDelMemberQualifier(RoleDocumentDelegationMemberQualifier qualifier,KimAttributeField definition) {
                    qualifier.setKimAttrDefnId(definition.getId());
     }
     
     /**
      * @see org.kuali.rice.krad.document.DocumentBase#doRouteStatusChange(org.kuali.rice.kew.framework.postprocessor.DocumentRouteStatusChange)
      */
     @Override
         public void doRouteStatusChange(DocumentRouteStatusChange statusChangeEvent) {
                 super.doRouteStatusChange(statusChangeEvent);
                 if (getDocumentHeader().getWorkflowDocument().isProcessed()) {
                         KIMServiceLocatorInternal.getUiDocumentService().saveRole(this);
                 }
         }
 
         public void initializeDocumentForNewRole() {
                 if(StringUtils.isBlank(this.roleId)){
                         SequenceAccessorService sas = getSequenceAccessorService();
                         Long nextSeq = sas.getNextAvailableSequenceNumber(
                                         KimConstants.SequenceNames.KRIM_ROLE_ID_S, this.getClass());
                         this.roleId = nextSeq.toString();
                 }
                 if(StringUtils.isBlank(this.roleTypeId)) {
                         this.roleTypeId = "1";
                 }
         }
         
         public String getRoleId(){
                 if(StringUtils.isBlank(this.roleId)){
                         initializeDocumentForNewRole();
                 }
                 return roleId;
         }
         
         @Override
         public void prepareForSave(){
                 SequenceAccessorService sas = getSequenceAccessorService();
                 
                 String roleId;
                 if(StringUtils.isBlank(getRoleId())){
                         Long nextSeq = sas.getNextAvailableSequenceNumber(
                                         KimConstants.SequenceNames.KRIM_ROLE_ID_S, this.getClass()); 
                         roleId = nextSeq.toString();
                         setRoleId(roleId);
                 } else {
                         roleId = getRoleId();
         }
 
                 if(getPermissions()!=null){
                         String rolePermissionId;
                         for(KimDocumentRolePermission permission: getPermissions()){
                                 permission.setRoleId(roleId);
                                 if(StringUtils.isBlank(permission.getRolePermissionId())){
                                         Long nextSeq = sas.getNextAvailableSequenceNumber(
                                                         KimConstants.SequenceNames.KRIM_ROLE_PERM_ID_S, 
                                                         KimDocumentRolePermission.class);
                                         rolePermissionId = nextSeq.toString();
                                         permission.setRolePermissionId(rolePermissionId);
                                 }
                         }
                 }
                 if(getResponsibilities()!=null){
                         String roleResponsibilityId;
                         for(KimDocumentRoleResponsibility responsibility: getResponsibilities()){
                                 if(StringUtils.isBlank(responsibility.getRoleResponsibilityId())){
                                         Long nextSeq = sas.getNextAvailableSequenceNumber(
                                                         KimConstants.SequenceNames.KRIM_ROLE_RSP_ID_S, 
                                                         KimDocumentRoleResponsibility.class);
                                         roleResponsibilityId = nextSeq.toString();
                                         responsibility.setRoleResponsibilityId(roleResponsibilityId);
                                 }
                                 responsibility.setRoleId(roleId);
                                 if(!getResponsibilityInternalService().areActionsAtAssignmentLevelById(responsibility.getResponsibilityId())){
                                         if(StringUtils.isBlank(responsibility.getRoleRspActions().get(0).getRoleResponsibilityActionId())){
                                                 Long nextSeq = sas.getNextAvailableSequenceNumber(
                                                                 KimConstants.SequenceNames.KRIM_ROLE_RSP_ACTN_ID_S,
                                                                 KimDocumentRoleResponsibilityAction.class);
                                                 String roleResponsibilityActionId = nextSeq.toString();
                                                 responsibility.getRoleRspActions().get(0).setRoleResponsibilityActionId(roleResponsibilityActionId);
                                         }
                                         responsibility.getRoleRspActions().get(0).setRoleMemberId("*");
                                         responsibility.getRoleRspActions().get(0).setDocumentNumber(getDocumentNumber());
                                 }
                         }
                 }
                 if(getMembers()!=null){
                         String roleMemberId;
                         String roleResponsibilityActionId;
                         for(KimDocumentRoleMember member: getMembers()){
                                 member.setRoleId(roleId);
                                 if(StringUtils.isBlank(member.getRoleMemberId())){
                                         Long nextSeq = sas.getNextAvailableSequenceNumber(
                                                         KimConstants.SequenceNames.KRIM_ROLE_MBR_ID_S,
                                                         KimDocumentRoleMember.class);
                                         roleMemberId = nextSeq.toString();
                                         member.setRoleMemberId(roleMemberId);
                                 }
                                 for(KimDocumentRoleQualifier qualifier: member.getQualifiers()){
                                         qualifier.setKimTypId(getKimType().getId());
                                 }
                                 for(KimDocumentRoleResponsibilityAction roleRespAction: member.getRoleRspActions()){
                                         if(StringUtils.isBlank(roleRespAction.getRoleResponsibilityActionId())){
                                                 Long nextSeq = sas.getNextAvailableSequenceNumber(
                                                                 KimConstants.SequenceNames.KRIM_ROLE_RSP_ACTN_ID_S,
                                                                 KimDocumentRoleResponsibilityAction.class);
                                                 roleResponsibilityActionId = nextSeq.toString();
                                                 roleRespAction.setRoleResponsibilityActionId(roleResponsibilityActionId);
                                         }
                                         roleRespAction.setRoleMemberId(member.getRoleMemberId());
                                         roleRespAction.setDocumentNumber(getDocumentNumber());
                                         if ( !StringUtils.equals( roleRespAction.getRoleResponsibilityId(), "*" ) ) {
                                                 for(KimDocumentRoleResponsibility responsibility: getResponsibilities()){
                                                         if( StringUtils.equals( roleRespAction.getKimResponsibility().getId(), responsibility.getResponsibilityId() ) ) {
                                                                 roleRespAction.setRoleResponsibilityId(responsibility.getRoleResponsibilityId());
                                                         }
                                                 }
                                         }
                                 }
                         }
                 }
                 if(getDelegationMembers()!=null){
                         for(RoleDocumentDelegationMember delegationMember: getDelegationMembers()){
                                 delegationMember.setDocumentNumber(getDocumentNumber());
                                 addDelegationMemberToDelegation(delegationMember);
                         }
                         for(RoleDocumentDelegation delegation: getDelegations()){
                                 delegation.setDocumentNumber(getDocumentNumber());
                                 delegation.setKimTypeId(getKimType().getId());
                                 for(RoleDocumentDelegationMember member: delegation.getMembers()){
                                         for(RoleDocumentDelegationMemberQualifier qualifier: member.getQualifiers()){
                                                 qualifier.setKimTypId(getKimType().getId());
                                         }
                                 }
                                 delegation.setRoleId(roleId);
                         }
                 }
         }
         
     public ResponsibilityService getResponsibilityService() {
             if ( responsibilityService == null ) {
                     responsibilityService = KimApiServiceLocator.getResponsibilityService();
             }
                 return responsibilityService;
         }
 
     public ResponsibilityInternalService getResponsibilityInternalService() {
             if ( responsibilityInternalService == null ) {
                     responsibilityInternalService = KimImplServiceLocator.getResponsibilityInternalService();
             }
                 return responsibilityInternalService;
         }
 
         /**
          * @return the editing
          */
         public boolean isEditing() {
                 return this.editing;
         }
 
         /**
          * @param editing the editing to set
          */
         public void setEditing(boolean editing) {
                 this.editing = editing;
         }
 
         /**
          * @return the delegations
          */
         public List<RoleDocumentDelegation> getDelegations() {
                 return this.delegations;
         }
 
         /**
          * @param delegations the delegations to set
          */
         public void setDelegations(List<RoleDocumentDelegation> delegations) {
                 this.delegations = delegations;
         }
         
         public void setKimType(KimType kimType) {
                 super.setKimType(kimType);
                 if (kimType != null){
                         setRoleTypeId(kimType.getId());
                         setRoleTypeName(kimType.getName());
                 }
         }
 }

1		/**
2		* Copyright 2005-2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.kim.document;
17
18		import org.apache.commons.lang.StringUtils;
19		import org.kuali.rice.kew.framework.postprocessor.DocumentRouteStatusChange;
20		import org.kuali.rice.kim.api.KimConstants;
21		import org.kuali.rice.kim.api.responsibility.ResponsibilityService;
22		import org.kuali.rice.kim.api.services.KimApiServiceLocator;
23		import org.kuali.rice.kim.api.type.KimAttributeField;
24		import org.kuali.rice.kim.api.type.KimType;
25		import org.kuali.rice.kim.bo.ui.KimDocumentRoleMember;
26		import org.kuali.rice.kim.bo.ui.KimDocumentRolePermission;
27		import org.kuali.rice.kim.bo.ui.KimDocumentRoleQualifier;
28		import org.kuali.rice.kim.bo.ui.KimDocumentRoleResponsibility;
29		import org.kuali.rice.kim.bo.ui.KimDocumentRoleResponsibilityAction;
30		import org.kuali.rice.kim.bo.ui.RoleDocumentDelegation;
31		import org.kuali.rice.kim.bo.ui.RoleDocumentDelegationMember;
32		import org.kuali.rice.kim.bo.ui.RoleDocumentDelegationMemberQualifier;
33		import org.kuali.rice.kim.impl.responsibility.ResponsibilityInternalService;
34		import org.kuali.rice.kim.impl.services.KimImplServiceLocator;
35		import org.kuali.rice.kim.impl.type.IdentityManagementTypeAttributeTransactionalDocument;
36		import org.kuali.rice.kim.service.KIMServiceLocatorInternal;
37		import org.kuali.rice.kim.web.struts.form.IdentityManagementRoleDocumentForm;
38		import org.kuali.rice.krad.service.SequenceAccessorService;
39		import org.springframework.util.AutoPopulatingList;
40
41		import java.util.ArrayList;
42		import java.util.Comparator;
43		import java.util.List;
44
45
46		/**
47		* This is a description of what this class does - bhargavp don't forget to fill this in.
48		*
49		* @author Kuali Rice Team (rice.collab@kuali.org)
50		*
51		*/
52		public class IdentityManagementRoleDocument extends IdentityManagementTypeAttributeTransactionalDocument {
53
54		private static final long serialVersionUID = 1L;
55		// principal data
56		protected String roleId;
57		protected String roleTypeId;
58		protected String roleTypeName;
59	0	protected String roleNamespace = "";
60	0	protected String roleName = "";
61	0	protected String roleDescription = "";
62
63	0	protected boolean active = true;
64
65		protected boolean editing;
66
67	0	protected List<KimDocumentRolePermission> permissions = new AutoPopulatingList(KimDocumentRolePermission.class);
68	0	protected List<KimDocumentRoleResponsibility> responsibilities = new AutoPopulatingList(KimDocumentRoleResponsibility.class);
69	0	protected List<KimDocumentRoleMember> members = new AutoPopulatingList(KimDocumentRoleMember.class);
70	0	private List<RoleDocumentDelegationMember> delegationMembers = new AutoPopulatingList(RoleDocumentDelegationMember.class);
71	0	private List<RoleDocumentDelegation> delegations = new AutoPopulatingList(RoleDocumentDelegation.class);
72
73		transient private ResponsibilityService responsibilityService;
74		transient private ResponsibilityInternalService responsibilityInternalService;
75
76	0	public IdentityManagementRoleDocument() {
77	0	}
78
79		/**
80		* @return the active
81		*/
82		public boolean isActive() {
83	0	return this.active;
84		}
85
86		/**
87		* @param active the active to set
88		*/
89		public void setActive(boolean active) {
90	0	this.active = active;
91	0	}
92
93		/**
94		* @param roleId the roleId to set
95		*/
96		public void setRoleId(String roleId) {
97	0	this.roleId = roleId;
98	0	}
99
100		/**
101		* @return the roleName
102		*/
103		public String getRoleName() {
104	0	return this.roleName;
105		}
106
107		/**
108		* @param roleName the roleName to set
109		*/
110		public void setRoleName(String roleName) {
111	0	this.roleName = roleName;
112	0	}
113
114		/**
115		* @return the roleDescription
116		*/
117		public String getRoleDescription() {
118	0	return this.roleDescription;
119		}
120
121		/**
122		* @param roleDescription the roleDescription to set
123		*/
124		public void setRoleDescription(String roleDescription) {
125	0	this.roleDescription = roleDescription;
126	0	}
127
128		/**
129		* @return the roleNamespace
130		*/
131		public String getRoleNamespace() {
132	0	return this.roleNamespace;
133		}
134
135		/**
136		* @param roleNamespace the roleNamespace to set
137		*/
138		public void setRoleNamespace(String roleNamespace) {
139	0	this.roleNamespace = roleNamespace;
140	0	}
141
142		/**
143		* @return the roleTypeId
144		*/
145		public String getRoleTypeId() {
146	0	return this.roleTypeId;
147		}
148
149		/**
150		* @param roleTypeId the roleTypeId to set
151		*/
152		public void setRoleTypeId(String roleTypeId) {
153	0	this.roleTypeId = roleTypeId;
154	0	}
155
156		/**
157		* @return the roleTypeName
158		*/
159		public String getRoleTypeName() {
160	0	if ( roleTypeName == null ) {
161	0	if ( kimType != null ) {
162	0	roleTypeName = kimType.getName();
163	0	} else if ( roleTypeId != null ) {
164	0	setKimType( KimApiServiceLocator.getKimTypeInfoService().getKimType(roleTypeId) );
165	0	if ( kimType != null ) {
166	0	roleTypeName = kimType.getName();
167		}
168		}
169		}
170	0	return this.roleTypeName;
171		}
172
173		/**
174		* @param roleTypeName the roleTypeName to set
175		*/
176		public void setRoleTypeName(String roleTypeName) {
177	0	this.roleTypeName = roleTypeName;
178	0	}
179
180		/**
181		* @return the delegationMembers
182		*/
183		public List<RoleDocumentDelegationMember> getDelegationMembers() {
184	0	return this.delegationMembers;
185		}
186
187		/**
188		* @param delegationMembers the delegationMembers to set
189		*/
190		public void setDelegationMembers(
191		List<RoleDocumentDelegationMember> delegationMembers) {
192	0	this.delegationMembers = delegationMembers;
193	0	}
194
195		/**
196		* @return the permissions
197		*/
198		public List<KimDocumentRolePermission> getPermissions() {
199	0	return this.permissions;
200		}
201
202		/**
203		* @param permissions the permissions to set
204		*/
205		public void setPermissions(List<KimDocumentRolePermission> permissions) {
206	0	this.permissions = permissions;
207	0	}
208
209		/**
210		* @return the responsibilities
211		*/
212		public List<KimDocumentRoleResponsibility> getResponsibilities() {
213	0	return this.responsibilities;
214		}
215
216		/**
217		* @param responsibilities the responsibilities to set
218		*/
219		public void setResponsibilities(
220		List<KimDocumentRoleResponsibility> responsibilities) {
221	0	this.responsibilities = responsibilities;
222	0	}
223
224		/**
225		* @return the members
226		*/
227		public List<KimDocumentRoleMember> getMembers() {
228	0	return this.members;
229		}
230
231	0	public enum RoleMemberMetaDataType implements Comparator<KimDocumentRoleMember>{
232	0	MEMBER_ID("memberId"),
233	0	MEMBER_NAME("memberName"),
234	0	FULL_MEMBER_NAME("memberFullName");
235
236		private final String attributeName;
237
238	0	RoleMemberMetaDataType(String anAttributeName) {
239	0	this.attributeName = anAttributeName;
240	0	}
241
242		public String getAttributeName() {
243	0	return attributeName;
244		}
245
246		@Override
247		public int compare(KimDocumentRoleMember m1, KimDocumentRoleMember m2) {
248	0	if (m1 == null && m2 == null) {
249	0	return 0;
250	0	} else if (m1 == null) {
251	0	return -1;
252	0	} else if (m2 == null) {
253	0	return 1;
254		}
255	0	if (this.getAttributeName().equals(MEMBER_ID.getAttributeName())) {
256	0	return m1.getMemberId().compareToIgnoreCase(m2.getMemberId());
257		}
258	0	else if (this.getAttributeName().equals(FULL_MEMBER_NAME.getAttributeName())) {
259	0	return m1.getMemberFullName().compareToIgnoreCase(m2.getMemberFullName());
260		}
261	0	return m1.getMemberName().compareToIgnoreCase(m2.getMemberName());
262		}
263		}
264
265		public void setMemberMetaDataTypeToSort(Integer columnNumber)
266		{
267	0	switch( columnNumber )
268		{
269		case 1:
270	0	this.memberMetaDataType = RoleMemberMetaDataType.MEMBER_ID;
271	0	break;
272		case 2:
273	0	this.memberMetaDataType = RoleMemberMetaDataType.MEMBER_NAME;
274	0	break;
275		case 3:
276	0	this.memberMetaDataType = RoleMemberMetaDataType.FULL_MEMBER_NAME;
277	0	break;
278		default:
279	0	this.memberMetaDataType = RoleMemberMetaDataType.MEMBER_NAME;
280		break;
281		}
282	0	}
283
284	0	protected RoleMemberMetaDataType memberMetaDataType = RoleMemberMetaDataType.MEMBER_NAME;
285
286		public RoleMemberMetaDataType getMemberMetaDataType() {
287	0	return memberMetaDataType;
288		}
289
290		public void setMemberMetaDataType(RoleMemberMetaDataType memberMetaDataType) {
291	0	this.memberMetaDataType = memberMetaDataType;
292	0	}
293
294		/**
295		* @return the members
296		*/
297		public KimDocumentRoleMember getMember(String roleMemberId) {
298	0	if(StringUtils.isEmpty(roleMemberId)) {return null;}
299	0	for(KimDocumentRoleMember roleMember: getMembers()){
300	0	if(roleMemberId.equals(roleMember.getRoleMemberId())) {
301	0	return roleMember;
302		}
303		}
304	0	return null;
305		}
306
307		/**
308		* @param members the members to set
309		*/
310		public void setMembers(List<KimDocumentRoleMember> members) {
311	0	this.members = members;
312	0	}
313
314		public void addResponsibility(KimDocumentRoleResponsibility roleResponsibility){
315	0	if(!getResponsibilityInternalService().areActionsAtAssignmentLevelById(roleResponsibility.getResponsibilityId())) {
316	0	roleResponsibility.getRoleRspActions().add(getNewRespAction(roleResponsibility));
317		}
318	0	getResponsibilities().add(roleResponsibility);
319	0	}
320
321		protected KimDocumentRoleResponsibilityAction getNewRespAction(KimDocumentRoleResponsibility roleResponsibility){
322	0	KimDocumentRoleResponsibilityAction roleRspAction = new KimDocumentRoleResponsibilityAction();
323	0	roleRspAction.setKimResponsibility(roleResponsibility.getKimResponsibility());
324	0	roleRspAction.setRoleResponsibilityId(roleResponsibility.getRoleResponsibilityId());
325	0	return roleRspAction;
326		}
327
328		public void addDelegationMember(RoleDocumentDelegationMember newDelegationMember){
329	0	getDelegationMembers().add(newDelegationMember);
330	0	}
331
332		/**
333		* @param member the members to set
334		*/
335		public void addMember(KimDocumentRoleMember member) {
336	0	SequenceAccessorService sas = getSequenceAccessorService();
337	0	Long nextSeq = sas.getNextAvailableSequenceNumber(
338		KimConstants.SequenceNames.KRIM_ROLE_MBR_ID_S,
339		KimDocumentRoleMember.class);
340	0	String roleMemberId = nextSeq.toString();
341	0	member.setRoleMemberId(roleMemberId);
342	0	setupMemberRspActions(member);
343	0	getMembers().add(member);
344	0	}
345
346		public KimDocumentRoleMember getBlankMember() {
347	0	KimDocumentRoleMember member = new KimDocumentRoleMember();
348		KimDocumentRoleQualifier qualifier;
349	0	if(getDefinitions()!=null){
350	0	for(KimAttributeField key : getDefinitions()) {
351	0	qualifier = new KimDocumentRoleQualifier();
352	0	qualifier.setKimAttrDefnId(getKimAttributeDefnId(key));
353	0	member.getQualifiers().add(qualifier);
354		}
355		}
356	0	setupMemberRspActions(member);
357	0	return member;
358		}
359
360		public RoleDocumentDelegationMember getBlankDelegationMember() {
361	0	RoleDocumentDelegationMember member = new RoleDocumentDelegationMember();
362		RoleDocumentDelegationMemberQualifier qualifier;
363	0	if(getDefinitions()!=null){
364	0	for(KimAttributeField key : getDefinitions()) {
365	0	qualifier = new RoleDocumentDelegationMemberQualifier();
366	0	setAttrDefnIdForDelMemberQualifier(qualifier, key);
367	0	member.getQualifiers().add(qualifier);
368		}
369		}
370	0	return member;
371		}
372
373		public void setupMemberRspActions(KimDocumentRoleMember member) {
374	0	member.getRoleRspActions().clear();
375	0	for (KimDocumentRoleResponsibility roleResp: getResponsibilities()) {
376	0	if (getResponsibilityInternalService().areActionsAtAssignmentLevelById(roleResp.getResponsibilityId())) {
377	0	KimDocumentRoleResponsibilityAction action = new KimDocumentRoleResponsibilityAction();
378	0	action.setRoleResponsibilityId("*");
379	0	action.setRoleMemberId(member.getRoleMemberId());
380	0	member.getRoleRspActions().add(action);
381	0	break;
382		}
383		}
384	0	}
385
386		public void updateMembers(IdentityManagementRoleDocumentForm roleDocumentForm){
387	0	for(KimDocumentRoleMember member: roleDocumentForm.getRoleDocument().getMembers()){
388	0	roleDocumentForm.getRoleDocument().setupMemberRspActions(member);
389		}
390	0	}
391
392		public void updateMembers(KimDocumentRoleResponsibility newResponsibility){
393	0	for(KimDocumentRoleMember member: getMembers()){
394	0	setupMemberRspActions(newResponsibility, member);
395		}
396	0	}
397
398		public void setupMemberRspActions(KimDocumentRoleResponsibility roleResp, KimDocumentRoleMember member) {
399	0	if ((member.getRoleRspActions()==null \|\| member.getRoleRspActions().size()<1) && getResponsibilityInternalService().areActionsAtAssignmentLevelById(roleResp.getResponsibilityId())) {
400	0	KimDocumentRoleResponsibilityAction action = new KimDocumentRoleResponsibilityAction();
401	0	action.setRoleResponsibilityId("*");
402	0	action.setRoleMemberId(member.getRoleMemberId());
403	0	if(member.getRoleRspActions()==null) {
404	0	member.setRoleRspActions(new ArrayList<KimDocumentRoleResponsibilityAction>());
405		}
406	0	member.getRoleRspActions().add(action);
407		}
408	0	}
409
410		protected void setAttrDefnIdForDelMemberQualifier(RoleDocumentDelegationMemberQualifier qualifier,KimAttributeField definition) {
411	0	qualifier.setKimAttrDefnId(definition.getId());
412	0	}
413
414		/**
415		* @see org.kuali.rice.krad.document.DocumentBase#doRouteStatusChange(org.kuali.rice.kew.framework.postprocessor.DocumentRouteStatusChange)
416		*/
417		@Override
418		public void doRouteStatusChange(DocumentRouteStatusChange statusChangeEvent) {
419	0	super.doRouteStatusChange(statusChangeEvent);
420	0	if (getDocumentHeader().getWorkflowDocument().isProcessed()) {
421	0	KIMServiceLocatorInternal.getUiDocumentService().saveRole(this);
422		}
423	0	}
424
425		public void initializeDocumentForNewRole() {
426	0	if(StringUtils.isBlank(this.roleId)){
427	0	SequenceAccessorService sas = getSequenceAccessorService();
428	0	Long nextSeq = sas.getNextAvailableSequenceNumber(
429		KimConstants.SequenceNames.KRIM_ROLE_ID_S, this.getClass());
430	0	this.roleId = nextSeq.toString();
431		}
432	0	if(StringUtils.isBlank(this.roleTypeId)) {
433	0	this.roleTypeId = "1";
434		}
435	0	}
436
437		public String getRoleId(){
438	0	if(StringUtils.isBlank(this.roleId)){
439	0	initializeDocumentForNewRole();
440		}
441	0	return roleId;
442		}
443
444		@Override
445		public void prepareForSave(){
446	0	SequenceAccessorService sas = getSequenceAccessorService();
447
448		String roleId;
449	0	if(StringUtils.isBlank(getRoleId())){
450	0	Long nextSeq = sas.getNextAvailableSequenceNumber(
451		KimConstants.SequenceNames.KRIM_ROLE_ID_S, this.getClass());
452	0	roleId = nextSeq.toString();
453	0	setRoleId(roleId);
454	0	} else {
455	0	roleId = getRoleId();
456		}
457
458	0	if(getPermissions()!=null){
459		String rolePermissionId;
460	0	for(KimDocumentRolePermission permission: getPermissions()){
461	0	permission.setRoleId(roleId);
462	0	if(StringUtils.isBlank(permission.getRolePermissionId())){
463	0	Long nextSeq = sas.getNextAvailableSequenceNumber(
464		KimConstants.SequenceNames.KRIM_ROLE_PERM_ID_S,
465		KimDocumentRolePermission.class);
466	0	rolePermissionId = nextSeq.toString();
467	0	permission.setRolePermissionId(rolePermissionId);
468	0	}
469		}
470		}
471	0	if(getResponsibilities()!=null){
472		String roleResponsibilityId;
473	0	for(KimDocumentRoleResponsibility responsibility: getResponsibilities()){
474	0	if(StringUtils.isBlank(responsibility.getRoleResponsibilityId())){
475	0	Long nextSeq = sas.getNextAvailableSequenceNumber(
476		KimConstants.SequenceNames.KRIM_ROLE_RSP_ID_S,
477		KimDocumentRoleResponsibility.class);
478	0	roleResponsibilityId = nextSeq.toString();
479	0	responsibility.setRoleResponsibilityId(roleResponsibilityId);
480		}
481	0	responsibility.setRoleId(roleId);
482	0	if(!getResponsibilityInternalService().areActionsAtAssignmentLevelById(responsibility.getResponsibilityId())){
483	0	if(StringUtils.isBlank(responsibility.getRoleRspActions().get(0).getRoleResponsibilityActionId())){
484	0	Long nextSeq = sas.getNextAvailableSequenceNumber(
485		KimConstants.SequenceNames.KRIM_ROLE_RSP_ACTN_ID_S,
486		KimDocumentRoleResponsibilityAction.class);
487	0	String roleResponsibilityActionId = nextSeq.toString();
488	0	responsibility.getRoleRspActions().get(0).setRoleResponsibilityActionId(roleResponsibilityActionId);
489		}
490	0	responsibility.getRoleRspActions().get(0).setRoleMemberId("*");
491	0	responsibility.getRoleRspActions().get(0).setDocumentNumber(getDocumentNumber());
492		}
493		}
494		}
495	0	if(getMembers()!=null){
496		String roleMemberId;
497		String roleResponsibilityActionId;
498	0	for(KimDocumentRoleMember member: getMembers()){
499	0	member.setRoleId(roleId);
500	0	if(StringUtils.isBlank(member.getRoleMemberId())){
501	0	Long nextSeq = sas.getNextAvailableSequenceNumber(
502		KimConstants.SequenceNames.KRIM_ROLE_MBR_ID_S,
503		KimDocumentRoleMember.class);
504	0	roleMemberId = nextSeq.toString();
505	0	member.setRoleMemberId(roleMemberId);
506		}
507	0	for(KimDocumentRoleQualifier qualifier: member.getQualifiers()){
508	0	qualifier.setKimTypId(getKimType().getId());
509		}
510	0	for(KimDocumentRoleResponsibilityAction roleRespAction: member.getRoleRspActions()){
511	0	if(StringUtils.isBlank(roleRespAction.getRoleResponsibilityActionId())){
512	0	Long nextSeq = sas.getNextAvailableSequenceNumber(
513		KimConstants.SequenceNames.KRIM_ROLE_RSP_ACTN_ID_S,
514		KimDocumentRoleResponsibilityAction.class);
515	0	roleResponsibilityActionId = nextSeq.toString();
516	0	roleRespAction.setRoleResponsibilityActionId(roleResponsibilityActionId);
517		}
518	0	roleRespAction.setRoleMemberId(member.getRoleMemberId());
519	0	roleRespAction.setDocumentNumber(getDocumentNumber());
520	0	if ( !StringUtils.equals( roleRespAction.getRoleResponsibilityId(), "*" ) ) {
521	0	for(KimDocumentRoleResponsibility responsibility: getResponsibilities()){
522	0	if( StringUtils.equals( roleRespAction.getKimResponsibility().getId(), responsibility.getResponsibilityId() ) ) {
523	0	roleRespAction.setRoleResponsibilityId(responsibility.getRoleResponsibilityId());
524		}
525		}
526		}
527		}
528		}
529		}
530	0	if(getDelegationMembers()!=null){
531	0	for(RoleDocumentDelegationMember delegationMember: getDelegationMembers()){
532	0	delegationMember.setDocumentNumber(getDocumentNumber());
533	0	addDelegationMemberToDelegation(delegationMember);
534		}
535	0	for(RoleDocumentDelegation delegation: getDelegations()){
536	0	delegation.setDocumentNumber(getDocumentNumber());
537	0	delegation.setKimTypeId(getKimType().getId());
538	0	for(RoleDocumentDelegationMember member: delegation.getMembers()){
539	0	for(RoleDocumentDelegationMemberQualifier qualifier: member.getQualifiers()){
540	0	qualifier.setKimTypId(getKimType().getId());
541		}
542		}
543	0	delegation.setRoleId(roleId);
544		}
545		}
546	0	}
547
548		public ResponsibilityService getResponsibilityService() {
549	0	if ( responsibilityService == null ) {
550	0	responsibilityService = KimApiServiceLocator.getResponsibilityService();
551		}
552	0	return responsibilityService;
553		}
554
555		public ResponsibilityInternalService getResponsibilityInternalService() {
556	0	if ( responsibilityInternalService == null ) {
557	0	responsibilityInternalService = KimImplServiceLocator.getResponsibilityInternalService();
558		}
559	0	return responsibilityInternalService;
560		}
561
562		/**
563		* @return the editing
564		*/
565		public boolean isEditing() {
566	0	return this.editing;
567		}
568
569		/**
570		* @param editing the editing to set
571		*/
572		public void setEditing(boolean editing) {
573	0	this.editing = editing;
574	0	}
575
576		/**
577		* @return the delegations
578		*/
579		public List<RoleDocumentDelegation> getDelegations() {
580	0	return this.delegations;
581		}
582
583		/**
584		* @param delegations the delegations to set
585		*/
586		public void setDelegations(List<RoleDocumentDelegation> delegations) {
587	0	this.delegations = delegations;
588	0	}
589
590		public void setKimType(KimType kimType) {
591	0	super.setKimType(kimType);
592	0	if (kimType != null){
593	0	setRoleTypeId(kimType.getId());
594	0	setRoleTypeName(kimType.getName());
595		}
596	0	}
597		}