/// <summary>
/// Function associated to a changed command. When the you user thought the UI changes
/// a control, it will trigger an ItemChangedCommand to be executed.
/// </summary>
/// <param name="dataObject">
/// Object exposed to the view
/// </param>
/// <param name="eventDictionary">
/// Dictionary related to the object
/// </param>
/// <param name="subSystem">
/// Subsystem type: ie. BookingSubsystem
/// </param>
/// <param name="subsystemName">
/// Subsystem name
/// </param>
/// <param name="objectPath">
/// Path of the object
/// </param>
/// <typeparam name="DtoType">
/// Exposed object type
/// </typeparam>
protected void OnChangedCommand <DtoType>(
DtoType dataObject,
IDictionary <string, object> eventDictionary,
DataSubSystem subSystem,
string subsystemName,
string objectPath)
where DtoType : class
{
var payLoad = BuildDataPayload(eventDictionary);
payLoad.PayloadType = DataPayLoad.Type.Update;
payLoad.PrimaryKeyValue = PrimaryKeyValue;
payLoad.HasDataObject = true;
payLoad.DataObject = dataObject;
payLoad.Sender = ViewModelUri.ToString();
payLoad.ObjectPath = ViewModelUri;
var handlerDo = new ChangeFieldHandlerDo <DtoType>(EventManager, subSystem);
if (OperationalState == DataPayLoad.Type.Insert)
{
handlerDo.OnInsert(payLoad, eventDictionary);
}
else
{
payLoad.PayloadType = DataPayLoad.Type.Update;
handlerDo.OnUpdate(payLoad, eventDictionary);
}
}
public DataPayLoad BuildShowPayLoadDo <T>(string name, T Object, DataSubSystem subSystem, string route = "", string sender = "", Uri objectPath = null, IDictionary <string, string> queries = null)
{
var currentPayload = BuildDefaultPayLoad <T>(name, Object, subSystem, route, sender, objectPath, queries);
currentPayload.PayloadType = DataPayLoad.Type.Show;
return(currentPayload);
}
public DataPayLoad BuildSystemDataPayLoad(string path, object dataObject, DataSubSystem subSystem)
{
DataPayLoad payload = new DataPayLoad();
payload.ObjectPath = new Uri(path);
payload.DataObject = dataObject;
payload.Subsystem = subSystem;
return(payload);
}
public DataPayLoad BuildRegistrationPayLoad(string path, object dataObject, DataSubSystem subSystem)
{
DataPayLoad payload = new DataPayLoad();
payload.PayloadType = DataPayLoad.Type.RegistrationPayload;
payload.DataObject = dataObject;
payload.ObjectPath = new Uri(path);
payload.Subsystem = subSystem;
return(payload);
}
/// <summary>
/// ActionOnPayload. This metion acts on a payload calling cleanup or init delegates.
/// </summary>
/// <param name="payLoad">Incoming payload</param>
/// <param name="primaryKeyValue">Primary Key of the view model.</param>
/// <param name="newId">New generated indentifier</param>
/// <param name="subSystem">Current subsystem</param>
/// <param name="subsystemName">Current subsystem name</param>
public void ActionOnPayload(DataPayLoad payLoad, string primaryKeyValue, string newId,
DataSubSystem subSystem, string subsystemName)
{
if (Init == null)
{
throw new Exception("Interpreter not initalized");
}
// check on primary key
switch (payLoad)
{
case null:
case NullDataPayload _:
return;
}
switch (payLoad.PayloadType)
{
case DataPayLoad.Type.Update:
case DataPayLoad.Type.UpdateView:
case DataPayLoad.Type.Show:
{
Init?.Invoke(primaryKeyValue, payLoad, false);
break;
}
case DataPayLoad.Type.Insert:
{
if (string.IsNullOrEmpty(primaryKeyValue))
{
primaryKeyValue = newId;
}
Init?.Invoke(primaryKeyValue, payLoad, true);
break;
}
case DataPayLoad.Type.Delete:
{
if (primaryKeyValue == payLoad.PrimaryKey)
{
CleanUp?.Invoke(payLoad, subSystem, subsystemName);
}
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Delvier incoming notify.
/// TODO: try to unify data subsystem and event subsystem.
/// </summary>
/// <param name="subSystem">Current subsystem</param>
/// <param name="payLoad">Current datapayload</param>
private void DeliverIncomingNotify(DataSubSystem subSystem, DataPayLoad payLoad)
{
payLoad.Subsystem = subSystem;
if (subSystem == DataSubSystem.SupplierSubsystem)
{
_eventManager.SendMessage(EventSubsystem.SuppliersSummaryVm, payLoad);
}
if (subSystem == DataSubSystem.CommissionAgentSubystem)
{
_eventManager.SendMessage(EventSubsystem.CommissionAgentSummaryVm, payLoad);
}
if (subSystem == DataSubSystem.VehicleSubsystem)
{
_eventManager.SendMessage(EventSubsystem.VehichleSummaryVm, payLoad);
}
}
/// <summary>
/// Each different subsytem call this method to notify a change in the system to the toolbar.
/// </summary>
/// <param name="payload"></param>
public void IncomingPayload(DataPayLoad payload)
{
IsNewEnabled = true;
CurrentPayLoad = payload;
switch (payload.PayloadType)
{
// a subsystem has opened a new window with data.
case DataPayLoad.Type.RegistrationPayload:
{
_activeSubSystem = payload.Subsystem;
IsNewEnabled = true;
break;
}
case DataPayLoad.Type.Delete:
{
string primaryKeyValue = payload.PrimaryKeyValue;
_configurationService.CloseTab(primaryKeyValue);
_activeSubSystem = payload.Subsystem;
_states = ToolbarStates.None;
DataPayLoad payLoad = new DataPayLoad
{
PayloadType = DataPayLoad.Type.UpdateView
};
DeliverIncomingNotify(_activeSubSystem, payLoad);
break;
}
case DataPayLoad.Type.UpdateView:
{
break;
}
// a subsystem has updated a new window with data.
case DataPayLoad.Type.Insert:
case DataPayLoad.Type.Update:
{
this.CurrentSaveImagePath = currentSaveImageModified;
this.IsSaveEnabled = true;
// this keeps the value for saving.
//MessageBox.Show("Schedule Payload");
_careKeeper.Schedule(payload);
break;
}
}
}
private DataPayLoad BuildDefaultPayLoad <T>(string name, T Object, DataSubSystem subSystem, string route = "", string sender = "", Uri objectPath = null, IDictionary <string, string> queries = null)
{
var currentPayload = new DataPayLoad();
var routedName = route;
currentPayload.Registration = routedName;
currentPayload.HasDataObject = true;
currentPayload.Subsystem = subSystem;
currentPayload.DataObject = Object;
currentPayload.Sender = sender;
currentPayload.ObjectPath = objectPath;
if (queries != null)
{
currentPayload.Queries = queries;
}
return(currentPayload);
}
/// <summary>
/// This delete asynchronously.
/// </summary>
/// <param name="primaryKey">Value of the primary key.</param>
/// <param name="subSystem">Kind of subsystem</param>
/// <param name="eventSubSystem">Event subsystem</param>
/// <returns></returns>
private async Task <bool> DeleteAsync(string primaryKey, DataSubSystem subSystem, string eventSubSystem)
{
if (string.IsNullOrEmpty(primaryKey))
{
throw new ArgumentNullException();
}
var deleted = false;
try
{
deleted = await _dataReservationService.DeleteAsync(_reservationRequest).ConfigureAwait(false);
}
catch (Exception e)
{
DialogService?.ShowErrorMessage(e.Message);
}
return(deleted);
}
public void NewItem <ViewType>(string subsystemName, string baseUri, DataSubSystem subsystem, string eventManagerName)
{
var id = DataIdentifier.NewId();
var newDo = DataProvider.GetNewDo(id);
var tmp = subsystemName;
var upperFirst = tmp.ToUpper();
tmp = upperFirst[0] + subsystemName.Substring(1);
var viewName = KarveLocale.Properties.Resources.lnew + " " + tmp + "." + id;
var uri = new Uri(baseUri + Guid.NewGuid().ToString());
var currentPayload = BuildShowPayLoadDo(uri.ToString(), newDo);
currentPayload.Subsystem = subsystem;
currentPayload.PayloadType = DataPayLoad.Type.Insert;
currentPayload.PrimaryKeyValue = id;
currentPayload.Sender = "karve://viewfactory";
currentPayload.Destination = uri;
CreateNewItem <ViewType>(viewName, uri, currentPayload);
EventManager.NotifyObserverSubsystem(eventManagerName, currentPayload);
}
private void DoNewCommand()
{
var payLoad = new DataPayLoad
{
PayloadType = DataPayLoad.Type.Insert,
Sender = ViewModelUri.ToString()
};
var activeView = _regionManager.Regions[RegionNames.TabRegion].ActiveViews.FirstOrDefault();
string directSubsystem = string.Empty;
if (activeView != null)
{
if (activeView is UserControl control)
{
if (control.DataContext is KarveViewModelBase baseViewModel)
{
var subsystem = baseViewModel.SubSystem;
if (subsystem != DataSubSystem.None)
{
_activeSubSystem = subsystem;
}
}
}
}
// one user that uses the command registration shall not use any new notification.
Uri uri = null;
if (IsCommandBaseOnly(ref uri))
{
DoNewAll(uri);
}
else
{
DeliverIncomingNotify(_activeSubSystem, payLoad);
}
_states = ToolbarStates.Insert;
}
// when i shall delete.
protected void CleanUp(DataPayLoad payLoad, DataSubSystem subsystem, string eventSubsystem)
{
EventManager.NotifyObserverSubsystem("ReservationRequests", payLoad);
}
protected void CleanUp(DataPayLoad payLoad, DataSubSystem subsystem, string eventSubsystem)
{
DisposeEvents();
}
protected void CleanUp(DataPayLoad payLoad, DataSubSystem subsystem, string eventSubsystem)
{
// DeleteItem(payLoad);
}
/// <summary>
/// Change field strategy.
/// </summary>
/// <param name="ev">Event manager for notify the toolbar.</param>
/// <param name="vmQueries">Dictionary of the queries.</param>
/// <param name="subSystem">Data Subsystem.</param>
public ChangeFieldStrategy(IEventManager ev, IDictionary <string, string> vmQueries, DataSubSystem subSystem)
{
_eventManager = ev;
_viewModelQueries = vmQueries;
}
// when i shall delete.
protected void CleanUp(DataPayLoad payLoad, DataSubSystem subsystem, string eventSubsystem)
{
EventManager.NotifyObserverSubsystem(BookingModule.RequestGroup, payLoad);
}