public ImportesRetenidosEntity(XElement item)
 {
     BaseRetencion     = BuscarValueXML.Buscar(item, "BaseRet");
     Impuesto          = BuscarValueXML.Buscar(item, "Impuesto");
     montoRetenido     = BuscarValueXML.Buscar(item, "montoRet");
     TipoPagoRetencion = BuscarValueXML.Buscar(item, "TipoPagoRet");
 }
 public ImpuestosTrasladadosServicioEntity(XElement item)
 {
     Base       = BuscarValueXML.Buscar(item, "Base");
     Impuesto   = BuscarValueXML.Buscar(item, "Impuesto");
     TipoFactor = BuscarValueXML.Buscar(item, "TipoFactor");
     TasaCuota  = BuscarValueXML.Buscar(item, "TasaCuota");
     Importe    = BuscarValueXML.Buscar(item, "Importe");
 }
Example #3
0
        public DeduccionesEntity(XElement Deducciones, XElement Detalle)
        {
            TotalOtrasDeducciones   = BuscarValueXML.Buscar(Deducciones, "TotalOtrasDeducciones");
            TotalImpuestosRetenidos = BuscarValueXML.Buscar(Deducciones, "TotalImpuestosRetenidos");

            Importe  = BuscarValueXML.Buscar(Detalle, "Importe");
            Concepto = BuscarValueXML.Buscar(Detalle, "Concepto");
        }
Example #4
0
        public TimbreEntity(List <XMLNodoEntity> lstNodos)
        {
            XMLNodoEntity nodo = lstNodos.Find(i => i.TipoNodo == Sistema.Nodo.Timbre);

            existeNodo = lstNodos.Exists(i => i.TipoNodo == Sistema.Nodo.Timbre);

            uuid          = BuscarValueXML.Buscar(nodo?.Timbre, "uuid");
            fechatimbrado = BuscarValueXML.Buscar(nodo?.Timbre, "fechatimbrado");
        }
Example #5
0
 public PercepcionesEntity(XElement Percepcion, XElement Detalle)
 {
     TotalGravado   = BuscarValueXML.Buscar(Percepcion, "TotalGravado");
     TotalExento    = BuscarValueXML.Buscar(Percepcion, "TotalExento");
     TotalSueldos   = BuscarValueXML.Buscar(Percepcion, "TotalSueldos");
     Concepto       = BuscarValueXML.Buscar(Detalle, "Concepto");
     ImporteGravado = BuscarValueXML.Buscar(Detalle, "ImporteGravado");
     ImporteExento  = BuscarValueXML.Buscar(Detalle, "ImporteExento");
 }
Example #6
0
        public PeriodoEntity(List <XMLNodoEntity> lstNodos)
        {
            XMLNodoEntity nodo = lstNodos.Find(i => i.TipoNodo == Sistema.Nodo.Periodo);

            existeNodo = lstNodos.Exists(i => i.TipoNodo == Sistema.Nodo.Periodo);

            MesInicial = BuscarValueXML.Buscar(nodo?.Periodo, "MesIni");
            MesFin     = BuscarValueXML.Buscar(nodo?.Periodo, "MesFin");
            Ejercicio  = BuscarValueXML.Buscar(nodo?.Periodo, "Ejerc");
        }
