public async Task <ServiceResponse <OrganizationItem> > SaveAsync(OrganizationItem organizationItem)
{
DateTime startTime = DateTime.Now;
try
{
var organizationFacade = this.Container.GetInstance <OrganizationFacade>();
var organization = await organizationFacade.SaveAsync(organizationItem, base.Email, base.IPAddress);
base.LogMessage("SaveAsync", DateTime.Now - startTime);
this.SendInvalidation();
var org = ModelConversions.Convert(organization);
org.CycleNumber = organizationItem.CycleNumber;
org.CycleEffectiveDate = organizationItem.CycleEffectiveDate;
return(new ServiceResponse <OrganizationItem>()
{
Item = org
});
//return ModelConversions.Convert(organization);
}
catch (Exception ex)
{
return(new ServiceResponse <OrganizationItem>()
{
HasError = true,
Message = ex.Message
});
}
}
public async Task <SiteProcessingTotalItem> SaveSiteProcessingTotalAsync(SiteProcessingTotalItem item, string savedBy)
{
var cellTypeManager = this.container.GetInstance <TransplantCellTypeManager>();
var totalManager = this.container.GetInstance <SiteProcessingTotalManager>();
var cellTypes = new List <TransplantCellType>();
foreach (var cellTypeName in item.SelectedTypes)
{
var cellType = await cellTypeManager.GetByNameAsync(cellTypeName);
if (cellType == null)
{
throw new Exception("Cannot find data");
}
cellTypes.Add(cellType);
}
var row = await totalManager.SaveAsync(cellTypes, item.Id,
item.SiteId, item.NumberOfUnits, Convert.ToDateTime(item.StartDate), Convert.ToDateTime(item.EndDate), savedBy);
await this.InvalidateCacheAsync(savedBy);
var conv = ModelConversions.Convert(row);
conv.SiteProcessingTotalTransplantCellTypes = cellTypes.Select(x => new SiteProcessingTotalTransplantCellTypeItem
{
TransplantCellType = ModelConversions.Convert(x)
})
.ToList();
return(conv);
}
public async Task <ServiceResponse <Question> > Save(Question model)
{
if (base.RoleId != (int)Constants.Role.FACTAdministrator && base.RoleId != (int)Constants.Role.QualityManager)
{
return(new ServiceResponse <Question>
{
HasError = true,
Message = "Not Authorized"
});
}
try
{
var facade = this.Container.GetInstance <QuestionFacade>();
var applicationSectionQuestion = await facade.SaveAsync(model, base.Email);
var question = ModelConversions.Convert(applicationSectionQuestion, true);
return(new ServiceResponse <Question>()
{
Item = question
});
}
catch (Exception ex)
{
return(new ServiceResponse <Question>
{
HasError = true,
Message = ex.Message
});
}
}
public async Task <List <InspectionItem> > GetInspectionBySite(Guid app, string site)
{
var startTime = DateTime.Now;
var inspectionFacade = this.Container.GetInstance <InspectionFacade>();
base.LogMessage("GetInspectionBySite", DateTime.Now - startTime);
var inspection = await inspectionFacade.GetInspectionBySiteAsync(app, site, base.UserId.GetValueOrDefault());
var result = new List <InspectionItem>();
for (var i = 0; i < inspection.Count; i++)
{
if (inspection[i] == null)
{
continue;
}
var item = ModelConversions.Convert(inspection[i]);
item.IsReinspection = i == 0;
result.Add(item);
}
return(result);
}
public ServiceResponse <ScopeTypeItem> Delete(ScopeTypeItem scopeTypeItem)
{
DateTime startTime = DateTime.Now;
try
{
var scopeTypeFacade = this.Container.GetInstance <ScopeTypeFacade>();
var scopeType = scopeTypeFacade.Delete(scopeTypeItem.ScopeTypeId, Email);
base.LogMessage("SaveAsync", DateTime.Now - startTime);
return(new ServiceResponse <ScopeTypeItem>()
{
Item = ModelConversions.Convert(scopeType)
});
}
catch (Exception ex)
{
return(new ServiceResponse <ScopeTypeItem>()
{
HasError = true,
Message = ex.Message
});
}
}
public UserItem GetCurrentUser()
{
DateTime startTime = DateTime.Now;
try
{
var userFacade = this.Container.GetInstance <UserFacade>();
if (!base.UserId.HasValue)
{
return(null);
}
var user = userFacade.GetById(base.UserId.Value);
base.LogMessage("GetCurrentUser", DateTime.Now - startTime);
var userItem = ModelConversions.Convert(user, true, true);
userItem.DocumentLibraryAccessToken = base.AccessToken;
return(userItem);
}
catch (Exception ex)
{
base.HandleException(ex);
throw;
}
}
public async Task <ServiceResponse <FacilityItems> > DeleteAsync(int facilityId)
{
DateTime startTime = DateTime.Now;
try
{
var facilityFacade = this.Container.GetInstance <FacilityFacade>();
var facility = await facilityFacade.DeleteAsync(facilityId, this.Email);
base.LogMessage("Delete", DateTime.Now - startTime);
this.SendInvalidation();
return(new ServiceResponse <FacilityItems>()
{
Item = ModelConversions.Convert(facility)
});
}
catch (Exception ex)
{
return(new ServiceResponse <FacilityItems>()
{
HasError = true,
Message = ex.Message
});
}
}
public ServiceResponse <ApplicationResponseCommentItem> Save(ApplicationResponseCommentItem applicationResponseCommentItem)
{
DateTime startTime = DateTime.Now;
try
{
var applicationResponseCommentFacade = this.Container.GetInstance <ApplicationResponseCommentFacade>();
var applicationResponseComment = applicationResponseCommentFacade.Save(applicationResponseCommentItem, base.UserId.GetValueOrDefault(), base.Email);
base.LogMessage("Save", DateTime.Now - startTime);
var manager = this.Container.GetInstance <ApplicationResponseCommentManager>();
var comment = manager.GetById(applicationResponseComment.Id);
return(new ServiceResponse <ApplicationResponseCommentItem>()
{
Item = ModelConversions.Convert(comment)
});
}
catch (Exception ex)
{
return(new ServiceResponse <ApplicationResponseCommentItem>()
{
HasError = true,
Message = ex.Message
});
}
}
public ServiceResponse <InspectionScheduleItem> GetInspectionSchedule(int organizationId, int applicationId)
{
DateTime startTime = DateTime.Now;
try
{
var inspectionScheduleFacade = this.Container.GetInstance <InspectionScheduleFacade>();
var inspectionSchedule = inspectionScheduleFacade.GetInspectionSchedule(organizationId, applicationId);
base.LogMessage("GetInspectionSchedule", DateTime.Now - startTime);
return(new ServiceResponse <InspectionScheduleItem>
{
Item = ModelConversions.Convert(inspectionSchedule)
});
}
catch (Exception ex)
{
return(new ServiceResponse <InspectionScheduleItem>
{
HasError = true,
Message = ex.Message
});
}
}
public ServiceResponse <AccreditationRoleItem> GetAccreditationRoleByUserIdAsync(Guid?userId, Guid uniqueId)
{
DateTime startTime = DateTime.Now;
try
{
var inspectionScheduleFacade = this.Container.GetInstance <InspectionScheduleFacade>();
var accreditationRole = inspectionScheduleFacade.GetAccreditationRoleByUserId(userId ?? base.UserId.GetValueOrDefault(), uniqueId);
base.LogMessage("GetAccreditationRoleByUserIdAsync", DateTime.Now - startTime);
return(new ServiceResponse <AccreditationRoleItem>
{
Item = ModelConversions.Convert(accreditationRole)
});
}
catch (Exception ex)
{
return(new ServiceResponse <AccreditationRoleItem>
{
HasError = true,
Message = ex.Message
});
}
}
public async Task <ServiceResponse <ApplicationSectionItem> > Save(ApplicationSectionItem model)
{
var startTime = DateTime.Now;
if (base.RoleId == (int)Constants.Role.FACTAdministrator || base.RoleId == (int)Constants.Role.PrimaryContact || base.RoleId == (int)Constants.Role.QualityManager)
{
try
{
var facade = this.Container.GetInstance <RequirementFacade>();
var section = await facade.SaveAsync(model, base.Email);
base.LogMessage("Requirement/Save", DateTime.Now - startTime);
this.SendInvalidation();
return(new ServiceResponse <ApplicationSectionItem>
{
Item = ModelConversions.Convert(section, model.AppUniqueId)
});
}
catch (Exception ex)
{
return(base.HandleException <ApplicationSectionItem>(ex));
}
}
else
{
return(new ServiceResponse <ApplicationSectionItem>
{
HasError = true,
Message = "Not Authorized"
});
}
}
public async Task <ServiceResponse <SiteProcessingMethodologyTotalItem> > SaveProcessingMethodologyTotal(SiteProcessingMethodologyTotalItem model)
{
DateTime startTime = DateTime.Now;
var siteFacade = this.Container.GetInstance <SiteFacade>();
try
{
var item = await siteFacade.SaveSiteProcessingMethodologyTotalAsync(model, base.Email);
base.LogMessage("SaveProcessingMethodologyTotal", DateTime.Now - startTime);
if (!model.Id.HasValue)
{
item.ProcessingType = new ProcessingType
{
Name = model.ProcessingType.Name
};
}
this.SendInvalidation();
return(new ServiceResponse <SiteProcessingMethodologyTotalItem>
{
Item = ModelConversions.Convert(item)
});
}
catch (Exception ex)
{
return(base.HandleException <SiteProcessingMethodologyTotalItem>(ex));
}
}
public async Task <ServiceResponse <SiteItems> > SaveAsync(SiteItems siteItem)
{
DateTime startTime = DateTime.Now;
try
{
var siteFacade = this.Container.GetInstance <SiteFacade>();
var site = await siteFacade.SaveAsync(siteItem, Email);
base.LogMessage("SaveAsync", DateTime.Now - startTime);
this.SendInvalidation();
return(new ServiceResponse <SiteItems>()
{
Item = ModelConversions.Convert(site, false, false)
});
}
catch (Exception ex)
{
return(new ServiceResponse <SiteItems>()
{
HasError = true,
Message = ex.Message
});
}
}
private ServiceResponse <DocumentItem> AddInternal(DocumentItem model)
{
DateTime startTime = DateTime.Now;
var documentFacade = this.Container.GetInstance <DocumentFacade>();
try
{
if (model.ReplacementOfId.HasValue)
{
documentFacade.ChangeLatest(model.ReplacementOfId.Value, base.Email);
}
var document = documentFacade.AddToLibrary(model.AppUniqueId, model.OrganizationName, model.Name, model.OriginalName, model.StaffOnly, base.Email, model.RequestValues, true, model.IsBaaDocument.GetValueOrDefault());
base.LogMessage("Add", DateTime.Now - startTime);
return(new ServiceResponse <DocumentItem>
{
Item = ModelConversions.Convert(document, false, true)
});
}
catch (Exception ex)
{
return(new ServiceResponse <DocumentItem>
{
HasError = true,
Message = ex.Message
});
}
}
public ServiceResponse <ApplicationVersionItem> Add(ApplicationVersionItem model)
{
var startTime = DateTime.Now;
try
{
var facade = this.Container.GetInstance <RequirementFacade>();
var appFacade = this.Container.GetInstance <ApplicationFacade>();
var version = facade.Add(model.ApplicationType.ApplicationTypeName, model.CopyFromId, model.Title,
model.VersionNumber, model.IsActive, base.Email);
version = appFacade.GetApplicationVersion(version.Id);
base.LogMessage("Version/Add", DateTime.Now - startTime);
return(new ServiceResponse <ApplicationVersionItem>
{
Item = ModelConversions.Convert(version, null, false)
});
}
catch (Exception ex)
{
return(base.HandleException <ApplicationVersionItem>(ex));
}
}
public void SetupDocumentLibrary()
{
var trueVaultManager = this.container.GetInstance <TrueVaultManager>();
var userManager = this.container.GetInstance <UserManager>();
var users = userManager.GetAllUsers();
var groups = trueVaultManager.GetAllGroups();
users = users.Where(x => x.DocumentLibraryUserId == null && x.EmailAddress != null).ToList();
foreach (var user in users)
{
try
{
var orgs = user.Organizations.Select(x => new UserOrganizationItem()
{
Organization = ModelConversions.Convert(x.Organization, false, false)
}).ToList();
user.DocumentLibraryUserId = trueVaultManager.CreateUser(orgs, user.EmailAddress, string.Empty,
groups);
userManager.Save(user);
}
catch (Exception e)
{
//skip record
}
}
}
public void SetupDocumentLibrary(Guid userId)
{
var trueVaultManager = this.container.GetInstance <TrueVaultManager>();
var userManager = this.container.GetInstance <UserManager>();
var users = userManager.GetAllUsers();
var groups = trueVaultManager.GetAllGroups();
var user = users.SingleOrDefault(x => x.Id == userId);
if (user == null)
{
return;
}
var orgs = user.Organizations.Select(x => new UserOrganizationItem()
{
Organization = ModelConversions.Convert(x.Organization, false, false)
}).ToList();
user.DocumentLibraryUserId = trueVaultManager.CreateUser(orgs, user.EmailAddress, string.Empty, groups);
userManager.BatchSave(user);
userManager.SaveChanges();
}
public async Task <ServiceResponse <FacilitySitePageItems> > GetFacilitySiteByUserIdAsync()
{
DateTime startTime = DateTime.Now;
try
{
var facilitySiteFacade = this.Container.GetInstance <FacilitySiteFacade>();
var siteFacade = this.Container.GetInstance <SiteFacade>();
var facilityFacade = this.Container.GetInstance <FacilityFacade>();
var facilitiesSites = await facilitySiteFacade.GetFacilitySiteByUserIdAsync(Email);
FacilitySitePageItems facilitySitePageItems = new FacilitySitePageItems();
facilitySitePageItems.FacilitySiteItems = ModelConversions.Convert(facilitiesSites);
facilitySitePageItems.SiteItems = ModelConversions.Convert(siteFacade.GetAll());
facilitySitePageItems.FacilityItems = ModelConversions.Convert(facilityFacade.GetAll());
base.LogMessage("GetFacilitySiteByUserIdAsync", DateTime.Now - startTime);
return(new ServiceResponse <FacilitySitePageItems>
{
Item = facilitySitePageItems
});
}
catch (Exception ex)
{
return(new ServiceResponse <FacilitySitePageItems>
{
HasError = true,
Message = ex.Message
});
}
}
public async Task <ServiceResponse <UserItem> > Save(UserModel userModel)
{
DateTime startTime = DateTime.Now;
try
{
var userFacade = this.Container.GetInstance <UserFacade>();
await userFacade.RegisterUserAsync(userModel.user, base.IPAddress, userModel.AddToExistingUser, base.Email);
var user = userFacade.GetByEmail(userModel.user.EmailAddress);
var result = ModelConversions.Convert(user);
base.LogMessage("Save", DateTime.Now - startTime);
return(new ServiceResponse <UserItem>
{
Item = result
});
}
catch (Exception ex)
{
return(new ServiceResponse <UserItem>
{
HasError = true,
Message = ex.Message
});
}
}
public List <SiteItems> GetOrganizationSites(string organizationName)
{
var siteManager = this.container.GetInstance <SiteManager>();
var orgFacilityManager = this.container.GetInstance <OrganizationFacilityManager>();
var strongRelations = orgFacilityManager.GetSiteIdsWithStrongRelations(organizationName);
var sites = siteManager.GetSitesByOrganizationInclusive(organizationName);
sites = sites.OrderBy(x => Comparer.OrderSite(x, strongRelations)).ToList();
var result = sites.Select(x => ModelConversions.Convert(x, true, false)).ToList();
foreach (var record in result)
{
record.Facilities = new List <FacilityItems>();
var site = sites.Single(x => x.Id == record.SiteId);
record.IsStrong = strongRelations.Any(x => x == record.SiteId);
foreach (var fac in site.FacilitySites)
{
record.Facilities.Add(ModelConversions.Convert(fac.Facility, false, true));
}
}
return(result);
}
public async Task <List <ScopeTypeItem> > GetAllActiveNonArchivedAsync()
{
DateTime startTime = DateTime.Now;
var scopeTypeFacade = this.Container.GetInstance <ScopeTypeFacade>();
base.LogMessage("GetAsync", DateTime.Now - startTime);
return(ModelConversions.Convert(await scopeTypeFacade.GetAllActiveNonArchivedAsync()).ToList());
}
public async Task <List <DocumentItem> > GetBAADocuments(string org)
{
var facade = this.Container.GetInstance <DocumentFacade>();
var documents = await facade.GetBAAByOrgAsync(org);
return(documents.Select(x => ModelConversions.Convert(x, null, true)).ToList());
}
public List <ApplicationVersionItem> GetAllForApplicationType(List <ApplicationSection> applicationSections, string applicationTypeName, bool onlyIncludeSectionsForActive)
{
LogMessage("GetAllForApplicationTypeItems (ApplicationSectionManager)");
var items = base.Repository.GetByType(applicationTypeName).OrderBy(x => x.CreatedDate).ToList();
return(items.Select(x => ModelConversions.Convert(x, null, onlyIncludeSectionsForActive, applicationSections)).ToList());
}
public async Task <List <ApplicationResponseStatusItem> > GetApplicationResponseStatusAsync()
{
DateTime startTime = DateTime.Now;
var appRespStatusFacade = this.Container.GetInstance <ApplicationResponseStatusFacade>();
base.LogMessage("GetApplicationResponseStatusAsync", DateTime.Now - startTime);
return(ModelConversions.Convert(await appRespStatusFacade.GetApplicationResponseStatusAsync()).ToList());
}
public List <ApplicationVersionItem> GetSimpleActiveVersions()
{
var facade = this.Container.GetInstance <ApplicationFacade>();
var versions = facade.GetSimpleActiveApplicationVersions();
return(versions.Select(x => ModelConversions.Convert(x, null, true, null, false)).ToList());
}
public List <AccreditationOutcomeItem> GetAccreditationOutcome()
{
DateTime startTime = DateTime.Now;
var accreditationOutcomeFacade = this.Container.GetInstance <AccreditationOutcomeFacade>();
base.LogMessage("GetAccreditationOutcome", DateTime.Now - startTime);
return(ModelConversions.Convert(accreditationOutcomeFacade.GetAccreditationOutcome()).ToList());
}
public List <FacilityItems> GetAllActiveFlatAsync()
{
var facade = this.Container.GetInstance <FacilityFacade>();
var facilities = facade.GetAllActive();
return(facilities.Select(x => ModelConversions.Convert(x, false)).OrderBy(x => x.FacilityName).ToList());
}
public ServiceResponse <UserItem> Impersonate(Guid u)
{
if (!base.IsFactStaff)
{
throw new Exception("Not Authorized");
}
var currentUser = base.Email;
this.Logout();
DateTime startTime = DateTime.Now;
var userFacade = this.Container.GetInstance <UserFacade>();
var auditLogFacade = this.Container.GetInstance <AuditLogFacade>();
var trueVaultManager = this.Container.GetInstance <TrueVaultManager>();
try
{
var user = userFacade.GetById(u);
if (user == null)
{
return(new ServiceResponse <UserItem>
{
});
}
var token = trueVaultManager.GetAccessToken(user.DocumentLibraryUserId);
if (token.Result != TrueVaultManager.Success)
{
throw new Exception("Cannot log into True Vault");
}
var userItem = ModelConversions.Convert(user, true, true);
userItem.DocumentLibraryAccessToken = EncodeHelper.EncodeToBase64(token.User.Access_token + ":");
var identity = this.GenerateUserIdentity(user, "", userItem.DocumentLibraryAccessToken, currentUser, true);
this.AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
this.AuthenticationManager.SignIn(new AuthenticationProperties {
IsPersistent = true
}, identity);
auditLogFacade.AddAuditLog(currentUser, base.IPAddress, $"User Impersonation as {user.EmailAddress}");
base.LogMessage("Impersonate", DateTime.Now - startTime);
return(new ServiceResponse <UserItem>
{
Item = userItem
});
}
catch (Exception ex)
{
return(base.HandleException <UserItem>(ex));
}
}
public async Task <List <OrganizationItem> > GetAll(string includeFac, string includeAll)
{
DateTime startTime = DateTime.Now;
var organizationFacade = this.Container.GetInstance <OrganizationFacade>();
var organizations = organizationFacade.GetAll(includeFac == "Y");
//var orgItems = organizations.Select(x=>ModelConversions.Convert(x)).OrderBy(x => x.OrganizationName).ToList();
var statuses = new List <string>
{
Constants.ApplicationStatus.Applied,
Constants.ApplicationStatus.InReview,
Constants.ApplicationStatus.ForReview,
Constants.ApplicationStatus.RFI,
Constants.ApplicationStatus.RFIReview,
Constants.ApplicationStatus.ApplicantResponse,
Constants.ApplicationStatus.ApplicantResponseReview
};
var result = new List <OrganizationItem>();
foreach (var org in organizations)
{
var orgItem = ModelConversions.Convert(org, includeFac == "Y", includeAll == "Y");
var app = org.Applications.FirstOrDefault(x => statuses.Any(y => y == x.ApplicationStatus.Name) && x.ApplicationType.Name == Constants.ApplicationTypes.Eligibility);
if (app != null)
{
orgItem.EligibilityApplicationUniqueId = app.UniqueId;
}
var renewalApp = org.Applications.FirstOrDefault(x => statuses.Any(y => y == x.ApplicationStatus.Name) && x.ApplicationType.Name == Constants.ApplicationTypes.Renewal);
if (renewalApp != null)
{
orgItem.RenewalApplicationUniqueId = renewalApp.UniqueId;
}
var complienceApp = org.Applications.FirstOrDefault(x => statuses.Any(y => y == x.ApplicationStatus.Name) && (x.ApplicationType.Name == Constants.ApplicationTypes.CT || x.ApplicationType.Name == Constants.ApplicationTypes.CordBlood || x.ApplicationType.Name == Constants.ApplicationTypes.Common));
if (complienceApp != null)
{
orgItem.ComplianceApplicationUniqueId = complienceApp.ComplianceApplicationId;
orgItem.ApplicationUniqueId = complienceApp.UniqueId;
}
result.Add(orgItem);
}
base.LogMessage("GetAll", DateTime.Now - startTime);
return(result.OrderBy(x => x.OrganizationName).ToList());
}
public List <DocumentItem> GetPostInspection(string org)
{
var facade = this.Container.GetInstance <DocumentFacade>();
var documents = facade.GetPostInspection(org, base.RoleId.GetValueOrDefault());
var result = documents.Select(x => ModelConversions.Convert(x, null, true)).ToList();
return(result);
}
