string preparaDeclaracionProvisional(string xmlDeclaracion, string rfc, string idDeclaracion, DeclaracionTemporal temporal, out string mensaje)
        {
            string uriBlob = string.Empty;

            mensaje = string.Empty;

            try
            {
                TransformadorSATMessage procesaMensaje   = new TransformadorSATMessage();
                RespuestaServicioDyP    respuestaProceso = procesaMensaje.EnviarMensajeSAT(xmlDeclaracion, idDeclaracion, rfc);

                if (respuestaProceso.Procesado)
                {
                    if (string.IsNullOrEmpty(new DeterminacionPagoDyP().ConsultarOpcPagoISREnClasificador(temporal.Ejercicio, rfc)))
                    {
                        /*Apartado para determinar si el contribuyente seleccionó ingreso menos gasto o coeficiente de utilidad en el formulario de ISR*/
                        try
                        {
                            XDocument xdocTmp = XDocument.Parse(xmlDeclaracion);
                            var       nodoISR = xdocTmp.XPathSelectElement("//*[local-name()='modeloDatos']/*[local-name()='entidad' and @tipo='SAT_DETERMINACION_IMPUESTO' and @claveimpuesto='" + TipoObligacion.ISR.ToDescription() + "']/*[local-name()='propiedad' and @claveinformativa='OCISR']");
                            if (nodoISR != null)
                            {
                                string misr = nodoISR.Value == "1" ? "CU" : "IG";
                                var    pago = new DeterminacionPagoDyP();
                                pago.AgregarOpcPagoISR(temporal.Ejercicio, rfc, misr);
                                pago.MarcarComoCerrada(temporal.Ejercicio, rfc);
                            }
                        }
                        catch (Exception _ex)
                        {
                            RegistraEvento.Instancia.EscribeEvento(_ex);
                            RegistroEvento.Error(ref _ex, CodigoEvento.ErrorDatos, GetType().Name);
                        }
                    }

                    uriBlob = respuestaProceso.PDF;

                    var declaraProvisional = new DeclaracionProvisional
                    {
                        rfc                           = rfc,
                        ejercicio                     = temporal.Ejercicio,
                        idDeclaracion                 = idDeclaracion,
                        NoReforma                     = temporal.VersionReforma,
                        periodicidad                  = temporal.Periodicidad,
                        periodicidadDescripcion       = temporal.PeriodicidadDescripcion,
                        periodo                       = temporal.Periodo,
                        tipoDeclaracion               = temporal.TipoDeclaracion,
                        tipoDeclaracionDescripcion    = temporal.TipoDeclaracionDescripcion,
                        periodoDescripcion            = temporal.PeriodoDescripcion,
                        tipoComplementaria            = temporal.TipoComplementaria,
                        tipoComplementariaDescripcion = temporal.TipoComplementariaDescripcion,
                    };

                    uriBlob = AlmacenarDeclaracionProvisional(declaraProvisional, xmlDeclaracion, respuestaProceso.XmlMessage, respuestaProceso.PDF, respuestaProceso.HTML);

                    EliminarDeclaracionTemporal(rfc, idDeclaracion);

                    using (AdministradorEnvioDeclaracionConceptos administrador = new AdministradorEnvioDeclaracionConceptos())
                    {
                        try
                        {
                            administrador.EnviarMensaje(rfc, idDeclaracion);
                        }
                        catch (Exception ex)
                        {
                            RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, "Generacion del mensaje de recepción de declaracion.");
                        }
                    }


                    try
                    {
                        using (var administrador = new AdministradorDeclaracionClasificador())
                        {
                            //var declaracionClasificador = administrador.ObtenerDeclaracionPorDypLlave(rfc, idDeclaracion);
                            //declaracionClasificador.EstadoActual = (int)Sat.DyP.Clasificador.Entidades.Enumeraciones.EstadoDeclaracion.Enviada;
                            //administrador.AgregarActualizarDeclaracion(declaracionClasificador);
                            //
                            var declaracionAlmacenada = DeclaracionClasificadorComplementos.MarcarComoDeclaracionEnviada(rfc, idDeclaracion, temporal.VersionReforma);
                            if (declaracionAlmacenada != null)
                            {
                                administrador.EncolarCfdisReportes(declaracionAlmacenada.RowKey);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, "Marcar como enviada y crear petición para worker de datos.");
                    }
                }
                else
                {
                    mensaje = respuestaProceso.Mensaje + respuestaProceso.PDF;
                }
            }
            catch (Exception ex) { throw ex; }
            return(uriBlob);
        }
        public List <string> ObtenerPlantillaObligaciones(dynamic parametro, out string formulario, out int codigoRespuesta)
        {
            List <string> plantillas = new List <string>();

            string[] xmlPlantillas          = null;
            string   xmlDeclaracionTemporal = string.Empty;
            string   xmlDeclaracionVigente  = string.Empty;

            codigoRespuesta = (int)CodigoRespuestaGeneral.OK;
            string forma   = "new";
            string mensaje = string.Empty;

            try
            {
                string rfc           = parametro.Rfc;
                long   idDeclaracion = parametro.NoDeclaracion ?? 0;
                string xmlTemporal   = string.Empty;
                var    obligaciones  = new List <string>();

                if (idDeclaracion > 0)
                {
                    AdministradorDeclaracionClasificador administrador = new AdministradorDeclaracionClasificador();
                    DeclaracionClasificador declaraClasificador        = administrador.ObtenerDeclaracionPorDypLlave(parametro.Rfc.ToString(), idDeclaracion.ToString());

                    if (declaraClasificador != null)
                    {
                        parametro.DeclaracionClasificador = declaraClasificador.Consecutivo;
                    }
                    else
                    {
                        parametro.DeclaracionClasificador = 1;
                        Exception ex = new Exception($"No encontro declaracion clasificardor:  {parametro.Rfc} - {idDeclaracion}");
                        RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
                    }
                }

                #region Obtenemos la informacion del contribuyente, ya sea por Precarga, Selector, Temporal
                var plantillaData = new Descarga.Entities.PrecargaContribuyente()
                {
                    rfc       = parametro.Rfc,
                    ejercicio = parametro.ejercicio != null?Convert.ToString(parametro.ejercicio) : null,
                                    periodo             = parametro.periodo != null ? parametro.periodo : null,
                                    tipoContribuyente   = parametro.TipoContribuyente,
                                    metodoAutenticacion = parametro.MetodoAutenticacion,
                                    declaracionID       = idDeclaracion,
                                    reformaID           = parametro.NoReforma != null ? parametro.NoReforma : null,
                                    alscEmpleado        = parametro.idAlscEmpleado,
                                    rfcEmpleado         = parametro.rfcEmpleado,
                                    presentaDeclaracion = parametro.presentaDeclaracion ?? false,
                                    OpcionCalculoISR    = parametro.OpcionCalculoISR ?? "-1",
                                    consecutivo         = parametro.DeclaracionClasificador.ToString(),
                                    MuestraCalculoISR   = parametro.muestraOCISR.ToString()
                };

                using (var prec = new Descarga.PreCarga())
                {
                    prec.DeclaracionDatos += (s, m, u) =>
                    {
                        try { return(Consultas.Consulta.InfoDeclaracion(s, m, u)); }
                        catch (Exception ex)
                        {
                            RegistraEvento.Instancia.EscribeEvento(ex);
                            RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
                            return(null);
                        }
                    };

                    prec.ejecutaAccion += (p, a) =>
                    {
                        switch (a)
                        {
                        case Descarga.PreCarga.accion.Totales:
                            if (obtieneTotales != null)
                            {
                                return(obtieneTotales(p[0], p[1], p[2], p[3]));
                            }
                            break;

                        case Descarga.PreCarga.accion.Plantillas:
                            for (int i = 4; i <= p.Length - 1; i++)
                            {
                                obligaciones.Add(p[i] /*.Replace("0145", "ISR").Replace("0309", "IVA")*/);
                            }
                            xmlPlantillas = ServicioObtienePlantillas(p[1], p[2], p[3] ?? parametro.periodicidad.ToString(), obligaciones.ToArray());
                            break;

                        case Descarga.PreCarga.accion.Complementaria:
                            Dictionary <string, string> listaConceptos = new Dictionary <string, string>();
                            foreach (string c in p[3].Split('|').Where(d => !string.IsNullOrEmpty(d)))
                            {
                                listaConceptos.Add(c.Split(',')[0], c.Split(',')[1]);
                            }

                            xmlDeclaracionVigente = RecuperarXmlConceptos(listaConceptos, p[0]);
                            break;

                        case Descarga.PreCarga.accion.Temporal:
                            if (RecuperaEntidadDeclaracionTemporal(p[0], p[3]) != null)
                            {
                                xmlTemporal = RecuperarXmlDeclaracionTemporal(p[0], p[3]);
                            }

                            if (!string.IsNullOrEmpty(xmlTemporal))
                            {
                                forma = "tmp";
                            }
                            break;
                        }

                        return(null);
                    };

                    try
                    {
                        mensaje = prec.ObtenerDatosContribuyente(plantillaData, out codigoRespuesta);
                    }
                    catch (Exception ex)
                    {
                        RegistraEvento.Instancia.EscribeEvento(ex);
                        RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
                    }
                }

                #endregion

                formulario = forma;
                plantillas.Add(mensaje);
                plantillas.Add(xmlTemporal);
                plantillas.Add(xmlDeclaracionVigente);
                if (xmlPlantillas != null)
                {
                    plantillas.AddRange(xmlPlantillas);
                }
                else
                {
                    plantillas.AddRange(new string[6]);
                }

                plantillas.Add(obligaciones.Count(o => o == TipoObligacion.ISR.ToDescription()).ToString().ToLower());
            }
            catch (Exception ex)
            {
                RegistraEvento.Instancia.EscribeEvento(ex);
                RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
                throw ex;
            }

            return(plantillas);
        }