publication example code

crm-example/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<artifactId>parent</artifactId>
+		<groupId>de.tudresden.inf.st.rmsc</groupId>
+		<version>1.0.0</version>
+	</parent>
+
+    <artifactId>crm-example</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+    <name>CRM EXAMPLE</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+        <java.version>1.8</java.version>
+    </properties>
+
+    <dependencies>
+        <!-- SCALA LANGUAGE -->
+        <dependency>
+            <groupId>org.scala-lang</groupId>
+            <artifactId>scala-library</artifactId>
+            <version>2.12.8</version>
+        </dependency>
+        <!-- SCROLL LANGUAGE -->
+        <dependency>
+            <groupId>com.github.max-leuthaeuser</groupId>
+            <artifactId>scroll_2.12</artifactId>
+            <version>1.8</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>1.7.30</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-simple -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-nop</artifactId>
+            <version>1.7.30</version>
+        </dependency>
+        <!-- THE CONFLICT RESOLVER INCLUDING RSYNC -->
+        <dependency>
+            <groupId>de.tudresden.inf.st.rmsc</groupId>
+            <artifactId>conflictresolver</artifactId>
+            <version>1.0.0</version>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/src/main/resources/libs/conflictresolver-1.0.0.jar</systemPath>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>5.5.2</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+            <plugins>
+                <plugin>
+                    <groupId>net.alchim31.maven</groupId>
+                    <artifactId>scala-maven-plugin</artifactId>
+                    <version>3.1.3</version>
+                    <executions>
+                        <execution>
+                            <goals>
+                                <goal>compile</goal>
+                                <goal>testCompile</goal>
+                            </goals>
+                        </execution>
+                    </executions>
+                </plugin>
+            </plugins>
+        <pluginManagement>
+            <plugins>
+        <!-- JUNIT -->
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-surefire-plugin</artifactId>
+                    <version>3.0.0-M3</version>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+</project>

crm-example/src/main/resources/application.properties

+# Needs to be disabled until https://jira.spring.io/browse/SPR-12542 is fixed
+spring.mvc.ignore-default-model-on-redirect=false
+
+spring.jpa.hibernate.ddl-auto=update
+spring.datasource.url=jdbc:h2:~/test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
+spring.datasource.driverClassName=org.h2.Driver
+#spring.datasource.username=sa
+#spring.datasource.password=sa
+spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
+
+# Logging
+logging.file=crm.log
+
+logging.level.root=ERROR

crm-example/src/main/scala/de/tudresden/inf/st/crme/Application.scala

