예제 #1
0
        public async Task <bool> Handle(UpdateProcessFileCommand request, CancellationToken cancellationToken)
        {
            var processFile = await _eventStoreRepository.GetLastAggregate <ProcessFileAggregate>(request.Id, ProcessFileAggregate.GetStreamName(request.Id));

            if (processFile == null || string.IsNullOrWhiteSpace(processFile.AggregateId))
            {
                _logger.LogError($"Cannot update process file because it doesn't exist : '{request.Id}'");
                throw new UnknownProcessFileException(request.Id);
            }

            processFile.Update(request.Name, request.Description);
            await _commitAggregateHelper.Commit(processFile, ProcessFileAggregate.GetStreamName(request.Id), cancellationToken);

            return(true);
        }
예제 #2
0
        public async Task <CreateProcessFileResult> Handle(CreateProcessFileCommand request, CancellationToken cancellationToken)
        {
            var payload = request.Payload;

            if (string.IsNullOrWhiteSpace(request.Payload))
            {
                payload = _options.DefaultBPMNFile;
            }

            var processFile = ProcessFileAggregate.New(Guid.NewGuid().ToString(), request.Name, request.Description, 0, payload);
            var streamName  = ProcessFileAggregate.GetStreamName(processFile.AggregateId);
            await _commitAggregateHelper.Commit(processFile, streamName, cancellationToken);

            _logger.LogInformation("Process file has been added");
            return(new CreateProcessFileResult
            {
                Id = processFile.AggregateId
            });
        }
예제 #3
0
        public async Task <PublishProcessFileResult> Handle(PublishProcessFileCommand request, CancellationToken cancellationToken)
        {
            var processFile = await _eventStoreRepository.GetLastAggregate <ProcessFileAggregate>(request.Id, ProcessFileAggregate.GetStreamName(request.Id));

            if (request == null || string.IsNullOrWhiteSpace(processFile.AggregateId))
            {
                throw new UnknownProcessFileException(request.Id);
            }

            var newProcessFile = processFile.Publish();
            await _commitAggregateHelper.Commit(processFile, ProcessFileAggregate.GetStreamName(processFile.AggregateId), cancellationToken);

            await _commitAggregateHelper.Commit(newProcessFile, ProcessFileAggregate.GetStreamName(newProcessFile.AggregateId), cancellationToken);

            return(new PublishProcessFileResult
            {
                Id = newProcessFile.AggregateId
            });
        }
        public async Task <SearchResult <ProcessInstanceResult> > Handle(CreateProcessInstanceCommand request, CancellationToken cancellationToken)
        {
            var processFile = await _eventStoreRepository.GetLastAggregate <ProcessFileAggregate>(request.ProcessFileId, ProcessFileAggregate.GetStreamName(request.ProcessFileId));

            if (processFile == null || string.IsNullOrWhiteSpace(processFile.AggregateId))
            {
                _logger.LogError($"the process file '{request.ProcessFileId}' doesn't exist");
                throw new UnknownProcessFileException(string.Format(Global.UnknownProcessFile, request.ProcessFileId));
            }

            var processInstances = BPMNParser.BuildInstances(processFile.Payload, request.ProcessFileId);
            var result           = new List <ProcessInstanceResult>();

            foreach (var processInstance in processInstances)
            {
                var pi = ProcessInstanceAggregate.New(request.ProcessFileId,
                                                      processFile.Name,
                                                      processInstance.ElementDefs.ToList(),
                                                      processInstance.Interfaces.ToList(),
                                                      processInstance.Messages.ToList(),
                                                      processInstance.ItemDefs.ToList(),
                                                      processInstance.SequenceFlows.ToList());
                await _commitAggregateHelper.Commit(pi, pi.GetStreamName(), cancellationToken);

                result.Add(ProcessInstanceResult.ToDto(pi));
            }

            return(new SearchResult <ProcessInstanceResult>
            {
                Content = result
            });
        }