Insurance-Example-Model.cml

/* Example Context Map written with 'ContextMapper DSL' */
ContextMap InsuranceContextMap {
	type = SYSTEM_LANDSCAPE
	state = TO_BE
	
	/* Add bounded contexts to this context map: */
	contains CustomerManagementContext
	contains CustomerSelfServiceContext
	contains PrintingContext
	contains PolicyManagementContext
	contains RiskManagementContext
	contains DebtCollection
	
	/* Define the context relationships: */ 

	CustomerSelfServiceContext [D,C]<-[U,S] CustomerManagementContext : Customer_Frontend_Backend_Relationship { // Relationship name is optional
		exposedAggregates = Customers
	}
	
	CustomerManagementContext [D,ACL]<-[U,OHS,PL] PrintingContext {
		implementationTechnology = "SOAP"
		downstreamRights = INFLUENCER
		exposedAggregates = Printing
	}
	
	PrintingContext [U,OHS,PL]->[D,ACL] PolicyManagementContext {
		implementationTechnology = "SOAP"
		exposedAggregates = Printing
	}
	
	RiskManagementContext [P]<->[P] PolicyManagementContext {
		implementationTechnology = "RabbitMQ"
	}	

	PolicyManagementContext [D,CF]<-[U,OHS,PL] CustomerManagementContext {
		implementationTechnology = "RESTfulHTTP"
		exposedAggregates = Customers
	}

	RiskManagementContext [D,CF]<-[U,OHS,PL] CustomerManagementContext {
    	implementationTechnology = "RESTfulHTTP"
    	exposedAggregates = Customers
	}

	DebtCollection [D,ACL]<-[U,OHS,PL] PrintingContext {
		implementationTechnology = "SOAP"
		exposedAggregates = Printing
	}

	PolicyManagementContext [SK]<->[SK] DebtCollection {
		implementationTechnology = "Shared Java Library, Communication over RESTful HTTP"
	}
	
}

/* Bounded Context Definitions */
BoundedContext CustomerManagementContext implements CustomerManagementDomain {
	type = FEATURE
	domainVisionStatement = "The customer management context is responsible for managing all the data of the insurance companies customers."
	implementationTechnology = "Java, JEE Application"
	responsibilities = "Customers, Addresses"
	
	Aggregate Customers {
		Entity Customer { 
			aggregateRoot
			
			- SocialInsuranceNumber sin
			String firstname
			String lastname
			- List<Address> addresses
			
			def AddressId createAddress(@Address address);
			def boolean changeCustomer(String firstname, String lastname);
		}
		
		Entity Address {
			String street
			int postalCode
			String city
		}
		
		ValueObject SocialInsuranceNumber {
			String sin key
		}
	}
	
}

BoundedContext CustomerSelfServiceContext implements CustomerManagementDomain {
	type = APPLICATION
	domainVisionStatement = "This context represents a web application which allows the customer to login and change basic data records like the address."
	responsibilities = "AddressChange"
	implementationTechnology = "PHP Web Application"
	
	Aggregate CustomerFrontend {
		Entity CustomerAddressChange {
			aggregateRoot
			
			- UserAccount issuer
			- Address changedAddress
		}
	}
	
	Aggregate Acounts {
		Entity UserAccount {
			aggregateRoot
			
			String username
			- Customer accountCustomer
		}
	}
}

BoundedContext PrintingContext implements PrintingDomain {
	type = SYSTEM
	responsibilities = "Document Printing"
	domainVisionStatement = "An external system which provides printing services to the other Bounded Contexts."
	
	Aggregate Printing {
		Entity PrintingJob {
			aggregateRoot
			
			int printingId
			- Document document
			- Template template
			
			def PrintStatus printJob(PrintingId printingId);
		}
		
		Entity Document {
			DomainObject source
			String template
		}
	}
	
	Aggregate Templating {
		Entity Template {
			aggregateRoot
			
			int templateId
			String templateName
		}
	}
}

BoundedContext PolicyManagementContext implements PolicyManagementDomain {
	type = FEATURE
	domainVisionStatement = "This bounded context manages the contracts and policies of the customers."
	responsibilities = "Offers, Contracts, Policies"
	implementationTechnology = "Java, Spring App"
	
	Aggregate Offers {
		owner ContractsTeam

		Entity Offer {
			aggregateRoot

			int offerId
			- Customer client
			- List<Product> products
			BigDecimal price
		}
	}

	Aggregate Products {
		owner ProductsTeam

		Entity Product {
			aggregateRoot

			- ProductId identifier
			String productName
		}

		ValueObject ProductId {
			int productId key
		}
	}

	Aggregate Contract {
		owner ContractsTeam

		Entity Contract {
			aggregateRoot

			- ContractId identifier
			- Customer client
			- List<Product> products
		}

		ValueObject ContractId {
			int contractId key
		}

		Entity Policy {
			int policyNr
			- Contract contract
			BigDecimal price
		}
	}
}

BoundedContext RiskManagementContext implements RiskManagementDomain {
	type = FEATURE
	domainVisionStatement = "Uses data from PolicyManagement context to calculate risks."
	responsibilities = "Customer Risk Calculation"
	implementationTechnology = "Java, Spring App"

	Aggregate Risks {
		Entity CustomerRiskFactor {
			aggregateRoot

			int totalRiskFactor
			- List<Risk> risks
			- Customer client
		}

		ValueObject Risk {
			int likelihood
			String risk
		}
	}
}

BoundedContext DebtCollection implements DebtsDomain {
	type = FEATURE
	domainVisionStatement = "The debt collection context is responsible for the financial income of the insurance company (the debts) which depend on the corresponding contracts and policies."
	responsibilities = "Debts, Dunning"
	implementationTechnology = "JEE"

	Aggregate Debts {
		Entity Debt {
			aggregateRoot

			int debtNr
			- Policy policy
			Date creationDate
			Date paymentDate
			Date paymentDeadline
			BigDecimal price
			PaymentStatus status
			- List<Dunning> dunnigs
		}

		Entity Dunning {
			int dunningNr
			- Debt debt
			Date dunningDate
			Date paymentDeadline
		}
	}
}

/* Teams: */
BoundedContext CustomersTeam { type TEAM }
BoundedContext ContractsTeam { type TEAM }
BoundedContext ProductsTeam { type TEAM }

/* Domain & Subdomain Definitions */
Domain InsuranceDomain {
	Subdomain CustomerManagementDomain {
		type = CORE_DOMAIN
		domainVisionStatement = "Subdomain managing everything customer-related."
	}
	Subdomain PolicyManagementDomain {
		type = CORE_DOMAIN
		domainVisionStatement = "Subdomain managing contracts and policies."
	}
	Subdomain PrintingDomain {
		type = SUPPORTING_DOMAIN
		domainVisionStatement = "Service (external system) to solve printing for all kinds of documents (debts, policies, etc.)"
	}
	Subdomain RiskManagementDomain {
		type = GENERIC_SUBDOMAIN
		domainVisionStatement = "Subdomain supporting everything which relates to risk management."
	}
	Subdomain DebtsDomain {
		type = GENERIC_SUBDOMAIN
		domainVisionStatement = "Subomain including everything related to the incoming money (debts, dunning, etc.)"
	}
}