private static void CargarResponsable(Responsable responsable, SqlCeConnection conn, LainsaSci ctx)
        {
            TResponsable tr = new TResponsable()
            {
                ResponsableId = responsable.ResponsableId,
                Nombre        = responsable.Nombre
            };

            CntSciTerminal.TSave(tr, conn);
        }
 private void CargarResponsables(TResponsable responsable)
 {
     cmbResponsable.Items.Clear();
     // cargamos el desplegable.
     CntSciTerminal.TOpen(this.conn);
     foreach (TResponsable r in CntSciTerminal.GetTResponsables(conn))
     {
         cmbResponsable.Items.Add(r.Nombre);
     }
     if (responsable != null)
     {
         cmbResponsable.Text = responsable.Nombre;
     }
     else
     {
         cmbResponsable.Text = "";
     }
     CntSciTerminal.TClose(this.conn);
 }
            public async Task <Unit> Handle(UpdatePlanAccionCommand request, CancellationToken cancellationToken)
            {
                IList <PlanVM> planesAccion = new List <PlanVM>();

                planesAccion = request.planes;

                //var planAccion = planesAccion.AsQueryable()
                //   .ProjectTo<TAccion>(_mapper.ConfigurationProvider)
                //   .ToList();

                IList <ResponsablesDto> respJson;

                foreach (var accionJson in planesAccion)
                {
                    var dataBD = await _context.TAccion.Include(i => i.RespPlanAccion).FirstOrDefaultAsync(i => i.CodAccion == accionJson.codAccion && i.Estado);

                    if (dataBD != null)
                    {
                        dataBD.CodActiRelacionada = accionJson.codActiRelacionada;
                        dataBD.CodAreaHsec        = accionJson.codAreaHsec;
                        dataBD.FechaSolicitud     = accionJson.fechaSolicitud;
                        dataBD.CodActiRelacionada = accionJson.codActiRelacionada;
                        dataBD.CodSolicitadoPor   = accionJson.codSolicitadoPor;
                        dataBD.DocReferencia      = accionJson.docReferencia;
                        dataBD.DocSubReferencia   = accionJson.docSubReferencia;
                        dataBD.CodNivelRiesgo     = accionJson.codNivelRiesgo;
                        dataBD.Tarea        = accionJson.tarea;
                        dataBD.FechaInicial = accionJson.fechaInicial;
                        dataBD.FechaFinal   = accionJson.fechaFinal;
                        dataBD.Estado       = accionJson.estado;
                        dataBD.Aprobador    = accionJson.Aprobador;

                        respJson = new List <ResponsablesDto>();
                        respJson = accionJson.RespPlanAccion.ToList();
                        var respBD = dataBD.RespPlanAccion.ToList();
                        var inter  = respJson.Select(x => x.codPersona).Intersect(respBD.Select(x => x.CodPersona)).ToList();
                        var right  = respJson.Select(x => x.codPersona).Except(respBD.Select(x => x.CodPersona)).ToList();
                        var left   = respBD.Select(x => x.CodPersona).Except(respJson.Select(x => x.codPersona)).ToList();

                        foreach (var item in left)
                        {
                            var eliminar     = dataBD.RespPlanAccion.FirstOrDefault(i => i.CodPersona == item && i.CodAccion == dataBD.CodAccion && i.Estado);
                            var eliminarLevS = _context.TLevantamientoPlan.Where(i => i.CodPersona == item && i.CodAccion == dataBD.CodAccion && i.Estado);
                            if (eliminarLevS.Count() > 0)
                            {
                                foreach (var it in eliminarLevS)
                                {
                                    it.Estado = false;
                                    _context.TLevantamientoPlan.Update(it);
                                }
                            }
                            if (eliminar != null)
                            {
                                eliminar.Estado = false;
                                _context.TResponsable.Update(eliminar);
                            }
                        }
                        TResponsable responsable;
                        foreach (var item in right)
                        {
                            responsable = new TResponsable();
                            var agregar = accionJson.RespPlanAccion.FirstOrDefault(i => i.codPersona == item && i.codAccion == dataBD.CodAccion);
                            responsable.CodAccion  = agregar.codAccion;
                            responsable.CodPersona = agregar.codPersona;
                            responsable.Estado     = true;
                            if (responsable.CodAccion != 0 && responsable.CodPersona != null)
                            {
                                TLevantamientoPlan lev;
                                lev                  = new TLevantamientoPlan();
                                lev.CodAccion        = responsable.CodAccion;
                                lev.CodPersona       = responsable.CodPersona;
                                lev.PorcentajeAvance = 0;
                                lev.Estado           = false;
                                _context.TResponsable.Add(responsable);
                                _context.TLevantamientoPlan.Add(lev);
                            }
                        }
                        foreach (var it in inter)
                        {
                            var actualizar = _context.TResponsable.FirstOrDefault(i => i.CodPersona == it && i.CodAccion == dataBD.CodAccion);
                            if (actualizar != null)
                            {
                                actualizar.Estado = true;
                                _context.TResponsable.Update(actualizar);
                            }
                        }
                        _context.TAccion.Update(dataBD);
                        await _context.SaveChangesAsync(cancellationToken);
                    }
                }

                // Actualiza codEstadoAccion de plan de accion dataBD
                foreach (var accion in planesAccion)
                {
                    var dataBD = _context.TAccion.Include(i => i.RespPlanAccion).FirstOrDefault(i => i.CodAccion == accion.codAccion && i.Estado);//.Distinct().OrderBy(x => x);*//*.Skip(0).Take(10);*/

                    if (dataBD != null)
                    {
                        double suma  = 0;
                        int    count = 0;

                        foreach (var it in dataBD.RespPlanAccion)
                        {
                            if (it.Estado)
                            {
                                var levTarea = _context.TLevantamientoPlan.Where(I => I.CodAccion == accion.codAccion && I.CodPersona == it.CodPersona && I.Estado);
                                if (levTarea.Count() > 0)
                                {
                                    var maxLevTarea = levTarea.Max(I => I.PorcentajeAvance);
                                    suma += maxLevTarea;
                                    count++;
                                }
                            }
                        }

                        double sumaDiv = 0;
                        if (count > 0)
                        {
                            sumaDiv = (suma / count);
                        }

                        if (sumaDiv > 0 && sumaDiv < 100)
                        {
                            dataBD.CodEstadoAccion = "03";
                        }

                        else if (sumaDiv >= 100)
                        {
                            dataBD.CodEstadoAccion = "02";
                        }

                        else
                        {
                            dataBD.CodEstadoAccion = "01";
                        }
                        _context.TAccion.Update(dataBD);
                        await _context.SaveChangesAsync(cancellationToken);
                    }
                }
                return(Unit.Value);
            }
Beispiel #4
0
            public async Task <Unit> Handle(CreatePlanAccionCommand request, CancellationToken cancellationToken)
            {
                //var data = await _context.TTipoAccion.FirstOrDefaultAsync(i => i.CodTipoAccion == request.CodTipoAccion);//.Distinct().OrderBy(x => x);*//*.Skip(0).Take(10);*/
                DateTime       date         = DateTime.Today;
                IList <PlanVM> planesAccion = request.planes;
                TAccion        data;

                foreach (var plan in planesAccion)
                {
                    bool validador = !String.IsNullOrEmpty(plan.docReferencia) &&
                                     !String.IsNullOrEmpty(plan.docSubReferencia) &&
                                     !String.IsNullOrEmpty(plan.tarea) &&
                                     !String.IsNullOrEmpty(plan.codSolicitadoPor);

                    if (validador)
                    {
                        data = new TAccion();
                        //data.CodEstadoAccion = plan.codEstadoAccion;
                        data.CodAreaHsec        = plan.codAreaHsec;
                        data.CodTipoAccion      = plan.codTipoAccion;
                        data.FechaSolicitud     = plan.fechaSolicitud;
                        data.CodActiRelacionada = plan.codActiRelacionada;
                        data.CodSolicitadoPor   = plan.codSolicitadoPor;
                        data.DocReferencia      = plan.docReferencia;

                        data.DocSubReferencia = plan.docSubReferencia;
                        data.CodNivelRiesgo   = plan.codNivelRiesgo;
                        data.Tarea            = plan.tarea;
                        data.FechaInicial     = plan.fechaInicial;
                        data.FechaFinal       = plan.fechaFinal;
                        data.Estado           = true;

                        data.CodTablaRef      = plan.codTablaRef;
                        data.CodEstadoAccion  = "01";
                        data.Aprobador        = plan.Aprobador;
                        data.EstadoAprobacion = "P";

                        data.CreadoPor     = "admin";
                        data.Creado        = date;
                        data.ModificadoPor = "admin";
                        data.Modificado    = date;

                        TResponsable resp;

                        var responsables = plan.RespPlanAccion;
                        foreach (var it in responsables)
                        {
                            resp            = new TResponsable();
                            resp.CodPersona = it.codPersona;
                            data.RespPlanAccion.Add(resp);
                        }

                        _context.TAccion.Add(data);
                        await _context.SaveChangesAsync(cancellationToken);

                        //var r1 = await _persons.CreateAprobacionPlan(data.CodAccion, data.DocReferencia, data.CodTablaRef);
                        var r1 = await _mediator.Send(new AprobacionPlanCreateCommand()
                        {
                            CodAccion = data.CodAccion, DocReferencia = data.DocReferencia, CodTabla = data.CodTablaRef
                        });

                        int verificador       = _context.TAccion.Count();
                        var ultCodCorrelativo = 1;
                        if (verificador > 0)
                        {
                            ultCodCorrelativo = _context.TAccion.Max(p => p.CodAccion);
                        }
                        //TLevantamientoPlan lev;
                        //foreach (var it in responsables)
                        //{
                        //    lev = new TLevantamientoPlan();
                        //    lev.CodAccion = ultCodCorrelativo;
                        //    lev.CodPersona = it.codPersona;
                        //    lev.PorcentajeAvance = 0;
                        //    lev.Estado = true;
                        //    _context.TLevantamientoPlan.Add(lev);
                        //}
                        await _context.SaveChangesAsync(cancellationToken);
                    }

                    else
                    {
                        new GeneralFailureException("Verifique los datos ingresados .. ojo: no deben ser vacios !");
                    }
                }
                return(Unit.Value);
            }