public static void buildDeleteNotification(
OJAnnotatedClass owner, OJAnnotatedOperation delete, PropertyWrapper propertyWrapper) {
OJIfStatement ifChanged = new OJIfStatement();
ifChanged.setCondition("true");
PropertyWrapper otherEnd = PropertyWrapper.from(propertyWrapper.getOtherEnd());
if (otherEnd.isMany()) {
OJForStatement forStatement =
new OJForStatement(
otherEnd.getName(), otherEnd.javaBaseTypePath(), "this." + otherEnd.getter() + "()");
forStatement
.getBody()
.addToStatements(constructNotifierForOtherEndMany(propertyWrapper, otherEnd));
delete.getBody().addToStatements(0, forStatement);
} else {
ifChanged.addToThenPart(constructNotifier(propertyWrapper));
delete.getBody().addToStatements(0, ifChanged);
}
owner.addToImports(
UmlgClassOperations.getPathName(propertyWrapper.getOwningType())
.append(UmlgClassOperations.propertyEnumName(propertyWrapper.getOwningType())));
owner.addToImports(UmlgGenerationUtil.UmlgNotificationManager);
owner.addToImports(UmlgGenerationUtil.ChangeHolder);
owner.addToImports(UmlgGenerationUtil.ChangeHolder);
owner.addToImports("java.util.Optional");
}
private static void buildGetAssociationClassForPropertyInstance(
OJAnnotatedClass owner, PropertyWrapper propertyWrapper) {
OJAnnotatedOperation getAC =
new OJAnnotatedOperation(
propertyWrapper.associationClassGetterForProperty(),
propertyWrapper.getAssociationClassPathName());
getAC.addParam(propertyWrapper.fieldname(), propertyWrapper.javaBaseTypePath());
OJForStatement forAC =
new OJForStatement(
"ac",
propertyWrapper.getAssociationClassPathName(),
"this." + propertyWrapper.getAssociationClassFakePropertyName());
OJIfStatement ifStatement =
new OJIfStatement(
"ac." + propertyWrapper.getter() + "().equals(" + propertyWrapper.fieldname() + ")",
"return ac");
forAC.getBody().addToStatements(ifStatement);
getAC.getBody().addToStatements(forAC);
getAC.getBody().addToStatements("return null");
owner.addToOperations(getAC);
}
private void addPostObjectRepresentation(PropertyWrapper pWrap, OJAnnotatedClass annotatedClass) {
OJAnnotatedOperation post =
new OJAnnotatedOperation("post", UmlgRestletGenerationUtil.Representation);
post.addToParameters(new OJParameter("entity", UmlgRestletGenerationUtil.Representation));
post.addToThrows(UmlgRestletGenerationUtil.ResourceException);
annotatedClass.addToImports(UmlgRestletGenerationUtil.ResourceException);
UmlgGenerationUtil.addOverrideAnnotation(post);
UmlgGenerationUtil.addSuppressWarning(post);
PropertyWrapper otherEndPWrap = new PropertyWrapper(pWrap.getOtherEnd());
OJPathName parentPathName = otherEndPWrap.javaBaseTypePath();
post.getBody()
.addToStatements(
"this."
+ parentPathName.getLast().toLowerCase()
+ "Id = "
+ UmlgRestletGenerationUtil.UmlgURLDecoder.getLast()
+ ".decode((String)getRequestAttributes().get(\""
+ parentPathName.getLast().toLowerCase()
+ "Id\"))");
annotatedClass.addToImports(UmlgRestletGenerationUtil.UmlgURLDecoder);
post.getBody()
.addToStatements(
parentPathName.getLast()
+ " parentResource = "
+ UmlgGenerationUtil.UMLGAccess
+ "."
+ UmlgGenerationUtil.getEntity
+ "("
+ parentPathName.getLast().toLowerCase()
+ "Id"
+ ")");
OJTryStatement ojTryStatement = new OJTryStatement();
OJField mapper = new OJField("mapper", UmlgGenerationUtil.ObjectMapper);
mapper.setInitExp(
UmlgGenerationUtil.ObjectMapperFactory.getLast() + ".INSTANCE.getObjectMapper()");
annotatedClass.addToImports(UmlgGenerationUtil.ObjectMapperFactory);
ojTryStatement.getTryPart().addToLocals(mapper);
OJPathName pathName =
new OJPathName("java.util.Map").addToGenerics("String").addToGenerics("Object");
OJAnnotatedField entityText = new OJAnnotatedField("entityText", "String");
entityText.setInitExp("entity.getText()");
ojTryStatement.getTryPart().addToLocals(entityText);
OJField resultMap =
new OJField(
"resultMap",
new OJPathName("java.util.Map")
.addToGenerics(
new OJPathName("Class<? extends " + pWrap.javaBaseTypePath().getLast() + ">"))
.addToGenerics(
"List<" + UmlgRestletGenerationUtil.UmlgNodeJsonHolder.getLast() + ">"));
resultMap.setInitExp(
"new HashMap<Class<? extends "
+ pWrap.javaBaseTypePath().getLast()
+ ">, List<"
+ UmlgRestletGenerationUtil.UmlgNodeJsonHolder.getLast()
+ ">>()");
annotatedClass.addToImports("java.util.HashMap");
annotatedClass.addToImports("java.util.List");
annotatedClass.addToImports(UmlgRestletGenerationUtil.UmlgNodeJsonHolder);
ojTryStatement.getTryPart().addToLocals(resultMap);
ojTryStatement
.getTryPart()
.addToStatements(
pathName.getLast()
+ " overloaded = mapper.readValue("
+ entityText.getName()
+ ", Map.class)");
ojTryStatement.getTryPart().addToStatements("Object o = overloaded.get(\"insert\")");
// Insert
OJIfStatement ifInsert = new OJIfStatement("o != null");
OJIfStatement ifArrayForInsert = new OJIfStatement("o instanceof ArrayList");
OJPathName genericsForArray =
new OJPathName("java.util.Map").addToGenerics("String").addToGenerics("Object");
OJField array =
new OJField("array", new OJPathName("java.util.List").addToGenerics(genericsForArray));
array.setInitExp("(ArrayList<Map<String, Object>>)o");
ifArrayForInsert.getThenPart().addToLocals(array);
ifInsert.addToThenPart(ifArrayForInsert);
ojTryStatement.getTryPart().addToStatements(ifInsert);
OJForStatement forArray =
new OJForStatement(
"overloadedJsonMap",
new OJPathName("java.util.Map")
.addToGenerics(new OJPathName("String"))
.addToGenerics(new OJPathName("Object")),
"array");
ifArrayForInsert.addToThenPart(forArray);
forArray.getBody().addToStatements("add(resultMap, parentResource, overloadedJsonMap)");
OJField map =
new OJField(
"overloadedJsonMap",
new OJPathName("java.util.Map").addToGenerics("String").addToGenerics("Object"));
map.setInitExp("(Map<String, Object>) o");
ifArrayForInsert.setElsePart(new OJBlock());
ifArrayForInsert.getElsePart().addToLocals(map);
ifArrayForInsert
.getElsePart()
.addToStatements("add(resultMap, parentResource, overloadedJsonMap)");
addPostResource(pWrap, annotatedClass, parentPathName);
// Delete
ojTryStatement.getTryPart().addToStatements("o = overloaded.get(\"delete\")");
OJIfStatement ifDelete = new OJIfStatement("o != null");
OJIfStatement ifArrayForDelete = new OJIfStatement("o instanceof ArrayList");
genericsForArray =
new OJPathName("java.util.Map").addToGenerics("String").addToGenerics("Object");
array =
new OJField("array", new OJPathName("java.util.ArrayList").addToGenerics(genericsForArray));
array.setInitExp("(ArrayList<Map<String, Object>>)o");
ifArrayForDelete.getThenPart().addToLocals(array);
ifDelete.addToThenPart(ifArrayForDelete);
ojTryStatement.getTryPart().addToStatements(ifDelete);
forArray =
new OJForStatement(
"map",
new OJPathName("java.util.Map")
.addToGenerics(new OJPathName("String"))
.addToGenerics(new OJPathName("Object")),
"array");
ifArrayForDelete.addToThenPart(forArray);
if (pWrap.isComposite()) {
forArray.getBody().addToStatements("delete(map)");
} else {
forArray.getBody().addToStatements("delete(parentResource, map)");
}
map =
new OJField(
"map", new OJPathName("java.util.Map").addToGenerics("String").addToGenerics("Object"));
map.setInitExp("(Map<String, Object>) o");
ifArrayForDelete.setElsePart(new OJBlock());
ifArrayForDelete.getElsePart().addToLocals(map);
if (pWrap.isComposite()) {
ifArrayForDelete.getElsePart().addToStatements("delete(map)");
} else {
ifArrayForDelete.getElsePart().addToStatements("delete(parentResource, map)");
}
addDeleteResource(pWrap, annotatedClass, parentPathName);
// Update
ojTryStatement.getTryPart().addToStatements("o = overloaded.get(\"update\")");
OJIfStatement ifUpdate = new OJIfStatement("o != null");
OJIfStatement ifArrayForUpdate = new OJIfStatement("o instanceof ArrayList");
genericsForArray =
new OJPathName("java.util.Map").addToGenerics("String").addToGenerics("Object");
array =
new OJField("array", new OJPathName("java.util.ArrayList").addToGenerics(genericsForArray));
array.setInitExp("(ArrayList<Map<String, Object>>)o");
ifArrayForUpdate.getThenPart().addToLocals(array);
ifUpdate.addToThenPart(ifArrayForUpdate);
ojTryStatement.getTryPart().addToStatements(ifUpdate);
forArray =
new OJForStatement(
"overloadedJsonMap",
new OJPathName("java.util.Map")
.addToGenerics(new OJPathName("String"))
.addToGenerics(new OJPathName("Object")),
"array");
ifArrayForUpdate.addToThenPart(forArray);
if (pWrap.isOrdered()) {
forArray.getBody().addToStatements("put(resultMap, parentResource, overloadedJsonMap)");
} else {
forArray.getBody().addToStatements("put(resultMap, overloadedJsonMap)");
}
map =
new OJField(
"overloadedJsonMap",
new OJPathName("java.util.Map").addToGenerics("String").addToGenerics("Object"));
map.setInitExp("(Map<String, Object>) o");
ifArrayForUpdate.setElsePart(new OJBlock());
ifArrayForUpdate.getElsePart().addToLocals(map);
if (pWrap.isOrdered()) {
// Include the parent as it will be needed to add the child at a particular index
ifArrayForUpdate
.getElsePart()
.addToStatements("put(resultMap, parentResource, overloadedJsonMap)");
} else {
ifArrayForUpdate.getElsePart().addToStatements("put(resultMap, overloadedJsonMap)");
}
addPutResource(pWrap, annotatedClass, parentPathName);
// Check if transaction needs commiting
commitOrRollback(ojTryStatement);
OJBlock jsonResultBlock = new OJBlock();
ojTryStatement.getTryPart().addToStatements(jsonResultBlock);
OJField result = new OJField("result", "java.lang.StringBuilder");
result.setInitExp("new StringBuilder(\"[\")");
jsonResultBlock.addToLocals(result);
OJField count = new OJField("count", "int");
count.setInitExp("1");
jsonResultBlock.addToLocals(count);
OJForStatement forConcreteClassifiers =
new OJForStatement(
"baseClass",
new OJPathName("Class")
.addToGenerics("? extends " + pWrap.javaBaseTypePath().getLast()),
"resultMap.keySet()");
jsonResultBlock.addToStatements(forConcreteClassifiers);
if (pWrap.isOne()) {
forConcreteClassifiers.getBody().addToStatements("result.append(\"{\\\"data\\\": \")");
} else {
forConcreteClassifiers.getBody().addToStatements("result.append(\"{\\\"data\\\": [\")");
}
OJField objectList =
new OJField(
"objectList",
new OJPathName("java.util.List")
.addToGenerics(UmlgRestletGenerationUtil.UmlgNodeJsonHolder));
objectList.setInitExp("resultMap.get(baseClass)");
forConcreteClassifiers.getBody().addToLocals(objectList);
OJField objectListCount = new OJField("objectListCount", new OJPathName("int"));
objectListCount.setInitExp("1");
forConcreteClassifiers.getBody().addToLocals(objectListCount);
OJForStatement forObjectList =
new OJForStatement("object", UmlgRestletGenerationUtil.UmlgNodeJsonHolder, "objectList");
forObjectList.getBody().addToStatements("result.append(object.toJson())");
OJIfStatement ifObjectListCountSmallerThanSize =
new OJIfStatement("objectListCount++ < objectList.size()", "result.append(\",\")");
forObjectList.getBody().addToStatements(ifObjectListCountSmallerThanSize);
forConcreteClassifiers.getBody().addToStatements(forObjectList);
if (pWrap.isOne()) {
forConcreteClassifiers.getBody().addToStatements("result.append(\",\")");
} else {
forConcreteClassifiers.getBody().addToStatements("result.append(\"],\")");
}
forConcreteClassifiers.getBody().addToStatements("result.append(\" \\\"meta\\\" : {\")");
forConcreteClassifiers
.getBody()
.addToStatements(
"result.append(\"\\\"qualifiedName\\\": \\\"" + pWrap.getQualifiedName() + "\\\"\")");
forConcreteClassifiers.getBody().addToStatements("result.append(\", \\\"to\\\": \")");
OJIfStatement ifClassInstanceOf = null;
Set<Classifier> concreteImplementations =
UmlgClassOperations.getConcreteImplementations((Classifier) pWrap.getType());
if (!concreteImplementations.isEmpty()) {
ifClassInstanceOf = new OJIfStatement();
forConcreteClassifiers.getBody().addToStatements(ifClassInstanceOf);
}
boolean first = true;
for (Classifier concreteImplementation : concreteImplementations) {
OJBlock ojIfBlock;
if (first) {
first = false;
ifClassInstanceOf.setCondition(
"baseClass.equals("
+ UmlgClassOperations.getPathName(concreteImplementation).getLast()
+ ".class)");
ojIfBlock = ifClassInstanceOf.getThenPart();
} else {
ojIfBlock =
ifClassInstanceOf.addToElseIfCondition(
"baseClass.equals("
+ UmlgClassOperations.getPathName(concreteImplementation).getLast()
+ ".class)",
"");
}
ojIfBlock.addToStatements(
"result.append("
+ UmlgClassOperations.propertyEnumName(concreteImplementation)
+ ".asJson())");
annotatedClass.addToImports(
UmlgClassOperations.getPathName(concreteImplementation)
.append(UmlgClassOperations.propertyEnumName(concreteImplementation)));
ojIfBlock.addToStatements("result.append(\", \\\"from\\\": \")");
Classifier owningType = (Classifier) pWrap.getOwningType();
ojIfBlock.addToStatements(
"result.append(" + UmlgClassOperations.propertyEnumName(owningType) + ".asJson())");
annotatedClass.addToImports(
UmlgClassOperations.getPathName(owningType)
.append(UmlgClassOperations.propertyEnumName(owningType)));
ojIfBlock.addToStatements("result.append(\"}\")");
}
OJIfStatement ifLast = new OJIfStatement("count++ == resultMap.size()");
ifLast.addToThenPart("result.append(\"}\")");
ifLast.addToElsePart("result.append(\"},\")");
forConcreteClassifiers.getBody().addToStatements(ifLast);
if (!concreteImplementations.isEmpty()) {
ifClassInstanceOf.addToElsePart(
"throw new IllegalStateException(\"Unknown type \" + baseClass.getName())");
}
jsonResultBlock.addToStatements("result.append(\"]\")");
jsonResultBlock.addToStatements(
"return new "
+ UmlgRestletGenerationUtil.JsonRepresentation.getLast()
+ "(result.toString())");
ojTryStatement.setCatchParam(new OJParameter("e", new OJPathName("java.lang.Exception")));
ojTryStatement.getCatchPart().addToStatements(UmlgGenerationUtil.UMLGAccess + ".rollback()");
ojTryStatement
.getCatchPart()
.addToStatements(
"throw "
+ UmlgRestletGenerationUtil.UmlgExceptionUtilFactory.getLast()
+ ".getTumlExceptionUtil().handle(e)");
annotatedClass.addToImports(UmlgRestletGenerationUtil.UmlgExceptionUtilFactory);
post.getBody().addToStatements(ojTryStatement);
annotatedClass.addToImports(parentPathName);
annotatedClass.addToImports(UmlgGenerationUtil.UMLGPathName);
annotatedClass.addToImports(UmlgRestletGenerationUtil.JsonRepresentation);
annotatedClass.addToOperations(post);
}
public static void buildManyAdder(
OJAnnotatedClass owner,
PropertyWrapper propertyWrapper,
boolean indexed,
boolean ignoreInverse) {
OJAnnotatedOperation adder = new OJAnnotatedOperation(propertyWrapper.adder());
if (!propertyWrapper.isMemberOfAssociationClass()) {
if (indexed) {
adder.addParam("index", "int");
}
adder.addParam(propertyWrapper.fieldname(), propertyWrapper.javaTypePath());
} else {
if (indexed) {
adder.addParam("index", "int");
}
adder.addParam(
propertyWrapper.getAssociationClassFakePropertyName(),
propertyWrapper.javaTypePathWithAssociationClass());
}
if (!(owner instanceof OJAnnotatedInterface)) {
if (!propertyWrapper.hasQualifiers()) {
if (!propertyWrapper.isMemberOfAssociationClass()) {
OJIfStatement ifNotNull =
new OJIfStatement("!" + propertyWrapper.fieldname() + ".isEmpty()");
ifNotNull.addToThenPart(
"this."
+ propertyWrapper.fieldname()
+ ".addAll("
+ propertyWrapper.fieldname()
+ ")");
adder.getBody().addToStatements(ifNotNull);
} else {
// iterate the association class set as it contains a Pair
OJForStatement associationClassPairs =
new OJForStatement(
"pair",
propertyWrapper.getAssociationClassPair(),
propertyWrapper.getAssociationClassFakePropertyName());
associationClassPairs
.getBody()
.addToStatements(propertyWrapper.adder() + "(pair.getFirst(), pair.getSecond())");
adder.getBody().addToStatements(associationClassPairs);
}
} else {
String elementName = "_" + propertyWrapper.fieldname().substring(0, 1);
OJForStatement forAll =
new OJForStatement(
elementName, propertyWrapper.javaBaseTypePath(), propertyWrapper.fieldname());
forAll
.getBody()
.addToStatements("this." + propertyWrapper.adder() + "(" + elementName + ")");
adder.getBody().addToStatements(forAll);
}
}
owner.addToOperations(adder);
OJAnnotatedOperation singleAdder =
new OJAnnotatedOperation(
!ignoreInverse ? propertyWrapper.adder() : propertyWrapper.adderIgnoreInverse());
if (indexed) {
singleAdder.addParam("index", "int");
}
singleAdder.addParam(propertyWrapper.fieldname(), propertyWrapper.javaBaseTypePath());
if (propertyWrapper.isMemberOfAssociationClass()) {
singleAdder.addParam(
StringUtils.uncapitalize(propertyWrapper.getAssociationClass().getName()),
UmlgClassOperations.getPathName(propertyWrapper.getAssociationClass()));
}
if (!(owner instanceof OJAnnotatedInterface)) {
PropertyWrapper otherEnd = new PropertyWrapper(propertyWrapper.getOtherEnd());
if (
/*For bags the one side can have many edges to the same element*/ propertyWrapper.isUnique()
&& propertyWrapper.hasOtherEnd()
&& !propertyWrapper.isEnumeration()
&& otherEnd.isOne()) {
OJIfStatement ifNotNull2 = new OJIfStatement(propertyWrapper.fieldname() + " != null");
ifNotNull2.addToThenPart(propertyWrapper.fieldname() + "." + otherEnd.clearer() + "()");
ifNotNull2.addToThenPart(
propertyWrapper.fieldname()
+ ".initialiseProperty("
+ UmlgClassOperations.propertyEnumName(otherEnd.getOwningType())
+ "."
+ otherEnd.fieldname()
+ ", false)");
ifNotNull2.addToThenPart(
propertyWrapper.remover() + "(" + propertyWrapper.fieldname() + ")");
owner.addToImports(
UmlgClassOperations.getPathName(otherEnd.getOwningType())
.append(UmlgClassOperations.propertyEnumName(otherEnd.getOwningType())));
singleAdder.getBody().addToStatements(ifNotNull2);
}
OJIfStatement ifNotNull = new OJIfStatement(propertyWrapper.fieldname() + " != null");
// Add in validations
OJBlock block;
if (propertyWrapper.isDataType()) {
OJField failedConstraints =
new OJField(
"violations",
new OJPathName("java.util.List")
.addToGenerics(UmlgGenerationUtil.UmlgConstraintViolation));
failedConstraints.setInitExp(
propertyWrapper.validator() + "(" + propertyWrapper.fieldname() + ")");
ifNotNull.getThenPart().addToLocals(failedConstraints);
OJIfStatement ifValidated = new OJIfStatement("violations.isEmpty()");
ifValidated.addToElsePart(
"throw new "
+ UmlgGenerationUtil.UmlgConstraintViolationException.getLast()
+ "(violations)");
owner.addToImports(UmlgGenerationUtil.UmlgConstraintViolationException);
ifNotNull.addToThenPart(ifValidated);
block = ifValidated.getThenPart();
} else {
block = ifNotNull.getThenPart();
}
if (!propertyWrapper.isMemberOfAssociationClass()) {
if (!indexed) {
if (!ignoreInverse) {
block.addToStatements(
"this."
+ propertyWrapper.fieldname()
+ ".add("
+ propertyWrapper.fieldname()
+ ")");
} else {
block.addToStatements(
"this."
+ propertyWrapper.fieldname()
+ ".addIgnoreInverse("
+ propertyWrapper.fieldname()
+ ")");
}
} else {
block.addToStatements(
"this."
+ propertyWrapper.fieldname()
+ ".add(index, "
+ propertyWrapper.fieldname()
+ ")");
}
} else {
if (!indexed) {
block.addToStatements(
"this."
+ propertyWrapper.fieldname()
+ ".add("
+ propertyWrapper.fieldname()
+ ", "
+ StringUtils.uncapitalize(propertyWrapper.getAssociationClass().getName())
+ ")");
} else {
block.addToStatements(
"this."
+ propertyWrapper.fieldname()
+ ".add(index, "
+ propertyWrapper.fieldname()
+ ", "
+ StringUtils.uncapitalize(propertyWrapper.getAssociationClass().getName())
+ ")");
}
}
singleAdder.getBody().addToStatements(ifNotNull);
}
owner.addToOperations(singleAdder);
// //Add change listener
// if (propertyWrapper.isChangedListener()) {
// PropertyChangeNotificationBuilder.buildChangeNotification(owner, singleAdder,
// propertyWrapper, PropertyChangeNotificationBuilder.CHANGE_TYPE.ADD);
// }
}