void ResponseDataDispatcher (TEntityAction entityAction)
{
if (entityAction.NotNull ()) {
// request
if (entityAction.IdCollection.Any ()) {
// to parent
// Dummy - Select - Many
var action = TEntityAction.Create (
TCategory.Dummy,
TOperation.Select,
TExtension.Many
);
foreach (var item in entityAction.IdCollection) {
action.IdCollection.Add (item);
}
action.Param2 = entityAction; // preserve
var message = new TCollectionMessageInternal (TInternalMessageAction.Request, TChild.List, TypeInfo);
message.Support.Argument.Types.Select (action);
DelegateCommand.PublishInternalMessage.Execute (message);
}
else {
var gadgets = new Collection<TActionComponent> ();
TActionConverter.Collection (TCategory.Test, gadgets, entityAction);
Model.Select (gadgets);
}
}
TDispatcher.Invoke (RefreshAllDispatcher);
}
internal void RefreshModel(TEntityAction entityAction)
{
if (entityAction.NotNull())
{
var gadgets = new Collection <TActionComponent> ();
TActionConverter.Collection(TCategory.Material, gadgets, entityAction);
if (gadgets.Any())
{
foreach (var component in gadgets)
{
var selection = TSelectionInfo.Create(component.Models.GadgetMaterialModel.GadgetName, component.Models.GadgetMaterialModel.Id, component.Models.GadgetMaterialModel.Enabled);
selection.SetImage(component.Models.GadgetMaterialModel.GetImage());
entityAction.SupportAction.SelectionCollection.Add(selection);
}
ComponentModelProperty.ValidateModel(true);
ComponentModelProperty.ExtensionModel.SelectModel(TCategory.Target, entityAction); // update Selection Property (Material list)
AlertsModel.Select(isOpen: false); // default
}
else
{
ComponentModelProperty.ValidateModel(false);
// show alerts
AlertsModel.Select(TAlertsModel.TKind.Warning);
AlertsModel.Select(Properties.Resource.RES_EMPTY, Properties.Resource.RES_LIST_EMPTY);
AlertsModel.Select(isOpen: true);
}
}
}
void ResponseSelectByIdDispatcher (TEntityAction entityAction)
{
entityAction.ThrowNull ();
if (entityAction.Param2 is GadgetTest gadget) {
if (gadget.HasContentTarget) {
var component = TActionComponent.Create (TCategory.Test);
component.Models.GadgetTestModel.CopyFrom (gadget);
TActionConverter.Select (TCategory.Test, component, entityAction);
gadget.CopyFrom (component.Models.GadgetTestModel);
Model.GadgetItemChecked (gadget, isChecked: gadget.IsChecked);
// to Sibling
var message = new TFactorySiblingMessageInternal (TInternalMessageAction.PropertySelect, TChild.List, TypeInfo);
message.Support.Argument.Args.Select (component);
message.Support.Argument.Args.Select (gadget.IsChecked ? "GadgetAdd" : "GadgetRemove");
if (Model.IsEditMode || Model.HasGadgetChecked) {
message.Support.Argument.Types.ReportData.SelectLock ();
}
DelegateCommand.PublishInternalMessage.Execute (message);
}
TDispatcher.Invoke (RefreshAllDispatcher);
}
}
void ResponseDataDispatcher (TEntityAction action)
{
var gadgets = new Collection<TActionComponent> ();
// Registration - Collection - Full (Registration)
if (action.CategoryType.IsCategory (TCategory.Registration)) {
TActionConverter.Collection (TCategory.Registration, gadgets, action);
Model.SelectRegistration (gadgets);
}
// Result - Collection - Full (Result )
if (action.CategoryType.IsCategory (TCategory.Result)) {
action.IdCollection.Clear (); // empty for sure
TActionConverter.Collection (TCategory.Result, gadgets, action);
Model.SelectResult (gadgets, action.IdDictionary);
// update
// Dummy - Select - Many
if (action.IdDictionary.Any ()) {
action.Operation.Select (TCategory.Dummy, TOperation.Select, TExtension.Many);
var message = new TCollectionMessageInternal (TInternalMessageAction.Request, TChild.List, TypeInfo);
message.Support.Argument.Types.Select (action);
DelegateCommand.PublishInternalMessage.Execute (message);
}
}
TDispatcher.Invoke (RefreshAllDispatcher);
}
internal void Select(TEntityAction entityAction)
{
// DATA IN:
// action.CollectionAction.ModelCollection
entityAction.ThrowNull();
//Registrations.Clear ();
ItemsSource.Clear();
var gadgets = new Collection <TActionComponent> ();
TActionConverter.Collection(TCategory.Registration, gadgets, entityAction);
foreach (var model in gadgets)
{
ItemsSource.Add(model.Models.GadgetRegistrationModel);
}
//foreach (var gadget in action.CollectionAction.GadgetRegistrationCollection) {
// if (action.CollectionAction.ModelCollection.ContainsKey (gadget.Id)) {
// var modelAction = action.CollectionAction.ModelCollection [gadget.Id];
// modelAction.GadgetRegistrationModel.CopyFrom (gadget);
// action.ModelAction.CopyFrom (modelAction);
// var item = TComponentModelItem.Create (action);
// Registrations.Add (item);
// RegistrationItemsSource.Add (item);
// }
//}
SelectedIndex = ItemsSource.Any() ? 0 : -1;
}
internal void Request(TActionComponent component)
{
component.ThrowNull();
var entityAction = TEntityAction.Create(TCategory.Registration);
ComponentModelProperty.RequestModel(entityAction);
TActionConverter.Select(TCategory.Registration, component, entityAction);
}
void ResponseSelectByIdDispatcher (TEntityAction entityAction)
{
var component = TActionComponent.Create (TCategory.Test);
TActionConverter.Select (TCategory.Test, component, entityAction);
// to Sibling
var message = new TCollectionSiblingMessageInternal (TInternalMessageAction.Select, TChild.List, TypeInfo);
message.Support.Argument.Args.Select (component);
DelegateCommand.PublishInternalMessage.Execute (message);
}
internal void SelectModel(TActionComponent component)
{
component.ThrowNull();
GadgetModel.Models.GadgetMaterialModel.CopyFrom(component.Models.GadgetMaterialModel);
var entityAction = TEntityAction.CreateDefault;
TActionConverter.Request(TCategory.Material, component, entityAction);
ComponentModelProperty.SelectModel(entityAction);
}
internal void SelectModel(TEntityAction entityAction)
{
entityAction.ThrowNull();
if (entityAction.CategoryType.IsCategory(TCategory.Test))
{
var component = TActionComponent.Create(TCategory.Test);
TActionConverter.Select(TCategory.Test, component, entityAction);
ComponentControlModel.SelectModel(component);
}
}
internal void Select(TEntityAction entityAction)
{
entityAction.ThrowNull();
Targets.Clear();
var gadgets = new Collection <TActionComponent> ();
TActionConverter.Collection(TCategory.Target, gadgets, entityAction);
foreach (var component in gadgets)
{
Targets.Add(component.Models.GadgetTargetModel);
}
}
void RequestModelDispatcher (TEntityAction action)
{
if (action.NotNull ()) {
var component = TActionComponent.Create (TCategory.Result);
Model.Request (component);
TActionConverter.Request (TCategory.Result, component, action);
action.Param1 = component;
// to Sibling
var message = new TFactorySiblingMessageInternal (TInternalMessageAction.Response, TChild.List, TypeInfo);
message.Support.Argument.Types.Select (action);
DelegateCommand.PublishInternalMessage.Execute (message);
}
}
void ResponseSelectManyDispatcher (TEntityAction entityAction)
{
if (entityAction.NotNull ()) {
if (entityAction.Param2 is TEntityAction action) {
foreach (var item in entityAction.CollectionAction.EntityCollection) {
action.CollectionAction.EntityCollection.Add (item.Key, item.Value);
}
var gadgets = new Collection<TActionComponent> ();
TActionConverter.Collection (TCategory.Test, gadgets, action);
Model.Select (gadgets);
}
}
TDispatcher.Invoke (RefreshAllDispatcher);
}
internal bool EditEnter(TActionComponent component)
{
var res = false;
if (component.NotNull())
{
var entityAction = TEntityAction.CreateDefault;
TActionConverter.Request(TCategory.Test, component, entityAction);
ComponentModelProperty.SelectModel(entityAction);
ValidateProperty();
res = component.Models.GadgetTestModel.ValidateId;
}
return(res);
}
internal bool EditEnter(TActionComponent component)
{
component.ThrowNull();
var entityAction = TEntityAction.CreateDefault;
TActionConverter.Request(TCategory.Target, component, entityAction);
// update Material selection
var tag = component.Models.GadgetTargetModel.MaterialId;
entityAction.SupportAction.SelectionInfo.Select(component.Models.GadgetTargetModel.Material, tag, enabled: component.Models.GadgetTargetModel.Enabled);
ComponentModelProperty.SelectModel(entityAction);
ComponentModelProperty.SelectionLock(component.Models.GadgetTargetModel.Busy);
return(component.Models.GadgetTargetModel.ValidateId);
}
internal void Select(TEntityAction entityAction)
{
// DATA IN:
// action.CollectionAction.ModelCollection
entityAction.ThrowNull();
Reports.Clear();
var gadgets = new Collection <TActionComponent> ();
TActionConverter.Collection(TCategory.Report, gadgets, entityAction);
foreach (var model in gadgets)
{
Reports.Add(model.Models.GadgetReportModel);
}
}
internal void Select(TEntityAction entityAction)
{
entityAction.ThrowNull();
ItemsSource.Clear();
var gadgets = new Collection <TActionComponent> ();
TActionConverter.Collection(TCategory.Material, gadgets, entityAction);
foreach (var model in gadgets)
{
ItemsSource.Add(model.Models.GadgetMaterialModel);
}
if (ItemsSource.Any())
{
SelectedIndex = 0;
}
}
public void Handle (TMessageInternal message)
{
if (message.NotNull ()) {
if (message.IsModule (TResource.TModule.Factory)) {
// from Sibling
if (message.Node.IsSiblingToMe (TChild.Design, TypeInfo)) {
// PropertySelect
if (message.IsAction (TInternalMessageAction.PropertySelect)) {
var action = TEntityAction.Request (message.Support.Argument.Types.EntityAction);
var propertyName = message.Support.Argument.Args.PropertyName;
if (propertyName.Equals ("edit", StringComparison.InvariantCulture)) {
if (message.Support.Argument.Args.Param1 is TActionComponent component) {
Model.SelectModel (component, propertyName);
}
}
else {
var component = TActionComponent.Create (TCategory.Target);
TActionConverter.Select (TCategory.Target, component, action);
Model.SelectModel (component, propertyName);
}
TDispatcher.Invoke (RefreshDesignDispatcher);
}
// Request
if (message.IsAction (TInternalMessageAction.Request)) {
TDispatcher.BeginInvoke (RequestDesignDispatcher, TEntityAction.Request (message.Support.Argument.Types.EntityAction));
}
// Cleanup
if (message.IsAction (TInternalMessageAction.Cleanup)) {
Model.Cleanup ();
TDispatcher.Invoke (RefreshDesignDispatcher);
}
}
}
}
}
internal void MaterialRefreshModel(TEntityAction entityAction)
{
entityAction.ThrowNull();
// for gadget Material
var gadgets = new Collection <TActionComponent> ();
TActionConverter.Collection(TCategory.Material, gadgets, entityAction);
MaterialSelectionItemsSource.Clear();
foreach (var gadget in gadgets)
{
MaterialSelectionItemsSource.Add(gadget.Models.GadgetMaterialModel);
}
if (MaterialSelectionItemsSource.Any())
{
MaterialSelectionSelectedIndex = 0;
}
}
void ModifyCommandDispatcher ()
{
var component = TActionComponent.Create (TCategory.Result);
Model.Request (component);
var gadget = component.Models.GadgetResultModel;
var action = TEntityAction.Create (TCategory.Result);
action.Id = gadget.Id;
TActionConverter.Request (TCategory.Result, component, action);
// Result - Change - Content
var entityAction = TEntityAction.Create (TCategory.Result, TOperation.Change, TExtension.Content);
entityAction.CollectionAction.EntityCollection.Add (gadget.Id, action);
// to parent
var message = new TFactoryMessageInternal (TInternalMessageAction.Request, TChild.List, TypeInfo);
message.Support.Argument.Types.Select (entityAction);
DelegateCommand.PublishInternalMessage.Execute (message);
}
internal void EditEnter(TActionComponent component)
{
if (component.NotNull())
{
if (component.IsCategory(TCategory.Result))
{
var gadget = component.Models.GadgetResultModel;
if (gadget.HasRegistration)
{
gadget.RequestContent(m_Registration);
}
var entityAction = TEntityAction.CreateDefault;
TActionConverter.Request(TCategory.Result, component, entityAction);
ComponentModelProperty.SelectModel(entityAction);
ValidateProperty();
}
}
}
internal void ModifyEnter(TActionComponent component)
{
if (component.NotNull())
{
if (component.IsCategory(TCategory.Result))
{
var gadget = component.Models.GadgetResultModel;
if (gadget.HasRegistration)
{
gadget.RequestContent(m_Registration);
}
var entityAction = TEntityAction.CreateDefault;
TActionConverter.Request(TCategory.Result, component, entityAction);
ComponentModelProperty.SelectModel(entityAction);
ComponentModelProperty.ValidateModel(validated: false);
ComponentModelProperty.IsComponentModelEnabled = false;
ComponentModelProperty.IsExtensionModelEnabled = false;
}
}
}
void ChangeSuccessDispatcher ()
{
if (Model.CanLock && m_CanLock) {
m_CanLock = false;
var component = TActionComponent.Create (TCategory.Result);
Model.RequestLockedStatus (component);
// Result - Change - Status
var entityAction = TEntityAction.Create (TCategory.Result, TOperation.Change, TExtension.Status);
TActionConverter.ModifyStatus (TCategory.Result, component, entityAction);
// to parent
var message = new TFactoryMessageInternal (TInternalMessageAction.Request, TChild.List, TypeInfo);
message.Support.Argument.Types.Select (entityAction);
DelegateCommand.PublishInternalMessage.Execute (message);
}
else {
TDispatcher.Invoke (CleanupDispatcher);
}
}
internal void RefreshModel(TEntityAction entityAction)
{
entityAction.ThrowNull();
MaterialItemsSource.Clear();
MaterialSelectionSelectedIndex = -1;
// for gadget Material
var gadgets = new Collection <TActionComponent> ();
TActionConverter.Collection(TCategory.Material, gadgets, entityAction);
foreach (var component in gadgets)
{
var gadgetMaterial = component.Models.GadgetMaterialModel;
if (gadgetMaterial.Enabled)
{
MaterialItemsSource.Add(gadgetMaterial);
foreach (var gadgetTarget in Targets)
{
// Node reverse here
if (gadgetTarget.MaterialId.Equals(gadgetMaterial.Id))
{
gadgetTarget.Material = gadgetMaterial.GadgetName;
}
}
}
}
if (MaterialItemsSource.Any())
{
MaterialSelected.CopyFrom(MaterialItemsSource [0]);
MaterialSelectionSelectedIndex = 0;
}
}
void ResponseSelectManyDispatcher (TEntityAction action)
{
if (action.NotNull ()) {
foreach (var itemIdResult in action.CollectionAction.EntityDictionary) {
var gadgetCollection = new Dictionary<Guid, Collection<TActionComponent>> ();
foreach (var entityCollection in itemIdResult.Value) {
var id = entityCollection.Key;
var entityAction = entityCollection.Value;
var gadgetComponent = new Collection<TActionComponent> ();
// Registration
if (entityAction.CategoryType.IsCategory (TCategory.Registration)) {
var gadgets = TActionComponent.Create (TCategory.Registration);
TActionConverter.Select (TCategory.Registration, gadgets, entityAction);
gadgetComponent.Add (gadgets);
}
// Test
if (entityAction.CategoryType.IsCategory (TCategory.Test)) {
var gadgets = TActionComponent.Create (TCategory.Test);
TActionConverter.Select (TCategory.Test, gadgets, entityAction);
gadgetComponent.Add (gadgets);
}
gadgetCollection.Add (id, gadgetComponent);
}
Model.SelectMany (itemIdResult.Key, gadgetCollection);
}
TDispatcher.Invoke (RefreshAllDispatcher);
}
}
