コード例 #1
0
        public async Task <DataBase.ViewModels.Profissionais_Saude> CreateAsync(
            [FromBody] DataBase.RequestModel.ProfissionalSaudeRequest profissionais_saude,
            CancellationToken ct
            )
        {
            var result = await _profissionais_saudeServices.CreateAsync(profissionais_saude, ct);

            var utilizador = await _utilizadorServices.GetByIdAsync(result.Id_Utilizador, ct);

            return(result.ToViewModel(utilizador));
        }
コード例 #2
0
        public async Task <DataBase.ViewModels.Doente> CreateAsync(
            [FromBody] DataBase.RequestModel.DoenteRequest doente,
            CancellationToken ct
            )
        {
            var result = await _doenteServices.CreateAsync(doente, ct);

            var utilizador = await _utilizadoresServices.GetByIdAsync(result.Id_Utilizador, ct);

            return(result.ToViewModel(utilizador));
        }
コード例 #3
0
        public async Task <DataBase.ViewModels.Internamento> CreateAsync(
            [FromBody] DataBase.Models.Internamento internamento,
            CancellationToken ct
            )
        {
            var result = await _internamentoServices.CreateAsync(internamento, ct);

            var doente = await _doenteServices.GetByIdAsync(result.Id_Doente, ct);

            var hospital = await _hospitalServices.GetByIdAsync(result.Id_Hospital, ct);

            var utilizador = await _utilizadorServices.GetByIdAsync(doente.Id_Utilizador, ct);

            return(result.ToViewModel(utilizador, hospital));
        }
コード例 #4
0
        /// <summary>
        /// Serviço para a atualização dos dados de um profssional de saude
        /// </summary>
        /// <param name="id">Identificador do profissional de saude</param>
        /// <param name="profissionais_saude">Dados do profissional de saude para gravar</param>
        /// <param name="ct">Cancellation Token - chamada asincrona</param>
        /// <returns>View do profissional de saude</returns>
        public async Task <Profissionais_Saude> UpdateAsync(int id, ProfissionalSaudeRequest profissionais_saude, CancellationToken ct)
        {
            try
            {
                var profissionalObject = await _profissionais_saudeRepository.GetAsync(id, ct);

                var utilizador = await _utilizadoresServices.GetByIdAsync(profissionalObject.Id_Utilizador, ct);

                utilizador.Nome     = profissionais_saude.Nome;
                utilizador.Idade    = profissionais_saude.Idade;
                utilizador.Morada   = profissionais_saude.Morada;
                utilizador.NIB      = profissionais_saude.NIB;
                utilizador.CC       = profissionais_saude.CC;
                utilizador.Sexo     = profissionais_saude.Sexo;
                utilizador.Username = profissionais_saude.CC.ToString();

                profissionalObject.Id_Hospital = profissionais_saude.Id_Hospital;
                profissionalObject.Profissao   = profissionais_saude.Profissao;

                var result = await _profissionais_saudeRepository.UpdateAsync(profissionalObject, ct);

                await _utilizadoresServices.UpdateAsync(utilizador.Id, utilizador, ct);

                return(result);
            }
            catch (Exception e)
            {
                throw new Exception("Ocorreu um erro na actualização do doente e respectivo utilizador.", e);
            }
        }
コード例 #5
0
        /// <summary>
        /// Serviço para a atualização dos dados de um doente
        /// </summary>
        /// <param name="id">Identificador do doente</param>
        /// <param name="doente">Dados do doente para gravar</param>
        /// <param name="ct">Cancellation Token - chamada asincrona</param>
        /// <returns>View do doente</returns>
        public async Task <Doente> UpdateAsync(
            int id,
            DataBase.RequestModel.DoenteRequest doente,
            CancellationToken ct
            )
        {
            try
            {
                var doenteObject = await _doenteRepository.GetAsync(id, ct);

                var utilizador = await _utilizadoresServices.GetByIdAsync(doenteObject.Id_Utilizador, ct);

                utilizador.Nome     = doente.Nome;
                utilizador.Idade    = doente.Idade;
                utilizador.Morada   = doente.Morada;
                utilizador.NIB      = doente.NIB;
                utilizador.CC       = doente.CC;
                utilizador.Sexo     = doente.Sexo;
                utilizador.Username = doente.CC.ToString();

                doenteObject.Regiao = doente.Regiao;

                var result = await _doenteRepository.UpdateAsync(doenteObject, ct);

                await _utilizadoresServices.UpdateAsync(utilizador.Id, utilizador, ct);

                return(result);
            }
            catch (Exception e)
            {
                throw new Exception("Ocorreu um erro na actualização do doente e respectivo utilizador.", e);
            }
        }
コード例 #6
0
        public async Task GetTestAsync()
        {
            var teste = await business.GetByIdAsync(
                1,
                CancellationToken.None
                );

            Assert.AreEqual(teste.Nome, "Diogo Biscaia");
        }