public void Handle()
{
try
{
DataModel.Meeting meeting = _uow.MeetingRepository.Get(_query.MandatorUIDs, _query.MeetingUID);
if (meeting == null)
{
throw new DataException("No Entity found to UID : " + _query.MeetingUID);
}
if (!_query.MandatorUIDs.Intersect(meeting.MandatorUIDs).Any())
{
throw new UnauthorizedAccessException("Meeting from another mandator");
}
_uow.MeetingRepository.Delete(_query.MandatorUIDs, _query.MeetingUID);
_uow.Commit();
}
catch (UnauthorizedAccessException)
{
throw new UnauthorizedAccessException("Not Authorized to Delete the Entity");
}
catch (DataException e)
{
throw new DataException("Internal Server Error during Saving Changes", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error during Saving Changes");
}
}
public void Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
uow.SessionRepository.Delete(_query.MandatorUIDs, _query.SessionUID);
uow.Commit();
}
public void Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
try
{
var membership = uow.MembershipRepository.Get(_query.MandatorUIDs, _query.MembershipUID);
if (membership == null)
{
throw new DataException("No Entity found to UID : " + _query.MembershipUID);
}
if (_query.MandatorUIDs.Intersect(membership.MandatorUIDs).Any())
{
if (membership.MemberInformationToMemberships != null &&
membership.MemberInformationToMemberships.Any())
{
throw new DataException(
string.Format(
"Could not remove Membership, because it is beeing used by {0} MemberInformationToMemberships",
membership.MemberInformationToMemberships.Count));
}
uow.MembershipRepository.Delete(_query.MandatorUIDs, _query.MembershipUID);
}
else
{
throw new UnauthorizedAccessException("Membership from another Mandator");
}
}
catch (DataException e)
{
throw new DataException("Internal Server Error during deleting Membership", e);
}
catch (UnauthorizedAccessException e)
{
throw new DataException("Internal Server Error during deleting Membership", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error during deleting Membership");
}
try
{
uow.Commit();
}
catch (DataException e)
{
throw new Exception("Internal Server Error during Saving changes", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error during Saving changes");
}
}
public void Handle()
{
DataModel.Session session = AutoMapper.Mapper.Map <DataModel.Session>(_query.Session);
session.SysUpdateTime = DateTimeOffset.Now;
session.SysUpdateAccountUID = Guid.NewGuid();
OrgManUnitOfWork uow = new OrgManUnitOfWork();
uow.SessionRepository.Update(_query.MandatorUIDs, session);
uow.Commit();
}
public Guid Handle()
{
DataModel.Session session = Mapper.Map <DataModel.Session>(_query.Session);
session.UID = Guid.NewGuid();
session.SysInsertTime = DateTimeOffset.Now;
session.SysInsertAccountUID = Guid.NewGuid();
OrgManUnitOfWork uow = new OrgManUnitOfWork();
uow.SessionRepository.Insert(session);
uow.Commit();
return(session.UID);
}
public Guid Handle()
{
try
{
DataModel.Meeting meeting = AutoMapper.Mapper.Map <DataModel.Meeting>(_query.MeetingDetailDomainModel);
if (meeting == null)
{
throw new DataException("Could not Map MeetingDetailDomainModel to Meeting");
}
//DynamicValidationService<DataModel.Meeting> validationService = new DynamicValidationService<DataModel.Meeting>(new UnityContainer());
//if (!validationService.Validate(meeting))
//{
// throw new DataException("Entity is Invalid");
//}
if (_query.MandatorUIDs.Intersect(meeting.MandatorUIDs).Any())
{
Guid meetingUid = Guid.NewGuid();
meeting.UID = meetingUid;
_uow.MeetingRepository.Insert(_query.MandatorUIDs, meeting);
_uow.Commit();
return(meeting.UID);
}
throw new UnauthorizedAccessException("Meeting from another mandator");
}
catch (UnauthorizedAccessException)
{
throw new UnauthorizedAccessException("Not Authorized to Create the Entity");
}
catch (InvalidOperationException)
{
throw new InvalidOperationException("Internal Server Error thrown during create process");
}
catch (DataException e)
{
throw new DataException("Internal Server Error", e);
}
catch (Exception e)
{
throw new Exception("Internal Server Error", e);
}
}
public Guid Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
try
{
var membership = AutoMapper.Mapper.Map <DataModel.Membership>(_query.MembershipDomainModel);
if (membership == null)
{
throw new DataException("Could not Map AdressManagementDetailDomainModel to IndividualPerson");
}
if (_query.MandatorUIDs.Intersect(membership.MandatorUIDs).Any())
{
membership.UID = Guid.NewGuid();
uow.MembershipRepository.Insert(_query.MandatorUIDs, membership);
uow.Commit();
return(membership.UID);
}
else
{
throw new UnauthorizedAccessException("Membership from another Mandator");
}
}
catch (DataException e)
{
throw new DataException("Internal Server Error during Inserting changes", e);
}
catch (UnauthorizedAccessException e)
{
throw new UnauthorizedAccessException("Internal Server Error during Inserting changes", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error during Inserting changes");
}
}
public MeetingDetailDomainModel Handle()
{
try
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
var meeting = Mapper.Map <DataModel.Meeting>(_query.MeetingDetailDomainModel);
if (_query.MandatorUIDs.Intersect(meeting.MandatorUIDs).Any())
{
uow.MeetingRepository.Update(_query.MandatorUIDs, meeting);
uow.Commit();
return(Mapper.Map <MeetingDetailDomainModel>(meeting));
}
throw new UnauthorizedAccessException("Meeting from another mandator");
}
catch (UnauthorizedAccessException)
{
throw new UnauthorizedAccessException("Not Authorized to Update the Entity");
}
catch (InvalidOperationException)
{
throw new InvalidOperationException("Internal Server Error thrown during update process");
}
catch (DataException e)
{
throw new DataException("Internal Server Error", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error");
}
}
public Guid Handle()
{
try
{
IndividualPerson individualPerson = Mapper.Map <IndividualPerson>(_query.AdressManagementDetailDomainModel);
if (individualPerson == null)
{
throw new DataException("Could not Map AdressManagementDetailDomainModel to IndividualPerson");
}
Guid individualPersonUid = Guid.NewGuid();
Guid adressUid = Guid.NewGuid();
Guid memberinformationUid = Guid.NewGuid();
individualPerson.UID = individualPersonUid;
individualPerson.Person.UID = individualPersonUid;
individualPerson.AdressUID = adressUid;
if (individualPerson.MemberInformation != null)
{
individualPerson.MemberInformation.UID = memberinformationUid;
if (individualPerson.MemberInformation.MemberInformationToMemberships != null)
{
foreach (var memberInformationToMembership in individualPerson.MemberInformation.MemberInformationToMemberships)
{
memberInformationToMembership.MemberInformationUID = memberinformationUid;
memberInformationToMembership.UID = Guid.NewGuid();
}
}
}
if (individualPerson.Adress != null)
{
individualPerson.Adress.UID = adressUid;
}
foreach (var phone in individualPerson.Phones)
{
phone.IndividualPersonUID = individualPersonUid;
phone.UID = Guid.NewGuid();
}
foreach (var email in individualPerson.Emails)
{
email.IndividualPersonUID = individualPersonUid;
email.UID = Guid.NewGuid();
}
foreach (var personToMandator in individualPerson.Person.PersonToMandators)
{
personToMandator.PersonUID = individualPersonUid;
personToMandator.UID = Guid.NewGuid();
}
_uow.IndividualPersonRepository.Insert(_query.MandatorUIDs, individualPerson);
_uow.Commit();
return(individualPerson.UID);
}
catch (DataException e)
{
throw new Exception("Internal Server Error", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error");
}
}
public void Handle()
{
try
{
IndividualPerson individualPerson = _uow.IndividualPersonRepository.Get(_query.MandatorUIDs, _query.IndividualPersonUID);
if (individualPerson == null)
{
throw new DataException("No Entity found to UID : " + _query.IndividualPersonUID);
}
if (individualPerson.Phones != null && individualPerson.Phones.Any())
{
DeletePhones(_query.MandatorUIDs, individualPerson.Phones.Select(p => p.UID).ToList());
}
if (individualPerson.Emails != null && individualPerson.Emails.Any())
{
DeleteEmails(_query.MandatorUIDs, individualPerson.Emails.Select(p => p.UID).ToList());
}
List <Guid> personToMandatorsToDeleteUids = individualPerson.Person.PersonToMandators.Select(p => p.UID).ToList();
if (individualPerson.Person.Login != null)
{
if (individualPerson.Person.Login.Sessions != null && individualPerson.Person.Login.Sessions.Any())
{
throw new DataException("Could not Delete, because there are active Sessions existing");
//DeleteSessions(individualPerson.Person.Login.Sessions.Select(s => s.UID).ToList());
}
_uow.LoginRepository.Delete(_query.MandatorUIDs, individualPerson.Person.Login.UID);
}
_uow.IndividualPersonRepository.Delete(_query.MandatorUIDs, _query.IndividualPersonUID);
if (individualPerson.Person != null && individualPerson.Person.IndividualPerson != null && individualPerson.Person.SystemPerson == null)
{
_uow.PersonRepository.Delete(_query.MandatorUIDs, individualPerson.Person.UID);
}
if (personToMandatorsToDeleteUids != null && personToMandatorsToDeleteUids.Any())
{
DeletePersonToMandators(personToMandatorsToDeleteUids);
}
else
{
throw new DataException("No MandatorUDIs found for Entity with the UID : " + _query.IndividualPersonUID);
}
if (individualPerson.MemberInformationUID != null)
{
if (individualPerson.MemberInformation.MemberInformationToMemberships != null && individualPerson.MemberInformation.MemberInformationToMemberships.Any())
{
DeleteMemberInformationToMemberships(individualPerson.MemberInformation.MemberInformationToMemberships.Select(m => m.UID).ToList());
}
DeleteMemberInformation(_query.MandatorUIDs, individualPerson.MemberInformationUID.Value);
}
DeleteAdress(individualPerson.AdressUID);
}
catch (DataException e)
{
throw new Exception("Internal Server Error", e);
}
catch (Exception e)
{
throw new Exception("Internal Server Error");
}
try
{
_uow.Commit();
}
catch (DataException e)
{
throw new Exception("Internal Server Error during Saving changes", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error during Saving changes");
}
}
public AdressManagementDetailDomainModel Handle()
{
try
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
Guid newMemberInformationUID = Guid.Empty;
if (_query.AdressManagementDetailDomainModel.MemberInformation != null && _query.AdressManagementDetailDomainModel.MemberInformation.UID == null || _query.AdressManagementDetailDomainModel.MemberInformation.UID == Guid.Empty)
{
newMemberInformationUID = Guid.NewGuid();
_query.AdressManagementDetailDomainModel.MemberInformation.UID = newMemberInformationUID;
}
if (_query.AdressManagementDetailDomainModel.MemberInformation != null && _query.AdressManagementDetailDomainModel.MemberInformation.MemberInformationToMemberships != null)
{
foreach (var memberInformationToMembership in _query.AdressManagementDetailDomainModel.MemberInformation.MemberInformationToMemberships)
{
if (memberInformationToMembership.UID == null || memberInformationToMembership.UID == Guid.Empty)
{
Guid newUid = Guid.NewGuid();
memberInformationToMembership.UID = newUid;
}
if (memberInformationToMembership.Membership == null)
{
memberInformationToMembership.Membership = Mapper.Map <MembershipDomainModel>(uow.MembershipRepository.Get(_query.MandatorUIDs, memberInformationToMembership.MembershipUID));
}
}
}
if (_query.AdressManagementDetailDomainModel.Phones != null)
{
foreach (var phone in _query.AdressManagementDetailDomainModel.Phones)
{
if (phone.UID == null || phone.UID == Guid.Empty)
{
phone.UID = Guid.NewGuid();
phone.IndividualPersonUID = _query.AdressManagementDetailDomainModel.UID;
}
}
}
if (_query.AdressManagementDetailDomainModel.Person.PersonToMandators != null)
{
foreach (var personToMandator in _query.AdressManagementDetailDomainModel.Person.PersonToMandators)
{
personToMandator.PersonUID = _query.AdressManagementDetailDomainModel.Person.UID;
personToMandator.UID = Guid.NewGuid();
}
}
if (_query.AdressManagementDetailDomainModel.Emails != null)
{
foreach (var email in _query.AdressManagementDetailDomainModel.Emails)
{
if (email.UID == null || email.UID == Guid.Empty)
{
email.UID = Guid.NewGuid();
email.IndividualPersonUID = _query.AdressManagementDetailDomainModel.UID;
}
}
}
var individualPerson = Mapper.Map <DataModel.IndividualPerson>(_query.AdressManagementDetailDomainModel);
uow.IndividualPersonRepository.Update(_query.MandatorUIDs, individualPerson);
uow.MemberInformationRepository.Update(_query.MandatorUIDs, individualPerson.MemberInformation);
uow.PersonRepository.Update(_query.MandatorUIDs, individualPerson.Person);
uow.AdressRepository.Update(_query.MandatorUIDs, individualPerson.Adress);
if (individualPerson.Phones != null)
{
foreach (var phone in individualPerson.Phones)
{
uow.PhoneRepository.Update(_query.MandatorUIDs, phone);
}
}
if (individualPerson.Emails != null)
{
foreach (var email in individualPerson.Emails)
{
uow.EmailRepository.Update(_query.MandatorUIDs, email);
}
}
uow.Commit();
foreach (var membership in individualPerson.MemberInformation.MemberInformationToMemberships)
{
var membershipTest = uow.MemberInformationToMembershipRepository.Get(membership.UID);
if (membershipTest == null)
{
uow.MemberInformationToMembershipRepository.Insert(membership);
}
else
{
uow.MemberInformationToMembershipRepository.Update(membership);
}
}
uow.Commit();
return(Mapper.Map <AdressManagementDetailDomainModel>(uow.IndividualPersonRepository.Get(_query.AdressManagementDetailDomainModel.UID)));
}
catch (InvalidOperationException e)
{
throw new Exception("Internal Server Error thrown during update process", e);
}
catch (DataException e)
{
throw new Exception("Internal Server Error", e);
}
catch (Exception e)
{
throw new Exception("Internal Server Error", e);
}
}