public async Task <IActionResult> Put(Guid ServicioId, [FromBody] ServicioDTO servicio)
{
servicio.ServId = ServicioId;
await Service.Insert(servicio);
return(Ok(true));
}
public IEnumerable <ServicioDTO> GetAll()
{
var servicios = _context.Servicio.Where(x => x.Estado == Constantes.Activo);
var serviciosDTO = ServicioDTO.DeModeloADTO(servicios);
return(serviciosDTO);
}
public ServicioDTO GuardarServicio(ServicioDTO servicio)
{
servicio.Codigo = Guid.NewGuid();
Servicio objServicio = _mapper.Map <Servicio>(servicio);
return(_mapper.Map <ServicioDTO>(_servicioService.GuardarNuevoServicio(objServicio)));
}
public ActionResult Create(ServicioModel model)
{
try
{
if (ModelState.IsValid)
{
MapeadorUIServicio mapeador = new MapeadorUIServicio();
ServicioDTO dto = mapeador.MapearT2T1(model);
bool guardado = _controlador.RegistrarServicio(dto);
if (guardado)
{
return(RedirectToAction("Index"));
}
else
{
return(View(model));
}
}
else
{
return(View(model));
}
}
catch
{
return(View());
}
}
public List <PedidoSalidaDTO> getPedido(string usuario, string estado, string pedido)
{
PedidoBE.Criterio criterio = new PedidoBE.Criterio();
criterio.OBTENER_SERVICIOS = true;
criterio.USUARIO_CODIGO = usuario;
criterio.ESTADO = estado;
criterio.ID_PEDIDO = pedido;
List <PedidoSalidaDTO> resultado = new List <PedidoSalidaDTO>();
List <PedidoBE> listaPedido = negocioBL.get(criterio);
foreach (PedidoBE pedidoBE in listaPedido)
{
PedidoSalidaDTO pedidoSalidaDTO = UtilFunction.getPedidoSalidaDTO(pedidoBE);
resultado.Add(pedidoSalidaDTO);
if (pedidoBE.servicios.Count > 0)
{
pedidoSalidaDTO.servicios = new List <ServicioDTO>();
foreach (ServicioBE servicioBE in pedidoBE.servicios)
{
ServicioDTO servicioDTO = UtilFunction.getServicioDTO(servicioBE);
pedidoSalidaDTO.servicios.Add(servicioDTO);
}
}
}
return(resultado);
}
public async Task <ServicioDTO> Update(int id, ServicioDTO dto, UsuarioDTO user)
{
var entity = await this._servicioRepository.GetBy(s => s.Id == id);
if (entity.IdRecursoHumano1 != dto.IdRecursoHumano1)
{
var oldRrhh = await _recursoHumanoRepository.GetBy(s => s.Id == entity.IdRecursoHumano1, r => r.IdRecursoNavigation);
if (oldRrhh.Multiservicio != true)
{
oldRrhh.IdRecursoNavigation.IdEstado = EstadosEnum.Disponible.ToInt();
await _recursoHumanoRepository.Update(oldRrhh);
}
var nwRrhh = await _recursoHumanoRepository.GetBy(s => s.Id == dto.IdRecursoHumano1, r => r.IdRecursoNavigation);
if (nwRrhh.Multiservicio != true)
{
nwRrhh.IdRecursoNavigation.IdEstado = EstadosEnum.Asignado.ToInt();
await _recursoHumanoRepository.Update(nwRrhh);
}
}
entity.FechaInicio = dto.FechaInicio;
entity.FechaFin = dto.FechaFin;
entity.IdCliente = dto.IdCliente;
entity.IdRecursoHumano1 = dto.IdRecursoHumano1;
entity.Nombre = dto.Nombre;
entity.Objetivo = dto.Objetivo;
entity.NroContrato = dto.NroContrato;
entity.UpdateDate = DateTime.Now;
entity.UpdateUserId = user.Id;
entity = await _servicioRepository.Update(id, entity);
return(_mapper.Map <ServicioDTO>(entity));
}
public bool RegistrarServicio(ServicioDTO servicio)
{
MapeadorControladorServicio mapeador = new MapeadorControladorServicio();
ServicioDBModel servicioDBModel = mapeador.MapearT2T1(servicio);
bool Respuesta = _repositorio.RegistrarServicio(servicioDBModel);
return(Respuesta);
}
public static ServicioBE getServicioBE(ServicioDTO pServicioDTO)
{
ServicioBE servicioBE = new ServicioBE();
servicioBE.codigo = pServicioDTO.servicioCodigo;
servicioBE.id = pServicioDTO.idServicio;
return(servicioBE);
}
public JsonResult Update(ServicioDTO ServicioDTO)
{
var result = new
{
ServicioDTOid = ServicioService.EditServicio(Mapper.Map <SistemaSLS.Domain.Entities.Servicio>(ServicioDTO))
};
return(Json(result, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Post([FromBody] ServicioDTO servicio)
{
//await Service.Insert(servicio);
//return Ok(true);
if (!ModelState.IsValid)
{
throw new Exception("Model is not Valid");
}
await Service.Insert(servicio);
return(Ok(true));
}
public async Task <Response> GetById(long id)
{
var servicio = await _context.Servicio.FirstOrDefaultAsync(r => r.id == id);
if (servicio == null)
{
return(new Response {
Mensaje = "Este servicio no existe"
});
}
var data = ServicioDTO.DeModeloADTO(servicio);
return(new Response {
Datos = data
});
}
public PedidoSalidaDTO InsertPedido(PedidoEntradaDTO pPedidoEntradaDTO)
{
PedidoBE pedidoBE = UtilFunction.getPedidoBE(pPedidoEntradaDTO);
pedidoBE.fecha = DateTime.Now;
List <PedidoServicioBE> listaPedidoServicioBE = new List <PedidoServicioBE>();
if (pPedidoEntradaDTO.servicios != null)
{
foreach (ServicioDTO servicioDTO in pPedidoEntradaDTO.servicios)
{
//ServicioBE servicioBE = UtilFunction.getServicioBE(servicioDTO);
//serviciosBE.Add(servicioBE);
PedidoServicioBE pedidoServicioBE = new PedidoServicioBE();
pedidoServicioBE.idServicio = servicioDTO.idServicio;
pedidoServicioBE.costo = servicioDTO.costo;
listaPedidoServicioBE.Add(pedidoServicioBE);
}
}
pedidoBE = negocioBL.insert(pedidoBE, listaPedidoServicioBE);
PedidoSalidaDTO pedidoSalidaDTO = new PedidoSalidaDTO();
List <PedidoBE> listaPedido = negocioBL.get(new PedidoBE.Criterio()
{
NO_PINTAR = true, ID_PEDIDO = pedidoBE.id.ToString(), OBTENER_SERVICIOS = true
});
if (listaPedido != null && listaPedido.Count > 0)
{
PedidoBE pedidoAuxBE = listaPedido[0];
pedidoSalidaDTO = UtilFunction.getPedidoSalidaDTO(pedidoAuxBE);
List <ServicioDTO> listaServicioDTO = new List <ServicioDTO>();
foreach (ServicioBE servicioBE in pedidoAuxBE.servicios)
{
ServicioDTO servicioDTO = UtilFunction.getServicioDTO(servicioBE);
listaServicioDTO.Add(servicioDTO);
}
pedidoSalidaDTO.servicios = listaServicioDTO;
}
return(pedidoSalidaDTO);
}
public async Task <ServiceResult> Get([FromRoute] string clienteId, [FromQuery] string id)
{
ServiceResult service = new ServiceResult();
try
{
ServicioDTO servicio = new ServicioDTO();
servicio = await servicioService.BuscarPorCodigoAsync(clienteId, id);
service.Data = servicio;
}
catch (Exception ex)
{
service.Errors(ex);
_logger.LogError(ex);
}
return(service);
}
public async Task <ActionResult <ServicioGetDTO> > PostServicio(ServicioDTO servicioDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var servicioEntity = _mapper.Map <Servicio>(servicioDTO);
var result = await _servicioService.CreateAsync(servicioEntity);
if (!result.Success)
{
return(BadRequest(result.Message));
}
return(Ok(_mapper.Map <ServicioGetDTO>(result.Servicio)));
}
public async Task <ServicioDTO> Create(ServicioDTO dto, UsuarioDTO user)
{
var entity = _mapper.Map <Servicio>(dto);
entity.UpdateDate = entity.CreationDate = DateTime.Now;
entity.UpdateUserId = entity.CreationUserId = user.Id;
entity.IdEmpresa = user.IdEmpresa;
entity.Active = true;
entity = await _servicioRepository.Insert(entity);
var rrhh = await _recursoHumanoRepository.GetBy(s => s.Id == entity.IdRecursoHumano1, r => r.IdRecursoNavigation);
if (rrhh.Multiservicio != true)
{
rrhh.IdRecursoNavigation.IdEstado = EstadosEnum.Asignado.ToInt();
await _recursoHumanoRepository.Update(rrhh);
}
return(_mapper.Map <ServicioDTO>(entity));
}
public static ServicioDTO getServicioDTO(ServicioBE pServicioBE)
{
ServicioDTO servicioDTO = new ServicioDTO();
servicioDTO.idServicio = pServicioBE.id;
servicioDTO.costo = pServicioBE.costo;
//servicioDTO.idEvento = pServicioBE.idEvento;
servicioDTO.servicioCodigo = pServicioBE.codigo;
servicioDTO.servicioNombre = pServicioBE.nombre;
servicioDTO.estadoEventoCodigo = pServicioBE.estadoEventoCodigo;
servicioDTO.estadoEventoNombre = pServicioBE.estadoEventoNombre;
servicioDTO.fecha = pServicioBE.fechaEvento;
if (pServicioBE.fechaEvento != null)
{
servicioDTO.fechaString = pServicioBE.fechaEvento.ToString();
}
servicioDTO.idPedidoServicio = pServicioBE.idPedidoServicio;
return(servicioDTO);
}
public async Task <IActionResult> Insert(int id, ServicioDTO servicio)
{
try
{
if (ModelState.IsValid)
{
servicio = await _servicioService.Update(id, servicio, Usuario);
return(Ok(servicio));
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public bool ActualizarServicio(ServicioDTO servicio)
{
throw new NotImplementedException();
}
public async Task Update(ServicioDTO entityDTO)
{
var entity =
Builders.GenericBuilder.builderDTOEntity <TServicio, ServicioDTO>(entityDTO);
await repository.Save(entity);
}