//Construtor informando o que é obrigatório para o chamado existir.
        public ChamadoEntity(SistemaEntity sistema, ChamadoPrioridadeValueObject prioridade)
        {
            //Validação de negócio com o framework BM.Validations.
            ValidatorHelper.GarantirNaoNulo(sistema, Mensagens.ChamadoSistemaInvalido);

            //Set das propriedades:
            Codigo        = new Guid();
            Sistema       = sistema;
            CodigoSistema = sistema.Codigo;
            Prioridade    = prioridade;
            //Status inicial
            Status = ChamadoStatusValueObject.Aberto;
        }
        //Realização da abertura do chamado.
        public ChamadoEntity Abrir(int codigoSistema, ChamadoPrioridadeValueObject prioridade)
        {
            //Recupera o sitema:
            var sistema = _sistemaRepository.GetByCodigo(codigoSistema);

            //Valida se o mesmo existe:
            ValidatorHelper.GarantirNaoNulo(sistema, Mensagens.SistemaNaoEncontrado);

            //Cria o chamado:
            var chamado = new ChamadoEntity(sistema, prioridade);

            //Salva o chamado:
            _chamadoRepository.Add(chamado);

            //Retorna o chamado criado:
            return(chamado);
        }
        public void QuandoEuAbrirUmChamado()
        {
            //arrange:
            // Definimos um código de sistema fictício.
            const int codigoSistema = 1;

            //Definimos uma prioridade.
            const ChamadoPrioridadeValueObject prioridade = ChamadoPrioridadeValueObject.Normal;

            //Definimos o que o repositório irá retornar de acordo com o código informado.
            _sistemaRepositoryMock.Setup(x => x.GetByCodigo(codigoSistema)).Returns(_sistema);

            //Declaramos a variável de retorno do teste.
            ChamadoEntity chamado;

            //act
            //Executamos a funcionalidade que será testada.
            chamado = _domainService.Abrir(codigoSistema, prioridade);

            //assert
            //Garantimos que o resultado da funcionalidade seja o esperado.

            //Garantimos que a variável de retorno não seja nula.
            Assert.IsNotNull(chamado);

            //Garantimos que a data da criação é a mesma de hoje.
            // *Não foi validado a hora, pois pode ocorrer diferença de milésimos de segundos.
            Assert.AreEqual(DateTime.Now.Date, chamado.DataCriacao.Date);

            //Garantimos que o status do chamado seja Aberto, quando ele for criado.
            Assert.AreEqual(ChamadoStatusValueObject.Aberto, chamado.Status);

            //Garantimos que a prioridade do chamado seja a mesma que solicitamos.
            Assert.AreEqual(ChamadoPrioridadeValueObject.Normal, chamado.Prioridade);

            //O resultado do chamado será escrito no Output. (serve apenas fins de log do teste)
            //Debug.WriteLine está fazendo um chamado.ToString() com a variável chamado.
            //O método ToString foi sobrescrito, informando os dados daquele chamado.
            Debug.WriteLine(chamado);
        }
        //Construtor informando o que é obrigatório para o prazo de solução existir.
        public ChamadoPrazoSolucaoValueObject(ChamadoPrioridadeValueObject prioridade)
        {
            //Definição das horas de atendimento (regra de negócio)
            switch (prioridade)
            {
            case ChamadoPrioridadeValueObject.Normal:
                //Set da propriedade
                HorasUteis = 24;
                break;

            case ChamadoPrioridadeValueObject.Crítico:
                //Set da propriedade
                HorasUteis = 4;
                break;

            default:
                throw new ApplicationException(Mensagens.ChamadoPrazoSolucaoPrioridadeNaoConfigurada);
            }

            //Set da propriedade
            Prioridade = prioridade;
        }