示例#1
0
        public CloseTicketResponse Close(CloseTicketRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            using (var trans = transactionFactory.GetTransaction())
            {
                var ticket = repo.Get(request.Identity);
                if (ReferenceEquals(ticket, null))
                {
                    return new CloseTicketResponse {
                               TicketNotFound = true
                    }
                }
                ;

                if (ticket.Closed)
                {
                    return new CloseTicketResponse {
                               TicketAlreadyClosed = true
                    }
                }
                ;

                ticket.Closed = true;
                repo.Update(ticket);
                trans.Commit();
            }

            return(new CloseTicketResponse());
        }
示例#2
0
        public EditTicketResponse Edit(EditTicketRequest request)
        {
            logger.Debug("About to validate an edit-ticket request");
            var validationResult = ValidateRequest(request);

            logger.Debug(validationResult);

            if (!validationResult.IsSuccess)
            {
                return(responseCreator.GetResponse(validationResult, null));
            }

            using (var trans = transactionFactory.GetTransaction())
            {
                if (logger.IsDebugEnabled)
                {
                    logger.Debug($"Transaction used is a {trans.GetType().FullName}");
                }

                var ticket = ticketRepo.Get(request.Identity);

                editor.Edit(ticket, request);
                ticketRepo.Update(ticket);
                trans.Commit();

                return(responseCreator.GetResponse(validationResult, ticket));
            }
        }
示例#3
0
        public AddWorklogResponse AddWorkLog(AddWorkLogRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            using (var transaction = transactionFactory.GetTransaction())
            {
                var getWorklogResponse = workLogProvider.GetWorkLog(request);
                if (getWorklogResponse?.Success != true)
                {
                    transaction.Rollback();
                    return(GetFailureResponse(getWorklogResponse));
                }

                getWorklogResponse.Ticket.WorkLogs.Add(getWorklogResponse.WorkLog);
                transaction.Commit();

                return(new AddWorklogResponse {
                    Success = true,
                    TicketId = getWorklogResponse.Ticket.GetIdentity(),
                });
            }
        }
示例#4
0
        public IHttpActionResult Post(CreateUserModel model)
        {
            if (model == null)
            {
                throw new ArgumentNullException(nameof(model));
            }

            bool exists;

            using (var tran = transactionCreator.GetTransaction())
            {
                var existingUser = userQuery.Get(model.username);

                if (existingUser == null)
                {
                    userCreator.Add(model.username, model.password);
                    exists = false;
                }
                else
                {
                    passwordChanger.ChangePassword(existingUser, model.password);
                    exists = true;
                }

                tran.Commit();
            }

            return(Ok(exists? $"The existing user '{model.username}' was updated" : $"The user '{model.username}' was created"));
        }
示例#5
0
        public CreateSprintResponse Create(CreateSprintRequest request)
        {
            var validationResult = ValidateRequest(request);
            var response         = responseFactory.GetResponse(validationResult);

            if (!validationResult.IsSuccess)
            {
                return(response);
            }

            Sprint sprint;

            using (var trans = transactionFactory.GetTransaction())
            {
                var project = projectGetter.GetCurrentProject();
                if (project == null)
                {
                    response.ProjectDoesNotExist = true;
                    return(response);
                }

                sprint = CreateSprint(request, project);
                sprintRepo.Add(sprint);
                trans.Commit();

                response.Sprint = sprint;
            }

            return(response);
        }
示例#6
0
        public CreateCommentResponse Create(CreateCommentRequest request)
        {
            var validator        = validatorFactory.GetValidator();
            var validationResult = validator.Validate(request);

            if (!validationResult.IsSuccess)
            {
                return(responseCreator(validationResult, null));
            }

            Comment comment;

            using (var tran = transactionCreator.GetTransaction())
            {
                var ticket = ticketRepo.Get(request.TicketId);
                comment = commentFactory.Create(request.Body);
                ticket.Comments.Add(comment);

                ticketRepo.Update(ticket);
                commentRepo.Add(comment);

                tran.Commit();
            }

            return(responseCreator(validationResult, comment));
        }
 public CreateProjectResponse CreateNewProject(CreateProjectRequest request)
 {
     using (var tran = transactionCreator.GetTransaction())
     {
         var output = wrapped.CreateNewProject(request);
         tran.Commit();
         return(output);
     }
 }
    public void Create()
    {
      using(var tran = transactionCreator.GetTransaction())
      {
        CreateInitialUser();
        CreateInitialProject();

        tran.Commit();
      }
    }
 public Ticket CreateTicket(CreateTicketRequest request)
 {
     using (var trans = transactionFactory.GetTransaction())
     {
         var ticket = wrappedInstance.CreateTicket(request);
         data.Add(ticket);
         trans.Commit();
         logger.InfoFormat("Created ticket {0}: {1}", ticket.GetTicketReference().ToString(true), ticket.Title);
         return(ticket);
     }
 }
