public static String DesaprobarHojaDeRuta(string IdCabecera, string IdUsuario)
    {
        using (EntidadesConosud dc = new EntidadesConosud())
        {
            long id     = long.Parse(IdCabecera);
            long idusua = long.Parse(IdUsuario);

            Entidades.CabeceraHojasDeRuta cab = (from c in dc.CabeceraHojasDeRuta
                                                 where c.IdCabeceraHojasDeRuta == id
                                                 select c).FirstOrDefault();


            cab.FechaAprobacion           = null;
            cab.FechaAprobacionSinLegajos = null;
            cab.SegUsuario = null;
            cab.Estado     = (from E in dc.Clasificacion
                              where E.Tipo == "EstadoHoja" && E.Descripcion == "No Aprobada"
                              select E).FirstOrDefault();


            dc.SaveChanges();


            return("DESAPROBADA");
        }
    }
        public void InitReport(CabeceraHojasDeRuta Cabecera, bool EsHistorico)
        {
            string periodo = String.Format("{0:yyyy/MM}", Cabecera.Periodo);

            Cabecera.ContratoEmpresasReference.Load();
            Cabecera.ContratoEmpresas.ContratoReference.Load();
            Cabecera.ContratoEmpresas.EmpresaReference.Load();


            if (EsHistorico)
            {
                txtLeyendaEncabezado.Value = "Luego de recibida y controlada la documentación por el contrato " + Cabecera.ContratoEmpresas.Contrato.Codigo +
                                             " de la empresa " + Cabecera.ContratoEmpresas.Empresa.RazonSocial + " y subcontratistas (si tuviese), por el período " + periodo +
                                             " y meses anteriores, si corresponde, se informa a continuación los pendientes:";
            }
            else
            {
                txtLeyendaEncabezado.Value = "Luego de recibida y controlada la documentación por el contrato " + Cabecera.ContratoEmpresas.Contrato.Codigo +
                                             " de la empresa " + Cabecera.ContratoEmpresas.Empresa.RazonSocial + " y subcontratistas (si tuviese), por el período " + periodo +
                                             ", se informan a continuación los pendientes:";
            }



            this.ReportParameters[0].Value = periodo;

            List <Entidades.HojasDeRuta> HojasConComentarios = (from H in Cabecera.HojasDeRuta
                                                                where H.HojaComentario != null && H.HojaComentario.Trim() != ""
                                                                select H).ToList();

            //this.DataSource = HojasConComentarios;
            DataSouece = HojasConComentarios;
        }
    public static object UpdateDataItem(IDictionary <string, object> item, long id)
    {
        long             idcabecera = 0;
        EntidadesConosud _dc        = new EntidadesConosud();

        Entidades.HojasDeRuta itemsHoja = (from H in _dc.HojasDeRuta
                                           where H.IdHojaDeRuta == id
                                           select H).First <Entidades.HojasDeRuta>();

        if (item["FechaEntrega"] != null)
        {
            itemsHoja.DocFechaEntrega = DateTime.Parse(item["FechaEntrega"].ToString());
        }
        else
        {
            itemsHoja.DocFechaEntrega = null;
        }

        itemsHoja.DocComentario = item["Comentario"].ToString();

        /// al presnetar documentación para una hoja de ruta que esta publicada
        /// se des-publica automaticamente.
        itemsHoja.CabeceraHojasDeRuta.Publicar = false;
        idcabecera = itemsHoja.CabeceraHojasDeRuta.IdCabeceraHojasDeRuta;


        if (itemsHoja.CabeceraHojasDeRuta != null)
        {
            Entidades.CabeceraHojasDeRuta cab = itemsHoja.CabeceraHojasDeRuta;
            if (!itemsHoja.CabeceraHojasDeRuta.ContratoEmpresas.EsContratista.Value)
            {
                cab = (from c in _dc.CabeceraHojasDeRuta
                       where c.ContratoEmpresas.Contrato.IdContrato == itemsHoja.CabeceraHojasDeRuta.ContratoEmpresas.Contrato.IdContrato &&
                       c.ContratoEmpresas.EsContratista.Value && c.Periodo == itemsHoja.CabeceraHojasDeRuta.Periodo
                       select c).First <Entidades.CabeceraHojasDeRuta>();
            }

            string estado = UpdateSeguimientoAuditoria(cab.IdCabeceraHojasDeRuta, cab.Periodo, cab.ContratoEmpresas.IdContratoEmpresas);

            cab.EstadoAlCierre = estado != "" ? estado : cab.EstadoAlCierre;
        }


        _dc.SaveChanges();

        return((from H in _dc.HojasDeRuta
                where H.CabeceraHojasDeRuta.IdCabeceraHojasDeRuta == idcabecera
                orderby H.Plantilla.Codigo
                select new
        {
            IdHoja = H.IdHojaDeRuta,
            Titulo = H.Plantilla.Descripcion,
            FechaEntrega = H.DocFechaEntrega,
            FechaEntregaOriginal = H.DocFechaEntrega,
            Comentario = H.DocComentario,
            Presento = false
        }).ToList());
    }
    //protected void EntityDataSourceHojas_Updating(object sender, EntityDataSourceChangingEventArgs e)
    //{
    //    Entidades.HojasDeRuta _hoja = (Entidades.HojasDeRuta)e.Entity;
    //    _hoja.AuditadoPor = (Session["usuario"] as Entidades.SegUsuario).Login;
    //    _hoja.HojaFechaControlado = DateTime.Now;

    //    if (!_hoja.PlantillaReference.IsLoaded) { _hoja.PlantillaReference.Load(); }
    //    if (!_hoja.CabeceraHojasDeRutaReference.IsLoaded) { _hoja.CabeceraHojasDeRutaReference.Load(); }
    //    if (!_hoja.CabeceraHojasDeRuta.ContratoEmpresasReference.IsLoaded) { _hoja.CabeceraHojasDeRuta.ContratoEmpresasReference.Load(); }
    //    if (!_hoja.CabeceraHojasDeRuta.ContratoEmpresas.ComentariosGral.IsLoaded) { _hoja.CabeceraHojasDeRuta.ContratoEmpresas.ComentariosGral.Load(); }

    //    foreach (ComentariosGral item in _hoja.CabeceraHojasDeRuta.ContratoEmpresas.ComentariosGral)
    //    {
    //        if (!item.PlantillaReference.IsLoaded) { item.PlantillaReference.Load(); }
    //    }


    //    var CurrentComentario = (from C in _hoja.CabeceraHojasDeRuta.ContratoEmpresas.ComentariosGral
    //                             where C.Plantilla.IdPlantilla == _hoja.Plantilla.IdPlantilla
    //                             select C).FirstOrDefault<ComentariosGral>();


    //    if (CurrentComentario == null)
    //    {
    //        ComentariosGral coment = new ComentariosGral();
    //        coment.Comentario = _comentarioGralIngresado;
    //        coment.ContratoEmpresas = _hoja.CabeceraHojasDeRuta.ContratoEmpresas;
    //        coment.Plantilla = _hoja.Plantilla;
    //        e.Context.AddObject("ComentariosGral", coment);
    //    }
    //    else
    //    {

    //        CurrentComentario.Comentario = _comentarioGralIngresado;
    //    }

    //    e.Context.SaveChanges();

    //}

    protected void btnAplicarEstimacion_Click(object sender, EventArgs e)
    {
        Entidades.CabeceraHojasDeRuta cab = (from C in Contexto.CabeceraHojasDeRuta
                                             where C.IdCabeceraHojasDeRuta == CurrentTempCabecera.IdCaebcera
                                             select C).First();

        cab.Estimacion = txtEstimacion.Text;
        Contexto.SaveChanges();
    }
