protected static boolean checkIdle(final Point p) throws NimbitsException {
final Calendar c = Calendar.getInstance();
c.add(Calendar.SECOND, p.getIdleSeconds() * -1);
boolean retVal = false;
final List<Entity> result =
EntityServiceFactory.getInstance()
.getEntityByKey(
UserServiceFactory.getServerInstance().getAdmin(), p.getOwner(), EntityType.user);
if (!result.isEmpty()) {
final User u = (User) result.get(0);
final List<Value> v = ValueServiceFactory.getInstance().getCurrentValue(p);
if (p.getIdleSeconds() > 0
&& !v.isEmpty()
&& v.get(0).getTimestamp().getTime() <= c.getTimeInMillis()
&& !p.getIdleAlarmSent()) {
p.setIdleAlarmSent(true);
EntityServiceFactory.getInstance().addUpdateEntity(u, p);
// PointServiceFactory.getInstance().updatePoint(u, p);
final Value va = ValueFactory.createValueModel(v.get(0), AlertType.IdleAlert);
SubscriptionServiceFactory.getInstance().processSubscriptions(u, p, va);
retVal = true;
}
}
return retVal;
}
static List populatedArray(int n) {
List a = ParallelArray.createEmpty(n, Object.class, ParallelArray.defaultExecutor()).asList();
assertTrue(a.isEmpty());
for (int i = 0; i < n; ++i) a.add(new Integer(i));
assertFalse(a.isEmpty());
assertEquals(n, a.size());
return a;
}
@Nullable
public static PyType getType(@NotNull PsiElement resolved, @NotNull List<PyType> elementTypes) {
final String qualifiedName = getQualifiedName(resolved);
final List<Integer> paramListTypePositions = new ArrayList<>();
final List<Integer> ellipsisTypePositions = new ArrayList<>();
for (int i = 0; i < elementTypes.size(); i++) {
final PyType type = elementTypes.get(i);
if (type instanceof PyTypeParser.ParameterListType) {
paramListTypePositions.add(i);
} else if (type instanceof PyTypeParser.EllipsisType) {
ellipsisTypePositions.add(i);
}
}
if (!paramListTypePositions.isEmpty()) {
if (!("typing.Callable".equals(qualifiedName) && paramListTypePositions.equals(list(0)))) {
return null;
}
}
if (!ellipsisTypePositions.isEmpty()) {
if (!("typing.Callable".equals(qualifiedName) && ellipsisTypePositions.equals(list(0))
|| "typing.Tuple".equals(qualifiedName)
&& ellipsisTypePositions.equals(list(1))
&& elementTypes.size() == 2)) {
return null;
}
}
if ("typing.Union".equals(qualifiedName)) {
return PyUnionType.union(elementTypes);
}
if ("typing.Optional".equals(qualifiedName) && elementTypes.size() == 1) {
return PyUnionType.union(elementTypes.get(0), PyNoneType.INSTANCE);
}
if ("typing.Callable".equals(qualifiedName) && elementTypes.size() == 2) {
final PyTypeParser.ParameterListType paramList =
as(elementTypes.get(0), PyTypeParser.ParameterListType.class);
if (paramList != null) {
return new PyCallableTypeImpl(paramList.getCallableParameters(), elementTypes.get(1));
}
if (elementTypes.get(0) instanceof PyTypeParser.EllipsisType) {
return new PyCallableTypeImpl(null, elementTypes.get(1));
}
}
if ("typing.Tuple".equals(qualifiedName)) {
if (elementTypes.size() > 1 && elementTypes.get(1) instanceof PyTypeParser.EllipsisType) {
return PyTupleType.createHomogeneous(resolved, elementTypes.get(0));
}
return PyTupleType.create(resolved, elementTypes);
}
final PyType builtinCollection = getBuiltinCollection(resolved);
if (builtinCollection instanceof PyClassType) {
final PyClassType classType = (PyClassType) builtinCollection;
return new PyCollectionTypeImpl(classType.getPyClass(), false, elementTypes);
}
return null;
}
private SNode searchInSuperTypes(SNode subType, CoercionMatcher superType, boolean isWeak) {
StructuralNodeSet<?> frontier = new StructuralNodeSet();
StructuralNodeSet<?> newFrontier = new StructuralNodeSet();
StructuralNodeSet<?> yetPassed = new StructuralNodeSet();
frontier.add(subType);
while (!frontier.isEmpty()) {
Set<SNode> yetPassedRaw = new THashSet<SNode>();
// collecting a set of frontier's ancestors
StructuralNodeSet<?> ancestors = new StructuralNodeSet();
for (SNode node : frontier) {
mySubTyping.collectImmediateSuperTypes(node, isWeak, ancestors, null);
yetPassedRaw.add(node);
}
ArrayList<SNode> ancestorsSorted;
ancestorsSorted = new ArrayList<SNode>(ancestors);
Collections.sort(
ancestorsSorted,
new Comparator<SNode>() {
@Override
public int compare(SNode o1, SNode o2) {
return TypesUtil.depth(o2) - TypesUtil.depth(o1);
}
});
List<SNode> results = new ArrayList<SNode>();
for (SNode ancestor : ancestorsSorted) {
if (superType.matchesWith(ancestor)) {
results.add(ancestor);
}
}
if (!results.isEmpty()) {
if (results.size() > 1) {
results = SubtypingUtil.eliminateSuperTypes(results);
}
if (!results.isEmpty()) {
return results.get(0);
}
}
for (SNode passedNodeRaw : yetPassedRaw) {
yetPassed.add(passedNodeRaw);
}
for (SNode passedNode : yetPassed) {
ancestors.removeStructurally(passedNode);
}
for (SNode ancestor : ancestors) {
Pair<Boolean, SNode> answer =
getCoerceCacheAnswer(ancestor, superType.getMatchingPattern(), isWeak);
if (answer != null) {
if (answer.o1 && answer.o2 == null) {
// System.out.println("coerce optimized");
continue;
}
}
newFrontier.addStructurally(ancestor);
yetPassed.addStructurally(ancestor);
}
frontier = newFrontier;
newFrontier = new StructuralNodeSet();
}
return null;
}
/**
* @param table_list lista de tabelas
* @param visited_tables lista de tabelas visitadas
* @param final_table tabela final/pretendida
*/
public static Node iterativeDepthFirstSearch(
int[][] initial_table, int[][] final_table, int max_depth) {
List table_list = new List();
table_list.addFirst(initial_table, 0, "");
List visited_tables = new List();
int[][] current_table = new int[3][3];
int depth = 0;
String path = new String();
while (!table_list.isEmpty()) {
List child_nodes = new List();
path = table_list.getPath();
depth = table_list.getDepth();
current_table = table_list.remove();
if (isSolution(current_table, final_table)) return new Node(current_table, depth, path, null);
visited_tables.addFirst(current_table, depth, path);
if (depth < max_depth) {
child_nodes = playDFS(child_nodes, current_table, depth, path);
// verifica se algum dos filhos já foi visitado
while (!child_nodes.isEmpty()) {
int d = child_nodes.getDepth();
String s = child_nodes.getPath();
int[][] child_table = child_nodes.remove();
if (!visited_tables.contains(child_table)) table_list.addFirst(child_table, d, s);
}
}
}
return iterativeDepthFirstSearch(initial_table, final_table, max_depth + 1);
}
@Override
public void run(ContinuationContext context) {
final List<Change> changesForPatch;
try {
final List<CommittedChangeList> lst = loadSvnChangeListsForPatch(myDescription);
changesForPatch = CommittedChangesTreeBrowser.collectChanges(lst, true);
for (Change change : changesForPatch) {
if (change.getBeforeRevision() != null) {
preloadRevisionContents(change.getBeforeRevision());
}
if (change.getAfterRevision() != null) {
preloadRevisionContents(change.getAfterRevision());
}
}
} catch (VcsException e) {
context.handleException(e, true);
return;
}
final List<Change> binaryChanges = filterOutBinary(changesForPatch);
if (binaryChanges != null && !binaryChanges.isEmpty()) {
myTheirsBinaryChanges.addAll(binaryChanges);
}
if (!changesForPatch.isEmpty()) {
myTheirsChanges.addAll(changesForPatch);
}
}
private void purgeQueue() {
final ReferenceContext refContext = queue.getFirst().ref;
// divide them up by source
while (!queue.isEmpty()) {
VCcontext context = queue.removeFirst();
for (final VariantContext vc : context.vcs) {
if (vc.getSource().equals(source1)) sourceVCs1.add(vc);
else sourceVCs2.add(vc);
}
}
writeAndPurgeAllEqualVariants(sourceVCs1, sourceVCs2, SAME_STATUS);
if (sourceVCs1.isEmpty()) {
writeAll(sourceVCs2, source2, null);
} else if (sourceVCs2.isEmpty()) {
writeAll(sourceVCs1, source1, null);
} else {
resolveByHaplotype(refContext);
}
// allow for GC of the data
sourceVCs1.clear();
sourceVCs2.clear();
}
/**
* Set list shown or progress bar show
*
* @param shown
* @param animate
* @return this fragment
*/
public ItemListFragment<E> setListShown(final boolean shown, final boolean animate) {
if (!isUsable()) {
return this;
}
if (shown == listShown) {
if (shown) {
// List has already been shown so hide/show the empty view with
// no fade effect
if (items.isEmpty()) {
hide(listView).show(emptyView);
} else {
hide(emptyView).show(listView);
}
}
return this;
}
listShown = shown;
if (shown) {
if (!items.isEmpty()) {
hide(progressBar).hide(emptyView).fadeIn(listView, animate)
.show(listView);
} else {
hide(progressBar).hide(listView).fadeIn(emptyView, animate)
.show(emptyView);
}
} else {
hide(listView).hide(emptyView).fadeIn(progressBar, animate)
.show(progressBar);
}
return this;
}
public Map<String, CodeRecord> get(String codeTableId) {
logger.info("加载代码表#" + codeTableId + "的数据...");
TSysCodeTable codeDic = JpaTool.get(TSysCodeTable.class, codeTableId);
List<CodeRecord> codes = null;
if (codeDic == null) {
List<TSysCodeTable> groupingCodeTables = sysCodeTableDao.getGroupingCodeTables();
for (TSysCodeTable codeTable : groupingCodeTables) {
codes = searchCodes(codeTableId, codeTable);
if (codes.isEmpty() == false) {
break;
}
}
// 存在排序值为空默认按编码升序排序
if (codes != null && codes.isEmpty() == false) {
Map<String, Object> propMap = new HashMap<String, Object>(2);
propMap.put("order", null);
propMap.put("order", "");
List<CodeRecord> list = CollectionQueryTool.orQuery(codes, propMap);
if (list.isEmpty() == false) {
codes = CollectionQueryTool.order(codes, Order.asc("code"));
}
}
} else {
codes = searchCodes(codeTableId, codeDic);
}
Map<String, CodeRecord> map = new LinkedCaseInsensitiveMap<CodeRecord>(codes.size());
for (CodeRecord codeRecord : codes) {
map.put(codeRecord.getCode(), codeRecord);
}
if (map.isEmpty()) {
logger.warn("代码表#" + codeTableId + "不存在或数据为空！");
}
return map;
}
/** Writes data pending message into a specific socket defined by the key */
private void write(SelectionKey key) throws IOException {
SocketChannel socketChannel = (SocketChannel) key.channel();
synchronized (pendingWriteData) {
List<ByteBuffer> queue = pendingWriteData.get(socketChannel);
if (queue == null) {
queue = new ArrayList<>();
pendingWriteData.put(socketChannel, queue);
}
// Write until there's no more data ...
while (!queue.isEmpty()) {
ByteBuffer buf = queue.get(0);
socketChannel.write(buf);
if (buf.remaining() > 0) {
logger.finest("Write Buffer Full!");
break;
}
queue.remove(0);
}
if (queue.isEmpty()) {
// All data written, change selector interest
logger.finest("No more Data to write!");
key.interestOps(SelectionKey.OP_READ);
}
}
}
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
assertSAX(!myParseStack.isEmpty());
ElementHandlerBase current = myParseStack.get(myParseStack.size() - 1);
if (mySb.length() > 0) {
current.characters(mySb.toString().trim(), myPending, myLockBuilder);
mySb.setLength(0);
}
while (true) {
final boolean createNewChild = current.startElement(uri, localName, qName, attributes);
if (createNewChild) {
assertSAX(myElementsMap.containsKey(qName));
final ElementHandlerBase newChild = myElementsMap.get(qName).get();
newChild.preAttributesEffect(myDataCallback);
newChild.updateStatus(attributes, myPending, myLockBuilder);
newChild.preEffect(myDataCallback);
myParseStack.add(newChild);
return;
} else {
// go up
current.postEffect(myDataCallback);
myParseStack.remove(myParseStack.size() - 1);
assertSAX(!myParseStack.isEmpty());
current = myParseStack.get(myParseStack.size() - 1);
}
}
}
/**
* Adds the {@code tags} to the {@code books}.
*
* @param realm Instance of Realm to use.
* @param books List of {@link RBook}s to add tags to.
* @param tags List {@link RTag}s.
*/
public static void addTagsToBooks(Realm realm, List<RBook> books, List<RTag> tags) {
if (books == null || tags == null) throw new IllegalArgumentException("No nulls allowed.");
if (books.isEmpty() || tags.isEmpty()) return;
// Get names of new/updated book tags.
String newBookTagName = Minerva.prefs().getNewBookTag(null);
String updatedBookTagName = Minerva.prefs().getUpdatedBookTag(null);
// Sometimes this method is called when we're already in a transaction. We can't nest them.
boolean isInXactAlready = realm.isInTransaction();
if (!isInXactAlready) realm.beginTransaction();
// Loop through books and add tags to them.
for (int i = books.size() - 1; i >= 0; i--) {
RBook book = books.get(i);
for (RTag tag : tags) {
// If the book doesn't already have the tag,
if (!book.tags.contains(tag)) {
// add the tag to the book,
book.tags.add(tag);
// and add the book to the tag.
tag.taggedBooks.add(book);
}
// Make sure that we set new/updated state to true if those tags were added (and it wasn't
// already).
if (newBookTagName != null && newBookTagName.equals(tag.name) && !book.isNew)
book.isNew = true;
if (updatedBookTagName != null && updatedBookTagName.equals(tag.name) && !book.isUpdated)
book.isUpdated = true;
}
}
// Again, if there's an outer transaction already ongoing, don't finish it here.
if (!isInXactAlready) realm.commitTransaction();
}
public void run() {
if (myBook != null) {
for (BookmarkQuery query = new BookmarkQuery(myBook, 20); ; query = query.next()) {
final List<Bookmark> thisBookBookmarks = myCollection.bookmarks(query);
if (thisBookBookmarks.isEmpty()) {
break;
}
myThisBookAdapter.addAll(thisBookBookmarks);
myAllBooksAdapter.addAll(thisBookBookmarks);
}
}
for (BookmarkQuery query = new BookmarkQuery(20); ; query = query.next()) {
final List<Bookmark> allBookmarks = myCollection.bookmarks(query);
if (allBookmarks.isEmpty()) {
break;
}
myAllBooksAdapter.addAll(allBookmarks);
}
runOnUiThread(
new Runnable() {
public void run() {
setProgressBarIndeterminateVisibility(false);
}
});
}
static void logPlugins() {
List<String> loadedBundled = new ArrayList<String>();
List<String> disabled = new ArrayList<String>();
List<String> loadedCustom = new ArrayList<String>();
for (IdeaPluginDescriptor descriptor : ourPlugins) {
final String version = descriptor.getVersion();
String s = descriptor.getName() + (version != null ? " (" + version + ")" : "");
if (descriptor.isEnabled()) {
if (descriptor.isBundled() || SPECIAL_IDEA_PLUGIN.equals(descriptor.getName()))
loadedBundled.add(s);
else loadedCustom.add(s);
} else {
disabled.add(s);
}
}
Collections.sort(loadedBundled);
Collections.sort(loadedCustom);
Collections.sort(disabled);
getLogger().info("Loaded bundled plugins: " + StringUtil.join(loadedBundled, ", "));
if (!loadedCustom.isEmpty()) {
getLogger().info("Loaded custom plugins: " + StringUtil.join(loadedCustom, ", "));
}
if (!disabled.isEmpty()) {
getLogger().info("Disabled plugins: " + StringUtil.join(disabled, ", "));
}
}
protected boolean updateSubAwardBudgetDetails(Budget budget, BudgetSubAwards subAward)
throws Exception {
List<String[]> errorMessages = new ArrayList<String[]>();
boolean success =
getKcBusinessRulesEngine().applyRules(new BudgetSubAwardsEvent(subAward, budget, ""));
if (subAward.getNewSubAwardFile().getBytes().length == 0) {
success = false;
}
if (success) {
getPropDevBudgetSubAwardService()
.updateSubAwardBudgetDetails(budget, subAward, errorMessages);
}
if (!errorMessages.isEmpty()) {
for (String[] message : errorMessages) {
String[] messageParameters = null;
if (message.length > 1) {
messageParameters = Arrays.copyOfRange(message, 1, message.length);
}
if (success) {
GlobalVariables.getMessageMap()
.putWarning(Constants.SUBAWARD_FILE_FIELD_NAME, message[0], messageParameters);
} else {
GlobalVariables.getMessageMap()
.putError(Constants.SUBAWARD_FILE_FIELD_NAME, message[0], messageParameters);
}
}
}
if (success && errorMessages.isEmpty()) {
GlobalVariables.getMessageMap()
.putInfo(Constants.SUBAWARD_FILE_FIELD_NAME, Constants.SUBAWARD_FILE_DETAILS_UPDATED);
}
return success;
}
/**
* Removes the {@code tags} from the {@code books}.
*
* @param realm Instance of Realm to use.
* @param books List of {@link RBook}s to remove tags from.
* @param tags List {@link RTag}s.
*/
public static void removeTagsFromBooks(Realm realm, List<RBook> books, List<RTag> tags) {
if (books == null || tags == null) throw new IllegalArgumentException("No nulls allowed.");
if (books.isEmpty() || tags.isEmpty()) return;
// Get names of new/updated book tags.
String newBookTagName = Minerva.prefs().getNewBookTag(null);
String updatedBookTagName = Minerva.prefs().getUpdatedBookTag(null);
realm.beginTransaction();
// Loop through books and remove tags from them.
for (int i = books.size() - 1; i >= 0; i--) {
RBook book = books.get(i);
for (RTag tag : tags) {
// If the book has the tag, remove it,
if (book.tags.remove(tag)) {
// and remove the book from the tag.
tag.taggedBooks.remove(book);
}
// Make sure that we new/updated state if we had those tags removed.
if (newBookTagName != null && newBookTagName.equals(tag.name)) book.isNew = false;
if (updatedBookTagName != null && updatedBookTagName.equals(tag.name))
book.isUpdated = false;
}
}
realm.commitTransaction();
}
@Nullable
private PyType resolveQualifierType(
@NotNull List<Token<PyElementType>> tokens,
@NotNull PyFile file,
@NotNull TypeEvalContext context,
@NotNull Map<TextRange, PyType> types,
@NotNull Map<PyType, TextRange> fullRanges,
@NotNull Map<PyType, PyImportElement> imports) {
if (tokens.isEmpty()) {
return null;
}
final Token<PyElementType> firstToken = tokens.get(0);
final String firstText = firstToken.getText().toString();
final TextRange firstRange = firstToken.getRange();
final List<RatedResolveResult> resolveResults = file.multiResolveName(firstText);
if (resolveResults.isEmpty()) {
return getImplicitlyResolvedType(tokens, context, types, fullRanges, firstRange);
}
final List<PyType> members = Lists.newArrayList();
for (RatedResolveResult result : resolveResults) {
final PsiElement resolved = result.getElement();
PyType type = null;
if (resolved instanceof PyTargetExpression) {
type =
PyTypingTypeProvider.getTypeFromTargetExpression(
(PyTargetExpression) resolved, context);
}
if (type == null && resolved instanceof PyTypedElement) {
type = context.getType((PyTypedElement) resolved);
}
if (type != null) {
if (!allowResolveToType(type)) {
continue;
}
if (type instanceof PyClassLikeType) {
type = ((PyClassLikeType) type).toInstance();
}
types.put(firstRange, type);
fullRanges.put(type, firstRange);
for (PyFromImportStatement fromImportStatement : file.getFromImports()) {
for (PyImportElement importElement : fromImportStatement.getImportElements()) {
if (firstText.equals(importElement.getVisibleName())) {
imports.put(type, importElement);
}
}
}
for (PyImportElement importElement : file.getImportTargets()) {
if (firstText.equals(importElement.getVisibleName())) {
imports.put(type, importElement);
}
}
}
members.add(type);
}
if (!members.isEmpty()) {
tokens.remove(0);
}
return PyUnionType.union(members);
}
/**
* identify additional groups that are not directly attached to amino acids.
*
* @param mc {@link ModifiedCompound}.
* @param chain a {@link Chain}.
* @return a list of added groups.
*/
private void identifyAdditionalAttachments(
ModifiedCompound mc, List<Group> ligands, Map<String, Chain> mapChainIdChain) {
if (ligands.isEmpty()) {
return;
}
// TODO: should the additional groups only be allowed to the identified
// ligands or both amino acids and ligands? Currently only on ligands
// ligands to amino acid bonds for same modification of unknown category
// will be combined in mergeModComps()
// TODO: how about chain-chain links?
List<Group> identifiedGroups = new ArrayList<Group>();
for (StructureGroup num : mc.getGroups(false)) {
Group group;
try {
// String numIns = "" + num.getResidueNumber();
// if (num.getInsCode() != null) {
// numIns += num.getInsCode();
// }
ResidueNumber resNum = new ResidueNumber();
resNum.setChainId(num.getChainId());
resNum.setSeqNum(num.getResidueNumber());
resNum.setInsCode(num.getInsCode());
// group = chain.getGroupByPDB(numIns);
group = mapChainIdChain.get(num.getChainId()).getGroupByPDB(resNum);
} catch (StructureException e) {
logger.error("Exception: ", e);
// should not happen
continue;
}
identifiedGroups.add(group);
}
int start = 0;
int n = identifiedGroups.size();
while (n > start) {
for (Group group1 : ligands) {
for (int i = start; i < n; i++) {
Group group2 = identifiedGroups.get(i);
if (!identifiedGroups.contains(group1)) {
List<Atom[]> linkedAtoms =
StructureUtil.findAtomLinkages(group1, group2, false, bondLengthTolerance);
if (!linkedAtoms.isEmpty()) {
for (Atom[] atoms : linkedAtoms) {
mc.addAtomLinkage(
StructureUtil.getStructureAtomLinkage(atoms[0], false, atoms[1], false));
}
identifiedGroups.add(group1);
break;
}
}
}
}
start = n;
n = identifiedGroups.size();
}
}
@Test
public void testParameterToPairsWhenNameIsInvalid() throws Exception {
List<Pair> pairs_a = apiClient.parameterToPairs("csv", null, new Integer(1));
List<Pair> pairs_b = apiClient.parameterToPairs("csv", "", new Integer(1));
assertTrue(pairs_a.isEmpty());
assertTrue(pairs_b.isEmpty());
}
@Override
@SuppressWarnings("deprecation")
public Object getValue(ELContext context, Object base, Object property) throws ELException {
// Don't call into the chain unless it's been decorated.
if (legacyVR instanceof ChainAwareVariableResolver) {
return null;
}
if (base != null) {
return null;
}
if (base == null && property == null) {
String message =
MessageUtils.getExceptionMessageString(
MessageUtils.NULL_PARAMETERS_ERROR_MESSAGE_ID, "base and property"); // ?????
throw new PropertyNotFoundException(message);
}
context.setPropertyResolved(true);
Object result = null;
FacesContext facesContext = (FacesContext) context.getContext(FacesContext.class);
String propString = property.toString();
Map<String, Object> stateMap = RequestStateManager.getStateMap(facesContext);
try {
// If we are already in the midst of an expression evaluation
// that touched this resolver...
//noinspection unchecked
List<String> varNames = (List<String>) stateMap.get(RequestStateManager.REENTRANT_GUARD);
if (varNames != null && !varNames.isEmpty() && varNames.contains(propString)) {
// take no action and return.
context.setPropertyResolved(false);
return null;
}
// Make sure subsequent calls don't take action.
if (varNames == null) {
varNames = new ArrayList<>();
stateMap.put(RequestStateManager.REENTRANT_GUARD, varNames);
}
varNames.add(propString);
result = legacyVR.resolveVariable(facesContext, propString);
} catch (EvaluationException ex) {
context.setPropertyResolved(false);
throw new ELException(ex);
} finally {
// Make sure to remove the guard after the call returns
//noinspection unchecked
List<String> varNames = (List<String>) stateMap.get(RequestStateManager.REENTRANT_GUARD);
if (varNames != null && !varNames.isEmpty()) {
varNames.remove(propString);
}
// Make sure that the ELContext "resolved" indicator is set
// in accordance wth the result of the resolution.
context.setPropertyResolved(result != null);
}
return result;
}
@Test
public void testCreateOrganizationAndAdminWithConfirmationAndActivation() throws Exception {
setup.set(PROPERTIES_SYSADMIN_APPROVES_ADMIN_USERS, "true");
setup.set(PROPERTIES_NOTIFY_ADMIN_OF_ACTIVATION, "true");
setup.set(PROPERTIES_SYSADMIN_APPROVES_ORGANIZATIONS, "false");
setup.set(PROPERTIES_ADMIN_USERS_REQUIRE_CONFIRMATION, "true");
final String orgName = uniqueOrg();
final String userName = uniqueUsername();
final String email = uniqueEmail();
OrganizationOwnerInfo org_owner =
createOwnerAndOrganization(
orgName, userName, "Test User", email, "testpassword", false, false);
assertNotNull(org_owner);
List<Message> user_inbox = Mailbox.get(email);
assertFalse(user_inbox.isEmpty());
Message confirmation = user_inbox.get(0);
assertEquals("User Account Confirmation: " + email, confirmation.getSubject());
String token = getTokenFromMessage(confirmation);
logger.info(token);
ActivationState state =
setup.getMgmtSvc().handleConfirmationTokenForAdminUser(org_owner.owner.getUuid(), token);
assertEquals(ActivationState.CONFIRMED_AWAITING_ACTIVATION, state);
confirmation = user_inbox.get(1);
String body =
((MimeMultipart) confirmation.getContent()).getBodyPart(0).getContent().toString();
Boolean subbedEmailed = StringUtils.contains(body, "$");
assertFalse(subbedEmailed);
assertEquals("User Account Confirmed", confirmation.getSubject());
List<Message> sysadmin_inbox = Mailbox.get("*****@*****.**");
assertFalse(sysadmin_inbox.isEmpty());
Message activation = sysadmin_inbox.get(0);
assertEquals("Request For Admin User Account Activation " + email, activation.getSubject());
token = getTokenFromMessage(activation);
logger.info(token);
state = setup.getMgmtSvc().handleActivationTokenForAdminUser(org_owner.owner.getUuid(), token);
assertEquals(ActivationState.ACTIVATED, state);
Message activated = user_inbox.get(2);
assertEquals("User Account Activated", activated.getSubject());
MockImapClient client = new MockImapClient("mockserver.com", "test-user-2", "somepassword");
client.processMail();
}
/**
* Persists a Audit
*
* @param object
* @param persisted
* @param auditingType
*/
public void audit(Object object, Object persisted, AuditingType auditingType) {
try {
if (isEntity(object)) {
Field[] fields = object.getClass().getDeclaredFields();
Method[] methods = object.getClass().getDeclaredMethods();
Method.setAccessible(methods, true);
Field.setAccessible(fields, true);
AbstractAuditing auditing = Configuration.getAbstractAuditing();
auditing.setIdentifier(Long.valueOf(getId(object).toString()));
auditing.setEntity(getEntityName(object.getClass()));
auditing.setAuditingType(auditingType);
auditing.setEventDate(new Date());
if (FacesContext.getCurrentInstance() != null) {
auditing.setIp(FacesUtils.getIP());
}
auditing.setAuditClass(object.getClass());
AbstractAuditingListener listener = Configuration.getAuditingListener();
if (listener != null) {
listener.onSave(auditing);
}
List<AbstractMetadata> metadatas = null;
boolean auditPersited = false;
if (auditingType.equals(AuditingType.INSERT) || auditingType.equals(AuditingType.DELETE)) {
entityManager.persist(auditing);
metadatas = getMetadata(object, null, auditing);
auditPersited = true;
} else if (auditingType.equals(AuditingType.UPDATE)) {
metadatas = getMetadata(object, persisted, auditing);
if (metadatas != null && !metadatas.isEmpty()) {
entityManager.persist(auditing);
auditPersited = true;
}
}
auditing.setMetadatas(metadatas);
// add to context
if (auditPersited == true) {
AuditContext context = AuditContext.getCurrentInstance();
if (context != null) {
context.setAuditing(object, auditing);
}
}
if (metadatas != null && !metadatas.isEmpty()) {
for (AbstractMetadata metadata : metadatas) {
entityManager.persist(metadata);
}
}
}
} catch (Throwable t) {
logger.log(Level.SEVERE, t.getMessage(), t);
}
}
/**
* Returns a map of colored mana symbol to basic land cards of that color.
*
* @param setsToUse which sets to retrieve basic lands from.
* @return a map of color to basic lands.
*/
private static Map<String, List<CardInfo>> generateBasicLands(List<String> setsToUse) {
List<String> landSets = new LinkedList<>();
// decide from which sets basic lands are taken from
for (String setCode : setsToUse) {
ExpansionInfo expansionInfo = ExpansionRepository.instance.getSetByCode(setCode);
if (expansionInfo.hasBasicLands()) {
landSets.add(expansionInfo.getCode());
}
}
// if sets have no basic land, take land from block
if (landSets.isEmpty()) {
for (String setCode : setsToUse) {
ExpansionInfo expansionInfo = ExpansionRepository.instance.getSetByCode(setCode);
List<ExpansionInfo> blockSets =
ExpansionRepository.instance.getSetsFromBlock(expansionInfo.getBlockName());
for (ExpansionInfo blockSet : blockSets) {
if (blockSet.hasBasicLands()) {
landSets.add(blockSet.getCode());
}
}
}
}
// if still no set with lands found, take one by random
if (landSets.isEmpty()) {
// if sets have no basic lands and also it has no parent or parent has no lands get last set
// with lands
// select a set with basic lands by random
Random generator = new Random();
List<ExpansionInfo> basicLandSets =
ExpansionRepository.instance.getSetsWithBasicLandsByReleaseDate();
if (basicLandSets.size() > 0) {
landSets.add(basicLandSets.get(generator.nextInt(basicLandSets.size())).getCode());
}
}
if (landSets.isEmpty()) {
throw new IllegalArgumentException("No set with basic land was found");
}
CardCriteria criteria = new CardCriteria();
if (!landSets.isEmpty()) {
criteria.setCodes(landSets.toArray(new String[landSets.size()]));
}
Map<String, List<CardInfo>> basicLandMap = new HashMap<>();
for (ColoredManaSymbol c : ColoredManaSymbol.values()) {
String landName = DeckGeneratorPool.getBasicLandName(c.toString());
criteria.rarities(Rarity.LAND).name(landName);
List<CardInfo> cards = CardRepository.instance.findCards(criteria);
basicLandMap.put(landName, cards);
}
return basicLandMap;
}
public boolean isEmpty() {
return super.isEmpty()
&& (identifier == null || identifier.isEmpty())
&& (patient == null || patient.isEmpty())
&& (description == null || description.isEmpty())
&& (status == null || status.isEmpty())
&& (notes == null || notes.isEmpty())
&& (concern == null || concern.isEmpty());
}
/**
* Checks that given function has any decorators from {@code abc} module.
*
* @param element Python function to check
* @param context type evaluation context. If it doesn't allow switch to AST, decorators will be
* compared by the text of the last component of theirs qualified names.
* @see PyKnownDecoratorUtil.KnownDecorator
*/
public static boolean hasAbstractDecorator(
@NotNull PyDecoratable element, @NotNull TypeEvalContext context) {
final List<KnownDecorator> knownDecorators = getKnownDecorators(element, context);
if (knownDecorators.isEmpty()) {
return false;
}
knownDecorators.retainAll(ABSTRACT_DECORATORS);
return !knownDecorators.isEmpty();
}
void init2ndPass() {
init2ndPassNamesWithDefaults();
for (int i = 0; i < properties.size(); i++) {
Property property = properties.get(i);
property.setOrdinal(i);
property.init2ndPass();
if (property.isPrimaryKey()) {
propertiesPk.add(property);
} else {
propertiesNonPk.add(property);
}
}
if (propertiesPk.size() == 1) {
pkProperty = propertiesPk.get(0);
pkType = schema.mapToJavaTypeNullable(pkProperty.getPropertyType());
} else {
pkType = "Void";
}
propertiesColumns = new ArrayList<Property>(properties);
for (ToOne toOne : toOneRelations) {
toOne.init2ndPass();
Property[] fkProperties = toOne.getFkProperties();
for (Property fkProperty : fkProperties) {
if (!propertiesColumns.contains(fkProperty)) {
propertiesColumns.add(fkProperty);
}
}
}
for (ToMany toMany : toManyRelations) {
toMany.init2ndPass();
// Source Properties may not be virtual, so we do not need the following code:
// for (Property sourceProperty : toMany.getSourceProperties()) {
// if (!propertiesColumns.contains(sourceProperty)) {
// propertiesColumns.add(sourceProperty);
// }
// }
}
if (active == null) {
active = schema.isUseActiveEntitiesByDefault();
}
active |= !toOneRelations.isEmpty() || !toManyRelations.isEmpty();
if (hasKeepSections == null) {
hasKeepSections = schema.isHasKeepSectionsByDefault();
}
init2ndPassIndexNamesWithDefaults();
for (ContentProvider contentProvider : contentProviders) {
contentProvider.init2ndPass();
}
}
private Component[][] eliminateUnusedRowsAndColumns(Component[][] table) {
if (table.length == 0) {
return table;
}
// Could make this into a Set, but I doubt there will be any real gain in performance as these
// are probably going
// to be very small.
List<Integer> rowsToRemove = new ArrayList<Integer>();
List<Integer> columnsToRemove = new ArrayList<Integer>();
final int tableRows = table.length;
final int tableColumns = table[0].length;
// Scan for unnecessary columns
columnLoop:
for (int column = tableColumns - 1; column > 0; column--) {
for (int row = 0; row < tableRows; row++) {
if (table[row][column] != table[row][column - 1]) {
continue columnLoop;
}
}
columnsToRemove.add(column);
}
// Scan for unnecessary rows
rowLoop:
for (int row = tableRows - 1; row > 0; row--) {
for (int column = 0; column < tableColumns; column++) {
if (table[row][column] != table[row - 1][column]) {
continue rowLoop;
}
}
rowsToRemove.add(row);
}
// If there's nothing to remove, just return the same
if (rowsToRemove.isEmpty() && columnsToRemove.isEmpty()) {
return table;
}
// Build a new table with rows & columns eliminated
Component[][] newTable = new Component[tableRows - rowsToRemove.size()][];
int insertedRowCounter = 0;
for (int row = 0; row < tableRows; row++) {
Component[] newColumn = new Component[tableColumns - columnsToRemove.size()];
int insertedColumnCounter = 0;
for (int column = 0; column < tableColumns; column++) {
if (columnsToRemove.contains(column)) {
continue;
}
newColumn[insertedColumnCounter++] = table[row][column];
}
newTable[insertedRowCounter++] = newColumn;
}
return newTable;
}
private void resolveByHaplotype(final ReferenceContext refContext) {
final byte[] source1Haplotype = generateHaplotype(sourceVCs1, refContext);
final byte[] source2Haplotype = generateHaplotype(sourceVCs2, refContext);
final SWPairwiseAlignment swConsensus1 =
new SWPairwiseAlignment(
refContext.getBases(), source1Haplotype, SW_MATCH, SW_MISMATCH, SW_GAP, SW_GAP_EXTEND);
final SWPairwiseAlignment swConsensus2 =
new SWPairwiseAlignment(
refContext.getBases(), source2Haplotype, SW_MATCH, SW_MISMATCH, SW_GAP, SW_GAP_EXTEND);
// protect against SW failures
if (swConsensus1.getCigar().toString().contains("S")
|| swConsensus1.getCigar().getReferenceLength() < 20
|| swConsensus2.getCigar().toString().contains("S")
|| swConsensus2.getCigar().getReferenceLength() < 20) {
// TODO -- handle errors appropriately
logger.debug("Bad SW alignment; aborting at " + refContext.getLocus());
return;
}
// order results by start position
final TreeMap<Integer, VariantContext> source1Map =
new TreeMap<Integer, VariantContext>(
HaplotypeCallerGenotypingEngine.generateVCsFromAlignment(
new Haplotype(source1Haplotype, false, 0, swConsensus1.getCigar()),
refContext.getBases(),
refContext.getWindow(),
source1));
final TreeMap<Integer, VariantContext> source2Map =
new TreeMap<Integer, VariantContext>(
HaplotypeCallerGenotypingEngine.generateVCsFromAlignment(
new Haplotype(source2Haplotype, false, 0, swConsensus2.getCigar()),
refContext.getBases(),
refContext.getWindow(),
source2));
if (source1Map.size() == 0 || source2Map.size() == 0) {
// TODO -- handle errors appropriately
logger.debug("No source alleles; aborting at " + refContext.getLocus());
return;
}
// create lists and test for equality
final List<VariantContext> source1Alleles = new ArrayList<VariantContext>(source1Map.values());
final List<VariantContext> source2Alleles = new ArrayList<VariantContext>(source2Map.values());
writeAndPurgeAllEqualVariants(source1Alleles, source2Alleles, SAME_BY_HAPLOTYPE_STATUS);
if (source1Alleles.isEmpty()) {
writeAll(source2Alleles, source2, null);
} else if (source2Alleles.isEmpty()) {
writeAll(source1Alleles, source1, null);
} else {
writeDifferences(source1Alleles, source2Alleles);
}
}
@NotNull
@SuppressWarnings("Duplicates")
private Collection<String> checkWatchable(
String reportedPath, boolean isExact, boolean fastPath) {
if (reportedPath == null) return Collections.emptyList();
List<String> flatWatchRoots = myFlatWatchRoots;
List<String> recursiveWatchRoots = myRecursiveWatchRoots;
if (flatWatchRoots.isEmpty() && recursiveWatchRoots.isEmpty()) return Collections.emptyList();
List<Pair<String, String>> mapping = myMapping;
Collection<String> affectedPaths = new SmartList<String>(reportedPath);
for (Pair<String, String> map : mapping) {
if (FileUtil.startsWith(reportedPath, map.first)) {
affectedPaths.add(map.second + reportedPath.substring(map.first.length()));
} else if (FileUtil.startsWith(reportedPath, map.second)) {
affectedPaths.add(map.first + reportedPath.substring(map.second.length()));
}
}
Collection<String> changedPaths = new SmartList<String>();
ext:
for (String path : affectedPaths) {
if (fastPath && !changedPaths.isEmpty()) break;
for (String root : flatWatchRoots) {
if (FileUtil.namesEqual(path, root)) {
changedPaths.add(path);
continue ext;
}
if (isExact) {
String parentPath = new File(path).getParent();
if (parentPath != null && FileUtil.namesEqual(parentPath, root)) {
changedPaths.add(path);
continue ext;
}
}
}
for (String root : recursiveWatchRoots) {
if (FileUtil.startsWith(path, root)) {
changedPaths.add(path);
continue ext;
}
if (!isExact) {
String parentPath = new File(root).getParent();
if (parentPath != null && FileUtil.namesEqual(path, parentPath)) {
changedPaths.add(root);
continue ext;
}
}
}
}
return changedPaths;
}
@Test
public void shouldNotSaveMotherOrChildFormsIfNullAndEmpty() {
careService.processAndSaveForms(null, new ArrayList<Map<String, String>>());
List<MotherCase> mothers = template.loadAll(MotherCase.class);
assertTrue(mothers.isEmpty());
List<ChildCase> children = template.loadAll(ChildCase.class);
assertTrue(children.isEmpty());
}