public PartyTypePair AddPartyTypePair(string title, PartyType allowedSource, PartyType allowedTarget, string description, bool partyRelationShipTypeDefault,
PartyRelationshipType partyRelationshipType, string conditionSource, string conditionTarget)
{
Contract.Requires(!string.IsNullOrEmpty(title));
Contract.Requires(allowedSource != null && allowedSource.Id > 0);
Contract.Requires(allowedTarget != null && allowedTarget.Id > 0);
Contract.Ensures(Contract.Result <PartyTypePair>() != null && Contract.Result <PartyTypePair>().Id >= 0);
var entity = new PartyTypePair()
{
AllowedSource = allowedSource,
AllowedTarget = allowedTarget,
Description = description,
PartyRelationshipType = partyRelationshipType,
Title = title,
PartyRelationShipTypeDefault = partyRelationShipTypeDefault,
ConditionSource = conditionSource,
ConditionTarget = conditionTarget
};
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <PartyTypePair> repo = uow.GetRepository <PartyTypePair>();
repo.Put(entity);
uow.Commit();
}
return(entity);
}
public PartyTypePair UpdatePartyTypePair(long id, string title, PartyType allowedSource, PartyType alowedTarget, string description, bool partyRelationShipTypeDefault,
PartyRelationshipType partyRelationshipType)
{
Contract.Requires(id > 0);
Contract.Requires(!string.IsNullOrEmpty(title));
Contract.Requires(allowedSource != null && allowedSource.Id > 0);
Contract.Requires(alowedTarget != null && alowedTarget.Id > 0);
Contract.Ensures(Contract.Result <PartyTypePair>() != null && Contract.Result <PartyTypePair>().Id >= 0);
var entity = new PartyTypePair();
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <PartyTypePair> repo = uow.GetRepository <PartyTypePair>();
entity = repo.Get(id);
if (entity == null)
{
BexisException.Throw(null, "PartyTypePair not found", BexisException.ExceptionType.Edit);
}
entity.AllowedSource = allowedSource;
entity.AllowedTarget = alowedTarget;
entity.Description = description;
entity.PartyRelationshipType = partyRelationshipType;
entity.Title = title;
entity.PartyRelationShipTypeDefault = partyRelationShipTypeDefault;
repo.Put(entity);
uow.Commit();
}
return(entity);
}
public ActionResult CreatePartyRelationships(int partyId, Dictionary <string, string> partyRelationshipsDic)
{
PartyManager partyManager = null;
PartyRelationshipTypeManager partyRelationshipManager = null;
try
{
partyManager = new PartyManager();
var party = partyManager.PartyRepository.Get(partyId);
var partyRelationships = ConvertDictionaryToPartyRelationships(partyRelationshipsDic, party, partyManager);
partyRelationshipManager = new PartyRelationshipTypeManager();
foreach (var partyRelationship in partyRelationships)
{
// Party TargetParty = partyManager.PartyRepository.Get(partyRelationship.TargetParty.Id);
// PartyRelationshipType partyRelationshipType = partyRelationshipManager.PartyRelationshipTypeRepository.Get(partyRelationship.PartyRelationshipType.Id);
PartyTypePair partyTypePair = partyRelationshipManager.PartyTypePairRepository.Get(partyRelationship.PartyTypePair.Id);
//Min date value is sent from telerik date time element, if it was empty
if (partyRelationship.EndDate == DateTime.MinValue)
{
partyRelationship.EndDate = DateTime.MaxValue;
}
partyManager.AddPartyRelationship(partyRelationship.SourceParty, partyRelationship.TargetParty, partyRelationship.Title, partyRelationship.Description, partyTypePair, partyRelationship.StartDate, partyRelationship.EndDate, partyRelationship.Scope);
}
partyManager?.Dispose();
return(RedirectToAction("CreateEdit", "party", new { id = partyId, relationTabAsDefault = true }));
}
finally
{
partyManager?.Dispose();
partyRelationshipManager?.Dispose();
}
}
public void UpdatePartyTypePair(PartyTypePair partyTypePair)
{
using (var uow = this.GetUnitOfWork())
{
var repo = uow.GetRepository <PartyTypePair>();
repo.Merge(partyTypePair);
var merged = repo.Get(partyTypePair.Id);
repo.Put(merged);
uow.Commit();
}
}
/// <summary>
///
/// </summary>
/// <param name="partyTypePair"></param>
/// <param name="partyRelationshipType"></param>
/// <param name="partyRelationshipTypeManager"></param>
private static void UpdateOrCreatePartyTypePair(PartyTypePair partyTypePair, PartyRelationshipType partyRelationshipType, PartyRelationshipTypeManager partyRelationshipTypeManager)
{
var entity = partyRelationshipTypeManager.PartyTypePairRepository.Get(item => item.Title == partyTypePair.Title && item.PartyRelationshipType.Id == partyRelationshipType.Id).FirstOrDefault();
if (entity != null)
{
partyRelationshipTypeManager.UpdatePartyTypePair(entity.Id, partyTypePair.Title, partyTypePair.SourcePartyType, partyTypePair.TargetPartyType, partyTypePair.Description, "", "", partyTypePair.PartyRelationShipTypeDefault, entity.PartyRelationshipType, entity.PermissionTemplate);
}
else
{
partyRelationshipTypeManager.AddPartyTypePair(partyTypePair.Title, partyTypePair.SourcePartyType, partyTypePair.TargetPartyType, partyTypePair.Description, partyTypePair.PartyRelationShipTypeDefault, partyRelationshipType, partyTypePair.ConditionSource, partyTypePair.ConditionTarget, partyTypePair.PermissionTemplate);
}
}
public bool RemovePartyTypePair(PartyTypePair partyTypePair)
{
Contract.Requires(partyTypePair != null && partyTypePair.Id > 0);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <PartyTypePair> repoPR = uow.GetRepository <PartyTypePair>();
IRepository <PartyRelationshipType> repoRel = uow.GetRepository <PartyRelationshipType>();
var entity = repoPR.Reload(partyTypePair);
if (repoRel.Get(item => item.AssociatedPairs.Contains(partyTypePair)).Count() > 0)
{
BexisException.Throw(entity, "There are some relations between this entity and 'PartyRelationshipType'.", BexisException.ExceptionType.Delete);
}
repoPR.Delete(entity);
uow.Commit();
}
return(true);
}
/// <summary>
/// Creating PartyRelationshipType
/// because PartyRelationshipType should have PartyTypePairs,partyTypePair created in the same time of creating PartyRelationshipType
/// </summary>
/// <param name="title"></param>
/// <param name="description"></param>
/// <param name="indicatesHierarchy"></param>
/// <param name="maxCardinality"></param>
/// <param name="minCardinality"></param>
/// <param name="partyTypePairAlowedSource"></param>
/// <param name="partyTypePairAlowedTarget"></param>
/// <param name="partyTypePairTitle"></param>
/// <param name="partyTypePairDescription"></param>
/// <returns></returns>
public PartyRelationshipType Create(string title, string displayName, string description, bool indicatesHierarchy, int maxCardinality,
int minCardinality, bool partyRelationShipTypeDefault, PartyType partyTypePairAlowedSource, PartyType partyTypePairAlowedTarget,
string partyTypePairTitle, string partyTypePairDescription, string conditionSource, string conditionTarget, int permissionTemplate)
{
Contract.Requires(!string.IsNullOrWhiteSpace(title) && !string.IsNullOrWhiteSpace(partyTypePairTitle));
Contract.Requires(partyTypePairAlowedSource != null && partyTypePairAlowedSource.Id > 0);
Contract.Requires(partyTypePairAlowedTarget != null && partyTypePairAlowedTarget.Id > 0);
Contract.Ensures((Contract.Result <PartyRelationshipType>() != null && Contract.Result <PartyRelationshipType>().Id >= 0));
//Contract.Ensures(Contract.Result<PartyTypePair>() != null && Contract.Result<PartyTypePair>().Id >= 0);
PartyRelationshipType entity = new PartyRelationshipType()
{
Description = description,
IndicatesHierarchy = indicatesHierarchy,
MaxCardinality = maxCardinality,
MinCardinality = minCardinality,
Title = title,
DisplayName = displayName
};
var partyTypeEntity = new PartyTypePair()
{
SourcePartyType = partyTypePairAlowedSource,
TargetPartyType = partyTypePairAlowedTarget,
Description = partyTypePairDescription,
PartyRelationshipType = entity,
Title = partyTypePairTitle,
PartyRelationShipTypeDefault = partyRelationShipTypeDefault,
ConditionSource = conditionSource,
PermissionTemplate = permissionTemplate,
ConditionTarget = conditionTarget
};
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <PartyRelationshipType> repo = uow.GetRepository <PartyRelationshipType>();
IRepository <PartyTypePair> repoPTP = uow.GetRepository <PartyTypePair>();
repo.Put(entity);
repoPTP.Put(partyTypeEntity);
uow.Commit();
}
return(entity);
}
public ActionResult CreatePartyRelationships(int partyId, Dictionary <string, string> partyRelationshipsDic)
{
PartyManager partyManager = null;
try
{
partyManager = new PartyManager();
Party party = partyManager.PartyRepository.Get(partyId);
List <PartyRelationship> partyRelationships = ConvertDictionaryToPartyRelationships(partyRelationshipsDic);
var partyRelationshipManager = new PartyRelationshipTypeManager();
foreach (var partyRelationship in partyRelationships)
{
Party secondParty = partyManager.PartyRepository.Get(partyRelationship.SecondParty.Id);
PartyRelationshipType partyRelationshipType = partyRelationshipManager.PartyRelationshipTypeRepository.Get(partyRelationship.PartyRelationshipType.Id);
PartyTypePair partyTypePair = partyRelationshipManager.PartyTypePairRepository.Get(partyRelationship.PartyTypePair.Id);
//Min date value is sent from telerik date time element, if it was empty
if (partyRelationship.EndDate == DateTime.MinValue)
{
partyRelationship.EndDate = DateTime.MaxValue;
}
partyManager.AddPartyRelationship(party, secondParty, partyRelationshipType, partyRelationship.Title, partyRelationship.Description, partyTypePair, partyRelationship.StartDate, partyRelationship.EndDate, partyRelationship.Scope);
}
partyManager?.Dispose();
//partyManager = new PartyManager();
////if relationship rules are satisfied, it is not temp
// if (string.IsNullOrWhiteSpace(Helpers.Helper.ValidateRelationships(party.Id)))
// party.IsTemp = false;
//else
// party.IsTemp = true;
//partyManager.Update(party);
return(RedirectToAction("CreateEdit", "party", new { id = partyId, relationTabAsDefault = true }));
}
finally
{
partyManager?.Dispose();
}
}
public PartyRelationship AddPartyRelationship(PartyX firstParty, PartyX secondParty, PartyRelationshipType partyRelationshipType,
string title, string description, PartyTypePair partyTypePair, DateTime?startDate = null, DateTime?endDate = null, string scope = "")
{
Contract.Requires(!string.IsNullOrWhiteSpace(title));
Contract.Requires(firstParty != null);
Contract.Requires(firstParty.Id >= 0, "Provided first entity must have a permanent ID");
Contract.Requires(secondParty != null);
Contract.Requires(secondParty.Id >= 0, "Provided first entity must have a permanent ID");
Contract.Requires(partyRelationshipType != null && partyRelationshipType.Id > 0);
Contract.Ensures(Contract.Result <PartyRelationship>() != null && Contract.Result <PartyRelationship>().Id >= 0);
if (startDate == null)
{
startDate = DateTime.MinValue;
}
if (endDate == null)
{
endDate = DateTime.MaxValue;
}
if (startDate > endDate)
{
BexisException.Throw(firstParty, "End date should be greater than start date.");
}
var entity = new PartyRelationship()
{
Description = description,
EndDate = endDate.Value,
FirstParty = firstParty,
PartyRelationshipType = partyRelationshipType,
Scope = scope,
SecondParty = secondParty,
StartDate = startDate.Value,
Title = title
};
if (partyTypePair != null)
{
entity.PartyTypePair = partyTypePair;
}
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <PartyX> repoParty = uow.GetRepository <PartyX>();
IRepository <PartyRelationship> repoPR = uow.GetRepository <PartyRelationship>();
IRepository <PartyRelationshipType> repoRelType = uow.GetRepository <PartyRelationshipType>();
partyRelationshipType = repoRelType.Reload(partyRelationshipType);
var cnt = repoPR.Query(item => (item.PartyRelationshipType != null && item.PartyRelationshipType.Id == partyRelationshipType.Id) &&
(item.FirstParty != null && item.FirstParty.Id == firstParty.Id) &&
(item.SecondParty != null && item.SecondParty.Id == secondParty.Id)).Where(item => item.EndDate > startDate).Count();
//Check maximun cardinality
if (partyRelationshipType.MaxCardinality != -1 && partyRelationshipType.MaxCardinality <= cnt)
{
BexisException.Throw(entity, string.Format("Maximum relations for this type of relation is {0}.", partyRelationshipType.MaxCardinality), BexisException.ExceptionType.Add);
}
//Check if there is a relevant party type pair
var alowedSource = partyRelationshipType.AssociatedPairs.FirstOrDefault(item => item.AllowedSource.Id == firstParty.PartyType.Id || item.AllowedSource.Id == secondParty.PartyType.Id);
var alowedTarget = partyRelationshipType.AssociatedPairs.FirstOrDefault(item => item.AllowedTarget.Id == firstParty.PartyType.Id || item.AllowedTarget.Id == secondParty.PartyType.Id);
if (alowedSource == null || alowedTarget == null)
{
BexisException.Throw(entity, "There is not relevant 'PartyTypePair' for these types of parties.", BexisException.ExceptionType.Add);
}
partyRelationshipType.PartyRelationships.Add(entity);
repoPR.Put(entity);
uow.Commit();
//update the source party to check if relationship rules are satisfied and changed the istemp field
Update(entity.FirstParty);
}
return(entity);
}