Beispiel #5
0
    protected void Page_Load(object sender, EventArgs e)
    {
        long             id = long.Parse(Request.QueryString["Id"].ToString());
        EntidadesConosud dc = new EntidadesConosud();

        Entidades.CabeceraHojasDeRuta cabecera = (from C in dc.CabeceraHojasDeRuta
                                                  .Include("HojasDeRuta")
                                                  where C.IdCabeceraHojasDeRuta == id
                                                  select C).First <Entidades.CabeceraHojasDeRuta>();

        InformexPeriodo rep = new InformexPeriodo();

        rep.InitReport(cabecera, false);
        this.ReportViewer1.Report = rep;
        (ReportViewer1.FindControl("ReportToolbar").FindControl("ExportGr").Controls[0].Controls[0] as DropDownList).ClearSelection();
        (ReportViewer1.FindControl("ReportToolbar").FindControl("ExportGr").Controls[0].Controls[0] as DropDownList).Items.FindByText("Excel").Selected = true;
    }
    protected void gvCabeceras_ItemDataBound(object sender, GridItemEventArgs e)
    {
        if (e.Item.ItemType == GridItemType.AlternatingItem || e.Item.ItemType == GridItemType.Item)
        {
            Entidades.CabeceraHojasDeRuta CurrentCabecera = (Entidades.CabeceraHojasDeRuta)e.Item.DataItem;
            //.Aprobada != "Aprobada" || CurrentCabecera.Aprobada != "Aprobada SL"
            if (CurrentCabecera.FechaAprobacion == null)
            {
                int SinDoc = (from H in CurrentCabecera.HojasDeRuta
                              where H.DocComentario != null &&
                              H.DocComentario.Trim() != ""
                              select H).Count();

                if (SinDoc == 0)
                {
                    /// Si no tiene comentarios de pendientes y no tiene todos los items aprobados,
                    /// entonces no se ha aprobado porque alguna de las sub contratistas
                    /// no esta aprobada y por lo tanto no puede aprobarce esta hoja.
                    int ItemsAprobados = CurrentCabecera.HojasDeRuta.Where(w => w.HojaAprobado.HasValue && w.HojaAprobado.Value).Count();
                    if (ItemsAprobados == 0)
                    {
                        (e.Item.FindControl("lblMotivo") as Label).Text = "No Presentó Documentación";
                    }
                    else
                    {
                        (e.Item.FindControl("lblMotivo") as Label).Text = "Por pendientes de Subcontratista";
                    }
                }


                int CantComentarios = (from H in CurrentCabecera.HojasDeRuta
                                       where H.HojaComentario != null &&
                                       H.HojaComentario.Trim() != ""
                                       select H).Count();


                if (CantComentarios > 0)
                {
                    (e.Item.FindControl("lblMotivo") as Label).Text = "Con Pendientes";
                }
            }
        }
    }
Beispiel #7
0
        public void InitReport(List <InformexPeriodoTemp> resultado, CabeceraHojasDeRuta Cabecera, bool EsHistorico)
        {
            EntidadesConosud dc = new EntidadesConosud();

            string periodo                = Cabecera.Periodo.Year.ToString() + "/" + string.Format("{0:00}", Cabecera.Periodo.Month);
            long   idContrato             = Cabecera.ContratoEmpresas.Contrato.IdContrato;
            string strSubContraristas     = "";
            string leyendaSubContratistas = "";


            var subcontratistas = from C in dc.ContratoEmpresas
                                  where C.Contrato.IdContrato == idContrato &&
                                  C.EsContratista == false
                                  select C.Empresa;

            foreach (Empresa emp in subcontratistas)
            {
                strSubContraristas += emp.RazonSocial + ", ";
            }

            if (strSubContraristas != "")
            {
                leyendaSubContratistas = ", y subcontratistas: " + strSubContraristas;
            }

            if (EsHistorico)
            {
                Leyenda = "Luego de realizado el control de la documentación de la empresa " + Cabecera.ContratoEmpresas.ConstratistaParaSubConstratista +
                          " por el contrato Nº " + Cabecera.ContratoEmpresas.Contrato.Codigo + " con VALE S.A., " +
                          "por el período " + periodo + " y meses anteriores" + leyendaSubContratistas + ", se informa a continuación el resultado:";
            }
            else
            {
                Leyenda = "Luego de realizado el control de la documentación de la empresa " + Cabecera.ContratoEmpresas.ConstratistaParaSubConstratista +
                          " por el contrato Nº " + Cabecera.ContratoEmpresas.Contrato.Codigo + " con VALE S.A., " +
                          "por el período " + periodo + " " + leyendaSubContratistas + ", se informa a continuación el resultado:";
            }

            DataSouece = resultado;
            //          this.DataSource = Helper.SerializeObject(resultado);
            textBox2.Value = System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(string.Format("{0:D}", DateTime.Now));
        }
    private static void GrabarAprobacion(Entidades.CabeceraHojasDeRuta cab, EntidadesConosud dc, long IdUsuario)
    {
        cab.FechaAprobacion = DateTime.Now;

        cab.Estado = (from E in dc.Clasificacion
                      where E.Tipo == "EstadoHoja" && E.Descripcion == "Aprobada"
                      select E).FirstOrDefault();

        cab.SegUsuario = (from S in dc.SegUsuario
                          where S.IdSegUsuario == IdUsuario
                          select S).FirstOrDefault();

        int CantidadLegajos = (from L in cab.ContEmpLegajos
                               select L).Count();

        if (CantidadLegajos == 0)
        {
            cab.FechaAprobacionSinLegajos = DateTime.Now;
        }
    }