Example #7
0
        public NominaEntity(XElement Nomina)
        {
            FechaPago         = BuscarValueXML.Buscar(Nomina, "FechaPago");
            FechaInicialPago  = BuscarValueXML.Buscar(Nomina, "FechaInicialPago");
            FechaFinalPago    = BuscarValueXML.Buscar(Nomina, "FechaFinalPago");
            NumDiasPagados    = BuscarValueXML.Buscar(Nomina, "NumDiasPagados");
            TotalPercepciones = BuscarValueXML.Buscar(Nomina, "TotalPercepciones");
            TotalDeducciones  = BuscarValueXML.Buscar(Nomina, "TotalDeducciones");

            Emisor   = new EmisorEntity(ValidarElementosDescendientesXML.ObtenerEntity(Nomina, "Emisor"));
            Receptor = new ReceptorEntity(ValidarElementosDescendientesXML.ObtenerEntity(Nomina, "Receptor"));
        }
 public ServiciosPlataformasTecnologicasEntity(XElement PlataformasTecnologicas)
 {
     Version                           = BuscarValueXML.Buscar(PlataformasTecnologicas, "Version");
     Periocidad                        = BuscarValueXML.Buscar(PlataformasTecnologicas, "Periodicidad");
     NumeroServicio                    = BuscarValueXML.Buscar(PlataformasTecnologicas, "NumServ");
     MontoTotalServiciosinIVA          = BuscarValueXML.Buscar(PlataformasTecnologicas, "MonTotServSIVA");
     TotalIVATrasladado                = BuscarValueXML.Buscar(PlataformasTecnologicas, "TotalIVATrasladado");
     TotalIVARetenido                  = BuscarValueXML.Buscar(PlataformasTecnologicas, "TotalIVARetenido");
     TotalISRRetenido                  = BuscarValueXML.Buscar(PlataformasTecnologicas, "TotalISRRetenido");
     DifIVAEntregadoPrestServ          = BuscarValueXML.Buscar(PlataformasTecnologicas, "DifIVAEntregadoPrestServ");
     MonTotalporUsoPlataforma          = BuscarValueXML.Buscar(PlataformasTecnologicas, "MonTotalporUsoPlataforma");
     MonTotalContribucionGubernamental = BuscarValueXML.Buscar(PlataformasTecnologicas, "MonTotalContribucionGubernamental");
 }
Example #9
0
        public ConceptoEntity(List <XMLNodoEntity> lstNodos)
        {
            XMLNodoEntity nodo = lstNodos.Find(i => i.TipoNodo == Sistema.Nodo.Concepto);

            existeNodo = lstNodos.Exists(i => i.TipoNodo == Sistema.Nodo.Concepto);

            ClaveProductorServicio = BuscarValueXML.Buscar(nodo?.Concepto, "ClaveProdServ", Sistema.Nivel.ElementroAtributo);
            Cantidad      = BuscarValueXML.Buscar(nodo?.Concepto, "cantidad", Sistema.Nivel.ElementroAtributo);
            ClaveUnidad   = BuscarValueXML.Buscar(nodo?.Concepto, "ClaveUnidad", Sistema.Nivel.ElementroAtributo);
            Descripcion   = BuscarValueXML.Buscar(nodo?.Concepto, "descripcion", Sistema.Nivel.ElementroAtributo);
            ValorUnitario = BuscarValueXML.Buscar(nodo?.Concepto, "valorunitario", Sistema.Nivel.ElementroAtributo);
            Importe       = BuscarValueXML.Buscar(nodo?.Concepto, "importe", Sistema.Nivel.ElementroAtributo);
            Descuento     = BuscarValueXML.Buscar(nodo?.Concepto, "Descuento", Sistema.Nivel.ElementroAtributo);
        }
Example #10
0
        public AtributoEntity(XElement item)
        {
            name = BuscarValueXML.Buscar(item, "name");
            use  = BuscarValueXML.Buscar(item, "use");

            var prefix = item.GetNamespaceOfPrefix("xs");

            if (!string.IsNullOrWhiteSpace(name))
            {
                foreach (var type in item.Element(prefix + "simpleType").Elements())
                {
                    tipo = BuscarValueXML.Buscar(type, "base").Replace("xs:", "");
                }
            }
        }
Example #11
0
        public ElementoEntity(IEnumerable <XElement> Elementos, XElement nodo)
        {
            atributos = new List <AtributoEntity>();
            name      = BuscarValueXML.Buscar(nodo, "name");

            foreach (var item in Elementos)
            {
                var atributo = new AtributoEntity(item);

                if (!string.IsNullOrWhiteSpace(atributo.name))
                {
                    atributos.Add(atributo);
                }
            }
        }
Example #12
0
        public ImpuestosRetenidosEntity(List <XMLNodoEntity> lstNodos)
        {
            XMLNodoEntity nodo = lstNodos.Find(i => i.TipoNodo == Sistema.Nodo.TotalSPT);

            existeNodo = lstNodos.Exists(i => i.TipoNodo == Sistema.Nodo.TotalSPT);

            MontoTotalOperacion = BuscarValueXML.Buscar(nodo?.Totales, "montoTotOperacion");
            MontoTotalGravado   = BuscarValueXML.Buscar(nodo?.Totales, "montoTotGrav");
            MontoTotalExento    = BuscarValueXML.Buscar(nodo?.Totales, "montoTotExent");
            MontoTotalRetenido  = BuscarValueXML.Buscar(nodo?.Totales, "montoTotRet");

            Importes = new List <ImportesRetenidosEntity>();
            if (nodo?.ImportesRetenidos.Any() == true)
            {
                Importes.AddRange(from XElement item in nodo.ImportesRetenidos select new ImportesRetenidosEntity(item));
            }
        }
