import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * Performs a search against an {@link org.kuali.rice.krad.bo.ExternalizableBusinessObject} by invoking the
 * module service
 *
 * @param searchCriteria map of criteria currently set
 * @param unbounded indicates whether the complete result should be returned.  When set to false the result is
 * limited (if necessary) to the max search result limit configured.
 * @return list of result objects, possibly bounded
 */
protected List<?> getSearchResultsForEBO(Map<String, String> searchCriteria, boolean unbounded) {
    ModuleService eboModuleService = KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService(
            getDataObjectClass());

    BusinessObjectEntry ddEntry = eboModuleService.getExternalizableBusinessObjectDictionaryEntry(
            getDataObjectClass());

    Map<String, String> filteredFieldValues = new HashMap<String, String>();
    for (String fieldName : searchCriteria.keySet()) {
        if (ddEntry.getAttributeNames().contains(fieldName)) {
            filteredFieldValues.put(fieldName, searchCriteria.get(fieldName));
        }
    }

    Map<String, Object> translatedValues = KRADUtils.coerceRequestParameterTypes(
            (Class<? extends ExternalizableBusinessObject>) getDataObjectClass(), filteredFieldValues);

    List<?> searchResults = eboModuleService.getExternalizableBusinessObjectsListForLookup(
            (Class<? extends ExternalizableBusinessObject>) getDataObjectClass(), (Map) translatedValues,
            unbounded);

    return searchResults;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
@Override
public void setDerivedValuesOnForm(HttpServletRequest request) {
	super.setDerivedValuesOnForm(request);

	String docTypeName = getDocTypeName();
	if (StringUtils.isNotBlank(docTypeName)) {
		DataDictionary dataDictionary = KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary();

           Class<? extends DerivedValuesSetter> derivedValuesSetterClass = null;
           KNSDocumentEntry documentEntry = (KNSDocumentEntry) dataDictionary.getDocumentEntry(docTypeName);
           derivedValuesSetterClass = (documentEntry).getDerivedValuesSetterClass();

		if (derivedValuesSetterClass != null) {
			DerivedValuesSetter derivedValuesSetter = null;
			try {
				derivedValuesSetter = derivedValuesSetterClass.newInstance();
			}

			catch (Exception e) {
				LOG.error("Unable to instantiate class " + derivedValuesSetterClass.getName(), e);
				throw new RuntimeException("Unable to instantiate class " + derivedValuesSetterClass.getName(), e);
			}
			derivedValuesSetter.setDerivedValues(this, request);
		}
	}
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
   * Gets an inquirable impl from the impl service name parameter. Then calls lookup service to retrieve the record from the
   * key/value parameters. Finally gets a list of Rows from the inquirable
   */
  public ActionForward start(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
      InquiryForm inquiryForm = (InquiryForm) form;
      if (inquiryForm.getBusinessObjectClassName() == null) {
          LOG.error("Business object name not given.");
          throw new RuntimeException("Business object name not given.");
      }
      
      Class boClass = Class.forName(inquiryForm.getBusinessObjectClassName());
      ModuleService responsibleModuleService = KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService(boClass);
if(responsibleModuleService!=null && responsibleModuleService.isExternalizable(boClass)){
	String redirectUrl = responsibleModuleService.getExternalizableBusinessObjectInquiryUrl(boClass, (Map<String, String[]>) request.getParameterMap());
	ActionForward redirectingActionForward = new RedirectingActionForward(redirectUrl);
	redirectingActionForward.setModule("/");
	return redirectingActionForward;
}

return continueWithInquiry(mapping, form, request, response);
  }
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
	 * Set the new collection records back to true so they can be deleted (copy
	 * should act like new)
	 *
	 * @see KualiMaintainableImpl#processAfterCopy()
	 */
	@Override
	public void processAfterCopy(MaintenanceDocument document, Map<String, String[]> parameters) {
		try {
			// This was the only remaining use of this method, as the operation with the wrapper
			// below is not necessarily safe to use in all situations, I am calling it here
			// from within the document code where we know it's safe:
			
			KradDataServiceLocator.getDataObjectService().wrap(businessObject).materializeReferencedObjectsToDepth(2
					, MaterializeOption.COLLECTIONS, MaterializeOption.UPDATE_UPDATABLE_REFS);
			
			KRADServiceLocatorWeb.getLegacyDataAdapter().setObjectPropertyDeep(businessObject, KRADPropertyConstants.NEW_COLLECTION_RECORD,
					boolean.class, true);
//			ObjectUtils.setObjectPropertyDeep(businessObject, KRADPropertyConstants.NEW_COLLECTION_RECORD,
//					boolean.class, true, 2);
		} catch (Exception e) {
			LOG.error("unable to set newCollectionRecord property: " + e.getMessage(), e);
			throw new RuntimeException("unable to set newCollectionRecord property: " + e.getMessage(), e);
		}
	}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * This overridden method ...
 *
 * @see org.kuali.rice.krad.datadictionary.validation.constraint.ValidDataPatternConstraint#getValidationMessageParams()
 */
@Override
public List<String> getValidationMessageParams() {
    if (validationMessageParams == null) {
        validationMessageParams = new ArrayList<String>();
        MessageService messageService = KRADServiceLocatorWeb.getMessageService();
        if (allowNegative) {
            validationMessageParams.add(messageService.getMessageText(
                    UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "positiveOrNegative"));
        } else {
            validationMessageParams.add(messageService.getMessageText(
                    UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "positiveOrZero"));
        }

        validationMessageParams.add(Integer.toString(precision));
        validationMessageParams.add(Integer.toString(scale));
    }
    return validationMessageParams;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * Gets keys for the maintainable business object from the persistence metadata explorer. Checks for existence of key property
 * names as request parameters, if found adds them to the returned hash map.
 */
   protected Map buildKeyMapFromRequest(Maintainable maintainable, HttpServletRequest request) {
	List keyFieldNames = null;
	// are override keys listed in the request? If so, then those need to be our keys,
	// not the primary keye fields for the BO
	if (!StringUtils.isBlank(request.getParameter(KRADConstants.OVERRIDE_KEYS))) {
		String[] overrideKeys = request.getParameter(KRADConstants.OVERRIDE_KEYS).split(KRADConstants.FIELD_CONVERSIONS_SEPARATOR);
		keyFieldNames = new ArrayList();
		for (String overrideKey : overrideKeys) {
			keyFieldNames.add(overrideKey);
		}
	}
	else {
		keyFieldNames = KRADServiceLocatorWeb.getLegacyDataAdapter().listPrimaryKeyFieldNames(maintainable.getBusinessObject().getClass());
	}
	return getRequestParameters(keyFieldNames, maintainable, request);
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
public static String getPartiallyMaskedValue(String className, String fieldName, Object formObject,
		String propertyName) {
	String displayMaskValue = null;
	Object propertyValue = ObjectUtils.getPropertyValue(formObject, propertyName);

	DataDictionaryEntryBase entry = (DataDictionaryEntryBase) KRADServiceLocatorWeb.getDataDictionaryService()
			.getDataDictionary().getDictionaryObjectEntry(className);
	AttributeDefinition a = entry.getAttributeDefinition(fieldName);

	AttributeSecurity attributeSecurity = a.getAttributeSecurity();
	if (attributeSecurity != null && attributeSecurity.isPartialMask()) {
		MaskFormatter partialMaskFormatter = attributeSecurity.getPartialMaskFormatter();
		displayMaskValue = partialMaskFormatter.maskValue(propertyValue);

	}
	return displayMaskValue;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * Given a InactivationBlockingMetadata, which represents a relationship that may block inactivation of a BO, it
 * determines whether there
 * is a record that violates the blocking definition
 *
 * @param maintenanceDocument
 * @param inactivationBlockingMetadata
 * @return true iff, based on the InactivationBlockingMetadata, the maintenance document should be allowed to route
 */
protected boolean processInactivationBlockChecking(MaintenanceDocument maintenanceDocument,
        InactivationBlockingMetadata inactivationBlockingMetadata) {
    String inactivationBlockingDetectionServiceBeanName =
            inactivationBlockingMetadata.getInactivationBlockingDetectionServiceBeanName();
    if (StringUtils.isBlank(inactivationBlockingDetectionServiceBeanName)) {
        inactivationBlockingDetectionServiceBeanName =
                KRADServiceLocatorWeb.DEFAULT_INACTIVATION_BLOCKING_DETECTION_SERVICE;
    }
    InactivationBlockingDetectionService inactivationBlockingDetectionService =
            KRADServiceLocatorWeb.getInactivationBlockingDetectionService(
                    inactivationBlockingDetectionServiceBeanName);

    boolean foundBlockingRecord = inactivationBlockingDetectionService.detectBlockingRecord(
            newDataObject, inactivationBlockingMetadata);

    if (foundBlockingRecord) {
        putInactivationBlockingErrorOnPage(maintenanceDocument, inactivationBlockingMetadata);
    }

    return !foundBlockingRecord;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
public static boolean isDocumentSession(Document document, PojoFormBase docForm) {
	boolean sessionDoc = document instanceof org.kuali.rice.krad.document.SessionDocument;
	boolean dataDictionarySessionDoc = false;
	if (!sessionDoc) {
		DataDictionary dataDictionary = KRADServiceLocatorWeb.getDataDictionaryService().getDataDictionary();
		if (docForm instanceof KualiMaintenanceForm) {
			KualiMaintenanceForm maintenanceForm = (KualiMaintenanceForm) docForm;
			if (dataDictionary != null) {
				if (maintenanceForm.getDocTypeName() != null) {
                       MaintenanceDocumentEntry maintenanceDocumentEntry = (MaintenanceDocumentEntry) dataDictionary.getDocumentEntry(maintenanceForm.getDocTypeName());
					dataDictionarySessionDoc = maintenanceDocumentEntry.isSessionDocument();
				}
			}
		}
		else {
			if (document != null && dataDictionary != null) {
				KNSDocumentEntry documentEntry = (KNSDocumentEntry) dataDictionary.getDocumentEntry(document.getClass().getName());
				dataDictionarySessionDoc = documentEntry.isSessionDocument();
			}
		}
	}
	return sessionDoc || dataDictionarySessionDoc;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * Overrides to retrieve the a {@link MaintenanceDocumentEntry} based on the configured data object class
 *
 * @return MaintenanceDocumentEntry document entry (exception thrown if not found)
 */
@Override
protected MaintenanceDocumentEntry getDocumentEntryForView() {
    MaintenanceDocumentEntry documentEntry = null;
    String docTypeName = KRADServiceLocatorWeb.getDocumentDictionaryService().getMaintenanceDocumentTypeName(
            getDataObjectClassName());
    if (StringUtils.isNotBlank(docTypeName)) {
        documentEntry = KRADServiceLocatorWeb.getDocumentDictionaryService().getMaintenanceDocumentEntry(
                docTypeName);
    }

    if (documentEntry == null) {
        throw new RuntimeException(
                "Unable to find maintenance document entry for data object class: " + getDataObjectClassName()
                        .getName());
    }

    return documentEntry;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * @see org.kuali.rice.krad.datadictionary.DataDictionaryMapper#getDataObjectEntry(org.kuali.rice.krad.datadictionary.DataDictionaryIndex,
 *      java.lang.String)
 */
@Override
public DataObjectEntry getDataObjectEntry(DataDictionaryIndex index, String className) {
    DataObjectEntry entry = getDataObjectEntryForConcreteClass(index, className);

    if (entry == null) {
        Class<?> boClass = null;
        try {
            boClass = Class.forName(className);
            ModuleService responsibleModuleService =
                    KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService(boClass);
            if (responsibleModuleService != null && responsibleModuleService.isExternalizable(boClass)) {
                entry = responsibleModuleService.getExternalizableBusinessObjectDictionaryEntry(boClass);
            }
        } catch (ClassNotFoundException cnfex) {
            // swallow so we can return null
        }
    }

    return entry;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * Determines wheter or not to create an automatic quickfinder widget for this field within the current lifecycle.
 *
 * @return True if an automatic quickfinder widget should be created for this field on the current lifecycle.
 */
protected boolean hasAutoQuickfinderRelationship() {
    String propertyName = getBindingInfo().getBindingName();

    // get object instance and class for parent
    View view = ViewLifecycle.getView();
    Object model = ViewLifecycle.getModel();
    Object parentObject = ViewModelUtils.getParentObjectForMetadata(view, model, this);
    Class<?> parentObjectClass = null;
    if (parentObject != null) {
        parentObjectClass = parentObject.getClass();
    }

    // get relationship from metadata service
    @SuppressWarnings("deprecation")
    DataObjectRelationship relationship = null;
    if (parentObject != null) {
        relationship = KRADServiceLocatorWeb.getLegacyDataAdapter().getDataObjectRelationship(parentObject,
                parentObjectClass, propertyName, "", true, true, false);
    }

    return relationship != null;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
@Override
public void validateBusinessRules(DocumentEvent event) {
    if (GlobalVariables.getMessageMap().hasErrors()) {
        logErrors();
        throw new ValidationException("errors occured before business rule");
    }

    // perform validation against rules engine
    LOG.info("invoking rules engine on document " + getDocumentNumber());
    boolean isValid = true;
    isValid = KRADServiceLocatorWeb.getKualiRuleService().applyRules(event);

    // check to see if the br eval passed or failed
    if (!isValid) {
        logErrors();
        // TODO: better error handling at the lower level and a better error message are
        // needed here
        throw new ValidationException("business rule evaluation failed");
    } else if (GlobalVariables.getMessageMap().hasErrors()) {
        logErrors();
        throw new ValidationException(
                "Unreported errors occured during business rule evaluation (rule developer needs to put meaningful error messages into global ErrorMap)");
    }
    LOG.debug("validation completed");

}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * Given a InactivationBlockingMetadata, which represents a relationship that may block inactivation of a BO, it
 * determines whether there
 * is a record that violates the blocking definition
 *
 * @param maintenanceDocument
 * @param inactivationBlockingMetadata
 * @return true iff, based on the InactivationBlockingMetadata, the maintenance document should be allowed to route
 */
protected boolean processInactivationBlockChecking(MaintenanceDocument maintenanceDocument,
        InactivationBlockingMetadata inactivationBlockingMetadata) {
    if (newBo instanceof PersistableBusinessObject) {
        String inactivationBlockingDetectionServiceBeanName =
                inactivationBlockingMetadata.getInactivationBlockingDetectionServiceBeanName();
        if (StringUtils.isBlank(inactivationBlockingDetectionServiceBeanName)) {
            inactivationBlockingDetectionServiceBeanName =
                    KRADServiceLocatorWeb.DEFAULT_INACTIVATION_BLOCKING_DETECTION_SERVICE;
        }
        InactivationBlockingDetectionService inactivationBlockingDetectionService = KRADServiceLocatorWeb
                .getInactivationBlockingDetectionService(inactivationBlockingDetectionServiceBeanName);

        boolean foundBlockingRecord = inactivationBlockingDetectionService
                .hasABlockingRecord((PersistableBusinessObject) newBo, inactivationBlockingMetadata);

        if (foundBlockingRecord) {
            putInactivationBlockingErrorOnPage(maintenanceDocument, inactivationBlockingMetadata);
        }

        return !foundBlockingRecord;
    }

    return true;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
@Override
public Document recallDocument(Document document, String annotation, boolean cancel) throws WorkflowException {
    checkForNulls(document);
    WorkflowDocument workflowDocument = KRADServiceLocatorWeb.getDocumentService().
            getByDocumentHeaderId(document.getDocumentNumber()).getDocumentHeader().getWorkflowDocument();

    if (!workflowDocument.isFinal() && !workflowDocument.isProcessed()) {
        Note note = createNoteFromDocument(document, annotation);
        document.addNote(note);
        getNoteService().save(note);
    }

    prepareWorkflowDocument(document);
    getWorkflowDocumentService().recall(document.getDocumentHeader().getWorkflowDocument(), annotation, cancel);
    UserSessionUtils.addWorkflowDocument(GlobalVariables.getUserSession(),
            document.getDocumentHeader().getWorkflowDocument());
    removeAdHocPersonsAndWorkgroups(document);
    return document;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
@Before
public void installRiceKualiModuleService() throws Exception {
    GlobalResourceLoader.stop();
    SimpleConfig config = new SimpleConfig();
    config.putProperty(CoreConstants.Config.APPLICATION_ID, "APPID");
    ConfigContext.init(config);

    StaticListableBeanFactory testBf = new StaticListableBeanFactory();

    KualiModuleService riceKualiModuleService = mock(KualiModuleService.class);
    when(riceKualiModuleService.getInstalledModuleServices()).thenReturn(riceModuleServices);

    testBf.addBean(KRADServiceLocatorWeb.KUALI_MODULE_SERVICE, riceKualiModuleService);

    ResourceLoader rl = new BeanFactoryResourceLoader(new QName("moduleservicebase-unittest"), testBf);
    GlobalResourceLoader.addResourceLoader(rl);
    GlobalResourceLoader.start();
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * Generates the js object used to override all default messages for validator jquery plugin
 * with custom messages retrieved from the message service
 * 
 * @return script for message override
 */
public static String generateValidatorMessagesOption() {
    MessageService messageService = KRADServiceLocatorWeb.getMessageService();

    String mOption = "";
    String keyValuePairs = "";
    for (ValidationMessageKeys element : EnumSet.allOf(ValidationMessageKeys.class)) {
        String key = element.toString();
        String message = messageService.getMessageText(UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + key);

        if (StringUtils.isNotEmpty(message)) {
            message = MessageStructureUtils.translateStringMessage(message);
            keyValuePairs = keyValuePairs + "\n" + key + ": '" + message + "',";
        }
    }

    keyValuePairs = StringUtils.removeEnd(keyValuePairs, ",");
    if (StringUtils.isNotEmpty(keyValuePairs)) {
        mOption = "{" + keyValuePairs + "}";
    }

    return mOption;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
protected boolean checkIfDuplicatePeopleFlow(PeopleFlowBo peopleFlowBo){
    boolean rulePassed = true;
    if (!(StringUtils.isBlank(peopleFlowBo.getName()) ||
          StringUtils.isBlank(peopleFlowBo.getNamespaceCode()))) {
            Map<String,String> criteria = new HashMap<String,String>();
            criteria.put(KewImplConstants.PropertyConstants.NAMESPACE_CODE, peopleFlowBo.getNamespaceCode());
            criteria.put(KewImplConstants.PropertyConstants.NAME, peopleFlowBo.getName());
            Collection<PeopleFlowBo> peopleFlows = KRADServiceLocatorWeb.getLegacyDataAdapter().findMatching(PeopleFlowBo.class, criteria);
            if (CollectionUtils.isEmpty(peopleFlows)) {
                rulePassed = true;
            } else {
                GlobalVariables.getMessageMap().putError("document.peopleFlow.duplicate",
                        RiceKeyConstants.PEOPLEFLOW_DUPLICATE, peopleFlowBo.getName().toString(), peopleFlowBo.getNamespaceCode().toString());
                rulePassed = false;
            }
    }
    return rulePassed;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
/**
 * Retrieves any {@link org.kuali.rice.krad.bo.DataObjectRelationship} that is associated with the given
 * field and has a configured lookup view.
 *
 * @param view view instance the quickfinder is associated with
 * @param model object containing the view data
 * @param field input field instance the quickfinder should apply to
 * @return data object relationship for the field, or null if one could not be found
 */
protected DataObjectRelationship getRelationshipForField(View view, Object model, InputField field) {
    String propertyName = field.getBindingInfo().getBindingName();

    // get object instance and class for parent
    Object parentObject = ViewModelUtils.getParentObjectForMetadata(view, model, field);
    Class<?> parentObjectClass = null;
    if (parentObject != null) {
        parentObjectClass = parentObject.getClass();
    }

    // get relationship from metadata service
    if (parentObjectClass != null) {
        return KRADServiceLocatorWeb.getLegacyDataAdapter().getDataObjectRelationship(parentObject,
                parentObjectClass, propertyName, "", true, true, false);
    }

    return null;
}
 

import org.kuali.rice.krad.service.KRADServiceLocatorWeb; //导入依赖的package包/类
protected DocumentAttribute generateSearchableAttributeFromChange(Object changeToPersist) {
    List<String> primaryKeyNames = KRADServiceLocatorWeb.getLegacyDataAdapter().listPrimaryKeyFieldNames(changeToPersist.getClass());

    for (Object primaryKeyNameAsObject : primaryKeyNames) {
        String primaryKeyName = (String)primaryKeyNameAsObject;
        Object value = ObjectUtils.getPropertyValue(changeToPersist, primaryKeyName);

        if (value != null) {
            final WorkflowAttributePropertyResolutionService propertyResolutionService = KNSServiceLocator
                    .getWorkflowAttributePropertyResolutionService();
            DocumentAttribute saValue = propertyResolutionService.buildSearchableAttribute((Class)changeToPersist.getClass(), primaryKeyName, value);
            return saValue;
        }
    }
    return null;
}