923 lines
32 KiB
C#
923 lines
32 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Linq;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Forms.VisualStyles;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using Caliburn.Micro;
|
|
using Caliburn.Micro.Core;
|
|
using MECF.Framework.Common.RecipeCenter;
|
|
using MECF.Framework.UI.Client.ClientBase;
|
|
using MECF.Framework.UI.Client.RecipeEditorLib.DGExtension.CustomColumn;
|
|
using MECF.Framework.UI.Client.RecipeEditorLib.RecipeModel;
|
|
using MECF.Framework.UI.Client.RecipeEditorLib.RecipeModel.Params;
|
|
using OpenSEMI.ClientBase;
|
|
using OpenSEMI.ClientBase.Command;
|
|
|
|
namespace MECF.Framework.UI.Client.CenterViews.Editors.Sequence
|
|
{
|
|
public class SequenceViewModel : BaseModel
|
|
{
|
|
public bool IsPermission => Permission == 3; //&& RtStatus != "AutoRunning";
|
|
|
|
public ObservableCollection<FileNode> Files { get; set; }
|
|
|
|
protected override void OnInitialize()
|
|
{
|
|
base.OnInitialize();
|
|
CurrentSequence = new SequenceData();
|
|
Columns = columnBuilder.Build();
|
|
|
|
editMode = EditMode.None;
|
|
IsSavedDesc = true;
|
|
|
|
var names = provider.GetSequences();
|
|
Files = new ObservableCollection<FileNode>(RecipeSequenceTreeBuilder.GetFiles("", names));
|
|
CurrentFileNode = Files[0];
|
|
|
|
SelectDefault(CurrentFileNode);
|
|
}
|
|
|
|
protected override void OnActivate()
|
|
{
|
|
base.OnActivate();
|
|
}
|
|
|
|
protected override void OnDeactivate(bool close)
|
|
{
|
|
base.OnDeactivate(close);
|
|
if (IsChanged)
|
|
{
|
|
if (DialogBox.Confirm("This sequence is changed,do you want to save it?"))
|
|
SaveSequence();
|
|
LoadData(CurrentSequence.Name);
|
|
}
|
|
}
|
|
|
|
protected override void OnViewLoaded(object view)
|
|
{
|
|
base.OnViewLoaded(view);
|
|
SequenceColumnBuilder.ApplyTemplate((UserControl)view, Columns);
|
|
var u = (SequenceView)view;
|
|
|
|
Columns.Apply((c) =>
|
|
{
|
|
c.Header = c;
|
|
u.dgCustom.Columns.Add(c);
|
|
});
|
|
|
|
u.dgCustom.ItemsSource = CurrentSequence.Steps;
|
|
|
|
UpdateView();
|
|
}
|
|
|
|
#region Sequence selection
|
|
|
|
public void TreeSelectChanged(FileNode file)
|
|
{
|
|
if (file != null && file.IsFile)
|
|
{
|
|
if (IsChanged)
|
|
if (DialogBox.Confirm("This sequence is changed,do you want to save it?"))
|
|
Save(CurrentSequence);
|
|
LoadData(file.FullPath);
|
|
CurrentFileNode = file;
|
|
}
|
|
else
|
|
{
|
|
ClearData();
|
|
editMode = EditMode.None;
|
|
CurrentSequence.Steps.Clear();
|
|
}
|
|
UpdateView();
|
|
}
|
|
|
|
private TreeViewItem GetParentObjectEx<TreeViewItem>(DependencyObject obj) where TreeViewItem : FrameworkElement
|
|
{
|
|
var parent = VisualTreeHelper.GetParent(obj);
|
|
while (parent != null)
|
|
{
|
|
if (parent is TreeViewItem)
|
|
{
|
|
return (TreeViewItem)parent;
|
|
}
|
|
parent = VisualTreeHelper.GetParent(parent);
|
|
}
|
|
return null;
|
|
}
|
|
public void TreeRightMouseDown(MouseButtonEventArgs e)
|
|
{
|
|
var item = GetParentObjectEx<TreeViewItem>(e.OriginalSource as DependencyObject) as TreeViewItem;
|
|
if (item != null)
|
|
{
|
|
item.Focus();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
private ICommand _NotImplementCommand;
|
|
public ICommand NotImplementCommand
|
|
{
|
|
get
|
|
{
|
|
if (_NotImplementCommand == null)
|
|
_NotImplementCommand = new BaseCommand(() => NotImplement());
|
|
return _NotImplementCommand;
|
|
}
|
|
}
|
|
|
|
public void NotImplement()
|
|
{
|
|
DialogBox.ShowInfo("Not Implement");
|
|
}
|
|
|
|
#region Sequence operation
|
|
|
|
private ICommand _NewFolderCommand;
|
|
public ICommand NewFolderCommand
|
|
{
|
|
get
|
|
{
|
|
if (_NewFolderCommand == null)
|
|
_NewFolderCommand = new BaseCommand(() => NewFolder());
|
|
return _NewFolderCommand;
|
|
}
|
|
}
|
|
public void NewFolder()
|
|
{
|
|
if (!CurrentFileNode.IsFile)
|
|
{
|
|
var dialog = new InputFileNameDialogViewModel("Input Folder Name");
|
|
var wm = new WindowManager();
|
|
var bret = wm.ShowDialog(dialog);
|
|
if (!(bool)bret)
|
|
return;
|
|
var fullpath = (CurrentFileNode.FullPath == "" ? dialog.DialogResult : CurrentFileNode.FullPath + "\\" + dialog.DialogResult);
|
|
if (provider.CreateSequenceFolder(fullpath))
|
|
{
|
|
var folder = new FileNode();
|
|
folder.Name = dialog.DialogResult;
|
|
folder.FullPath = fullpath;
|
|
folder.Parent = CurrentFileNode;
|
|
CurrentFileNode.Files.Add(folder);
|
|
}
|
|
else
|
|
DialogBox.ShowError("Create folder failed!");
|
|
}
|
|
}
|
|
|
|
private ICommand _NewFolderInParentCommand;
|
|
public ICommand NewFolderInParentCommand
|
|
{
|
|
get
|
|
{
|
|
if (_NewFolderInParentCommand == null)
|
|
_NewFolderInParentCommand = new BaseCommand(() => NewFolderInParent());
|
|
return _NewFolderInParentCommand;
|
|
}
|
|
}
|
|
public void NewFolderInParent()
|
|
{
|
|
var dialog = new InputFileNameDialogViewModel("Input Folder Name");
|
|
var wm = new WindowManager();
|
|
var bret = wm.ShowDialog(dialog);
|
|
if (!(bool)bret)
|
|
return;
|
|
var fullpath = dialog.DialogResult;
|
|
if (provider.CreateSequenceFolder(fullpath))
|
|
{
|
|
var folder = new FileNode();
|
|
folder.Name = dialog.DialogResult;
|
|
folder.FullPath = fullpath;
|
|
folder.Parent = Files[0];
|
|
Files[0].Files.Add(folder);
|
|
}
|
|
else
|
|
DialogBox.ShowError("Create folder failed!");
|
|
}
|
|
|
|
private ICommand _NewSequenceInParentCommand;
|
|
public ICommand NewSequenceInParentCommand
|
|
{
|
|
get
|
|
{
|
|
if (_NewSequenceInParentCommand == null)
|
|
_NewSequenceInParentCommand = new BaseCommand(() => NewSequenceInParent());
|
|
return _NewSequenceInParentCommand;
|
|
}
|
|
}
|
|
public void NewSequenceInParent()
|
|
{
|
|
var dialog = new InputFileNameDialogViewModel("Input New Sequence Name");
|
|
var wm = new WindowManager();
|
|
var bret = wm.ShowDialog(dialog);
|
|
if ((bool)bret)
|
|
{
|
|
if (IsChanged)
|
|
{
|
|
if (DialogBox.Confirm("This sequence is changed,do you want to save it?"))
|
|
{
|
|
CurrentSequence.Revisor = BaseApp.Instance.UserContext.LoginName;
|
|
CurrentSequence.ReviseTime = DateTime.Now;
|
|
Save(CurrentSequence);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var fullpath = dialog.DialogResult;
|
|
if (string.IsNullOrEmpty(fullpath))
|
|
{
|
|
DialogBox.ShowError("SequenceName cannot be null or empty!");
|
|
return;
|
|
}
|
|
if (IsExist(fullpath))
|
|
{
|
|
DialogBox.ShowError("Sequence already existed!");
|
|
}
|
|
else
|
|
{
|
|
var sequence = new SequenceData
|
|
{
|
|
Name = fullpath,
|
|
Creator = BaseApp.Instance.UserContext.LoginName,
|
|
CreateTime = DateTime.Now,
|
|
Revisor = BaseApp.Instance.UserContext.LoginName,
|
|
ReviseTime = DateTime.Now,
|
|
Description = string.Empty
|
|
};
|
|
|
|
if (Save(sequence))
|
|
{
|
|
CurrentSequence.Name = sequence.Name;
|
|
CurrentSequence.Creator = sequence.Creator;
|
|
CurrentSequence.CreateTime = sequence.CreateTime;
|
|
CurrentSequence.Revisor = sequence.Revisor;
|
|
CurrentSequence.ReviseTime = sequence.ReviseTime;
|
|
CurrentSequence.Description = sequence.Description;
|
|
CurrentSequence.Steps.Clear();
|
|
|
|
var file = new FileNode();
|
|
file.Name = dialog.DialogResult;
|
|
file.FullPath = CurrentSequence.Name;
|
|
file.IsFile = true;
|
|
file.Parent = Files[0];
|
|
Files[0].Files.Insert(findInsertPosition(Files[0].Files), file);
|
|
editMode = EditMode.Normal;
|
|
UpdateView();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public int findInsertPosition(ObservableCollection<FileNode> files)
|
|
{
|
|
var pos = -1;
|
|
if (files.Count == 0)
|
|
pos = 0;
|
|
else
|
|
{
|
|
var foundfolder = false;
|
|
for (var index = 0; index < files.Count; index++)
|
|
{
|
|
if (!files[index].IsFile)
|
|
{
|
|
foundfolder = true;
|
|
pos = index;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundfolder)
|
|
pos = files.Count;
|
|
}
|
|
return pos;
|
|
}
|
|
|
|
private ICommand _SaveAsCommand;
|
|
public ICommand SaveAsCommand
|
|
{
|
|
get
|
|
{
|
|
if (_SaveAsCommand == null)
|
|
_SaveAsCommand = new BaseCommand(() => SaveAsSequence());
|
|
return _SaveAsCommand;
|
|
}
|
|
}
|
|
|
|
public void SaveAsSequence()
|
|
{
|
|
if (CurrentFileNode.IsFile)
|
|
{
|
|
var dialog = new InputFileNameDialogViewModel("SaveAs Sequence");
|
|
var wm = new WindowManager();
|
|
var bret = wm.ShowDialog(dialog);
|
|
if (!(bool)bret)
|
|
return;
|
|
var fullpath = (CurrentFileNode.Parent.FullPath == "" ? dialog.DialogResult : CurrentFileNode.Parent.FullPath + "\\" + dialog.DialogResult);
|
|
|
|
if (string.IsNullOrEmpty(fullpath))
|
|
{
|
|
DialogBox.ShowError("SequenceName cannot be null or empty!");
|
|
return;
|
|
}
|
|
if (IsExist(fullpath))
|
|
{
|
|
DialogBox.ShowError("Sequence already existed!");
|
|
}
|
|
else
|
|
{
|
|
if (IsChanged)
|
|
{
|
|
if (DialogBox.Confirm("This sequence is changed,do you want to save it?"))
|
|
{
|
|
Save(CurrentSequence);
|
|
}
|
|
}
|
|
|
|
CurrentSequence.Revisor = BaseApp.Instance.UserContext.LoginName;
|
|
CurrentSequence.ReviseTime = DateTime.Now;
|
|
var tempName = CurrentSequence.Name;
|
|
CurrentSequence.Name = fullpath;
|
|
if (provider.SaveAs(fullpath, CurrentSequence))
|
|
{
|
|
var node = new FileNode
|
|
{
|
|
Parent = CurrentFileNode.Parent,
|
|
Name = dialog.DialogResult,
|
|
FullPath = fullpath,
|
|
IsFile = true
|
|
};
|
|
CurrentFileNode.Parent.Files.Add(node);
|
|
}
|
|
else
|
|
{
|
|
CurrentSequence.Name = tempName;
|
|
DialogBox.ShowError("SaveAs failed!");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private ICommand _DeleteFolderCommand;
|
|
public ICommand DeleteFolderCommand
|
|
{
|
|
get
|
|
{
|
|
if (_DeleteFolderCommand == null)
|
|
_DeleteFolderCommand = new BaseCommand(() => DeleteFolder());
|
|
return _DeleteFolderCommand;
|
|
}
|
|
}
|
|
public void DeleteFolder()
|
|
{
|
|
if (!CurrentFileNode.IsFile && CurrentFileNode.FullPath != "")
|
|
{
|
|
if (DialogBox.Confirm("Do you want to delete this folder? this operation will delete all files in this folder."))
|
|
{
|
|
if (provider.DeleteSequenceFolder(CurrentFileNode.FullPath))
|
|
{
|
|
CurrentFileNode.Parent.Files.Remove(CurrentFileNode);
|
|
}
|
|
else
|
|
DialogBox.ShowInfo("Delete folder failed!");
|
|
}
|
|
}
|
|
}
|
|
|
|
private ICommand _NewSequenceCommand;
|
|
public ICommand NewSequenceCommand
|
|
{
|
|
get
|
|
{
|
|
if (_NewSequenceCommand == null)
|
|
_NewSequenceCommand = new BaseCommand(() => NewSequence());
|
|
return _NewSequenceCommand;
|
|
}
|
|
}
|
|
public void NewSequence()
|
|
{
|
|
var dialog = new InputFileNameDialogViewModel("Input New Sequence Name");
|
|
var wm = new WindowManager();
|
|
var bret = wm.ShowDialog(dialog);
|
|
if ((bool)bret)
|
|
{
|
|
if (IsChanged)
|
|
{
|
|
if (DialogBox.Confirm("This sequence is changed,do you want to save it?"))
|
|
{
|
|
CurrentSequence.Revisor = BaseApp.Instance.UserContext.LoginName;
|
|
CurrentSequence.ReviseTime = DateTime.Now;
|
|
Save(CurrentSequence);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var fullpath = dialog.DialogResult;
|
|
if (CurrentFileNode.IsFile)
|
|
fullpath = (string.IsNullOrEmpty(CurrentFileNode.Parent.FullPath) ? dialog.DialogResult : CurrentFileNode.Parent.FullPath + "\\" + dialog.DialogResult);
|
|
else
|
|
fullpath = (string.IsNullOrEmpty(CurrentFileNode.FullPath) ? dialog.DialogResult : CurrentFileNode.FullPath + "\\" + dialog.DialogResult);
|
|
|
|
if (string.IsNullOrEmpty(fullpath))
|
|
{
|
|
DialogBox.ShowError("SequenceName cannot be null or empty!");
|
|
return;
|
|
}
|
|
if (IsExist(fullpath))
|
|
{
|
|
DialogBox.ShowError("Sequence already existed!");
|
|
}
|
|
else
|
|
{
|
|
var sequence = new SequenceData
|
|
{
|
|
Name = fullpath,
|
|
Creator = BaseApp.Instance.UserContext.LoginName,
|
|
CreateTime = DateTime.Now,
|
|
Revisor = BaseApp.Instance.UserContext.LoginName,
|
|
ReviseTime = DateTime.Now,
|
|
Description = string.Empty
|
|
};
|
|
|
|
if (Save(sequence))
|
|
{
|
|
CurrentSequence.Name = sequence.Name;
|
|
CurrentSequence.Creator = sequence.Creator;
|
|
CurrentSequence.CreateTime = sequence.CreateTime;
|
|
CurrentSequence.Revisor = sequence.Revisor;
|
|
CurrentSequence.ReviseTime = sequence.ReviseTime;
|
|
CurrentSequence.Description = sequence.Description;
|
|
CurrentSequence.Steps.Clear();
|
|
|
|
var file = new FileNode();
|
|
file.Name = dialog.DialogResult;
|
|
file.FullPath = CurrentSequence.Name;
|
|
file.IsFile = true;
|
|
file.Parent = CurrentFileNode.IsFile ? CurrentFileNode.Parent : CurrentFileNode;
|
|
if (CurrentFileNode.IsFile)
|
|
CurrentFileNode.Parent.Files.Insert(findInsertPosition(CurrentFileNode.Parent.Files), file);
|
|
else
|
|
CurrentFileNode.Files.Insert(findInsertPosition(CurrentFileNode.Files), file);
|
|
editMode = EditMode.Normal;
|
|
UpdateView();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private ICommand _RenameCommand;
|
|
public ICommand RenameCommand
|
|
{
|
|
get
|
|
{
|
|
if (_RenameCommand == null)
|
|
_RenameCommand = new BaseCommand(() => RenameSequence());
|
|
return _RenameCommand;
|
|
}
|
|
}
|
|
public void RenameSequence()
|
|
{
|
|
if (CurrentFileNode.IsFile)
|
|
{
|
|
var dialog = new InputFileNameDialogViewModel("Rename Sequence");
|
|
var wm = new WindowManager();
|
|
dialog.FileName = CurrentFileNode.Name;
|
|
var bret = wm.ShowDialog(dialog);
|
|
if (!(bool)bret)
|
|
return;
|
|
var fullpath = CurrentFileNode.Parent.FullPath == "" ? dialog.DialogResult : CurrentFileNode.Parent.FullPath + "\\" + dialog.DialogResult;
|
|
|
|
if (string.IsNullOrEmpty(fullpath))
|
|
{
|
|
DialogBox.ShowError("SequenceName cannot be null or empty!");
|
|
return;
|
|
}
|
|
if (IsExist(fullpath))
|
|
{
|
|
DialogBox.ShowError("Sequence already existed!");
|
|
}
|
|
else
|
|
{
|
|
if (IsChanged)
|
|
{
|
|
if (DialogBox.Confirm("This sequence is changed,do you want to save it?", "") == true)
|
|
{
|
|
Save(CurrentSequence);
|
|
}
|
|
}
|
|
CurrentSequence.Revisor = BaseApp.Instance.UserContext.LoginName;
|
|
CurrentSequence.ReviseTime = DateTime.Now;
|
|
if (provider.Rename(CurrentSequence.Name, fullpath))
|
|
{
|
|
CurrentFileNode.Name = dialog.DialogResult;
|
|
CurrentFileNode.FullPath = fullpath;
|
|
CurrentSequence.Name = fullpath;
|
|
}
|
|
else
|
|
DialogBox.ShowError("Rename failed!");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SaveSequence()
|
|
{
|
|
if (IsChanged)
|
|
{
|
|
Save(CurrentSequence);
|
|
}
|
|
}
|
|
|
|
private ICommand _DeleteCommand;
|
|
public ICommand DeleteSequenceCommand
|
|
{
|
|
get
|
|
{
|
|
if (_DeleteCommand == null)
|
|
_DeleteCommand = new BaseCommand(() => DeleteSequence());
|
|
return _DeleteCommand;
|
|
}
|
|
}
|
|
public void DeleteSequence()
|
|
{
|
|
if (CurrentFileNode.IsFile)
|
|
{
|
|
if (DialogBox.Confirm("Do you want to delete this sequence?"))
|
|
{
|
|
if (provider.Delete(CurrentSequence.Name))
|
|
{
|
|
CurrentFileNode.Parent.Files.Remove(CurrentFileNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ReloadSequence()
|
|
{
|
|
if (editMode == EditMode.Normal || editMode == EditMode.Edit)
|
|
{
|
|
LoadData(CurrentSequence.Name);
|
|
UpdateView();
|
|
}
|
|
}
|
|
|
|
private bool Save(SequenceData seq)
|
|
{
|
|
var result = false;
|
|
if (string.IsNullOrEmpty(seq.Name))
|
|
{
|
|
DialogBox.ShowError("Sequence name can't be empty");
|
|
return false;
|
|
}
|
|
|
|
string ruleCheckMessage = null;
|
|
if (!ValidateSequenceRules(seq, ref ruleCheckMessage))
|
|
{
|
|
DialogBox.ShowError(string.Format($"{seq.Name} rules check failed, don't allow to save: {ruleCheckMessage}"));
|
|
return false;
|
|
}
|
|
|
|
seq.Revisor = BaseApp.Instance.UserContext.LoginName;
|
|
seq.ReviseTime = DateTime.Now;
|
|
result = provider.Save(seq);
|
|
|
|
if (result)
|
|
{
|
|
foreach (var parameters in seq.Steps)
|
|
{
|
|
parameters.Apply(param => param.IsSaved = true);
|
|
}
|
|
editMode = EditMode.Normal;
|
|
IsSavedDesc = true;
|
|
NotifyOfPropertyChange("IsSavedDesc");
|
|
UpdateView();
|
|
}
|
|
else
|
|
DialogBox.ShowError("Save failed!");
|
|
return result;
|
|
}
|
|
|
|
private bool IsExist(string sequenceName)
|
|
{
|
|
var existed = false;
|
|
var fileNode = CurrentFileNode.IsFile ? CurrentFileNode.Parent : CurrentFileNode;
|
|
for (var index = 0; index < fileNode.Files.Count; index++)
|
|
{
|
|
if (string.Equals(fileNode.Files[index].FullPath, sequenceName, StringComparison.CurrentCultureIgnoreCase))
|
|
{
|
|
existed = true;
|
|
break;
|
|
}
|
|
}
|
|
return existed;
|
|
}
|
|
|
|
private static bool ValidateSequenceRules(SequenceData currentSequence, ref string ruleCheckMessage)
|
|
{
|
|
foreach (var stepInfo in currentSequence.Steps)
|
|
{
|
|
if (string.IsNullOrEmpty((stepInfo[1] as PositionParam).Value))
|
|
{
|
|
ruleCheckMessage = $"Step{(stepInfo[0] as StepParam).Value}, Position Is Empty";
|
|
|
|
return false;
|
|
}
|
|
|
|
//if (((stepInfo[4] as PathFileParam).Visible == Visibility.Visible && string.IsNullOrEmpty((stepInfo[4] as PathFileParam).Value)) ||
|
|
// ((stepInfo[5] as PathFileParam).Visible == Visibility.Visible && string.IsNullOrEmpty((stepInfo[5] as PathFileParam).Value)))
|
|
//{
|
|
// ruleCheckMessage = $"Step{(stepInfo[0] as StepParam).Value}, Recipe Is Empty";
|
|
|
|
// return false;
|
|
//}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Steps operation
|
|
|
|
public void AddStep()
|
|
{
|
|
CurrentSequence.Steps.Add(CurrentSequence.CreateStep(Columns));
|
|
|
|
if (editMode != EditMode.New && editMode != EditMode.ReName)
|
|
editMode = EditMode.Edit;
|
|
|
|
UpdateView();
|
|
}
|
|
|
|
public void AppendStep()
|
|
{
|
|
var index = -1;
|
|
var found = false;
|
|
for (var i = 0; i < CurrentSequence.Steps.Count; i++)
|
|
{
|
|
if (CurrentSequence.Steps[i][0] is StepParam && ((StepParam)CurrentSequence.Steps[i][0]).IsChecked)
|
|
{
|
|
index = i;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (found)
|
|
{
|
|
if (editMode != EditMode.New && editMode != EditMode.ReName)
|
|
editMode = EditMode.Edit;
|
|
|
|
CurrentSequence.Steps.Insert(index, CurrentSequence.CreateStep(Columns));
|
|
}
|
|
}
|
|
|
|
private RecipeStepCollection copySteps = new RecipeStepCollection();
|
|
public void CopyStep()
|
|
{
|
|
copySteps.Clear();
|
|
|
|
for (var i = 0; i < CurrentSequence.Steps.Count; i++)
|
|
{
|
|
if (CurrentSequence.Steps[i][0] is StepParam && ((StepParam)CurrentSequence.Steps[i][0]).IsChecked)
|
|
{
|
|
copySteps.Add(CurrentSequence.CloneStep(Columns, CurrentSequence.Steps[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void PasteStep()
|
|
{
|
|
if (copySteps.Count > 0)
|
|
{
|
|
if (editMode != EditMode.New && editMode != EditMode.ReName)
|
|
editMode = EditMode.Edit;
|
|
for (var i = 0; i < CurrentSequence.Steps.Count; i++)
|
|
{
|
|
if (CurrentSequence.Steps[i][0] is StepParam && ((StepParam)CurrentSequence.Steps[i][0]).IsChecked)
|
|
{
|
|
for (var copyindex = 0; copyindex < copySteps.Count; copyindex++)
|
|
{
|
|
CurrentSequence.Steps.Insert(i, CurrentSequence.CloneStep(Columns, copySteps[copyindex]));
|
|
i++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
UpdateView();
|
|
}
|
|
}
|
|
|
|
public void DeleteStep()
|
|
{
|
|
if (editMode != EditMode.New && editMode != EditMode.ReName)
|
|
editMode = EditMode.Edit;
|
|
|
|
var steps = CurrentSequence.Steps.ToList();
|
|
|
|
for (var i = 0; i < steps.Count; i++)
|
|
{
|
|
if (steps[i][0] is StepParam && ((StepParam)steps[i][0]).IsChecked)
|
|
{
|
|
CurrentSequence.Steps.Remove(steps[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SelectRecipe(PathFileParam param)
|
|
{
|
|
var dialog = new RecipeSequenceSelectDialogViewModel();
|
|
dialog.DisplayName = "Select Recipe";
|
|
var parameters = param.Parent;
|
|
PositionParam posParam = null;
|
|
for (var index = 0; index < parameters.Count; index++)
|
|
{
|
|
if (parameters[index] is PositionParam)
|
|
{
|
|
posParam = parameters[index] as PositionParam;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var lstFiles = RecipeClient.Instance.Service.GetRecipesByPath($"Sic\\{param.PrefixPath}", false).ToList();
|
|
|
|
dialog.Files = new ObservableCollection<FileNode>(RecipeSequenceTreeBuilder.GetFiles("", lstFiles));
|
|
|
|
var wm = new WindowManager();
|
|
var bret = wm.ShowDialog(dialog);
|
|
if ((bool)bret)
|
|
{
|
|
param.Value = $"Sic\\{param.PrefixPath}\\" + dialog.DialogResult;
|
|
|
|
var path = param.Value;
|
|
var index = path.LastIndexOf("\\");
|
|
if (index > -1)
|
|
{
|
|
param.FileName = path.Substring(index + 1);
|
|
}
|
|
else
|
|
{
|
|
param.FileName = path;
|
|
}
|
|
|
|
param.IsSaved = false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void SelectDefault(FileNode node)
|
|
{
|
|
if (!node.IsFile)
|
|
{
|
|
if (node.Files.Count > 0)
|
|
{
|
|
foreach (var file in node.Files)
|
|
{
|
|
if (file.IsFile)
|
|
{
|
|
TreeSelectChanged(file);
|
|
//break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LoadData(string newSeqName)
|
|
{
|
|
var Sequence = provider.GetSequenceByName(Columns, newSeqName);
|
|
|
|
CurrentSequence.Name = Sequence.Name;
|
|
CurrentSequence.Creator = Sequence.Creator;
|
|
CurrentSequence.CreateTime = Sequence.CreateTime;
|
|
CurrentSequence.Revisor = Sequence.Revisor;
|
|
CurrentSequence.ReviseTime = Sequence.ReviseTime;
|
|
CurrentSequence.Description = Sequence.Description;
|
|
|
|
CurrentSequence.Steps.Clear();
|
|
Sequence.Steps.ToList().ForEach(step =>
|
|
CurrentSequence.Steps.Add(step));
|
|
|
|
//int index = 1;
|
|
//foreach (RecipeStep parameters in this.CurrentSequence.Steps)
|
|
//{
|
|
// (parameters[0] as StepParam).Value = index.ToString();
|
|
// index++;
|
|
|
|
// foreach (var para in parameters)
|
|
// {
|
|
// var pathFile = para as PathFileParam;
|
|
// if (pathFile != null)
|
|
// {
|
|
// pathFile.Value = pathFile.Value.Replace($"{pathFile.PrefixPath}\\", "");
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
IsSavedDesc = true;
|
|
NotifyOfPropertyChange("IsSavedDesc");
|
|
|
|
editMode = EditMode.Normal;
|
|
}
|
|
|
|
private void ClearData()
|
|
{
|
|
editMode = EditMode.None;
|
|
CurrentSequence.Steps.Clear();
|
|
CurrentSequence.Name = string.Empty;
|
|
CurrentSequence.Description = string.Empty;
|
|
|
|
IsSavedDesc = true;
|
|
|
|
NotifyOfPropertyChange("IsSavedGroup");
|
|
NotifyOfPropertyChange("IsSavedDesc");
|
|
}
|
|
|
|
public void UpdateView()
|
|
{
|
|
EnableSequenceName = false;
|
|
NotifyOfPropertyChange("EnableSequenceName");
|
|
|
|
EnableNew = true;
|
|
EnableReName = true;
|
|
EnableCopy = true;
|
|
EnableDelete = true;
|
|
EnableSave = true;
|
|
EnableStep = true;
|
|
|
|
NotifyOfPropertyChange("EnableNew");
|
|
NotifyOfPropertyChange("EnableReName");
|
|
NotifyOfPropertyChange("EnableCopy");
|
|
NotifyOfPropertyChange("EnableDelete");
|
|
NotifyOfPropertyChange("EnableSave");
|
|
NotifyOfPropertyChange("EnableStep");
|
|
|
|
if (editMode == EditMode.None)
|
|
{
|
|
EnableNew = true;
|
|
EnableReName = false;
|
|
EnableCopy = false;
|
|
EnableDelete = false;
|
|
EnableStep = false;
|
|
EnableSave = false;
|
|
|
|
NotifyOfPropertyChange("EnableNew");
|
|
NotifyOfPropertyChange("EnableReName");
|
|
NotifyOfPropertyChange("EnableCopy");
|
|
NotifyOfPropertyChange("EnableDelete");
|
|
NotifyOfPropertyChange("EnableSave");
|
|
NotifyOfPropertyChange("EnableStep");
|
|
}
|
|
}
|
|
|
|
private bool IsChanged
|
|
{
|
|
get
|
|
{
|
|
var changed = false;
|
|
if (!IsSavedDesc || editMode == EditMode.Edit)
|
|
changed = true;
|
|
else
|
|
{
|
|
foreach (var parameters in CurrentSequence.Steps)
|
|
{
|
|
if (parameters.Where(param => param.IsSaved == false && param.Name != "Step").Count() > 0)
|
|
{
|
|
changed = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return changed;
|
|
}
|
|
}
|
|
|
|
public bool EnableNew { get; set; }
|
|
public bool EnableReName { get; set; }
|
|
public bool EnableCopy { get; set; }
|
|
public bool EnableDelete { get; set; }
|
|
public bool EnableSave { get; set; }
|
|
public bool EnableStep { get; set; }
|
|
public bool IsSavedDesc { get; set; }
|
|
|
|
|
|
public FileNode CurrentFileNode { get; private set; }
|
|
public SequenceData CurrentSequence { get; private set; }
|
|
public ObservableCollection<EditorDataGridTemplateColumnBase> Columns { get; set; }
|
|
|
|
public bool EnableSequenceName { get; set; }
|
|
|
|
private string selectedSequenceName = string.Empty;
|
|
private string SequenceNameBeforeRename = string.Empty;
|
|
private string lastSequenceName = string.Empty;
|
|
|
|
private SequenceColumnBuilder columnBuilder = new SequenceColumnBuilder();
|
|
private EditMode editMode;
|
|
private SequenceDataProvider provider = new SequenceDataProvider();
|
|
}
|
|
}
|