Ejemplo n.º 1
0
 public FibonacciWorkflowData(int numberOfSteps)
 {
     this.numberOfSteps         = numberOfSteps;
     stepTemplate               = FibonacciSampleData.StepTemplate;
     workflowTemplate           = FibonacciDataGenerator.GetWorkflowTemplate(numberOfSteps);
     workflowTemplateWithInputs = FibonacciDataGenerator.GetWorkflowTemplateWithInputs(numberOfSteps);
 }
Ejemplo n.º 2
0
        protected StronglyTypedTemplateWrapper(StepTemplate <WMColumnTemplate> template)
        {
            if (null == template)
            {
                throw new ArgumentNullException(nameof(template));
            }

            var controlTemplates = new List <ControlTemplate>();

            foreach (var tunableShapeColumn in template.TunableShape.Columns)
            {
                foreach (var controlTemplate in tunableShapeColumn.Controls)
                {
                    controlTemplates.AddRange(SelectControlTemplates(controlTemplate));
                }
            }

            var controlTemplateDictionary = new Dictionary <string, ControlTemplate>();

            foreach (var controlTemplate in controlTemplates)
            {
                if (null == controlTemplate.Name)
                {
                    continue;
                }

                controlTemplateDictionary.Add(controlTemplate.Name, controlTemplate);
            }

            _controlTemplates          = controlTemplates;
            _controlTemplateDictionary = controlTemplateDictionary;
        }
Ejemplo n.º 3
0
 public NewStepTemplateRequest(StepTemplate template)
 {
     Name               = template.Name;
     Version            = template.Version;
     AllowDynamicInputs = template.AllowDynamicInputs;
     InputDefinitions   = template.InputDefinitions;
     OutputDefinitions  = template.OutputDefinitions;
 }
Ejemplo n.º 4
0
        public void QueueTemplateForRegistration(StepTemplate stepTemplate)
        {
            var foundTemplateCount = RegisteredTemplates.Where(rt => rt.ReferenceId == stepTemplate.ReferenceId).Count();

            if (foundTemplateCount == 0)
            {
                RegisteredTemplates.Add(stepTemplate);
            }
            else if (foundTemplateCount == 1)
            {
                throw new StepTemplateDuplicateFoundException();
            }
            else
            {
                throw new StepTemplateNotFoundException();
            }
        }
Ejemplo n.º 5
0
        private async Task <bool> RegisterTemplateAsync(StepTemplate stepTemplate)
        {
            var result = await _client.PostStepTemplate(new NewStepTemplateRequest()
            {
                Name               = stepTemplate.Name,
                Version            = stepTemplate.Version,
                AllowDynamicInputs = stepTemplate.AllowDynamicInputs,
                InputDefinitions   = stepTemplate.InputDefinitions,
                OutputDefinitions  = stepTemplate.OutputDefinitions
            }, idToken);

            if (result != null)
            {
                Logger.LogInformation("Successfully registered template " + stepTemplate.ReferenceId);
                return(true);
            }
            else
            {
                throw new Exception("Error adding template for template " + stepTemplate.ReferenceId);
            }
        }
Ejemplo n.º 6
0
 public static bool DoesStepMatchesTemplate(Step step, StepTemplate stepTemplate)
 {
     return(step.StepTemplateId == stepTemplate.ReferenceId);
 }
Ejemplo n.º 7
0
        public async Task <CommandResult> Handle(CreateStepTemplateCommand request, CancellationToken cancellationToken)
        {
            var stopwatch = new Stopwatch();

            stopwatch.Start();

            if (request.ReferenceId != null)
            {
                request.Name    = request.ReferenceId.Split(':')[0];
                request.Version = request.ReferenceId.Split(':')[1];
            }


            var newId           = Guid.NewGuid();
            var newStepTemplate = new StepTemplate(
                newId,
                request.ReferenceId == null ? request.Name + ":" + request.Version : request.ReferenceId,
                request.Description,
                request.AllowDynamicInputs,
                request.InputDefinitions.ToDictionary(entry => entry.Key.ToLower(),
                                                      entry => entry.Value),
                request.OutputDefinitions.ToDictionary(entry => entry.Key.ToLower(),
                                                       entry => entry.Value),
                request.CreatedBy,
                DateTime.UtcNow
                );

            var existingStepTemplate = await _entitiesRepository.GetFirstOrDefaultAsync <StepTemplate>(st => st.ReferenceId == newStepTemplate.ReferenceId);

            if (existingStepTemplate == null)
            {
                if (request.Name.First() == '_' && request.CreatedBy != SystemUsers.SYSTEM_TEMPLATES_MANAGER)
                {
                    throw new InvalidStepTemplateException("Only system workflows can start with _");
                }

                var createdWorkflowTemplateId = await _node.Handle(new AddShardWriteOperation()
                {
                    Data             = newStepTemplate,
                    WaitForSafeWrite = true,
                    Operation        = ConsensusCore.Domain.Enums.ShardOperationOptions.Create
                });
            }
            else
            {
                Logger.LogDebug("Found existing step template");

                BaseException exception;
                if (!existingStepTemplate.IsEqual(newStepTemplate, out exception))
                {
                    throw exception;
                }
            }

            stopwatch.Stop();
            return(new CommandResult()
            {
                ObjectRefId = newStepTemplate.ReferenceId,
                ElapsedMs = stopwatch.ElapsedMilliseconds,
                Type = CommandResultTypes.Create
            });
        }