/**
* Update the calculated person data. This method and updateCalculatedPersonOnDeleteOfSor need to
* be generalized to handle recalculations.
*
* @param toPerson
* @param fromPerson
* @param sorPerson Adjust calculated roles... Point prc_role to prc_person receiving role Add the
* role to the set of roles in receiving prc_person Remove role from prc person losing role
*/
protected void updateCalculatedPersonsOnMoveOfSor(
final Person toPerson, final Person fromPerson, final SorPerson sorPerson) {
Assert.notNull(toPerson, "toPerson cannot be null");
Assert.notNull(fromPerson, "fromPerson cannot be null");
logger.info("UpdateCalculated: recalculating person data for move.");
final List<Role> rolesToDelete = new ArrayList<Role>();
final List<SorRole> sorRoles = new ArrayList<SorRole>(sorPerson.getRoles());
for (final SorRole sorRole : sorRoles) {
for (final Role role : fromPerson.getRoles()) {
if (sorRole.getId().equals(role.getSorRoleId())) {
sorRoleElector.addSorRole(sorRole, toPerson);
rolesToDelete.add(role);
}
}
}
for (final Role role : rolesToDelete) {
sorRoleElector.removeCalculatedRole(
fromPerson, role, this.personRepository.getSoRRecordsForPerson(fromPerson));
fromPerson.getRoles().remove(role);
}
// TODO recalculate names for person receiving role? Anything else?
// TODO recalculate names for person losing role? Anything else?
// this.personRepository.savePerson(fromPerson);
// this.personRepository.savePerson(toPerson);
}
public ServiceExecutionResult<SorRole> updateSorRole(
final SorPerson sorPerson, final SorRole sorRole) {
Assert.notNull(sorPerson, "sorPerson cannot be null.");
Assert.notNull(sorRole, "sorRole cannot be null.");
final Set validationErrors = this.validator.validate(sorRole);
if (!validationErrors.isEmpty()) {
// since because of existing design we cannot raise exception, we can only rollback the
// transaction through code
// OR-384
if (TransactionAspectSupport.currentTransactionStatus() != null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
return new GeneralServiceExecutionResult<SorRole>(validationErrors);
}
final SorRole savedSorRole = this.personRepository.saveSorRole(sorRole);
final Person person = this.personRepository.findByInternalId(sorPerson.getPersonId());
final Role role = person.findRoleBySoRRoleId(savedSorRole.getId());
if (role != null) {
// update calculated role only if that role was previously converted to calculated one by
// sorRoleElector
role.recalculate(savedSorRole);
this.personRepository.savePerson(person);
}
// else //do nothing i.e. don't update the calculated role if SorRoleElector Previously decided
// not to convert this sor role to calculated role
return new GeneralServiceExecutionResult<SorRole>(savedSorRole);
}
@PreAuthorize("hasPermission(#sorRole, 'admin')")
public ServiceExecutionResult<SorRole> validateAndSaveRoleForSorPerson(
final SorPerson sorPerson, final SorRole sorRole) {
logger.info(" validateAndSaveRoleForSorPerson start");
Assert.notNull(sorPerson, "SorPerson cannot be null.");
Assert.notNull(sorRole, "SorRole cannot be null.");
// check if the SoR Role has an ID assigned to it already and assign source sor
setRoleIdAndSource(sorRole, sorPerson.getSourceSor());
final Set validationErrors = this.validator.validate(sorRole);
if (!validationErrors.isEmpty()) {
// since because of existing design we cannot raise exception, we can only rollback the
// transaction through code
// OR-384
if (TransactionAspectSupport.currentTransactionStatus() != null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
return new GeneralServiceExecutionResult<SorRole>(validationErrors);
}
final SorPerson newSorPerson = this.personRepository.saveSorPerson(sorPerson);
Person person = this.personRepository.findByInternalId(newSorPerson.getPersonId());
final SorRole newSorRole = newSorPerson.findSorRoleBySorRoleId(sorRole.getSorId());
// let sor role elector decide if this new role can be converted to calculated one
sorRoleElector.addSorRole(newSorRole, person);
person = recalculatePersonBiodemInfo(person, newSorPerson, RecalculationType.UPDATE, false);
this.personRepository.savePerson(person);
logger.info("validateAndSaveRoleForSorPerson end");
return new GeneralServiceExecutionResult<SorRole>(newSorRole);
}
/**
* This does not explicitly delete the names because its assumed the recalculation will clean it
* up.
*/
public boolean deleteSystemOfRecordPerson(
final SorPerson sorPerson, final boolean mistake, final String terminationTypes) {
Assert.notNull(sorPerson, "sorPerson cannot be null.");
final String terminationTypeToUse =
terminationTypes != null ? terminationTypes : Type.TerminationTypes.UNSPECIFIED.name();
final Person person = this.personRepository.findByInternalId(sorPerson.getPersonId());
Assert.notNull(person, "person cannot be null.");
if (mistake) {
Set<Role> rolesToDelete = new HashSet<Role>();
for (final SorRole sorRole : sorPerson.getRoles()) {
for (final Role role : person.getRoles()) {
if (sorRole.getId().equals(role.getSorRoleId())) {
rolesToDelete.add(role);
}
}
}
for (final Role role : rolesToDelete) {
// let sorRoleElector delete the role and add another role if required
sorRoleElector.removeCalculatedRole(
person, role, this.personRepository.getSoRRecordsForPerson(person));
}
final Number number = this.personRepository.getCountOfSoRRecordsForPerson(person);
if (number.intValue() == 1) {
this.personRepository.deletePerson(person);
}
this.personRepository.deleteSorPerson(sorPerson);
return true;
}
// we do this explicitly here because once they're gone we can't re-calculate? We might move to
// this to the recalculateCalculatedPerson method.
final Type terminationReason =
this.referenceRepository.findType(Type.DataTypes.TERMINATION, terminationTypeToUse);
for (final SorRole sorRole : sorPerson.getRoles()) {
for (final Role role : person.getRoles()) {
if (!role.isTerminated() && sorRole.getId().equals(role.getSorRoleId())) {
role.expireNow(terminationReason, true);
}
}
}
this.personRepository.deleteSorPerson(sorPerson);
this.personRepository.savePerson(person);
Person p = recalculatePersonBiodemInfo(person, sorPerson, RecalculationType.DELETE, mistake);
this.personRepository.savePerson(p);
return true;
}
public boolean deleteSystemOfRecordPerson(
final String sorSource,
final String sorId,
final boolean mistake,
final String terminationTypes) {
Assert.notNull(sorSource, "sorSource cannot be null.");
Assert.notNull(sorId, "sorId cannot be null.");
final SorPerson sorPerson =
this.personRepository.findBySorIdentifierAndSource(sorSource, sorId);
return sorPerson != null && deleteSystemOfRecordPerson(sorPerson, mistake, terminationTypes);
}
public ServiceExecutionResult<ReconciliationResult> reconcile(
final ReconciliationCriteria reconciliationCriteria) throws IllegalArgumentException {
Assert.notNull(reconciliationCriteria, "reconciliationCriteria cannot be null");
logger.info("reconcile start");
final Set validationErrors = this.validator.validate(reconciliationCriteria);
if (!validationErrors.isEmpty()) {
Iterator iter = validationErrors.iterator();
while (iter.hasNext()) {
logger.info("validation errors: " + iter.next());
}
logger.info("reconcile start");
// since because of existing design we cannot raise exception, we can only rollback the
// transaction through code
// OR-384
if (TransactionAspectSupport.currentTransactionStatus() != null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
return new GeneralServiceExecutionResult<ReconciliationResult>(validationErrors);
}
final ReconciliationResult result = this.reconciler.reconcile(reconciliationCriteria);
// (reconciliationCriteria, result);
return new GeneralServiceExecutionResult<ReconciliationResult>(result);
}
/**
* @param name The name of the parameter. Not empty.
* @param value The string value of the parameter. Not null.
* @return The newly created subdialogue parameter
*/
public static Parameter createWithValue(String name, String value) {
Assert.notNull(value, "value");
Parameter parameter = new Parameter(name);
parameter.mValue = value;
return parameter;
}
/**
* @param name The name of the parameter. Not empty.
* @param expression The ECMAScript expression of the parameter. Not null.
* @return The newly created subdialogue parameter
*/
public static Parameter createWithExpression(String name, String expression) {
Assert.notNull(expression, "expression");
Parameter parameter = new Parameter(name);
parameter.mExpression = expression;
return parameter;
}
protected FS createFileSystem(String[] pathPatterns, String[] filterPatterns) {
Assert.notNull(pathPatterns, "PathPatterns must not be null");
Assert.notNull(filterPatterns, "FilterPatterns must not be null");
FS fileSystem = new FS();
for (String pathPattern : pathPatterns) {
try {
fileSystem.mount(
new SimpleFileSystemDriver(
new DirectoryHandle(pathPattern, this.resourceLoader, filterPatterns)));
} catch (IOException ex) {
throw new IllegalStateException(
"Failed to mount file system for '" + pathPattern + "'", ex);
}
}
return fileSystem;
}
/**
* Persists an SorPerson on update.
*
* @param sorPerson the person to update.
* @return serviceExecutionResult.
*/
public ServiceExecutionResult<SorPerson> updateSorPerson(final SorPerson sorPerson) {
final Set validationErrors = this.validator.validate(sorPerson);
if (!validationErrors.isEmpty()) {
Iterator iter = validationErrors.iterator();
while (iter.hasNext()) {
logger.info("validation errors: " + iter.next());
}
// since because of existing design we cannot raise exception, we can only rollback the
// transaction through code
// OR-384
if (TransactionAspectSupport.currentTransactionStatus() != null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
return new GeneralServiceExecutionResult<SorPerson>(validationErrors);
}
// do reconciliationCheck to make sure that modifications do not cause person to reconcile to a
// different person
if (!this.reconciler.reconcilesToSamePerson(sorPerson)) {
throw new IllegalStateException();
}
// Iterate over any sorRoles setting sorid and source id if not specified by SoR.
for (final SorRole sorRole : sorPerson.getRoles()) {
setRoleIdAndSource(sorRole, sorPerson.getSourceSor());
}
// Save Sor Person
final SorPerson savedSorPerson = this.personRepository.saveSorPerson(sorPerson);
Person person = this.findPersonById(savedSorPerson.getPersonId());
Assert.notNull(person, "person cannot be null.");
logger.info(
"Verifying Number of calculated Roles before the calculate: " + person.getRoles().size());
// Iterate over sorRoles. SorRoles may be new or updated.
for (final SorRole savedSorRole : savedSorPerson.getRoles()) {
logger.info(
"DefaultPersonService: savedSorPersonRole Found, savedSorRoleID: "
+ savedSorRole.getId());
logger.info("DefaultPersonService: savedSorPersonRole Found, Role Must be newly added.");
// let sor role elector decide if this new role can be converted to calculated one
sorRoleElector.addSorRole(savedSorRole, person);
logger.info(
"Verifying Number of calculated Roles after calculate: " + person.getRoles().size());
}
for (final IdentifierAssigner ia : this.identifierAssigners) {
ia.addIdentifierTo(sorPerson, person);
}
person = recalculatePersonBiodemInfo(person, savedSorPerson, RecalculationType.UPDATE, false);
person = this.personRepository.savePerson(person);
return new GeneralServiceExecutionResult<SorPerson>(savedSorPerson);
}
public static void save(Properties properties, File file) throws IOException {
Assert.notNull(properties, "存储的属性为空！");
OutputStream outputStream = new FileOutputStream(file);
properties.store(outputStream, "saved on " + DateHelper.getStringDate());
outputStream.flush();
outputStream.close();
}
/**
* Creates a new {@code PropertyPlaceholderHelper} that uses the supplied prefix and suffix.
*
* @param placeholderPrefix the prefix that denotes the start of a placeholder
* @param placeholderSuffix the suffix that denotes the end of a placeholder
* @param valueSeparator the separating character between the placeholder variable and the
* associated default value, if any
* @param ignoreUnresolvablePlaceholders indicates whether unresolvable placeholders should be
* ignored ({@code true}) or cause an exception ({@code false}).
*/
public PropertyPlaceholderHelper(
String placeholderPrefix,
String placeholderSuffix,
String valueSeparator,
boolean ignoreUnresolvablePlaceholders) {
Assert.notNull(placeholderPrefix, "placeholderPrefix must not be null");
Assert.notNull(placeholderSuffix, "placeholderSuffix must not be null");
this.placeholderPrefix = placeholderPrefix;
this.placeholderSuffix = placeholderSuffix;
String simplePrefixForSuffix = wellKnownSimplePrefixes.get(this.placeholderSuffix);
if (simplePrefixForSuffix != null && this.placeholderPrefix.endsWith(simplePrefixForSuffix)) {
this.simplePrefix = simplePrefixForSuffix;
} else {
this.simplePrefix = this.placeholderPrefix;
}
this.valueSeparator = valueSeparator;
this.ignoreUnresolvablePlaceholders = ignoreUnresolvablePlaceholders;
}
/**
* Replaces all placeholders of format {@code ${name}} with the corresponding property from the
* supplied {@link java.util.Properties}.
*
* @param value the value containing the placeholders to be replaced.
* @param properties the {@code Properties} to use for replacement.
* @return the supplied value with placeholders replaced inline.
*/
public String replacePlaceholders(String value, final Properties properties) {
Assert.notNull(properties, "Argument 'properties' must not be null.");
return replacePlaceholders(
value,
new PlaceholderResolver() {
@Override
public String resolvePlaceholder(String placeholderName) {
return properties.getProperty(placeholderName);
}
});
}
public static void save(Map<String, String> map, File file) throws IOException {
Assert.notNull(map, "属性集合为空！");
Properties properties = new Properties();
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
String key = entry.getKey();
String value = entry.getValue();
properties.setProperty(key, value);
}
save(properties, file);
}
public ServiceExecutionResult<Person> addPersonAndLink(
final ReconciliationCriteria reconciliationCriteria, final Person person)
throws IllegalArgumentException, IllegalStateException, SorPersonAlreadyExistsException {
Assert.notNull(reconciliationCriteria, "reconciliationCriteria cannot be null.");
Assert.notNull(person, "person cannot be null.");
logger.info(" addPersonAndLink start");
final ReconciliationResult result = this.criteriaCache.get(reconciliationCriteria);
if (result == null) {
throw new IllegalStateException("No ReconciliationResult found for provided criteria.");
}
for (final PersonMatch personMatch : result.getMatches()) {
if (personMatch.getPerson().getId().equals(person.getId())) {
addSorPersonAndLink(reconciliationCriteria, person);
final Person savedPerson = this.personRepository.findByInternalId(person.getId());
return new GeneralServiceExecutionResult<Person>(savedPerson);
}
}
logger.info("addPersonAndLink end");
throw new IllegalStateException("Person not found in ReconciliationResult.");
}
public ServiceExecutionResult<Person> addPerson(
final ReconciliationCriteria reconciliationCriteria)
throws ReconciliationException, IllegalArgumentException, SorPersonAlreadyExistsException {
Assert.notNull(reconciliationCriteria, "reconciliationCriteria cannot be null");
logger.info("addPerson start");
if (reconciliationCriteria.getSorPerson().getSorId() != null
&& this.findBySorIdentifierAndSource(
reconciliationCriteria.getSorPerson().getSourceSor(),
reconciliationCriteria.getSorPerson().getSorId())
!= null) {
// throw new IllegalStateException("CANNOT ADD SAME SOR RECORD.");
throw new SorPersonAlreadyExistsException(
this.findBySorIdentifierAndSource(
reconciliationCriteria.getSorPerson().getSourceSor(),
reconciliationCriteria.getSorPerson().getSorId()));
}
final Set validationErrors = this.validator.validate(reconciliationCriteria);
if (!validationErrors.isEmpty()) {
Iterator iter = validationErrors.iterator();
while (iter.hasNext()) {
logger.info("validation errors: " + iter.next());
}
// since because of existing design we cannot raise exception, we can only rollback the
// transaction through code
// OR-384
if (TransactionAspectSupport.currentTransactionStatus() != null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
return new GeneralServiceExecutionResult<Person>(validationErrors);
}
final ReconciliationResult result = this.reconciler.reconcile(reconciliationCriteria);
switch (result.getReconciliationType()) {
case NONE:
return new GeneralServiceExecutionResult<Person>(
saveSorPersonAndConvertToCalculatedPerson(reconciliationCriteria));
case EXACT:
return new GeneralServiceExecutionResult<Person>(
addNewSorPersonAndLinkWithMatchedCalculatedPerson(reconciliationCriteria, result));
}
this.criteriaCache.put(reconciliationCriteria, result);
logger.info("addPerson start");
throw new ReconciliationException(result);
}
public boolean deleteSystemOfRecordRole(
final SorPerson sorPerson,
final SorRole sorRole,
final boolean mistake,
final String terminationTypes)
throws IllegalArgumentException {
Assert.notNull(sorRole, "sorRole cannot be null.");
Assert.notNull(sorPerson, "soPerson cannot be null.");
final String terminationTypeToUse =
terminationTypes != null ? terminationTypes : Type.TerminationTypes.UNSPECIFIED.name();
final Person person = this.personRepository.findByInternalId(sorPerson.getPersonId());
Assert.notNull(person, "person cannot be null.");
final Role role = person.findRoleBySoRRoleId(sorRole.getId());
// delete and expire role only if it exist at calculated level
if (role != null)
if (mistake) {
// let SorRoleElector remove the role
sorRoleElector.removeCalculatedRole(
person, role, this.personRepository.getSoRRecordsForPerson(person));
} else {
final Type terminationReason =
this.referenceRepository.findType(Type.DataTypes.TERMINATION, terminationTypeToUse);
if (!role.isTerminated()) {
role.expireNow(terminationReason, true);
}
}
sorPerson.getRoles().remove(sorRole);
this.personRepository.saveSorPerson(sorPerson);
this.personRepository.savePerson(person);
return true;
}
/**
* Instantiates the specified class.
*
* @param name the name of the class to instantiate
* @return the Class instance
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public static <T> Class<T> forName(String name) {
Assert.notNull(name, "class name");
Class type = simpleTypeMap.get(name);
if (type != null) return type;
else {
try {
return (Class<T>) getContextClassLoader().loadClass(name);
} catch (ClassNotFoundException e) {
throw ExceptionMapper.configurationException(e, name);
} catch (NullPointerException e) {
// this is raised by the Eclipse BundleLoader if it does not find the class
throw ExceptionMapper.configurationException(e, name);
}
}
}
public ServiceExecutionResult<Person> forceAddPerson(
final ReconciliationCriteria reconciliationCriteria)
throws IllegalArgumentException, IllegalStateException {
Assert.notNull(reconciliationCriteria, "reconciliationCriteria cannot be null.");
logger.info("forceAddPerson start");
final ReconciliationResult result = this.criteriaCache.get(reconciliationCriteria);
if (result == null) {
throw new IllegalStateException("No ReconciliationResult found for provided criteria.");
}
this.criteriaCache.remove(reconciliationCriteria);
logger.info("forceAddPerson end");
return new GeneralServiceExecutionResult<Person>(
saveSorPersonAndConvertToCalculatedPerson(reconciliationCriteria));
}
protected boolean isEnabled(CRaSHPlugin<?> plugin) {
Assert.notNull(plugin, "Plugin must not be null");
if (ObjectUtils.isEmpty(this.disabledPlugins)) {
return true;
}
Set<Class<?>> pluginClasses = ClassUtils.getAllInterfacesAsSet(plugin);
pluginClasses.add(plugin.getClass());
for (Class<?> pluginClass : pluginClasses) {
if (isEnabled(pluginClass)) {
return true;
}
}
return false;
}
/**
* Generates views based on annotations found in a persistent class. Typically @DocumentReferences
* annotations.
*
* @param persistentType
* @return a Map with generated views.
*/
public Map<String, DesignDocument.View> generateViewsFromPersistentType(
final Class<?> persistentType) {
Assert.notNull(persistentType, "persistentType may not be null");
final Map<String, DesignDocument.View> views = new HashMap<String, DesignDocument.View>();
createDeclaredViews(views, persistentType);
eachField(
persistentType,
new Predicate<Field>() {
public boolean apply(Field input) {
if (hasAnnotation(input, DocumentReferences.class)) {
generateView(views, input);
}
return false;
}
});
return views;
}
public void addComment(Comment c) {
Assert.notNull(c, "Comment may not be null");
Assert.hasText(c.getBlogPostId(), "Comment must have a blog post id");
db.create(c);
}
public RevisionResponseHandler(ObjectMapper om) {
Assert.notNull(om, "ObjectMapper cannot be null");
objectMapper = om;
}
/**
* Bring your own ObjectMapper. The mapper is used when serializing keys when building the query.
*
* @param om
*/
public ViewQuery(ObjectMapper om) {
Assert.notNull(om, "ObjectMapper may not be null");
mapper = om;
}
public Builder setMethod(SubmitMethod method) {
Assert.notNull(method, "method");
mMethod = method;
return this;
}
public Builder addVoiceXmlParameter(Parameter parameter) {
Assert.notNull(parameter, "parameter");
mParameters.add(parameter);
return this;
}
@Override
public List<SorPerson> getSorPersonsFor(final Person person) {
Assert.notNull(person);
return this.personRepository.getSoRRecordsForPerson(person);
}
/**
* @param name The name of the parameter. Not empty.
* @param json The JSON value of the parameter. Not null.
* @return The newly created subdialogue parameter
*/
public static Parameter createWithJson(String name, JsonValue json) {
Assert.notNull(json, "json");
return createWithExpression(name, json.toString());
}
public void matchCircularReferencesUsing(
final CircularReferenceMatchingMode circularReferenceMatchingMode) {
Assert.notNull(circularReferenceMatchingMode, "circularReferenceMatchingMode");
this.circularReferenceMatchingMode = circularReferenceMatchingMode;
}
/** @param submitParameters A list of variable to submit when invoking the URI. Not null. */
public final void setSubmitParameters(VariableList submitParameters) {
Assert.notNull(submitParameters, "submitParameters");
mSubmitParameters = submitParameters;
}