protected override void DeleteItem(DataPayLoad payLoad)
{
bool isDeleted = false;
NotifyTaskCompletion.Create(DeleteAsync(payLoad),
(sender, args) =>
{
if (sender is INotifyTaskCompletion <bool> taskCompletion)
{
if (taskCompletion.IsFaulted)
{
DialogService?.ShowErrorMessage("Error during aving: " + taskCompletion.ErrorMessage);
}
if (!taskCompletion.IsSuccessfullyCompleted)
{
return;
}
isDeleted = true;
}
});
if (isDeleted)
{
var dataPayLoad = new DataPayLoad
{
Sender = ViewModelUri.ToString(),
PayloadType = DataPayLoad.Type.UpdateView
};
EventManager.NotifyObserverSubsystem("ReservationRequests", dataPayLoad);
UnregisterToolBar(payLoad.PrimaryKeyValue);
DeleteRegion();
DialogService?.ShowErrorMessage("Data deleted with success!");
}
}
/// <summary>
/// Dictionary of events.
/// </summary>
/// <param name="eventDictionary"></param>
private void OnChangedField(IDictionary <string, object> eventDictionary)
{
object dataObject = DataObject;
DataPayLoad payLoad = BuildDataPayload(eventDictionary);
ChangeFieldHandlerDo <ClientDto> handlerDo = new ChangeFieldHandlerDo <ClientDto>(EventManager,
DataSubSystem.ClientSubsystem);
var fixedValue = DataObject;
FixCreditCardInfo(ref fixedValue, ExpireMonth, ExpireYear);
DataObject = fixedValue;
if (string.IsNullOrEmpty(payLoad.PrimaryKeyValue))
{
payLoad.PrimaryKeyValue = PrimaryKeyValue;
}
SetBasePayLoad(eventDictionary, ref payLoad);
if (CurrentOperationalState == DataPayLoad.Type.Insert)
{
handlerDo.OnInsert(payLoad, eventDictionary);
}
else
{
payLoad.PayloadType = DataPayLoad.Type.Update;
handlerDo.OnUpdate(payLoad, eventDictionary);
}
}
/// <summary>
/// TODO when it is called an insert.
/// </summary>
/// <param name="payload"></param>
public void IncomingPayload(DataPayLoad payload)
{
if (payload.PayloadType == DataPayLoad.Type.Insert)
{
// just the active view shall do an insert for the helpers
var activeView = RegionManager.Regions[RegionNames.TabRegion].ActiveViews.FirstOrDefault();
if (activeView is UserControl control)
{
if (control.DataContext is KarveViewModelBase baseViewModel)
{
if (ViewModelUri == baseViewModel.ViewModelUri)
{
NotifyTaskCompletion.Create(InsertEntity(payload), (ev, result) =>
{
if (result is INotifyTaskCompletion <bool> taskResult)
{
if (taskResult.IsFaulted)
{
DialogService?.ShowErrorMessage("Error inserting:" + taskResult.ErrorMessage);
}
}
});
}
}
}
}
}
public async Task WhenIntegrated_Should_LoadCreditCardExpirationData()
{
var clientService = _dataServices.GetClientDataServices();
var sampleClient = await clientService.GetPagedSummaryDoAsync(1, 2);
var firstClient = sampleClient.FirstOrDefault();
var clientData = await clientService.GetDoAsync(firstClient.Code);
clientData.Value.CreditCardExpiryMonth = "05";
clientData.Value.CreditCardExpiryYear = "27";
var returnValue = await clientService.SaveAsync(clientData);
var newClient = await clientService.GetDoAsync(firstClient.Code);
var payLoad = new DataPayLoad();
payLoad.DataObject = clientData;
payLoad.HasDataObject = true;
payLoad.PayloadType = DataPayLoad.Type.Show;
payLoad.PrimaryKeyValue = clientData.Value.NUMERO_CLI;
_viewModel.IncomingPayload(payLoad);
Assert.AreEqual("05", _viewModel.ExpireMonth);
Assert.AreEqual("27", _viewModel.ExpireYear);
}
private void DoSaveCommand()
{
if (this.IsSaveEnabled)
{
this.CurrentSaveImagePath = KarveToolBarViewModel.currentSaveImage;
this.IsSaveEnabled = false;
DataPayLoad payLoad = _careKeeper.GetScheduledPayload();
if ((_careKeeper.GetScheduledPayloadType() == DataPayLoad.Type.Insert) || (_states == ToolbarStates.Insert))
{
InsertDataCommand dataCommand = new InsertDataCommand(this._dataServices,
this._careKeeper,
this._eventManager,
this._configurationService)
{
ValidationRules = this._validationRules
};
_careKeeper.Do(new CommandWrapper(dataCommand));
_states = ToolbarStates.None;
}
else
{
SaveDataCommand dataCommand = new SaveDataCommand(this._dataServices, this._careKeeper,
this._eventManager, this._configurationService);
payLoad = _careKeeper.Do(new CommandWrapper(dataCommand));
payLoad.PayloadType = DataPayLoad.Type.UpdateView;
_eventManager.NotifyObserverSubsystem(payLoad.SubsystemName, payLoad);
//DeliverIncomingNotify(payLoad.Subsystem, payLoad);
}
}
this.CurrentSaveImagePath = KarveToolBarViewModel.currentSaveImage;
this.IsSaveEnabled = false;
}
public void IncomingPayload(DataPayLoad dataPayLoad)
{
if (dataPayLoad == null)
{
return;
}
if (dataPayLoad.PayloadType != DataPayLoad.Type.Insert)
{
if ((dataPayLoad.Sender != null) && (dataPayLoad.Sender.Equals(ViewModelUri)))
{
return;
}
}
var interpreter = new PayloadInterpeter <IBookingIncidentData>();
var currentId = _dataIncidentService.NewId();
interpreter.Init = Init;
interpreter.CleanUp = CleanUp;
if (string.IsNullOrEmpty(PrimaryKeyValue))
{
PrimaryKeyValue = dataPayLoad.PrimaryKeyValue;
}
if (string.IsNullOrEmpty(PrimaryKeyValue))
{
return;
}
// i check what i have to do.
OperationalState = interpreter.CheckOperationalType(dataPayLoad);
// i act on the system and notify the subsystem
interpreter.ActionOnPayload(dataPayLoad, PrimaryKeyValue, currentId, SubSystem,
EventSubsystem.BookingSubsystemVm);
}
private static async void CalculateTimeLeft()
{
try
{
//Calculate time left in the day
var remainingTimeString = TimeSpan.FromHours(24) - DateTime.Now.TimeOfDay;
var remainingHourInPercentage = Math.Round(((remainingTimeString.TotalHours / 24) * 100), 1);
DataPayLoad = new DataPayLoad()
{
Game = "DAYACTIVE",
Event = "DISPLAY_TIME",
Data = new Data()
{
Value = remainingHourInPercentage.ToString()
}
};
HttpResponseMessage response = await Connector.Client.PostAsJsonAsync(
"game_event", DataPayLoad);
response.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
string currentMethodName = ErrorHandling.GetCurrentMethodName();
ErrorHandling.LogErrorToTxtFile(ex, currentMethodName);
}
}
public override void ExecutePayload(IDataServices services, IEventManager manager, ref DataPayLoad payLoad)
{
DataServices = services;
EventManager = manager;
CurrentPayload = payLoad;
ToolbarInitializationNotifier = NotifyTaskCompletion.Create <DataPayLoad>(HandleSaveOrUpdate(payLoad), ExecutedPayloadHandler);
}
public void Should_Insert_ANewItem()
{
ReservationRequestViewObject viewObject = new ReservationRequestViewObject()
{
NUMERO = "12190"
};
IReservationRequest reservationRequest = new ReservationRequest(viewObject);
bool isRegistered = false;
DataPayLoad currentDataPayLoad = null;
var requestService = new Mock <IReservationRequestDataService>();
requestService.Setup(x => x.GetNewDo(It.IsAny <string>())).Returns(reservationRequest);
_eventManager.Setup(x => x.NotifyToolBar(It.IsAny <DataPayLoad>())).Callback <DataPayLoad>(x =>
{
isRegistered = x.PayloadType == DataPayLoad.Type.RegistrationPayload;
currentDataPayLoad = x;
});
_dataServices.Setup(x => x.GetReservationRequestDataService()).Returns(requestService.Object);
var reservationRequestsView = new ReservationRequestsViewModel(_dataServices.Object, _interacionController.Object, _dialogService.Object, _eventManager.Object, _navigator.Object, null, null, _unityContainer.Object);
// now i should arrange a new id and send to the reservation request view model.
DataPayLoad payload = new DataPayLoad();
payload.PayloadType = DataPayLoad.Type.Insert;
payload.DataObject = reservationRequest;
payload.HasDataObject = true;
reservationRequestsView.IncomingPayload(payload);
Assert.AreEqual(reservationRequestsView.DataObject.NUMERO, viewObject.NUMERO);
}
/// <summary>
/// Reverted current value.
/// </summary>
/// <param name="payLoad">This is the payload.</param>
public override void Revert(DataPayLoad payLoad)
{
var tmp = CurrentValue;
CurrentValue = payLoad.DataObject as Dto;
PreviousValue = tmp;
}
/// <summary>
/// Data payload
/// </summary>
/// <param name="payload">Payload to be used.</param>
private void OnMailBoxHandler(DataPayLoad payload)
{
var newId = string.Empty;
OperationalState = _payloadInterpeter.CheckOperationalType(payload);
_payloadInterpeterReload.ActionOnPayload(payload, payload.PrimaryKeyValue, newId, DataSubSystem.BookingSubsystem, BookingModule.BookingSubSystem);
}
protected void RegisterView(ref DataPayLoad dataPayLoad)
{
Address = new Uri(new Uri("karve://helpers/"), UniqueId);
// needs an unique.
ViewModelUri = Address;
dataPayLoad.ObjectPath = Address;
}
public void Should_Call_AnInitPayload()
{
// arrange
var initValue = 0;
var cleanUpValue = 0;
var payLoad = new DataPayLoad
{
DataObject = new OfficeDtos(),
PrimaryKeyValue = "3893893",
Subsystem = DataSubSystem.OfficeSubsystem,
SubsystemName = MasterModuleConstants.OfficeSubSytemName,
PayloadType = DataPayLoad.Type.Show
};
var parser = new PayloadInterpeter <OfficeDtos>
{
Init = (value, packet, insertion) => { initValue++; },
CleanUp = (key, system, name) => { cleanUpValue++; }
};
// act
parser.ActionOnPayload(payLoad, "3893893", "838393", DataSubSystem.OfficeSubsystem, MasterModuleConstants.OfficeSubSytemName);
// assert.
Assert.AreEqual(initValue, 1);
Assert.AreEqual(cleanUpValue, 0);
}
private async Task <bool> HandleReservationSaveOrUpdate(DataPayLoad payLoad)
{
var reservationService = DataServices.GetReservationRequestDataService();
var dataObject = payLoad.DataObject;
var currentWorkingObject = dataObject;
var result = false;
if (dataObject is KarveDataServices.IReservationRequest req)
{
currentWorkingObject = req.Value;
}
if (currentWorkingObject is ReservationRequestDto currentDto)
{
// hwew we are sure that we are saving.
var currentValue = await reservationService.GetDoAsync(currentDto.NUMERO).ConfigureAwait(false);
if ((currentValue == null))
{
payLoad.PayloadType = DataPayLoad.Type.Insert;
}
currentValue.Value = currentDto;
switch (payLoad.PayloadType)
{
case DataPayLoad.Type.Insert:
case DataPayLoad.Type.Update:
{
result = await reservationService.SaveAsync(currentValue).ConfigureAwait(false);
break;
}
}
}
return(result);
}
protected bool IsForMe <DomainType>(DataPayLoad dataPayLoad, Func <DomainType, bool> fieldCompare) where DomainType : class
{
// is it null?
if (dataPayLoad == null)
{
return(false);
}
// is it sent by myself?
if ((dataPayLoad.Sender != null) && (dataPayLoad.Sender.Equals(ViewModelUri)))
{
return(false);
}
if (dataPayLoad.DataObject == null)
{
return(false);
}
if (PrimaryKeyValue.Length > 0)
{
var request = dataPayLoad.DataObject as DomainType;
if (request == null)
{
return(false);
}
return(fieldCompare(request));
}
return(true);
}
protected override void DeleteItem(DataPayLoad payLoad)
{
NotifyTaskCompletion.Create <bool>(this.DeleteAsync(payLoad),
ev: (sender, args) =>
{
if (!(sender is INotifyTaskCompletion <bool> taskCompletion))
{
return;
}
if (taskCompletion.IsFaulted)
{
DialogService?.ShowErrorMessage("Error during deleting the invoice");
}
if (!taskCompletion.IsSuccessfullyCompleted)
{
return;
}
var dataPayLoad = new DataPayLoad()
{
Sender = ViewModelUri.ToString(),
PayloadType = DataPayLoad.Type.UpdateView
};
EventManager.NotifyObserverSubsystem(InvoiceModule.InvoiceSubSystem, dataPayLoad);
UnregisterToolBar(payLoad.PrimaryKey);
DeleteRegion();
});
}
/// <summary>
/// This is to save or update the data contained in the payload.
/// </summary>
/// <param name="payLoad"></param>
/// <returns></returns>
protected override async Task <DataPayLoad> HandleSaveOrUpdate(DataPayLoad payLoad)
{
DataPayLoad currentPayLoad = payLoad;
if (currentPayLoad.HasDataObject)
{
SetModification(ref currentPayLoad);
Dto currentDto = currentPayLoad.DataObject as Dto;
if (currentDto == null)
{
currentDto = CurrentValue;
}
bool value = await _saver.SaveDto(currentDto);
if (!value)
{
State = "Error in insertion/update";
}
else
{
HelperView.Add(currentDto);
}
SaveState = value;
State = "";
}
return(currentPayLoad);
}
protected override void NewItem()
{
string name = "Nueva Empresa";
//KarveLocale.Properties.Resources.CompanyControlViewModel_NewItem_NuevaEmpresa;
string companyId = _companyDataServices.GetNewId();
string viewNameValue = name + "." + companyId;
// here shall be added to the region
var navigationParameters = new NavigationParameters
{
{ "id", companyId },
{ ScopedRegionNavigationContentLoader.DefaultViewName, viewNameValue }
};
var uri = new Uri(typeof(CompanyInfoView).FullName + navigationParameters, UriKind.Relative);
RegionManager.RequestNavigate("TabRegion", uri);
DataPayLoad currentPayload = BuildShowPayLoadDo(viewNameValue);
currentPayload.Subsystem = DataSubSystem.CompanySubsystem;
currentPayload.PayloadType = DataPayLoad.Type.Insert;
currentPayload.PrimaryKeyValue = companyId;
currentPayload.DataObject = _companyDataServices.GetNewCompanyDo(companyId);
currentPayload.HasDataObject = true;
currentPayload.Sender = EventSubsystem.CompanySummaryVm;
EventManager.NotifyObserverSubsystem(MasterModuleConstants.CompanySubSystemName, currentPayload);
}
public void SaveViewCommand(object key)
{
bool isSaved = false;
_reservationRequest.Value = DataObject;
NotifyTaskCompletion.Create(_dataReservationService.SaveAsync(_reservationRequest), (sender, args) =>
{
if (sender is INotifyTaskCompletion <bool> taskCompletion)
{
if (taskCompletion.IsFaulted)
{
DialogService?.ShowErrorMessage("Error during saving: " + taskCompletion.ErrorMessage);
}
if (taskCompletion.IsSuccessfullyCompleted)
{
isSaved = true;
}
}
});
if (isSaved)
{
var dataPayLoad = new DataPayLoad
{
Sender = ViewModelUri.ToString(),
PayloadType = DataPayLoad.Type.UpdateView
};
EventManager.NotifyObserverSubsystem("ReservationRequests", dataPayLoad);
DialogService?.ShowErrorMessage("Data saved with success!");
}
}
private void OnChangedField(IDictionary <string, object> eventDictionary)
{
DataPayLoad payLoad = BuildDataPayload(eventDictionary);
payLoad.Subsystem = DataSubSystem.SupplierSubsystem;
payLoad.SubsystemName = MasterModuleConstants.ProviderSubsystemName;
payLoad.PayloadType = DataPayLoad.Type.Update;
ChangeFieldHandlerDo <ISupplierData> handlerDo = new ChangeFieldHandlerDo <ISupplierData>(EventManager,
DataSubSystem.SupplierSubsystem);
var fieldName = string.Empty;
SetBasePayLoad(eventDictionary, ref payLoad);
// FIXME: replace conditional with polymorphism.
if (CurrentOperationalState == DataPayLoad.Type.Insert)
{
payLoad.PayloadType = DataPayLoad.Type.Insert;
handlerDo.OnInsert(payLoad, eventDictionary);
}
else
{
payLoad.PayloadType = DataPayLoad.Type.Update;
handlerDo.OnUpdate(payLoad, eventDictionary);
}
}
/// <summary>
/// Update summary.
/// </summary>
/// <param name="payLoad">Payload to be updated.</param>
/// <returns></returns>
public override bool UpdateEntity(DataPayLoad payLoad)
{
State = BaseHelperViewModel.UpdateState;
SaveState = false;
SaveItem(payLoad);
Update();
return(SaveState);
}
/// <summary>
/// This execute a payload.
/// </summary>
/// <param name="services">Data services to be used for executing the payload</param>
/// <param name="manager">Manager to be used for sending messages to the view model</param>
/// <param name="payLoad">Payload to be used for sending it.</param>
public override void ExecutePayload(IDataServices services, IEventManager manager, ref DataPayLoad payLoad)
{
_commissionAgentDataServices = services.GetCommissionAgentDataServices();
DataServices = services;
_payload = payLoad;
EventManager = manager;
_initializationNotifier = NotifyTaskCompletion.Create <DataPayLoad>(HandleCommissionAgentSave(_payload), ExecutedPayloadHandler);
}
/// <summary>
/// Execute the payload when the user press to save and it notifies the
/// </summary>
/// <param name="services">Data services are used to store the data.</param>
/// <param name="manager">Event manager is used to notify the caller and refresh data.</param>
/// <param name="payLoad">Payload to be updated</param>
public override void ExecutePayload(IDataServices services, IEventManager manager, ref DataPayLoad payLoad)
{
CurrentEventManager = manager;
CurrentPayload = payLoad;
DataServices = services ?? throw new ArgumentNullException($"Cannot save without DataServices");
ToolbarInitializationNotifier =
NotifyTaskCompletion.Create <DataPayLoad>(HandleSaveOrUpdate(payLoad), ExecutedPayloadHandler);
}
private void CheckData(DataPayLoad data)
{
// var currentValue = data.CollectionData[3];
var currentType = data.PayloadType;
//Assert.AreEqual(currentValue, 3);
Assert.AreEqual(currentType, DataPayLoad.Type.Insert);
}
/// <summary>
/// In this case we dont know the type so the resposability will be of the view model.
/// </summary>
/// <param name="payLoad">Payload</param>
/// <returns></returns>
protected override async Task <DataPayLoad> HandleSaveOrUpdate(DataPayLoad payLoad)
{
var dataObject = payLoad.DataObject;
Type type = dataObject.GetType();
await Task.Delay(1);
return(payLoad);
}
/// <summary>
/// Delete a company given its primary key
/// </summary>
/// <param name="primaryKey">Delete a single company</param>
/// <param name="payLoad">Payload received</param>
/// <returns></returns>
public override async Task <bool> DeleteAsync(string primaryKey, DataPayLoad payLoad)
{
var data = await _companyDataServices.GetAsyncCompanyDo(primaryKey);
var retValue = await _companyDataServices.DeleteCompanyAsyncDo(data);
return(retValue);
}
/// <summary>
/// This execute the payload and notify the event manager
/// </summary>
/// <param name="services">Services to be used</param>
/// <param name="manager">Manager to be notified</param>
/// <param name="payLoad">Payload to execute.</param>
public override void ExecutePayload(IDataServices services, IEventManager manager, ref DataPayLoad payLoad)
{
_dataServices = services.GetSupplierDataServices();
_payload = payLoad;
EventManager = manager;
DataServices = services;
_initializationNotifier = NotifyTaskCompletion.Create <DataPayLoad>(HandleSaveOrUpdate(_payload), ExecutedPayloadHandler);
}
protected async void HandlePayLoadMessage(DataPayLoad payLoad)
{
if (payLoad.ObjectPath == Address)
{
switch (payLoad.PayloadType)
{
case DataPayLoad.Type.RevertChanges:
{
Revert(payLoad);
break;
}
case DataPayLoad.Type.Delete:
{
bool deleted = await DeleteEntity(payLoad).ConfigureAwait(false);
if (!deleted)
{
DialogService?.ShowErrorMessage("Cannot delete helper entity");
}
else
{
DialogService?.ShowMessage("Information", "Line deleted with success");
}
break;
}
case DataPayLoad.Type.Insert:
{
bool inserted = await InsertEntity(payLoad).ConfigureAwait(false);
if (!inserted)
{
DialogService?.ShowErrorMessage("Cannot insert helper entity");
}
else
{
DialogService?.ShowMessage("Information", "Line inserted with success");
}
break;
}
case DataPayLoad.Type.Update:
{
bool update = UpdateEntity(payLoad);
if (!update)
{
MessageBox.Show("Cannot update helper entity");
}
else
{
DialogService?.ShowMessage("Information", "Line updated with success");
}
break;
}
}
}
}
/// <summary>
/// Register the toolbar.
/// </summary>
protected void RegisterToolBar()
{
// each module notify the toolbar.
var payLoad = new DataPayLoad();
SetRegistrationPayLoad(ref payLoad);
payLoad.PayloadType = DataPayLoad.Type.RegistrationPayload;
EventManager.NotifyToolBar(payLoad);
}
/// <summary>
/// This method register a subsystem.
/// </summary>
private void RegisterSubsystem()
{
DataPayLoad payLoad = new DataPayLoad();
payLoad.PayloadType = DataPayLoad.Type.RegistrationPayload;
payLoad.Subsystem = DataSubSystem.HelperSubsytsem;
RegisterView(ref payLoad);
EventManager.NotifyToolBar(payLoad);
}