Example #13
0
 public ReceptorEntity(XElement Receptor)
 {
     CURP = BuscarValueXML.Buscar(Receptor, "CURP");
     NumSeguridadSocial     = BuscarValueXML.Buscar(Receptor, "NumSeguridadSocial");
     FechaInicioRelLaboral  = BuscarValueXML.Buscar(Receptor, "FechaInicioRelLaboral");
     Antiguedad             = BuscarValueXML.Buscar(Receptor, "Antigüedad");
     TipoContrato           = BuscarValueXML.Buscar(Receptor, "TipoContrato");
     Sindicalizado          = BuscarValueXML.Buscar(Receptor, "Sindicalizado");
     TipoJornada            = BuscarValueXML.Buscar(Receptor, "TipoJornada");
     TipoRegimen            = BuscarValueXML.Buscar(Receptor, "TipoRegimen");
     NumEmpleado            = BuscarValueXML.Buscar(Receptor, "NumEmpleado");
     RiesgoPuesto           = BuscarValueXML.Buscar(Receptor, "RiesgoPuesto");
     PeriodicidadPago       = BuscarValueXML.Buscar(Receptor, "PeriodicidadPago");
     CuentaBancaria         = BuscarValueXML.Buscar(Receptor, "CuentaBancaria");
     SalarioDiarioIntegrado = BuscarValueXML.Buscar(Receptor, "SalarioDiarioIntegrado");
     ClaveEntFed            = BuscarValueXML.Buscar(Receptor, "ClaveEntFed");
 }
Example #14
0
        public VisualStudioEntity(XMLNodoEntity nodo)
        {
            AssemblyName           = BuscarValueXML.Buscar(nodo?.PropertyGroup, "AssemblyName");
            TargetFrameworkVersion = BuscarValueXML.Buscar(nodo?.PropertyGroup, "TargetFrameworkVersion");
            PlatformTarget         = BuscarValueXML.Buscar(nodo?.PropertyGroup, "PlatformTarget");

            var item = BuscarElementosXML.Buscar(nodo?.ItemGroup, "ProjectReference");

            Proyectos = new List <string>();
            if (item?.Any() == true)
            {
                Proyectos.AddRange(from XElement x in item.Elements()
                                   where ValidarItemXML.Validar(x.Name.LocalName, "Name")
                                   select BuscarValueXML.Buscar(x, "Name", Sistema.Nivel.Raiz));
            }

            TotalDependencias = Proyectos.Count;
        }
Example #15
0
        public EmisorEntity(List <XMLNodoEntity> lstNodos)
        {
            XMLNodoEntity nodo = lstNodos.Find(i => i.TipoNodo == Sistema.Nodo.Emisor);

            existeNodo = lstNodos.Exists(i => i.TipoNodo == Sistema.Nodo.Emisor);

            RFC = BuscarValueXML.Buscar(nodo?.Emisor, "Rfc");

            if (string.IsNullOrWhiteSpace(RFC))
            {
                RFC = BuscarValueXML.Buscar(nodo?.Emisor, "RFCEmisor");
            }

            Nombre = BuscarValueXML.Buscar(nodo?.Emisor, "Nombre");

            if (string.IsNullOrWhiteSpace(Nombre))
            {
                Nombre = BuscarValueXML.Buscar(nodo?.Emisor, "NomDenRazSocE");
            }
        }
        public DetallesServicioEntity(DetalleServicioSPTModel servicio)
        {
            FormaPagoServ        = BuscarValueXML.Buscar(servicio.DetallesDelServicio, "FormaPagoServ");
            TipoDeServ           = BuscarValueXML.Buscar(servicio.DetallesDelServicio, "TipoDeServ");
            SubTipServ           = BuscarValueXML.Buscar(servicio.DetallesDelServicio, "SubTipServ");
            RFCTerceroAutorizado = BuscarValueXML.Buscar(servicio.DetallesDelServicio, "RFCTerceroAutorizado");
            FechaServ            = BuscarValueXML.Buscar(servicio.DetallesDelServicio, "FechaServ");
            PrecioServSinIVA     = BuscarValueXML.Buscar(servicio.DetallesDelServicio, "PrecioServSinIVA");

            ImpuestosTrasladoServicio = new List <ImpuestosTrasladadosServicioEntity>();

            if (servicio.ImpuestosTrasladadosdelServicio.Any())
            {
                ImpuestosTrasladoServicio.AddRange(from XElement item in servicio.ImpuestosTrasladadosdelServicio
                                                   select new ImpuestosTrasladadosServicioEntity(item));
            }

            Contribucion     = new ContribucionGubernamentalEntity(servicio);
            ComisionServicio = new ComisiondelServicioEntity(servicio);
        }
