public MembershipDomainModel 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 (membership.MandatorUIDs.Intersect(_query.MandatorUIDs).Any())
{
return(AutoMapper.Mapper.Map <MembershipDomainModel>(membership));
}
else
{
throw new UnauthorizedAccessException("Membership from another Mandator");
}
}
catch (DataException e)
{
throw new DataException("Internal Server Error during loading Membership", e);
}
catch (UnauthorizedAccessException e)
{
throw new UnauthorizedAccessException("Internal Server Error during loading Membership", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error during Saving changes");
}
}
public Guid Handle()
{
try
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
Guid?personUid = uow.AuthenticationRepository.Login(_query.Username, _query.Password);
if (personUid != null)
{
return(personUid.Value);
}
else
{
throw new UnauthorizedAccessException("Invalid Userinformation");
}
}
catch (DataException e)
{
throw new Exception("Internal Server Error", e);
}
catch (UnauthorizedAccessException e)
{
throw new Exception("Unauthorized Access", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error");
}
}
public List <MeetingSearchDomainModel> Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
DynamicSearchService searchService = new DynamicSearchService();
Expression <Func <DataModel.Meeting, bool> > whereExpression = null;
if (_query.SearchCriterias != null)
{
try
{
whereExpression = searchService.GetWhereExpression <DataModel.Meeting>(_query.SearchCriterias);
}
catch (Exception)
{
throw new InvalidOperationException("Exception thrown while Building Search Expression from SearchCriteria");
}
}
DynamicOrderService orderService = new DynamicOrderService();
SortOrderDomainModel orderDomainModel = new SortOrderDomainModel()
{
Direction = Common.DynamicOrderService.DynamicOrderModel.Enums.OrderCriteriaDirectionEnum.OrderByDescending,
Field = "StartDate"
};
var orderQuery = orderService.GetOrderBy <DataModel.Meeting>(orderDomainModel);
var meetings = uow.MeetingRepository.Get(_query.MandatorUIDs, whereExpression, orderQuery, null, _query.NumberOfRows);
return(AutoMapper.Mapper.Map <List <MeetingSearchDomainModel> >(meetings));
}
public List <AdressManagementSearchDomainModel> Handle()
{
try
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
DynamicSearchService searchService = new DynamicSearchService();
Expression <Func <DataModel.IndividualPerson, bool> > whereExpression = null;
if (_query.SearchCriterias != null)
{
try
{
whereExpression = searchService.GetWhereExpression <DataModel.IndividualPerson>(_query.SearchCriterias);
}
catch (Exception)
{
throw new InvalidOperationException("Exception thrown while Building Search Expression from SearchCriteria");
}
}
var items = uow.IndividualPersonRepository.Get(_query.MandatorUIDs, whereExpression, null, "Person, Person.PersonToMandators, MemberInformation, Adress", _query.NumberOfRows);
return(Mapper.Map <List <AdressManagementSearchDomainModel> >(items));
}
catch (InvalidOperationException e)
{
throw new Exception("Internal Server Error", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error");
}
}
public SessionDomainModel Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
var session = uow.SessionRepository.Get(_query.SessionUID);
return(Mapper.Map <SessionDomainModel>(session));
}
public AdressManagementDetailDomainModel Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
var individualPerson = uow.IndividualPersonRepository.Get(_query.MandatorUIDs, _query.AdressUID);
return(Mapper.Map <AdressManagementDetailDomainModel>(individualPerson));
}
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 MeetingDetailDomainModel Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
var meeting = uow.MeetingRepository.Get(_query.MandatorUIDs, _query.MeetingUID);
if (_query.MandatorUIDs.Intersect(meeting.MandatorUIDs).Any())
{
return(Mapper.Map <MeetingDetailDomainModel>(meeting));
}
return(null);
}
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 byte[] Handle()
{
try
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
var individualPerson = uow.IndividualPersonRepository.Get(_query.MandatorUIDs, _query.IndividualPersonUID);
if (individualPerson != null)
{
if (individualPerson.MandatorUIDs.Intersect(_query.MandatorUIDs).Any())
{
string fullLink = Path.Combine(_query.PictureDirectoryPath, individualPerson.PictureLink);
if (Directory.Exists(fullLink))
{
System.IO.File.Delete(fullLink);
individualPerson.PictureLink = null;
uow.IndividualPersonRepository.Update(_query.MandatorUIDs, individualPerson);
}
throw new FileNotFoundException(string.Format("File {0} does not Exists", fullLink));
}
throw new UnauthorizedAccessException("Individual Person from another Mandator");
}
throw new DataException("No Entity found to UID : " + _query.IndividualPersonUID);
}
catch (DataException e)
{
throw new DataException("Internal Server Error", e);
}
catch (UnauthorizedAccessException e)
{
throw new UnauthorizedAccessException("Internal Server Error", e);
}
catch (FileNotFoundException e)
{
throw new FileNotFoundException("Internal Server Error", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error");
}
}
public HttpResponseMessage Get()
{
try
{
List <MandatorDomainModel> result = new List <MandatorDomainModel>();
OrgManUnitOfWork uow = new OrgManUnitOfWork();
foreach (Guid uid in RequestMandatorUIDs)
{
result.Add(AutoMapper.Mapper.Map <MandatorDomainModel>(uow.MandatorRepository.Get(uid)));
}
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
public PictureDomainModel Handle()
{
try
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
var individualPerson = uow.IndividualPersonRepository.Get(_query.MandatorUIDs, _query.Picture.IndividualPersonUID);
if (individualPerson != null)
{
throw new DataException("No Entity found to UID : " + _query.Picture.IndividualPersonUID);
}
string combinedPath = Path.Combine(_query.PictureDirectoryPath, individualPerson.PictureLink);
if (!Directory.Exists(combinedPath))
{
throw new FileNotFoundException(string.Format("File {0} does not Exists", combinedPath));
}
else
{
System.IO.File.WriteAllBytes(combinedPath, _query.Picture.Picture);
individualPerson.PictureLink = combinedPath;
uow.IndividualPersonRepository.Update(_query.MandatorUIDs, individualPerson);
return(_query.Picture);
}
}
catch (DataException e)
{
throw new DataException("Internal Server Error", e);
}
catch (UnauthorizedAccessException e)
{
throw new UnauthorizedAccessException("Internal Server Error", e);
}
catch (Exception)
{
throw new Exception("Internal Server Error");
}
}
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 List <MembershipDomainModel> Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
return(AutoMapper.Mapper.Map <List <MembershipDomainModel> >(uow.MembershipRepository.Get(_query.MandatorUIDs, null, null, null, null)));
}
public GetFileTreeQueryHandler(GetFileTreeQuery query, IUnityContainer unityContainer) : base(unityContainer)
{
_query = query;
_uow = new OrgManUnitOfWork();
}
public InsertAdressQueryHandler(InsertAdressQuery query, IUnityContainer unityContainer) : base(unityContainer)
{
_query = query;
_uow = new OrgManUnitOfWork();
}
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);
}
}
public List <AdressManagementSearchDomainModel> Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
return(AutoMapper.Mapper.Map <List <AdressManagementSearchDomainModel> >(uow.IndividualPersonRepository.Get(_query.MandatorUids, _query.SeachText)));
}
public List <Guid> Handle()
{
OrgManUnitOfWork uow = new OrgManUnitOfWork();
return(uow.SessionRepository.Get(_query.SessionUID).MandatorUIDs.ToList());
}
public DeleteMeetingQueryHandler(DeleteMeetingQuery query, IUnityContainer unityContainer) : base(unityContainer)
{
_query = query;
_uow = new OrgManUnitOfWork();
}
