Пример #1
0
        public static async Task <Response <InformeResponse> > UpdateInformeTareasReasignarInforme(int IdInformeNuevo, int IdInformeAnterior, int IdTarea)
        {
            Response <InformeResponse> response;

            try
            {
                byte estadoActivo = Constants.EstadosInforme.ACTIVO;

                await InformeTareasData.UpdateInformeTareasReasignarInforme(IdInformeNuevo, IdInformeAnterior, IdTarea, estadoActivo);

                response = new Response <InformeResponse>
                {
                    EsCorrecto = true,
                    Valor      = new InformeResponse
                    {
                        Informe = new InformeEntity()
                    },
                    Mensaje = "OK",
                    Estado  = true,
                };

                return(response);
            }
            catch (FaultException <ServiceError> )
            {
                throw;
            }
            catch (Exception ex)
            {
                return(new Response <InformeResponse>(false, null, Functions.MessageError(ex), false));
            }
        }
Пример #2
0
        public static async Task <Response <InformeResponse> > DeleteInformeTareas(int IdInforme, int IdTarea, int IdTipMan, string AreCodigo)
        {
            Response <InformeResponse> response;

            try
            {
                await InformeTareasData.DeleteInformeTareas(IdInforme, IdTarea);

                await ControlUnidadTipoMantenimientoData.AnularControlUnidadMantenimiento(IdTipMan, AreCodigo);

                response = new Response <InformeResponse>
                {
                    EsCorrecto = true,
                    Valor      = new InformeResponse
                    {
                        Informe = new InformeEntity()
                    },
                    Mensaje = "OK",
                    Estado  = true,
                };

                return(response);
            }
            catch (FaultException <ServiceError> )
            {
                throw;
            }
            catch (Exception ex)
            {
                return(new Response <InformeResponse>(false, null, Functions.MessageError(ex), false));
            }
        }
Пример #3
0
        public static Response <InformeResponse> ListInformeOrdenMantenimiento(int IdInforme)
        {
            try
            {
                Response <InformeResponse>           response;
                List <InformeOrdenMantenimientoList> List;

                List = InformeTareasData.ListInformeOrdenMantenimiento(IdInforme);

                response = new Response <InformeResponse>
                {
                    EsCorrecto = true,
                    Valor      = new InformeResponse {
                        ListInformeOrdenMantenimiento = List
                    },
                    Mensaje = "OK",
                    Estado  = true,
                };

                return(response);
            }
            catch (Exception ex)
            {
                return(new Response <InformeResponse>(false, null, Functions.MessageError(ex), false));
            }
        }
Пример #4
0
        public static async Task <Response <OrdenMasivaResponse> > InsertTareasSistemas(TareaSistemaRequest request)
        {
            Response <OrdenMasivaResponse> response;

            try
            {
                XElement xmlElements = new XElement("Root",
                                                    request.ListInsertar.Select(i => new XElement("Tareas",
                                                                                                  new XAttribute("IdTarea", i.IdTarea), i.IdTarea))
                                                    );

                await InformeTareasData.InsertTareasSistemas(request.Are_Codigo, request.IdClaseMantenimiento, request.Operacion, xmlElements.ToString());

                response = new Response <OrdenMasivaResponse>
                {
                    EsCorrecto = true,
                    Valor      = new OrdenMasivaResponse
                    {
                        List = new List <OrdenMasivaList>()
                    },
                    Mensaje = "OK",
                    Estado  = true,
                };

                return(response);
            }
            catch (FaultException <ServiceError> )
            {
                throw;
            }
            catch (Exception ex)
            {
                return(new Response <OrdenMasivaResponse>(false, null, Functions.MessageError(ex), false));
            }
        }
Пример #5
0
        public static async Task <Response <InformeResponse> > InsertInformeTareas(InformeRequest request)
        {
            Response <InformeResponse> response;
            InformeTareasEntity        objInformeTareas;
            List <InformeTareasList>   objInformeTareasAnteriorActivo;
            List <InformeTareasList>   objInformeTareasAnteriorInactivo;

            try
            {
                objInformeTareas = request.InformeTareas;
                objInformeTareasAnteriorActivo   = InformeTareasData.ListInformeTareas(objInformeTareas.IdInforme, objInformeTareas.IdTarea);
                objInformeTareasAnteriorInactivo = InformeTareasData.ListInformeTareas(objInformeTareas.IdInforme, objInformeTareas.IdTarea, 0);

                if (objInformeTareasAnteriorActivo.Count > 0)
                {
                    BusinessException.Generar(Constants.YA_EXISTE);
                }
                else if (objInformeTareasAnteriorInactivo.Count > 0)
                {
                    await InformeTareasData.DeleteInformeTareas(objInformeTareas.IdInforme, objInformeTareas.IdTarea, 1, objInformeTareas.Observacion);
                }
                else
                {
                    await InformeTareasData.InsertInformeTareas(objInformeTareas);
                }

                response = new Response <InformeResponse>
                {
                    EsCorrecto = true,
                    Valor      = new InformeResponse
                    {
                        Informe = new InformeEntity()
                    },
                    Mensaje = "OK",
                    Estado  = true,
                };

                return(response);
            }
            catch (Exception ex)
            {
                throw;
            }
        }
