public static ContractFileSession FromContract(EditorContract contract)
{
return(new ContractFileSession()
{
SerializedContract = EditorContractXML.To(contract)
});
}
public static ContractProcess ValidatePotentialDiagram(this EditorContract contract, BPMNProcessDiagram newDiagram)
{
if (newDiagram == null)
{
throw new ArgumentNullException(nameof(newDiagram));
}
var processes = ProcessFactory.FromXML(newDiagram.DiagramXML);
if (processes.Count() != 1)
{
throw new InvalidProcessCountException("The diagram must contain exactly one process");
}
var newMainProcess = processes.First();
if (!newMainProcess.StartEvents.Any())
{
throw new AtLeastOneStartEventRequiredException("At least one start event is required");
}
if (!newMainProcess.EndEvents.Any())
{
throw new AtLeastOneEndEventRequiredException("At least one end event is required");
}
return(newMainProcess);
}
public static void ReplaceSafely(this EditorContract contract, ContractBusinessRuleActivity activity, DMNProcessDiagram newDiagram)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (newDiagram == null)
{
throw new ArgumentNullException(nameof(newDiagram));
}
if (DMNProcessDiagram.IsNullOrEmpty(newDiagram))
{
activity.Diagram = newDiagram;
return;
}
var oldDiagram = activity.Diagram;
activity.Diagram = newDiagram;
contract.GetMigrator().Notify(
() => activity.Diagram,
() => activity.Diagram = newDiagram,
() => activity.Diagram = oldDiagram,
MigratorMode.EveryChange
);
}
public void SetNewDiagram()
{
var contract = new EditorContract()
{
Id = "contract",
Name = "Contract",
Processes = new ContractProcesses()
{
}
};
contract.ReplaceSafely(BPMNProcessDiagram.FromXml(GetExampleBPMN()));
contract.Processes.Main.UserActivities.First().Form = new ContractForm()
{
Id = "XXX"
};
contract.Processes.Main.BusinessActivities.First().Diagram = DMNProcessDiagram.FromXml("YYY");
contract.Processes.Main.ScriptActivities.First().Script = "ZZZ";
contract.Processes.Main.StartEvents.First().StartForm = new ContractForm()
{
Id = "XXXX"
};
contract.Processes.Diagram = BPMNProcessDiagram.FromXml(GetExampleBPMN());
//Check
Assert.AreEqual("XXXX", contract.Processes.Main.StartEvents.First().StartForm.Id);
Assert.AreEqual("XXX", contract.Processes.Main.UserActivities.First().Form.Id);
Assert.AreEqual("YYY", contract.Processes.Main.BusinessActivities.First().Diagram.DiagramXML);
Assert.AreEqual("ZZZ", contract.Processes.Main.ScriptActivities.First().Script);
AssertExampleProcess(contract.Processes.Main);
}
public void EntityAnalysis_Sample1()
{
var contract = new EditorContract()
{
DataModel = new ContractDataModel()
{
Entities = new List <ContractEntity>()
{
new ContractEntity()
{
Name = "Entity 1",
},
new ContractEntity()
{
Name = "Entity 2",
PrimitiveProperties = new List <PrimitiveContractProperty>()
{
new PrimitiveContractProperty()
{
IsMandatory = true,
Name = "Property 1",
Type = PrimitiveContractPropertyType.Bool
}
}
}
}
}
};
var analysis = contract.AnalyzeIntegrityOf(contract.DataModel.Entities[1]);
Assert.IsTrue(!analysis.HasDeleteRisks());
}
/// <summary>
/// Serializes a contract into xml format
/// </summary>
/// <param name="contract">The contract to serialize</param>
/// <returns>Contract as xml</returns>
public static string To(EditorContract contract)
{
var xml = new XmlSerializer(EditorContractType);
using var textWriter = new StringWriter();
xml.Serialize(textWriter, contract);
return(textWriter.ToString());
}
public static ContractIntegrityAnalysisResult AnalyzeIntegrityOf(this EditorContract contract, ContractEntity entity)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
var deleteRisks = new List <ContractIntegrityAnalysisDeleteCase>();
var childrenAnalyses = new List <ContractIntegrityAnalysisResult>();
//Search dependent reference properties
foreach (var contractEntity in contract.DataModel.Entities)
{
if (contractEntity == entity)
{
continue;
}
foreach (var property in contractEntity.ReferenceProperties)
{
var currentEntity = contractEntity;
var currentProperty = property;
if (property.Entity == entity)
{
currentEntity.WithMigrator(contract.GetMigrator());
deleteRisks.Add(
new ContractIntegrityAnalysisDeleteCase(
$"Property {currentEntity.Name}.{currentProperty.Name} will be deleted",
() => { currentEntity.RemoveProperty(currentProperty); })
);
childrenAnalyses.Add(contract.AnalyzeIntegrityOf(currentProperty));
}
}
}
//Analyze all child properties
foreach (var property in entity.PrimitiveProperties)
{
childrenAnalyses.Add(contract.AnalyzeIntegrityOf(property));
}
foreach (var property in entity.ReferenceProperties)
{
if (property.Entity != null)
{
childrenAnalyses.Add(contract.AnalyzeIntegrityOf(property));
}
}
return(new ContractIntegrityAnalysisResult(deleteRisks, childrenAnalyses));
}
public void BPMNProcessReplaceSafely_NoRisks()
{
var contract = new EditorContract()
{
Processes = new ContractProcesses()
{
}
};
contract.ReplaceSafely(BPMNProcessDiagram.Default());
Assert.IsFalse(contract.AnalyzeIntegrityWhenReplacedWith(BPMNProcessDiagram.Default()).HasDeleteRisks());
}
public static ContractIntegrityAnalysisResult AnalyzeIntegrityOf(this EditorContract contract, ContractActivity activity)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
return(ContractIntegrityAnalysisResult.Empty());
}
public static void AddSafely(this EditorContract contract, ContractEntity entity)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
contract.DataModel.AddEntity(entity);
//contract.DataModel.Entities.Add(entity);
}
public static ContractIntegrityAnalysisResult AnalyzeIntegrityOf(this EditorContract contract, ReferenceContractProperty property)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
var deleteRisks = contract.AnalyzeDeleteRisksOf(property);
return(new ContractIntegrityAnalysisResult(deleteRisks));
}
static void SetReferencesInDataModels(EditorContract contract)
{
//Set referenced values in data models
foreach (var entity in contract.DataModel.Entities)
{
//Reference properties
foreach (var property in entity.ReferenceProperties)
{
if (property.EntityId != null)
{
property.Entity = contract.DataModel.Entities
.Where(e => e.Id == property.EntityId)
.Single();
}
}
}
}
public void BPMNProcessReplaceSafely()
{
var contract = new EditorContract()
{
Processes = new ContractProcesses()
{
}
};
contract.ReplaceSafely(BPMNProcessDiagram.Default());
Assert.AreEqual(0, contract.AnalyzeIntegrityWhenReplacedWith(BPMNProcessDiagram.FromXml(GetExampleBPMN())).DeleteRisks.Count());
contract.ReplaceSafely(BPMNProcessDiagram.FromXml(GetExampleBPMN()));
Assert.AreEqual(3, contract.AnalyzeIntegrityWhenReplacedWith(BPMNProcessDiagram.Default()).DeleteRisks.Count());
}
async Task LoadCurrentContractAsync()
{
Loading = true;
try
{
ContractFileSession = await ContractFileSessionService.GetAsync(Id);
Contract = EditorContractXML.From(ContractFileSession.SerializedContract);
}
catch (Exception e)
{
initialException = e;
}
Loading = false;
}
public static void ValidatePotentialDiagram(this EditorContract contract, ContractBusinessRuleActivity activity, DMNProcessDiagram newDiagram)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (newDiagram == null)
{
throw new ArgumentNullException(nameof(newDiagram));
}
}
public void SerializationWithEmptyContract()
{
var contract = new EditorContract()
{
Id = "contract",
Name = "Contract"
};
//Serialize
var serializedContract = EditorContractXML.To(contract);
//Deserialize
var deserializedContract = EditorContractXML.From(serializedContract);
//Check
Assert.AreEqual("contract", deserializedContract.Id);
Assert.AreEqual("Contract", deserializedContract.Name);
}
public static void RemoveSafely(this EditorContract contract, ContractEntity entity)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
//Remove all risks
contract.AnalyzeIntegrityOf(entity).ResolveDeleteRisks();
//Remove this
//contract.DataModel.Entities.Remove(entity);
contract.DataModel.RemoveEntity(entity);
}
public static ContractIntegrityAnalysisResult AnalyzeIntegrityOf(this EditorContract contract, ContractForm form, ContractFormField field)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (form == null)
{
throw new ArgumentNullException(nameof(form));
}
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
return(ContractIntegrityAnalysisResult.Empty());
}
//--------------------------------------------------
// REFERENCE PROPERTY
//--------------------------------------------------
public static void AddSafely(this EditorContract contract, ContractEntity entity, ReferenceContractProperty property)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
//entity.ReferenceProperties.Add(property);
entity.AddProperty(property);
}
public void SerializationWithNoDiagram()
{
var contract = new EditorContract()
{
Id = "contract",
Name = "Contract",
DataModel = GetExampleDataModel()
};
//Serialize
var serializedContract = EditorContractXML.To(contract);
//Deserialize
var deserializedContract = EditorContractXML.From(serializedContract);
//Check
Assert.AreEqual("contract", deserializedContract.Id);
Assert.AreEqual("Contract", deserializedContract.Name);
AssertExampleDataModel(deserializedContract.DataModel);
}
public static void AddSafely(this EditorContract contract, ContractForm form, ContractFormField field)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (form == null)
{
throw new ArgumentNullException(nameof(form));
}
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
//form.Fields.Add(field);
form.WithMigrator(contract.GetMigrator()).AddField(field);
}
public static void RemoveSafely(this EditorContract contract, ReferenceContractProperty property)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
//Remove all risks
contract.AnalyzeIntegrityOf(property).ResolveDeleteRisks();
//Remove this
var entity = contract.DataModel.GetEntityOf(property);
//entity.ReferenceProperties.Remove(property);
entity.RemoveProperty(property);
}
async Task CreateNewContractAsync()
{
var newContract = new EditorContract();
var newSession = ContractFileSession.FromContract(newContract);
newSession.Id = newSessionId;
Loading = true;
try
{
await ContractFileSessionService.InsertAsync(newSession);
NavigationManager.NavigateTo("/ContractFileSession/" + newSession.Id);
}
catch (Exception)
{
newContractAlertController.AddAlert("Something went wrong :(", AlertScheme.Danger);
}
Loading = false;
}
public static void RemoveSafely(this EditorContract contract, ContractForm form, ContractFormField field)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (form == null)
{
throw new ArgumentNullException(nameof(form));
}
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
//Remove all risks
contract.AnalyzeIntegrityOf(form, field).ResolveDeleteRisks();
//Remove this
//form.Fields.Remove(field);
form.WithMigrator(contract.GetMigrator()).RemoveField(field);
}
public void Setup()
{
property1 = new PrimitiveContractProperty();
property4 = new PrimitiveContractProperty();
entity1 = new ContractEntity()
{
PrimitiveProperties = new List <PrimitiveContractProperty>()
{
property1,
property4
}
};
property2 = new ReferenceContractProperty()
{
Entity = entity1
};
property5 = new ReferenceContractProperty()
{
Entity = entity1
};
entity2 = new ContractEntity()
{
ReferenceProperties = new List <ReferenceContractProperty>()
{
property2,
property5
}
};
entity3 = new ContractEntity()
{
};
property6 = new ReferenceContractProperty();
property7 = new ReferenceContractProperty();
entity4 = new ContractEntity()
{
ReferenceProperties = new List <ReferenceContractProperty>()
{
property6
}
};
entity5 = new ContractEntity()
{
ReferenceProperties = new List <ReferenceContractProperty>()
{
property7
}
};
property6.Entity = entity5;
property7.Entity = entity4;
contract = new EditorContract()
{
DataModel = new ContractDataModel()
{
Entities = new List <ContractEntity>()
{
entity1,
entity2,
entity3,
entity4,
entity5
},
},
Processes = new ContractProcesses()
{
Main = new ContractProcess()
{
ProcessElements = new List <ContractProcessElement>()
{
new ContractUserActivity()
{
Form = new ContractForm()
{
Fields = new List <ContractFormField>()
{
new ContractFormField()
{
PropertyBinding = new ContractPropertyBinding()
{
Property = property4
}
},
new ContractFormField()
{
PropertyBinding = new ContractPropertyBinding()
{
Property = property5
}
}
}
}
}
}
}
}
};
}
//--------------------------------------------------
// PROPERTY ANALYSIS
//--------------------------------------------------
public static List <ContractIntegrityAnalysisDeleteCase> AnalyzeDeleteRisksOf(this EditorContract contract, ContractProperty property)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
var deleteRisks = new List <ContractIntegrityAnalysisDeleteCase>();
//Check for contract property bindings delete risks
foreach (var activity in contract.Processes.Main.UserActivities)
{
foreach (var field in activity.Form.Fields)
{
if (field.PropertyBinding == null || field.PropertyBinding.Property != property)
{
continue;
}
var currentField = field.WithMigrator(contract.GetMigrator());
deleteRisks.Add(new ContractIntegrityAnalysisDeleteCase(
$"Property binding on form field {currentField.Name} will be removed",
() => { currentField.PropertyBinding = null; }));
}
}
return(deleteRisks);
}
public static void ReplaceSafely(this EditorContract contract, BPMNProcessDiagram newDiagram)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (newDiagram == null)
{
throw new ArgumentNullException(nameof(newDiagram));
}
if (BPMNProcessDiagram.IsNullOrEmpty(newDiagram))
{
contract.Processes.Diagram = BPMNProcessDiagram.Default();
contract.Processes.Main = ContractProcess.Empty();
return;
}
var newMainProcess = contract.ValidatePotentialDiagram(newDiagram);
if (contract.Processes.Main != null)
{
contract.AnalyzeIntegrityWhenReplacedWith(newDiagram).ResolveDeleteRisks();
}
var oldDiagram = contract.Processes.Diagram;
contract.Processes.Diagram = newDiagram;
var oldProcess = contract.Processes.Main;
var newProcess = newMainProcess;
contract.Processes.Main = newProcess;
if (newProcess == null || oldProcess == null)
{
return;
}
//Update activities
UpdateMainProcessActivities(oldProcess.ScriptActivities, newProcess.ScriptActivities);
UpdateMainProcessActivities(oldProcess.BusinessActivities, newProcess.BusinessActivities);
UpdateMainProcessActivities(oldProcess.UserActivities, newProcess.UserActivities);
//Update start events
UpdateMainProcessActivities(oldProcess.StartEvents, newProcess.StartEvents);
//Add migration
contract.GetMigrator().Notify(
() => contract.Processes.Diagram,
() =>
{
//Up
contract.Processes.Diagram = newDiagram;
contract.Processes.Main = newProcess;
},
() =>
{
//Down
contract.Processes.Diagram = oldDiagram;
contract.Processes.Main = oldProcess;
}, MigratorMode.EveryChange);
}
public static ContractIntegrityAnalysisResult AnalyzeIntegrityWhenReplacedWith(this EditorContract contract, BPMNProcessDiagram newDiagram)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (newDiagram == null)
{
throw new ArgumentNullException(nameof(newDiagram));
}
var deleteRisks = new List <ContractIntegrityAnalysisDeleteCase>();
var childrenAnalyses = new List <ContractIntegrityAnalysisResult>();
//Figure out activities that will be deleted
var oldActivities = new List <ContractActivity>()
.Concat(contract.Processes.Main.BusinessActivities)
.Concat(contract.Processes.Main.UserActivities)
.Concat(contract.Processes.Main.ScriptActivities)
.ToList();
var newMainProcess = ProcessFactory.FromXML(newDiagram.DiagramXML).First();
var newActivities = new List <ContractActivity>()
.Concat(newMainProcess.BusinessActivities)
.Concat(newMainProcess.UserActivities)
.Concat(newMainProcess.ScriptActivities)
.ToList();
var deletedActivities = new List <ContractActivity>();
foreach (var oldActivity in oldActivities)
{
var linkedNewActivity = newActivities.Where(e => e.Id == oldActivity.Id).SingleOrDefault();
if (linkedNewActivity == null)
{
deletedActivities.Add(oldActivity);
}
}
//Create delete risks
foreach (var deletedActivity in deletedActivities)
{
deleteRisks.Add(new ContractIntegrityAnalysisDeleteCase($"Activity {deletedActivity.Name} will be deleted", () => { }));
}
//Add children risks
foreach (var deletedActivity in deletedActivities)
{
childrenAnalyses.Add(contract.AnalyzeIntegrityOf(deletedActivity));
}
return(new ContractIntegrityAnalysisResult(deleteRisks, childrenAnalyses));
}
public static ContractIntegrityAnalysisResult AnalyzeIntegrityWhenReplacedWith(this EditorContract contract, ContractBusinessRuleActivity activity, DMNProcessDiagram newDiagram)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (newDiagram == null)
{
throw new ArgumentNullException(nameof(newDiagram));
}
var deleteRisks = new List <ContractIntegrityAnalysisDeleteCase>();
var childrenAnalyses = new List <ContractIntegrityAnalysisResult>();
return(new ContractIntegrityAnalysisResult(deleteRisks, childrenAnalyses));
}
public void SerializationWithDiagram()
{
var contract = new EditorContract()
{
Id = "contract",
Name = "Contract",
DataModel = GetExampleDataModel(),
Processes = new ContractProcesses()
{
}
};
contract.ReplaceSafely(BPMNProcessDiagram.FromXml(GetExampleBPMN()));
contract.Processes.Main.UserActivities.First().Form = new ContractForm()
{
Id = "XXX"
};
contract.Processes.Main.BusinessActivities.First().Diagram = DMNProcessDiagram.FromXml("YYY");
contract.Processes.Main.ScriptActivities.First().Script = "ZZZ";
contract.Processes.Main.StartEvents.First().StartForm = new ContractForm()
{
Id = "XXXX"
};
contract.Processes.Main.StartEvents.First().StartForm.Fields.Add(new ContractFormField()
{
PropertyBinding = new ContractPropertyBinding()
{
Property = contract.DataModel.Entities[0].PrimitiveProperties[0]
}
});
contract.Processes.Main.UserActivities.First().Form.Fields.Add(new ContractFormField()
{
PropertyBinding = new ContractPropertyBinding()
{
Property = contract.DataModel.Entities[0].PrimitiveProperties[0]
}
});
//Serialize
var serializedContract = EditorContractXML.To(contract);
//Deserialize
var deserializedContract = EditorContractXML.From(serializedContract);
//Check
Assert.AreEqual("XXXX", contract.Processes.Main.StartEvents.First().StartForm.Id);
Assert.AreEqual("XXX", contract.Processes.Main.UserActivities.First().Form.Id);
Assert.AreEqual("YYY", contract.Processes.Main.BusinessActivities.First().Diagram.DiagramXML);
Assert.AreEqual("ZZZ", contract.Processes.Main.ScriptActivities.First().Script);
Assert.AreEqual(contract.DataModel.Entities[0].PrimitiveProperties[0],
contract.Processes.Main.StartEvents.First().StartForm.Fields[0].PropertyBinding.Property);
Assert.AreEqual(contract.DataModel.Entities[0].PrimitiveProperties[0],
contract.Processes.Main.UserActivities.First().Form.Fields[0].PropertyBinding.Property);
Assert.AreEqual("contract", deserializedContract.Id);
Assert.AreEqual("Contract", deserializedContract.Name);
AssertExampleDataModel(deserializedContract.DataModel);
Assert.AreEqual(GetExampleBPMN(), deserializedContract.Processes.Diagram.DiagramXML);
AssertExampleProcess(contract.Processes.Main);
}