Beispiel #9
0
    protected void btnContProrr_Click(object sender, EventArgs e)
    {
        EntidadesConosud dc = new EntidadesConosud();

        List <Entidades.Contrato> contratos = (from C in dc.Contrato
                                               where C.Prorroga != null
                                               select C).ToList <Entidades.Contrato>();


        foreach (Entidades.Contrato itemContratos in contratos)
        {
            if (!itemContratos.ContratoEmpresas.IsLoaded)
            {
                itemContratos.ContratoEmpresas.Load();
            }
            /// Para cada contrato empresa busco los legajos de la ultima hoja de ruta
            /// segun la fecha de vencimiento.
            foreach (Entidades.ContratoEmpresas itemContratosEmp in itemContratos.ContratoEmpresas)
            {
                if (!itemContratosEmp.CabeceraHojasDeRuta.IsLoaded)
                {
                    itemContratosEmp.CabeceraHojasDeRuta.Load();
                }
                Entidades.CabeceraHojasDeRuta CabFechaVencimiento = itemContratosEmp.CabeceraHojasDeRuta.Where(C => C.Periodo.Month == itemContratos.FechaVencimiento.Value.Month && C.Periodo.Year == itemContratos.FechaVencimiento.Value.Year).FirstOrDefault();

                /// Legajos que se tienen que copiar
                if (CabFechaVencimiento != null)
                {
                    if (!CabFechaVencimiento.ContEmpLegajos.IsLoaded)
                    {
                        CabFechaVencimiento.ContEmpLegajos.Load();
                    }

                    /// cabecera pertenecientes a la prorroga
                    List <Entidades.CabeceraHojasDeRuta> CabProrrogadas = itemContratosEmp.CabeceraHojasDeRuta.Where(C => (C.Periodo.Month > itemContratos.FechaVencimiento.Value.Month && C.Periodo.Year == itemContratos.FechaVencimiento.Value.Year) || C.Periodo.Year > itemContratos.FechaVencimiento.Value.Year).ToList();
                    foreach (Entidades.CabeceraHojasDeRuta itemCabPro in CabProrrogadas)
                    {
                        /// si la cabecera prorrogada no tiene legajos asociados
                        /// entonces le copio los legados de la cabecera segun la
                        /// fecha de vencimiento
                        if (!itemCabPro.ContEmpLegajos.IsLoaded)
                        {
                            itemCabPro.ContEmpLegajos.Load();
                        }
                        if (itemCabPro.ContEmpLegajos != null && itemCabPro.ContEmpLegajos.Count == 0)
                        {
                            foreach (Entidades.ContEmpLegajos itemLeg in CabFechaVencimiento.ContEmpLegajos)
                            {
                                if (!itemLeg.LegajosReference.IsLoaded)
                                {
                                    itemLeg.LegajosReference.Load();
                                }
                                Entidades.ContEmpLegajos newContLeg = new Entidades.ContEmpLegajos();
                                newContLeg.ContratoEmpresas    = itemContratosEmp;
                                newContLeg.CabeceraHojasDeRuta = itemCabPro;
                                newContLeg.Legajos             = itemLeg.Legajos;
                                dc.AddToContEmpLegajos(newContLeg);
                            }
                        }
                    }
                }
            }

            dc.SaveChanges();
        }
    }
    public static object UpdateData(List <IDictionary <string, object> > datos, bool fueraTermino)
    {
        long idcabecera = 0;

        Entidades.CabeceraHojasDeRuta cabecera = null;
        EntidadesConosud _dc = new EntidadesConosud();

        foreach (IDictionary <string, object> item in datos)
        {
            if (bool.Parse(item["Presento"].ToString()))
            {
                long id = long.Parse(item["IdHoja"].ToString());


                Entidades.HojasDeRuta itemsHoja = (from H in _dc.HojasDeRuta
                                                   where H.IdHojaDeRuta == id
                                                   select H).First <Entidades.HojasDeRuta>();

                itemsHoja.DocFechaEntrega = DateTime.Now;
                itemsHoja.DocComentario   = "Sin Comentarios";

                /// al presnetar documentación para una hoja de ruta que esta publicada
                /// se des-publica automaticamente.
                itemsHoja.CabeceraHojasDeRuta.Publicar       = false;
                itemsHoja.CabeceraHojasDeRuta.EsFueraTermino = fueraTermino;
                idcabecera = itemsHoja.CabeceraHojasDeRuta.IdCabeceraHojasDeRuta;
                cabecera   = itemsHoja.CabeceraHojasDeRuta;
            }
        }

        if (cabecera != null)
        {
            Entidades.CabeceraHojasDeRuta cab = cabecera;
            if (!cabecera.ContratoEmpresas.EsContratista.Value)
            {
                cab = (from c in _dc.CabeceraHojasDeRuta
                       where c.ContratoEmpresas.Contrato.IdContrato == cabecera.ContratoEmpresas.Contrato.IdContrato &&
                       c.ContratoEmpresas.EsContratista.Value && (c.Periodo.Month == cabecera.Periodo.Month && c.Periodo.Year == cabecera.Periodo.Year)
                       select c).First <Entidades.CabeceraHojasDeRuta>();
            }

            string estado = UpdateSeguimientoAuditoria(cab.IdCabeceraHojasDeRuta, cab.Periodo, cab.ContratoEmpresas.IdContratoEmpresas);

            cab.EstadoAlCierre = estado != "" ? estado : cab.EstadoAlCierre;
        }

        _dc.SaveChanges();


        return((from H in _dc.HojasDeRuta
                where H.CabeceraHojasDeRuta.IdCabeceraHojasDeRuta == idcabecera
                orderby H.Plantilla.Codigo
                select new
        {
            IdHoja = H.IdHojaDeRuta,
            Titulo = H.Plantilla.Descripcion,
            FechaEntrega = H.DocFechaEntrega,
            FechaEntregaOriginal = H.DocFechaEntrega,
            Comentario = H.DocComentario,
            Presento = false
        }).ToList());
    }
