/// <summary>
/// Send a message from a view module to another view module.
/// </summary>
/// <param name="viewModuleId">Identifier of the view model</param>
/// <param name="payLoad">Message to be sent directly to the view model</param>
public void SendMessage(string viewModuleId, DataPayLoad payLoad)
{
if (_mailBox.ContainsKey(viewModuleId))
{
MailBoxMessageHandler messageHandler = _mailBox[viewModuleId];
messageHandler?.Invoke(payLoad);
}
else
{
if (payLoad.PayloadType == DataPayLoad.Type.Delete)
{
NotifyObserverSubsystem(viewModuleId, payLoad);
return;
}
if (payLoad.PrimaryKeyValue == null)
{
NotifyObserverSubsystem(viewModuleId, payLoad);
return;
}
// second chance
string primaryKeyValue = viewModuleId + "." + payLoad.PrimaryKeyValue;
if (_mailBox.ContainsKey(primaryKeyValue))
{
MailBoxMessageHandler messageHandler = _mailBox[primaryKeyValue];
messageHandler?.Invoke(payLoad);
}
}
}
public void MergePayLoad(DataPayLoad payLoad)
{
var payLoads = _payLoad.AsList();
if (payLoad.ObjectPath != null)
{
var samePayLoads = payLoads.Where(x => x.ObjectPath == payLoad.ObjectPath);
if (EnqueueSingle(payLoad))
{
var otherPayloads = payLoads.Except(samePayLoads);
IList <DataPayLoad> payload = new List <DataPayLoad>();
payload.Add(payLoad);
var unionPayLoad = otherPayloads.Union(payload);
_payLoad.Clear();
foreach (var p in unionPayLoad)
{
_payLoad.Enqueue(p);
}
}
else
{
_payLoad.Enqueue(payLoad);
}
}
else
{
// anonymous payload.
_payLoad.Enqueue(payLoad);
}
}
private void NotifyObserver(DataPayLoad payload, IList <IEventObserver> eoList)
{
IsNotified = true;
for (int i = 0; i < eoList.Count; ++i)
{
IEventObserver eo = eoList[i];
eo.IncomingPayload(payload);
}
}
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);
}
/// <summary>
/// Summary. Registered mailbox.
/// </summary>
/// <param name="id">Identifier.</param>
/// <param name="payLoad">Payload.</param>
/// <returns></returns>
public bool IsRegisteredMailbox(string id, DataPayLoad payLoad)
{
string primaryKeyValue = id + "." + payLoad.PrimaryKeyValue;
if (_mailBox.ContainsKey(primaryKeyValue))
{
return(true);
}
return(_mailBox.ContainsKey(id));
}
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>
/// This function has the single resposability to check the current operational state.
/// </summary>
/// <param name="payLoad"></param>
/// <returns></returns>
public DataPayLoad.Type CheckOperationalType(DataPayLoad payLoad)
{
switch (payLoad.PayloadType)
{
case DataPayLoad.Type.UpdateView:
case DataPayLoad.Type.Show:
return(DataPayLoad.Type.Show);
default:
return(payLoad.PayloadType);
}
}
private void NotifyObserver(DataPayLoad payload, IList <WeakReference <IEventObserver> > eoList)
{
IsNotified = true;
for (int i = 0; i < eoList.Count; ++i)
{
IEventObserver eo = null;
if (eoList[i].TryGetTarget(out eo))
{
eo.IncomingPayload(payload);
}
}
}
/// <summary>
/// Schedule a payload.
/// </summary>
/// <param name="payload">Payload to be scheduled</param>
public void Schedule(DataPayLoad payload)
{
if (payload?.DataObject == null)
{
return;
}
if (!_payLoad.Contains(payload))
{
MergePayLoad(payload);
}
_scheduledPayLoad = _payLoad.Any();
}
/// <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>
/// Insert a command in the history
/// </summary>
/// <param name="w">CommandWrapper that incapusulate the command</param>
/// <returns>The descheduled payload, already executed</returns>
public DataPayLoad Do(CommandWrapper w)
{
var currentPayload = new DataPayLoad();
if (_payLoad.Count <= 0)
{
return(currentPayload);
}
currentPayload = _payLoad.Dequeue();
w.Parameters = currentPayload;
_history.DoCommand(w);
_scheduledPayLoad = _payLoad.Count > 0;
return(currentPayload);
}
/// <summary>
/// Notify Observer subsystem.
/// </summary>
/// <param name="id">Identifier of a subsystem</param>
/// <param name="dataPayload">Message to be sent to the subsystem</param>
public void NotifyObserverSubsystem(string id, DataPayLoad dataPayload)
{
if (id == null)
{
return;
}
if (_subsystemObserver.ContainsKey(id))
{
if (_subsystemObserver.TryGetValue(id, out IList <WeakReference <IEventObserver> > value))
{
NotifyObserver(dataPayload, value);
}
}
}
private void Notify(DataPayLoad dataPayLoad, IList <IEventObserver> values, IList <IEventObserver> disabled)
{
// the item are not disabled.
foreach (IEventObserver eo in values)
{
// i dont send the message to myself.
if (!string.IsNullOrEmpty(dataPayLoad.Sender))
{
string sender = dataPayLoad.Sender;
if (!disabled.Contains(eo))
{
eo.IncomingPayload(dataPayLoad);
}
}
}
}
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>
/// Set or Get the the name of the controller view model in the subsystem.
/// </summary>
public object Clone()
{
DataPayLoad payLoad = new DataPayLoad();
if (!typeof(DataPayLoad).IsSerializable)
{
throw new ArgumentException("The type must be serializable.", "source");
}
IFormatter formatter = new BinaryFormatter();
Stream stream = new MemoryStream();
using (stream)
{
formatter.Serialize(stream, this);
stream.Seek(0, SeekOrigin.Begin);
payLoad = (DataPayLoad)formatter.Deserialize(stream);
}
return(payLoad);
}
private void Notify(DataPayLoad dataPayLoad, IList <WeakReference <IEventObserver> > values, IList <WeakReference <IEventObserver> > disabled)
{
// the item are not disabled.
foreach (WeakReference <IEventObserver> eo in values)
{
// I need a sender addres.
if (!string.IsNullOrEmpty(dataPayLoad.Sender))
{
string sender = dataPayLoad.Sender;
if (!disabled.Contains(eo))
{
IEventObserver observerEvent = null;
if (eo.TryGetTarget(out observerEvent))
{
observerEvent.IncomingPayload(dataPayLoad);
}
}
}
}
}
/// <summary>
/// Notify Observer subsystem.
/// </summary>
/// <param name="id">Identifier of a subsystem</param>
/// <param name="dataPayload">Message to be sent to the subsystem</param>
public void NotifyObserverSubsystem(string id, DataPayLoad dataPayload)
{
if (id == null)
{
return;
}
if (_subsystemObserver.ContainsKey(id))
{
if (_subsystemObserver.TryGetValue(id, out IList <IEventObserver> value))
{
// ok we get the disabled
_notificationDisabled.TryGetValue(id, out IList <IEventObserver> disabledItemList);
if ((disabledItemList == null))
{
NotifyObserver(dataPayload, value);
}
else
{
// the item are not disabled.
Notify(dataPayload, value, disabledItemList);
}
}
}
}
public void NotifyObserver(DataPayLoad payload)
{
throw new NotImplementedException();
}
/// <summary>
/// Notify the toolbar
/// </summary>
/// <param name="payload">Message to be sent</param>
public void NotifyToolBar(DataPayLoad payload)
{
NotifyObserver(payload, _toolBar);
}
public void SendMessage(string viewModuleId, DataPayLoad payLoad)
{
throw new NotImplementedException();
}
public void NotifyToolBar(DataPayLoad payload)
{
throw new NotImplementedException();
}
public void NotifyObserverSubsystem(string id, DataPayLoad dataPayload)
{
throw new NotImplementedException();
}
public bool IsRegisteredMailbox(string id, DataPayLoad payLoad)
{
throw new NotImplementedException();
}
/// <summary>
/// Enqueue a single payload
/// </summary>
/// <param name="payLoad">Payload to enqueue</param>
/// <returns>True o false in case of payload</returns>
public bool EnqueueSingle(DataPayLoad payLoad)
{
var type = (payLoad.PayloadType == DataPayLoad.Type.Update) || (payLoad.PayloadType == DataPayLoad.Type.Insert) || (payLoad.PayloadType == DataPayLoad.Type.Delete);
return(type);
}
/// <summary>
/// Notify all the global observer of a new message
/// </summary>
/// <param name="payload">Message to be send to all the system</param>
public void NotifyObserver(DataPayLoad payload)
{
NotifyObserver(payload, _observers);
}