Пример #6
0
        public static async Task <Response <InformeResponse> > UpdateInformeTareasEstado(int IdInforme, int IdTarea, int Estado)
        {
            Response <InformeResponse> response;

            try
            {
                await InformeTareasData.UpdateInformeTareasEstado(IdInforme, IdTarea, Convert.ToByte(Estado));

                if (Estado == Constants.EstadosInforme.ANULADO)
                {
                    var objInformeTarea = InformeTareasData.ListInformeTareas(IdInforme, IdTarea, 99)[0];
                    var objInforme      = InformeData.SelectInforme(IdInforme);
                    await ControlUnidadTipoMantenimientoData.AnularControlUnidadMantenimiento(objInformeTarea.IdTipMan, objInforme.Are_Codigo);
                }

                response = new Response <InformeResponse>
                {
                    EsCorrecto = true,
                    Valor      = new InformeResponse
                    {
                        Informe = new InformeEntity()
                    },
                    Mensaje = "OK",
                    Estado  = true,
                };

                return(response);
            }
            catch (FaultException <ServiceError> )
            {
                throw;
            }
            catch (Exception ex)
            {
                return(new Response <InformeResponse>(false, null, Functions.MessageError(ex), false));
            }
        }
Пример #7
0
        public static Response <InformeResponse> ListInformeTareasBackLog(string IdUnidad, string Tipo)
        {
            try
            {
                Response <InformeResponse> response;
                List <InformeTareasList>   List;

                List = new List <InformeTareasList>();

                if (Tipo == Constants.TipoInforme.CORRECTIVO)
                {
                    List = InformeTareasData.ListInformeTareasBackLogCorrectivo(IdUnidad);
                }
                else
                {
                    List = InformeTareasData.ListInformeTareasBackLogPreventivo(IdUnidad);
                }



                response = new Response <InformeResponse>
                {
                    EsCorrecto = true,
                    Valor      = new InformeResponse {
                        ListInformeTareas = List
                    },
                    Mensaje = "OK",
                    Estado  = true,
                };

                return(response);
            }
            catch (Exception ex)
            {
                return(new Response <InformeResponse>(false, null, Functions.MessageError(ex), false));
            }
        }
Пример #8
0
        public static async Task <Response <OrdenMasivaResponse> > InsertPreventivo(OrdenMasivaRequest request)
        {
            Response <OrdenMasivaResponse> response;
            List <OrdenMasivaList>         ListInsertar;
            string                      FechaGenerar;
            decimal                     klm_acumulado;
            DateTime                    fechaRegistro;
            string                      usuarioRegistro;
            string                      are_codigo;
            int                         idMaxRevision;
            int                         idMaxInforme;
            decimal                     idNumInforme;
            InformeEntity               objInforme;
            ProgramacionEntity          objProgramacion;
            List <TareasPendientesList> listTareasPendientes;
            InformeTareasEntity         objInformeTareas;

            ListInsertar    = request.ListInsertar;
            FechaGenerar    = request.FechaGenerar;
            fechaRegistro   = DateTime.Now;
            usuarioRegistro = request.UsuarioRegistro;

            try
            {
                foreach (var item in ListInsertar)
                {
                    if (!item.Correctivo)
                    {
                        continue;
                    }
                    if (item.Preventivo)
                    {
                        continue;
                    }

                    are_codigo    = item.IdUnidad;
                    klm_acumulado = AreData.SelectAre(are_codigo).Klm_Acumulados;
                    idMaxRevision = SolicitudRevisionTecnicaData.ObtenerUltimoId();

                    objInforme = new InformeEntity
                    {
                        Are_Codigo           = item.IdUnidad,
                        ChoferEntrega        = item.IDChofer,
                        KmUnidad             = klm_acumulado,
                        Ofi_Codigo           = Convert.ToInt32(item.CodOrigen).ToString("00#"),
                        Fecha                = Convert.ToDateTime(FechaGenerar),
                        CostoManoObra        = 0,
                        CostoRepuestos       = 0,
                        ServicioTerceros     = 0,
                        Observacion          = "",
                        IdUndAlerta          = 0,
                        IdPlanEjecucionTarea = "",
                        Tipo            = "0",
                        UsuarioRegistro = Convert.ToInt16(usuarioRegistro)
                    };

                    idMaxInforme = InformeData.InsertInforme(objInforme);
                    idNumInforme = Convert.ToDecimal(item.NumeroOrden);

                    objProgramacion = new ProgramacionEntity
                    {
                        CODI_PROGRAMACION  = item.Codi_Programacion,
                        NumeroMantenimieto = idNumInforme.ToString(),
                    };

                    await InformeData.UpdateInforme_NumInforme(idMaxInforme, idNumInforme);

                    await ProgramacionData.UpdateProgramacionOrdenPreventivoGeneracion(objProgramacion);

                    //Tareas pendientes
                    listTareasPendientes = TipoMantenimientoData.ListTareasPendientes(are_codigo);

                    foreach (var itemTareasPendientes in listTareasPendientes)
                    {
                        objInformeTareas = new InformeTareasEntity
                        {
                            FechaInicio     = FechaGenerar,
                            IdInforme       = idMaxInforme,
                            IdTarea         = itemTareasPendientes.IdTarea,
                            Observacion     = "",
                            UsuarioRegistro = Convert.ToInt32(usuarioRegistro)
                        };

                        await InformeTareasData.InsertInformeTareas(objInformeTareas);

                        await InformeTareasData.UpdateInformeTareasKilometraje(idMaxInforme, itemTareasPendientes.IdTarea, itemTareasPendientes.KmtActual);
                    }
                }

                response = new Response <OrdenMasivaResponse>
                {
                    EsCorrecto = true,
                    Valor      = new OrdenMasivaResponse
                    {
                        List = new List <OrdenMasivaList>()
                    },
                    Mensaje = "OK",
                    Estado  = true,
                };

                return(response);
            }
            catch (FaultException <ServiceError> )
            {
                throw;
            }
            catch (Exception ex)
            {
                return(new Response <OrdenMasivaResponse>(false, null, Functions.MessageError(ex), false));
            }
        }