Exemple #1
0
        public async Task <int> GrabarMaeCargaActividad(McmaeCargaForDos McmaeCargaForDos)
        {
            int codigo = 0;

            try
            {
                await context.McmaeCargaForDos.AddAsync(McmaeCargaForDos);

                codigo = await context.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
                throw new Exception(ex.Message);
            }
            return(codigo);
        }
        public async Task <PedidoTrabajoAccionesResponse> ResponderInconvenientePT(MCMovBanPTRequest request)
        {
            try
            {
                //MovBand
                var maxIdBan = await context.McmovBanPt.Where(m => m.INumIdPt == request.iNumIdPT &&
                                                              m.INumDetPt == request.iNumDetPT &&
                                                              m.BEstRegistro == true).MaxAsync(b => (int?)b.INumDesBanPt) ?? 0;

                var mov = await context.McmovBanPt.Where(m => m.INumIdPt == request.iNumIdPT &&
                                                         m.INumDetPt == request.iNumDetPT &&
                                                         m.BEstRegistro == true &&
                                                         m.INumDesBanPt == maxIdBan).AsNoTracking().FirstOrDefaultAsync() ?? null;

                var MCMovBanPT = new McmovBanPt
                {
                    BEstRegistro       = true,
                    INumIdPt           = request.iNumIdPT,
                    INumDetPt          = request.iNumDetPT,
                    SdFecCreacion      = DateTime.Now,
                    VCodUsuCreacion    = request.vCodUsuarioCreacion,
                    INumDesBanPt       = maxIdBan == 0 ? 1 : maxIdBan + 1,
                    CTipBandeja        = "2",
                    CEstBandeja        = "1",
                    ICodTraResponsable = mov.ICodTraResponsable,
                    vContenido         = request.Mensaje,
                    SdFecIngreso       = DateTime.Now,
                    CNomTerCreacion    = request.Terminal
                };


                await context.McmovBanPt.AddAsync(MCMovBanPT);

                await context.SaveChangesAsync();

                mov.SdFecFinalizacion   = DateTime.Now;
                mov.VCodUsuModificacion = request.vCodUsuarioCreacion;
                mov.CNomTerModificacion = request.Terminal;
                mov.SdFecModificacion   = DateTime.Now;
                mov.CEstBandeja         = "2";

                context.McmovBanPt.Update(mov);
                await context.SaveChangesAsync();

                if (request.Rutas != null)
                {
                    if (request.Rutas.Count() > 0)
                    {
                        foreach (var ruta in request.Rutas)
                        {
                            var maxIdAdj = await context.McmaeAdjPt.Where(m => m.INumIdPt == request.iNumIdPT &&
                                                                          m.INumDetPt == request.iNumDetPT &&
                                                                          m.BEstRegistro == true).MaxAsync(b => (int?)b.INumDetAdjT) ?? 0;

                            var adjunto = new McmaeAdjPt
                            {
                                INumIdPt        = request.iNumIdPT,
                                INumDetPt       = request.iNumDetPT,
                                SdFecCreacion   = DateTime.Now,
                                CNomTerCreacion = request.Terminal,
                                INumDetAdjT     = maxIdAdj == 0 ? 1 : maxIdAdj + 1,
                                VRutaAdjunto    = ruta,
                                ITipAdjunto     = 2,
                                BEstRegistro    = true,
                                VCodUsuCreacion = request.vCodUsuarioCreacion
                            };

                            await context.McmaeAdjPt.AddAsync(adjunto);

                            await context.SaveChangesAsync();
                        }
                    }
                }

                if (!string.IsNullOrEmpty(request.Email))
                {
                    var mailRequest = new McSendMailRequest
                    {
                        Asunto           = "Se ha registrado una incidencia para el pedido de trabajo " + request.PedidoTrabajo,
                        Texto_Notificar  = !string.IsNullOrEmpty(request.Mensaje) ? request.Mensaje : "Se ha registrado una incidencia para el pedido de trabajo " + request.PedidoTrabajo,
                        Cuenta_Notificar = request.Email,
                        Cuentas_Copias   = "",
                        Profile_Correo   = ""
                    };
                    //Descomentar la línea siguiente para enviar correo electrónico al responsable
                    SendMail(mailRequest);
                }

                return(new PedidoTrabajoAccionesResponse
                {
                    Exito = true,
                    Mensaje = "Operacion realizada exitosamente"
                });
            }
            catch (Exception ex)
            {
                return(new PedidoTrabajoAccionesResponse
                {
                    Exito = false,
                    Mensaje = "Ha ocurrido un error inesperado " + ex.Message
                });
            }
        }
        public async Task <McdetCargaForDosEdicionResponse> Edicion(McdetCargaForDosEdicionRequest request)
        {
            try
            {
                int actualizadoCorrectamente = 0;
                var McdetCargaForDosEdicion  = await context.McdetCargaForDos.Where(x => x.INumCarga == request.NumCarga &&
                                                                                    x.INumDetCarga == request.CodigoDetalle).AsNoTracking().FirstOrDefaultAsync();

                if (McdetCargaForDosEdicion != null)
                {
                    McdetCargaForDosEdicion.VRuc             = request.Ruc;
                    McdetCargaForDosEdicion.VRazSocial       = request.RazonSocial;
                    McdetCargaForDosEdicion.VZonEspecifica   = request.ZonaEspecifica;
                    McdetCargaForDosEdicion.VPrioridad       = request.Prioridad;
                    McdetCargaForDosEdicion.VPerIntervencion = request.PermisoInt;

                    context.McdetCargaForDos.Update(McdetCargaForDosEdicion);
                    actualizadoCorrectamente = await context.SaveChangesAsync();
                }
                if (!string.IsNullOrEmpty(request.Trabajadores))
                {
                    //var pt = await context.McmaePt.Where(t => t.VNumPt == McdetCargaForDosEdicion.VNumPt).AsNoTracking().FirstOrDefaultAsync();

                    var trab = request.Trabajadores.Split(',');
                    var trabajadoresToDisable = await context.McmaeCargaTraForDos.Where(x => x.INumCarga == request.NumCarga &&
                                                                                        x.INumDetCarga == request.CodigoDetalle &&
                                                                                        !trab.Contains(x.ICodTrabjador.ToString()) &&
                                                                                        x.BEstRegistro == true).AsNoTracking().ToListAsync();

                    foreach (var item in trab)
                    {
                        var traForDos = await context.McmaeCargaTraForDos.Where(x => x.INumCarga == request.NumCarga &&
                                                                                x.INumDetCarga == request.CodigoDetalle &&
                                                                                x.ICodTrabjador == int.Parse(item)).AsNoTracking().FirstOrDefaultAsync();

                        if (traForDos == null)
                        {
                            McmaeCargaTraForDos tpt = new McmaeCargaTraForDos
                            {
                                INumCarga       = request.NumCarga,
                                INumDetCarga    = request.CodigoDetalle,
                                BEstRegistro    = true,
                                VCodUsuCreacion = request.Usuario,
                                SdFecCreacion   = DateTime.Now,
                                CNomTerCreacion = request.NombreTerminal,
                                ICodTrabjador   = int.Parse(item)
                            };

                            await context.McmaeCargaTraForDos.AddAsync(tpt);

                            await context.SaveChangesAsync();
                        }
                        else
                        {
                            traForDos.CNomTerModificacion = request.NombreTerminal;
                            traForDos.VCodUsuModificacion = request.Usuario;
                            traForDos.SdFecModificacion   = DateTime.Now;
                            traForDos.BEstRegistro        = true;

                            context.McmaeCargaTraForDos.Update(traForDos);
                            int r = await context.SaveChangesAsync();
                        }
                    }

                    if (trabajadoresToDisable != null)
                    {
                        foreach (var item in trabajadoresToDisable)
                        {
                            item.BEstRegistro = false;
                            context.McmaeCargaTraForDos.Update(item);
                            int r = await context.SaveChangesAsync();
                        }
                    }
                }
                if (actualizadoCorrectamente > 0)
                {
                    return(new McdetCargaForDosEdicionResponse
                    {
                        Exito = true,
                        Mensaje = "Detalle de carga fue actualizado exitosamente."
                    });
                }
                else
                {
                    return(new McdetCargaForDosEdicionResponse
                    {
                        Exito = false,
                        Mensaje = "Detalle de carga no fue actualizado correctamente."
                    });
                }
            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
                throw new Exception(ex.Message);
            }
        }
        public async Task <PedidoTrabajoAccionesResponse> IniciarPedidoTrabajo(MCMovEstadoPTRequest request)
        {
            try
            {
                var inconvenienteNotRespons = await context.McmovBanPt.Where(m => m.INumIdPt == request.iNumIdPT &&
                                                                             m.INumDetPt == request.iNumDetPT &&
                                                                             m.CEstBandeja == "1" &&
                                                                             m.CTipBandeja == "1" &&
                                                                             m.BEstRegistro == true).AsNoTracking().AsNoTracking().FirstOrDefaultAsync();

                if (inconvenienteNotRespons == null)
                {
                    var maxIdEst = await context.McmovEstPt.Where(m => m.INumIdPt == request.iNumIdPT &&
                                                                  m.INumDetPt == request.iNumDetPT &&
                                                                  m.BEstRegistro == true).MaxAsync(m => (int?)m.INumDetEstPt) ?? 0;

                    var MCMovEstadoPT = new McmovEstPt
                    {
                        BEstRegistro    = true,
                        CEstPt          = "E",
                        INumIdPt        = request.iNumIdPT,
                        INumDetPt       = request.iNumDetPT,
                        SdFecCreacion   = DateTime.Now,
                        SdFecIniEstado  = DateTime.Now,
                        VCodUsuCreacion = request.vCodUsuarioCreacion,
                        INumDetEstPt    = maxIdEst == 0 ? 1 : maxIdEst + 1,
                        CNomTerCreacion = request.Terminal
                    };


                    await context.McmovEstPt.AddAsync(MCMovEstadoPT);

                    await context.SaveChangesAsync();

                    var McMaePT = await context.McmaePt.Where(x => x.INumIdPt == request.iNumIdPT).AsNoTracking().FirstOrDefaultAsync();

                    McMaePT.CEstPt = "E";
                    McMaePT.VCodUsuModificacion = request.vCodUsuarioCreacion;
                    McMaePT.SdFecModificacion   = DateTime.Now;
                    McMaePT.CNomTerModificacion = request.Terminal;

                    context.McmaePt.Update(McMaePT);
                    await context.SaveChangesAsync();

                    return(new PedidoTrabajoAccionesResponse
                    {
                        Exito = true,
                        Mensaje = "Operacion realizada exitosamente"
                    });
                }
                else
                {
                    return(new PedidoTrabajoAccionesResponse
                    {
                        Exito = false,
                        Mensaje = "PT tiene incidente pendiente de responder "
                    });
                }
            }
            catch (Exception ex)
            {
                return(new PedidoTrabajoAccionesResponse
                {
                    Exito = false,
                    Mensaje = "Ha ocurrido un error inesperado " + ex.InnerException.Message
                });
            }
        }