public async Task <int> Handle(CreateTestExecutionCommand request, CancellationToken cancellationToken)
        {
            var ste = await _context.StageTests.Where(st => st.TestId == request.TestId && st.StageId == request.StageId).FirstOrDefaultAsync();


            //Map request to entity
            var entity = new TestExecution
            {
                //TestId = request.TestId,
                //StageId = request.StageId,
            };


            if (ste != null)
            {
                ste.TestExecutions = new List <TestExecution>()
                {
                    entity
                };
            }
            else
            {
                var test = await _context.Tests.FindAsync(request.TestId);

                if (test == null)
                {
                    throw new NotFoundException(nameof(test), request.TestId);
                }

                var stage = await _context.Stages.FindAsync(request.StageId);

                if (stage == null)
                {
                    throw new NotFoundException(nameof(stage), request.StageId);
                }

                var stageTestEntity = new StageTest
                {
                    TestId         = request.TestId,
                    StageId        = request.StageId,
                    TestExecutions = new List <TestExecution>()
                    {
                        entity
                    }
                };

                _context.StageTests.Add(stageTestEntity);
            }

            //_context.TestExecutions.Add(entity);
            //_context.StageTests.Add(stageTestEntity);


            await _context.SaveChangesAsync(cancellationToken);

            return(entity.Id);
        }
Beispiel #2
0
        public async Task <int> Handle(CreateTestCommand request, CancellationToken cancellationToken)
        {
            var stage = await _context.Stages.FindAsync(request.StageId);

            if (stage == null)
            {
                throw new NotFoundException(nameof(Stage), request.StageId);
            }

            var newEntity = new StageTest
            {
                Stage = stage
            };

            var jiraNumber = StringCleaner.CleanInput(request.JiraTestNumber).Trim();

            if (string.IsNullOrEmpty(jiraNumber))
            {
                throw new NotFoundException("User input is bad.", request.JiraTestNumber);
            }

            var existingTest = await _context.Tests.Include(t => t.StageTests).Where(x => x.JiraTestNumber == jiraNumber).FirstOrDefaultAsync();

            if (existingTest != null)
            {
                if (existingTest.StageTests.Where(x => x.StageId == request.StageId).FirstOrDefault() != null)
                {
                    // Test already exists for the requested stage
                    return(-1);
                }

                // Add the existing test to the requested stage
                newEntity.Test = existingTest;
            }
            else
            {
                // Test doesnt exist so add it to the DB
                newEntity.Test = new Test {
                    JiraTestNumber = jiraNumber
                };
            }

            _context.StageTests.Add(newEntity);
            await _context.SaveChangesAsync(cancellationToken);

            return(newEntity.TestId);
        }