Example #17
0
        public TrasladoEntity(List <XMLNodoEntity> lstNodos)
        {
            XMLNodoEntity nodo = lstNodos.Find(i => i.TipoNodo == Sistema.Nodo.Traslado);

            existeNodo = lstNodos.Exists(i => i.TipoNodo == Sistema.Nodo.Traslado);

            Tasa       = string.Empty;
            TasaOCuota = BuscarValueXML.Buscar(nodo?.Traslado, "tasaocuota");

            if (string.IsNullOrWhiteSpace(TasaOCuota))
            {
                Tasa = BuscarValueXML.Buscar(nodo?.Traslado, "tasa");
            }

            TotalImpuestosTrasladados = BuscarValueXML.Buscar(nodo?.Impuestos, "totalimpuestostrasladados");
            ImpuestoTraslado          = BuscarValueXML.Buscar(nodo?.Traslado, "impuesto");
            ImporteTraslado           = BuscarValueXML.Buscar(nodo?.Traslado, "importe");

            TotalImpuestosRetenidos = BuscarValueXML.Buscar(nodo?.Impuestos, "totalimpuestosretenidos");
            ImpuestoRetencion       = BuscarValueXML.Buscar(nodo?.Retencion, "impuesto");
            ImporteRetencion        = BuscarValueXML.Buscar(nodo?.Retencion, "importe");
        }
Example #18
0
        public VisualStudioModel(List <XMLNodoEntity> lstNodos)
        {
            try
            {
                Packages     = new List <PackagesEntity>();
                ValuesConfig = new List <ConfigEntity>();

                if (ValidarTipoNodo.Existe(out XMLNodoEntity nodo, Sistema.Nodo.VisualStudio, lstNodos))
                {
                    VisualStudio = new VisualStudioEntity(nodo);

                    XMLNodoEntity config;
                    if (ValidarTipoNodo.Existe(out config, Sistema.Nodo.Config, lstNodos))
                    {
                        var conexion = BuscarValueXML.Buscar(config?.connectionStrings, "connectionString", Sistema.Nivel.ElementroAtributo);

                        if (config?.appSettings?.Elements()?.Any() == true)
                        {
                            ValuesConfig.AddRange(from XElement item in config.appSettings.Elements()
                                                  where ValidarItemXML.Validar(item.Name.LocalName, "add")
                                                  select new ConfigEntity(item, conexion));
                        }
                    }

                    XMLNodoEntity Pack;
                    if (ValidarTipoNodo.Existe(out Pack, Sistema.Nodo.Nuget, lstNodos))
                    {
                        var package = Pack?.Nugets?.Elements().Where(p => ValidarItemXML.Validar(p.Name.LocalName, "package")).ToList();
                        Packages.AddRange(from XElement pack in package select new PackagesEntity(pack));
                    }
                }
            }
            catch (Exception ex)
            {
                Error = ex;
            }
        }
