public Models.UpdateResult SaveListItem(Models.ListItem model)
{
return(Execute(context =>
{
Guid lastUpdateAccountId = context.Accounts.Single(a => a.Username == model.LastUpdateUsername).AccountId;
Data.ListItem listItem;
if (!string.IsNullOrEmpty(model.ID))
{
Guid listItemId = BaseModel.DecryptId(model.ID);
listItem = context.ListItems.Single(li => li.ListItemId == listItemId);
if (listItem.LastUpdateTimestamp.Ticks != model.Age)
{
return new UpdateResult(UpdateResult.ResultType.DataChanged);
}
}
else
{
listItem = new Data.ListItem
{
ParentId = BaseModel.DecryptNullableId(model.ParentID),
StatusId = GetListItem("Status", "Active").GUID
};
context.ListItems.Add(listItem);
}
if (!string.IsNullOrWhiteSpace(model.Name))
{
listItem.Name = model.Name;
}
listItem.Description = model.Description;
listItem.SortOrder = model.SortOrder;
listItem.Code = model.Code;
listItem.Value = model.Value;
WriteAudit(context, lastUpdateAccountId);
listItem.LastUpdateAccountId = lastUpdateAccountId;
listItem.LastUpdateTimestamp = DateTime.Now;
context.SaveChanges();
return new UpdateResult(true);
}));
}
public UpdateResult UpdatePatient(Data.Models.Patient model, Guid accountId)
{
return(Execute(context =>
{
Guid patientId = BaseModel.DecryptId(model.ID);
Data.Patient patient = context.Patients.FirstOrDefault(x => x.PatientId == patientId);
patient.FirstName = model.FirstName;
patient.LastName = model.LastName;
patient.TitleId = BaseModel.DecryptNullableId(model.TitleId);
patient.BirthDate = model.BirthDate;
patient.GenderId = BaseModel.DecryptNullableId(model.GenderID);
patient.RaceId = BaseModel.DecryptNullableId(model.RaceID);
patient.ContactNumber = model.ContactNumber;
patient.IDNumber = model.IDNumber;
patient.Street = model.Street;
patient.CityId = BaseModel.DecryptNullableId(model.CityId);
patient.ProvinceId = BaseModel.DecryptNullableId(model.ProvinceId);
patient.CountryId = BaseModel.DecryptNullableId(model.CountryID);
patient.PostalCode = model.PostalCode;
patient.NextOfKinName = model.NextOfKinName;
patient.NextOfKinContact = model.NextOfKinContact;
patient.MedicalSchemeMembershipNumber = model.MedicalSchemeNo;
patient.MedicalSchemeId = BaseModel.DecryptNullableId(model.MedicalSchemeID);
patient.NextOfKinEmail = model.NextOfKinEmail;
patient.NextOfKinRelationship = model.NextOfKinRelationship;
patient.ResidentialEnvironmentId = BaseModel.DecryptNullableId(model.ResidentialEnvironmentID);
patient.AdmitFromId = BaseModel.DecryptNullableId(model.AdmitFromID);
patient.DischargeToId = BaseModel.DecryptNullableId(model.DischargeToID);
var deleteList = new List <PatientSupportService>();
foreach (var supportService in patient.PatientSupportServices)
{
if (model.SupportServices.Count(x => x.SupportServiceId == supportService.SupportServiceId) == 0)
{
deleteList.Add(supportService);
}
else
{
supportService.Note = model.SupportServices.Single(x => x.SupportServiceId == supportService.SupportServiceId).Note;
}
}
foreach (var supportService in deleteList)
{
context.PatientSupportServices.Remove(supportService);
}
if (model.SupportServices != null)
{
foreach (var supportService in model.SupportServices)
{
if (patient.PatientSupportServices.Count(x => x.SupportServiceId == supportService.SupportServiceId) == 0)
{
patient.PatientSupportServices.Add(new PatientSupportService()
{
SupportServiceId = supportService.SupportServiceId,
Note = supportService.Note,
LastUpdatedTimestamp = DateTime.Now,
LastUpdatedAccountId = accountId
});
}
}
}
WriteAudit(context, accountId);
patient.LastUpdateTimestamp = DateTime.Now;
patient.LastUpdateAccountId = accountId;
context.SaveChanges();
return new UpdateResult(true);
}));
}
public UpdateResult SaveNewProvider(Models.Provider model, Guid accountId)
{
return(Execute(context =>
{
if (model.ProviderID == null)
{
Data.Provider newProvider = new Data.Provider
{
Name = model.Name,
IsGroup = model.IsGroup,
AcuityTypeId = model.AcuityTypeId,
DateCreatedTimestamp = DateTime.Now,
LastUpdateTimestamp = DateTime.Now,
LastUpdateAccountId = accountId,
MonthlyRate = Convert.ToDecimal(model.MonthlyRate),
ProfileImage = model.ProfileImage != null ? Convert.FromBase64String(model.ProfileImage) : null
};
if (model.ParentID != null)
{
newProvider.ParentId = BaseModel.DecryptNullableId(model.ParentID);
}
else
{
newProvider.ParentId = null;
}
if (!model.IsGroup)
{
List <Data.ProviderServiceType> providerServiceTypeList = new List <ProviderServiceType>();
foreach (Data.Models.ProviderServiceType pst in model.ServiceTypes)
{
Data.ProviderServiceType providerServiceType = new Data.ProviderServiceType()
{
CityId = BaseModel.DecryptNullableId(pst.CityID),
ContactNumber = pst.ContactNumber,
CountryId = BaseModel.DecryptNullableId(pst.CountryID),
DateCreatedTimestamp = DateTime.Now,
LastUpdateAccountId = accountId,
LastUpdateTimestamp = DateTime.Now,
PostalCode = pst.PostalCode,
ProvinceId = BaseModel.DecryptNullableId(pst.ProvinceID),
Street = pst.Street,
ServiceTypeId = BaseModel.DecryptId(pst.ServiceTypeID),
};
List <Data.ProviderServiceTypeScale> scaleList = new List <ProviderServiceTypeScale>();
foreach (string s in pst.ScaleList)
{
scaleList.Add(new Data.ProviderServiceTypeScale()
{
ScaleId = BaseModel.DecryptId(s)
});
}
providerServiceType.ProviderServiceTypeScales = scaleList;
providerServiceTypeList.Add(providerServiceType);
}
newProvider.ProviderServiceTypes = providerServiceTypeList;
}
context.Providers.Add(newProvider);
WriteAudit(context, accountId);
context.SaveChanges();
foreach (ProviderServiceType pst in newProvider.ProviderServiceTypes)
{
foreach (ProviderServiceTypeScale psts in pst.ProviderServiceTypeScales)
{
WriteManualAudit(context, new Data.Audit()
{
TableName = "ProviderServiceTypeScale",
FieldName = "ScaleId",
OldValue = null,
NewValue = psts.ScaleId.ToString(),
UpdateDate = DateTime.Now,
AccountId = accountId,
PrimaryKeyId = newProvider.ProviderId,
ChangeTypeId = DataAccess.ListItem.GetList("ChangeType").Single(x => x.Name == "Insert").GetId()
});
}
}
context.SaveChanges();
}
else
{
Guid providerGUID = Data.Models.BaseModel.DecryptId(model.ProviderID);
Data.Provider provider = context.Providers.SingleOrDefault(x => x.ProviderId == providerGUID);
provider.Name = model.Name;
provider.IsGroup = model.IsGroup;
provider.AcuityTypeId = model.AcuityTypeId;
provider.MonthlyRate = Convert.ToDecimal(model.MonthlyRate);
provider.ProfileImage = model.ProfileImage != null ? Convert.FromBase64String(model.ProfileImage) : null;
if (model.ParentID != null)
{
provider.ParentId = BaseModel.DecryptNullableId(model.ParentID);
}
else
{
provider.ParentId = null;
}
if (!model.IsGroup)
{
List <ProviderServiceType> tempListProviderServiceType = new List <ProviderServiceType>();
foreach (ProviderServiceType pst in provider.ProviderServiceTypes)
{
if (model.ServiceTypes.Where(x => x.ID != null).Where(x => BaseModel.DecryptId(x.ID) == pst.ProviderServiceTypeId).ToList().Count == 0)
{
tempListProviderServiceType.Add(pst);
}
}
foreach (ProviderServiceType pst in tempListProviderServiceType)
{
List <ProviderServiceTypeScale> tempScaleList = pst.ProviderServiceTypeScales.ToList();
foreach (ProviderServiceTypeScale psts in tempScaleList)
{
context.ProviderServiceTypeScales.Remove(psts);
WriteManualAudit(context, new Data.Audit()
{
TableName = "ProviderServiceTypeScale",
FieldName = "ScaleId",
OldValue = psts.ScaleId.ToString(),
NewValue = null,
UpdateDate = DateTime.Now,
AccountId = accountId,
PrimaryKeyId = provider.ProviderId,
ChangeTypeId = DataAccess.ListItem.GetList("ChangeType").Single(x => x.Name == "Delete").GetId()
});
}
context.ProviderServiceTypes.Remove(pst);
}
if (model.ServiceTypes != null)
{
foreach (Data.Models.ProviderServiceType pst in model.ServiceTypes)
{
Guid ID;
Data.ProviderServiceType providerServiceType;
if (pst.ID != null)
{
ID = Data.Models.BaseModel.DecryptId(pst.ID);
providerServiceType = provider.ProviderServiceTypes.Single(x => x.ProviderServiceTypeId == ID);
}
else
{
providerServiceType = new ProviderServiceType();
providerServiceType.ProviderServiceTypeId = Guid.NewGuid();
}
providerServiceType.CityId = BaseModel.DecryptNullableId(pst.CityID);
providerServiceType.ContactNumber = pst.ContactNumber;
providerServiceType.CountryId = BaseModel.DecryptNullableId(pst.CountryID);
providerServiceType.LastUpdateAccountId = accountId;
providerServiceType.LastUpdateTimestamp = DateTime.Now;
providerServiceType.PostalCode = pst.PostalCode;
providerServiceType.ProvinceId = BaseModel.DecryptNullableId(pst.ProvinceID);
providerServiceType.Street = pst.Street;
List <ProviderServiceTypeScale> tempList = new List <ProviderServiceTypeScale>();
foreach (ProviderServiceTypeScale psts in providerServiceType.ProviderServiceTypeScales)
{
if (pst.ScaleList.Where(x => BaseModel.DecryptId(x) == psts.ScaleId).ToList().Count == 0)
{
tempList.Add(psts);
}
}
foreach (ProviderServiceTypeScale psts in tempList)
{
providerServiceType.ProviderServiceTypeScales.Remove(psts);
context.ProviderServiceTypeScales.Remove(psts);
WriteManualAudit(context, new Data.Audit()
{
TableName = "ProviderServiceTypeScale",
FieldName = "ScaleId",
OldValue = psts.ScaleId.ToString(),
NewValue = null,
UpdateDate = DateTime.Now,
AccountId = accountId,
PrimaryKeyId = provider.ProviderId,
ChangeTypeId = DataAccess.ListItem.GetList("ChangeType").Single(x => x.Name == "Delete").GetId()
});
}
foreach (string scaleId in pst.ScaleList)
{
if (providerServiceType.ProviderServiceTypeScales.Where(x => x.ScaleId == BaseModel.DecryptId(scaleId)).ToList().Count == 0)
{
ProviderServiceTypeScale tempScale = new ProviderServiceTypeScale()
{
ScaleId = BaseModel.DecryptId(scaleId)
};
if (pst.ID != null)
{
tempScale.ProviderServiceTypeId = BaseModel.DecryptId(pst.ID);
}
providerServiceType.ProviderServiceTypeScales.Add(tempScale);
WriteManualAudit(context, new Data.Audit()
{
TableName = "ProviderServiceTypeScale",
FieldName = "ScaleId",
OldValue = null,
NewValue = tempScale.ScaleId.ToString(),
UpdateDate = DateTime.Now,
AccountId = accountId,
PrimaryKeyId = provider.ProviderId,
ChangeTypeId = DataAccess.ListItem.GetList("ChangeType").Single(x => x.Name == "Insert").GetId()
});
}
}
if (pst.ID == null)
{
providerServiceType.ServiceTypeId = BaseModel.DecryptId(pst.ServiceTypeID);
providerServiceType.ProviderId = provider.ProviderId;
providerServiceType.DateCreatedTimestamp = DateTime.Now;
provider.ProviderServiceTypes.Add(providerServiceType);
}
}
}
}
WriteAudit(context, accountId);
context.SaveChanges();
}
return new UpdateResult(true);
}));
}
public JsonResult NewCase(ViewModels.Case model)
{
string ICD10 = model.ICD10ID.Split(' ')[0];
SADFM.Data.Models.ListItem icd10_ListItem = SADFM.Data.DataAccess.ListItem.GetList("ICD10", filter: li => li.Name == ICD10).FirstOrDefault();
if (icd10_ListItem == null)
{
return(Json(new { Success = false, Error = "Cannot find ICD" }));
}
if (model.CaseId == null)
{
Data.Models.Account account = UserHelper.GetCurrentAccount();
Guid accountId = account.GetId();
SADFM.Data.Case caseObject = new SADFM.Data.Case()
{
ICD10Id = icd10_ListItem.GetId(),
CaseId = Guid.NewGuid(),
DateCreatedTimestamp = DateTime.Now,
LastUpdateTimestamp = DateTime.Now,
StartDate = model.StartDate,
EndDate = model.EndDate,
PatientId = SADFM.Data.Models.BaseModel.DecryptId(model.PatientId),
LastUpdateAccountId = UserHelper.GetCurrentAccount().GetId(),
ImpairmentGroupId = model.ImpairmentGroupId != null?BaseModel.DecryptNullableId(model.ImpairmentGroupId) : null,
ReferringDoctor = model.ReferringDoctor,
ReferringDoctorContact = model.ReferringDoctorContact,
ReferringDoctorEmail = model.ReferringDoctorEmail,
ReferringDoctorPracticeNumber = model.ReferringDoctorPracticeNumber,
TreatingDoctor = model.TreatingDoctor,
TreatingDoctorContact = model.TreatingDoctorContact,
TreatingDoctorEmail = model.TreatingDoctorEmail,
TreatingDoctorPracticeNumber = model.TreatingDoctorPracticeNumber,
AdmissionStatusId = SADFM.Data.Models.BaseModel.DecryptNullableId(model.AdmissionStatusId)
};
if (UserHelper.GetCurrentAccount().Permissions.Count(x => x.GetClientId() == UserHelper.SelectedClientId && (x.PermissionDescription.Equals("Clinician"))) != 0)
{
caseObject.PatientProviders.Add(new Data.PatientProvider()
{
AccountId = UserHelper.GetCurrentAccount().GetId(),
AssignedTimestamp = DateTime.Now,
CreatedTimestamp = DateTime.Now,
LastUpdateAccountId = UserHelper.GetCurrentAccount().GetId(),
LastUpdateTimestamp = DateTime.Now,
ProviderId = UserHelper.SelectedClientId.Value,
PatientProviderId = Guid.NewGuid(),
PatientId = SADFM.Data.Models.BaseModel.DecryptId(model.PatientId)
});
}
DataAccess.Account.AddCase(caseObject, UserHelper.GetCurrentAccount().GetId());
return(Json(new
{
Success = true,
Id = caseObject.CaseId.ToString("N")
}));
}
else
{
return(Json(DataAccess.Account.UpdateCase(new Data.Case()
{
CaseId = Data.Models.BaseModel.DecryptId(model.CaseId),
StartDate = model.StartDate,
EndDate = model.EndDate,
ICD10Id = icd10_ListItem.GetId(),
PatientId = Data.Models.BaseModel.DecryptId(model.PatientId),
ImpairmentGroupId = model.ImpairmentGroupId != null ? BaseModel.DecryptNullableId(model.ImpairmentGroupId) : null,
ReferringDoctor = model.ReferringDoctor,
ReferringDoctorContact = model.ReferringDoctorContact,
ReferringDoctorEmail = model.ReferringDoctorEmail,
ReferringDoctorPracticeNumber = model.ReferringDoctorPracticeNumber,
TreatingDoctor = model.TreatingDoctor,
TreatingDoctorContact = model.TreatingDoctorContact,
TreatingDoctorEmail = model.TreatingDoctorEmail,
TreatingDoctorPracticeNumber = model.TreatingDoctorPracticeNumber,
AdmissionStatusId = SADFM.Data.Models.BaseModel.DecryptNullableId(model.AdmissionStatusId)
}, UserHelper.GetCurrentAccount().GetId())));
}
}
