Exemplo n.º 1
0
        public async Task <HttpResponseMessage> SaveRequirementDetail(RequisitoDTO SettingDetail)
        {
            return(await HandleOperationExecutionAsync(async() =>
            {
                var result =
                    await
                    _configuracionesService.SaveRequirementDetail(SettingDetail);

                return Request.CreateResponse(HttpStatusCode.OK, result);
            }));
        }
        public async Task <RequisitoDTO> Insert(int idServicio, RequisitoDTO dto, UsuarioDTO currUser)
        {
            if (!(await _servicioRepository.Any(s => s.Id == idServicio && s.IdEmpresa == currUser.IdEmpresa)))
            {
                throw new NotFoundException();
            }
            var entity = _mapper.Map <Requisito>(dto);

            entity.UpdateDate   = entity.CreationDate = DateTime.Now;
            entity.UpdateUserId = entity.CreationUserId = currUser.Id;
            entity.Active       = true;
            entity.IdServicio   = idServicio;
            return(_mapper.Map <RequisitoDTO>(await _requisitoRepository.Insert(entity)));
        }
        private bool IsValid(RequisitoDTO requisito)
        {
            if (!ModelState.IsValid)
            {
                return(false);
            }
            switch (requisito.IdTipoRegla)
            {
            case 1:
            {
                return(requisito.IdTipoRecurso1.HasValue && requisito.IdTipoRecurso2.HasValue &&
                       (requisito.IdTipoRecursoMaterial1.HasValue || requisito.IdTipoRecurso1.Value == TipoRecursoEnum.Recurso_Humano.ToInt()) &&
                       requisito.IdTipoRecursoMaterial2.HasValue &&
                       requisito.Periodicidad.HasValue && requisito.IdUtiempo.HasValue);
            }

            case 2:
            {
                return(requisito.IdTipoRecurso1.HasValue && requisito.IdTipoRecurso2.HasValue &&
                       (requisito.IdTipoRecursoMaterial1.HasValue || requisito.IdTipoRecurso1.Value == TipoRecursoEnum.Recurso_Humano.ToInt()) &&
                       requisito.IdTipoRecursoRenovable.HasValue);
            }

            case 3:
            {
                return(requisito.IdTipoRecurso1.HasValue && requisito.IdTipoRecurso2.HasValue &&
                       (requisito.IdTipoRecursoMaterial1.HasValue || requisito.IdTipoRecurso1.Value == TipoRecursoEnum.Recurso_Humano.ToInt()) &&
                       requisito.IdTipoRecursoMaterial2.HasValue);
            }

            case 4:
            {
                return(requisito.IdTipoRecurso1.HasValue &&
                       requisito.IdTipoRecursoMaterial1.HasValue &&
                       requisito.Periodicidad.HasValue && requisito.IdUtiempo.HasValue);
            }

            case 5:
            {
                return(requisito.IdTipoRecurso1.HasValue &&
                       (requisito.IdTipoRecursoMaterial1.HasValue || requisito.IdTipoRecurso1.Value == TipoRecursoEnum.Recurso_Humano.ToInt()) &&
                       requisito.Periodicidad.HasValue && requisito.IdUtiempo.HasValue);
            }

            default:
                return(false);
            }
        }
Exemplo n.º 4
0
        /// <summary>
        ///     Actualización / Inserción de un requisito
        /// </summary>
        /// <param name="DetalleRequisito"></param>
        /// <returns></returns>
        public async Task <int> SalvarActualizarRequisito(RequisitoDTO DetalleRequisito)
        {
            using (var modelo = new ISSSTEEntities())
            {
                var resultado = new Requisito
                {
                    RequisitoId      = DetalleRequisito.RequisitoId,
                    CatTipoTramiteId = DetalleRequisito.CatTipoTramiteId,
                    Descripcion      = DetalleRequisito.Descripcion,
                    NombreDocumento  = DetalleRequisito.NombreDocumento,
                    EsActivo         = DetalleRequisito.EsActivo,
                    EsObligatorio    = DetalleRequisito.EsObligatorio
                };

                modelo.Requisito.AddOrUpdate(resultado);
                return(await modelo.SaveChangesAsync());
            }
        }
        public async Task <IActionResult> Insert(int idServicio, RequisitoDTO requisito)
        {
            try
            {
                if (IsValid(requisito))
                {
                    requisito = await _requisitoService.Insert(idServicio, requisito, Usuario);

                    return(Ok(requisito));
                }
                else
                {
                    return(BadRequest(ModelState));
                }
            }
            catch (NotFoundException nf) { return(NotFound(nf.Message)); }
            catch (Exception e)
            {
                return(StatusCode(500, e.Message));
            }
        }
        public async Task <int> SaveRequirementDetail(RequisitoDTO RequirementDetail)
        {
            var requisitoDao = new RequisitoDAO();

            return(await requisitoDao.SalvarActualizarRequisito(RequirementDetail));
        }