Page Comparison

namespace ViewEnterprise {
	class Goal
	class Objective
	class Reporting {
		name
		objective *
	}
	class Organisation
	
	Goal *- Objective
}

ViewEnterprise -[hidden]-> ViewBusiness

namespace ViewBusiness {
	class KPI {
		name
		description
	}


	class Process {
		name
		result
	}
	Process --> KPI : génère
	Process *-> Activity : orchestre
	Process --> ViewEnterprise.Objective : couvre
	

	class Activity {
		name
		begin
		activity
	}
	
	class Role
	Role "1..*" -- "1..*" Activity : work
	ViewEnterprise.Organisation *-down- Role : met en jeu
	ViewEnterprise.Reporting o-down- KPI : "présente la performance de"

	Process -up-> ViewEnterprise.Objective : "répond à"
} 
ViewBusiness
-[hidden]-> ViewFunctionnal 

namespace ViewFunctionnal {
	class Flow {
		pattern
		criticity
		frequency
		isSequenced
		acknowledgmentOfReceipt
	}

	class Data {
		nom
		définition
		état
		typologie
	}

	Flow o-- Data: datas
	Flow o-- ViewApplication.Mediation: Mediations

	class Application
	Application o-- Service : metruns
à disposition
	Application *-> Service : utiliseuse
	Application *-- UseCase : proposeexpose
	Application o-- Data : used
	Application *-- Data : owned
	Application
*-->
Evénement : émet
	Application o--> Evénement : réagit à

	Flow o- Application: origins
	Flow o- Application: targets

	class Service {
		opération
	}
	ViewEnterprise.Objective --o Service: objectives
	Service --o ViewBusiness.Activity : draw in game

	class Domain {
		nom
	}
	Domain *-- Domain : sub domains
	Domain o-- Application : content


	class Event {
		nom
		Date émission
	}
	Application *--> Event: emit
	Application o--> Event: intercept	

	class UseCase {
		nom
		objectif
		scénario nominal
		scénario variante *
	}
	UseCase -up-> ViewBusiness.Activity : automatize 
	UseCase -- ViewBusiness.Role: actors
}

ViewFunctionnal -[hidden]->
ViewApplication


namespace ViewApplication {
	
	class Deliverable {
		nom
		technology
		version
	}
	Deliverable *-- Interface : consomme
	Deliverable --> Interface : expose

	class Mediation {
		transactional
		type
	}

	

	class Interface {
		format
		protocole
	}
	Interface --> Security
	Mediation o-- Interface : inputs
	Mediation o-- Interface : outputs
	

	class Security {
		identification
		authentification
		encryption
		signature
	}
	
	class Mediation {
		transactionnelle
		type
	}
	Mediation "0..*" - "0..*" Interface
	(Mediation, Interface) .. UsageRestriction

	class UsageRestriction {
		"volumétrie pic"
		"volumétrie moyenne"
		"volumétrie seuil"
		"durée du cache"
	}

	class Contract {
		opération
		version
		type
	}
	Contract --|> Interface
	Contract --> SLA
	Contract *- ViewFunctionnal.Service: implement


	class SLA {
		responseTimeAvg
		responseTimeMax
		avaibility
		robustness
		lostMessages
	}
	
}


namespace ViewTechnical {
	class EndPoint {
		IP
		port
		URL
	}
	ViewApplication.Interface *-down- EndPoint : endpoints

	class DataCenter
	class Zone
	DataCenter *-- Zone: zones


	class Network
	Network --* Zone: networks

	class Server {
		CPU
		RAM
	}
	Server o-- EndPoint
	Server --* Network
	Server *-- Server: servers virtualized

	class Software {
		nom
		version
	}
	Server *-- Software: installed
	Software <-- ViewApplication.Deliverable : deployed on
	Software *-- Software: dependencies

}

ViewEnterprise -[hidden]down-> ViewBusiness
ViewBusiness -[hidden]down-> ViewFunctionnal
ViewFunctionnal -[hidden]down-> ViewApplication
ViewApplication -[hidden]down-> ViewTechnical