public ActionResult AddSupplier(List <KeyValue> supplier)
{
try
{
var supplierId = Guid.NewGuid().ToString();
KeyValueService.AddAttribute(supplier, "Id", supplierId);
var supplierReturnObject = SupplierService.InsertSupplier(supplier);
return(supplierReturnObject.State == "success"
? Json(new { state = "success", supplierId = supplierReturnObject.Id }, JsonRequestBehavior.AllowGet)
: Json(new { state = "error", hospital = "" }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(ex.Message, JsonRequestBehavior.AllowGet));
}
}
protected virtual bool EnsureUmbracoUpgradeState(IUmbracoDatabaseFactory databaseFactory, ILogger logger)
{
var upgrader = new Upgrader(new UmbracoPlan());
var stateValueKey = upgrader.StateValueKey;
// no scope, no service - just directly accessing the database
using (var database = databaseFactory.CreateDatabase())
{
CurrentMigrationState = KeyValueService.GetValue(database, stateValueKey);
FinalMigrationState = upgrader.Plan.FinalState;
}
logger.Debug <RuntimeState>("Final upgrade state is {FinalMigrationState}, database contains {DatabaseState}", FinalMigrationState, CurrentMigrationState ?? "<null>");
return(CurrentMigrationState == FinalMigrationState);
}
private async Task CloseBettingAsync(OnChatCommandReceivedArgs e)
{
if (!_isBettingOpen)
{
_client.SendMessage(e, "Betting was already closed.");
return;
}
_isBettingOpen = false;
_canProcessBets = true;
await KeyValueService.CreateOrUpdateAsync(nameof(SlothyBetStatus), nameof(SlothyBetStatus.InProgress));
var stats = CalculateStats();
_client.SendMessage(e, $"Betting is now closed. | {stats}");
}
private async Task RefreshTokenAsync()
{
_api.Settings.AccessToken = null;
_api.Settings.ClientId = _config.SubPointsClientId;
var resp = await _api.Auth.RefreshAuthTokenAsync(_config.SubPointsRefreshToken, _config.SubPointsClientSecret);
_config.SubPointsAccessToken = resp.AccessToken;
_config.SubPointsRefreshToken = resp.RefreshToken;
_api.Settings.AccessToken = _config.SubPointsAccessToken;
_tokenRefreshTimer?.Dispose();
_tokenRefreshTimer = new Timer(async _ => await RefreshTokenAsync(), null, TimeSpan.FromSeconds(resp.ExpiresIn - 600), TimeSpan.FromMilliseconds(-1));
await KeyValueService.CreateOrUpdateAsync("SubPointsTokens", $"{resp.AccessToken}|||||{resp.RefreshToken}");
}
public ActionResult UpdateInformant(List <KeyValue> informant)
{
if (informant == null || informant.Count <= 0)
{
return(Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
KeyValueService.AddAttribute(informant, "ModifiedById", GetCurrentUserId());
var informantPersonReturnObject = PersonService.UpdatePerson(informant);
if (informantPersonReturnObject.State != "success")
{
return(Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
var informantReturnObject = InformantService.UpdateInformant(informant);
return(informantReturnObject.State == "success"
? Json(new { state = "success", informantId = informantReturnObject.Id }, JsonRequestBehavior.AllowGet)
: Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
public ActionResult UpdateNextOfKin(List <KeyValue> nextOfKin)
{
if (nextOfKin == null || nextOfKin.Count <= 0)
{
return(Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
KeyValueService.AddAttribute(nextOfKin, "ModifiedById", GetCurrentUserId());
var personReturnObject = PersonService.UpdatePerson(nextOfKin);
if (personReturnObject.State != "success")
{
return(Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
var returnObject = InformantService.UpdateInformant(nextOfKin);
return(returnObject.State == "success"
? Json(new { state = "success", nextOfKinId = returnObject.Id }, JsonRequestBehavior.AllowGet)
: Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
public ActionResult UpdateDoctor(List <KeyValue> doctor)
{
if (doctor == null || doctor.Count <= 0)
{
return(Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
KeyValueService.AddAttribute(doctor, "ModifiedById", GetCurrentUserId());
var doctorPersonReturnObject = PersonService.UpdatePerson(doctor);
if (doctorPersonReturnObject.State != "success")
{
return(Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
var doctorReturnObject = DoctorService.UpdateDoctor(doctor);
return(doctorReturnObject.State == "success"
? Json(new { state = "success", doctorId = doctorReturnObject.Id }, JsonRequestBehavior.AllowGet)
: Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
public ActionResult UpdateDeceased(List <KeyValue> deceased)
{
if (deceased == null || deceased.Count <= 0)
{
return(Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
KeyValueService.AddAttribute(deceased, "ModifiedById", GetCurrentUserId());
var deceasedPersonReturnObject = PersonService.UpdatePerson(deceased);
if (deceasedPersonReturnObject.State != "success")
{
return(Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
var deceasedReturnObject = DeceasedService.UpdateDeceased(deceased);
return(deceasedReturnObject.State == "success"
? Json(new { state = "success", deceasedId = deceasedReturnObject.Id }, JsonRequestBehavior.AllowGet)
: Json(new { state = "success", message = "" }, JsonRequestBehavior.AllowGet));
}
public async Task InitializeAsync()
{
var raw = await KeyValueService.GetByKeyAsync("SubPointsTokens");
if (!string.IsNullOrEmpty(raw?.Value))
{
var split = raw.Value.Split("|||||");
_config.SubPointsRefreshToken = split[1];
}
await RefreshTokenAsync();
_pubSub.OnChannelSubscription += OnChannelSubscription;
if (_config.TrackSubPoints)
{
_manualUpdateTimer = new Timer(async _ => await UpdateSubPointsFromApiAsync(), null, TimeSpan.Zero, TimeSpan.FromMinutes(5));
_batchSubUpdateTimer = new Timer(async _ => await HandleSubBatchAsync(), null, TimeSpan.Zero, TimeSpan.FromSeconds(5));
}
}
private async Task ProcessBetsAsync(OnChatCommandReceivedArgs e, SlothyBetType type)
{
if (!_canProcessBets)
{
_client.SendMessage(e, $"@{e.Command.ChatMessage.DisplayName}: Bets cannot be processed right now. " +
"If betting is open, close it first.");
return;
}
_canProcessBets = false;
_canProcessCorrection = false;
_client.SendMessage(e, "Processing bets...");
var currentBets = _betSvc.GetAllCurrentBets();
foreach (var bet in currentBets)
{
if (bet.BetType == type)
{
await _slothySvc.AddSlothiesAsync(bet.UserId, bet.Amount);
}
else
{
await _slothySvc.AddSlothiesAsync(bet.UserId, 0 - bet.Amount);
}
}
var stats = CalculateStats();
_previousSlothyBetRecords = currentBets;
_previousBetWinType = type;
await _betSvc.ClearBetsAsync();
await KeyValueService.CreateOrUpdateAsync(nameof(SlothyBetStatus), nameof(SlothyBetStatus.Closed));
_canProcessCorrection = true;
_client.SendMessage(e, $"Bets processed. | {stats}");
}
private async Task ProcessForfeitAsync(OnChatCommandReceivedArgs e)
{
if (!_canProcessBets)
{
_client.SendMessage(e, $"@{e.Command.ChatMessage.DisplayName}: Bets cannot be processed right now.");
return;
}
_canProcessBets = false;
_canProcessCorrection = false;
_previousSlothyBetRecords = _betSvc.GetAllCurrentBets();
_previousBetWinType = SlothyBetType.Void;
await _betSvc.ClearBetsAsync();
await KeyValueService.CreateOrUpdateAsync(nameof(SlothyBetStatus), nameof(SlothyBetStatus.Closed));
_canProcessCorrection = true;
_client.SendMessage(e, "All bets have been canceled.");
}
public ActionResult AddDocument(HttpPostedFileBase proofOfPayment)
{
try
{
if (proofOfPayment == null)
{
return(Json(new { state = "error", message = "" }, JsonRequestBehavior.AllowGet));
}
var documentId = Guid.NewGuid().ToString();
var document = new List <KeyValue>();
KeyValueService.AddAttribute(document, "Id", documentId);
KeyValueService.AddAttribute(document, "FileName", proofOfPayment.FileName);
KeyValueService.AddAttribute(document, "MimeType", proofOfPayment.ContentType);
KeyValueService.AddAttribute(document, "Size", proofOfPayment.ContentLength.ToString());
KeyValueService.AddAttribute(document, "CreatedOn",
DateTime.Now.ToString(CultureInfo.InvariantCulture));
KeyValueService.AddAttribute(document, "CreatedById", GetCurrentUserId());
var stream = proofOfPayment.InputStream;
var binaryReader = new BinaryReader(stream);
var bytes = binaryReader.ReadBytes((int)stream.Length);
var documentReturnObject = DocumentService.InsertDocument(document, bytes);
if (documentReturnObject.State == "success")
{
return(Json(new { state = "success", documentId = documentReturnObject.Id },
JsonRequestBehavior.AllowGet));
}
return(Json(new { state = "error", message = "" }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new { state = "error", message = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
public ServerSettingsViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k) : base(n, a, al, k)
{
}
public InvoiceCreationDetailsViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k) : base(n, a, al, k)
{
}
public WarehouseClientsSuppliersListViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k) : base(n, a, al, k)
{
}
public RegisterViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k) : base(n, a, al, k)
{
}
public ActionResult CreateFuneral(List <KeyValue> deceased, List <KeyValue> informant, List <KeyValue> nextOfKin,
List <KeyValue> doctor, List <KeyValue> homeAffairsOfficer, List <KeyValue> funeral)
{
if (funeral == null)
{
funeral = new List <KeyValue>();
}
if (deceased != null && deceased.Count > 0)
{
var deceasedAddress = KeyValueService.GetAttributeValue(deceased, "FullAddress");
if (deceasedAddress != null)
{
var address = new List <KeyValue>();
KeyValueService.AddAttribute(address, "Id", Guid.NewGuid().ToString());
KeyValueService.AddAttribute(address, "FullAddress", deceasedAddress);
var addressReturnObject = AddressService.InsertAddress(address);
if (addressReturnObject.State == "success")
{
KeyValueService.AddAttribute(deceased, "AddressId", addressReturnObject.Id);
}
}
var deceasedPersonId = Guid.NewGuid().ToString();
KeyValueService.AddAttribute(deceased, "Id", deceasedPersonId);
GenericModelService.AddAuditAttributeForCreateEvent(deceased, GetCurrentUserId());
var deceasedPersonReturnObject = PersonService.InsertPerson(deceased);
if (deceasedPersonReturnObject.State == "success")
{
KeyValueService.AddAttribute(deceased, "PersonId", deceasedPersonId);
var deceasedReturnObject = DeceasedService.InsertDeceased(deceased);
if (deceasedReturnObject.State == "success")
{
KeyValueService.AddAttribute(funeral, "DeceasedId", deceasedReturnObject.Id);
}
}
}
if (informant != null && informant.Count > 0)
{
var informantPersonId = Guid.NewGuid().ToString();
KeyValueService.AddAttribute(informant, "Id", informantPersonId);
GenericModelService.AddAuditAttributeForCreateEvent(informant, GetCurrentUserId());
var informantPersonReturnObject = PersonService.InsertPerson(informant);
if (informantPersonReturnObject.State == "success")
{
KeyValueService.AddAttribute(informant, "PersonId", informantPersonId);
var informantReturnObject = InformantService.InsertInformant(informant);
if (informantReturnObject.State == "success")
{
KeyValueService.AddAttribute(funeral, "InformantId", informantReturnObject.Id);
}
}
}
if (nextOfKin != null && nextOfKin.Count > 0)
{
var nextOfKinPersonId = Guid.NewGuid().ToString();
KeyValueService.AddAttribute(nextOfKin, "Id", nextOfKinPersonId);
GenericModelService.AddAuditAttributeForCreateEvent(nextOfKin, GetCurrentUserId());
var nextOfKinPersonReturnObject = PersonService.InsertPerson(nextOfKin);
if (nextOfKinPersonReturnObject.State == "success")
{
KeyValueService.AddAttribute(nextOfKin, "PersonId", nextOfKinPersonId);
var nextOfKinReturnObject = NextOfKinService.InsertNextOfKin(nextOfKin);
if (nextOfKinReturnObject.State == "success")
{
KeyValueService.AddAttribute(funeral, "NextOfKinId", nextOfKinReturnObject.Id);
}
}
}
if (doctor != null && doctor.Count > 0)
{
if (KeyValueService.AttributeContainsValue(doctor, "Id"))
{
var doctorPersonId = KeyValueService.GetAttributeValue(doctor, "Id");
KeyValueService.AddAttribute(funeral, "DoctorId", doctorPersonId);
}
else
{
var doctorPersonId = Guid.NewGuid().ToString();
KeyValueService.AddAttribute(doctor, "Id", doctorPersonId);
GenericModelService.AddAuditAttributeForCreateEvent(doctor, GetCurrentUserId());
var nextOfKinPersonReturnObject = PersonService.InsertPerson(doctor);
if (nextOfKinPersonReturnObject.State == "success")
{
KeyValueService.AddAttribute(doctor, "PersonId", doctorPersonId);
var doctorReturnObject = DoctorService.InsertDoctor(doctor);
if (doctorReturnObject.State == "success")
{
KeyValueService.AddAttribute(funeral, "DoctorId", doctorReturnObject.Id);
}
}
}
}
if (homeAffairsOfficer != null && homeAffairsOfficer.Count > 0)
{
if (KeyValueService.AttributeContainsValue(homeAffairsOfficer, "Id"))
{
var homeAffairsOfficerPersonId = KeyValueService.GetAttributeValue(homeAffairsOfficer, "Id");
KeyValueService.AddAttribute(funeral, "HomeAffairsOfficerId", homeAffairsOfficerPersonId);
}
else
{
var homeAffairsOfficerPersonId = Guid.NewGuid().ToString();
KeyValueService.AddAttribute(homeAffairsOfficer, "Id", homeAffairsOfficerPersonId);
GenericModelService.AddAuditAttributeForCreateEvent(homeAffairsOfficer, GetCurrentUserId());
var homeAffairsOfficerPersonReturnObject = PersonService.InsertPerson(homeAffairsOfficer);
if (homeAffairsOfficerPersonReturnObject.State == "success")
{
KeyValueService.AddAttribute(homeAffairsOfficer, "PersonId",
homeAffairsOfficerPersonReturnObject.Id);
var homeAffairsOfficerReturnObject =
HomeAffairsOfficerService.InsertHomeAffairesOfficer(homeAffairsOfficer);
if (homeAffairsOfficerReturnObject.State == "success")
{
KeyValueService.AddAttribute(funeral, "HomeAffairsOfficerId",
homeAffairsOfficerReturnObject.Id);
}
}
}
}
if (funeral.Count <= 0)
{
return(Json(new { state = "error", message = "" }, JsonRequestBehavior.AllowGet));
}
var funeralId = Guid.NewGuid().ToString();
KeyValueService.AddAttribute(funeral, "Id", funeralId);
#region Get Vehicle Number
var counterConfiguration = NumberConfigurationService.GetNextNumber("funeral");
var counterConfigurationId = (Guid)counterConfiguration.FirstOrDefault(x => x.Key == "Id").Value;
var entityName = (string)counterConfiguration.FirstOrDefault(x => x.Key == "EntityName").Value;
var nextNumber = (int)counterConfiguration.FirstOrDefault(x => x.Key == "NextNumber").Value;
var prefix = (string)counterConfiguration.FirstOrDefault(x => x.Key == "Prefix").Value;
var incrementBy = (int)counterConfiguration.FirstOrDefault(x => x.Key == "IncrementBy").Value;
var length = (int)counterConfiguration.FirstOrDefault(x => x.Key == "Length").Value;
var number = length == 0 ? "" : nextNumber.ToString("D" + length);
var funeralNumber = prefix + number;
#endregion
KeyValueService.AddAttribute(funeral, "FuneralNumber", funeralNumber);
GenericModelService.AddAuditAttributeForCreateEvent(funeral, GetCurrentUserId());
var funeralReturnObject = FuneralService.InsertFuneral(funeral);
if (funeralReturnObject.State != "success")
{
return(Json(new { state = "error", message = "" }, JsonRequestBehavior.AllowGet));
}
nextNumber = nextNumber + incrementBy;
NumberConfigurationService.SetNextNumber(counterConfigurationId.ToString(), entityName, nextNumber);
return(Json(new { state = "success", funeralId = funeralReturnObject.Id }, JsonRequestBehavior.AllowGet));
}
public ViewUserProfileContactsViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k) : base(n, a, al, k)
{
}
public NewsPageViewModel(INavigationService n, StudioServicesApi a, DatabaseService d, AlertService al, KeyValueService k) : base(n, a, al, k)
{
db = d;
Newsboard = new ObservableCollection <Message>();
MessengerInstance.Register <int>(this, "PublicNewsPrev", (curr_message) =>
{
if (lastSelectedNews < Newsboard.Count - 1)
{
if (Newsboard[lastSelectedNews].Id == curr_message)
{
var msg = Newsboard[lastSelectedNews + 1];
if (!msg.IsRead)
{
markAsRead.Add(lastSelectedNews + 1);
}
MessengerInstance.Send <Message>(msg, "PublicNewsRead");
lastSelectedNews++;
return;
}
}
else
{
MessengerInstance.Send <Message>(null, "PublicNewsRead");
}
});
MessengerInstance.Register <int>(this, "PublicNewsNext", (curr_message) =>
{
if (lastSelectedNews > 0)
{
if (Newsboard[lastSelectedNews].Id == curr_message)
{
var msg = Newsboard[lastSelectedNews - 1];
if (!msg.IsRead)
{
markAsRead.Add(lastSelectedNews - 1);
}
MessengerInstance.Send <Message>(msg, "PublicNewsRead");
lastSelectedNews--;
return;
}
}
else
{
MessengerInstance.Send <Message>(null, "PublicNewsRead");
}
});
}
public CrendorSubPointsController(CrendorWebSocketManager wsMgr, IMemoryCache cache, KeyValueService kvSvc)
{
_wsMgr = wsMgr;
_cache = cache;
_kvSvc = kvSvc;
}
public AddContactMethodViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k) : base(n, a, al, k)
{
}
public WarehouseInvoiceListViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k) : base(n, a, al, k)
{
// Costruttore
}
public ViewMessageViewModel(INavigationService n, StudioServicesApi a, DatabaseService d, AlertService al, KeyValueService k) : base(n, a, al, k)
{
db = d;
MessengerInstance.Register <Message>(this, "PublicNewsRead", async(message) =>
{
if (message == null)
{
ShowToast("Non ci sono ulteriori messaggi");
return;
}
await NavigatedToAsync(message);
});
}
public AddEmailViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k, AssemblyFileReader ar) : base(n, a, al, k)
{
assembly_files = ar;
Email = new Email();
}
public ActionResult UpdateFuneral(List <KeyValue> deceased, List <KeyValue> informant, List <KeyValue> nextOfKin,
List <KeyValue> doctor, List <KeyValue> homeAffairsOfficer, List <KeyValue> funeral)
{
var funeralId = Guid.Empty;
if (funeral == null)
{
funeral = new List <KeyValue>();
}
else
{
funeralId = Guid.Parse(funeral.FirstOrDefault(x => x.Key == "Id")?.Value);
}
if (deceased != null && deceased.Count > 0)
{
KeyValueService.AddAttribute(deceased, "ModifiedById", GetCurrentUserId());
var deceasedPersonReturnObject = PersonService.UpdatePerson(deceased);
if (deceasedPersonReturnObject.State == "success")
{
var deceasedReturnObject = DeceasedService.UpdateDeceased(deceased);
}
}
if (informant != null && informant.Count > 0)
{
var existingInformantCount = InformantService.QueryCountOfInformantsByFuneralId(funeralId);
if (existingInformantCount > 0)
{
KeyValueService.AddAttribute(informant, "ModifiedById", GetCurrentUserId());
var informantPersonReturnObject = PersonService.UpdatePerson(informant);
if (informantPersonReturnObject.State == "success")
{
var informantReturnObject = InformantService.UpdateInformant(informant);
}
}
else
{
var informantPersonId = Guid.NewGuid().ToString();
KeyValueService.AddAttribute(informant, "Id", informantPersonId);
GenericModelService.AddAuditAttributeForCreateEvent(informant, GetCurrentUserId());
var informantPersonReturnObject = PersonService.InsertPerson(informant);
if (informantPersonReturnObject.State == "success")
{
KeyValueService.AddAttribute(informant, "PersonId", informantPersonId);
var informantReturnObject = InformantService.InsertInformant(informant);
if (informantReturnObject.State == "success")
{
KeyValueService.SetOrAddAttribute(funeral, "InformantId", informantReturnObject.Id);
}
}
}
}
if (nextOfKin != null && nextOfKin.Count > 0)
{
var existingNextOfKinCount = NextOfKinService.QueryCountOfNextOsKinssByFuneralId(funeralId);
if (existingNextOfKinCount > 0)
{
KeyValueService.AddAttribute(nextOfKin, "ModifiedById", GetCurrentUserId());
var nextOfKinPersonReturnObject = PersonService.UpdatePerson(nextOfKin);
if (nextOfKinPersonReturnObject.State == "success")
{
var nextOfKinReturnObject = NextOfKinService.UpdateNextOfKin(nextOfKin);
}
}
else
{
var nextOfKinPersonId = Guid.NewGuid().ToString();
KeyValueService.AddAttribute(nextOfKin, "Id", nextOfKinPersonId);
GenericModelService.AddAuditAttributeForCreateEvent(nextOfKin, GetCurrentUserId());
var nextOfKinPersonReturnObject = PersonService.InsertPerson(nextOfKin);
if (nextOfKinPersonReturnObject.State == "success")
{
KeyValueService.AddAttribute(nextOfKin, "PersonId", nextOfKinPersonId);
var nextOfKinReturnObject = NextOfKinService.InsertNextOfKin(nextOfKin);
if (nextOfKinReturnObject.State == "success")
{
KeyValueService.SetOrAddAttribute(funeral, "NextOfKinId", nextOfKinReturnObject.Id);
}
}
}
}
//if (doctor != null && doctor.Count > 0)
//{
// var existingDoctorCount = DoctorService.QueryCountOfDoctorsByFuneralId(funeralId);
// if (existingDoctorCount > 0)
// {
// KeyValueService.AddAttribute(doctor, "ModifiedById", GetCurrentUserId());
// var nextOfKinPersonReturnObject = PersonService.UpdatePerson(doctor);
// if (nextOfKinPersonReturnObject.State == "success")
// {
// DoctorService.UpdateDoctor(doctor);
// }
// }
// else
// {
// var doctorPersonId = Guid.NewGuid().ToString();
// KeyValueService.AddAttribute(doctor, "Id", doctorPersonId);
// GenericModelService.AddAuditAttributeForCreateEvent(doctor, GetCurrentUserId());
// var nextOfKinPersonReturnObject = PersonService.InsertPerson(doctor);
// if (nextOfKinPersonReturnObject.State == "success")
// {
// KeyValueService.AddAttribute(doctor, "PersonId", doctorPersonId);
// var doctorReturnObject = DoctorService.InsertDoctor(doctor);
// KeyValueService.SetOrAddAttribute(funeral, "DoctorId", doctorReturnObject.Id);
// }
// }
//}
//if (homeAffairsOfficer != null && homeAffairsOfficer.Count > 0)
//{
// var existingHomeAffairsOfficerCount = HomeAffairsOfficerService.QueryCountOfHomeAffairsOfficersByFuneralId(funeralId);
// if(existingHomeAffairsOfficerCount > 0)
// {
// KeyValueService.AddAttribute(homeAffairsOfficer, "ModifiedById", GetCurrentUserId());
// var homeAffairsOfficerPersonReturnObject = PersonService.UpdatePerson(homeAffairsOfficer);
// }
// else
// {
// var homeAffairsOfficerPersonId = Guid.NewGuid().ToString();
// KeyValueService.AddAttribute(homeAffairsOfficer, "Id", homeAffairsOfficerPersonId);
// GenericModelService.AddAuditAttributeForCreateEvent(homeAffairsOfficer, GetCurrentUserId());
// var homeAffairsOfficerPersonReturnObject = PersonService.InsertPerson(homeAffairsOfficer);
// if (homeAffairsOfficerPersonReturnObject.State == "success")
// {
// KeyValueService.AddAttribute(homeAffairsOfficer, "PersonId", Guid.NewGuid().ToString());
// var homeAffairsOfficerReturnObject = HomeAffairsOfficerService.InsertHomeAffairesOfficer(homeAffairsOfficer);
// if(homeAffairsOfficerReturnObject.State == "success")
// {
// KeyValueService.SetOrAddAttribute(funeral, "HomeAffairsOfficerId", homeAffairsOfficerReturnObject.Id);
// }
// }
// }
//}
if (funeral.Count <= 0)
{
return(Json("error", JsonRequestBehavior.AllowGet));
}
KeyValueService.AddAttribute(funeral, "ModifiedById", GetCurrentUserId());
var funeralReturnObject = FuneralService.UpdateFuneral(funeral);
return(funeralReturnObject.State == "success"
? Json(new { state = "success", funeralId = funeralReturnObject.Id }, JsonRequestBehavior.AllowGet)
: Json("error", JsonRequestBehavior.AllowGet));
}
public MyViewModel(INavigationService n, StudioServicesApi a, AlertService alert, KeyValueService kv)
{
Navigation = n as NavigationService;
api = a;
messageService = alert;
kvSettings = kv;
}
public AddCompanyProductViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k) : base(n, a, al, k)
{
}
public AddInvoiceProductPopupViewModel(INavigationService n, StudioServicesApi a, AlertService al, KeyValueService k) : base(n, a, al, k)
{
}