Beispiel #11
0
    protected void Page_Load(object sender, EventArgs e)
    {
        long             id          = long.Parse(Request.QueryString["Id"].ToString());
        bool             EsHistorico = bool.Parse(Request.QueryString["EsHistorico"].ToString());
        EntidadesConosud dc          = new EntidadesConosud();

        Entidades.CabeceraHojasDeRuta cabecera = (from C in dc.CabeceraHojasDeRuta
                                                  .Include("ContratoEmpresas.Contrato")
                                                  .Include("ContratoEmpresas")
                                                  .Include("ContratoEmpresas.Empresa")
                                                  where C.IdCabeceraHojasDeRuta == id
                                                  select C).First <Entidades.CabeceraHojasDeRuta>();



        ///// Cabecera hoja de ruta donde no tiene documentacion
        ///// presentada para ninguno de sus items (Contratista y sub contratista)
        //List<Entidades.CabeceraHojasDeRuta> CabSinDocumentacion = (from C in dc.CabeceraHojasDeRuta
        //                                       .Include("ContratoEmpresas.Contrato")
        //                                       .Include("ContratoEmpresas")
        //                                       .Include("ContratoEmpresas.Empresa")
        //                                                   where C.ContratoEmpresas.Contrato.IdContrato == cabecera.ContratoEmpresas.Contrato.IdContrato
        //                                                   && C.Periodo <= cabecera.Periodo
        //                                                   && C.FechaAprobacion == null
        //                                                   && C.HojasDeRuta.Count(h => h.DocFechaEntrega != null) == 0
        //                                                   select C).ToList<Entidades.CabeceraHojasDeRuta>();


        ///// Cabecera hoja de ruta donde TIENE documentacion
        ///// presentada para alguno de sus items pero aun no se han auditado (Contratista y sub contratista)
        ///// es decir no hay items aprobados ni comentarios de los mismos.
        //List<Entidades.CabeceraHojasDeRuta> CabSinAuditoria = (from C in dc.CabeceraHojasDeRuta
        //                                       .Include("ContratoEmpresas.Contrato")
        //                                       .Include("ContratoEmpresas")
        //                                       .Include("ContratoEmpresas.Empresa")
        //                                                           where C.ContratoEmpresas.Contrato.IdContrato == cabecera.ContratoEmpresas.Contrato.IdContrato
        //                                                           && C.Periodo <= cabecera.Periodo
        //                                                           && C.FechaAprobacion == null
        //                                                           && C.HojasDeRuta.Count(h => h.DocFechaEntrega != null) > 0
        //                                                           && C.HojasDeRuta.Count(h => h.HojaFechaAprobacion != null) == 0
        //                                                           && C.HojasDeRuta.Count(h => h.HojaComentario != "") == 0
        //                                                           select C).ToList<Entidades.CabeceraHojasDeRuta>();


        List <Entidades.HojasDeRuta> HRConPendientes = new List <Entidades.HojasDeRuta>();

        if (EsHistorico)
        {
            /// items de las cabeceras que tiene ingresado
            /// algún comentario y no estan aprobadas (Contratista y sub contratista)
            /// Para todos los periodos


            if (Session["TipoUsuario"] != null && Session["TipoUsuario"] == "Cliente")
            {
                /// Para este tipo de cliente solo se muestra el historico de las
                /// hojas de ruta que estan publicadas, ademas de las otras condiciones.

                HRConPendientes = (from I in dc.HojasDeRuta
                                   .Include("CabeceraHojasDeRuta.ContratoEmpresas.Contrato")
                                   .Include("CabeceraHojasDeRuta.ContratoEmpresas")
                                   .Include("CabeceraHojasDeRuta")
                                   .Include("CabeceraHojasDeRuta.ContratoEmpresas.Empresa")
                                   .Include("Plantilla")
                                   where I.CabeceraHojasDeRuta.ContratoEmpresas.Contrato.IdContrato == cabecera.ContratoEmpresas.Contrato.IdContrato &&
                                   I.CabeceraHojasDeRuta.Periodo <= cabecera.Periodo &&
                                   I.CabeceraHojasDeRuta.FechaAprobacion == null &&
                                   I.HojaComentario != "" &&
                                   I.CabeceraHojasDeRuta.Publicar == true
                                   orderby I.CabeceraHojasDeRuta.Periodo descending, I.Plantilla.Codigo
                                   select I).ToList <Entidades.HojasDeRuta>();
            }
            else
            {
                HRConPendientes = (from I in dc.HojasDeRuta
                                   .Include("CabeceraHojasDeRuta.ContratoEmpresas.Contrato")
                                   .Include("CabeceraHojasDeRuta.ContratoEmpresas")
                                   .Include("CabeceraHojasDeRuta")
                                   .Include("CabeceraHojasDeRuta.ContratoEmpresas.Empresa")
                                   .Include("Plantilla")
                                   where I.CabeceraHojasDeRuta.ContratoEmpresas.Contrato.IdContrato == cabecera.ContratoEmpresas.Contrato.IdContrato &&
                                   I.CabeceraHojasDeRuta.Periodo <= cabecera.Periodo &&
                                   I.CabeceraHojasDeRuta.FechaAprobacion == null &&
                                   I.HojaComentario != ""
                                   orderby I.CabeceraHojasDeRuta.Periodo descending, I.Plantilla.Codigo
                                   select I).ToList <Entidades.HojasDeRuta>();
            }
        }
        else
        {
            /// items de las cabeceras que tiene ingresado
            /// algún comentario y no estan aprobadas (Contratista y sub contratista)
            /// Solo para el periodo seleccionado
            HRConPendientes = (from I in dc.HojasDeRuta
                               .Include("CabeceraHojasDeRuta.ContratoEmpresas.Contrato")
                               .Include("CabeceraHojasDeRuta.ContratoEmpresas")
                               .Include("CabeceraHojasDeRuta")
                               .Include("CabeceraHojasDeRuta.ContratoEmpresas.Empresa")
                               .Include("Plantilla")
                               where I.CabeceraHojasDeRuta.ContratoEmpresas.Contrato.IdContrato == cabecera.ContratoEmpresas.Contrato.IdContrato &&
                               I.CabeceraHojasDeRuta.Periodo.Month == cabecera.Periodo.Month && I.CabeceraHojasDeRuta.Periodo.Year == cabecera.Periodo.Year &&
                               I.CabeceraHojasDeRuta.FechaAprobacion == null &&
                               I.HojaComentario != ""
                               orderby I.CabeceraHojasDeRuta.Periodo descending, I.Plantilla.Codigo
                               select I).ToList <Entidades.HojasDeRuta>();
        }

        List <InformexPeriodoTemp> Resultado = new List <InformexPeriodoTemp>();

        foreach (Entidades.HojasDeRuta hoja in HRConPendientes)
        {
            Entidades.InformexPeriodoTemp I = new Entidades.InformexPeriodoTemp();
            I.RazonSocial   = hoja.CabeceraHojasDeRuta.ContratoEmpresas.Empresa.RazonSocial;
            I.Periodo       = hoja.CabeceraHojasDeRuta.Periodo;
            I.PeriodoDesc   = Capitalize(string.Format("{0:Y}", hoja.CabeceraHojasDeRuta.Periodo));
            I.EsContratista = hoja.CabeceraHojasDeRuta.ContratoEmpresas.EsContratista.Value;
            I.Comentario    = hoja.HojaComentario;
            I.Tipo          = "Hojas Con Pendientes";

            I.OrdenDetalle = int.Parse(hoja.CabeceraHojasDeRuta.Periodo.Year.ToString() + string.Format("{0:00}", hoja.CabeceraHojasDeRuta.Periodo.Month));
            if (I.EsContratista)
            {
                I.OrdenEmpresas = 0;
            }
            else
            {
                I.OrdenEmpresas = 1;
            }

            Resultado.Add(I);
        }

        /// Solo vamos a mostrar las hojas que tienen pendientes (21/10/2010)
        //foreach (Entidades.CabeceraHojasDeRuta itemC in CabSinDocumentacion)
        //{
        //    Entidades.InformexPeriodoTemp I = new Entidades.InformexPeriodoTemp();
        //    I.RazonSocial = itemC.ContratoEmpresas.Empresa.RazonSocial;
        //    I.Periodo = itemC.Periodo;
        //    I.PeriodoDesc = string.Format("{0:Y}", itemC.Periodo);
        //    I.EsContratista = itemC.ContratoEmpresas.EsContratista.Value;
        //    I.Comentario = "";
        //    I.Tipo = "Hojas Sin Documentación Presentada";
        //    I.OrdenDetalle = int.Parse(itemC.Periodo.Year.ToString() + string.Format("{0:00}", itemC.Periodo.Month));
        //    if (I.EsContratista)
        //        I.OrdenEmpresas = 0;
        //    else
        //        I.OrdenEmpresas = 1;

        //    Resultado.Add(I);
        //}


        /// Solo vamos a mostrar las hojas que tienen pendientes (21/10/2010)
        //foreach (Entidades.CabeceraHojasDeRuta itemC in CabSinAuditoria)
        //{
        //    Entidades.InformexPeriodoTemp I = new Entidades.InformexPeriodoTemp();
        //    I.RazonSocial = itemC.ContratoEmpresas.Empresa.RazonSocial;
        //    I.Periodo = itemC.Periodo;
        //    I.PeriodoDesc = string.Format("{0:Y}", itemC.Periodo);
        //    I.EsContratista = itemC.ContratoEmpresas.EsContratista.Value;
        //    I.Comentario = "";
        //    I.Tipo = "Hojas en Proceso de Auditoria";
        //    I.OrdenDetalle = int.Parse(itemC.Periodo.Year.ToString() + string.Format("{0:00}", itemC.Periodo.Month));
        //    if (I.EsContratista)
        //        I.OrdenEmpresas = 0;
        //    else
        //        I.OrdenEmpresas = 1;

        //    Resultado.Add(I);
        //}


        if (Resultado.Count > 0)
        {
            InformexPeriodoHistorico rep = new InformexPeriodoHistorico();
            rep.InitReport(Resultado, cabecera, EsHistorico);
            this.ReportViewer1.Report = rep;
            (ReportViewer1.FindControl("ReportToolbar").FindControl("ExportGr").Controls[0].Controls[0] as DropDownList).ClearSelection();
            (ReportViewer1.FindControl("ReportToolbar").FindControl("ExportGr").Controls[0].Controls[0] as DropDownList).Items.FindByText("Excel").Selected = true;
        }
        else
        {
            divcontent.Visible       = false;
            lblSinResultados.Visible = true;
        }
    }
