void ValidateProcedure()
{
var nameList = new List<string>();
foreach (var procedure in ClientManager.SystemConfiguration.AutomationConfiguration.Procedures)
{
Procedure = procedure;
foreach (var procedureStep in procedure.Steps)
ValidateStep(procedure, procedureStep);
if (nameList.Contains(procedure.Name))
Errors.Add(new ProcedureValidationError(procedure, "Процедура с таким именем уже существует " + procedure.Name, ValidationErrorLevel.CannotSave));
nameList.Add(procedure.Name);
var varList = new List<string>();
foreach (var variable in procedure.Variables)
{
if (varList.Contains(variable.Name))
Errors.Add(new VariableValidationError(variable, "Переменная с таким именем уже существует " + variable.Name, ValidationErrorLevel.CannotSave));
varList.Add(variable.Name);
}
var argList = new List<string>();
foreach (var argument in procedure.Arguments)
{
if (argList.Contains(argument.Name))
Errors.Add(new VariableValidationError(argument, "Аргумент с таким именем уже существует " + argument.Name, ValidationErrorLevel.CannotSave));
argList.Add(argument.Name);
}
}
}
public FilterSelectionViewModel(Procedure procedure)
{
Title = "Выбор фильтра";
Procedure = procedure;
InitializeFilters();
CreateFilterCommand = new RelayCommand(OnCreateFilter);
}
public ProcedureDetailsViewModel(Procedure procedure = null)
{
if (procedure == null)
{
Procedure = new Procedure { ContextType = ContextType.Server };
var i = 0;
do { i++; } while (ClientManager.SystemConfiguration.AutomationConfiguration.Procedures.Any(x => x.Name == Procedure.Name + i));
Procedure.Name += i;
Title = "Создание процедуры";
}
else
{
Procedure = procedure;
Title = "Редактирование процедуры";
}
Name = Procedure.Name;
Description = Procedure.Description;
IsActive = Procedure.IsActive;
StartWithApplication = Procedure.StartWithApplication;
IsSync = Procedure.IsSync;
TimeOut = Procedure.TimeOut;
SelectedTimeType = Procedure.TimeType;
SelectedContextType = Procedure.ContextType;
TimeTypes = AutomationHelper.GetEnumObs<TimeType>();
ContextTypes = AutomationHelper.GetEnumObs<ContextType>();
}
public ScheduleProcedureViewModel(ScheduleProcedure scheduleProcedure, Procedure callingProcedure = null)
{
CallingProcedure = callingProcedure;
ScheduleProcedure = scheduleProcedure;
Procedure = ClientManager.SystemConfiguration.AutomationConfiguration.Procedures.FirstOrDefault(x => x.Uid == scheduleProcedure.ProcedureUid);
if (Procedure != null)
UpdateArguments();
}
public void Update(Procedure procedure)
{
Procedure = procedure;
if (StepsViewModel.SelectedStep != null)
StepsViewModel.SelectedStep.UpdateContent();
OnPropertyChanged(() => Name);
OnPropertyChanged(() => IsActive);
OnPropertyChanged(() => ContextType);
}
public OpcDaTagFileterSectionViewModel(Procedure procedure)
{
Title = "Выбор фильтра";
Procedure = procedure;
InitializeFilters();
CreateFilterCommand = new RelayCommand(OnCreateFilter);
ServiceFactory.Events.GetEvent<CreateOpcDaTagFilterEvent>().Subscribe(ListWasChanged);
}
public ConditionsViewModel(Procedure procedure)
{
Procedure = procedure;
AddCommand = new RelayCommand(OnAdd);
DeleteCommand = new RelayCommand(OnDelete, CanDelete);
AddOpcTagFilterCommand = new RelayCommand(OnAddOpcTagFilter);
RemoveOpcTagFilterCommand = new RelayCommand(OnRemoveOpcTagFilter, CanDeleteOpcTagFilter);
Initialize();
ServiceFactory.Events.GetEvent<DeleteOpcDaTagFilterEvent>().Subscribe(FilterWasDeleted);
}
public ArgumentsViewModel(Procedure procedure) : base(procedure)
{
AddCommand = new RelayCommand(OnAdd);
DeleteCommand = new RelayCommand(OnDelete, CanDelete);
EditCommand = new RelayCommand(OnEdit, CanEdit);
Variables = new ObservableCollection<VariableViewModel>();
foreach (var variable in procedure.Arguments)
{
var argumentViewModel = new VariableViewModel(variable);
Variables.Add(argumentViewModel);
}
}
public ProcedurePainter(PresenterItem presenterItem)
: base(presenterItem.DesignerCanvas, presenterItem.Element)
{
PresenterItem = presenterItem;
Item = CreateItem(presenterItem);
PresenterItem.IsPoint = false;
PresenterItem.ShowBorderOnMouseOver = true;
PresenterItem.Cursor = Cursors.Hand;
PresenterItem.ClickEvent += (s, e) =>
ProcedureArgumentsViewModel.Run(Item);
_tooltip = new ProcedureTooltipViewModel(Item);
}
public static void Run(Procedure procedure)
{
List<Argument> args = null;
if (procedure.Arguments.Count > 0)
{
var viewModel = new ProcedureArgumentsViewModel(procedure);
if (DialogService.ShowModalWindow(viewModel)) ;
args = viewModel.ArgumentViewModels.Arguments.Select(x =>
new Argument
{
VariableScope = VariableScope.ExplicitValue,
Value = x.Argument.Value,
ExplicitType = x.Argument.ExplicitType,
EnumType = x.Argument.EnumType,
ObjectType = x.Argument.ObjectType,
IsList = x.Argument.IsList
}).ToList();
}
ProcedureHelper.Run(procedure, args, ClientManager.CurrentUser);
}
public static void Run(Procedure procedure, List<Argument> args = null, User user = null)
{
if (args == null)
args = new List<Argument>();
using (new WaitWrapper())
{
var thread = new Thread(() =>
{
if (procedure.ContextType == ContextType.Client)
AutomationProcessor.RunProcedure(procedure, args, null, user, null, RubezhServiceFactory.UID);
else
ClientManager.RubezhService.RunProcedure(procedure.Uid, args);
}
)
{
Name = "Run Procedure",
};
thread.Start();
while (!thread.Join(50))
ApplicationService.DoEvents();
}
}
public ProcedureViewModel(Procedure procedure)
{
ShowStepsCommand = new RelayCommand(OnShowSteps);
ShowVariablesCommand = new RelayCommand(OnShowVariables);
ShowArgumentsCommand = new RelayCommand(OnShowArguments);
ShowConditionsCommand = new RelayCommand(OnShowConditions);
Procedure = procedure;
procedure.PlanElementUIDsChanged += UpdateVisualizationState;
StepsViewModel = new StepsViewModel(procedure);
VariablesViewModel = new VariablesViewModel(procedure);
ArgumentsViewModel = new ArgumentsViewModel(procedure);
ConditionsViewModel = new ConditionsViewModel(procedure);
MenuTypes = new ObservableRangeCollection<MenuType>
{
MenuType.IsSteps,
MenuType.IsVariables,
MenuType.IsArguments,
MenuType.IsConditions
};
SelectedMenuType = MenuTypes.FirstOrDefault();
}
public ProcedureThread(Procedure procedure, List<Argument> arguments, List<Variable> callingProcedureVariables, JournalItem journalItem = null, User user = null, Guid? clientUID = null)
{
UID = Guid.NewGuid();
ClientUID = clientUID.HasValue ? clientUID.Value : Guid.Empty;
ContextType = procedure.ContextType;
User = user;
IsAlive = true;
JournalItem = journalItem;
TimeOut = procedure.TimeOut;
TimeType = procedure.TimeType;
AutoResetEvent = new AutoResetEvent(false);
Steps = procedure.Steps;
AllVariables = Utils.Clone(procedure.Variables);
var procedureArguments = Utils.Clone(procedure.Arguments);
InitializeArguments(procedureArguments, arguments, callingProcedureVariables);
AllVariables.AddRange(procedureArguments);
AllVariables.AddRange(ProcedureExecutionContext.GlobalVariables);
Thread = new Thread(() => RunInThread(arguments))
{
Name = string.Format("ProcedureThread [{0}]", UID),
};
IsSync = procedure.IsSync;
}
public ProcedureArgumentsViewModel(Procedure procedure)
{
Title = procedure.Name;
SaveCaption = "Выполнить";
ArgumentViewModels = new ArgumentsViewModel(procedure);
}
void ValidateStep(Procedure procedure, ProcedureStep step)
{
switch (step.ProcedureStepType)
{
case ProcedureStepType.PlaySound:
var soundStep = (SoundStep)step;
if (ClientManager.SystemConfiguration.AutomationConfiguration.AutomationSounds.All(x => x.Uid != soundStep.SoundUid))
Errors.Add(new ProcedureStepValidationError(step, "Необходимо выбрать звук", ValidationErrorLevel.CannotSave));
break;
case ProcedureStepType.ShowMessage:
var showMessageStep = (ShowMessageStep)step;
ValidateArgument(procedure, step, showMessageStep.MessageArgument);
if (showMessageStep.WithConfirmation)
ValidateArgument(procedure, step, showMessageStep.ConfirmationValueArgument);
break;
case ProcedureStepType.Arithmetics:
var arithmeticStep = (ArithmeticStep)step;
if (!ValidateArgument(procedure, step, arithmeticStep.Argument1))
break;
if (!ValidateArgument(procedure, step, arithmeticStep.Argument2))
break;
ValidateArgument(procedure, step, arithmeticStep.ResultArgument);
break;
case ProcedureStepType.CreateColor:
var createColorStep = (CreateColorStep)step;
if (!ValidateArgument(procedure, step, createColorStep.AArgument))
break;
if (!ValidateArgument(procedure, step, createColorStep.RArgument))
break;
if (!ValidateArgument(procedure, step, createColorStep.GArgument))
break;
if (!ValidateArgument(procedure, step, createColorStep.BArgument))
break;
ValidateArgument(procedure, step, createColorStep.ResultArgument);
break;
case ProcedureStepType.If:
case ProcedureStepType.While:
var conditionStep = (ConditionStep)step;
foreach (var condition in conditionStep.Conditions)
{
if (!ValidateArgument(procedure, step, condition.Argument1))
break;
ValidateArgument(procedure, step, condition.Argument2);
}
break;
case ProcedureStepType.AddJournalItem:
var journalStep = (JournalStep)step;
ValidateArgument(procedure, step, journalStep.MessageArgument);
break;
case ProcedureStepType.FindObjects:
var findObjectStep = (FindObjectStep)step;
if (!ValidateArgument(procedure, step, findObjectStep.ResultArgument))
break;
foreach (var findObjectCondition in findObjectStep.FindObjectConditions)
{
if (!ValidateArgument(procedure, step, findObjectCondition.SourceArgument))
break;
}
break;
case ProcedureStepType.Foreach:
var foreachStep = (ForeachStep)step;
if (!ValidateArgument(procedure, step, foreachStep.ItemArgument))
break;
ValidateArgument(procedure, step, foreachStep.ListArgument);
break;
case ProcedureStepType.For:
var forStep = (ForStep)step;
if (!ValidateArgument(procedure, step, forStep.IndexerArgument))
break;
if (!ValidateArgument(procedure, step, forStep.InitialValueArgument))
break;
if (!ValidateArgument(procedure, step, forStep.ValueArgument))
break;
ValidateArgument(procedure, step, forStep.IteratorArgument);
break;
case ProcedureStepType.Pause:
var pauseStep = (PauseStep)step;
ValidateArgument(procedure, step, pauseStep.PauseArgument);
break;
case ProcedureStepType.ProcedureSelection:
var procedureSelectionStep = (ProcedureSelectionStep)step;
if (ClientManager.SystemConfiguration.AutomationConfiguration.Procedures.All(x => x.Uid != procedureSelectionStep.ScheduleProcedure.ProcedureUid))
Errors.Add(new ProcedureStepValidationError(step, "Необходимо выбрать процедуру", ValidationErrorLevel.CannotSave));
foreach (var argument in procedureSelectionStep.ScheduleProcedure.Arguments)
ValidateArgument(procedure, step, argument);
break;
case ProcedureStepType.SetValue:
var setValueStep = (SetValueStep)step;
if (!ValidateArgument(procedure, step, setValueStep.SourceArgument))
break;
ValidateArgument(procedure, step, setValueStep.TargetArgument);
break;
case ProcedureStepType.IncrementValue:
var incrementValueStep = (IncrementValueStep)step;
ValidateArgument(procedure, step, incrementValueStep.ResultArgument);
break;
case ProcedureStepType.ControlGKDevice:
if (!GlobalSettingsHelper.GlobalSettings.IgnoredErrors.Contains(ValidationErrorType.DeviceHaveSelfLogik))
{
var controlGKDeviceStep = (ControlGKDeviceStep)step;
var gkDevice = GKManager.DeviceConfiguration.Devices.FirstOrDefault(x => x.UID == controlGKDeviceStep.GKDeviceArgument.UidValue);
if (gkDevice != null && gkDevice.Logic.OnClausesGroup.Clauses.Count > 0)
Errors.Add(new ProcedureStepValidationError(step, "Исполнительное устройство содержит собственную логику", ValidationErrorLevel.Warning));
ValidateArgument(procedure, step, controlGKDeviceStep.GKDeviceArgument);
}
break;
case ProcedureStepType.ControlGKFireZone:
if (!LicenseManager.CurrentLicenseInfo.HasFirefighting)
Errors.Add(new ProcedureStepValidationError(step, "Отсутствует лицензия для выполнения шага", ValidationErrorLevel.Warning));
var controlGKFireZoneStep = (ControlGKFireZoneStep)step;
ValidateArgument(procedure, step, controlGKFireZoneStep.GKFireZoneArgument);
break;
case ProcedureStepType.ControlGKGuardZone:
if (!LicenseManager.CurrentLicenseInfo.HasGuard)
Errors.Add(new ProcedureStepValidationError(step, "Отсутствует лицензия для выполнения шага", ValidationErrorLevel.Warning));
var controlGKGuardZoneStep = (ControlGKGuardZoneStep)step;
ValidateArgument(procedure, step, controlGKGuardZoneStep.GKGuardZoneArgument);
break;
case ProcedureStepType.ControlDirection:
var controlDirectionStep = (ControlDirectionStep)step;
ValidateArgument(procedure, step, controlDirectionStep.DirectionArgument);
break;
case ProcedureStepType.ControlGKDoor:
if (!LicenseManager.CurrentLicenseInfo.HasSKD)
Errors.Add(new ProcedureStepValidationError(step, "Отсутствует лицензия для выполнения шага", ValidationErrorLevel.Warning));
var controlGKDoorStep = (ControlGKDoorStep)step;
ValidateArgument(procedure, step, controlGKDoorStep.DoorArgument);
break;
case ProcedureStepType.ControlDelay:
var controlDelayStep = (ControlDelayStep)step;
ValidateArgument(procedure, step, controlDelayStep.DelayArgument);
break;
case ProcedureStepType.GetObjectProperty:
var getObjectPropertyStep = (GetObjectPropertyStep)step;
if (!ValidateArgument(procedure, step, getObjectPropertyStep.ObjectArgument))
break;
ValidateArgument(procedure, step, getObjectPropertyStep.ResultArgument);
break;
case ProcedureStepType.SendEmail:
var sendEmailStep = (SendEmailStep)step;
if (!ValidateArgument(procedure, step, sendEmailStep.EMailAddressFromArgument))
break;
if (!ValidateArgument(procedure, step, sendEmailStep.EMailAddressToArgument))
break;
if (!ValidateArgument(procedure, step, sendEmailStep.EMailContentArgument))
break;
if (!ValidateArgument(procedure, step, sendEmailStep.EMailTitleArgument))
break;
if (!ValidateArgument(procedure, step, sendEmailStep.SmtpArgument))
break;
if (!ValidateArgument(procedure, step, sendEmailStep.LoginArgument))
break;
if (!ValidateArgument(procedure, step, sendEmailStep.PasswordArgument))
break;
ValidateArgument(procedure, step, sendEmailStep.PortArgument);
break;
case ProcedureStepType.RunProgram:
var RunProgramStep = (RunProgramStep)step;
if (!ValidateArgument(procedure, step, RunProgramStep.ParametersArgument))
break;
ValidateArgument(procedure, step, RunProgramStep.PathArgument);
break;
case ProcedureStepType.Random:
var randomStep = (RandomStep)step;
ValidateArgument(procedure, step, randomStep.MaxValueArgument);
break;
case ProcedureStepType.ChangeList:
var changeListStep = (ChangeListStep)step;
if (!ValidateArgument(procedure, step, changeListStep.ItemArgument))
break;
ValidateArgument(procedure, step, changeListStep.ListArgument);
break;
case ProcedureStepType.CheckPermission:
var checkPermissionStep = (CheckPermissionStep)step;
if (!ValidateArgument(procedure, step, checkPermissionStep.PermissionArgument))
break;
ValidateArgument(procedure, step, checkPermissionStep.ResultArgument);
break;
case ProcedureStepType.GetJournalItem:
var getJournalItemStep = (GetJournalItemStep)step;
ValidateArgument(procedure, step, getJournalItemStep.ResultArgument);
break;
case ProcedureStepType.GetListCount:
var getListCountStep = (GetListCountStep)step;
if (!ValidateArgument(procedure, step, getListCountStep.ListArgument))
break;
ValidateArgument(procedure, step, getListCountStep.CountArgument);
break;
case ProcedureStepType.GetListItem:
var getListItemStep = (GetListItemStep)step;
if (!ValidateArgument(procedure, step, getListItemStep.ListArgument))
break;
if (!ValidateArgument(procedure, step, getListItemStep.ItemArgument))
break;
if (getListItemStep.PositionType == PositionType.ByIndex)
ValidateArgument(procedure, step, getListItemStep.IndexArgument);
break;
case ProcedureStepType.ControlVisualGet:
case ProcedureStepType.ControlVisualSet:
var controlVisualStep = (ControlVisualStep)step;
if (!ValidateArgument(procedure, step, controlVisualStep.Argument))
break;
if (controlVisualStep.Layout == Guid.Empty)
Errors.Add(new ProcedureStepValidationError(step, "Не выбран макет", ValidationErrorLevel.CannotSave));
else if (controlVisualStep.LayoutPart == Guid.Empty)
Errors.Add(new ProcedureStepValidationError(step, "Не выбран элемент макета", ValidationErrorLevel.CannotSave));
else if (!controlVisualStep.Property.HasValue)
Errors.Add(new ProcedureStepValidationError(step, "Не выбрано свойство", ValidationErrorLevel.CannotSave));
break;
case ProcedureStepType.ControlPlanGet:
case ProcedureStepType.ControlPlanSet:
var controlPlanStep = (ControlPlanStep)step;
ValidateArgument(procedure, step, controlPlanStep.ValueArgument);
if (controlPlanStep.PlanUid == Guid.Empty)
Errors.Add(new ProcedureStepValidationError(step, "Не выбран план", ValidationErrorLevel.CannotSave));
else if (controlPlanStep.ElementUid == Guid.Empty)
Errors.Add(new ProcedureStepValidationError(step, "Не выбран элемент плана", ValidationErrorLevel.CannotSave));
break;
case ProcedureStepType.ControlOpcDaTagGet:
case ProcedureStepType.ControlOpcDaTagSet:
var controlOpcDaTagStep = (ControlOpcDaTagStep)step;
if (controlOpcDaTagStep.OpcDaServerUID == Guid.Empty)
Errors.Add(new ProcedureStepValidationError(step, "Не выбран OPC DA Сервер", ValidationErrorLevel.CannotSave));
else if (controlOpcDaTagStep.OpcDaTagUID == Guid.Empty)
Errors.Add(new ProcedureStepValidationError(step, "Не выбран OPC DA Тэг", ValidationErrorLevel.CannotSave));
else
ValidateArgument(procedure, step, controlOpcDaTagStep.ValueArgument);
break;
case ProcedureStepType.ShowDialog:
var showDialogStep = (ShowDialogStep)step;
if (showDialogStep.Layout == Guid.Empty)
Errors.Add(new ProcedureStepValidationError(step, "Не выбран макет", ValidationErrorLevel.CannotSave));
break;
case ProcedureStepType.CloseDialog:
var closeDialogStep = (CloseDialogStep)step;
ValidateArgument(procedure, step, closeDialogStep.WindowIDArgument);
break;
case ProcedureStepType.GenerateGuid:
var generateGuidStep = (GenerateGuidStep)step;
ValidateArgument(procedure, step, generateGuidStep.ResultArgument);
break;
case ProcedureStepType.SetJournalItemGuid:
var setJournalItemGuidStep = (SetJournalItemGuidStep)step;
ValidateArgument(procedure, step, setJournalItemGuidStep.ValueArgument);
break;
case ProcedureStepType.ExportJournal:
var exportJournalStep = (ExportJournalStep)step;
if (!ValidateArgument(procedure, step, exportJournalStep.IsExportJournalArgument))
break;
if (!ValidateArgument(procedure, step, exportJournalStep.IsExportPassJournalArgument))
break;
if (!ValidateArgument(procedure, step, exportJournalStep.MaxDateArgument))
break;
if (!ValidateArgument(procedure, step, exportJournalStep.MinDateArgument))
break;
ValidateArgument(procedure, step, exportJournalStep.PathArgument);
break;
case ProcedureStepType.ExportConfiguration:
var exportConfigurationStep = (ExportConfigurationStep)step;
if (!ValidateArgument(procedure, step, exportConfigurationStep.IsExportDevices))
break;
if (!ValidateArgument(procedure, step, exportConfigurationStep.IsExportDoors))
break;
if (!ValidateArgument(procedure, step, exportConfigurationStep.IsExportZones))
break;
ValidateArgument(procedure, step, exportConfigurationStep.PathArgument);
break;
case ProcedureStepType.ExportOrganisation:
var exportOrganisationStep = (ExportOrganisationStep)step;
if (!ValidateArgument(procedure, step, exportOrganisationStep.IsWithDeleted))
break;
if (!ValidateArgument(procedure, step, exportOrganisationStep.Organisation))
break;
ValidateArgument(procedure, step, exportOrganisationStep.PathArgument);
break;
case ProcedureStepType.ExportOrganisationList:
var exportOrganisationListStep = (ExportOrganisationListStep)step;
if (!ValidateArgument(procedure, step, exportOrganisationListStep.IsWithDeleted))
break;
ValidateArgument(procedure, step, exportOrganisationListStep.PathArgument);
break;
case ProcedureStepType.ImportOrganisationList:
var importOrganisationListStep = (ImportOrganisationListStep)step;
if (!ValidateArgument(procedure, step, importOrganisationListStep.IsWithDeleted))
break;
ValidateArgument(procedure, step, importOrganisationListStep.PathArgument);
break;
case ProcedureStepType.ImportOrganisation:
var importOrganisationStep = (ImportOrganisationStep)step;
if (!ValidateArgument(procedure, step, importOrganisationStep.IsWithDeleted))
break;
ValidateArgument(procedure, step, importOrganisationStep.PathArgument);
break;
case ProcedureStepType.Ptz:
if (!LicenseManager.CurrentLicenseInfo.HasVideo)
Errors.Add(new ProcedureStepValidationError(step, "Отсутствует лицензия для выполнения шага", ValidationErrorLevel.Warning));
var ptzStep = (PtzStep)step;
if (!ValidateArgument(procedure, step, ptzStep.CameraArgument))
break;
ValidateArgument(procedure, step, ptzStep.PtzNumberArgument);
break;
case ProcedureStepType.StartRecord:
if (!LicenseManager.CurrentLicenseInfo.HasVideo)
Errors.Add(new ProcedureStepValidationError(step, "Отсутствует лицензия для выполнения шага", ValidationErrorLevel.Warning));
var startRecordStep = (StartRecordStep)step;
if (!ValidateArgument(procedure, step, startRecordStep.CameraArgument))
break;
if (!ValidateArgument(procedure, step, startRecordStep.EventUIDArgument))
break;
ValidateArgument(procedure, step, startRecordStep.TimeoutArgument);
break;
case ProcedureStepType.StopRecord:
if (!LicenseManager.CurrentLicenseInfo.HasVideo)
Errors.Add(new ProcedureStepValidationError(step, "Отсутствует лицензия для выполнения шага", ValidationErrorLevel.Warning));
var stopRecordStep = (StopRecordStep)step;
if (!ValidateArgument(procedure, step, stopRecordStep.CameraArgument))
break;
ValidateArgument(procedure, step, stopRecordStep.EventUIDArgument);
break;
case ProcedureStepType.RviAlarm:
if (!LicenseManager.CurrentLicenseInfo.HasVideo)
Errors.Add(new ProcedureStepValidationError(step, "Отсутствует лицензия для выполнения шага", ValidationErrorLevel.Warning));
var rviAlarmStep = (RviAlarmStep)step;
ValidateArgument(procedure, step, rviAlarmStep.NameArgument);
break;
case ProcedureStepType.RviOpenWindow:
if (!LicenseManager.CurrentLicenseInfo.HasVideo)
Errors.Add(new ProcedureStepValidationError(step, "Отсутствует лицензия для выполнения шага", ValidationErrorLevel.Warning));
var rviOpenWindowStep = (RviOpenWindowStep)step;
ValidateArgument(procedure, step, rviOpenWindowStep.NameArgument);
break;
case ProcedureStepType.Now:
var nowStep = (NowStep)step;
ValidateArgument(procedure, step, nowStep.ResultArgument);
break;
case ProcedureStepType.HttpRequest:
var httpRequestStep = (HttpRequestStep)step;
ValidateArgument(procedure, step, httpRequestStep.UrlArgument);
if (httpRequestStep.HttpMethod == HttpMethod.Post)
ValidateArgument(procedure, step, httpRequestStep.ContentArgument);
ValidateArgument(procedure, step, httpRequestStep.ResponseArgument);
break;
}
if (step is UIStep && ((UIStep)step).LayoutFilter.Count == 0)
Errors.Add(new ProcedureStepValidationError(step, "Необходимо выбрать как минимум один макет в фильтре макетов", ValidationErrorLevel.CannotSave));
foreach (var childStep in step.Children)
ValidateStep(procedure, childStep);
}
bool ValidateArgument(Procedure procedure, ProcedureStep step, Argument argument)
{
var localVariables = new List<Variable>(Procedure.Variables);
localVariables.AddRange(new List<Variable>(Procedure.Arguments));
if (argument.VariableScope == VariableScope.GlobalVariable)
{
var variable = ClientManager.SystemConfiguration.AutomationConfiguration.GlobalVariables.FirstOrDefault(x => x.Uid == argument.VariableUid);
if (variable == null)
{
Errors.Add(new ProcedureStepValidationError(step, "Все переменные должны быть инициализированы", ValidationErrorLevel.CannotSave));
return false;
}
else if (variable.ContextType == ContextType.Client && procedure.ContextType == ContextType.Server)
{
Errors.Add(new ProcedureStepValidationError(step, "Глобальная переменная \"" + variable.Name + "\" будет определена на сервере, т.к. контекст исполнения процедуры - сервер", ValidationErrorLevel.Warning));
return false;
}
}
if (argument.VariableScope == VariableScope.LocalVariable)
if (localVariables.All(x => x.Uid != argument.VariableUid))
{
Errors.Add(new ProcedureStepValidationError(step, "Все переменные должны быть инициализированы", ValidationErrorLevel.CannotSave));
return false;
}
return true;
}
void InvalidateArgument(Procedure procedure, Argument argument)
{
var localVariables = new List<Variable>(procedure.Variables);
localVariables.AddRange(new List<Variable>(procedure.Arguments));
if (argument.VariableScope == VariableScope.GlobalVariable)
if (GlobalVariables.All(x => x.Uid != argument.VariableUid))
argument.VariableUid = Guid.Empty;
if (argument.VariableScope == VariableScope.LocalVariable)
if (localVariables.All(x => x.Uid != argument.VariableUid))
argument.VariableUid = Guid.Empty;
}
public void InvalidateStep(ProcedureStep step, Procedure procedure)
{
InvalidateArguments(step, procedure);
switch (step.ProcedureStepType)
{
case ProcedureStepType.PlaySound:
var soundStep = (SoundStep)step;
if (AutomationSounds.All(x => x.Uid != soundStep.SoundUid))
soundStep.SoundUid = Guid.Empty;
break;
case ProcedureStepType.If:
case ProcedureStepType.While:
var conditionStep = (ConditionStep)step;
foreach (var condition in conditionStep.Conditions)
{
InvalidateArgument(procedure, condition.Argument1);
InvalidateArgument(procedure, condition.Argument2);
}
break;
case ProcedureStepType.FindObjects:
var findObjectStep = (FindObjectStep)step;
foreach (var findObjectCondition in findObjectStep.FindObjectConditions)
InvalidateArgument(procedure, findObjectCondition.SourceArgument);
break;
case ProcedureStepType.ProcedureSelection:
var procedureSelectionStep = (ProcedureSelectionStep)step;
if (Procedures.All(x => x.Uid != procedureSelectionStep.ScheduleProcedure.ProcedureUid))
procedureSelectionStep.ScheduleProcedure.ProcedureUid = Guid.Empty;
foreach (var argument in procedureSelectionStep.ScheduleProcedure.Arguments)
InvalidateArgument(procedure, argument);
break;
case ProcedureStepType.ControlPlanGet:
case ProcedureStepType.ControlPlanSet:
var controlPlanStep = (ControlPlanStep)step;
if (ConfigurationCash.PlansConfiguration == null || ConfigurationCash.PlansConfiguration.AllPlans == null)
return;
var plan = ConfigurationCash.PlansConfiguration.AllPlans.FirstOrDefault(x => x.UID == controlPlanStep.PlanUid);
if (plan == null)
{
controlPlanStep.PlanUid = Guid.Empty;
controlPlanStep.ElementUid = Guid.Empty;
}
else
{
if (plan.AllElements.All(x => x.UID != controlPlanStep.ElementUid))
controlPlanStep.ElementUid = Guid.Empty;
}
break;
case ProcedureStepType.ControlOpcDaTagGet:
case ProcedureStepType.ControlOpcDaTagSet:
var controlOpcDaTagStep = (ControlOpcDaTagStep)step;
var server = OpcDaTsServers.FirstOrDefault(x => x.Uid == controlOpcDaTagStep.OpcDaServerUID);
if (server == null)
{
controlOpcDaTagStep.OpcDaServerUID = Guid.Empty;
controlOpcDaTagStep.OpcDaTagUID = Guid.Empty;
}
else if (server.Tags.All(x => x.Uid != controlOpcDaTagStep.OpcDaTagUID))
controlOpcDaTagStep.OpcDaTagUID = Guid.Empty;
break;
}
}
void InvalidateArguments(ProcedureStep step, Procedure procedure)
{
foreach (var argument in step.GetType().GetProperties().Where(x => x.PropertyType == typeof(Argument)))
{
var value = (Argument)argument.GetValue(step, null);
InvalidateArgument(procedure, value);
}
}
public ArgumentsViewModel(Procedure procedure)
{
Procedure = procedure;
UpdateArguments();
}
public ProcedureViewModel(Procedure procedure)
{
Procedure = procedure;
ArgumentsViewModel = new ArgumentsViewModel(procedure);
RunCommand = new RelayCommand(OnRun);
}
public static void RunProcedure(Procedure procedure, List<Argument> arguments, List<Variable> callingProcedureVariables, User user = null, JournalItem journalItem = null, Guid? clientUID = null)
{
if (procedure.IsActive && _procedureThreads != null)
{
var procedureThread = new ProcedureThread(procedure, arguments, callingProcedureVariables, journalItem, user, clientUID);
_procedureThreads.TryAdd(procedureThread.UID, procedureThread);
procedureThread.Start();
}
}
public ProcedureTooltipViewModel(Procedure procedure)
{
Procedure = procedure;
}
