public override void AddNewValueChain()
{
TransformationTreeItem action = new TransformationTreeItem(false);
action.name = getNewName("Action");
AddNewBlock(new ActionItem(), action);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void onDeleteBlock(DesignerItem sender)
{
if (this.EditedObject != null && sender.Tag != null)
{
TransformationTreeItem entity = (TransformationTreeItem)sender.Tag;
if (entity.parent != null)
{
if (entity.childrenListChangeHandler.Items.Count > 0)
{
TransformationTreeItem entityChild = entity.childrenListChangeHandler.Items[0];
entity.ForgetChild(entityChild);
entityChild.parent = null;
this.EditedObject.AddItem(entityChild);
}
entity.parent.RemoveChild(entity);
}
else
{
this.EditedObject.DeleteItem(entity);
}
this.IsModify = true;
}
}
public void FillItem()
{
if (Loop == null)
{
Loop = new TransformationTreeItem(true);
}
Loop.name = this.NameTextBox.Text.Trim();
Loop.increase = this.IncreaseButton.IsChecked.Value;
Loop.ranking = ranking;
Loop.type = this.TypeTextBox.Text;
this.ValueField.Fill();
//Loop.Instruction = FillCondition();
//if (Loop.Instruction == null) Loop.conditions = null;
//else Loop.conditions = TransformationTreeService.getInstructionString(Loop.Instruction);
FillLoopCondition();
FillUserDialog();
//Loop.loopConditionsChangeHandler.AddNew(FillLoopCondition());
Loop.refreshLoopOid = null;
Object item = this.LoopComboBox.SelectedItem;
if (item != null && item is TransformationTreeItem)
{
Loop.refreshLoopOid = ((TransformationTreeItem)item).oid;
}
}
private void OnPasting(DesignerItem item, TransformationTreeItem currentAction)
{
if (PastingAction != null)
{
PastingAction(item, currentAction);
}
}
public void SetLoopValue(TransformationTreeItem loop)
{
String name = loop.name;
RPeriodNamePanel panel = GetPeriodNamePanel(loop);
if (panel != null)
{
int position = Period != null ? Period.itemListChangeHandler.Items.Count : 0;
//panel.UpdateInterval(interval, position);
}
else
{
int position = Period != null ? Period.itemListChangeHandler.Items.Count : 0;
List <PeriodItem> items = new List <PeriodItem>(0);
PeriodItem item = new PeriodItem();
item.name = name;
item.loop = loop;
item.position = position++;
item.operatorSign = DateOperator.EQUALS.sign;
items.Add(item);
panel = new RPeriodNamePanel(name, items);
if (loop.IsPeriod)
{
panel.ItemPanel1.OperatorCol.Width = new GridLength(200, GridUnitType.Auto);
panel.ItemPanel2.OperatorCol.Width = new GridLength(200, GridUnitType.Auto);
panel.ItemPanel1.SignComboBox.Width = 100;
}
AddNamePanel(panel);
OnAdded(panel.ItemPanel1);
}
}
public override void AddNewObject()
{
TransformationTreeItem loop = new TransformationTreeItem(true);
loop.name = getNewName("Loop");
AddNewBlock(new LoopItem(), loop);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void Edit(TransformationTreeItem item)
{
if (item == null)
{
return;
}
item = item.oid != null?this.TransformationTreeService.getItemByOid(item.oid) : item;
if (this.AllocationBoxDialog == null)
{
this.AllocationBoxDialog = new AllocationBoxDialog();
this.AllocationBoxDialog.TransformationTreeService = this.TransformationTreeService;
if (!this.IsReadOnly)
{
this.AllocationBoxDialog.initializeSideBar();
}
if (!this.IsReadOnly)
{
this.AllocationBoxDialog.SaveButton.Click += OnLoopDialogSave;
}
this.AllocationBoxDialog.CancelButton.Click += OnLoopDialogCancel;
this.AllocationBoxDialog.Closing += OnLoopDialogClosing;
this.AllocationBoxDialog.Owner = ApplicationManager.Instance.MainWindow;
}
this.AllocationBoxDialog.Loop = item;
this.AllocationBoxDialog.DisplayItem();
this.AllocationBoxDialog.SetReadOnly(this.IsReadOnly);
if (!this.AllocationBoxDialog.IsVisible)
{
this.AllocationBoxDialog.ShowDialog();
}
}
protected void OnEditingItem(DesignerItem item)
{
if (item.Tag != null)
{
if (!(item.Tag is TransformationTreeItem))
{
System.Web.Script.Serialization.JavaScriptSerializer Serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
Serializer.MaxJsonLength = 99999999;
item.Tag = Serializer.Deserialize <TransformationTreeItem>(item.Tag.ToString());
}
TransformationTreeEditorItem page = (TransformationTreeEditorItem)getTransformationTreeEditor().getActivePage();
TransformationTreeItem treeItem = (TransformationTreeItem)item.Tag;
//if (treeItem.IsAction && page.EditedObject.hasUnsavedLoop())
if (page.IsModify)
{
Save(page);
DesignerItem block = page.GetTransformationTreeForm().TransformationTreeDiagramView.designerCanvas.GetBlockByName(treeItem.name);
if (block == null)
{
return;
}
item = block;
treeItem = (TransformationTreeItem)item.Tag;
}
page.GetTransformationTreeForm().EditedDesignerItem = item;
this.RemoveCommands();
page.GetTransformationTreeForm().Edit(treeItem);
this.initializeCommands();
}
}
public void Display(TransformationTreeItem item)
{
throwEvent = false;
this.Clear();
this.Line = item;
ValueListChangeHandler = new PersistentListChangeHandler <TransformationTreeLoopValue>();
if (item == null)
{
return;
}
IList <TransformationTreeLoopValue> listeItem = item.valueListChangeHandler.getItems().Count > item.valueListChangeHandler.Items.Count ? item.valueListChangeHandler.getItems() : item.valueListChangeHandler.Items;
ValueListChangeHandler.originalList = new List <TransformationTreeLoopValue>(listeItem);
int index = 1;
foreach (TransformationTreeLoopValue loopValue in ValueListChangeHandler.Items)
{
//loopValue.updatePeriod(Periodicity);
AllocationValueItemField itemField = new AllocationValueItemField(loopValue);
Add(itemField);
index++;
}
throwEvent = true;
}
private void setLoop(TransformationTreeItem loop)
{
this.TargetItem.attribute = null;
this.TargetItem.value = null;
this.TargetItem.formula = "";
this.TargetItem.loop = loop;
}
private void OnEditingItemEnded(object obj)
{
TransformationTreeEditorItem page = (TransformationTreeEditorItem)getTransformationTreeEditor().getActivePage();
if (page.GetTransformationTreeForm().EditedDesignerItem == null || page.GetTransformationTreeForm().EditedDesignerItem.Tag == null)
{
return;
}
TransformationTreeItem item = (TransformationTreeItem)page.GetTransformationTreeForm().EditedDesignerItem.Tag;
TransformationTreeItem parent = item.parent;
item = GetTransformationTreeService().SaveTransformationTreeItem(item);
AfterSave();
if (item != null)
{
item.parent = parent;
item.tree = page.EditedObject;
if (item.parent != null)
{
item.parent.ReplaceChild(item);
}
else
{
page.EditedObject.ReplaceItem(item);
}
page.GetTransformationTreeForm().refreshItem(item);
page.GetTransformationTreeForm().EditedDesignerItem.Tag = item;
page.GetTransformationTreeForm().RedisplayItem(item);
}
BlockPanel.Loops = new List <TransformationTreeItem>(page.EditedObject.GetAllLoops().ToList());
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void onAddBlock(DesignerItem sender)
{
if (this.EditedObject != null && sender.Tag != null)
{
JavaScriptSerializer serial = new JavaScriptSerializer();
TransformationTreeItem transformationTreeItem = null;
if (sender.Tag is TransformationTreeItem)
{
transformationTreeItem = (TransformationTreeItem)sender.Tag;
}
else if (sender.Tag is string)
{
transformationTreeItem = serial.Deserialize <TransformationTreeItem>((string)sender.Tag);
}
this.EditedObject.itemListChangeHandler.AddNew(transformationTreeItem);
}
this.IsModify = true;
if (Change != null)
{
Change();
}
if (ChangeEventHandler != null)
{
ChangeEventHandler.change();
}
}
public void SetLoop(TransformationTreeItem loop)
{
bool added = false;
if (loop == null)
{
return;
}
if (this.PeriodItem == null)
{
this.PeriodItem = new PeriodItem(Index - 1);
added = true;
}
this.PeriodItem.operatorSign = this.SignComboBox.SelectedItem.ToString();
this.PeriodItem.period = null;
this.PeriodItem.operationDate = "";
this.PeriodItem.operationGranularity = "";
this.PeriodItem.value = null;
this.PeriodItem.formula = loop.name;
this.PeriodItem.loop = loop;
this.PeriodItem.name = "";
if (Added != null && added)
{
Added(this);
}
if (Updated != null && !added)
{
Updated(this);
}
}
public void SetLoop(TransformationTreeItem loop)
{
bool added = false;
if (loop == null)
{
return;
}
if (this.TargetItem == null)
{
this.TargetItem = new TargetItem(Index - 1);
added = true;
}
this.TargetItem.operatorType = this.ComboBox.SelectedItem.ToString();
this.TargetItem.attribute = null;
this.TargetItem.value = null;
this.TargetItem.formula = "";
this.TargetItem.loop = loop;
if (Added != null && added)
{
Added(this);
}
if (Updated != null && !added)
{
Updated(this);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
{
try
{
JToken token = null;
JObject jsonObject = JObject.Load(reader);
if (jsonObject.TryGetValue("typeName", out token))
{
switch ((string)token)
{
case "TransformationTreeLoop": {
TransformationTreeItem loop = jsonObject.ToObject <TransformationTreeItem>(serializer);
return(loop);
}
case "TransformationTreeAction": {
TransformationTreeItem action = jsonObject.ToObject <TransformationTreeItem>(serializer);
return(action);
}
default: {
TransformationTreeItem action = jsonObject.ToObject <TransformationTreeItem>(serializer);
return(action);
}
}
}
return(jsonObject.ToObject <TransformationTreeItem>(serializer));
}
catch (Exception)
{
return(null);
}
}
public override void AddNewObject()
{
TransformationTreeItem loop = new TransformationTreeItem(true);
loop.name = getNewName("Block");
loop.isDefaultName = true;
AddNewBlock(new AllocationBoxItem(), loop);
}
public void SetLoopValue(TransformationTreeItem loop)
{
if (this.ActiveItemPanel == null)
{
this.ActiveItemPanel = (RTargetItemPanel)this.panel.Children[this.panel.Children.Count - 1];
}
this.ActiveItemPanel.SetLoop(loop);
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
public void refreshItem(TransformationTreeItem item)
{
item.tree = this.EditedObject;
this.AllocationDiagramView.designerCanvas.RefreshEntity(item);
foreach (TransformationTreeItem child in item.childrenListChangeHandler.Items)
{
child.parent = item;
refreshItem(child);
}
}
public void SetLoop(TransformationTreeItem loop)
{
if (loop == null)
{
return;
}
added = false;
setTargetItem(Index);
setLoop(loop);
AddOrUpdateItem();
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void onModifyBlock(DesignerItem sender)
{
if (this.EditedObject != null && sender.Tag != null)
{
TransformationTreeItem entity = (TransformationTreeItem)sender.Tag;
}
this.IsModify = true;
if (Change != null)
{
Change();
}
}
private void OnSelecteLoopFromSidebar(object item)
{
if (item is TransformationTreeItem)
{
TransformationTreeItem value = new TransformationTreeItem();
value.oid = ((TransformationTreeItem)item).oid;
value.name = ((TransformationTreeItem)item).name;
value.loop = ((TransformationTreeItem)item).loop;
value.type = ((TransformationTreeItem)item).type;
SetValue(value);
}
}
/// <summary>
/// Rajoute une inputTable
/// </summary>
/// <param name="inputTable">L'inputTable à modifier</param>
public void AddTreeLoop(TransformationTreeItem treeLoop)
{
BrowserData data = new BrowserData();
if (treeLoop.oid.HasValue)
{
data.oid = treeLoop.oid.Value;
}
data.name = treeLoop.name;
this.liste.Add(treeLoop);
this.cvs.DeferRefresh();
}
/// <summary>
/// Retire un Design de la liste
/// </summary>
/// <param name="inputTable">L'Design à modifier</param>
public void RemoveTreeLoop(TransformationTreeItem treeLoop)
{
foreach (TransformationTreeItem data in this.liste)
{
if (data.name == treeLoop.name)
{
this.liste.Remove(data);
this.cvs.DeferRefresh();
return;
}
}
}
/// <summary>
/// Cette methode est appelée lorsau'on a ajouté un lien entre deaux blocks
/// </summary>
/// <param name="parent"></param>
/// <param name="child"></param>
protected void onAddLink(DesignerItem parent, DesignerItem child)
{
if (parent.Tag == null || child.Tag == null)
{
return;
}
TransformationTreeItem parentTag = (TransformationTreeItem)parent.Tag;
TransformationTreeItem childTag = (TransformationTreeItem)child.Tag;
this.EditedObject.ForgetItem(childTag);
parentTag.AddChild(childTag);
this.IsModify = true;
}
public void RefreshEntity(TransformationTreeItem entity)
{
foreach (UIElement item in this.Children)
{
if (item is DiagramDesigner.DesignerItem)
{
object tag = ((DiagramDesigner.DesignerItem)item).Tag;
if (((DiagramDesigner.DesignerItem)item).Renderer.Text.ToUpper().Equals(entity.name.ToUpper()))
{
((DiagramDesigner.DesignerItem)item).Tag = entity;
}
}
}
}
public void FillItem()
{
if (Action == null)
{
Action = new TransformationTreeItem(false);
}
Action.name = this.NameTextBox.Text.Trim();
Action.Instruction = this.InstructionsPanel.Fill();
Action.conditions = TransformationTreeService.getInstructionString(Action.Instruction);
//BlockPanel.Loops = null;
//BlockPanel.TransformationTables = null;
//BlockPanel.TransformationSlides = null;
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
protected override void SetCopyOfTag(DiagramDesigner.DesignerItem item)
{
string name = item.Renderer.Text;
DiagramDesigner.DesignerItem dItem = GetDesignerItemByName(name);
bool isCutMode = dItem == null;
dItem = dItem != null ? dItem : item;
object tag = ((DiagramDesigner.DesignerItem)dItem).Tag;
if (tag != null && (tag is TransformationTreeItem || tag is string))
{
JavaScriptSerializer serial = new JavaScriptSerializer();
TransformationTreeItem transformationTreeItem = tag is TransformationTreeItem ? (TransformationTreeItem)tag :
serial.Deserialize <TransformationTreeItem>((string)tag);
if (transformationTreeItem == null)
{
return;
}
TransformationTreeItem currenItem = null;
if (transformationTreeItem.IsLoop)
{
currenItem = transformationTreeItem.GetCopy(isCutMode);
}
else if (transformationTreeItem.IsAction)
{
currenItem = transformationTreeItem.GetCopy(isCutMode);
SourcingServiceFactory tableServiceFactory = new SourcingServiceFactory(Kernel.Application.ApplicationManager.Instance);
currenItem = transformationTreeItem.setCopyReport(currenItem, tableServiceFactory.GetInputTableService());
Kernel.Service.TransformationTreeService treeService = new Kernel.Service.TransformationTreeService();
if (PastingAction != null)
{
PastingAction(item, currenItem);
}
}
if (currenItem != null)
{
currenItem.name = getNewName(currenItem.name, true);
item.Tag = currenItem;
item.Renderer.Text = currenItem.name;
((DiagramDesigner.DesignerItem)dItem).Tag = transformationTreeItem;
}
}
else
{
item.Tag = tag;
}
}
/// <summary>
/// Retourne un Design à partir de son nom
/// </summary>
/// <param name="designName">Le nom de l'Design</param>
/// <returns>L'Design renvoyé</returns>
public TransformationTreeItem getTreeLoopByName(string treeLoopName)
{
foreach (TransformationTreeItem obj in this.liste)
{
if (obj.name.ToUpper() == treeLoopName.ToUpper())
{
TransformationTreeItem treeLoop = new TransformationTreeItem();
treeLoop.name = obj.name;
treeLoop.oid = obj.oid;
return(treeLoop);
}
}
return(null);
}
private void onMoveLinkSource(DesignerItem oldParent, DesignerItem child, DesignerItem newParent)
{
if (oldParent.Tag == null || child.Tag == null || newParent.Tag == null)
{
return;
}
TransformationTreeItem oldParentTag = (TransformationTreeItem)oldParent.Tag;
TransformationTreeItem newParentTag = (TransformationTreeItem)newParent.Tag;
TransformationTreeItem childTag = (TransformationTreeItem)child.Tag;
oldParentTag.ForgetChild(childTag);
childTag.parent = null;
newParentTag.AddChild(childTag);
this.IsModify = true;
}
private void onMoveLinkTarget(DesignerItem parent, DesignerItem oldChild, DesignerItem newChild)
{
if (parent.Tag == null || oldChild.Tag == null || newChild.Tag == null)
{
return;
}
TransformationTreeItem parentTag = (TransformationTreeItem)parent.Tag;
TransformationTreeItem oldChildTag = (TransformationTreeItem)oldChild.Tag;
TransformationTreeItem newChildTag = (TransformationTreeItem)newChild.Tag;
parentTag.ForgetChild(oldChildTag);
oldChildTag.parent = null;
this.EditedObject.AddItem(oldChildTag);
parentTag.AddChild(newChildTag);
this.IsModify = true;
}