Example #19
0
        public ComprobanteEntity(List <XMLNodoEntity> lstNodos)
        {
            XMLNodoEntity nodo = lstNodos.Find(i => i.TipoNodo == Sistema.Nodo.Comprobante);

            existeNodo = lstNodos.Exists(i => i.TipoNodo == Sistema.Nodo.Comprobante);

            Fecha             = BuscarValueXML.Buscar(nodo?.Comprobante, "fecha");
            TipoDeComprobante = BuscarValueXML.Buscar(nodo?.Comprobante, "tipodecomprobante");
            Version           = BuscarValueXML.Buscar(nodo?.Comprobante, "version");
            SubTotal          = BuscarValueXML.Buscar(nodo?.Comprobante, "subtotal");
            Descuento         = BuscarValueXML.Buscar(nodo?.Comprobante, "descuento");
            TipoCambio        = BuscarValueXML.Buscar(nodo?.Comprobante, "tipocambio");
            Moneda            = BuscarValueXML.Buscar(nodo?.Comprobante, "moneda");
            Total             = BuscarValueXML.Buscar(nodo?.Comprobante, "total");
            Version           = BuscarValueXML.Buscar(nodo?.Comprobante, "Version");
            MetodoPago        = BuscarValueXML.Buscar(nodo?.Comprobante, "MetodoPago");
            FormaPago         = BuscarValueXML.Buscar(nodo?.Comprobante, "FormaPago");
            NoCertificado     = BuscarValueXML.Buscar(nodo?.Comprobante, "NoCertificado");
            Certificado       = BuscarValueXML.Buscar(nodo?.Comprobante, "Certificado");
            Sello             = BuscarValueXML.Buscar(nodo?.Comprobante, "Sello");
            Folio             = BuscarValueXML.Buscar(nodo?.Comprobante, "Folio");
            Serie             = BuscarValueXML.Buscar(nodo?.Comprobante, "Serie");
            LugarExpedicion   = BuscarValueXML.Buscar(nodo?.Comprobante, "LugarExpedicion");
        }
Example #20
0
        public ReceptorEntity(List <XMLNodoEntity> lstNodos)
        {
            XMLNodoEntity nodo = lstNodos.Find(i => i.TipoNodo == Sistema.Nodo.Receptor);

            existeNodo = lstNodos.Exists(i => i.TipoNodo == Sistema.Nodo.Receptor);

            Nacionalidad = BuscarValueXML.Buscar(nodo?.Receptor, "Nacionalidad");
            RFC          = BuscarValueXML.Buscar(nodo?.Nacional, "RFCRecep");

            if (string.IsNullOrWhiteSpace(RFC))
            {
                RFC = BuscarValueXML.Buscar(nodo?.Receptor, "Rfc");
            }

            Nombre = BuscarValueXML.Buscar(nodo?.Nacional, "NomDenRazSocR");

            if (string.IsNullOrWhiteSpace(Nombre))
            {
                Nombre = BuscarValueXML.Buscar(nodo?.Receptor, "Nombre");
            }

            CURP    = BuscarValueXML.Buscar(nodo?.Nacional, "CURPR");
            UsoCFDI = BuscarValueXML.Buscar(nodo?.Receptor, "UsoCFDI");
        }
 public ContribucionGubernamentalEntity(DetalleServicioSPTModel nodo)
 {
     ImpContrib = BuscarValueXML.Buscar(nodo.ContribucionGubernamental, "ImpContrib");
     EntidadDondePagaLaContribucion = BuscarValueXML.Buscar(nodo.ContribucionGubernamental, "EntidadDondePagaLaContribucion");
 }
Example #22
0
 public ConfigEntity(XElement config, string conexionvalue)
 {
     connectionStrings = conexionvalue;
     key   = BuscarValueXML.Buscar(config, "key");
     value = BuscarValueXML.Buscar(config, "value");
 }
 public ComisiondelServicioEntity(DetalleServicioSPTModel nodo)
 {
     Base       = BuscarValueXML.Buscar(nodo.ComisionDelServicio, "Base");
     Porcentaje = BuscarValueXML.Buscar(nodo.ComisionDelServicio, "Porcentaje");
     Importe    = BuscarValueXML.Buscar(nodo.ComisionDelServicio, "Importe");
 }
Example #24
0
 public PackagesEntity(XElement package)
 {
     id              = BuscarValueXML.Buscar(package, "id");
     version         = BuscarValueXML.Buscar(package, "version");
     targetFramework = BuscarValueXML.Buscar(package, "targetFramework");
 }
Example #25
0
 public EmisorEntity(XElement Emisor)
 {
     RegistroPatronal = BuscarValueXML.Buscar(Emisor, "RegistroPatronal");
 }