public void AddRelatedStep(ProcedureStep step)
{
if (!Equals(step.Procedure, this.Procedure))
throw new Exception();
_relatedSteps.Add(step);
}
protected static T CurrentProcedureStep <T>(Procedure rp, ActivityStatus status) where T : ProcedureStep
{
ProcedureStep uncastProcedureStep = CollectionUtils.SelectFirst(
rp.ProcedureSteps,
delegate(ProcedureStep ps) { return(ps.Is <T>() && ps.State == status); });
return(uncastProcedureStep != null?uncastProcedureStep.Downcast <T>() : null);
}
public void ProcedureSelectionStep(ProcedureStep procedureStep)
{
var procedureSelectionStep = (ProcedureSelectionStep)procedureStep;
var childProcedure = ProcedureExecutionContext.SystemConfiguration.AutomationConfiguration.Procedures.
FirstOrDefault(x => x.Uid == procedureSelectionStep.ScheduleProcedure.ProcedureUid);
if (childProcedure != null)
AutomationProcessor.RunProcedure(childProcedure, procedureSelectionStep.ScheduleProcedure.Arguments, AllVariables, User, JournalItem, ClientUID);
}
private void BuildProcedure()
{
List <ProcedureStep> procedureSteps = new List <ProcedureStep>();
Procedure procedure = new Procedure("Maintainance", "Maintainance procedure of the Siemens CT.");
myWorkflowGraph.AddNode(procedure);
ProcedureStep submit = new ProcedureStep(ProcedureStepEunm.CreateStep.ToString(), "The CSE submit a maintain ticket.");
ProcedureStep ticketCheck = new ProcedureStep(ProcedureStepEunm.TicketCheck.ToString(), "The Interface check the ticket.");
ProcedureStep preAnalysis = new ProcedureStep(ProcedureStepEunm.PreAnalysis.ToString(), "The SE pre-analysis the issue and assign to RP.");
ProcedureStep solve = new ProcedureStep(ProcedureStepEunm.Solve.ToString(), "The RP solve the issue.");
ProcedureStep evaluate = new ProcedureStep(ProcedureStepEunm.Evaluate.ToString(), "The SE evaluate the solution.");
ProcedureStep regression = new ProcedureStep(ProcedureStepEunm.Regression.ToString(), "The test center regression the soultion.");
ProcedureStep feedback = new ProcedureStep(ProcedureStepEunm.Feedback.ToString(), "The CSE give a Feedback to the customer.");
procedureSteps.Add(submit);
procedureSteps.Add(ticketCheck);
procedureSteps.Add(preAnalysis);
procedureSteps.Add(solve);
procedureSteps.Add(evaluate);
procedureSteps.Add(regression);
procedureSteps.Add(feedback);
foreach (var curItem in procedureSteps)
{
myWorkflowGraph.AddNode(curItem);
}
ProcedureBuilder.BuildProcedure(myWorkflowGraph, procedure, procedureSteps);
Edge newEdge = new Next("Submit");
myWorkflowGraph.AddEdge(submit, ticketCheck, newEdge);
newEdge = new Next("Assign");
myWorkflowGraph.AddEdge(ticketCheck, preAnalysis, newEdge);
newEdge = new Next("Assign");
myWorkflowGraph.AddEdge(preAnalysis, solve, newEdge);
newEdge = new Next("Submit");
myWorkflowGraph.AddEdge(solve, evaluate, newEdge);
newEdge = new Next("Assign");
myWorkflowGraph.AddEdge(evaluate, regression, newEdge);
newEdge = new Next("Submit");
myWorkflowGraph.AddEdge(regression, feedback, newEdge);
newEdge = new Next("Feedback");
myWorkflowGraph.AddEdge(ticketCheck, feedback, newEdge);
newEdge = new Next("Feedback");
myWorkflowGraph.AddEdge(preAnalysis, feedback, newEdge);
newEdge = new Next("Feedback");
myWorkflowGraph.AddEdge(evaluate, feedback, newEdge);
newEdge = new Next("Rework");
myWorkflowGraph.AddEdge(evaluate, solve, newEdge);
newEdge = new Next("Return");
myWorkflowGraph.AddEdge(regression, evaluate, newEdge);
}
public void AddRelatedStep(ProcedureStep step)
{
if (!Equals(step.Procedure, this.Procedure))
{
throw new Exception();
}
_relatedSteps.Add(step);
}
public ProcedureStepViewModel(ProcedureStep procedureStep)
{
ProcedureStep = procedureStep;
if (ProcedureStep.ProcedureStepType == ProcedureStepType.PlaySound)
{
SoundStepViewModel = new SoundStepViewModel(procedureStep);
}
}
public StepStore(ProcedureStep curStep)
{
strName = curStep.Name;
bolIsFeedback = curStep.IsFeedback;
if (bolIsFeedback == false)
{
strGroup = curStep.HandleRole.Name;
}
strDescription = curStep.Description;
}
public void GetObjectPropertyStep(ProcedureStep procedureStep)
{
var getObjectPropertyStep = (GetObjectPropertyStep)procedureStep;
var target = AllVariables.FirstOrDefault(x => x.Uid == getObjectPropertyStep.ResultArgument.VariableUid);
var item = GetResolvedValue(getObjectPropertyStep.ObjectArgument);
if (item == null)
return;
var propertyValue = GetPropertyValue(getObjectPropertyStep.Property, item);
ProcedureExecutionContext.SetVariableValue(target, propertyValue, ClientUID);
}
public ProcedureStep GiveMeMappedObject(string tripleStoreId)
{
string id = tripleStoreId ?? TripleStoreId;
ProcedureStep result = new ProcedureStep();
result.Id = new System.Uri($"https://id.parliament.uk/{id}");
result.ProcedureStepName = Title;
result.ProcedureStepDescription = Description;
return(result);
}
/// <summary>
/// Initialize this worklist item from the specified procedure step and related entities.
/// </summary>
/// <param name="step"></param>
/// <param name="timeField"></param>
/// <remarks>
/// This method is not efficient for generating a large number of worklist items from a large set of procedure steps,
/// because it causes a large number of secondary references and collections to be initiliazed.
/// Use <see cref="WorklistItem.InitializeFromTuple"/> instead.
/// </remarks>
public override void InitializeFromProcedureStep(ProcedureStep step, WorklistItemField timeField)
{
var reportingStep = step.As<ReportingProcedureStep>();
if (reportingStep != null && reportingStep.ReportPart != null)
{
this.ReportRef = reportingStep.ReportPart.Report.GetRef();
this.ReportPartIndex = reportingStep.ReportPart.Index;
this.HasErrors = reportingStep.Is<TranscriptionReviewStep>()
? reportingStep.As<TranscriptionReviewStep>().HasErrors : false;
}
base.InitializeFromProcedureStep(step, timeField);
}
public ProcedureStepSummary CreateProcedureStepSummary(ProcedureStep ps, IPersistenceContext context)
{
var assembler = new ProcedureAssembler();
var modalityAssembler = new ModalityAssembler();
return(new ProcedureStepSummary(
ps.GetRef(),
ps.Name,
EnumUtils.GetEnumValueInfo(ps.State, context),
ps.StartTime,
ps.EndTime,
ps.Is <ModalityProcedureStep>() ? modalityAssembler.CreateModalitySummary(ps.As <ModalityProcedureStep>().Modality) : null,
assembler.CreateProcedureSummary(ps.Procedure, context)));
}
/// <summary>
/// Initialize this worklist item from the specified procedure step and related entities.
/// </summary>
/// <param name="step"></param>
/// <param name="timeField"></param>
/// <remarks>
/// This method is not efficient for generating a large number of worklist items from a large set of procedure steps,
/// because it causes a large number of secondary references and collections to be initiliazed.
/// Use <see cref="WorklistItem.InitializeFromTuple"/> instead.
/// </remarks>
public override void InitializeFromProcedureStep(ProcedureStep step, WorklistItemField timeField)
{
var reportingStep = step.As <ReportingProcedureStep>();
if (reportingStep != null && reportingStep.ReportPart != null)
{
this.ReportRef = reportingStep.ReportPart.Report.GetRef();
this.ReportPartIndex = reportingStep.ReportPart.Index;
this.HasErrors = reportingStep.Is <TranscriptionReviewStep>()
? reportingStep.As <TranscriptionReviewStep>().HasErrors : false;
}
base.InitializeFromProcedureStep(step, timeField);
}
/// <summary>
/// Helper method that implements the logic for performing searches on worklists.
/// </summary>
/// <typeparam name="TItem"></typeparam>
/// <typeparam name="TSummary"></typeparam>
/// <param name="request"></param>
/// <param name="broker"></param>
/// <param name="projection"></param>
/// <param name="mapCallback"></param>
/// <returns></returns>
protected TextQueryResponse <TSummary> SearchHelper <TItem, TSummary>(
WorklistItemTextQueryRequest request,
IWorklistItemBroker broker,
WorklistItemProjection projection,
Converter <TItem, TSummary> mapCallback)
where TSummary : DataContractBase
where TItem : WorklistItem
{
var procedureStepClass = request.ProcedureStepClassName == null ? null
: ProcedureStep.GetSubClass(request.ProcedureStepClassName, PersistenceContext);
var helper = new WorklistItemTextQueryHelper <TItem, TSummary>(broker, mapCallback, procedureStepClass, projection, request.Options, PersistenceContext);
return(helper.Query(request));
}
public void Test_Reassign()
{
Procedure procedure = new Procedure();
DocumentationProcedureStep procedureStep = new DocumentationProcedureStep(procedure);
procedureStep.Suspend();
Staff performer = new Staff();
ProcedureStep newStep = procedureStep.Reassign(performer); // Perform event
// just need to test that it returns a new instance of this class
// everything else has been covered in base class tests
Assert.IsNotNull(newStep);
Assert.AreNotEqual(this, newStep);
Assert.IsInstanceOfType(typeof(DocumentationProcedureStep), newStep);
Assert.AreEqual(procedure, newStep.Procedure);
}
public void Test_AutoStartOrderProcedure()
{
Order order = TestOrderFactory.CreateOrder(2, 2, true);
// put the order in progress
Procedure rp = CollectionUtils.FirstElement(order.Procedures);
ProcedureStep step = CollectionUtils.FirstElement(rp.ProcedureSteps);
step.Start(TestStaffFactory.CreateStaff(new StaffTypeEnum("STEC", null, null)));
// procedure is in progress
CheckStatus(ProcedureStatus.IP, rp);
Assert.IsNotNull(rp.StartTime);
// order is in progress
CheckStatus(OrderStatus.IP, order);
Assert.IsNotNull(order.StartTime);
}
public void Test_Reassign()
{
Procedure procedure = new Procedure();
Protocol protocol = new Protocol(procedure);
Staff staff1 = new Staff(),
staff2 = new Staff();
ProtocolAssignmentStep ps1 = new ProtocolAssignmentStep(protocol);
ps1.Procedure = procedure;
ps1.Start(staff1);
ProcedureStep ps2 = ps1.Reassign(staff2);
Assert.IsInstanceOf(typeof(ProtocolAssignmentStep), ps2);
Assert.AreNotEqual(ps1, ps2);
Assert.AreEqual(ps1.Protocol, ((ProtocolAssignmentStep)ps2).Protocol);
Assert.IsTrue(procedure.ProcedureSteps.Contains(ps2));
}
public void Test_ScheduleProcedureStep()
{
// create an unscheduled order
Order order = TestOrderFactory.CreateOrder(1, 1, true);
DateTime scheduleTime = DateTime.Now;
Procedure rp = CollectionUtils.FirstElement(order.Procedures);
ProcedureStep step = CollectionUtils.FirstElement(rp.ProcedureSteps);
step.Schedule(scheduleTime);
Assert.AreEqual(scheduleTime, step.Scheduling.StartTime);
// verify order and rp scheduled time are updated to reflect earliest time
Assert.AreEqual(scheduleTime, rp.ScheduledStartTime);
Assert.AreEqual(scheduleTime, order.ScheduledStartTime);
}
public void Test_RescheduleLater()
{
Order order = TestOrderFactory.CreateOrder(2, 2, true, true);
DateTime originalTime = (DateTime)order.ScheduledStartTime;
DateTime newTime = originalTime + TimeSpan.FromDays(1);
Procedure rp = CollectionUtils.FirstElement(order.Procedures);
ProcedureStep step = CollectionUtils.FirstElement(rp.ProcedureSteps);
step.Schedule(newTime);
Assert.AreEqual(newTime, step.Scheduling.StartTime);
// verify order and rp scheduled time still reflect earliest time
Assert.AreEqual(originalTime, rp.ScheduledStartTime);
Assert.AreEqual(originalTime, order.ScheduledStartTime);
}
public ProcedureStepDetail CreateProcedureStepDetail(ProcedureStep ps, IPersistenceContext context)
{
var staffAssembler = new StaffAssembler();
var modalityAssembler = new ModalityAssembler();
return(new ProcedureStepDetail(
ps.GetRef(),
ps.Name,
ps.GetClass().Name,
ps.Is <ModalityProcedureStep>() ? ps.As <ModalityProcedureStep>().Description : null,
EnumUtils.GetEnumValueInfo(ps.State, context),
ps.CreationTime,
ps.Scheduling == null ? null : ps.Scheduling.StartTime,
ps.StartTime,
ps.EndTime,
ps.AssignedStaff == null ? null : staffAssembler.CreateStaffSummary(ps.AssignedStaff, context),
ps.PerformingStaff == null ? null : staffAssembler.CreateStaffSummary(ps.PerformingStaff, context),
ps.Is <ModalityProcedureStep>() ? modalityAssembler.CreateModalitySummary(ps.As <ModalityProcedureStep>().Modality) : null));
}
/// <summary>
/// Gets the value for the specified time field from the specified procedure step or its associated entities.
/// </summary>
/// <param name="step"></param>
/// <param name="timeField"></param>
/// <returns></returns>
protected override DateTime?GetTimeValue(ProcedureStep step, WorklistItemField timeField)
{
var reportingStep = step.As <ReportingProcedureStep>();
if (reportingStep != null)
{
if (timeField == WorklistItemField.ReportPartPreliminaryTime)
{
return(reportingStep.ReportPart.PreliminaryTime);
}
if (timeField == WorklistItemField.ReportPartCompletedTime)
{
return(reportingStep.ReportPart.CompletedTime);
}
}
return(base.GetTimeValue(step, timeField));
}
public void SetJournalItemGuidStep(ProcedureStep procedureStep)
{
//var setJournalItemGuidArguments = procedureStep.SetJournalItemGuidArguments;
//if (JournalItem != null)
//{
// using (var dbService = new DbService())
// {
// var eventUIDString = GetValue<String>(setJournalItemGuidArguments.ValueArgument);
// Guid eventUID;
// if (CheckGuid(eventUIDString))
// {
// eventUID = new Guid(eventUIDString);
// }
// else
// {
// return;
// }
// dbService.JournalTranslator.SaveVideoUID(JournalItem.UID, eventUID, Guid.Empty);
// }
//}
}
public void Test_Reassign()
{
Procedure procedure = new Procedure();
string description = "description.";
Modality modality = new Modality();
ModalityProcedureStep procedureStep = new ModalityProcedureStep(procedure, description, modality);
procedureStep.Suspend();
Staff performer = new Staff();
ProcedureStep newStep = procedureStep.Reassign(performer); // Perform event
// just need to test that it returns a new instance of this class
// everything else has been covered in base class tests
Assert.IsNotNull(newStep);
Assert.AreNotEqual(this, newStep);
Assert.IsInstanceOf(typeof(ModalityProcedureStep), newStep);
Assert.AreEqual(procedure, newStep.Procedure);
Assert.AreEqual(description, ((ModalityProcedureStep)newStep).Description);
Assert.AreEqual(modality, ((ModalityProcedureStep)newStep).Modality);
}
public void Test_CancelOrderFromInProgress()
{
Order order = TestOrderFactory.CreateOrder(2, 2, true);
// put the order in progress
Procedure rp = CollectionUtils.FirstElement(order.Procedures);
ProcedureStep step = CollectionUtils.FirstElement(rp.ProcedureSteps);
step.Start(TestStaffFactory.CreateStaff(new StaffTypeEnum("STEC", null, null)));
try
{
order.Cancel(new OrderCancelInfo(_defaultCancelReason, TestStaffFactory.CreateStaff(new StaffTypeEnum("SCLR", null, null)), "", null));
Assert.Fail("expected exception when trying to cancel non-scheduled order");
}
catch (Exception e)
{
Assert.IsInstanceOfType(typeof(WorkflowException), e);
}
}
public static void BuildTask(Graph graph, Task newTask, string creator, string handler, string currentStep)
{
Edge newEdge;
graph.AddNode(newTask);
User cse = graph.GetNodeByName(creator) as User;
newEdge = new Create();
graph.AddEdge(cse, newTask, newEdge);
newEdge = new CreateBy();
graph.AddEdge(newTask, cse, newEdge);
User inter = graph.GetNodeByName(handler) as User;
newEdge = new Assigned();
graph.AddEdge(inter, newTask, newEdge);
newEdge = new AssignTo();
graph.AddEdge(newTask, inter, newEdge);
ProcedureStep curStep = graph.GetNodeByName(currentStep) as ProcedureStep;
newEdge = new CurrentStep();
graph.AddEdge(newTask, curStep, newEdge);
}
public TextQueryResponse <ReportingWorklistItemSummary> SearchWorklists(WorklistItemTextQueryRequest request)
{
var procedureStepClass = request.ProcedureStepClassName == null ? null
: ProcedureStep.GetSubClass(request.ProcedureStepClassName, PersistenceContext);
// decide which broker/projection to use for searching
var isReporting = typeof(ReportingProcedureStep).IsAssignableFrom(procedureStepClass);
var broker = isReporting ?
(IWorklistItemBroker)PersistenceContext.GetBroker <IReportingWorklistItemBroker>()
: PersistenceContext.GetBroker <IProtocolWorklistItemBroker>();
var projection = isReporting ?
WorklistItemProjection.ReportingWorklistSearch :
WorklistItemProjection.ProtocolWorklistSearch;
var assembler = new ReportingWorkflowAssembler();
return(SearchHelper <ReportingWorklistItem, ReportingWorklistItemSummary>(
request,
broker,
projection,
item => assembler.CreateWorklistItemSummary(item, PersistenceContext)));
}
public void SendEmailStep(ProcedureStep procedureStep)
{
var sendEmailStep = (SendEmailStep)procedureStep;
var smtp = (string)GetValue(sendEmailStep.SmtpArgument);
var port = (int)GetValue(sendEmailStep.PortArgument);
var login = (string)GetValue(sendEmailStep.LoginArgument);
var password = (string)GetValue(sendEmailStep.PasswordArgument);
var eMailAddressFrom = (string)GetValue(sendEmailStep.EMailAddressFromArgument);
var eMailAddressTo = (string)GetValue(sendEmailStep.EMailAddressToArgument);
var title = (string)GetValue(sendEmailStep.EMailTitleArgument);
var content = (string)GetValue(sendEmailStep.EMailContentArgument);
var Smtp = new SmtpClient(smtp, port);
Smtp.Credentials = new NetworkCredential(login, password);
Smtp.EnableSsl = true;
var Message = new MailMessage();
Message.From = new MailAddress(eMailAddressFrom);
Message.To.Add(new MailAddress(eMailAddressTo));
Message.Subject = title;
Message.Body = content;
try
{
Smtp.Send(Message);
}
catch
{
}
}
private void CheckStatus(ActivityStatus status, ProcedureStep o)
{
Assert.AreEqual(status, o.State, string.Format("Exptected {0} status {1}", o.GetClass().Name, status.ToString()));
}
public void RviAlarmStep(ProcedureStep procedureStep)
{
var rviAlarmStep = (RviAlarmStep)procedureStep;
var name = GetStringValue(rviAlarmStep.NameArgument);
if (LicenseManager.CurrentLicenseInfo.HasVideo)
ProcedureExecutionContext.RviAlarm(ClientUID, name);
else
ProcedureExecutionContext.AddJournalItem(ClientUID, "Выполнение функции \"Вызвать тревогу в Rvi Оператор\" заблокировано в связи с отсутствием лицензии");
}
public void CloseDialogStep(ProcedureStep procedureStep)
{
var closeDialogStep = (CloseDialogStep)procedureStep;
var windowID = GetStringValue(closeDialogStep.WindowIDArgument);
var automationCallbackResult = new AutomationCallbackResult()
{
AutomationCallbackType = AutomationCallbackType.CloseDialog,
Data = new CloseDialogCallbackData()
{
WindowID = windowID
}
};
SendCallback(closeDialogStep, automationCallbackResult);
}
public void ControlOpcDaTagSetStep(ProcedureStep procedureStep)
{
var controlOpcDaTagSetStep = (ControlOpcDaTagSetStep)procedureStep;
var value = GetValue(controlOpcDaTagSetStep.ValueArgument);
OpcDaHelper.OnWriteTagValue(controlOpcDaTagSetStep.OpcDaTagUID, value);
}
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);
}
}
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;
}
public void StopRecordStep(ProcedureStep procedureStep)
{
var stopRecordStep = (StopRecordStep)procedureStep;
var cameraRef = (ObjectReference)GetValue(stopRecordStep.CameraArgument);
var eventUid = (Guid)GetValue(stopRecordStep.EventUIDArgument);
if (LicenseManager.CurrentLicenseInfo.HasVideo)
ProcedureExecutionContext.StopRecord(ClientUID, cameraRef.UID, eventUid);
else
ProcedureExecutionContext.AddJournalItem(ClientUID, "Выполнение функции \"Остановить запись\" заблокировано в связи с отсутствием лицензии", cameraRef.UID);
}
public void StartRecordStep(ProcedureStep procedureStep)
{
var startRecordStep = (StartRecordStep)procedureStep;
var cameraRef = (ObjectReference)GetValue(startRecordStep.CameraArgument);
if (LicenseManager.CurrentLicenseInfo.HasVideo)
{
var timeout = (int)GetValue(startRecordStep.TimeoutArgument);
switch (startRecordStep.TimeType)
{
case TimeType.Millisec: timeout = (int)((double)timeout * 0.001); break;
case TimeType.Min: timeout *= 60; break;
case TimeType.Hour: timeout *= 3600; break;
case TimeType.Day: timeout *= 86400; break;
}
if (JournalItem != null)
{
Guid eventUid = Guid.NewGuid();
SetValue(startRecordStep.EventUIDArgument, eventUid);
ProcedureExecutionContext.StartRecord(ClientUID, cameraRef.UID, JournalItem.UID, eventUid, timeout);
}
}
else
ProcedureExecutionContext.AddJournalItem(ClientUID, "Выполнение функции \"Начать запись\" заблокировано в связи с отсутствием лицензии", cameraRef.UID);
}
public void ExportConfigurationStep(ProcedureStep procedureStep)
{
var exportConfigurationStep = (ExportConfigurationStep)procedureStep;
var isExportDevices = (bool)GetValue(exportConfigurationStep.IsExportDevices);
var isExportDoors = (bool)GetValue(exportConfigurationStep.IsExportDoors);
var isExportZones = (bool)GetValue(exportConfigurationStep.IsExportZones);
var path = (string)GetValue(exportConfigurationStep.PathArgument);
ProcedureExecutionContext.ExportConfiguration(ClientUID, isExportDevices, isExportDoors, isExportZones, path);
}
public void ImportOrganisationListStep(ProcedureStep procedureStep)
{
var importOrganisationListStep = (ImportOrganisationListStep)procedureStep;
var isWithDeleted = (bool)GetValue(importOrganisationListStep.IsWithDeleted);
var path = (string)GetValue(importOrganisationListStep.PathArgument);
ProcedureExecutionContext.ImportOrganisationList(ClientUID, isWithDeleted, path);
}
public void ExportOrganisationStep(ProcedureStep procedureStep)
{
var exportOrganisationStep = (ExportOrganisationStep)procedureStep;
var isWithDeleted = (bool)GetValue(exportOrganisationStep.IsWithDeleted);
var organisationRef = (ObjectReference)GetValue(exportOrganisationStep.Organisation);
var path = (string)GetValue(exportOrganisationStep.PathArgument);
ProcedureExecutionContext.ExportOrganisation(ClientUID, isWithDeleted, organisationRef.UID, path);
}
public void ExportJournalStep(ProcedureStep procedureStep)
{
var exportJournalStep = (ExportJournalStep)procedureStep;
var isExportJournal = (bool)GetValue(exportJournalStep.IsExportJournalArgument);
var isExportPassJournal = (bool)GetValue(exportJournalStep.IsExportPassJournalArgument);
var minDate = (DateTime)GetValue(exportJournalStep.MinDateArgument);
var maxDate = (DateTime)GetValue(exportJournalStep.MaxDateArgument);
var path = (string)GetValue(exportJournalStep.PathArgument);
ProcedureExecutionContext.ExportJournal(ClientUID, isExportJournal, isExportPassJournal, minDate, maxDate, path);
}
public void PtzStep(ProcedureStep procedureStep)
{
var ptzStep = (PtzStep)procedureStep;
var cameraRef = (ObjectReference)GetValue(ptzStep.CameraArgument);
var ptzNumber = (int)GetValue(ptzStep.PtzNumberArgument);
if (LicenseManager.CurrentLicenseInfo.HasVideo)
ProcedureExecutionContext.Ptz(ClientUID, cameraRef.UID, ptzNumber);
else
ProcedureExecutionContext.AddJournalItem(ClientUID, "Выполнение функции \"Ptz камеры\" заблокировано в связи с отсутствием лицензии", cameraRef.UID);
}
public void ShowPropertyStep(ProcedureStep procedureStep)
{
var showPropertyStep = (ShowPropertyStep)procedureStep;
var objectRef = (ObjectReference)GetValue(showPropertyStep.ObjectArgument);
if (showPropertyStep.ObjectType == ObjectType.Zone && !LicenseManager.CurrentLicenseInfo.HasFirefighting ||
showPropertyStep.ObjectType == ObjectType.GuardZone && !LicenseManager.CurrentLicenseInfo.HasGuard ||
showPropertyStep.ObjectType == ObjectType.GKDoor && !LicenseManager.CurrentLicenseInfo.HasSKD ||
showPropertyStep.ObjectType == ObjectType.VideoDevice && !LicenseManager.CurrentLicenseInfo.HasVideo)
{
ProcedureExecutionContext.AddJournalItem(ClientUID, "Выполнение функции \"Показать свойства объекта\" заблокировано в связи с отсутствием лицензии", objectRef.UID);
return;
}
var automationCallbackResult = new AutomationCallbackResult()
{
AutomationCallbackType = AutomationCallbackType.Property,
Data = new PropertyCallBackData()
{
ObjectType = showPropertyStep.ObjectType,
ObjectUid = objectRef.UID
},
};
SendCallback(showPropertyStep, automationCallbackResult);
}
Result RunStep(ProcedureStep procedureStep)
{
if (IsTimeOut)
return Result.Normal;
switch (procedureStep.ProcedureStepType)
{
case ProcedureStepType.If:
if (Compare(procedureStep))
{
foreach (var childStep in procedureStep.Children[0].Children)
{
var result = RunStep(childStep);
if (result != Result.Normal)
{
return result;
}
}
}
else
{
foreach (var childStep in procedureStep.Children[1].Children)
{
var result = RunStep(childStep);
if (result != Result.Normal)
{
return result;
}
}
}
break;
case ProcedureStepType.While:
while (Compare(procedureStep))
{
if (IsTimeOut)
return Result.Normal;
foreach (var childStep in procedureStep.Children[0].Children)
{
var result = RunStep(childStep);
if (result == Result.Break)
return Result.Normal;
if (result == Result.Continue)
break;
if (result == Result.Exit)
return Result.Exit;
}
}
break;
case ProcedureStepType.GenerateGuid:
GenerateGuidStep(procedureStep);
break;
case ProcedureStepType.SetJournalItemGuid:
SetJournalItemGuidStep(procedureStep);
break;
case ProcedureStepType.Foreach:
var foreachStep = (ForeachStep)procedureStep;
var listVariable = AllVariables.FirstOrDefault(x => x.Uid == foreachStep.ListArgument.VariableUid);
var itemVariable = AllVariables.FirstOrDefault(x => x.Uid == foreachStep.ItemArgument.VariableUid);
if (listVariable != null && listVariable.IsList)
{
foreach (var listVariableItem in listVariable.ResolvedValue as IList)
{
if (itemVariable != null)
ProcedureExecutionContext.SetVariableValue(itemVariable, listVariableItem, ClientUID);
foreach (var childStep in procedureStep.Children[0].Children)
{
var result = RunStep(childStep);
if (result == Result.Break)
return Result.Normal;
if (result == Result.Continue)
break;
if (result == Result.Exit)
return Result.Exit;
}
}
}
break;
case ProcedureStepType.For:
var forStep = (ForStep)procedureStep;
var indexerVariable = AllVariables.FirstOrDefault(x => x.Uid == forStep.IndexerArgument.VariableUid);
var initialValue = (int)GetValue(forStep.InitialValueArgument);
var value = (int)GetValue(forStep.ValueArgument);
var iterator = (int)GetValue(forStep.IteratorArgument);
if (indexerVariable != null)
{
var condition = Compare(initialValue, value, forStep.ConditionType);
var currentIntValue = indexerVariable.IntValue;
for (indexerVariable.IntValue = initialValue; condition != null && condition.Value; )
{
if (IsTimeOut)
return Result.Normal;
foreach (var childStep in procedureStep.Children[0].Children)
{
var result = RunStep(childStep);
if (result == Result.Break)
{
indexerVariable.IntValue = currentIntValue;
return Result.Normal;
}
if (result == Result.Continue)
break;
if (result == Result.Exit)
return Result.Exit;
}
indexerVariable.IntValue = indexerVariable.IntValue + iterator;
condition = Compare(indexerVariable.IntValue, value, forStep.ConditionType);
}
indexerVariable.IntValue = currentIntValue;
}
break;
case ProcedureStepType.ProcedureSelection:
ProcedureSelectionStep(procedureStep);
break;
case ProcedureStepType.GetObjectProperty:
GetObjectPropertyStep(procedureStep);
break;
case ProcedureStepType.Arithmetics:
ArithmeticStep(procedureStep);
break;
case ProcedureStepType.CreateColor:
CreateColorStep(procedureStep);
break;
case ProcedureStepType.PlaySound:
SoundStep(procedureStep);
break;
case ProcedureStepType.Pause:
PauseStep(procedureStep);
break;
case ProcedureStepType.AddJournalItem:
JournalStep(procedureStep);
break;
case ProcedureStepType.ShowMessage:
ShowMessageStep(procedureStep);
break;
case ProcedureStepType.FindObjects:
FindObjectStep(procedureStep);
break;
case ProcedureStepType.ControlGKDevice:
ControlGKDeviceStep(procedureStep);
break;
case ProcedureStepType.ControlGKFireZone:
ControlGKFireZoneStep(procedureStep);
break;
case ProcedureStepType.ControlGKGuardZone:
ControlGKGuardZoneStep(procedureStep);
break;
case ProcedureStepType.ControlDirection:
ControlDirectionStep(procedureStep);
break;
case ProcedureStepType.ControlGKDoor:
ControlGKDoorStep(procedureStep);
break;
case ProcedureStepType.ControlDelay:
ControlDelayStep(procedureStep);
break;
case ProcedureStepType.ControlPumpStation:
ControlPumpStationStep(procedureStep);
break;
case ProcedureStepType.ControlMPT:
ControlMPTStep(procedureStep);
break;
case ProcedureStepType.IncrementValue:
IncrementValueStep(procedureStep);
break;
case ProcedureStepType.SetValue:
SetValueStep(procedureStep);
break;
case ProcedureStepType.Random:
RandomStep(procedureStep);
break;
case ProcedureStepType.ChangeList:
ChangeListStep(procedureStep);
break;
case ProcedureStepType.CheckPermission:
CheckPermissionStep(procedureStep);
break;
case ProcedureStepType.GetListCount:
GetListCountStep(procedureStep);
break;
case ProcedureStepType.GetListItem:
GetListItemStep(procedureStep);
break;
case ProcedureStepType.GetJournalItem:
GetJournalItemStep(procedureStep);
break;
case ProcedureStepType.ControlVisualGet:
ControlVisualGetStep(procedureStep);
break;
case ProcedureStepType.ControlVisualSet:
ControlVisualSetStep(procedureStep);
break;
case ProcedureStepType.ControlPlanGet:
ControlPlanGetStep(procedureStep);
break;
case ProcedureStepType.ControlPlanSet:
ControlPlanSetStep(procedureStep);
break;
case ProcedureStepType.ControlOpcDaTagGet:
ControlOpcDaTagGetStep(procedureStep);
break;
case ProcedureStepType.ControlOpcDaTagSet:
ControlOpcDaTagSetStep(procedureStep);
break;
case ProcedureStepType.ShowDialog:
ShowDialogStep(procedureStep);
break;
case ProcedureStepType.CloseDialog:
CloseDialogStep(procedureStep);
break;
case ProcedureStepType.ShowProperty:
ShowPropertyStep(procedureStep);
break;
case ProcedureStepType.SendEmail:
SendEmailStep(procedureStep);
break;
case ProcedureStepType.Exit:
return Result.Exit;
case ProcedureStepType.Break:
return Result.Break;
case ProcedureStepType.Continue:
return Result.Continue;
case ProcedureStepType.ExportJournal:
ExportJournalStep(procedureStep);
break;
case ProcedureStepType.ExportOrganisation:
ExportOrganisationStep(procedureStep);
break;
case ProcedureStepType.ImportOrganisation:
ImportOrganisationStep(procedureStep);
break;
case ProcedureStepType.ExportOrganisationList:
ExportOrganisationListStep(procedureStep);
break;
case ProcedureStepType.ImportOrganisationList:
ImportOrganisationListStep(procedureStep);
break;
case ProcedureStepType.ExportConfiguration:
ExportConfigurationStep(procedureStep);
break;
case ProcedureStepType.Ptz:
PtzStep(procedureStep);
break;
case ProcedureStepType.StartRecord:
StartRecordStep(procedureStep);
break;
case ProcedureStepType.StopRecord:
StopRecordStep(procedureStep);
break;
case ProcedureStepType.RviAlarm:
RviAlarmStep(procedureStep);
break;
case ProcedureStepType.RviOpenWindow:
RviOpenWindowStep(procedureStep);
break;
case ProcedureStepType.Now:
NowStep(procedureStep);
break;
case ProcedureStepType.RunProgram:
RunProgramStep(procedureStep);
break;
case ProcedureStepType.HttpRequest:
HttpRequestStep(procedureStep);
break;
}
return Result.Normal;
}
protected override bool IsRelatedStep(ProcedureStep step)
{
return(_relatedSteps.Contains(step));
}
public void HttpRequestStep(ProcedureStep procedureStep)
{
var httpRequestStep = (HttpRequestStep)procedureStep;
var url = (string)GetValue(httpRequestStep.UrlArgument);
var content = (string)GetValue(httpRequestStep.ContentArgument);
var responseVariable = AllVariables.FirstOrDefault(x => x.Uid == httpRequestStep.ResponseArgument.VariableUid);
var webClient = new WebClient();
webClient.Encoding = System.Text.Encoding.UTF8;
var response = "";
switch (httpRequestStep.HttpMethod)
{
case HttpMethod.Get:
response = webClient.DownloadString(url);
break;
case HttpMethod.Post:
response = webClient.UploadString(url, content);
break;
}
SetValue(httpRequestStep.ResponseArgument, response);
}
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;
}
}
private bool InputVarification()
{
const string strExtractPattern = @"[\u4E00-\u9FA5A-Za-z0-9_]+"; //匹配目标"Step:+Handler:"组合
MatchCollection matches;
Regex regObj;
//用户名
if (IsCreateCheckBox.IsChecked == true)
{
strName = NewNameBox.Text;
if (strName == "")
{
InputWarning.PlacementTarget = NewNameBox;
WarningInfo.Text = "Please enter a non-empty value.";
InputWarning.IsOpen = true;
return false;
}
regObj = new Regex(strExtractPattern);//正则表达式初始化，载入匹配模式
matches = regObj.Matches(strName);//正则表达式对分词结果进行匹配
if (matches.Count == 0)
{
InputWarning.PlacementTarget = NewNameBox;
WarningInfo.Text = "Name field only include Chinese, English, Underline characters.";
InputWarning.IsOpen = true;
return false;
}
}
else
{
//绑定步骤检查
int index = 0;
newProceSteps = new List<ProcedureStep>();
ProcedureStep newPStep, previousStep = null;
foreach(StepStore newStep in newSteps)
{
newPStep = new ProcedureStep(newStep.Name, index, newStep.IsFeedback, newStep.Description);
newPStep.HandleRole = mainDataSet.GetGroupItem(newStep.HandleGroup);
newPStep.HandleRole.BindingStep.Add(newPStep);
if (previousStep != null)
{
previousStep.NextStep = newPStep;
newPStep.PreviousStep = previousStep;
}
newProceSteps.Add(newPStep);
previousStep = newPStep;
index++;
}
}
//任务类型
strType = TypeComboBox.Text;
if(strType != null)
{
regObj = new Regex(strExtractPattern);//正则表达式初始化，载入匹配模式
matches = regObj.Matches(strType);//正则表达式对分词结果进行匹配
if (matches.Count == 0)
{
InputWarning.PlacementTarget = TypeComboBox;
WarningInfo.Text = "Type field only include Chinese, English, Underline characters.";
InputWarning.IsOpen = true;
return false;
}
}
//描述
strDescription = DescriptionBox.Text;
if (strDescription == "")
{
InputWarning.PlacementTarget = DescriptionBox;
WarningInfo.Text = "Please enter a non-empty value.";
InputWarning.IsOpen = true;
return false;
}
return true;
}
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);
}
public void ArithmeticStep(ProcedureStep procedureStep)
{
var arithmeticStep = (ArithmeticStep)procedureStep;
object value1;
object value2;
var resultVariable = AllVariables.FirstOrDefault(x => x.Uid == arithmeticStep.ResultArgument.VariableUid);
switch (arithmeticStep.ExplicitType)
{
case ExplicitType.Boolean:
{
value1 = GetValue(arithmeticStep.Argument1);
value2 = GetValue(arithmeticStep.Argument2);
bool result = false;
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.And)
result = (bool)value1 & (bool)value2;
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Or)
result = (bool)value1 || (bool)value2;
if (resultVariable != null)
resultVariable.BoolValue = result;
break;
}
case ExplicitType.Integer:
{
value1 = GetValue(arithmeticStep.Argument1);
value2 = GetValue(arithmeticStep.Argument2);
int result = 0;
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Add)
result = (int)value1 + (int)value2;
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Sub)
result = (int)value1 - (int)value2;
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Multi)
result = (int)value1 * (int)value2;
if ((arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Div) && ((int)value2 != 0))
result = (int)value1 / (int)value2;
if (resultVariable != null)
resultVariable.IntValue = result;
break;
}
case ExplicitType.Float:
{
value1 = GetValue(arithmeticStep.Argument1);
value2 = GetValue(arithmeticStep.Argument2);
double result = 0;
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Add)
result = (double)value1 + (double)value2;
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Sub)
result = (double)value1 - (double)value2;
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Multi)
result = (double)value1 * (double)value2;
if ((arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Div) && ((int)value2 != 0))
result = (double)value1 / (double)value2;
if (resultVariable != null)
resultVariable.FloatValue = result;
break;
}
case ExplicitType.DateTime:
{
value1 = GetValue(arithmeticStep.Argument1);
value2 = new TimeSpan();
switch (arithmeticStep.TimeType)
{
case TimeType.Millisec:
value2 = TimeSpan.FromMilliseconds((int)GetValue(arithmeticStep.Argument2));
break;
case TimeType.Sec:
value2 = TimeSpan.FromSeconds((int)GetValue(arithmeticStep.Argument2));
break;
case TimeType.Min:
value2 = TimeSpan.FromMinutes((int)GetValue(arithmeticStep.Argument2));
break;
case TimeType.Hour:
value2 = TimeSpan.FromHours((int)GetValue(arithmeticStep.Argument2));
break;
case TimeType.Day:
value2 = TimeSpan.FromDays((int)GetValue(arithmeticStep.Argument2));
break;
}
var result = new DateTime();
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Add)
result = (DateTime)value1 + (TimeSpan)value2;
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Sub)
result = (DateTime)value1 - (TimeSpan)value2;
if (resultVariable != null)
resultVariable.DateTimeValue = result;
break;
}
case ExplicitType.String:
{
if (arithmeticStep.ArithmeticOperationType == ArithmeticOperationType.Add)
if (resultVariable != null)
resultVariable.StringValue = String.Concat(GetStringValue(arithmeticStep.Argument1), GetStringValue(arithmeticStep.Argument2));
break;
}
}
ProcedureExecutionContext.SynchronizeVariable(resultVariable, ClientUID);
}
public void ShowDialogStep(ProcedureStep procedureStep)
{
var showDialogStep = (ShowDialogStep)procedureStep;
var windowID = GetStringValue(showDialogStep.WindowIDArgument);
var automationCallbackResult = new AutomationCallbackResult()
{
AutomationCallbackType = AutomationCallbackType.ShowDialog,
Data = new ShowDialogCallbackData()
{
IsModalWindow = showDialogStep.IsModalWindow,
Layout = showDialogStep.Layout,
Title = showDialogStep.Title,
AllowClose = showDialogStep.AllowClose,
AllowMaximize = showDialogStep.AllowMaximize,
Height = showDialogStep.Height,
MinHeight = showDialogStep.MinHeight,
MinWidth = showDialogStep.MinWidth,
Sizable = showDialogStep.Sizable,
TopMost = showDialogStep.TopMost,
Width = showDialogStep.Width,
CustomPosition = showDialogStep.CustomPosition,
Left = showDialogStep.Left,
Top = showDialogStep.Top,
WindowID = windowID
},
};
SendCallback(showDialogStep, automationCallbackResult);
}
public override BaseResource[] TransformSource(DataSet dataset)
{
ProcedureStep procedureStep = new ProcedureStep();
DataRow stepRow = dataset.Tables[0].Rows[0];
Uri idUri = GiveMeUri(GetText(stepRow["TripleStoreId"]));
if (idUri == null)
{
return(null);
}
else
{
procedureStep.Id = idUri;
}
if (Convert.ToBoolean(stepRow["IsDeleted"]))
{
return new BaseResource[] { procedureStep }
}
;
procedureStep.ProcedureStepName = GetText(stepRow["ProcedureStepName"]);
procedureStep.ProcedureStepDescription = GetText(stepRow["ProcedureStepDescription"]);
var scopeNote = GetText(stepRow["ProcedureStepScopeNote"]);
if (!String.IsNullOrEmpty(scopeNote))
{
procedureStep.ProcedureStepScopeNote = new string[] { scopeNote }
}
;
var linkNote = GetText(stepRow["ProcedureStepLinkNote"]);
if (!String.IsNullOrEmpty(linkNote))
{
procedureStep.ProcedureStepLinkNote = new string[] { linkNote }
}
;
var dateNote = GetText(stepRow["ProcedureStepDateNote"]);
if (!String.IsNullOrEmpty(dateNote))
{
procedureStep.ProcedureStepDateNote = new string[] { dateNote }
}
;
Uri PubTripleStoreId = GiveMeUri(GetText(stepRow["PubTripleStoreId"]));
if (PubTripleStoreId != null)
{
var PublicationName = GetText(stepRow["PublicationName"]);
var PublicationUrl = GetText(stepRow["PublicationUrl"]);
procedureStep.ProcedureStepHasProcedureStepPublication = new ProcedureStepPublication[]
{
new ProcedureStepPublication()
{
Id = PubTripleStoreId
}
};
if (!string.IsNullOrWhiteSpace(PublicationName))
{
procedureStep.ProcedureStepHasProcedureStepPublication.First().ProcedureStepPublicationName
= new string[] { PublicationName };
}
if (!string.IsNullOrWhiteSpace(PublicationUrl))
{
procedureStep.ProcedureStepHasProcedureStepPublication.First().ProcedureStepPublicationUrl
= new string[] { PublicationUrl };
}
}
Uri linkedIdUri = GiveMeUri(GetText(stepRow["LinkedTripleStoreId"]));
if (linkedIdUri != null)
{
procedureStep.ProcedureStepIsCommonlyActualisedAlongsideProcedureStep = new ProcedureStep[] { new ProcedureStep()
{
Id = linkedIdUri
} }
}
;
List <House> houses = new List <House>();
if ((dataset.Tables.Count == 2) && (dataset.Tables[1].Rows != null))
{
foreach (DataRow row in dataset.Tables[1].Rows)
{
Uri houseUri = GiveMeUri(GetText(row["House"]));
if (houseUri == null)
{
continue;
}
else
{
houses.Add(new House()
{
Id = houseUri
});
}
}
}
procedureStep.ProcedureStepHasHouse = houses;
return(new BaseResource[] { procedureStep });
}
public override BaseResource[] TransformSource(DataSet dataset)
{
ProcedureRoute procedureRoute = new ProcedureRoute();
DataRow row = dataset.Tables[0].Rows[0];
Uri idUri = GiveMeUri(GetText(row["TripleStoreId"]));
if (idUri == null)
{
return(null);
}
else
{
procedureRoute.Id = idUri;
}
if (Convert.ToBoolean(row["IsDeleted"]))
{
return new BaseResource[] { procedureRoute }
}
;
string routeType = GetText(row["ProcedureRouteTypeName"]);
if (string.IsNullOrWhiteSpace(routeType))
{
return(null);
}
if (Enum.TryParse <ProcedureRouteType>(routeType, out ProcedureRouteType procedureRouteKind) == false)
{
logger.Warning($"Invalid route type '{routeType}' found");
return(null);
}
procedureRoute.ProcedureRouteHasProcedure = giveMeUris(dataset.Tables[1], "TripleStoreId")
.Select(u => new Procedure()
{
Id = u
})
.ToArray();
Uri fromStepUri = GiveMeUri(GetText(row["FromStep"]));
if (fromStepUri != null)
{
ProcedureStep fromProcedureStep = new ProcedureStep();
fromProcedureStep.Id = fromStepUri;
switch (procedureRouteKind)
{
case ProcedureRouteType.Allows:
fromProcedureStep.ProcedureStepAllowsAllowedProcedureRoute = new List <AllowedProcedureRoute>()
{
new AllowedProcedureRoute()
{
Id = procedureRoute.Id
}
};
break;
case ProcedureRouteType.Causes:
fromProcedureStep.ProcedureStepCausesCausedProcedureRoute = new List <CausedProcedureRoute>()
{
new CausedProcedureRoute()
{
Id = procedureRoute.Id
}
};
break;
case ProcedureRouteType.Precludes:
fromProcedureStep.ProcedureStepPrecludesPrecludedProcedureRoute = new List <PrecludedProcedureRoute>()
{
new PrecludedProcedureRoute()
{
Id = procedureRoute.Id
}
};
break;
case ProcedureRouteType.Requires:
fromProcedureStep.ProcedureStepRequiresRequiredProcedureRoute = new List <RequiredProcedureRoute>()
{
new RequiredProcedureRoute()
{
Id = procedureRoute.Id
}
};
break;
}
procedureRoute.ProcedureRouteIsFromProcedureStep = new List <ProcedureStep>()
{
fromProcedureStep
};
}
else
{
return(null);
}
Uri toStepUri = GiveMeUri(GetText(row["ToStep"]));
if (toStepUri != null)
{
procedureRoute.ProcedureRouteIsToProcedureStep = new List <ProcedureStep>()
{
new ProcedureStep()
{
Id = toStepUri
}
}
}
;
else
{
return(null);
}
return(new BaseResource[] { procedureRoute });
}
protected override bool IsRelatedStep(ProcedureStep step)
{
// this is by definition related to this!
return Equals(this, step) || _relatedSteps.Contains(step);
}
public void NowStep(ProcedureStep procedureStep)
{
var nowStep = (NowStep)procedureStep;
SetValue(nowStep.ResultArgument, DateTime.Now);
}
public void RviOpenWindowStep(ProcedureStep procedureStep)
{
var rviOpenWindowStep = (RviOpenWindowStep)procedureStep;
var name = GetStringValue(rviOpenWindowStep.NameArgument);
var x = (int)GetValue(rviOpenWindowStep.XArgument);
var y = (int)GetValue(rviOpenWindowStep.YArgument);
var monitorNumber = (int)GetValue(rviOpenWindowStep.MonitorNumberArgument);
var login = (string)GetValue(rviOpenWindowStep.LoginArgument);
var ip = (string)GetValue(rviOpenWindowStep.IpArgument);
if (LicenseManager.CurrentLicenseInfo.HasVideo)
ProcedureExecutionContext.RviOpenWindow(ClientUID, name, x, y, monitorNumber, login, ip);
else
ProcedureExecutionContext.AddJournalItem(ClientUID, "Выполнение функции \"Показать раскладку в Rvi Оператор\" заблокировано в связи с отсуствием лицензии");
}
public void RunProgramStep(ProcedureStep procedureStep)
{
var runProgramStep = (RunProgramStep)procedureStep;
var processName = (string)GetValue(runProgramStep.PathArgument);
var parameters = (string)GetValue(runProgramStep.ParametersArgument);
System.Diagnostics.Process.Start(processName, parameters);
}
protected override bool IsRelatedStep(ProcedureStep step)
{
// this is by definition related to this!
return(Equals(this, step) || _relatedSteps.Contains(step));
}