Beispiel #12
0
    public static void GenerarHojadeRuta(ObjectContext pContext, DateTime FInicio, DateTime FFin, Entidades.ContratoEmpresas pContratoEmpresas)
    {
        string queryString = @"SELECT VALUE CabeceraHojasDeRuta FROM 
            EntidadesConosud.CabeceraHojasDeRuta AS CabeceraHojasDeRuta";
        ObjectQuery <Entidades.CabeceraHojasDeRuta> CabeceraHojasDeRutaQuery1 =
            new ObjectQuery <Entidades.CabeceraHojasDeRuta>(queryString, pContext);

        DateTime FechaInicio = FInicio;
        DateTime FechaFinal  = FFin;

        int ultimonrocarpeta = 1;

        try
        {
            ultimonrocarpeta  = CabeceraHojasDeRutaQuery1.Max(c => c.NroCarpeta);
            ultimonrocarpeta += 1;
        }
        catch { }


        long id = Convert.ToInt64(Helpers.EstadosHoja.NoAprobada);
        IEnumerable <KeyValuePair <string, object> > entityKeyValues = new KeyValuePair <string, object>[] {
            new KeyValuePair <string, object>("IdClasificacion", id)
        };
        EntityKey key = new EntityKey("EntidadesConosud.Clasificacion", entityKeyValues);

        Entidades.Clasificacion _est = (Entidades.Clasificacion)pContext.GetObjectByKey(key);

        /// Guardo la ultima cabecera antes de generar las nuevas para
        /// luego obtener los legados de la mism.

        Entidades.CabeceraHojasDeRuta UltimaCabecera = null;
        if (pContratoEmpresas.IdContratoEmpresas > 0)
        {
            if (!pContratoEmpresas.CabeceraHojasDeRuta.IsLoaded)
            {
                pContratoEmpresas.CabeceraHojasDeRuta.Load();
            }
            UltimaCabecera = pContratoEmpresas.CabeceraHojasDeRuta.OrderBy(w => w.Periodo).Last();
        }


        while (GeneraxFecha(ref FechaInicio, ref FechaFinal))
        {
            if (UltimaCabecera == null || !(UltimaCabecera.Periodo.Month == FechaFinal.Month && UltimaCabecera.Periodo.Year == FechaFinal.Year))
            {
                /// control por las dudas que el primer periodo que se intenta crear ya existe.
                if (UltimaCabecera == null || string.Format("{0:MMyyyy}", FechaInicio) != string.Format("{0:MMyyyy}", UltimaCabecera.Periodo))
                {
                    /// controlo que el periodo que se esta intentando crear no exista ya.
                    if (!pContratoEmpresas.CabeceraHojasDeRuta.Any(w => string.Format("{0:MMyyyy}", w.Periodo) == string.Format("{0:MMyyyy}", FechaInicio)))
                    {
                        /// Genero la cabecera de hoja de ruta
                        Entidades.CabeceraHojasDeRuta _CabHojaRuta = new Entidades.CabeceraHojasDeRuta();
                        _CabHojaRuta.ContratoEmpresas = pContratoEmpresas;
                        _CabHojaRuta.Estado           = _est;
                        _CabHojaRuta.Periodo          = FechaInicio;
                        _CabHojaRuta.NroCarpeta       = ultimonrocarpeta;
                        _CabHojaRuta.Estimacion       = string.Empty;
                        _CabHojaRuta.EsFueraTermino   = false;
                        pContext.AddObject("EntidadesConosud.CabeceraHojasDeRuta", _CabHojaRuta);

                        queryString = @"SELECT VALUE Plantilla FROM EntidadesConosud.Plantilla AS Plantilla";

                        ObjectQuery <Entidades.Plantilla> PlantillaQuery1 =
                            new ObjectQuery <Entidades.Plantilla>(queryString, pContext);

                        /// Genero los items de las hojas de ruta
                        foreach (Entidades.Plantilla plan in PlantillaQuery1.Select(p => p))
                        {
                            Entidades.HojasDeRuta _HojasDeRuta = new Entidades.HojasDeRuta();
                            _HojasDeRuta.Plantilla      = plan;
                            _HojasDeRuta.HojaAprobado   = false;
                            _HojasDeRuta.HojaComentario = string.Empty;
                            _HojasDeRuta.AuditadoPor    = string.Empty;
                            _HojasDeRuta.DocComentario  = string.Empty;
                            _CabHojaRuta.HojasDeRuta.Add(_HojasDeRuta);

                            pContext.AddObject("EntidadesConosud.HojasDeRuta", _HojasDeRuta);
                        }

                        /// Asocio  los legajos a la nueva cabecera

                        if (UltimaCabecera != null)
                        {
                            if (!UltimaCabecera.ContEmpLegajos.IsLoaded)
                            {
                                UltimaCabecera.ContEmpLegajos.Load();
                            }
                            foreach (Entidades.ContEmpLegajos itemContLeg in UltimaCabecera.ContEmpLegajos)
                            {
                                if (!itemContLeg.LegajosReference.IsLoaded)
                                {
                                    itemContLeg.LegajosReference.Load();
                                }

                                Entidades.ContEmpLegajos newContLeg = new Entidades.ContEmpLegajos();
                                newContLeg.ContratoEmpresas = pContratoEmpresas;
                                newContLeg.Legajos          = itemContLeg.Legajos;
                                _CabHojaRuta.ContEmpLegajos.Add(newContLeg);

                                pContext.AddObject("EntidadesConosud.ContEmpLegajos", newContLeg);
                            }
                        }
                    }
                }
            }

            FechaInicio       = FechaInicio.AddMonths(1);
            ultimonrocarpeta += 1;
        }
    }
