Exemple #1
0
        public ActionResult Create(IssueServiceClientDTO clientDto)
        {
            //
            // So clientes podem criar issues
            if (!User.IsInRole(LoginService.Client))
                return new RedirectResult("/");

            // Verificar erros no modelo
            if (!ModelState.IsValid)
                return RedirectToAction("Create");

            // Obter serviço cliente de factory
            IIssueClientService clientService = ObjectsManager.GetInstance<IIssueClientService>();

            try {
                clientService.Add(clientDto);
            }
            catch(ProjectDisabledException ex){
                ModelState.AddModelError(string.Empty, "This project is currently disabled. You cannot add a new issue");
                return RedirectToAction("Create");
            }

            // Sucesso
            ViewBag.Who = "New Issue";
            return View("CUD", ActionEnum.Created);
        }
        public void Add(IssueServiceClientDTO issueClientDto)
        {
            if (issueClientDto == null)
                throw new ArgumentNullException("issueClientDto");

            //
            // O cliente so pode inserir um issue se, o projecto a que pertence o issue
            // pertence ao cliente.

            // Verificar se sou cliente
            Client dbClient = GetDbClient();

            // Obter o projecto a partir do Dto data e ver se o cliente sou eu..
            Project dbProject = _db.Query<Project>().GetByIdIncludeClient(issueClientDto.ProjectId);

            if (dbProject == null || dbProject.Client.UserID != dbClient.UserID) {
                throw new HijackedException("ProjectID hijacked");
            }

            if(dbProject != null && !dbProject.Enabled)
                throw new ProjectDisabledException("Project disabled");

            // Se estou aqui então eu sou o owner do projecto
            _db.Insert(issueClientDto.CopyToDomainObject(dbProject, dbClient));

            //
            // Executar o serviço de enviar emails para os membros do projecto deste issue.
            NotificatorClientDTO clientDto = new NotificatorClientDTO(
                dbClient.Name,
                dbProject.ProjectID,
                dbProject.Name,

                issueClientDto.Priority,
                issueClientDto.Type,
                issueClientDto.ShortDescription,
                issueClientDto.LongDescription
            );

            // Notificar
            _notificator.NotifyMembers(clientDto);
        }
        public bool Update(IssueServiceClientDTO issueClientDto)
        {
            if (issueClientDto == null)
                throw new ArgumentNullException("issueClientDto");

            //
            // O cliente so pode actualizar um issue se, foi ele a inserir esse issue
            // e so pode actualizar se o estado nao for terminated

            // Verificar se sou cliente
            Client dbClient = GetDbClient();

            // Obter o issue a partir do Dto data (ignorando o projectId) e vou verificar
            // se eu sou quem inseriou o issue porque só eu posso editar o issue.
            Issue dbIssue = _db.Query<Issue>().GetByIdIncludeAll(issueClientDto.IssueId);
            if (dbClient.UserID != dbIssue.Client.UserID)
                throw new HijackedException("This issue doesnt belongs to you");

            if (dbIssue.Project != null && !dbIssue.Project.Enabled)
                throw new ProjectDisabledException("Project disabled");

            //
            // Seguro realizar acções
            if (dbIssue.State == (int)StateEnum.Terminated)
                return false;

            // A partir daqui é seguro realizar acções
            dbIssue.UpdateDomainObjectFromDTO(issueClientDto);
            return true;
        }
Exemple #4
0
        public ActionResult Edit(int id, FormCollection collection)
        {
            //
            // Não posso usar modelbinder devido a só depois de saber a role à
            // qual estou associado posso construir o objecto DTO

            if (User.IsInRole(LoginService.Admin))
            {
                //
                // Criar objecto membro dto com os dados do Form
                IssueServiceMemberDTO memberDto = new IssueServiceMemberDTO();
                UpdateModel(memberDto);
                memberDto.IssueId = id;

                // Obter e invocar changeState no serviço
                IIssueAdminService adminService = ObjectsManager.GetInstance<IIssueAdminService>();

                // Verificar erros de negocio
                if (!adminService.ChangeState(memberDto))
                {
                    // Se estamos aqui então o estado do issue está terminado e nao pode ser alterado
                    ModelState.AddModelError(string.Empty, "This issue is already terminated");
                    return RedirectToAction("Edit", new { id });
                }
            }

            if (User.IsInRole(LoginService.Member))
            {
                //
                // Criar objecto dto com os dados do Form
                IssueServiceMemberDTO memberDto = new IssueServiceMemberDTO();
                UpdateModel(memberDto);
                memberDto.IssueId = id;

                // Obter e invocar changeState no serviço
                IIssueMemberService memberService = ObjectsManager.GetInstance<IIssueMemberService>();

                // Verificar erros de negocio
                try {
                    if(!memberService.ChangeState(memberDto)){
                        // Se estamos aqui então o estado do issue está terminado e nao pode ser alterado
                        ModelState.AddModelError(string.Empty, "This issue is already terminated");
                        return RedirectToAction("Edit", new { id });
                    }
                }
                catch (IssueWasAlreadyTakedByAnotherMember ex) {
                    // Se estamos aqui então o issue ja foi aceite por outro membro
                    ModelState.AddModelError(string.Empty, string.Format("This issue is in resolution by {0}", ex.Message));
                    return RedirectToAction("Edit", new { id });
                }
            }

            if (User.IsInRole(LoginService.Client)) {
                //
                // Criar objecto dto com os dados do Form
                IssueServiceClientDTO clientDto = new IssueServiceClientDTO();
                if (!TryUpdateModel(clientDto)){

                    // Verificar erros no modelo
                    return RedirectToAction("Edit", new { id });
                }

                clientDto.IssueId = id;

                // Obter e invocar update no serviço
                IIssueClientService clientService = ObjectsManager.GetInstance<IIssueClientService>();

                try {
                    // Verificar erros de negocio
                    if (!clientService.Update(clientDto)) {
                        // Se estamos aqui então o estado do issue está terminado e nao pode ser alterado
                        ModelState.AddModelError(string.Empty, "This issue is already terminated");
                        return RedirectToAction("Edit", new { id });
                    }
                }
                catch (ProjectDisabledException ex) {
                    ModelState.AddModelError(string.Empty, "This project is currently disabled. You cannot update the issue");
                    return RedirectToAction("Edit", new { id });
                }
            }

            // Sucesso
            ViewBag.Who = "Existing Issue";
            return View("CUD", ActionEnum.Edited);
        }