+package de.tudresden.inf.st.crme
+
+import de.tudresden.inf.st.crme.models.modelA.PresenceEmployee
+import de.tudresden.inf.st.crme.models.modelB.{Member, Team}
+import de.tudresden.inf.st.crme.models.modelC.SimpleEmployee
+import de.tudresden.inf.st.crme.rsync.compartments.{CrmModelsConstructionCompartment, CrmModelsDestructionCompartment, CrmModelsSyncCompartment}
+import de.tudresden.inf.st.crme.rsync.constants.ModelConstants
+import org.rosi_project.model_management.core.{ModelElementLists, PlayerSync, SynchronizationCompartment}
+import org.rosi_project.model_management.sync.lock.{ElementLock, ElementLockProvider, SynchronizationAware}
+import org.rosi_project.model_management.util.UuidUtil
+import org.slf4j.LoggerFactory
+import scroll.internal.Compartment
+
+object Application extends App {
+
+
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/models/MetaModels.scala

+package de.tudresden.inf.st.crme.models
+
+import de.tudresden.inf.st.crme.models.modelA.{Employee, PresenceEmployee, RemoteEmployee}
+import de.tudresden.inf.st.crme.models.modelB.{Member, Team}
+import de.tudresden.inf.st.crme.models.modelC.SimpleEmployee
+import de.tudresden.inf.st.crme.rsync.compartments.{CrmModelsConstructionCompartment, CrmModelsDestructionCompartment, CrmModelsSyncCompartment}
+import de.tudresden.inf.st.crme.rules.customrules.{LeaderCustomReferenceCreationRule, MemberCustomDeletionRule, MemberCustomReferenceCreationRule, MemberCustomReferenceDeletionRule}
+import de.tudresden.inf.st.crme.rules.systemrules.{OwnerDataConflictSystemRule, TsDataConflictSystemRule, TsReferenceConflictSystemRule}
+import org.rosi_project.model_management.core.{Cardinality, Field, ModelElementLists, ModelInformation, SynchronizationCompartment}
+import org.rosi_project.model_management.sync.conflict.customrules.CustomRuleExecutor
+import org.rosi_project.model_management.sync.conflict.systemrules.SystemRuleExecutor
+
+import scala.reflect.classTag
+
+object MetaModels {
+  def reset(): Unit = {
+    ModelElementLists.dropAll()
+    initCrmMetaModels()
+    System.gc()
+  }
+
+  def initCrmMetaModels(): Unit ={
+    // Model A
+    ModelInformation.add(
+      ModelInformation(classTag[PresenceEmployee].runtimeClass, classTag[Employee].runtimeClass),
+      ModelInformation(classTag[Employee].runtimeClass, null, Field.primitives(classTag[String], "fullName", "birthday", "address") ++
+        Field.primitives(classTag[Float], "salary")),
+      ModelInformation(classTag[RemoteEmployee].runtimeClass, classTag[Employee].runtimeClass))
+
+    // Model B
+    ModelInformation.add(
+      ModelInformation(classTag[Team].runtimeClass, null, Field.primitives(classTag[String], "teamName") ++
+        Set(Field.association(classTag[Member], "members", Cardinality.Many,
+          (team, member) => team.asInstanceOf[Team].addMember(member.asInstanceOf[Member]),
+          (team, member) => team.asInstanceOf[Team].removeMember(member.asInstanceOf[Member])),
+
+          Field.association(classTag[Member], "leader", Cardinality.One,
+            (team, leader) => team.asInstanceOf[Team].setLeader(leader.asInstanceOf[Member]),
+            (team, leader) => team.asInstanceOf[Team].setLeader(null))
+        )),
+      ModelInformation(classTag[Member].runtimeClass, null, Field.primitives(classTag[String], "birthday", "firstName", "companyLocation", "lastName", "address") ++
+        Set(Field.association(classTag[Team], "leaderInTeam", Cardinality.One,
+          (member, team) => member.asInstanceOf[Member].setLeaderInTeam(team.asInstanceOf[Team]),
+          (member, team) => member.asInstanceOf[Member].setLeaderInTeam(null)),
+
+          Field.association(classTag[Member], "memberInTeam", Cardinality.One,
+            (member, team) => member.asInstanceOf[Member].setMemberInTeam(team.asInstanceOf[Team]),
+            (member, team) => member.asInstanceOf[Member].setMemberInTeam(null)),
+        )))
+
+    // Model C
+    ModelInformation.add(ModelInformation(classTag[SimpleEmployee].runtimeClass, null, Field.primitives(classTag[String], "birthday", "team", "fullName", "address") ++
+      Field.primitives(classTag[Boolean], "isRemoteEmployee")))
+
+    // RSync Setup
+    SynchronizationCompartment.reset()
+    SynchronizationCompartment.createRoleManager()
+    SynchronizationCompartment.changeConstructionRule(CrmModelsConstructionCompartment)
+    SynchronizationCompartment.changeDestructionRule(CrmModelsDestructionCompartment)
+    SynchronizationCompartment.addSynchronizationRule(new CrmModelsSyncCompartment())
+
+    SystemRuleExecutor.addSystemDataRule(new TsDataConflictSystemRule, new OwnerDataConflictSystemRule)
+    SystemRuleExecutor.addSystemReferenceRule(new TsReferenceConflictSystemRule)
+
+    CustomRuleExecutor.addCustomDeletionRule(new MemberCustomDeletionRule)
+    CustomRuleExecutor.addCustomReferenceRule(new MemberCustomReferenceCreationRule, new MemberCustomReferenceDeletionRule, new LeaderCustomReferenceCreationRule)
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/models/modelA/Employee.scala

+package de.tudresden.inf.st.crme.models.modelA
+
+import org.rosi_project.model_management.core
+import org.rosi_project.model_management.core.{ConflictResolvable, Field, MapSerializable, ModelInformation, PlayerSync, PrimitiveField}
+import org.rosi_project.model_management.sync.lock.{ElementLock, SynchronizationAware}
+
+import scala.reflect.classTag
+
+abstract class Employee (protected var fullName: String, protected var birthday: String,
+                protected var address: String, protected var salary: Float,
+                         lock: ElementLock, guid: String, owner: String) extends ConflictResolvable(lock, guid, owner) {
+
+  def this(guid: String, lock: ElementLock, data: Map[String, String]) = this(data("fullName"), data("birthday"),
+    data("address"), data("salary").toFloat, lock, guid, data("owner"))
+
+  override def serialize: Map[String, String] = Map("fullName" -> fullName, "birthday" -> birthday, "adress" -> address, "salary" -> salary.toString) ++ super.serialize()
+
+  override def unserialize(data: Map[String, String]): Unit ={
+    super.unserialize(data)
+    if(data.contains("fullName")) fullName = data("fullName")
+    if(data.contains("birthday")) birthday = data("birthday")
+    if(data.contains("address")) address = data("address")
+    if(data.contains("salary")) salary = data("salary").toFloat
+  }
+
+  def syncFieldsToOtherModels(): Unit = {
+    +this syncEmployeeFields()
+  }
+
+  def getFullName(): String = {
+    fullName
+  }
+
+  def setFullName(s : String): Unit = {
+    fullName = s
+  }
+
+  def getSalary(): Float = {
+    salary
+  }
+
+  def setSalary(f : Float): Unit = {
+    salary = f
+  }
+
+  def getAddress(): String = {
+    address
+  }
+
+  def setAddress(s : String): Unit = {
+    address = s
+  }
+
+  def getBirthday(): String = {
+    birthday
+  }
+
+  def setBirthday(s : String): Unit = {
+    birthday = s
+  }
+
+  def getRelated: Set[PlayerSync] = {
+    val relatedElementsMetaObject = +this getRelatedElements()
+    val relatedObjects: Set[PlayerSync] = relatedElementsMetaObject.right.get.head.right.get
+    relatedObjects
+  }
+
+  override def toString(): String = {
+    return "Employee: " + fullName + " D: " + deleted
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/models/modelA/PresenceEmployee.scala

+package de.tudresden.inf.st.crme.models.modelA
+
+import org.rosi_project.model_management.core.{Field, ModelInformation}
+import org.rosi_project.model_management.sync.lock.ElementLock
+
+class PresenceEmployee(fullName: String, birthday: String,
+                       address: String, salary: Float,
+                       lock: ElementLock, guid: String, owner: String)
+  extends Employee (fullName, birthday, address, salary, lock, guid, owner ) {
+
+  def this(guid: String, lock: ElementLock, data: Map[String, String]) = this(data("fullName"), data("birthday"),
+    data("address"), data("salary").toFloat, lock, guid, data("owner"))
+
+  override def toString(): String = {
+    var lockData: String = ""
+
+    if(this.lock != null){
+      lockData += this.lock.getId()
+    }else{
+      lockData += "---"
+    }
+
+    return "PresenceEmployee: " + getFullName() + " pbirthday: " + getBirthday() + " paddress: " +
+      getAddress()  + " psalary: " + getSalary()  + " guid: " + guid + " D: " + deleted + " lock: " + lockData
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/models/modelA/RemoteEmployee.scala

+package de.tudresden.inf.st.crme.models.modelA
+
+import org.rosi_project.model_management.core.ModelInformation
+import org.rosi_project.model_management.sync.lock.ElementLock
+
+import scala.reflect.classTag
+
+class RemoteEmployee (fullName: String, birthday: String,
+                      address: String, salary: Float, lock: ElementLock,
+                      guid: String, owner: String)
+  extends Employee (fullName, birthday, address, salary, lock, guid, owner) {
+
+  def this(guid: String, lock: ElementLock, data: Map[String, String]) = this(data("fullName"), data("birthday"),
+    data("address"), data("salary").toFloat, lock, guid, data("owner"))
+
+  override def toString(): String = {
+
+    var lockData: String = ""
+
+    if(this.lock != null){
+      lockData += this.lock.getId()
+    }else{
+      lockData += "---"
+    }
+
+    return "RemoteEmployee: " + getFullName() + " rbirthday: " + getBirthday() + " raddress: " +
+      getAddress()  + " rSalary: " + getSalary()  + " reGuid: " + guid + " D: " + deleted + " lock: " + lockData
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/models/modelB/Member.scala

+package de.tudresden.inf.st.crme.models.modelB
+
+import org.rosi_project.model_management.core.{ConflictResolvable, ModelInformation, PlayerSync}
+import org.rosi_project.model_management.sync.lock.{ElementLock, SynchronizationAware}
+
+class Member (protected var birthday: String, protected var firstName: String, protected  var companyLocation : String,
+              protected var lastName: String, protected var address: String,
+              protected var leaderInTeam: Team, protected var memberInTeam: Team,
+              lock: ElementLock, guid: String, owner: String) extends ConflictResolvable (lock, guid, owner){
+
+  def this(guid: String, lock: ElementLock, map: Map[String, String]) = this(map("birthday"), map("fullname"), map("companyLocation"), map("lastName"),
+    map("address"), ModelInformation.fromGuid(map("leaderInTeam")).asInstanceOf[Team], ModelInformation.fromGuid(map("memberInTeam")).asInstanceOf[Team], lock, guid, map("owner"))
+
+  override def serialize: Map[String, String] = Map("birthday" -> birthday, "firstName" -> firstName, "lastName" -> lastName,
+    "companyLocation" -> companyLocation, "address" -> address, "leaderInTeam" -> ModelInformation.getGuid(leaderInTeam),
+    "memberInTeam" -> ModelInformation.getGuid(memberInTeam)) ++ super.serialize()
+
+  override def unserialize(data: Map[String, String]): Unit = {
+    super.unserialize(data)
+    birthday = data("birthday")
+    firstName = data("firstName")
+    lastName = data("lastName")
+    companyLocation = data("companyLocation")
+    address = data("address")
+    leaderInTeam = ModelInformation.fromGuid(data("leaderInTeam")).asInstanceOf[Team]
+    memberInTeam = ModelInformation.fromGuid(data("memberInTeam")).asInstanceOf[Team]
+  }
+
+  def syncFieldsToOtherModels(): Unit = {
+    +this syncMemberFields()
+  }
+
+  def getCompanyLocation(): String = {
+    companyLocation
+  }
+
+  def getFullName() = s"${firstName} ${lastName}"
+
+  def setCompanyLocation(s : String): Unit = {
+    companyLocation = s
+  }
+
+  def getLastName(): String = {
+    lastName
+  }
+
+  def setLastName(s : String): Unit = {
+    lastName = s
+  }
+
+  def getFirstName(): String = {
+    firstName
+  }
+
+  def setFirstName(s : String): Unit = {
+    firstName = s
+  }
+
+  def getAddress(): String = {
+    address
+  }
+
+  def setAddress(s : String): Unit = {
+    address = s
+  }
+
+  def getBirthday(): String = {
+    birthday
+  }
+
+  def setBirthday(s : String): Unit = {
+    birthday = s
+  }
+
+  def getLeaderInTeam(): Team = {
+    leaderInTeam
+  }
+
+  def setLeaderInTeam(t : Team): Unit = {
+    leaderInTeam = t
+    +this syncLeaderInTeam()
+  }
+
+  def getMemberInTeam(): Team = {
+    memberInTeam
+  }
+
+  def setMemberInTeam(t : Team): Unit = {
+    memberInTeam = t
+    +this syncMemberInTeam()
+  }
+
+  def setMemberWithoutSyncInTeam(t : Team): Unit = {
+    memberInTeam = t
+  }
+
+  def getRelated: Set[PlayerSync] = {
+    val relatedElementsMetaObject = +this getRelatedElements()
+    val relatedObjects: Set[PlayerSync] = relatedElementsMetaObject.right.get.head.right.get
+    relatedObjects
+  }
+
+  override def toString: String = {
+
+    var lockData: String = ""
+    var teamName = "---"
+
+    if(memberInTeam != null){
+      teamName = memberInTeam.getTeamName()
+    }
+
+    if(this.lock != null){
+      lockData += this.lock.getId()
+    }else{
+      lockData += "---"
+    }
+
+    return "Member: " + guid + " ts: "  + ts + " rv: " + rv + " owner: " + owner  + " memberteam: "+
+      teamName + " firstname: " + firstName + " lastName: " + lastName + " birthday: " +
+      birthday  + " companyLocation: " + companyLocation  + " address: " + address + " D: " + deleted + " lock: " + lockData
+  }
+}
\ No newline at end of file

crm-example/src/main/scala/de/tudresden/inf/st/crme/models/modelB/Team.scala

+package de.tudresden.inf.st.crme.models.modelB
+
+import de.tudresden.inf.st.crme.models.modelA.Employee
+import org.rosi_project.model_management.core.{AssociationField, Cardinality, ConflictResolvable, Field, ModelInformation, PlayerSync}
+import org.rosi_project.model_management.sync.lock.{ElementLock, SynchronizationAware}
+
+import scala.::
+import scala.reflect.classTag
+
+class Team(protected var teamName: String, protected var leader: Member,
+           protected var members: Set[Member],
+           tLock: ElementLock, tGuid: String, tOwner: String) extends ConflictResolvable (tLock, tGuid, tOwner){
+
+  def this(guid: String, lock: ElementLock, data: Map[String, String]) = this(data("teamName"),
+    ModelInformation.fromGuid(data("leader")).asInstanceOf[Member], ModelInformation.fromGuids(classTag[Member], data("members")).map(x => x.asInstanceOf[Member]), lock, guid, data("owner"))
+
+  override def serialize(): Map[String, String] = Map("teamName" -> teamName, "members" -> ModelInformation.getGuids(members.toSet[SynchronizationAware]),
+    "leader" -> ModelInformation.getGuid(leader)) ++ super.serialize()
+
+  override def unserialize(data: Map[String, String]): Unit = {
+    super.unserialize(data)
+    if(data.contains("teamName")) teamName = data("teamName")
+    if(data.contains("members")) members = ModelInformation.fromGuids(classTag[Member], data("members")).map(x => x.asInstanceOf[Member])
+    if(data.contains("leader")) leader = ModelInformation.fromGuid(data("leader")).asInstanceOf[Member]
+  }
+
+  def syncFieldsToOtherModels(): Unit = {
+    +this syncTeamFields()
+  }
+
+  def setLeader(m: Member): Unit = {
+    leader = m
+  }
+
+  def getLeader(): Member = {
+    leader
+  }
+
+  def setTeamName(s: String): Unit = {
+    teamName = s
+  }
+
+  def getTeamName(): String = {
+    teamName
+  }
+
+  def getMembers(): Set[Member] = {
+    members
+  }
+
+  def addMember(m: Member): Unit = {
+    addMemberWithoutSync(m)
+    +this syncAddMember (m)
+  }
+
+  def addMemberWithoutSync(m: Member): Unit = {
+
+    if(members == null){
+      members = Set()
+    }
+
+    require(m != null)
+    require(!members.contains(m))
+    members += m
+  }
+
+  def removeMember(m: Member): Unit = {
+    removeMemberWithoutSync(m)
+    +this syncRemoveMember (m)
+  }
+
+  def addMemberOnlySync(m: Member): Unit = +this syncAddMember(m)
+
+  def removeMemberOnlySync(m: Member): Unit = +this syncRemoveMember(m)
+
+  def removeMemberWithoutSync(m: Member): Unit = {
+    require(m != null)
+    require(members.contains(m))
+    members -= m
+  }
+
+  def getRelated: Set[PlayerSync] = {
+    val relatedElementsMetaObject = +this getRelatedElements()
+    val relatedObjects: Set[PlayerSync] = relatedElementsMetaObject.right.get.head.right.get
+    relatedObjects
+  }
+
+  override def toString: String = {
+
+    var mString: String = ""
+
+    getMembers().foreach { m =>
+      mString += " ++ Member: "
+      mString += m.getLastName
+    }
+
+    var lockData: String = ""
+
+    if(this.lock != null){
+      lockData += this.lock.getId()
+    }else{
+      lockData += "---"
+    }
+
+    return "Team: " + guid + " ts: "  + ts + " rv: " + rv + " owner: " + tOwner + " teamname: " + teamName + " leader: "+
+      leader + " D: " + deleted + " lock: " + lockData + " ** With members:" + mString
+  }
+
+}
\ No newline at end of file

crm-example/src/main/scala/de/tudresden/inf/st/crme/models/modelC/SimpleEmployee.scala

+package de.tudresden.inf.st.crme.models.modelC
+
+import de.tudresden.inf.st.crme.models.modelA.Employee
+import org.rosi_project.model_management.core.{ConflictResolvable, Field, ModelInformation, PlayerSync}
+import org.rosi_project.model_management.sync.lock.{ElementLock, SynchronizationAware}
+
+
+class SimpleEmployee  (protected var birthday: String, protected  var isRemoteEmployee : Boolean, var team: String,
+                       protected var fullName: String, protected var address: String, lock: ElementLock,
+                       guid: String, owner: String) extends ConflictResolvable (lock, guid, owner){
+
+  def this(guid: String, lock: ElementLock, data: Map[String, String]) = this(data("birthday"),
+    data("isRemoteEmployee").toBoolean, data("team"), data("fullName"), data("address"), lock, guid, data("owner"))
+
+  override def serialize(): Map[String, String] = Map("isRemoteEmployee" -> isRemoteEmployee.toString, "fullName" -> fullName,
+    "birthday" -> birthday, "address" -> address, "team" -> team) ++ super.serialize()
+
+  override def unserialize(data: Map[String, String]): Unit = {
+    super.unserialize(data)
+    isRemoteEmployee = data("isRemoteEmployee").toBoolean
+    fullName = data("fullName")
+    birthday = data("birthday")
+    address = data("address")
+    team = data("team")
+  }
+
+  def syncFieldsToOtherModels(): Unit = {
+    +this syncSimpleEmployeeFields()
+  }
+
+  def getIsRemoteEmployee(): Boolean = {
+    isRemoteEmployee
+  }
+
+  def setIsRemoteEmployee(b : Boolean): Unit = {
+    isRemoteEmployee = b
+  }
+
+  def getTeam(): String = {
+    team
+  }
+
+  def setTeam(s : String): Unit = {
+    team = s
+  }
+
+  def getFullName(): String = {
+    fullName
+  }
+
+  def setFullName(s : String): Unit = {
+    fullName = s
+  }
+
+  def getAddress(): String = {
+    address
+  }
+
+  def setAddress(s : String): Unit = {
+    address = s
+  }
+
+  def getBirthday(): String = {
+    birthday
+  }
+
+  def setBirthday(s : String): Unit = {
+    birthday = s
+  }
+
+  def getRelated: Set[PlayerSync] = {
+    val relatedElementsMetaObject = +this getRelatedElements()
+    val relatedObjects: Set[PlayerSync] = relatedElementsMetaObject.right.get.head.right.get
+    relatedObjects
+  }
+
+  override def toString: String = {
+
+    var lockData: String = ""
+
+    if(this.lock != null){
+      lockData += this.lock.getId()
+    }else{
+      lockData += "---"
+    }
+
+    return "SimpleEmployee: " + guid + " ts: "  + ts + " rv: " + rv + " owner: " + owner  +
+      " isRemoteEmployee: " + isRemoteEmployee + " fullName: " + fullName + " birthday: " +
+      birthday  +  " address: " + address + " team: " + team + " D: " + deleted + " lock: " + lockData
+  }
+}
\ No newline at end of file

crm-example/src/main/scala/de/tudresden/inf/st/crme/rsync/compartments/CrmModelsConstructionCompartment.scala

+package de.tudresden.inf.st.crme.rsync.compartments
+
+import de.tudresden.inf.st.crme.models.modelA.{Employee, PresenceEmployee, RemoteEmployee}
+import de.tudresden.inf.st.crme.models.modelB.{Member, Team}
+import de.tudresden.inf.st.crme.models.modelC.SimpleEmployee
+import org.rosi_project.model_management.core.{ModelElementLists, PlayerSync, SynchronizationCompartment}
+import org.rosi_project.model_management.sync.IConstructionCompartment
+import org.rosi_project.model_management.sync.lock.{ElementLock, SynchronizationAware}
+import org.rosi_project.model_management.sync.roles.{IConstructor, IRoleManager}
+import org.rosi_project.model_management.util.UuidUtil
+
+object CrmModelsConstructionCompartment extends IConstructionCompartment {
+
+  override def getRuleName: String = "CrmModelsConstruction"
+
+  override def getConstructorForClassName(classname: Object): IConstructor = {
+
+    if (classname.isInstanceOf[Member]) {
+      return new MemberConstruct()
+    }
+
+    if (classname.isInstanceOf[Team]) {
+      return new TeamConstruct()
+    }
+
+    if (classname.isInstanceOf[SimpleEmployee]) {
+      return new SimpleEmployeeConstruct()
+    }
+
+    if(classname.isInstanceOf[Employee] || classname.isInstanceOf[PresenceEmployee] || classname.isInstanceOf[RemoteEmployee]){
+      return new EmployeeConstruct()
+    }
+
+    null
+  }
+
+  class EmployeeConstruct() extends IConstructor {
+
+    override def construct(comp: PlayerSync, man: IRoleManager): Unit = {
+
+      val birthday: String = +this getBirthday()
+      val fullName: String = +this getFullName()
+      val address: String = +this getAddress()
+      val owner: String = +this getOwner()
+      val splitName: Array[String] = fullName.split(" ")
+      var firstName: String = null
+      var lastName: String = null
+
+      if (splitName.size == 2) {
+        firstName = splitName(0);
+        lastName = splitName(1);
+      }
+
+      val lock: ElementLock = comp.asInstanceOf[SynchronizationAware].lock
+
+      val simpleEmployee: SimpleEmployee = new SimpleEmployee(birthday, comp.isInstanceOf[RemoteEmployee], null,
+        fullName, address, lock, UuidUtil.generateUuid(), owner)
+      simpleEmployee.ts = 1
+      simpleEmployee.rv = 1
+
+      val member: Member = new Member(birthday, firstName, "DEFAULT", lastName, address
+        , null, null, lock, UuidUtil.generateUuid(), owner)
+      member.ts = 1
+      member.rv = 1
+
+      createContainerElement(true, true, comp, man)
+      createContainerElement(false, true, simpleEmployee, SynchronizationCompartment.createRoleManager())
+      createContainerElement(false, true, member, SynchronizationCompartment.createRoleManager())
+
+      makeCompleteConstructionProcess(containers)
+    }
+  }
+
+  class MemberConstruct() extends IConstructor {
+
+    override def construct(comp: PlayerSync, man: IRoleManager): Unit = {
+
+      val birthday: String = +this getBirthday()
+      val firstName: String = +this getFirstName()
+      val companyLocation: String = +this getCompanyLocation()
+      val lastName: String = +this getLastName()
+      val address: String = +this getAddress()
+      val memberInTeam: Team = +this getMemberInTeam()
+      val owner: String = +this getOwner()
+
+      val isRemoteWorker = (companyLocation == null)
+      val fullName = firstName + " " + lastName
+
+      val lock: ElementLock = comp.asInstanceOf[SynchronizationAware].lock
+
+      var tName: String = null
+
+      if(memberInTeam != null){
+        tName = memberInTeam.getTeamName()
+      }
+
+      val simpleEmployee: SimpleEmployee = new SimpleEmployee(birthday, isRemoteWorker, tName,
+        fullName, address, lock, UuidUtil.generateUuid(), owner)
+      simpleEmployee.ts = 1
+      simpleEmployee.rv = 1
+
+      var employee: Employee = null
+      var teamName: String = null
+
+      if(memberInTeam != null){
+        teamName = memberInTeam.getTeamName()
+      }
+
+      if(companyLocation == null){
+        employee = new RemoteEmployee(fullName, birthday, address, -1f, lock, UuidUtil.generateUuid(), owner)
+      }else{
+        employee = new PresenceEmployee(fullName, birthday, address, -1f, lock, UuidUtil.generateUuid(), owner)
+      }
+
+      employee.ts = 1
+      employee.rv = 1
+
+      createContainerElement(true, true, comp, man)
+      createContainerElement(false, true, simpleEmployee, SynchronizationCompartment.createRoleManager())
+      createContainerElement(false, true, employee, SynchronizationCompartment.createRoleManager())
+
+      makeCompleteConstructionProcess(containers)
+    }
+  }
+
+  class TeamConstruct() extends IConstructor {
+
+    override def construct(comp: PlayerSync, man: IRoleManager): Unit = {
+
+      comp.ts = 1
+      comp.rv = 1
+
+      createContainerElement(true, true, comp, man)
+      makeCompleteConstructionProcess(containers)
+
+    }
+  }
+
+  class SimpleEmployeeConstruct() extends IConstructor {
+
+    override def construct(comp: PlayerSync, man: IRoleManager): Unit = {
+
+      val birthday: String = +this getBirthday()
+      val isRemoteEmployee: Boolean = +this getIsRemoteEmployee()
+      val fullName: String = +this getFullName()
+      val address: String = +this getAddress()
+      val owner: String = +this getOwner()
+      val teamName: String = +this getTeam()
+
+      val lock: ElementLock = comp.asInstanceOf[SynchronizationAware].lock
+      val splitName: Array[String] = fullName.split(" ")
+      var firstName: String = null
+      var lastName: String = null
+      var companyLocation: String = null
+
+      if (splitName.size == 2) {
+        firstName = splitName(0);
+        lastName = splitName(1);
+      }
+
+      if(!isRemoteEmployee){
+        companyLocation = "DEFAULT"
+      }
+
+/*      val team: Team = new Team(teamName, null, null, lock, UuidUtil.generateUuid(), owner)
+      team.ts = 1
+      team.rv = 1 */
+
+      val member: Member = new Member(birthday, firstName, companyLocation, lastName, address
+        , null, null, lock, UuidUtil.generateUuid(), owner)
+      member.ts = 1
+      member.rv = 1
+
+//      team.addMemberWithoutSync(member)
+
+      var employee: Employee = null
+
+      if(companyLocation == null){
+        employee = new RemoteEmployee(fullName, birthday, address, -1f, lock, UuidUtil.generateUuid(), owner)
+      }else{
+        employee = new PresenceEmployee(fullName, birthday, address, -1f, lock, UuidUtil.generateUuid(), owner)
+      }
+
+      employee.ts = 1
+      employee.rv = 1
+
+      createContainerElement(true, true, comp, man)
+      createContainerElement(false, true, member, SynchronizationCompartment.createRoleManager())
+      // createContainerElement(false, true, team, SynchronizationCompartment.createRoleManager())
+      createContainerElement(false, true, employee, SynchronizationCompartment.createRoleManager())
+
+      makeCompleteConstructionProcess(containers)
+    }
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/rsync/compartments/CrmModelsDestructionCompartment.scala

+package de.tudresden.inf.st.crme.rsync.compartments
+
+import org.rosi_project.model_management.core.{ModelElementLists, PlayerSync}
+import org.rosi_project.model_management.sync.IDestructionCompartment
+import org.rosi_project.model_management.sync.roles.{IDestructor, IRoleManager}
+import org.slf4j.LoggerFactory
+
+object CrmModelsDestructionCompartment extends IDestructionCompartment{
+
+  override def getRuleName: String = "CrmModelsDestruction"
+
+  override def getDestructorForClassName(classname: Object): IDestructor = {
+    new DeleteRoleAndConnections();
+  }
+
+  /**
+   * Destruction-role that deletes objects in all models
+   */
+  class DeleteRoleAndConnections() extends IDestructor {
+
+    val logger = LoggerFactory.getLogger(classOf[DeleteRoleAndConnections])
+
+    def deleteRoleFunction(): Unit = {
+
+      logger.info("%%%%%%% Executing DeleteRoleAndConnections %%%%%%%")
+      //get the list of related manager
+      var relatedManagers: Set[IRoleManager] = (+this).getRelatedManager()
+
+      //clear all lists from the related managers
+      (+this).clearListsOfRelatedManager()
+
+      //delete also all related elements
+      relatedManagers.foreach { m =>
+        (+m).deleteObjectFromSynchro()
+      }
+
+      //send notification about deletion
+      (+this).deletionNotification()
+
+      //clear now the related manager list
+      (+this).clearRelatedManager()
+      //delete all roles this element has
+      val player = this.player
+      if (player.isRight) {
+        val test: PlayerSync = player.right.get.asInstanceOf[PlayerSync]
+        ModelElementLists.removeElement(test)
+        val roles = test.roles()
+        roles.foreach { r =>
+          r.remove()
+        }
+      }
+    }
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/rsync/compartments/CrmModelsSyncCompartment.scala

+package de.tudresden.inf.st.crme.rsync.compartments
+
+import de.tudresden.inf.st.crme.models.modelA.Employee
+import de.tudresden.inf.st.crme.models.modelB.{Member, Team}
+import de.tudresden.inf.st.crme.models.modelC.SimpleEmployee
+import de.tudresden.inf.st.crme.rsync.constants.ModelConstants
+import org.rosi_project.model_management.core.{ModelElementLists, PlayerSync}
+import org.rosi_project.model_management.sync.ISyncCompartment
+import org.rosi_project.model_management.sync.lock.{ElementLock, ElementLockProvider, LockResult}
+import org.rosi_project.model_management.sync.roles.ISyncRole
+import org.rosi_project.model_management.util.UuidUtil
+import org.slf4j.LoggerFactory
+
+import scala.sys.error
+
+class CrmModelsSyncCompartment extends ISyncCompartment {
+
+  override def getRuleName: String = "CrmModelsSync"
+
+  val logger = LoggerFactory.getLogger(classOf[CrmModelsSyncCompartment])
+
+  override protected def getFirstRole(classname: Object): ISyncRole = {
+    if (classname.isInstanceOf[Employee] || classname.isInstanceOf[Member] || classname.isInstanceOf[Team]
+      || classname.isInstanceOf[SimpleEmployee])
+      return new Sync()
+    null
+  }
+
+  override def isFirstIntegration(classname: Object): Boolean = {
+    (classname.isInstanceOf[Employee] || classname.isInstanceOf[Member] || classname.isInstanceOf[Team]
+      || classname.isInstanceOf[SimpleEmployee])
+  }
+
+  override def getNewInstance: ISyncCompartment = new CrmModelsSyncCompartment
+
+  class Sync() extends ISyncRole {
+
+    override def getOuterCompartment: ISyncCompartment = CrmModelsSyncCompartment.this
+
+    def getRelatedElements(): Set[PlayerSync] = {
+      var relatedObjects: Set[PlayerSync] = Set()
+      getSyncer().foreach { a =>
+        if (a.player.right.get.isInstanceOf[PlayerSync]) {
+          relatedObjects += a.player.right.get.asInstanceOf[PlayerSync]
+        }
+      }
+      relatedObjects
+    }
+
+    def syncEmployeeFields(): Unit = {
+      ElementLockProvider.synchronized {
+        if (!doSync) {
+          // start sync
+          doSync = true
+
+          val birthday: String = +this getBirthday()
+          val fullName: String = +this getFullName()
+          val address: String = +this getAddress()
+          val owner: String = +this getOwner()
+          val splitName: Array[String] = fullName.split(" ")
+          var firstName: String = null
+          var lastName: String = null
+
+          if (splitName.size == 2) {
+            firstName = splitName(0);
+            lastName = splitName(1);
+          }
+
+          getSyncer().foreach { syncer =>
+
+            val ts: Int = (+syncer).ts
+
+            if (syncer.player.right.get.isInstanceOf[SimpleEmployee]) {
+              (+syncer).setFullName(fullName)
+              (+syncer).setBirthday(birthday)
+              (+syncer).setAddress(address)
+
+              if (ts == Int.MaxValue) {
+                (+syncer).ts = 1
+              } else {
+                (+syncer).ts = ts + 1
+              }
+            }
+
+            if (syncer.player.right.get.isInstanceOf[Member]) {
+              (+syncer).setFirstName(firstName)
+              (+syncer).setLastName(lastName)
+              (+syncer).setBirthday(birthday)
+              (+syncer).setAddress(address)
+              (+syncer).setOwner(owner)
+
+              if (ts == Int.MaxValue) {
+                (+syncer).ts = 1
+              } else {
+                (+syncer).ts = ts + 1
+              }
+            }
+          }
+        }
+        doSync = false
+      }
+    }
+
+    def syncSimpleEmployeeFields(): Unit = {
+      ElementLockProvider.synchronized {
+        if (!doSync) {
+          // start sync
+          doSync = true
+
+          val birthday: String = +this getBirthday()
+          val fullName: String = +this getFullName()
+          val address: String = +this getAddress()
+          val owner: String = +this getOwner()
+          val isRemoteEmployee: Boolean = +this getIsRemoteEmployee()
+          val teamName: String = +this getTeam()
+          val splitName: Array[String] = fullName.split(" ")
+          var firstName: String = null
+          var lastName: String = null
+
+          if (splitName.size == 2) {
+            firstName = splitName(0);
+            lastName = splitName(1);
+          }
+
+          getSyncer().foreach { syncer =>
+
+            val ts: Int = (+syncer).ts
+            val guid: String = (+syncer).guid
+
+            if (syncer.player.right.get.isInstanceOf[Employee]) {
+              (+syncer).setFullName(fullName)
+              (+syncer).setOwner(owner)
+              (+syncer).setAddress(address)
+              (+syncer).setBirthday(birthday)
+
+              if (ts == Int.MaxValue) {
+                (+syncer).ts = 1
+              } else {
+                (+syncer).ts = ts + 1
+              }
+            }
+
+            if (syncer.player.right.get.isInstanceOf[Member]) {
+              (+syncer).setFirstName(firstName)
+              (+syncer).setLastName(lastName)
+              (+syncer).setBirthday(birthday)
+              (+syncer).setAddress(address)
+              (+syncer).setOwner(owner)
+              val currentLocation: String = (+syncer).getCompanyLocation()
+
+              if (!isRemoteEmployee && currentLocation != null) {
+                (+syncer).setCompanyLocation("DEFAULT")
+              }
+
+/*              val t: Team = (+syncer).getMemberInTeam()
+
+              var found: Boolean = false
+              if (((t != null && t.getTeamName() != teamName) || t == null) && teamName != null) {
+                ModelElementLists.getDirectElementsFromType(ModelConstants.TEAM_MODEL_TYPE).foreach { i =>
+                  if (i.asInstanceOf[Team].getTeamName() == teamName) {
+                    found = true
+
+                    var lockSuccess: Boolean = false
+                    var lockRes: LockResult = null
+
+                    while (!lockSuccess){
+                      val lockResIter = ElementLockProvider.provideLock(i.asInstanceOf[Team].guid)
+                      lockRes = lockResIter
+                      lockSuccess = lockResIter.success
+                    }
+
+                    (+syncer).setMemberWithoutSyncInTeam(i)
+                    // enables bi-directional sync ..
+                    i.asInstanceOf[Team].addMemberWithoutSync(ModelElementLists.getElementByGuid(guid).asInstanceOf[Member])
+                    i.asInstanceOf[Team].rv = i.asInstanceOf[Team].rv + 1
+
+                    ElementLockProvider.removeLocksFromElement(lockRes.lock.getId(), i.asInstanceOf[Team].guid)
+                  } else if(i.asInstanceOf[Team].getMembers().exists(x => x.guid == guid)){
+                    // Remove member from old team
+                    val member = ModelElementLists.getElementByGuid(guid).asInstanceOf[Member]
+                    i.asInstanceOf[Team].removeMemberWithoutSync(member)
+                    // Remove team if now empty
+                    // if(i.asInstanceOf[Team].getMembers().isEmpty) i.asInstanceOf[Team].deleteObjectFromSynchro()
+                  }
+                }
+              } */
+
+              if (ts == Int.MaxValue) {
+                (+syncer).ts = 1
+              } else {
+                (+syncer).ts = ts + 1
+              }
+            }
+          }
+        }
+        doSync = false
+      }
+    }
+
+    def syncMemberFields(): Unit = {
+      ElementLockProvider.synchronized {
+        if (!doSync) {
+          // start sync
+          doSync = true
+
+          val birthday: String = +this getBirthday()
+          val firstName: String = +this firstName()
+          val lastName: String = +this lastName()
+          val address: String = +this getAddress()
+          val owner: String = +this getOwner()
+          val companyLocation: String = +this getCompanyLocation()
+
+          getSyncer().foreach { syncer =>
+
+            val ts: Int = (+syncer).ts
+
+            if (syncer.player.right.get.isInstanceOf[Employee]) {
+              (+syncer).setFullName(firstName + " " + lastName)
+              (+syncer).setOwner(owner)
+              (+syncer).setAddress(address)
+              (+syncer).setBirthday(birthday)
+
+              if (ts == Int.MaxValue) {
+                (+syncer).ts = 1
+              } else {
+                (+syncer).ts = ts + 1
+              }
+            }
+
+            if (syncer.player.right.get.isInstanceOf[SimpleEmployee]) {
+              (+syncer).setFullName(firstName + " " + lastName)
+              (+syncer).setBirthday(birthday)
+              (+syncer).setAddress(address)
+
+              if (companyLocation == null) {
+                (+syncer).setIsRemoteEmployee(true)
+              } else {
+                (+syncer).setIsRemoteEmployee(false)
+              }
+
+              if (ts == Int.MaxValue) {
+                (+syncer).ts = 1
+              } else {
+                (+syncer).ts = ts + 1
+              }
+            }
+          }
+        }
+        doSync = false
+      }
+    }
+
+    def syncTeamFields(): Unit = {
+      ElementLockProvider.synchronized {
+        if (!doSync) {
+          // start sync
+          doSync = true
+          // nothing to do
+        }
+        doSync = false
+      }
+    }
+
+    def syncLeaderInTeam(): Unit = {
+      ElementLockProvider.synchronized {
+        if (!doSync) {
+          // start sync
+          doSync = true
+          // nothing to do
+        }
+        doSync = false
+      }
+    }
+
+    def syncMemberInTeam(): Unit = {
+      ElementLockProvider.synchronized {
+        if (!doSync) {
+          // start sync
+          doSync = true
+          var memberInTeam: Team = (+this).getMemberInTeam()
+
+          getSyncer().foreach { syncer =>
+
+            val ts: Int = (+syncer).ts
+
+            if (syncer.player.right.get.isInstanceOf[SimpleEmployee]) {
+
+              if (memberInTeam != null) {
+                (+syncer).setTeam(memberInTeam.getTeamName())
+              } else {
+                (+syncer).setTeam(null)
+              }
+
+              if (ts == Int.MaxValue) {
+                (+syncer).ts = 1
+              } else {
+                (+syncer).ts = ts + 1
+              }
+            }
+          }
+          doSync = false
+        }
+      }
+    }
+
+    def syncAddMember(member: PlayerSync): Unit = {
+      ElementLockProvider.synchronized {
+        if (!doSync) {
+
+          // start sync
+          doSync = true
+
+          val name: String = +this getTeamName()
+
+          member.getRelatedObjects().foreach {
+            case employee: SimpleEmployee =>
+              employee.setTeam(name)
+            case _ =>
+          }
+        }
+        doSync = false
+      }
+    }
+  }
+
+  def syncRemoveMember(member: PlayerSync): Unit = {
+    ElementLockProvider.synchronized {
+      if (!doSync) {
+
+        // start sync
+        doSync = true
+
+        member.getRelatedObjects().foreach {
+          case employee: SimpleEmployee =>
+            employee.setTeam(null)
+          case _ =>
+        }
+      }
+      doSync = false
+    }
+  }
+}
\ No newline at end of file

crm-example/src/main/scala/de/tudresden/inf/st/crme/rsync/constants/ModelConstants.scala

+package de.tudresden.inf.st.crme.rsync.constants
+
+object ModelConstants {
+
+  final val SIMPLE_EMPLOYEE_MODEL_TYPE = "de.tudresden.inf.st.crme.models.modelC.SimpleEmployee"
+
+  final val MEMBER_MODEL_TYPE = "de.tudresden.inf.st.crme.models.modelB.Member"
+  final val TEAM_MODEL_TYPE = "de.tudresden.inf.st.crme.models.modelB.Team"
+
+  final val EMPLOYEE_MODEL_TYPE = "de.tudresden.inf.st.crme.models.modelA.Employee"
+  final val PRESENCE_EMPLOYEE_MODEL_TYPE = "de.tudresden.inf.st.crme.models.modelA.PresenceEmployee"
+  final val REMOTE_EMPLOYEE_MODEL_TYPE = "de.tudresden.inf.st.crme.models.modelA.RemoteEmployee"
+
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/rules/customrules/LeaderCustomReferenceCreationRule.scala

+package de.tudresden.inf.st.crme.rules.customrules
+
+import de.tudresden.inf.st.crme.models.modelA.Employee
+import de.tudresden.inf.st.crme.models.modelB.Team
+import org.rosi_project.model_management.core.PlayerSync
+import org.rosi_project.model_management.sync.conflict.customrules.ICustomReferenceRule
+import org.slf4j.LoggerFactory
+import scroll.internal.Compartment
+
+class LeaderCustomReferenceCreationRule extends ICustomReferenceRule {
+
+  override def getRuleName(): String = "LeaderCustomReferenceCreationRule"
+
+  override def isReferenceDeletionRule(): Boolean = false
+
+  override def matchesRule(referencingElement: PlayerSync, referencedElement: PlayerSync, senderRv: Int, senderOwner: String, collection: String): Boolean = {
+    var isEligible = false
+
+    new Compartment {
+      referencingElement match {
+        case _: Team => {
+          if (collection == "leader") {
+            val related: Set[AnyRef] = (+referencingElement).getRelatedElements()
+            related.foreach {
+              case s: Employee => isEligible  = s.getSalary() >= 3000
+            }
+          }
+        }
+      }
+    }
+
+    return isEligible
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/rules/customrules/MemberCustomDeletionRule.scala

+package de.tudresden.inf.st.crme.rules.customrules
+
+import de.tudresden.inf.st.crme.models.modelB.{Member, Team}
+import org.rosi_project.model_management.core.{ModelElementLists, PlayerSync}
+import org.rosi_project.model_management.sync.conflict.customrules.ICustomDeletionRule
+import org.rosi_project.model_management.sync.lock.SynchronizationAware
+import org.slf4j.LoggerFactory
+
+class MemberCustomDeletionRule extends ICustomDeletionRule {
+
+  private val logger = LoggerFactory.getLogger(classOf[MemberCustomDeletionRule])
+
+  /**
+   * get name of this rule
+   */
+  def getRuleName(): String = "MemberCustomDeletionRule"
+
+  /**
+   * return true if no task references comment (the element)
+   */
+  def matchesRule(element: PlayerSync, senderOwner: String): Boolean = {
+
+    if (element.isInstanceOf[Member]) {
+      val elems: Set[SynchronizationAware] = ModelElementLists
+        .getDirectElementsFromType("de.tudresden.inf.st.crme.models.modelB.Team")
+      elems.foreach{ e =>
+        val team: Team = e.asInstanceOf[Team]
+        team.getMembers().foreach{ c=>
+          if(c.guid == element.asInstanceOf[SynchronizationAware].guid && team.getLeader() == null){
+            logger.info("Custom-Deletion-Rule does not allow deletion")
+            return false
+          }
+        }
+      }
+      logger.info("Custom-Deletion-Rule allows deletion")
+      return true
+    }
+
+    logger.info("Custom-Deletion-Rule does not allow deletion")
+    false
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/rules/customrules/MemberCustomReferenceCreationRule.scala

+package de.tudresden.inf.st.crme.rules.customrules
+
+import de.tudresden.inf.st.crme.models.modelB.Team
+import org.rosi_project.model_management.core.PlayerSync
+import org.rosi_project.model_management.sync.conflict.customrules.ICustomReferenceRule
+import org.rosi_project.model_management.sync.lock.SynchronizationAware
+import org.slf4j.LoggerFactory
+
+class MemberCustomReferenceCreationRule extends ICustomReferenceRule{
+
+  private val log = LoggerFactory.getLogger(classOf[MemberCustomReferenceCreationRule])
+
+  override def getRuleName(): String = "MemberCustomReferenceCreationRule"
+
+  override def isReferenceDeletionRule(): Boolean = false
+
+  override def matchesRule(referencingElement: PlayerSync, referencedElement: PlayerSync, senderRv: Int, senderOwner: String, collection: String): Boolean = {
+
+    if (referencingElement.isInstanceOf[Team]) {
+      val team: Team = referencingElement.asInstanceOf[Team]
+      team.getMembers().foreach { c =>
+        if (c.guid == referencedElement.asInstanceOf[SynchronizationAware].guid) {
+          // REF-ADD-ADD
+          log.info("Detected conflict (REF-ADD-ADD): " + team.guid)
+          return false
+        }
+      }
+      return true
+    }
+    false
+  }
+}

crm-example/src/main/scala/de/tudresden/inf/st/crme/rules/customrules/MemberCustomReferenceDeletionRule.scala

+package de.tudresden.inf.st.crme.rules.customrules
+
+import de.tudresden.inf.st.crme.models.modelB.Team
+import org.rosi_project.model_management.core.PlayerSync
+import org.rosi_project.model_management.sync.conflict.customrules.ICustomReferenceRule
+import org.slf4j.LoggerFactory
+import org.rosi_project.model_management.sync.lock._
+
+
+class MemberCustomReferenceDeletionRule extends ICustomReferenceRule {
+
+  private val logger = LoggerFactory.getLogger(classOf[MemberCustomReferenceDeletionRule])
+
+  /**
+   * returns the name of this rule
+   */
+  def getRuleName(): String = "MemberCustomReferenceCreationRule"
+
+  /**
+   * true -> it is a ReferenceCreationRule
+   */
+  def isReferenceDeletionRule(): Boolean = true
+
+  /**
+   * return true if rule allows deletion of reference
+   */
+  def matchesRule(referencingElement: PlayerSync, referencedElement: PlayerSync, senderRv: Int, senderOwner: String, collection: String): Boolean = {
+    if (referencingElement.isInstanceOf[Team]) {
+      val team: Team = referencingElement.asInstanceOf[Team]
+      team.getMembers().foreach { c =>
+        if (c.guid == referencedElement.asInstanceOf[SynchronizationAware].guid) {
+          return true
+        }
+      }
+      // REF-DEL-DEL
+      logger.error("Detected conflict (REF-DEL-DEL): " + team.guid)
+      return false
+    }
+    false
+  }
+}
\ No newline at end of file

crm-example/src/main/scala/de/tudresden/inf/st/crme/rules/systemrules/OwnerDataConflictSystemRule.scala

+package de.tudresden.inf.st.crme.rules.systemrules
+
+import org.rosi_project.model_management.core.PlayerSync
+import org.rosi_project.model_management.core.ModelElementLists
+import org.rosi_project.model_management.sync.conflict.systemrules.{DataConflictSystemRule, SystemRule}
+import org.rosi_project.model_management.sync.lock._
+import org.slf4j.LoggerFactory
+
+/**
+ * Data-conflict-system-rule which integrates the owner mechanism.
+ */
+@SystemRule("data")
+class OwnerDataConflictSystemRule extends DataConflictSystemRule {
+
+  val logger = LoggerFactory.getLogger(classOf[OwnerDataConflictSystemRule])
+
+  def getRuleName() = "OwnerDataConflictSystemRule"
+
+  def resolveModificationConflicts(ts: Int, modifier: String, guid: String, elementKey: String): (Boolean, PlayerSync) = {
+
+    val elementSet: Set[SynchronizationAware] = ModelElementLists.getDirectElementsFromType(elementKey)
+
+    elementSet.foreach { elem =>
+      val playerSync: SynchronizationAware = elem.asInstanceOf[SynchronizationAware]
+
+      // check for conflicts
+      if (playerSync.guid == guid) {
+        if (playerSync.deleted) {
+          logger.error("Detected deleted element in ModelElementsList ... this should not occur!")
+        }
+        // check if mod-mod-conflict
+        if (playerSync.owner != modifier) {
+          logger.error("Owner-Rule detected conflict (MOD-MOD): " + guid)
+          return (false, playerSync)
+        } else {
+          logger.info("Owner-Rule passed by " + guid)
+          return (true, playerSync)
+        }
+      }
+    }
+    logger.error("Owner-Rule detected conflict (DEL-MOD): " + guid)
+    (false, null)
+  }
+
+  def resolveDeletionConflicts(ts: Int, modifier: String, guid: String, elementKey: String): (Boolean, PlayerSync) = {
+
+    val elementSet: Set[SynchronizationAware] = ModelElementLists.getDirectElementsFromType(elementKey)
+
+    elementSet.foreach { elem =>
+      val playerSync: SynchronizationAware = elem.asInstanceOf[SynchronizationAware]
+
+      if (playerSync.guid == guid) {
+        if (playerSync.deleted) {
+          logger.error("Detected deleted element in ModelElementsList ... this should not occur!")
+        }
+        // check if mod-del-conflict
+        if (playerSync.owner != modifier) {
+          logger.error("Owner-Rule detected conflict (MOD-DEL): " + guid)
+          return (false, playerSync)
+        } else {
+          logger.info("Owner-Rule passed by " + guid)
+          return (true, playerSync)
+        }
+      }
+    }
+    logger.error("Owner-Rule detected conflict (DEL-DEL): " + guid)
+    (false, null)
+  }
+}