Exemple #1
0
        public Task <int> Handle(RegisterNewObjetoApreendidoCommand request, CancellationToken cancellationToken)
        {
            if (!request.IsValid())
            {
                NotifyValidationErrors(request);
                return(Task.FromResult(0));
            }

            var procedimento = _procedimentoRepository.GetById(request.ProcedimentoId);

            if (procedimento == null)
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "O Procedimento não foi encontrado."));
                return(Task.FromResult(0));
            }

            var objetoApreendido = new ObjetoApreendido(request.Descricao, request.Local, procedimento);

            if (_objetoApreendidoRepository.Exists(objetoApreendido.Descricao, request.ProcedimentoId))
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "O Objeto já está sendo usado."));
                return(Task.FromResult(0));
            }

            _objetoApreendidoRepository.Add(objetoApreendido);

            if (Commit())
            {
                //TO DO
            }

            return(Task.FromResult(objetoApreendido.Id));
        }
        public Task <int> Handle(RegisterNewMovimentacaoCommand request, CancellationToken cancellationToken)
        {
            if (!request.IsValid())
            {
                NotifyValidationErrors(request);
                return(Task.FromResult(0));
            }

            var procedimento = _procedimentoRepository.GetById(request.ProcedimentoId);

            if (procedimento == null)
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "O procedimento não foi encontrado."));
                return(Task.FromResult(0));
            }

            if (_movimentacaoRepository.Exists(request.Destino, request.ProcedimentoId))
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "A Movimentação já está sendo usada."));
                return(Task.FromResult(0));
            }

            var movimentacao = new Movimentacao(request.Destino, request.Data, procedimento);

            _movimentacaoRepository.Add(movimentacao);

            if (Commit())
            {
                //TO DO
            }

            return(Task.FromResult(movimentacao.Id));
        }
        public Task <int> Handle(RegisterNewSituacaoProcedimentoCommand request, CancellationToken cancellationToken)
        {
            if (!request.IsValid())
            {
                NotifyValidationErrors(request);
                return(Task.FromResult(0));
            }

            var procedimento = _procedimentoRepository.GetById(request.ProcedimentoId);

            if (procedimento == null)
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "O Procedimento não foi encontrado."));
                return(Task.FromResult(0));
            }

            var situacao = _situacaoRepository.GetById(request.SituacaoId);

            if (situacao == null)
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "A Situação não foi encontrada."));
                return(Task.FromResult(0));
            }

            SituacaoTipo tipoSituacao = null;

            if (request.SituacaoTipoId.HasValue)
            {
                tipoSituacao = _situacaoTipoRepository.GetById(request.SituacaoTipoId.Value);

                if (request.SituacaoTipoId.Value > 0 && tipoSituacao == null)
                {
                    Bus.RaiseEvent(new DomainNotification(request.MessageType, "O motivo não foi encontrado."));
                    return(Task.FromResult(0));
                }
            }

            //if (_situacaoProcedimentoRepository.Exists(request.ProcedimentoId, request.SituacaoId, request.SituacaoTipoId))
            //{
            //    Bus.RaiseEvent(new DomainNotification(request.MessageType, "O procedimento encontra-se na situação atual. Nada pra atualizar."));
            //    return Task.FromResult(0);
            //}

            var situacaoProcedimento = new SituacaoProcedimento(procedimento, situacao, tipoSituacao, request.DataRelatorio, request.Observacao);

            _situacaoProcedimentoRepository.Add(situacaoProcedimento);

            procedimento.SituacaoAtual = situacao;

            _procedimentoRepository.Update(procedimento);

            if (Commit())
            {
                //TO DO
            }

            return(Task.FromResult(situacaoProcedimento.Id));
        }
        public Task <int> Handle(RemoveProcedimentoCommand request, CancellationToken cancellationToken)
        {
            if (!request.IsValid())
            {
                NotifyValidationErrors(request);
                return(Task.FromResult(0));
            }

            var procedimento = _procedimentoRepository.GetById(request.Id);

            if (procedimento == null)
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "O procedimento não foi encontrado."));
                return(Task.FromResult(0));
            }

            _vitimaRepository.Remove(x => x.ProcedimentoId == request.Id);
            _indiciadoRepository.Remove(x => x.ProcedimentoId == request.Id);
            _movimentacaoRepository.Remove(x => x.ProcedimentoId == request.Id);
            _objetoApreendidoRepository.Remove(x => x.ProcedimentoId == request.Id);
            _situacaoProcedimentoRepository.Remove(x => x.ProcedimentoId == request.Id);

            _procedimentoRepository.Remove(request.Id);

            if (Commit())
            {
                // TO DO: Raise Event
            }

            return(Task.FromResult(request.Id));
        }
        public Task <int> Handle(RegisterNewVitimaCommand request, CancellationToken cancellationToken)
        {
            if (!request.IsValid())
            {
                NotifyValidationErrors(request);
                return(Task.FromResult(0));
            }

            var procedimento = _procedimentoRepository.GetById(request.ProcedimentoId);

            if (procedimento == null)
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "O Procedimento não foi encontrado."));
                return(Task.FromResult(0));
            }

            Municipio municipio = null;

            if (request.MunicipioId.HasValue)
            {
                municipio = _municipioRepository.GetById(request.MunicipioId.Value);

                if (request.MunicipioId > 0 && municipio == null)
                {
                    Bus.RaiseEvent(new DomainNotification(request.MessageType, "O Município não foi encontrado."));
                    return(Task.FromResult(0));
                }
            }

            if (_vitimaRepository.Exists(request.Nome, request.ProcedimentoId))
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "A Vítima já está sendo usada."));
                return(Task.FromResult(0));
            }

            var vitima = new Vitima(request.Email, procedimento, request.Nome, request.NomePai, request.NomeMae, request.DataNascimento, request.Telefone, municipio);

            _vitimaRepository.Add(vitima);

            if (Commit())
            {
                //TO DO
            }

            return(Task.FromResult(vitima.Id));
        }
Exemple #6
0
        public Task <int> Handle(RegisterNewIndiciadoCommand request, CancellationToken cancellationToken)
        {
            if (!request.IsValid())
            {
                NotifyValidationErrors(request);
                return(Task.FromResult(0));
            }

            var procedimento = _procedimentoRepository.GetById(request.ProcedimentoId);

            if (procedimento == null)
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "O Procedimento não foi encontrado."));
                return(Task.FromResult(0));
            }

            var municipio = _municipioRepository.GetById(request.MunicipioId);

            if (request.MunicipioId > 0 && municipio == null)
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "O Município não foi encontrado."));
                return(Task.FromResult(0));
            }

            if (_indiciadoRepository.Exists(request.Nome, request.ProcedimentoId))
            {
                Bus.RaiseEvent(new DomainNotification(request.MessageType, "A Indiciado já está sendo usada."));
                return(Task.FromResult(0));
            }

            var indiciado = new Indiciado(request.Apelido, procedimento, request.Nome, request.NomePai, request.NomeMae, request.DataNascimento, request.Idade, request.Telefone, municipio);

            _indiciadoRepository.Add(indiciado);

            if (Commit())
            {
                //TO DO
            }

            return(Task.FromResult(indiciado.Id));
        }