Beispiel #13
0
    protected void btnGenerar_Click(object sender, EventArgs e)
    {
        EntidadesConosud dc = new EntidadesConosud();
        int Mes_AGenerar    = int.Parse(txtMesAño.Text.Split('/')[0]);
        int Año_AGenerar    = int.Parse(txtMesAño.Text.Split('/')[1]);

        int Mes_Refrencia = Mes_AGenerar - 1;
        int Año_Refrencia = Año_AGenerar;


        Entidades.CabeceraHojasDeRuta cabeceraAnterior = (from C in dc.CabeceraHojasDeRuta
                                                          where (C.ContratoEmpresas.IdContratoEmpresas == 2073) &&
                                                          C.Periodo.Month == Mes_Refrencia && C.Periodo.Year == Año_Refrencia
                                                          select C).FirstOrDefault();

        if (cabeceraAnterior != null)
        {
            if (!cabeceraAnterior.ContratoEmpresasReference.IsLoaded)
            {
                cabeceraAnterior.ContratoEmpresasReference.Load();
            }
            if (!cabeceraAnterior.EstadoReference.IsLoaded)
            {
                cabeceraAnterior.EstadoReference.Load();
            }

            // 1. Creo la cabecera para el periodo solicitado
            Entidades.CabeceraHojasDeRuta newCab = new Entidades.CabeceraHojasDeRuta();
            newCab.Periodo          = DateTime.Parse("01/" + Mes_AGenerar.ToString() + "/" + Año_AGenerar.ToString());
            newCab.ContratoEmpresas = cabeceraAnterior.ContratoEmpresas;
            newCab.Estado           = cabeceraAnterior.Estado;
            newCab.NroCarpeta       = cabeceraAnterior.NroCarpeta;
            newCab.Publicar         = false;
            newCab.EsFueraTermino   = false;
            newCab.Estimacion       = string.Empty;
            dc.AddToCabeceraHojasDeRuta(newCab);

            //2. Creo los items de la hoja de ruta
            if (!cabeceraAnterior.HojasDeRuta.IsLoaded)
            {
                cabeceraAnterior.HojasDeRuta.Load();
            }
            foreach (var item in cabeceraAnterior.HojasDeRuta)
            {
                if (!item.PlantillaReference.IsLoaded)
                {
                    item.PlantillaReference.Load();
                }
                Entidades.HojasDeRuta newHoja = new Entidades.HojasDeRuta();
                newHoja.CabeceraHojasDeRuta = newCab;
                newHoja.Plantilla           = item.Plantilla;
                newHoja.HojaComentario      = string.Empty;
                newHoja.DocComentario       = string.Empty;
                newHoja.HojaAprobado        = false;
            }

            //3. Creo los legajos asociados
            if (!cabeceraAnterior.ContEmpLegajos.IsLoaded)
            {
                cabeceraAnterior.ContEmpLegajos.Load();
            }
            foreach (var item in cabeceraAnterior.ContEmpLegajos)
            {
                if (!item.LegajosReference.IsLoaded)
                {
                    item.LegajosReference.Load();
                }
                Entidades.ContEmpLegajos newLeg = new Entidades.ContEmpLegajos();
                newLeg.CabeceraHojasDeRuta = newCab;
                newLeg.ContratoEmpresas    = cabeceraAnterior.ContratoEmpresas;
                newLeg.Legajos             = item.Legajos;
            }


            dc.SaveChanges();
        }
    }
