Пример #1
0
        public async Task <IActionResult> Crear(ModeloValidation modeloValidation)
        {
            if (modeloValidation == null)
            {
                return(BadRequest(404));
            }
            if (ModelState.IsValid)
            {
                var modelo = new Modelo
                {
                    Sku          = modeloValidation.Sku,
                    Denominacion = modeloValidation.Denominacion,
                    Objetivo     = modeloValidation.Objetivo
                };

                var spec         = new ModeloConNumeroSpecification(modeloValidation.Sku);
                var modeloValido = await _unitOfWork.Repository <Modelo>().GetEntityWithSpec(spec);

                if (modeloValido == null)
                {
                    _unitOfWork.Repository <Modelo>().Add(modelo);
                    await _unitOfWork.Complete();

                    _unitOfWork.Dispose();
                    return(RedirectToAction("Index"));
                }
                ModelState.AddModelError("", "El codigo ya existe, ingrese uno nuevo");
            }
            return(RedirectToAction("Index"));
        }
Пример #2
0
        public async Task <IActionResult> Update(ModeloValidation modeloValidation)
        {
            if (modeloValidation == null)
            {
                return(BadRequest(404));
            }
            if (ModelState.IsValid)
            {
                var modelo = new Modelo
                {
                    Sku          = modeloValidation.Sku,
                    Denominacion = modeloValidation.Denominacion,
                    Objetivo     = modeloValidation.Objetivo
                };

                var spec         = new ModeloConNumeroSpecification(modelo.Sku);
                var modeloValido = await _unitOfWork.Repository <Modelo>().GetEntityWithSpec(spec);

                if (modeloValido != null)
                {
                    modeloValido.Sku          = modelo.Sku;
                    modeloValido.Denominacion = modelo.Denominacion;
                    modeloValido.Objetivo     = modelo.Objetivo;
                    _unitOfWork.Repository <Modelo>().Update(modeloValido);
                    await _unitOfWork.Complete();

                    _unitOfWork.Dispose();
                    return(RedirectToAction("Index"));
                }
            }
            return(RedirectToAction("Edit"));
        }
Пример #3
0
        public async Task <IActionResult> Delete(string sku)
        {
            if (ModelState.IsValid)
            {
                var spec         = new ModeloConNumeroSpecification(sku);
                var modeloValido = await _unitOfWork.Repository <Modelo>().GetEntityWithSpec(spec);

                if (modeloValido != null)
                {
                    _unitOfWork.Repository <Modelo>().Delete(modeloValido);
                    await _unitOfWork.Complete();
                }
            }
            return(RedirectToAction("Index"));
        }
Пример #4
0
        public async Task <IActionResult> Edit(string sku)
        {
            if (ModelState.IsValid)
            {
                var spec         = new ModeloConNumeroSpecification(sku);
                var modeloValido = await _unitOfWork.Repository <Modelo>().GetEntityWithSpec(spec);

                if (modeloValido != null)
                {
                    var modeloValidation = new ModeloValidation()
                    {
                        Sku          = modeloValido.Sku,
                        Denominacion = modeloValido.Denominacion,
                        Objetivo     = modeloValido.Objetivo
                    };
                    return(View(modeloValidation));
                }
            }
            return(View());
        }
Пример #5
0
        public async Task <IActionResult> CrearOrden(OrdenIniciarViewModel orden, int numeroOrden)
        {
            var usuario = await ObtenerUsuario();

            var specLinea = new LineaConIdSpecification(Int32.Parse(orden.LineaSelected));
            var linea     = await _unitOfWork.Repository <LineaDeTrabajo>().GetEntityWithSpec(specLinea);

            var specModelo = new ModeloConNumeroSpecification(orden.ModeloSelected);
            var modelo     = await _unitOfWork.Repository <Modelo>().GetEntityWithSpec(specModelo);

            var specColor = new ColorConNumeroSpecification(Int32.Parse(orden.ColorSelected));
            var color     = await _unitOfWork.Repository <Color>().GetEntityWithSpec(specColor);

            var turnos = await _unitOfWork.Repository <Turno>().ListAllAsync();

            var horaActual = _unitOfWork.GetHora();

            var estadoFinalizada = EstadoOrden.Finalizada;

            var specLineas = new AddLineasIncludesSpecification();
            var lineas     = await _unitOfWork.Repository <LineaDeTrabajo>().ListAsync(specLineas);

            int usuarioValidado = 0;

            if (ModelState.IsValid)
            {
                foreach (var li in lineas)
                {
                    var validacionDeEmpleado = li.ComprobarAsignacionSupervisor(usuario.Empleado);
                    if (validacionDeEmpleado)
                    {
                        usuarioValidado++;
                    }
                }

                if (linea != null && modelo != null && color != null && usuario != null && usuarioValidado == lineas.Count)
                {
                    var lineaDisponible = linea.ObtenerLineaSiEstaFinalizada(estadoFinalizada);
                    if (lineaDisponible)
                    {
                        var spec           = new OrdenConNumeroSpecification(numeroOrden);
                        var ordenExistente = await _unitOfWork.Repository <OrdenDeProduccion>()
                                             .GetEntityWithSpec(spec);

                        if (ordenExistente == null)
                        {
                            var ordenV =
                                linea.CrearOrden(numeroOrden, modelo, color, usuario.Empleado, turnos, horaActual);
                            if (ordenV != null)
                            {
                                _unitOfWork.Repository <LineaDeTrabajo>().Update(linea);
                                await _unitOfWork.Complete();
                            }
                            ModelState.AddModelError("", "Se debe crear la orden en un turno valido ");
                        }
                        ModelState.AddModelError("", "Orden ya existente, ingrese otra");
                    }
                    ModelState.AddModelError("", "Orden activa en linea" + linea.Numero + ", finalice la ultima para crear otra");
                }
            }

            return(RedirectToAction("ObtenerLineas"));
        }