public async Task <IActionResult> InsertMaterialAsignado(RecursoAsignadoDTO dto)
        {
            if (ModelState.IsValid)
            {
                dto = await _recursoAsignadoService.CreateRRMM(this.Usuario, dto);

                return(Ok(dto));
            }
            else
            {
                return(BadRequest(ModelState));
            }
        }
        public async Task <RecursoAsignadoDTO> Update(UsuarioDTO userLogged, int id, RecursoAsignadoDTO dto)
        {
            var entity   = _mapper.Map <RecursoAsignado>(dto);
            var entityOG = await _recursoAsignadoRepository.GetBy(s => s.Id == id);

            entity.Active         = true;
            entity.CreationDate   = entityOG.CreationDate;
            entity.CreationUserId = entityOG.CreationUserId;
            entity.UpdateDate     = DateTime.Now;
            entity.UpdateUserId   = userLogged.Id;

            entity = await _recursoAsignadoRepository.Update(id, entity);

            return(_mapper.Map <RecursoAsignadoDTO>(entity));;
        }
        public async Task <IEnumerable <RecursoAsignadoDTO> > ListRRMM(UsuarioDTO userlogged, int idRecurso, RecursoAsignadoFilterDTO filter = null)
        {
            var entitiesDTO = new List <RecursoAsignadoDTO>();

            var entitiesRRMM = await _recursoAsignadoRepository.ListBy(recursoAsignado =>
                                                                       recursoAsignado.Active == true &&
                                                                       (recursoAsignado.IdRecurso1 == idRecurso) &&
                                                                       recursoAsignado.IdRecurso2Navigation.IdTipoRecursoNavigation.Id == TipoRecursoEnum.Recurso_Material.ToInt() &&
                                                                       (!filter.CreationDateFrom.HasValue || recursoAsignado.CreationDate >= filter.CreationDateFrom.Value) &&
                                                                       (!filter.CreationDateTo.HasValue || recursoAsignado.CreationDate <= filter.CreationDateTo.Value) &&

                                                                       (
                                                                           filter.Name.IsNullOrEmpty() ||
                                                                           recursoAsignado.IdRecurso2Navigation.RecursoMaterial.FirstOrDefault().Marca.ToLower().Contains(filter.Name) ||
                                                                           recursoAsignado.IdRecurso2Navigation.RecursoMaterial.FirstOrDefault().Modelo.ToLower().Contains(filter.Name) ||
                                                                           recursoAsignado.IdRecurso2Navigation.RecursoMaterial.FirstOrDefault().IdTipoRecursoMaterialNavigation.Descripcion.ToLower().Contains(filter.Name) ||
                                                                           recursoAsignado.IdUbicacionNavigation.Referencia.ToLower().Contains(filter.Name)
                                                                       )
                                                                       ,
                                                                       s => s.IdRecurso2Navigation.RecursoMaterial,
                                                                       s => s.IdUbicacionNavigation
                                                                       );;

            foreach (var item in entitiesRRMM)
            {
                var result = new RecursoAsignadoDTO
                {
                    ReferenciaUbicacion = item.IdUbicacionNavigation?.Referencia,

                    Id            = item.Id,
                    IdRecurso1    = item.IdRecurso1,
                    IdRecurso2    = item.IdRecurso2,
                    FechaAsignado = item.FechaAsignado,
                    IdUbicacion   = item.IdUbicacion,

                    recursoMaterial = _mapper.Map <RecursoMaterialDTO>(await _RecursoMaterialRespository.GetBy
                                                                       (
                                                                           s => s.IdRecurso == item.IdRecurso2,
                                                                           s => s.IdTipoRecursoMaterialNavigation
                                                                       ))
                };
                entitiesDTO.Add(result);
            }

            return(entitiesDTO);
        }
        public async Task <RecursoAsignadoDTO> CreateRRRR(UsuarioDTO userLogged, RecursoAsignadoDTO dto)
        {
            var entity = _mapper.Map <RecursoAsignado>(dto);

            entity.CreationDate   = DateTime.Now;
            entity.CreationUserId = userLogged.Id;
            entity.Active         = true;
            entity.FechaAsignado  = DateTime.Now;

            entity = await _recursoAsignadoRepository.Insert(entity);

            var recurso = await _recursoRepository.GetBy(s => s.Id == entity.IdRecurso2);

            recurso.IdEstado = EstadosEnum.Asignado.ToInt();
            await _recursoRepository.Update(recurso);

            return(_mapper.Map <RecursoAsignadoDTO>(entity));
        }
        public async Task <RecursoAsignadoDTO> CreateRRMM(UsuarioDTO userLogged, RecursoAsignadoDTO dto)
        {
            var entity = _mapper.Map <RecursoAsignado>(dto);

            /*entity.IdRecurso1 = (await _RecursoMaterialRespository.GetBy(s => s.Id == entity.IdRecurso1)).IdRecurso;*/
            entity.CreationDate   = DateTime.Now;
            entity.CreationUserId = userLogged.Id;
            entity.Active         = true;
            entity.FechaAsignado  = DateTime.Now;

            var recursoMaterial = await _RecursoMaterialRespository.GetBy(s => s.IdRecursoNavigation.Id == dto.IdRecurso2, s => s.IdRecursoNavigation);

            if (recursoMaterial.Stockeable == true)
            {
                bool bajar = await _stockRecursoMaterialService.DismiuyeUno((int)dto.IdUbicacion, recursoMaterial.IdRecursoNavigation.Id);

                if (!bajar)
                {
                    throw new NotFoundException();
                }

                if (await _stockRecursoMaterialRepository.Any(s => s.Active == true && s.IdRecursoMaterial == recursoMaterial.Id && s.CantidadDisponible > 0))
                {
                    recursoMaterial.IdRecursoNavigation.IdEstado = EstadosEnum.Disponible.ToInt();
                    await _RecursoMaterialRespository.Update(recursoMaterial);
                }
                else
                {
                    recursoMaterial.IdRecursoNavigation.IdEstado = EstadosEnum.Asignado.ToInt();
                    await _RecursoMaterialRespository.Update(recursoMaterial);
                }
            }
            else
            {
                var recurso = await _recursoRepository.GetById(dto.IdRecurso2);

                recurso.IdEstado = EstadosEnum.Asignado.ToInt();
                await _recursoRepository.Update(recurso);
            }
            entity = await _recursoAsignadoRepository.Insert(entity);

            return(_mapper.Map <RecursoAsignadoDTO>(entity));
        }