public UpdateResult SetActiveStatus(string id, bool active, string lastUpdateUsername)
{
return(Execute(context =>
{
Guid lastUpdateAccountId = context.Accounts.Single(a => a.Username == lastUpdateUsername).AccountId;
Guid accountId = BaseModel.DecryptId(id);
if (lastUpdateAccountId == accountId)
{
return new UpdateResult("Cannot update your own status");
}
Models.ListItem listItem = DataAccess.ListItem.GetListItem("Status", active ? "Active" : "InActive");
Data.Account account = context.Accounts.Single(acc => acc.AccountId == accountId);
account.StatusId = listItem.GUID;
WriteAudit(context, lastUpdateAccountId);
account.LastUpdateAccountId = account.AccountId;
account.LastUpdateTimestamp = DateTime.Now;
context.SaveChanges();
return new UpdateResult(true);
}));
}
public UpdateResult SetNewPassword(string accountID, string newPassword, string oldPassword, bool verifyOldPassword)
{
return(Execute(context =>
{
Guid accountId = BaseModel.DecryptId(accountID);
Data.Account account = context.Accounts.SingleOrDefault(a => a.AccountId == accountId);
if (account == null)
{
return new UpdateResult("Invalid user");
}
if (verifyOldPassword)
{
if (account.Password != MD5.Hex(oldPassword))
{
return new UpdateResult("Invalid old password");
}
}
account.Password = MD5.Hex(newPassword);
if (!verifyOldPassword)
{
account.ResetBySuperAdmin = true;
}
context.SaveChanges();
return new UpdateResult(true);
}));
}
public JsonResult AddPatientProviders(List <PatientFacility> model)
{
try
{
foreach (var item in model)
{
if (item.DischargedTimestamp.HasValue)
{
_patientService.DeallocateTeamMember(BaseModel.DecryptId(item.PatientId), BaseModel.DecryptId(item.PatientProviderID));
}
else
{
string ICD10 = item.ReasonForAdmissionName.Split(' ')[0];
SADFM.Data.Models.ListItem icd10_ListItem = ICD10 == "Unknown"? null : SADFM.Data.DataAccess.ListItem.GetList("ICD10", filter: li => li.Name == ICD10).FirstOrDefault();
_patientService.AllocateTeamMember(BaseModel.DecryptId(item.PatientId), BaseModel.DecryptId(item.ProviderId), BaseModel.DecryptId(item.AccountID), icd10_ListItem == null? (Guid?)null : icd10_ListItem.GetId(), icd10_ListItem == null? null : item.ICD10CodeTimestamp);
}
}
return(Json(new
{
Success = true
}));
}
catch (Exception ex)
{
return(Json(new UpdateResult(ex.Message)));
}
}
public bool AllowScale(Guid accountId, string scaleID)
{
Guid scaleId = BaseModel.DecryptId(scaleID);
return(Execute(context =>
{
ScalePermission sp = (ScalePermission)context.ScalePermissions.OrderByDescending(x => x.DateCreatedTimestamp).FirstOrDefault(x => x.AccountId == accountId && x.ScaleId == scaleId);
return sp != null && !olderThanYear(sp.LastUpdateTimestamp) && sp.Grade >= 80;
}));
}
public JsonResult Read(string ID)
{
var message = DataAccess.Account.GetMessage(BaseModel.DecryptId(ID), UserHelper.Username);
return(Json(new
{
Message = message,
NewUnreadCount = UserHelper.GetCurrentAccount().UnreadMessageCount
}));
}
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 List <Models.Account> GetAccountsOfProvider(string ProviderId, string AccountId)
{
return(Execute(context =>
{
if (string.IsNullOrWhiteSpace(ProviderId))
{
return new List <Models.Account>();
}
Guid providerId = BaseModel.DecryptId(ProviderId);
List <Models.Account> result = new List <Models.Account>();
foreach (var act in context.ProviderAccountPermissions.Where(pap => pap.ProviderId == providerId && pap.Permission.Description.Equals("Clinician")).Select(pap => pap.Account))
{
if (result.Count(a => a.GUID == act.AccountId) == 0)
{
result.Add((Models.Account)act);
}
}
return result;
}));
}
public void UpdateMesssages(string username, string[] messageIDs, Action <Data.Message> messageUpdate, Action <Data.MessageRecipient> recipientUpdate)
{
Execute(context =>
{
List <Guid> messageIds = messageIDs.Select(s => BaseModel.DecryptId(s)).ToList();
if (messageUpdate != null)
{
foreach (Data.Message message in context.Messages.Where(m => m.FromAccount.Username.ToLower() == username && messageIds.Contains(m.MessageId)))
{
messageUpdate(message);
}
}
foreach (Data.MessageRecipient recipient in context.MessageRecipients.Where(mr => mr.RecipientAccount.Username.ToLower() == username && messageIds.Contains(mr.MessageId)))
{
recipientUpdate(recipient);
}
context.SaveChanges();
return(true);
});
}
public UpdateResult AddPermission(Permission permission)
{
return(Execute(context =>
{
Guid cid = BaseModel.DecryptId(permission.ClientID);
Guid pid = BaseModel.DecryptId(permission.PermissionID);
Guid aid = BaseModel.DecryptId(permission.AccountID);
Data.Provider provider = context.Providers.SingleOrDefault(p => p.ProviderId == cid);
if (provider != null)
{
if (provider.ProviderAccountPermissions.SingleOrDefault(pap => pap.AccountId == aid && pap.PermissionId == pid) == null)
{
provider.ProviderAccountPermissions.Add(new ProviderAccountPermission
{
AccountId = aid,
PermissionId = pid,
});
}
}
else
if (context.FunderAccountPermissions.SingleOrDefault(fap => fap.AccountId == aid && fap.PermissionId == pid && fap.FunderId == cid) == null)
{
context.FunderAccountPermissions.Add(new FunderAccountPermission
{
AccountId = aid,
FunderId = cid,
PermissionId = pid
});
}
context.SaveChanges();
return new UpdateResult(true);
}));
}
public Models.Account VerifyAccount(Models.Account model)
{
return(Execute(context =>
{
Guid accountId;
if (!Guid.TryParse(model.ID, out accountId))
{
return null;
}
Data.Account account;
try
{
account = context.Accounts.Single(a => a.AccountId == accountId);
}
catch
{
return null;
}
account.SecurityQuestionId = BaseModel.DecryptId(model.SecurityQuestionID);
account.SecurityQuestionAnswer = model.SecurityQuestionAnswer;
account.Password = MD5.Hex(model.Password);
Guid lastUpdateAccountId = context.Accounts.OrderBy(a => a.DateCreatedTimestamp).First().AccountId;
WriteAudit(context, lastUpdateAccountId);
account.LastUpdateAccountId = account.AccountId;
account.LastUpdateTimestamp = DateTime.Now;
context.SaveChanges();
return (Models.Account)account;
}));
}
public JsonResult PatientProviders(string Patient)
{
return(Json(
Utilities.DataTableJson(
Utilities.DataTableRequest.Parse(Request.Form),
DataAccess.Patient.GetById(Guid.ParseExact(Patient, "N")).PatientProviders.Select(x =>
{
return new
{
Provider = x.Name,
AssignedDate = x.AssignedTimestamp.ToString("dd MMM yyyy"),
DischargeDate = x.DischargedTimestamp.HasValue ? x.DischargedTimestamp.Value.ToString("dd MMM yyyy") : "",
ID = x.PatientProviderID,
ProviderId = BaseModel.DecryptId(x.ProviderId),
PatientProviderId = BaseModel.DecryptId(x.PatientProviderID),
AccountFullname = x.AccountFullname,
AccountRoles = x.AccountRoles,
CaseId = x.CaseId,
CaseICD10 = x.CaseICD10
};
}).ToList(),
null,
x => x.Provider, x => x.AssignedDate, x => x.CaseICD10, x => x.DischargeDate, x => x.ID, x => x.ProviderId, x => x.PatientProviderId, x => x.AccountFullname, x => x.AccountRoles, x => x.CaseId)));
}
public UpdateResult AddNewUsers(List <Models.Account> newUsers, string clientId, List <string> permissions, string lastUpdateUsername)
{
try
{
return(Execute(context =>
{
Guid lastUpdateAccountId = context.Accounts.Single(a => a.Username == lastUpdateUsername).AccountId;
Guid cid = BaseModel.DecryptId(clientId);
Data.Provider provider = context.Providers.SingleOrDefault(p => p.ProviderId == cid);
Data.ListItem funder = context.ListItems.SingleOrDefault(li => li.ListItemId == cid);
List <Data.Account> inserts = new List <Data.Account>();
foreach (var user in newUsers)
{
var newData = new Data.Account
{
Username = user.Username,
FirstName = user.FirstName,
LastName = user.LastName,
EmailAddress = user.EmailAddress,
Password = string.Empty,
FirstSignIn = true,
ResetBySuperAdmin = false,
AccountTypeId = DataAccess.ListItem.GetListItem("AccountType", "User").GUID,
StatusId = DataAccess.ListItem.GetListItem("Status", "Active").GUID
};
foreach (var permissionId in permissions)
{
Guid pid = BaseModel.DecryptId(permissionId);
if (provider != null)
{
newData.ProviderAccountPermissions.Add(new ProviderAccountPermission
{
ProviderId = cid,
PermissionId = pid
});
}
else if (funder != null)
{
newData.FunderAccountPermissions.Add(new FunderAccountPermission
{
FunderId = cid,
PermissionId = pid
});
}
}
context.Accounts.Add(newData);
inserts.Add(newData);
}
WriteAudit(context, lastUpdateAccountId);
inserts.ForEach(a =>
{
a.LastUpdateAccountId = lastUpdateAccountId;
a.LastUpdateTimestamp = DateTime.Now;
a.DateCreatedTimestamp = DateTime.Now;
});
context.SaveChanges();
return new UpdateResult(true);
}));
}
catch (Exception ex)
{
return(new UpdateResult("Error inserting new users"));
}
}
public JsonResult RemoveScale(string patientId, string scaleId)
{
return(Json(Data.DataAccess.Patient.RemoveScale(Guid.ParseExact(patientId, "N"), BaseModel.DecryptId(scaleId), UserHelper.GetCurrentAccount().GetId())));
}
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 AddScale(string patientId, string scaleId, string frequencyId)
{
return(Json(Data.DataAccess.Patient.AddScale(BaseModel.DecryptId(patientId), BaseModel.DecryptId(scaleId), BaseModel.DecryptId(frequencyId), UserHelper.GetCurrentAccount().GetId(), UserHelper.SelectedClientId.Value)));
}
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 Update(Models.Account account, string lastUpdateUsername)
{
return(Execute(cx =>
{
Guid findId = account.GetId();
Guid lastUpdateAccountId = cx.Accounts.Single(a => a.Username == lastUpdateUsername).AccountId;
Data.Account act = cx.Accounts.SingleOrDefault(a => a.AccountId == findId);
if (act == null)
{
return new UpdateResult("Cannot find account for username: {0}", account.Username);
}
if (act.LastUpdateTimestamp.Ticks != account.Age)
{
return new UpdateResult(UpdateResult.ResultType.DataChanged);
}
try
{
act.FirstName = account.FirstName;
act.LastName = account.LastName;
act.EmailAddress = account.EmailAddress;
act.PracticeNumber = account.PracticeNumber;
act.ProfessionalBodyId = account.ProfessionalBody;
act.RegistrationNumber = account.RegistrationNumber;
if (!string.IsNullOrEmpty(account.TitleId))
{
act.TitleId = Models.BaseModel.DecryptNullableId(account.TitleId);
}
if (account.AccountRoles != null)
{
List <Data.AccountRole> accountRoleList = new List <Data.AccountRole>();
if (act.AccountRoles.Count != 0)
{
accountRoleList = act.AccountRoles.GroupBy(x => x.RoleId).FirstOrDefault().ToList();
}
foreach (Data.AccountRole ar in accountRoleList)
{
act.AccountRoles.Remove(ar);
cx.AccountRoles.Remove(ar);
}
foreach (Data.Models.AccountRole ar in account.AccountRoles)
{
Guid id = BaseModel.DecryptId(ar.RoleID);
if (act.AccountRoles.Where(x => x.RoleId == id).ToList().Count == 0)
{
act.AccountRoles.Add(new AccountRole()
{
RoleId = id,
AccountId = act.AccountId,
AccountRoleId = Guid.NewGuid()
});
}
}
}
act.ContactNumber = account.ContactNumber;
act.IDNumberType = account.IDType;
act.IDNumber = account.IDNumber;
if (account.Avatar != null)
{
act.Avatar = Convert.FromBase64String(account.Avatar.Substring(22));
}
if (cx.ChangeTracker.HasChanges())
{
WriteAudit(cx, lastUpdateAccountId);
act.LastUpdateTimestamp = DateTime.Now;
act.LastUpdateAccountId = lastUpdateAccountId;
act.FirstSignIn = false;
cx.SaveChanges();
}
return new UpdateResult(true);
}
catch (Exception ex)
{
return new UpdateResult("Error updating profile: {0}", ex.Message);
}
}));
}
public ContentResult GetCities(string ProvinceId)
{
if (ProvinceId.Equals(""))
{
return(Content(""));
}
MvcHtmlString combobox = SADFM.Web.Shared.HtmlHelper.DropdownBox(SADFM.Data.DataAccess.ListItem.GetListByParentId(BaseModel.DecryptId(ProvinceId), deep: false), "CityID", l => l.ID, l => l.Description, "chosen-select", dataPlaceholder: "City");
return(Content(combobox.ToHtmlString()));
}
