use of org.commongeoregistry.adapter.metadata.GeoObjectType in project geoprism-registry by terraframe.
the class GeoObjectExcelExporter method createWorkbook.
public Workbook createWorkbook() throws IOException {
Workbook workbook = new XSSFWorkbook();
Sheet sheet = workbook.createSheet(WorkbookUtil.createSafeSheetName(this.type.getLabel().getValue()));
CreationHelper createHelper = workbook.getCreationHelper();
Font font = workbook.createFont();
font.setBold(true);
CellStyle boldStyle = workbook.createCellStyle();
boldStyle.setFont(font);
CellStyle dateStyle = workbook.createCellStyle();
dateStyle.setDataFormat(createHelper.createDataFormat().getFormat(BuiltinFormats.getBuiltinFormat(14)));
Row header = sheet.createRow(0);
boolean includeCoordinates = this.type.getGeometryType().equals(GeometryType.POINT) || this.type.getGeometryType().equals(GeometryType.MIXED);
Collection<AttributeType> attributes = new ImportAttributeSerializer(Session.getCurrentLocale(), includeCoordinates, true, locales).attributes(this.type.getType());
// Get the ancestors of the type
List<GeoObjectType> dtoAncestors = this.type.getTypeAncestors(this.hierarchy, true);
List<ServerGeoObjectType> ancestors = new LinkedList<ServerGeoObjectType>();
for (GeoObjectType ancestor : dtoAncestors) {
ancestors.add(ServerGeoObjectType.get(ancestor));
}
this.writeHeader(boldStyle, header, attributes, ancestors);
for (int i = 0; i < this.objects.size(); i++) {
ServerGeoObjectIF object = this.objects.get(i);
Row row = sheet.createRow(i + 1);
this.writeRow(row, object, attributes, ancestors, dateStyle);
}
return workbook;
}
use of org.commongeoregistry.adapter.metadata.GeoObjectType in project geoprism-registry by terraframe.
the class HierarchyService method insertBetweenTypes.
/**
* Inserts the {@link GeoObjectType} 'middleGeoObjectTypeCode' into the
* hierarchy as the child of 'parentGeoObjectTypeCode' and the new parent for
* 'youngestGeoObjectTypeCode'. If an existing parent/child relationship
* already exists between 'youngestGeoObjectTypeCode' and
* 'parentgeoObjectTypeCode', it will first be removed.
* youngestGeoObjectTypeCode can also be an array (comma separated list).
*
* @param sessionId
* @param hierarchyTypeCode
* code of the {@link HierarchyType}
* @param parentGeoObjectTypeCode
* parent {@link GeoObjectType}.
* @param middleGeoObjectTypeCode
* middle child {@link GeoObjectType} after this method returns
* @param youngestGeoObjectTypeCode
* youngest child {@link GeoObjectType} after this method returns
*/
@Request(RequestType.SESSION)
public HierarchyType insertBetweenTypes(String sessionId, String hierarchyTypeCode, String parentGeoObjectTypeCode, String middleGeoObjectTypeCode, String youngestGeoObjectTypeCode) {
ServerHierarchyType type = ServerHierarchyType.get(hierarchyTypeCode);
ServerGeoObjectType parentType = ServerGeoObjectType.get(parentGeoObjectTypeCode);
ServerGeoObjectType middleType = ServerGeoObjectType.get(middleGeoObjectTypeCode);
List<ServerGeoObjectType> youngestTypes = Arrays.asList(youngestGeoObjectTypeCode.split(",")).stream().map(code -> ServerGeoObjectType.get(code.trim())).collect(Collectors.toList());
ServiceFactory.getGeoObjectTypeRelationshipPermissionService().enforceCanAddChild(type, parentType, middleType);
type.insertBetween(parentType, middleType, youngestTypes);
return type.toHierarchyType();
}
use of org.commongeoregistry.adapter.metadata.GeoObjectType in project geoprism-registry by terraframe.
the class HierarchyService method getHierarchiesForType.
@Request(RequestType.SESSION)
public JsonArray getHierarchiesForType(String sessionId, String code, Boolean includeTypes) {
ServerGeoObjectType geoObjectType = ServerGeoObjectType.get(code);
List<ServerHierarchyType> hierarchyTypes = ServerHierarchyType.getAll();
JsonArray hierarchies = new JsonArray();
HierarchyTypePermissionServiceIF htpService = ServiceFactory.getHierarchyPermissionService();
GeoObjectRelationshipPermissionServiceIF grpService = ServiceFactory.getGeoObjectRelationshipPermissionService();
for (ServerHierarchyType sHT : hierarchyTypes) {
if (htpService.canRead(sHT.getOrganizationCode())) {
List<GeoObjectType> parents = geoObjectType.getTypeAncestors(sHT, true);
if (parents.size() > 0 || geoObjectType.isRoot(sHT)) {
JsonObject object = new JsonObject();
object.addProperty("code", sHT.getCode());
object.addProperty("label", sHT.getDisplayLabel().getValue());
if (includeTypes) {
JsonArray pArray = new JsonArray();
for (GeoObjectType parent : parents) {
ServerGeoObjectType pType = ServerGeoObjectType.get(parent);
if (!pType.getCode().equals(geoObjectType.getCode()) && grpService.canViewChild(sHT.getOrganizationCode(), null, pType)) {
JsonObject pObject = new JsonObject();
pObject.addProperty("code", pType.getCode());
pObject.addProperty("label", pType.getLabel().getValue());
pArray.add(pObject);
}
}
object.add("parents", pArray);
}
hierarchies.add(object);
}
}
}
if (hierarchies.size() == 0) {
for (ServerHierarchyType sHT : hierarchyTypes) {
if (htpService.canWrite(sHT.getOrganizationCode())) {
if (geoObjectType.isRoot(sHT)) {
JsonObject object = new JsonObject();
object.addProperty("code", sHT.getCode());
object.addProperty("label", sHT.getDisplayLabel().getValue());
object.add("parents", new JsonArray());
hierarchies.add(object);
}
}
}
}
return hierarchies;
}
use of org.commongeoregistry.adapter.metadata.GeoObjectType in project geoprism-registry by terraframe.
the class GeoObjectImportConfiguration method fromJSON.
@Request
public GeoObjectImportConfiguration fromJSON(String json, boolean includeCoordinates) {
super.fromJSON(json);
SimpleDateFormat format = new SimpleDateFormat(GeoObjectImportConfiguration.DATE_FORMAT);
format.setTimeZone(GeoRegistryUtil.SYSTEM_TIMEZONE);
JSONObject config = new JSONObject(json);
JSONObject type = config.getJSONObject(TYPE);
JSONArray locations = config.has(LOCATIONS) ? config.getJSONArray(LOCATIONS) : new JSONArray();
JSONArray attributes = type.getJSONArray(GeoObjectType.JSON_ATTRIBUTES);
String code = type.getString(GeoObjectType.JSON_CODE);
ServerGeoObjectType got = ServerGeoObjectType.get(code);
this.setType(got);
this.setIncludeCoordinates(includeCoordinates);
this.setPostalCode(config.has(POSTAL_CODE) && config.getBoolean(POSTAL_CODE));
if (config.has(REVEAL_GEOMETRY_COLUMN)) {
this.setRevealGeometryColumn(config.getString(REVEAL_GEOMETRY_COLUMN));
}
try {
if (config.has(GeoObjectImportConfiguration.START_DATE)) {
this.setStartDate(format.parse(config.getString(GeoObjectImportConfiguration.START_DATE)));
}
if (config.has(GeoObjectImportConfiguration.END_DATE)) {
this.setEndDate(format.parse(config.getString(GeoObjectImportConfiguration.END_DATE)));
}
} catch (ParseException e) {
throw new ProgrammingErrorException(e);
}
if (config.has(HIERARCHY)) {
String hCode = config.getString(HIERARCHY);
if (hCode.length() > 0) {
ServerHierarchyType hierarchyType = ServerHierarchyType.get(hCode);
List<GeoObjectType> ancestors = got.getTypeAncestors(hierarchyType, true);
this.setHierarchy(hierarchyType);
if (ancestors.size() > 0) {
this.setRoot(null);
}
}
}
if (config.has(EXCLUSIONS)) {
JSONArray exclusions = config.getJSONArray(EXCLUSIONS);
for (int i = 0; i < exclusions.length(); i++) {
JSONObject exclusion = exclusions.getJSONObject(i);
String attributeName = exclusion.getString(AttributeType.JSON_CODE);
String value = exclusion.getString(VALUE);
this.addExclusion(attributeName, value);
}
}
for (int i = 0; i < attributes.length(); i++) {
JSONObject attribute = attributes.getJSONObject(i);
if (attribute.has(TARGET)) {
String attributeName = attribute.getString(AttributeType.JSON_CODE);
// In the case of a spreadsheet, this ends up being the column header
String target = attribute.getString(TARGET);
if (attribute.has("locale")) {
String locale = attribute.getString("locale");
if (this.getFunction(attributeName) == null) {
this.setFunction(attributeName, new LocalizedValueFunction());
}
LocalizedValueFunction function = (LocalizedValueFunction) this.getFunction(attributeName);
function.add(locale, new BasicColumnFunction(target));
} else {
this.setFunction(attributeName, new BasicColumnFunction(target));
}
}
}
for (int i = 0; i < locations.length(); i++) {
JSONObject location = locations.getJSONObject(i);
if (location.has(TARGET) && location.getString(TARGET).length() > 0 && location.has(MATCH_STRATEGY) && location.getString(MATCH_STRATEGY).length() > 0) {
String pCode = location.getString(AttributeType.JSON_CODE);
ServerGeoObjectType pType = ServerGeoObjectType.get(pCode);
ServerHierarchyType pHierarchy = got.findHierarchy(this.hierarchy, pType);
String target = location.getString(TARGET);
ParentMatchStrategy matchStrategy = ParentMatchStrategy.valueOf(location.getString(MATCH_STRATEGY));
// coming in with use BasicColumnFunctions
if (location.has("type") && location.getString("type").equals(ConstantShapefileFunction.class.getName())) {
this.addParent(new Location(pType, pHierarchy, new ConstantShapefileFunction(target), matchStrategy));
} else {
this.addParent(new Location(pType, pHierarchy, new BasicColumnFunction(target), matchStrategy));
}
}
}
// If the hierarchy is inherited, we need to resolve the hierarchy
// inheritance chain and set them properly on the Location objects
// To do this, we must start from the bottom and resolve upwards
ServerHierarchyType ht = this.hierarchy;
for (int i = this.locations.size() - 1; i >= 0; --i) {
Location loc = this.locations.get(i);
ht = got.findHierarchy(ht, loc.getType());
loc.setHierarchy(ht);
}
return this;
}
use of org.commongeoregistry.adapter.metadata.GeoObjectType in project geoprism-registry by terraframe.
the class ServerGeoObjectType method getTypeAncestors.
/**
* Returns all ancestors of a GeoObjectType
*
* @param hierarchyType
* The Hierarchy code
* @param includeInheritedTypes
* TODO
* @param GeoObjectType
* child
*
* @return
*/
public List<GeoObjectType> getTypeAncestors(ServerHierarchyType hierarchyType, Boolean includeInheritedTypes) {
List<GeoObjectType> ancestors = new LinkedList<GeoObjectType>();
Collection<com.runwaysdk.business.ontology.Term> list = GeoEntityUtil.getOrderedAncestors(Universal.getRoot(), this.getUniversal(), hierarchyType.getUniversalType());
list.forEach(term -> {
Universal parent = (Universal) term;
if (!parent.getKeyName().equals(Universal.ROOT) && !parent.getOid().equals(this.getUniversal().getOid())) {
ServerGeoObjectType sParent = ServerGeoObjectType.get(parent);
ancestors.add(sParent.getType());
if (includeInheritedTypes && sParent.isRoot(hierarchyType)) {
ServerHierarchyType inheritedHierarchy = sParent.getInheritedHierarchy(hierarchyType);
if (inheritedHierarchy != null) {
ancestors.addAll(0, sParent.getTypeAncestors(inheritedHierarchy, includeInheritedTypes));
}
}
}
});
if (ancestors.size() == 0) {
ServerGeoObjectType superType = this.getSuperType();
if (superType != null) {
return superType.getTypeAncestors(hierarchyType, includeInheritedTypes);
}
}
return ancestors;
}
Aggregations