Пример #1
0
        public async Task <Evento> UpdateEventos(int eventoId, Evento model)
        {
            try
            {
                var evento = await _eventoPersistence.GetAllEventoByIdAsync(eventoId, false);

                if (evento == null)
                {
                    return(null);
                }

                model.Id = evento.Id;

                _geralPersistence.Update(model);
                if (await _geralPersistence.SaveChangesAsync())
                {
                    return(await _eventoPersistence.GetAllEventoByIdAsync(model.Id, false));
                }
                return(null);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Пример #2
0
        public async Task <Solicitacao> UpdateSolicitacao(int id, Solicitacao model)
        {
            try
            {
                var solicitacao = await _solicitacaPersistence.GetAllSolicitacaoByIdAsync(id);

                if (solicitacao == null)
                {
                    return(null);
                }

                model.Pedido = solicitacao.Pedido;

                _geralPersistence.Update(model);
                if (await _geralPersistence.SaveChangesAsync())
                {
                    return(await _solicitacaPersistence.GetAllSolicitacaoByIdAsync(model.Pedido));
                }
                return(null);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Пример #3
0
        public async Task <Evento> UpdateEvento(int eventoId, Evento model)
        {
            try
            {
                var evento = await _eventoPersistence.GetEventosByIdAsync(eventoId, false); // busca um evento especifico

                model.EventoId = evento.EventoId;

                // verificaçao se um evento foi retornado ou nao
                if (evento == null)
                {
                    return(null);
                }

                _geralPersistence.Update <Evento>(model);

                // se foi salvo
                bool save = await _geralPersistence.SaveChangesAsync();

                if (save)
                {
                    // return Ok()
                    return(await _eventoPersistence.GetEventosByIdAsync(model.EventoId, false));
                }

                return(null);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Пример #4
0
        public async Task <EventoDto> Update(int eventoId, EventoDto model)
        {
            try
            {
                var evento = await _eventoPersist.GetEventoByIdAsync(eventoId, false);

                if (evento == null)
                {
                    return(null);
                }

                model.Id = evento.Id;

                _mapper.Map(model, evento);

                _geralPersist.Update <Evento>(evento);
                if (await _geralPersist.SaveChangesAsync())
                {
                    var eventoRetorno = await _eventoPersist.GetEventoByIdAsync(evento.Id, false);

                    return(_mapper.Map <EventoDto>(eventoRetorno));
                }
                return(null);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Пример #5
0
        public async Task <Palestrante> UpdatePalestrantes(int palestranteId, Palestrante model)
        {
            try
            {
                var palestrante = await _palestrantePersistence.GetPalestranteByIdAsync(palestranteId, false);

                if (palestrante == null)
                {
                    return(null);
                }

                model.Id = palestrante.Id;

                _geralPersistence.Update(model);
                if (await _geralPersistence.SaveChangesAsync())
                {
                    return(await _palestrantePersistence.GetPalestranteByIdAsync(model.Id, false));
                }
                return(null);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
Пример #6
0
        public async Task <Item> Update(Item item)
        {
            try
            {
                var existItem = _itemPersist.GetItemById(item.Id) != null;
                if (existItem)
                {
                    return(null);
                }
                _geralPersist.Update(item);

                if (await _geralPersist.SaveChangesAsync())
                {
                    return(item);
                }
                return(null);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }