public async Task <Unit> Handle(ToleranciaCeroUpdateCommand request, CancellationToken cancellationToken)
            {
                var tolerancia = _context.ToleranciaCero.Include(p => p.ToleranciaPersonas).Include(c => c.ToleranciaAnalisisCausa).Include(r => r.ToleranciaReglas).First(t => t.CodTolCero.Equals(request.CodTolCero));

                tolerancia.FechaTolerancia = request.FechaTolerancia;
                tolerancia.CodPosicionGer  = request.CodPosicionGer;
                tolerancia.CodPosicionSup  = request.CodPosicionSup;
                tolerancia.Proveedor       = request.Proveedor;
                tolerancia.AntTolerancia   = request.AntTolerancia;
                tolerancia.IncumpDesc      = request.IncumpDesc;
                tolerancia.ConsecReales    = request.ConsecReales;
                tolerancia.ConsecPot       = request.ConsecPot;
                tolerancia.ConclusionesTol = request.ConclusionesTol;
                tolerancia.CodDetSancion   = request.CodDetSancion;

                //PERSONAS
                tolerancia.ToleranciaPersonas = tolerancia.ToleranciaPersonas.Where(p => p.Estado == true).ToList();

                var interPersonas = tolerancia.ToleranciaPersonas.Select(x => x.CodPersona).Intersect(request.Personas).ToList(); //update
                var leftPersonas  = request.Personas.Except(tolerancia.ToleranciaPersonas.Select(x => x.CodPersona)).ToList();    //new
                var rightPersonas = tolerancia.ToleranciaPersonas.Select(x => x.CodPersona).Except(request.Personas).ToList();    //delete

                foreach (var CodPersona in interPersonas)
                {
                    var pm = tolerancia.ToleranciaPersonas.First(t => t.CodPersona.Equals(CodPersona));
                    pm.Estado = true;
                }

                foreach (var CodPersona in leftPersonas)
                {
                    TPersonaToleranciaDto toleranciapersona = new TPersonaToleranciaDto();
                    toleranciapersona.CodPersona = CodPersona;
                    var _toleranciapersona = _mapper.Map <TPersonaToleranciaDto, TPersonaTolerancia>(toleranciapersona);
                    tolerancia.ToleranciaPersonas.Add(_toleranciapersona);
                }

                foreach (var CodPersona in rightPersonas)
                {
                    var pm = tolerancia.ToleranciaPersonas.First(t => t.CodPersona.Equals(CodPersona));
                    pm.Estado = false;
                }


                //CAUSAS
                tolerancia.ToleranciaAnalisisCausa = tolerancia.ToleranciaAnalisisCausa.Where(a => a.Estado == true).ToList();

                var interCausas = tolerancia.ToleranciaAnalisisCausa.Select(x => x.CodAnalisis).Intersect(request.Causas.Select(c => c.CodAnalisis)).ToList(); //update
                var leftCausas  = request.Causas.Select(c => c.CodAnalisis).Except(tolerancia.ToleranciaAnalisisCausa.Select(x => x.CodAnalisis)).ToList();    //new
                var rightCausas = tolerancia.ToleranciaAnalisisCausa.Select(x => x.CodAnalisis).Except(request.Causas.Select(c => c.CodAnalisis)).ToList();    //delete

                foreach (var CodAnalisis in interCausas)
                {
                    var causa = request.Causas.First(c => c.CodAnalisis.Equals(CodAnalisis));
                    var cm    = tolerancia.ToleranciaAnalisisCausa.First(t => t.CodAnalisis.Equals(CodAnalisis));
                    cm.Comentario = causa.Comentario;
                    cm.Estado     = true;
                }

                foreach (var CodAnalisis in leftCausas)
                {
                    var causa = request.Causas.First(c => c.CodAnalisis.Equals(CodAnalisis));
                    TToleranciaCeroAnalisisCausaDto toleranciaanalisis = new TToleranciaCeroAnalisisCausaDto();
                    toleranciaanalisis.CodAnalisis = CodAnalisis;
                    toleranciaanalisis.Comentario  = causa.Comentario;
                    var _toleranciaanalisis = _mapper.Map <TToleranciaCeroAnalisisCausaDto, TToleranciaCeroAnalisisCausa>(toleranciaanalisis);
                    tolerancia.ToleranciaAnalisisCausa.Add(_toleranciaanalisis);
                }

                foreach (var CodAnalisis in rightCausas)
                {
                    var cm = tolerancia.ToleranciaAnalisisCausa.First(t => t.CodAnalisis.Equals(CodAnalisis));
                    cm.Comentario = "";
                    cm.Estado     = false;
                }

                //REGLAS
                tolerancia.ToleranciaReglas = tolerancia.ToleranciaReglas.Where(r => r.Estado == true).ToList();

                var interReglas = tolerancia.ToleranciaReglas.Select(x => x.CodRegla).Intersect(request.Reglas).ToList(); //update
                var leftReglas  = request.Reglas.Except(tolerancia.ToleranciaReglas.Select(x => x.CodRegla)).ToList();    //new
                var rightReglas = tolerancia.ToleranciaReglas.Select(x => x.CodRegla).Except(request.Reglas).ToList();    //delete

                foreach (var CodRegla in interReglas)
                {
                    var rm = tolerancia.ToleranciaReglas.First(t => t.CodRegla.Equals(CodRegla));
                    rm.Estado = true;
                }

                foreach (var CodRegla in leftReglas)
                {
                    TRegTolDetalleDto toleranciaregla = new TRegTolDetalleDto();
                    toleranciaregla.CodRegla = CodRegla;
                    var _toleranciaregla = _mapper.Map <TRegTolDetalleDto, TRegTolDetalle>(toleranciaregla);
                    tolerancia.ToleranciaReglas.Add(_toleranciaregla);
                }

                foreach (var CodRegla in rightReglas)
                {
                    var rm = tolerancia.ToleranciaReglas.First(t => t.CodRegla.Equals(CodRegla));
                    rm.Estado = false;
                }

                _context.ToleranciaCero.Update(tolerancia);
                //_context.TUsuario.Remove(user);
                await _context.SaveChangesAsync(cancellationToken);

                return(Unit.Value);
            }
            public async Task <Unit> Handle(ToleranciaCeroInsertCommand request, CancellationToken cancellationToken)
            {
                try
                {
                    ToleranciaCeroDto nuevo  = new ToleranciaCeroDto();
                    string            maxCod = _context.ToleranciaCero.Max(t => t.CodTolCero);
                    if (maxCod == null)
                    {
                        maxCod = "TOL00000001";
                    }
                    else
                    {
                        int id = int.Parse(maxCod.Substring(3, 8)) + 1;
                        maxCod = "TOL" + id.ToString("D8");
                    }

                    nuevo.CodTolCero      = maxCod;
                    nuevo.FechaTolerancia = request.FechaTolerancia;
                    nuevo.CodPosicionGer  = request.CodPosicionGer;
                    nuevo.CodPosicionSup  = request.CodPosicionSup;
                    nuevo.Proveedor       = request.Proveedor;
                    nuevo.AntTolerancia   = request.AntTolerancia;
                    nuevo.IncumpDesc      = request.IncumpDesc;
                    nuevo.ConsecReales    = request.ConsecReales;
                    nuevo.ConsecPot       = request.ConsecPot;
                    nuevo.ConclusionesTol = request.ConclusionesTol;
                    nuevo.CodDetSancion   = request.CodDetSancion;

                    foreach (string persona in request.Personas)
                    {
                        TPersonaToleranciaDto toleranciapersona = new TPersonaToleranciaDto();
                        toleranciapersona.CodPersona = persona;
                        nuevo.ToleranciaPersonas.Add(toleranciapersona);
                    }

                    foreach (var causa in request.Causas)
                    {
                        TToleranciaCeroAnalisisCausaDto analisiscausa = new TToleranciaCeroAnalisisCausaDto();
                        analisiscausa.CodAnalisis  = causa.CodAnalisis;
                        analisiscausa.Comentario   = causa.Comentario;
                        analisiscausa.CodCondicion = causa.CodCondicion;
                        nuevo.ToleranciaAnalisisCausa.Add(analisiscausa);
                    }

                    foreach (string regla in request.Reglas)
                    {
                        TRegTolDetalleDto reglatolerancia = new TRegTolDetalleDto();
                        reglatolerancia.CodRegla = regla;
                        nuevo.ToleranciaReglas.Add(reglatolerancia);
                    }

                    var tolerancia = _mapper.Map <ToleranciaCeroDto, TToleranciaCero>(nuevo);
                    _context.ToleranciaCero.Add(tolerancia);

                    await _context.SaveChangesAsync(cancellationToken);

                    return(Unit.Value);
                }catch (Exception e)
                {
                    throw e;
                }
            }