示例#10
0
        public PasswordChangeResponse ChangeOwnPassword(PasswordChangeRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            using (var tran = transactionCreator.GetTransaction())
            {
                var user = userReader.RequireCurrentUser();
                if (!IsExistingPasswordCorrect(request.ExistingPassword, user))
                {
                    return new PasswordChangeResponse {
                               ExistingPasswordIncorrect = true
                    }
                }
                ;

                if (request.ConfirmNewPassword != request.NewPassword)
                {
                    return new PasswordChangeResponse {
                               NewPasswordDoesNotMatchConfirmation = true
                    }
                }
                ;

                if (!policy.IsPasswordOk(request.NewPassword, user))
                {
                    return new PasswordChangeResponse {
                               NewPasswordDoesNotSatisfyPolicy = true
                    }
                }
                ;

                updater.ChangePassword(user, request.NewPassword);
                tran.Commit();
            }

            return(new PasswordChangeResponse());
        }

        bool IsExistingPasswordCorrect(string password, User user)
        {
            var credentials = new LoginCredentials
            {
                Password = password,
                Username = user.Username,
            };

            return(authService.Authenticate(credentials).Success);
        }
示例#11
0
        public DeleteCommentResponse Delete(DeleteCommentRequest request)
        {
            var validator        = validatorFactory.GetValidator();
            var validationResult = validator.Validate(request);

            if (!validationResult.IsSuccess)
            {
                return(responseCreator(validationResult));
            }

            using (var tran = transactionCreator.GetTransaction())
            {
                var comment = data.Get(request.CommentId);
                comment.Ticket.Comments.Remove(comment);
                tran.Commit();
            }

            return(responseCreator(validationResult));
        }
示例#12
0
        public EditSprintResponse Edit(EditSprintRequest request)
        {
            var validationResult = ValidateRequest(request);

            if (!validationResult.IsSuccess)
            {
                return(responseCreator(validationResult, null));
            }

            Sprint sprint;

            using (var trans = transactionFactory.GetTransaction())
            {
                sprint = sprintRepo.Get(request.SprintIdentity);
                mapper.Map(request, sprint);
                sprintRepo.Update(sprint);
                trans.Commit();
            }

            return(responseCreator(validationResult, sprint));
        }
示例#13
0
        public EditCommentResponse Edit(EditCommentRequest request)
        {
            var validator        = validatorFactory.GetValidator();
            var validationResult = validator.Validate(request);

            if (!validationResult.IsSuccess)
            {
                return(responseCreator(validationResult));
            }

            using (var tran = transactionCreator.GetTransaction())
            {
                var comment = commentRepo.Get(request.CommentIdentity);
                comment.Body = request.Body;
                comment.LastEditTimestamp = environment.GetCurrentUtcTimestamp();
                commentRepo.Update(comment);
                tran.Commit();
            }

            return(responseCreator(validationResult));
        }
示例#14
0
        public void Load()
        {
            using (var tran = transactionCreator.GetTransaction())
            {
                var project = repo.Query <Project>().First();
                var admin   = userQuery.Get(AdminUser.Username);
                admin.SiteAdministrator = true;

                var youssef = CreateYoussef();
                project.Administrators.Add(youssef);

                var sprint1 = CreateSprintOne(project);
                var sprint2 = CreateSprintTwo(project);
                var sprint3 = CreateSprintThree(project);

                var bug         = CreateBugType();
                var enhancement = CreateEnhancementType();

                var ticket1 = CreateTicketOne(sprint1, youssef, enhancement);
                var ticket2 = CreateTicketTwo(sprint1, youssef, enhancement);
                var ticket3 = CreateTicketThree(sprint1, youssef, enhancement);
                var ticket4 = CreateClosedTicketFour(sprint1, youssef, bug);
                var ticket5 = CreateTicketFive(sprint2, youssef, bug);
                var ticket6 = CreateTicketSix(sprint2, youssef, bug);

                project.NextAvailableTicketNumber = 7;

                var comment1 = CreateCommentOne(ticket1, youssef);
                var comment2 = CreateCommentTwo(ticket2, admin);
                var comment3 = CreateCommentThree(ticket2, admin);
                var comment4 = CreateCommentFour(ticket2, admin);

                CreateExistingLabelOne(ticket2, ticket3, ticket4);
                CreateExistingLabelTwo(ticket6);

                tran.Commit();
            }
        }