From 479349a6b689399ecfef422e109180f7602f730c Mon Sep 17 00:00:00 2001 From: Robert Csakany Date: Fri, 2 Feb 2024 01:59:41 +0100 Subject: [PATCH] Improve actor transformation --- .../psm/modules/actor/actorType.etl | 659 +++++++++++++++++- 1 file changed, 639 insertions(+), 20 deletions(-) diff --git a/judo-tatami-jsl-jsl2psm/src/main/epsilon/transformations/psm/modules/actor/actorType.etl b/judo-tatami-jsl-jsl2psm/src/main/epsilon/transformations/psm/modules/actor/actorType.etl index 174bff3e..3f9bdf78 100644 --- a/judo-tatami-jsl-jsl2psm/src/main/epsilon/transformations/psm/modules/actor/actorType.etl +++ b/judo-tatami-jsl-jsl2psm/src/main/epsilon/transformations/psm/modules/actor/actorType.etl @@ -1,40 +1,659 @@ -/* -////////////////////////////////////////////////// -// Unmapped actor object type -////////////////////////////////////////////////// +@abstract +rule CreateAbstractActorType + transform s: JSL!ActorDeclaration + to t: JUDOPSM!AbstractActorType { + t.name = s.name; + t.transferObjectType = s.getPrincipal().getTransferDeclarationEquivalent(); + s.getPrincipal().getTransferDeclarationEquivalent().actorType = t; + t.realm = s.getRealm().value.value; + s.eContainer.getModelRoot().elements.add(t); +} + @greedy -rule CreateUnmappedActorTransferObjectType +rule CreateActorType transform s: JSL!ActorDeclaration - to t: JUDOPSM!UnmappedTransferObjectType { - guard: s.map.isUndefined() + to t: JUDOPSM!ActorType + extends CreateAbstractActorType { + guard: s.getPrincipal().isDefined() and not s.getPrincipal().map.isDefined() - t.setId("(jsl/" + s.getId() + ")/CreateUnmappedActorTransferObjectType"); + t.setId("(jsl/" + s.getId() + ")/CreateActorType"); - t.name = s.name; + log.debug("Created ActorType: " + t.name); +} + +@greedy +rule CreateMappedActorType + transform s: JSL!ActorDeclaration + to t: JUDOPSM!MappedActorType + extends CreateAbstractActorType { + guard: s.getPrincipal().isDefined() and s.getPrincipal().map.isDefined() + t.setId("(jsl/" + s.getId() + ")/CreateMappedActorType"); + + t.entityType = s.getPrincipal().map.entity.getEntityDeclarationEquivalent(); + + // TODO: Annotation or parameter? + t.kind = "EMAIL"; + t.managed = true; + + if (s.getGuard().isDefined()) { + t.filter = s.equivalent("CreateFilterExpressionForMappedActorType"); + } + + log.debug("Created ActorType: " + t.name); +} + +@greedy +rule CreateActorTypeWithoutPrincipal + transform s: JSL!ActorDeclaration + to t: JUDOPSM!ActorType { + guard: s.getPrincipal().isUndefined() + + t.setId("(jsl/" + s.getId() + ")/CreateActorTypeWithoutPrincipal"); + + if (s.getGuard().isDefined()) { + t.filter = s.equivalent("CreateFilterExpressionForMappedActorType"); + } s.eContainer.getModelRoot().elements.add(t); + log.debug("Created MappedTransferObjectType: " + t.name); +} + - log.debug("Created UnmappedTransferObjectType: " + t.name); +@lazy +rule CreateFilterExpressionForMappedActorType + transform s: JSL!ActorDeclaration + to t: JUDOPSM!LogicalExpressionType { + t.setId("(jsl/" + s.getId() + ")/CreateFilterExpressionForMappedActorType"); + t.expression = expressionUtils.getJqlForExpression(s.getGuard().expression, entityNamePrefix, entityNamePostfix); + + log.debug("Created Logical Expression Type for Mapped Actor Type filter: " + s.name); } +@greedy +rule CreateMetadataType + transform s: JSL!ActorDeclaration + to t: JUDOPSM!UnmappedTransferObjectType { + t.name = "_MetadataFor" + s.name; + t.setId("(jsl/" + s.getId() + ")/CreateMetadataType"); + s.eContainer.getModelRoot().elements.add(t); +} -////////////////////////////////////////////////// -// Mapped actor object type -////////////////////////////////////////////////// @greedy -rule CreateMappedActorTransferObjectType +rule CreateMetadataTypeSecurity transform s: JSL!ActorDeclaration - to t: JUDOPSM!MappedTransferObjectType { - guard: s.map.isDefined() + to t: JUDOPSM!TransferObjectRelation { - t.setId("(jsl/" + s.getId() + ")/CreateMappedActorTransferObjectType"); + t.setId("(jsl/" + s.getId() + ")/CreateMetadataTypeSecurity"); - t.entityType = s.map.entity.getPSMEquivalent(); + t.name = "security"; + t.embedded = true; + t.cardinality = s.equivalent("CreateMetadataTypeSecurityCardinality"); + t.target = s.equivalent("CreateMetadataSecurityType"); + s.equivalent("CreateMetadataType").relations.add(t); +} - t.name = s.name; +@greedy +rule CreateMetadataTypeSecurityCardinality + transform s: JSL!ActorDeclaration + to t: JUDOPSM!Cardinality { + + t.setId("(jsl/" + s.getId() + ")/CreateMetadataTypeSecurityCardinality"); + t.lower = 0; + t.upper = -1; +} + +@greedy +rule CreateMetadataSecurityType + transform s: JSL!ActorDeclaration + to t: JUDOPSM!UnmappedTransferObjectType { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityType"); + t.name = "_MetadataSecurityFor" + s.name; s.eContainer.getModelRoot().elements.add(t); +} - log.debug("Created MappedTransferObjectType: " + t.name); + +@lazy +rule CreateActorStringType + transform s: String + to t : JUDOPSM!StringType { + + t.setId("(jsl/" + s.replaceAll("::", "_") + ")/CreateActorStringType"); + t.name = "ActorStringType"; + t.maxLength = 8192; + s.getUniqueModelName().equivalent("CreateModelPackages").elements.add(t); + log.debug("CreateActorStringType type created: " + t.name); +} + + +@greedy +rule CreateMetadataSecurityTypeName + transform s: JSL!ActorDeclaration + to t: JUDOPSM!TransferAttribute { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityTypeName"); + t.name = "name"; + t.dataType = "extensions".equivalent("CreateActorStringType"); + t.required = true; + s.equivalent("CreateMetadataSecurityType").attributes.add(t); +} + + +@greedy +rule CreateMetadataSecurityTypeOpenIdConfigurationUrl + transform s: JSL!ActorDeclaration + to t: JUDOPSM!TransferAttribute { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityTypeOpenIdConfigurationUrl"); + t.name = "openIdConfigurationUrl"; + t.dataType = "extensions".equivalent("CreateActorStringType"); + t.required = false; + s.equivalent("CreateMetadataSecurityType").attributes.add(t); +} + +@greedy +rule CreateMetadataSecurityTypeIssuer + transform s: JSL!ActorDeclaration + to t: JUDOPSM!TransferAttribute { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityTypeIssuer"); + t.name = "issuer"; + t.dataType = "extensions".equivalent("CreateActorStringType"); + t.required = false; + s.equivalent("CreateMetadataSecurityType").attributes.add(t); +} + +@greedy +rule CreateMetadataSecurityTypeAuthEndpoint + transform s: JSL!ActorDeclaration + to t: JUDOPSM!TransferAttribute { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityTypeAuthEndpoint"); + t.name = "authEndpoint"; + t.dataType = "extensions".equivalent("CreateActorStringType"); + t.required = false; + s.equivalent("CreateMetadataSecurityType").attributes.add(t); +} + +@greedy +rule CreateMetadataSecurityTypeTokenEndpoint + transform s: JSL!ActorDeclaration + to t: JUDOPSM!TransferAttribute { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityTypeTokenEndpoint"); + t.name = "tokenEndpoint"; + t.dataType = "extensions".equivalent("CreateActorStringType"); + t.required = false; + s.equivalent("CreateMetadataSecurityType").attributes.add(t); +} + +@greedy +rule CreateMetadataSecurityTypeLogoutEndpoint + transform s: JSL!ActorDeclaration + to t: JUDOPSM!TransferAttribute { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityTypeLogoutEndpoint"); + t.name = "logoutEndpoint"; + t.dataType = "extensions".equivalent("CreateActorStringType"); + t.required = false; + s.equivalent("CreateMetadataSecurityType").attributes.add(t); +} + +@greedy +rule CreateMetadataSecurityTypeClientId + transform s: JSL!ActorDeclaration + to t: JUDOPSM!TransferAttribute { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityTypeClientId"); + t.name = "clientId"; + t.dataType = "extensions".equivalent("CreateActorStringType"); + t.required = false; + s.equivalent("CreateMetadataSecurityType").attributes.add(t); +} + +@greedy +rule CreateMetadataSecurityTypeClientBaseUrl + transform s: JSL!ActorDeclaration + to t: JUDOPSM!TransferAttribute { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityTypeClientBaseUrl"); + t.name = "clientBaseUrl"; + t.dataType = "extensions".equivalent("CreateActorStringType"); + t.required = false; + s.equivalent("CreateMetadataSecurityType").attributes.add(t); +} + +@greedy +rule CreateMetadataSecurityTypeDefaultScopes + transform s: JSL!ActorDeclaration + to t: JUDOPSM!TransferAttribute { + t.setId("(jsl/" + s.getId() + ")/CreateMetadataSecurityTypeDefaultScopes"); + t.name = "defaultScopes"; + t.dataType = "extensions".equivalent("CreateActorStringType"); + t.required = false; + s.equivalent("CreateMetadataSecurityType").attributes.add(t); +} + +@greedy +rule CreateGetMetadataOperationForActorType + transform s: JSL!ActorDeclaration + to t : JUDOPSM!UnboundOperation { + t.setId("(jsl/" + s.getId() + ")/CreateGetMetadataOperationForActorType"); + t.name = "_metadata"; + t.behaviour = s.equivalent("CreateGetMetadataOperationForActorTypeBehaviour"); + s.getActorDeclarationEquivalent().operations.add(t); +} + +@lazy +rule CreateGetMetadataOperationForActorTypeBehaviour + transform s: JSL!ActorDeclaration + to t : JUDOPSM!TransferOperationBehaviour { + t.setId("(jsl/" + s.getId() + ")/CreateGetMetadataOperationForActorTypeBehaviour"); + t.behaviourType = JUDOPSM!TransferOperationBehaviourType#GET_METADATA; + t.owner = s.getActorDeclarationEquivalent(); +} +/* +@greedy +rule CreateGetMetadataOperationOutputParameterForActorType + transform s: JSL!ActorDeclaration + to t : JUDOPSM!Parameter { + t.setId("(esm/" + s.getId() + ")/GetMetadataOperationOutputParameterForActorType"); + + t.name = "output"; + t.type = s.equivalent("CreateMetadataType"); + t.cardinality = new JUDOPSM!Cardinality; + t.cardinality.setId("(esm/" + s.getId() + ")/GetMetadataOperationOutputParameterForActorType/Cardinality"); + t.cardinality.lower = 0; + t.cardinality.upper = 1; + + s.equivalent("CreateGetMetadataOperationForActorType").output = t; +} + +@greedy +rule CreateGetPrincipalOperationForActorType + transform s: JSL!ActorDeclaration + to t : JUDOPSM!UnboundOperation { + guard: s.getPrincipal().isDefined() + + t.setId("(esm/" + s.getId() + ")/GetPrincipalOperationForActorType"); + + t.name = "_principal"; + t.behaviour = new JUDOPSM!TransferOperationBehaviour; + t.behaviour.setId("(esm/" + s.getId() + ")/GetPrincipalOperationForActorType/Behaviour"); + t.behaviour.behaviourType = JUDOPSM!TransferOperationBehaviourType#GET_PRINCIPAL; + t.behaviour.owner = s.getPSMEquivalent(); + + s.getPSMEquivalent().operations.add(t); +} + +@greedy +rule CreateGetPrincipalOperationOutputParameterForActorType + transform s: JSL!ActorDeclaration + to t : JUDOPSM!Parameter { + guard: s.getPrincipal().isDefined() + + t.setId("(esm/" + s.getId() + ")/GetPrincipalOperationOutputParameterForActorType"); + + t.name = "output"; + t.type = s.principal.getPSMTransferObjectTypeEquivalent(); + t.cardinality = new JUDOPSM!Cardinality; + t.cardinality.setId("(esm/" + s.getId() + ")/GetPrincipalOperationOutputParameterForActorType/Cardinality"); + t.cardinality.lower = 0; + t.cardinality.upper = 1; + + s.equivalent("CreateGetPrincipalOperationForActorType").output = t; +} + + +*/ + + +/* +@abstract +rule CreateTransferObjectRelationFromAccess + transform s: ESM!Access + to t: JUDOPSM!TransferObjectRelation + extends CreateNamedElement { + t.cardinality = s.equivalent("CreateCardinalityForReferenceTypedElement"); + t.access = true; + t.target = s.target.getPSMTransferObjectTypeEquivalent(); + s.eContainer.getPSMEquivalent().relations.add(t); + + if (s.isCreateAllowed()) { + t.embeddedCreate = true; + } + if (s.isUpdateAllowed()) { + t.embeddedUpdate = true; + } + if (s.isDeleteAllowed()) { + t.embeddedDelete = true; + } + log.debug("Created access relation: " + t.name + " for actor type: " + t.eContainer.name); +} + +rule CreateAccessTransferObjectRelationWithoutBinding + transform s: ESM!Access + to t: JUDOPSM!TransferObjectRelation + extends CreateTransferObjectRelationFromAccess { + guard: s.accessType == ESM!AccessType#ALL + + t.setId("(esm/" + s.getId() + ")/AccessTransferObjectRelationWithoutBinding"); + +} + +rule CreateAccessTransferObjectRelationWithBinding + transform s: ESM!Access + to t: JUDOPSM!TransferObjectRelation + extends CreateTransferObjectRelationFromAccess { + guard: s.accessType == ESM!AccessType#DERIVED + + t.setId("(esm/" + s.getId() + ")/AccessTransferObjectRelationWithBinding"); + t.binding = s.getPSMTransferObjectRelationBindingEquivalent(); +} +*/ + + +/* + + + + + + + + + + + + + + + + + + +*/ + + +/* +import "../namespace/namespace.etl"; +import "../derived/referenceAccessor.etl"; +import "../../../../operations/_importAll.eol"; + +@abstract +rule CreateAbstractActorType + transform s: ESM!ActorType + to t: JUDOPSM!AbstractActorType + extends CreateNamespaceElement { + t.transferObjectType = s.principal.getPSMTransferObjectTypeEquivalent(); + s.principal.getPSMTransferObjectTypeEquivalent().actorType = t; + if (not s.isEffectiveAnonymous()) { + t.realm = s.realm; + } +} + +rule CreateActorTypeClaim + transform s : ESM!Claim + to t : JUDOPSM!TransferAttribute { + guard: not s.eContainer.isEffectiveAnonymous() + + t.setId("(esm/" + s.getId() + ")/Claim"); + + t.name = s.attribute.name; + t.claimType = s.claimType.asString(); + t.dataType = s.attribute.dataType.getPSMEquivalent(); + t.required = s.attribute.required; + + if (s.attribute.binding.isDefined() and s.attribute.memberType == ESM!MemberType#MAPPED) { + t.binding = s.attribute.equivalent("CreateTransferAttributeFromBound").binding; + } else if (s.attribute.eContainer.isKindOf(ESM!EntityType) and s.attribute.memberType == ESM!MemberType#STORED) { + t.binding = s.attribute.equivalent("CreateAttribute"); + } else if (s.attribute.binding.isDefined() and s.attribute.binding.eContainer.isKindOf(ESM!EntityType) and s.attribute.memberType == ESM!MemberType#STORED) { + t.binding = s.attribute.equivalent("CreateTransferAttributeFromAttributeForDefaultTransferObjectType").binding; + } else if (s.attribute.eContainer.isKindOf(ESM!EntityType) and s.attribute.memberType == ESM!MemberType#DERIVED) { + t.binding = s.attribute.equivalent("CreateDataProperty"); + } else if (s.attribute.eContainer.isTypeOf(ESM!TransferObjectType) and s.attribute.memberType == ESM!MemberType#DERIVED) { + t.binding = s.attribute.equivalent("CreateDataPropertyForTransferAttributeBinding"); + } else if (s.attribute.memberType <> ESM!MemberType#TRANSIENT) { + log.error("Unsupported claim attribute: " + s.attribute.eContainer.getNamespaceElementFQName() + "." + s.attribute.name); + } + + s.eContainer.getPSMEquivalent().attributes.add(t); + + log.debug("Created ActorType Claim: " + t.name); +} + +rule CreateActorType + transform s: ESM!ActorType + to t: JUDOPSM!ActorType + extends CreateAbstractActorType { + guard: s.principal.isDefined() and not s.principal.isMapped() + + t.setId("(esm/" + s.getId() + ")/ActorType"); + + log.debug("Created ActorType: " + t.name); +} + +@lazy +rule CreateMetadataType + transform s: ESM!ActorType + to t: JUDOPSM!UnmappedTransferObjectType + extends CreateNamespaceElement { + t.name = "_MetadataFor" + s.name; + + t.setId("(esm/" + s.getId() + ")/MetadataType"); + + var security = new JUDOPSM!TransferObjectRelation(); + security.setId("(esm/" + s.getId() + ")/MetadataType/Security"); + security.name = "security"; + security.embedded = true; + security.cardinality = new JUDOPSM!Cardinality; + security.cardinality.setId("(esm/" + s.getId() + ")/MetadataType/Security/Cardinality"); + security.cardinality.lower = 0; + security.cardinality.upper = -1; + security.target = s.equivalent("CreateMetadataSecurityType"); + + t.relations.add(security); +} + +@lazy +rule CreateMetadataSecurityType + transform s: ESM!ActorType + to t: JUDOPSM!UnmappedTransferObjectType + extends CreateNamespaceElement { + t.setId("(esm/" + s.getId() + ")/MetadataSecurityType"); + + t.name = "_MetadataSecurityFor" + s.name; + + var m : ESM!Model = ESM!Model.all.first(); + + var name = new JUDOPSM!TransferAttribute(); + name.setId("(esm/" + s.getId() + ")/MetadataSecurityType/Name"); + name.name = "name"; + name.dataType = m.equivalent("CreateAutoGeneratedStringType"); + name.required = true; + + var openIdConfigurationUrl = new JUDOPSM!TransferAttribute(); + openIdConfigurationUrl.setId("(esm/" + s.getId() + ")/MetadataSecurityType/OpenIdConfigurationUrl"); + openIdConfigurationUrl.name = "openIdConfigurationUrl"; + openIdConfigurationUrl.dataType = m.equivalent("CreateAutoGeneratedStringType"); + openIdConfigurationUrl.required = false; + + var issuer = new JUDOPSM!TransferAttribute(); + issuer.setId("(esm/" + s.getId() + ")/" + s.name + "/Issuer"); + issuer.name = "issuer"; + issuer.dataType = m.equivalent("CreateAutoGeneratedStringType"); + issuer.required = false; + + var authEndpoint = new JUDOPSM!TransferAttribute(); + authEndpoint.setId("(esm/" + s.getId() + ")/MetadataSecurityType/AuthEndpoint"); + authEndpoint.name = "authEndpoint"; + authEndpoint.dataType = m.equivalent("CreateAutoGeneratedStringType"); + authEndpoint.required = false; + + var tokenEndpoint = new JUDOPSM!TransferAttribute(); + tokenEndpoint.setId("(esm/" + s.getId() + ")/MetadataSecurityType/TokenEndpoint"); + tokenEndpoint.name = "tokenEndpoint"; + tokenEndpoint.dataType = m.equivalent("CreateAutoGeneratedStringType"); + tokenEndpoint.required = false; + + var logoutEndpoint = new JUDOPSM!TransferAttribute(); + logoutEndpoint.setId("(esm/" + s.getId() + ")/MetadataSecurityType/LogoutEndpoint"); + logoutEndpoint.name = "logoutEndpoint"; + logoutEndpoint.dataType = m.equivalent("CreateAutoGeneratedStringType"); + logoutEndpoint.required = false; + + var clientId = new JUDOPSM!TransferAttribute(); + clientId.setId("(esm/" + s.getId() + ")/MetadataSecurityType/ClientId"); + clientId.name = "clientId"; + clientId.dataType = m.equivalent("CreateAutoGeneratedStringType"); + clientId.required = true; + + var clientBaseUrl = new JUDOPSM!TransferAttribute(); + clientBaseUrl.setId("(esm/" + s.getId() + ")/MetadataSecurityType/ClientBaseUrl"); + clientBaseUrl.name = "clientBaseUrl"; + clientBaseUrl.dataType = m.equivalent("CreateAutoGeneratedStringType"); + clientBaseUrl.required = false; + + var defaultScopes = new JUDOPSM!TransferAttribute(); + defaultScopes.setId("(esm/" + s.getId() + ")/MetadataSecurityType/DefaultScopes"); + defaultScopes.name = "defaultScopes"; + defaultScopes.dataType = m.equivalent("CreateAutoGeneratedStringType"); + defaultScopes.required = true; + + t.attributes.add(name); + t.attributes.add(openIdConfigurationUrl); + t.attributes.add(issuer); + t.attributes.add(authEndpoint); + t.attributes.add(tokenEndpoint); + t.attributes.add(logoutEndpoint); + t.attributes.add(clientId); + t.attributes.add(clientBaseUrl); + t.attributes.add(defaultScopes); +} + +rule CreateMappedActorType + transform s: ESM!ActorType + to t: JUDOPSM!MappedActorType + extends CreateAbstractActorType { + guard: s.principal.isDefined() and s.principal.isMapped() + + t.setId("(esm/" + s.getId() + ")/MappedActorType"); + + t.entityType = s.principal.mapping.target.getPSMEquivalent(); + t.managed = s.managed; + t.kind = s.kind.asString(); + + if (s.isActiveExpression.isDefined() and s.isActiveExpression.trim().length() > 0) { + t.filter = s.equivalent("CreateFilterExpressionForMappedActorType"); + } + + log.debug("Created ActorType: " + t.name); +} + +rule CreateActorTypeWithoutPrincipal + transform s: ESM!ActorType + to t: JUDOPSM!ActorType + extends CreateNamespaceElement { + guard: s.principal.isUndefined() + + t.setId("(esm/" + s.getId() + ")/ActorTypeWithoutPrincipal"); + + if (not s.isEffectiveAnonymous()) { + t.realm = s.realm; + } +} + +@abstract +rule CreateTransferObjectRelationFromAccess + transform s: ESM!Access + to t: JUDOPSM!TransferObjectRelation + extends CreateNamedElement { + t.cardinality = s.equivalent("CreateCardinalityForReferenceTypedElement"); + t.access = true; + t.target = s.target.getPSMTransferObjectTypeEquivalent(); + s.eContainer.getPSMEquivalent().relations.add(t); + + if (s.isCreateAllowed()) { + t.embeddedCreate = true; + } + if (s.isUpdateAllowed()) { + t.embeddedUpdate = true; + } + if (s.isDeleteAllowed()) { + t.embeddedDelete = true; + } + log.debug("Created access relation: " + t.name + " for actor type: " + t.eContainer.name); +} + +rule CreateAccessTransferObjectRelationWithoutBinding + transform s: ESM!Access + to t: JUDOPSM!TransferObjectRelation + extends CreateTransferObjectRelationFromAccess { + guard: s.accessType == ESM!AccessType#ALL + + t.setId("(esm/" + s.getId() + ")/AccessTransferObjectRelationWithoutBinding"); + +} + +rule CreateAccessTransferObjectRelationWithBinding + transform s: ESM!Access + to t: JUDOPSM!TransferObjectRelation + extends CreateTransferObjectRelationFromAccess { + guard: s.accessType == ESM!AccessType#DERIVED + + t.setId("(esm/" + s.getId() + ")/AccessTransferObjectRelationWithBinding"); + t.binding = s.getPSMTransferObjectRelationBindingEquivalent(); +} + +@lazy +rule CreateFilterExpressionForMappedActorType + transform s : ESM!ActorType + to t: JUDOPSM!LogicalExpressionType { + t.setId("(esm/" + s.getId() + ")/FilterExpressionForMappedActorType"); + t.expression = s.isActiveExpression; + log.debug("Created Logical Expression Type for Mapped Actor Type filter: " + s.name); } + */ + +/* + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +*/ \ No newline at end of file