Beispiel #14
0
    protected void btnMesNoviembre_Click(object sender, EventArgs e)
    {
        EntidadesConosud dc = new EntidadesConosud();

        //select * from cabecerahojasderuta where idcontratoempresa in (2128,
        //2129 ,2130 ,2132 ,2133 ,2139 ,2151 ,2152 ,2153 ,2156 ) and
        //month(Periodo) = 12 and year(Periodo) = 2010


        try
        {
            List <Entidades.CabeceraHojasDeRuta> cabeceras = (from C in dc.CabeceraHojasDeRuta
                                                              where (C.ContratoEmpresas.IdContratoEmpresas == 2128 ||
                                                                     C.ContratoEmpresas.IdContratoEmpresas == 2129 ||
                                                                     C.ContratoEmpresas.IdContratoEmpresas == 2130 ||
                                                                     C.ContratoEmpresas.IdContratoEmpresas == 2132 ||
                                                                     C.ContratoEmpresas.IdContratoEmpresas == 2139 ||
                                                                     C.ContratoEmpresas.IdContratoEmpresas == 2151 ||
                                                                     C.ContratoEmpresas.IdContratoEmpresas == 2152 ||
                                                                     C.ContratoEmpresas.IdContratoEmpresas == 2153 ||
                                                                     C.ContratoEmpresas.IdContratoEmpresas == 2156) &&
                                                              C.Periodo.Month == 12 && C.Periodo.Year == 2010
                                                              select C).ToList <Entidades.CabeceraHojasDeRuta>();



            foreach (Entidades.CabeceraHojasDeRuta itemCab in cabeceras)
            {
                if (!itemCab.ContratoEmpresasReference.IsLoaded)
                {
                    itemCab.ContratoEmpresasReference.Load();
                }
                if (!itemCab.EstadoReference.IsLoaded)
                {
                    itemCab.EstadoReference.Load();
                }

                // 1. Creo la cabecera para el periodo 11
                Entidades.CabeceraHojasDeRuta newCab = new Entidades.CabeceraHojasDeRuta();
                newCab.Periodo          = DateTime.Parse("01/11/2010");
                newCab.ContratoEmpresas = itemCab.ContratoEmpresas;
                newCab.Estado           = itemCab.Estado;
                newCab.NroCarpeta       = itemCab.NroCarpeta;
                dc.AddToCabeceraHojasDeRuta(newCab);

                //2. Creo los items de la hoja de ruta
                if (!itemCab.HojasDeRuta.IsLoaded)
                {
                    itemCab.HojasDeRuta.Load();
                }
                foreach (var item in itemCab.HojasDeRuta)
                {
                    if (!item.PlantillaReference.IsLoaded)
                    {
                        item.PlantillaReference.Load();
                    }
                    Entidades.HojasDeRuta newHoja = new Entidades.HojasDeRuta();
                    newHoja.CabeceraHojasDeRuta = newCab;
                    newHoja.Plantilla           = item.Plantilla;
                }

                //3. Creo los legajos asociados
                if (!itemCab.ContEmpLegajos.IsLoaded)
                {
                    itemCab.ContEmpLegajos.Load();
                }
                foreach (var item in itemCab.ContEmpLegajos)
                {
                    if (!item.LegajosReference.IsLoaded)
                    {
                        item.LegajosReference.Load();
                    }
                    Entidades.ContEmpLegajos newLeg = new Entidades.ContEmpLegajos();
                    newLeg.CabeceraHojasDeRuta = newCab;
                    newLeg.ContratoEmpresas    = itemCab.ContratoEmpresas;
                    newLeg.Legajos             = item.Legajos;
                }


                dc.SaveChanges();
            }
        }
        catch (Exception er)
        {
            throw er;
        }
    }
    protected void LinkButtonEliminar_OnClick(object sender, EventArgs e)
    {
        try
        {
            int    i          = RadGrid1.SelectedItems[0].DataSetIndex - (this.RadGrid1.CurrentPageIndex * this.RadGrid1.PageSize);
            string IdContrato = RadGrid1.Items[i].GetDataKeyValue("IdContrato").ToString();
            long   id         = Convert.ToInt64(IdContrato);


            //if ((from h in Contexto.HojasDeRuta
            //     where h.CabeceraHojasDeRuta.ContratoEmpresas.Contrato.IdContrato == id
            //     && h.HojaFechaAprobacion != null
            //     select h).Count() > 0)
            //{
            //    string scriptstring = "radalert('<h4>No se puede eliminar el contrato porque tiene cargada infomacion en su hoja de ruta!</h4>', 330, 100, 'Contratos');";
            //    ScriptManager.RegisterStartupScript(this, this.GetType(), "radalert", scriptstring, true);
            //    return;
            //}

            Entidades.Contrato _contrato = (from c in Contexto.Contrato
                                            .Include("ContratoEmpresas.CabeceraHojasDeRuta.HojasDeRuta")
                                            where c.IdContrato == id
                                            select c).First();



            int j = _contrato.ContratoEmpresas.Count();
            while (j > 0)
            {
                Entidades.ContratoEmpresas _ContratoEmpresas = _contrato.ContratoEmpresas.Take(1).First();
                if (!_ContratoEmpresas.ComentariosGral.IsLoaded)
                {
                    _ContratoEmpresas.ComentariosGral.Load();
                }
                List <ComentariosGral> coment = _ContratoEmpresas.ComentariosGral.ToList();

                foreach (ComentariosGral itemComent in coment)
                {
                    Contexto.DeleteObject(itemComent);
                }

                if (!_ContratoEmpresas.Contrato.DatosDeSueldos.IsLoaded)
                {
                    _ContratoEmpresas.Contrato.DatosDeSueldos.Load();
                }
                List <DatosDeSueldos> infoSueldos = _ContratoEmpresas.Contrato.DatosDeSueldos.ToList();

                foreach (DatosDeSueldos itemsueldo in infoSueldos)
                {
                    Contexto.DeleteObject(itemsueldo);
                }



                int j2 = _ContratoEmpresas.CabeceraHojasDeRuta.Count();
                while (j2 > 0)
                {
                    Entidades.CabeceraHojasDeRuta _CabeceraHojasDeRuta = _ContratoEmpresas.CabeceraHojasDeRuta.Take(1).First();

                    int j3 = _CabeceraHojasDeRuta.HojasDeRuta.Count();
                    while (j3 > 0)
                    {
                        Entidades.HojasDeRuta _HojasDeRuta = _CabeceraHojasDeRuta.HojasDeRuta.Take(1).First();
                        Contexto.DeleteObject(_HojasDeRuta);
                        j3--;
                    }
                    Contexto.DeleteObject(_CabeceraHojasDeRuta);
                    j2--;
                }
                Contexto.DeleteObject(_ContratoEmpresas);
                j--;
            }

            Contexto.DeleteObject(_contrato);
            Contexto.SaveChanges();

            this.CargarSessionContratos();
            this.RadGrid1.Rebind();
        }
        catch (Exception err)
        {
            string scriptstring = "radalert('<h4>" + err.InnerException.Message.Substring(0, 150) + "</h4>', 630, 100, 'Contratos');";
            ScriptManager.RegisterStartupScript(this, this.GetType(), "radalert", scriptstring, true);
        }
    }
    public static String AprobarHojaDeRuta(string IdHojaRuta, string IdUsuario)
    {
        string retorno    = "false";
        bool   UltimaHoja = false;

        EntidadesConosud dc = new EntidadesConosud();

        long id = long.Parse(IdHojaRuta);
        int  ItemNoAprobados = (from H in dc.HojasDeRuta
                                where H.CabeceraHojasDeRuta.IdCabeceraHojasDeRuta == id &&
                                H.HojaFechaAprobacion == null
                                select H).Count();


        Entidades.CabeceraHojasDeRuta cab = (from C in dc.CabeceraHojasDeRuta
                                             .Include("ContratoEmpresas")
                                             .Include("ContratoEmpresas.Contrato")
                                             .Include("ContratoEmpresas.CabeceraHojasDeRuta")
                                             .Include("ContratoEmpresas.Empresa")
                                             .Include("ContEmpLegajos")
                                             .Include("ContEmpLegajos.Legajos")
                                             .Include("ContEmpLegajos.Legajos.objConvenio")
                                             where C.IdCabeceraHojasDeRuta == id
                                             select C).First();


        List <Entidades.CabeceraHojasDeRuta> hojaContratoOrdenadas = (from C in cab.ContratoEmpresas.CabeceraHojasDeRuta
                                                                      orderby C.Periodo
                                                                      select C).ToList <Entidades.CabeceraHojasDeRuta>();



        if (hojaContratoOrdenadas.Last().Periodo == cab.Periodo
            ||
            hojaContratoOrdenadas.Last().Periodo == cab.Periodo.AddMonths(-1))
        {
            UltimaHoja = true;
        }
        else
        {
            UltimaHoja = false;
        }



        if (ItemNoAprobados > 0)
        {
            retorno = "Items|" + UltimaHoja.ToString();
        }
        else
        {
            // Si es la ultima hoja de ruta tengo que controlar
            // que las hojas anteriores esten aprobadas, para poder
            // aprobar la hoja en cuentión.
            if (UltimaHoja)
            {
                /// Si la hoja pertenece a un Sub-Contratista
                /// solo controlo las hojas de ruta de él.
                if (!cab.ContratoEmpresas.EsContratista.Value)
                {
                    int HayHojasSinAprobar = (from H in dc.CabeceraHojasDeRuta
                                              where H.Periodo <= cab.Periodo &&
                                              H.IdCabeceraHojasDeRuta != cab.IdCabeceraHojasDeRuta &&
                                              H.FechaAprobacion == null &&
                                              H.ContratoEmpresas.IdContratoEmpresas == cab.ContratoEmpresas.IdContratoEmpresas
                                              select H).Count();

                    if (HayHojasSinAprobar > 0)
                    {
                        retorno = "Hojas|" + UltimaHoja.ToString();
                    }
                    else
                    {
                        GrabarAprobacion(cab, dc, long.Parse(IdUsuario));
                        dc.SaveChanges();
                        retorno = "Aprobada|" + UltimaHoja.ToString();
                    }
                }
                /// Si la hoja pertenece a un Contratista tengo
                /// que controlar las hojas de él y de todos los
                /// subcontratistas que tenga.
                else
                {
                    int HayHojasSinAprobar = (from H in dc.CabeceraHojasDeRuta
                                              where H.Periodo <= cab.Periodo &&
                                              H.FechaAprobacion == null &&
                                              H.ContratoEmpresas.Contrato.IdContrato == cab.ContratoEmpresas.Contrato.IdContrato &&
                                              H.IdCabeceraHojasDeRuta != id
                                              select H).Count();
                    if (HayHojasSinAprobar > 0)
                    {
                        retorno = "SubContratistas|" + UltimaHoja.ToString();
                    }
                    else
                    {
                        GrabarAprobacion(cab, dc, long.Parse(IdUsuario));
                        dc.SaveChanges();
                        retorno = "Aprobada|" + UltimaHoja.ToString();
                    }
                }
            }
            /// Si no es la ultima hoja de ruta.
            else
            {
                /// Si la hoja pertenece a un Contratista
                /// tengo que controlar que las hojas de sus sub-Contratistas
                /// esten aprobadas, para el mismo periodo, para poder
                /// aprobar la hoja en cuestion.
                if (cab.ContratoEmpresas.EsContratista.Value)
                {
                    int HayHojasSinAprobar = (from H in dc.CabeceraHojasDeRuta
                                              where (H.Periodo.Month == cab.Periodo.Month) &&
                                              (H.Periodo.Year == cab.Periodo.Year) &&
                                              H.FechaAprobacion == null &&
                                              H.ContratoEmpresas.Contrato.IdContrato == cab.ContratoEmpresas.Contrato.IdContrato &&
                                              H.ContratoEmpresas.Empresa.IdEmpresa != cab.ContratoEmpresas.Empresa.IdEmpresa
                                              select H).Count();

                    if (HayHojasSinAprobar > 0)
                    {
                        retorno = "SUBACTUAL|" + UltimaHoja.ToString();
                    }
                    else
                    {
                        GrabarAprobacion(cab, dc, long.Parse(IdUsuario));
                        dc.SaveChanges();
                        retorno = "Aprobada|" + UltimaHoja.ToString();
                    }
                }
                else
                {
                    GrabarAprobacion(cab, dc, long.Parse(IdUsuario));
                    dc.SaveChanges();
                    retorno = "Aprobada|" + UltimaHoja.ToString();
                }
            }
        }

        return(retorno.ToUpper());
    }
    public void RadAjaxManager1_AjaxRequest(object sender, AjaxRequestEventArgs e)
    {
        EntidadesConosud dc = Contexto;

        if (e.Argument == "Update")
        {
            long id = long.Parse(RadGrid1.SelectedValue.ToString());

            Entidades.Empresa EmpUpdate = (from L in dc.Empresa
                                           where L.IdEmpresa == id
                                           select L).FirstOrDefault <Entidades.Empresa>();

            int cant = (from l in dc.Empresa
                        where l.CUIT.Trim() == txtCUIT.Text.Trim() &&
                        l.IdEmpresa != id
                        select l).Count();

            txtCUIT.Attributes.Remove("NroExistente");

            if (cant > 0)
            {
                txtCUIT.Attributes.Add("NroExistente", true.ToString());
                upNroCUIT.Update();
                return;
            }
            else
            {
                txtCUIT.Attributes.Add("NroExistente", false.ToString());
                upNroCUIT.Update();
            }


            if (EmpUpdate != null)
            {
                /// Controles Tipo TextBox
                EmpUpdate.RazonSocial          = txtRazonSocial.Text.Trim();
                EmpUpdate.RepresentanteTecnico = txtTecnico.Text.Trim();
                EmpUpdate.PrestacionEmergencia = txtPrestacionEmergencias.Text.Trim();
                EmpUpdate.Direccion            = txtDireccion.Text.Trim();
                EmpUpdate.Telefono             = txtTelefono.Text.Trim();
                EmpUpdate.Emergencia           = txtEmergencias.Text.Trim();
                EmpUpdate.CorreoElectronico    = txtEmail.Text.Trim();

                /// Controles Tipo Telerik
                EmpUpdate.CUIT = txtCUIT.Text;

                /// Controles Tipo Fecha
                EmpUpdate.FechaAlta = txtFechaAlta.SelectedDate;

                dc.SaveChanges();
            }

            FiltrarEmpresas(txtApellidoLegajo.Text.Trim());
            return;
        }
        if (e.Argument == "delete")
        {
            long id = long.Parse(RadGrid1.SelectedValue.ToString());


            Entidades.Empresa EmpDelete = (from L in Contexto.Empresa
                                           where L.IdEmpresa == id
                                           select L).FirstOrDefault <Entidades.Empresa>();


            /// Saco a todos los lejos asociados a la empresa.
            List <Legajos> legajosAsociados = EmpDelete.Legajos.ToList();
            foreach (Legajos leg in legajosAsociados)
            {
                leg.objEmpresaLegajo = null;
            }


            /// Saco a todos vehiculos asociados
            List <VahiculosyEquipos> VehiculosAsociados = EmpDelete.VahiculosyEquipos.ToList();
            foreach (VahiculosyEquipos vec in VehiculosAsociados)
            {
                vec.objEmpresa = null;
            }


            /// Saco el usario a asociado a la empresa
            List <SegUsuario> SegUsuairoEmp = (from L in Contexto.SegUsuario
                                               where L.IdEmpresa == id
                                               select L).ToList <SegUsuario>();

            foreach (SegUsuario item in SegUsuairoEmp)
            {
                item.Empresa = null;
            }


            int j = EmpDelete.ContratoEmpresas.Count();
            while (j > 0)
            {
                Entidades.ContratoEmpresas _ContratoEmpresas = EmpDelete.ContratoEmpresas.Take(1).First();
                //if (!_ContratoEmpresas.ComentariosGral.IsLoaded) { _ContratoEmpresas.ComentariosGral.Load(); }
                List <ComentariosGral> comentsGrales = _ContratoEmpresas.ComentariosGral.ToList();
                foreach (ComentariosGral itemComent in comentsGrales)
                {
                    Contexto.DeleteObject(itemComent);
                }


                int j2 = _ContratoEmpresas.CabeceraHojasDeRuta.Count();
                while (j2 > 0)
                {
                    Entidades.CabeceraHojasDeRuta _CabeceraHojasDeRuta = _ContratoEmpresas.CabeceraHojasDeRuta.Take(1).First();

                    int j3 = _CabeceraHojasDeRuta.HojasDeRuta.Count();
                    while (j3 > 0)
                    {
                        Entidades.HojasDeRuta _HojasDeRuta = _CabeceraHojasDeRuta.HojasDeRuta.Take(1).First();
                        Contexto.DeleteObject(_HojasDeRuta);
                        j3--;
                    }


                    int j4 = _CabeceraHojasDeRuta.ContEmpLegajos.Count();
                    while (j4 > 0)
                    {
                        ContEmpLegajos _Leghoja = _CabeceraHojasDeRuta.ContEmpLegajos.Take(1).First();
                        Contexto.DeleteObject(_Leghoja);
                        j4--;
                    }


                    Contexto.DeleteObject(_CabeceraHojasDeRuta);
                    j2--;
                }
                Contexto.DeleteObject(_ContratoEmpresas);
                j--;
            }

            Contexto.DeleteObject(EmpDelete);

            try
            {
                Contexto.SaveChanges();
                FiltrarEmpresas(txtApellidoLegajo.Text.Trim());
            }
            catch
            {
                ScriptManager.RegisterStartupScript(this, this.GetType(), "eliminacionEmpresa", "radalert('La emprsa no puede ser eliminada ya que posee mucha información asociada, por favor tome contacto con el administrador del sistema.',300,150)", true);
                FiltrarEmpresas(txtApellidoLegajo.Text.Trim());
            }
        }
        if (e.Argument == "Insert")
        {
            Entidades.Empresa EmpInsert = new Entidades.Empresa();

            int cant = (from l in dc.Empresa
                        where l.CUIT == txtCUIT.Text.Trim()
                        select l).Count();


            if (cant > 0)
            {
                txtCUIT.Attributes.Add("NroExistente", true.ToString());
                upNroCUIT.Update();
                return;
            }
            else
            {
                txtCUIT.Attributes.Add("NroExistente", false.ToString());
                upNroCUIT.Update();
            }


            /// Controles Tipo TextBox
            EmpInsert.RazonSocial          = txtRazonSocial.Text.Trim();
            EmpInsert.RepresentanteTecnico = txtTecnico.Text.Trim();
            EmpInsert.PrestacionEmergencia = txtPrestacionEmergencias.Text.Trim();
            EmpInsert.Direccion            = txtDireccion.Text.Trim();
            EmpInsert.Telefono             = txtTelefono.Text.Trim();
            EmpInsert.Emergencia           = txtEmergencias.Text.Trim();
            EmpInsert.CorreoElectronico    = txtEmail.Text.Trim();

            /// Controles Tipo Telerik
            EmpInsert.CUIT = txtCUIT.Text;

            /// Controles Tipo Fecha
            EmpInsert.FechaAlta = txtFechaAlta.SelectedDate;


            dc.AddToEmpresa(EmpInsert);
            dc.SaveChanges();
        }

        FiltrarEmpresas(txtApellidoLegajo.Text.Trim());
    }