/// <summary>
/// Almacena una declaración temporal en el Blob
/// </summary>
/// <param name="declaracionBase64">Archivo en base 64 de la declaración</param>
/// <param name="rfc">Rfc del contribuyente</param>
/// <param name="regimen">Regimen a presentar</param>
/// <param name="ejercicio">Identificador del ejercicio</param>
/// <param name="periodo">Identificador del periodo</param>
/// <param name="periododescripcion">Descripción del periodo</param>
/// <param name="tipoDeclaracion">Tipo de declaración presentada</param>
/// <param name="tipoDeclaracionDescripcion">Descripción de la declaración</param>
/// <param name="tipoComplementaria">Tipo de complemetaria</param>
/// <param name="tipoComplementariaDescripcion">Decripción del tipo de complementaria</param>
/// <param name="tipoPersona">Tipo de persona F o M</param>
/// <param name="subregimen">Identificadores de subregimen separados con "," </param>
/// <param name="areageografica">Identificador del area geografica</param>
/// <param name="sinCalculo">Bandera que indica si se implementara calculo automatico</param>
/// <returns>Uri del Blob</returns>
public string AlmacenarDeclaracionTemporal(string declaracionBase64, string rfcContribuyente, string idDeclaracion, int ejercicio,
string periodo, string periodoDescripcion, string periodicidad, string periodicidadDescripcion,
string tipoDeclaracion, string tipoDeclaracionDescripcion, string tipoComplementaria, string tipoComplementariaDescripcion, string NoReforma,
bool contieneErrores = false)
{
string uriBlob = string.Empty;
try
{
RegistroEvento.Informacion(String.Format("Inicia AlmacenarDeclaracionTemporal con los sigs datos, rfc {0}, idDeclaracion {1}, ejercicio {2}, tipo decla {3}",
rfcContribuyente, idDeclaracion, ejercicio, tipoDeclaracion), CodigoEvento.InformacionNegocio, String.Empty, "Declaracion");
string declaracion = Utileria.Instancia.DeCodificarBase64(declaracionBase64);
using (var administrador = new AdministradorDeclaracion())
{
uriBlob = administrador.AlmacenarDeclaracionTemporal(declaracion, rfcContribuyente, idDeclaracion, ejercicio,
periodo, periodoDescripcion, periodicidad, periodicidadDescripcion,
tipoDeclaracion, tipoDeclaracionDescripcion, tipoComplementaria, tipoComplementariaDescripcion, NoReforma, contieneErrores);
}
RegistroEvento.Informacion(String.Format("Termino sin Error AlmacenarDeclaracionTemporal con los sigs datos, rfc {0}, idDeclaracion {1}, ejercicio {2}, tipo decla {3}",
rfcContribuyente, idDeclaracion, ejercicio, tipoDeclaracion), CodigoEvento.InformacionNegocio, String.Empty, "Declaracion");
}
catch (Exception ex)
{
RegistraEvento.Instancia.EscribeEvento(ex);
RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
throw ex;
}
return(uriBlob);
}
public bool AddRegistroSesion(string loggedUser, byte tipoAccion, byte tipoObjeto, int?idRegistro, string origen)
{
var keyUsuario = 1;
try
{
if (loggedUser != "1")
{
var usuarioLog = _db.Usuarios.FirstOrDefault(u => u.Id == loggedUser);
if (usuarioLog != null)
{
keyUsuario = usuarioLog.UsuarioKey;
}
}
var regSesion = new RegistroEvento()
{
UsuarioKey = keyUsuario,
EventoFecha = DateTime.Now,
IdTipoAccion = tipoAccion,
IdTipoObjeto = tipoObjeto,
IdRegistro = idRegistro,
Origen = origen
};
_db.RegistroEventos.Add(regSesion);
_db.SaveChanges();
}
catch (Exception)
{
return(false);
}
return(true);
}
public ActionResult PresentaDeclaracion(string id)
{
ActionResult vista = this.View(RecursoClasificador.ParcialErrorEnPermisos);
try
{
ContribuyenteInfo contribuyente = this.ContribuyenteAutenticado();
if (!string.IsNullOrEmpty(id) && this.PeticionDesdeLugarReferido() && contribuyente.Espms)
{
string strMensaje = "";
id = new Sat.DyP.Herramientas.Encripcion.Encripcion().DesencriptaCadena(id, Sat.DyP.Herramientas.Encripcion.TipoEncripcion.Base64URL);
this.ViewBag.idDeclaracion = id;
this.ViewBag.RFC = Utileria.Instancia.CodificarBase64(contribuyente.Rfc);
vista = this.View();
using (var declaracion = new Declaracion())
{
ViewBag.Devolucion = declaracion.obtieneMontoDevolucion(contribuyente.Rfc, id, out strMensaje);
}
}
}
catch (Exception ex)
{
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, RecursoClasificador.ErrorEnAutenticacion, null, null, origen: RecursoClasificador.ClasificadorOrigen);
}
return(vista);
}
public string RecibeDeclaracionFirmada(DyP.Herramientas.Entidad.Declaracion.ReciboDeclaracionFirmada rdf, out string mensajeRespuesta)
{
string uriBlob = string.Empty;
mensajeRespuesta = string.Empty;
try
{
DeclaracionTemporal temporal = this.RecuperaEntidadDeclaracionTemporal(rdf.rfc, rdf.idDeclaracion);
if (temporal != null)
{
string declaracion = RecuperarXmlDeclaracionTemporal(rdf.rfc, rdf.idDeclaracion, false);
string xmlDeclaracion = agregaValoresDeclaracion(declaracion, true, rdf.numeroCertificado, "", rdf.firma, rdf.folioFirmado);
uriBlob = preparaDeclaracionProvisional(xmlDeclaracion, rdf.rfc, rdf.idDeclaracion, temporal, out mensajeRespuesta);
}
else
{
mensajeRespuesta = "No existe la declaracion temporal";
}
}
catch (Exception ex)
{
RegistraEvento.Instancia.EscribeEvento(ex);
RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
throw ex;
}
return(uriBlob);
}
public byte[] RecuperaPDF(string uriBlob)
{
byte[] archivoDeBytes = null;
try
{
if (!string.IsNullOrEmpty(uriBlob))
{
using (var administradorConfiguracion = new AdministradorConfiguracion())
{
Stream stream = administradorConfiguracion.RecuperarArchivoBlob(uriBlob);
if (stream != null)
{
stream.Seek(0, SeekOrigin.Begin);
// El stream ya contiene el pdf
using (MemoryStream memStream = new MemoryStream())
{
stream.CopyTo(memStream);
archivoDeBytes = memStream.ToArray();
}
}
}
}
}
catch (Exception ex)
{
RegistraEvento.Instancia.EscribeEvento(ex);
RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
throw ex;
}
return(archivoDeBytes);
}
public string AlmacenarDeclaracionProvisional(DeclaracionProvisional pro, string xmlDeclaracion, string xmlSatMessage, string pdfBase64, string htmlBase64)
{
string uriBlob = string.Empty;
try
{
RegistroEvento.Informacion(String.Format("Inicia AlmacenarDeclaracionProvisional con los sigs datos, rfc {0}, idDeclaracion {1}, ejercicio {2}, tipo decla {3}",
pro.rfc, pro.idDeclaracion, pro.ejercicio, pro.tipoDeclaracion), CodigoEvento.InformacionNegocio, String.Empty, "Declaracion");
using (var administrador = new AdministradorDeclaracion())
{
uriBlob = administrador.RecibeDeclaracionDyp(pro, xmlDeclaracion, xmlSatMessage, pdfBase64, htmlBase64);
}
RegistroEvento.Informacion(String.Format("Termino sin Error AlmacenarDeclaracionProvisional con los sigs datos, rfc {0}, idDeclaracion {1}, ejercicio {2}, tipo decla {3}",
pro.rfc, pro.idDeclaracion, pro.ejercicio, pro.tipoDeclaracion), CodigoEvento.InformacionNegocio, String.Empty, "Declaracion");
}
catch (Exception ex)
{
RegistraEvento.Instancia.EscribeEvento(ex);
RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
throw ex;
}
return(uriBlob);
}
public ActionResult RecibeDeclaracion(string data)
{
ResultadoViewModel resultado = null;
try
{
ContribuyenteInfo contribuyente = this.ContribuyenteAutenticado();
string idDeclaracion = data;
string mensajeError;
string uriArchivoAcuse;
using (Declaracion negocioDeclaracion = new Declaracion())
{
uriArchivoAcuse = negocioDeclaracion.RecibeDeclaracion(contribuyente.Rfc, idDeclaracion, out mensajeError);
}
if (string.IsNullOrEmpty(mensajeError))
{
resultado = new ResultadoViewModel()
{
EsValido = true,
Archivo = uriArchivoAcuse,
};
}
else
{
resultado = new ResultadoViewModel()
{
EsValido = false, Mensaje = mensajeError
};
}
}
catch (Exception ex)
{
resultado = new ResultadoViewModel()
{
EsValido = false,
Mensaje =
"Se generó un error al recibir la declaración. Inténtelo nuevamente."
};
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, "DeclaracionController");
}
var jsonResult = this.Json(resultado, JsonRequestBehavior.AllowGet);
jsonResult.MaxJsonLength = int.MaxValue;
return(jsonResult);
}
/// <summary>
/// Agregamos valores fijos a la declaración
/// </summary>
/// <param name="declaracion">Declaración</param>
/// <param name="conFirma">Variable si la declaración viene firmada</param>
/// <param name="numeroCertificado">Numero de certificado</param>
/// <param name="certificado">Certificado</param>
/// <param name="firma">Firma</param>
/// <returns>Declaración con los valores agregados</returns>
private string agregaValoresDeclaracion(string declaracion, bool conFirma, string numeroCertificado = "", string certificado = "", string firma = "", string folioFirmado = "")
{
XDocument doc = XDocument.Parse(declaracion);
string rfcTermina, alscTermina;
rfcTermina = alscTermina = string.Empty;
try
{
XElement entidad = doc.XPathSelectElement("//*[local-name()='modeloDatos']/*[local-name()='entidad' and @tipo='SAT_DATOS_GENERALES']");
if (conFirma)
{
Dictionary <string, string> atributosFirma = new Dictionary <string, string>()
{
{ "43", "true" },
{ "44", numeroCertificado },
{ "48", certificado },
{ "49", firma }
};
foreach (var dic in atributosFirma)
{
var propiedad = (from p in entidad.Elements()
where (string)p.Attribute("id") == dic.Key
select p
).SingleOrDefault();
propiedad.Value = dic.Value ?? "";
}
}
}
catch (Exception ex)
{
RegistraEvento.Instancia.EscribeEvento(ex);
RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
throw ex;
}
return(doc.ToString());
}
public string ObtenerCadenaOriginal(string rfc, string idDeclaracion)
{
string cadenaOriginalBase64 = string.Empty;
try
{
// Obtenemos la declaración temporal
string declaracion = RecuperarXmlDeclaracionTemporal(rfc, idDeclaracion, false);
// Obtenemos la cadena original
string cadenaOriginal = Sellado.Herramienta.CadenaOriginal.Instancia.ObtenCadenaOriginal(declaracion, TipoCadenaOriginal.FirmaCliente);
cadenaOriginalBase64 = Utileria.Instancia.CodificarBase64(cadenaOriginal);
}
catch (Exception ex)
{
RegistraEvento.Instancia.EscribeEvento(ex);
RegistroEvento.Error(ref ex, CodigoEvento.ErrorInfraestrucura, GetType().Name);
throw ex;
}
return(cadenaOriginalBase64);
}
public ActionResult VistaPrevia(string id)
{
ActionResult vista = this.View(RecursoClasificador.ParcialErrorEnPermisos);
var encabezado = new EncabezadoDypClasificador();
try
{
ContribuyenteInfo contribuyente = this.ContribuyenteAutenticado();
if (!string.IsNullOrEmpty(id) && this.PeticionDesdeLugarReferido() && contribuyente.Espms)
{
vista = RedirectToAction("Abrir", new { id });
}
}
catch (Exception ex)
{
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, RecursoClasificador.ErrorEnAutenticacion, null, null, origen: RecursoClasificador.ClasificadorOrigen);
}
TempData[TEMP_DATA_ENCABEZADO] = encabezado;
return(vista);
}
public ActionResult ObtenerCadenaOriginal(string data)
{
ResultadoViewModel resultado = null;
try
{
ContribuyenteInfo contribuyente = this.ContribuyenteAutenticado();
string cadenaOriginal = string.Empty;
var parametro = System.Web.Helpers.Json.Decode(data);
string rfc = contribuyente.Rfc;
string idDeclaracion = parametro["idDeclaracion"];
using (var declaracion = new Declaracion())
{
cadenaOriginal = declaracion.ObtenerCadenaOriginal(rfc, idDeclaracion);
}
resultado = new ResultadoViewModel()
{
EsValido = true,
Archivo = cadenaOriginal,
Contribuyente = contribuyente
};
}
catch (Exception ex)
{
resultado = new ResultadoViewModel()
{
EsValido = false,
Mensaje = "Se generó un error al obtener la cadena original. Inténtelo nuevamente."
};
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, "DeclaracionController");
}
var jsonResult = this.Json(resultado, JsonRequestBehavior.AllowGet);
jsonResult.MaxJsonLength = int.MaxValue;
return(jsonResult);
}
public ActionResult AbrirEmpleado(string id)
{
ActionResult vista = this.View(RecursoClasificador.ParcialErrorEnPermisos);
var declaracion = new DeclaracionClasificador();
string limpio = string.Empty;
try
{
if (ConfiguracionApp.AdaptadorCloud.RecuperarBoolean("IsPortalEmpleado"))
{
var empleado = this.ObtieneInfoEmpleado();
var encriptador = new Sat.DyP.Herramientas.Encripcion.Encripcion();
var datosEntrada = encriptador.DesencriptaCadena(id, Sat.DyP.Herramientas.Encripcion.TipoEncripcion.Base64URL);
if (!string.IsNullOrEmpty(datosEntrada))
{
var configs = datosEntrada.Split(',').Where(x => x.Contains("re:")).FirstOrDefault();
var rfcContribuyente = datosEntrada.Split(',').Where(x => x.Contains("r:")).FirstOrDefault();
var rfcEmpleado = string.Empty;
if (!string.IsNullOrEmpty(configs))
{
rfcEmpleado = configs.Replace("re:", string.Empty);
rfcContribuyente = !string.IsNullOrEmpty(rfcContribuyente) ? rfcContribuyente.Replace("r:", string.Empty) : rfcEmpleado;
// Llamada desde empleado
if (rfcEmpleado == empleado.Rfc)
{
bool contribuyenteValido = this.ObtieneInfoContribuyenteEmpleado(rfcContribuyente);
if (contribuyenteValido)
{
ContribuyenteInfo contribuyente = MemberCache.Instancia.UsuarioActual;
if (!string.IsNullOrEmpty(id) && contribuyente.Espms)
{
declaracion = DeclaracionClasificadorComplementos.ObtenerDeclaracionDedeUrl(id);
var declaracionTemporal = declaracion.ActualizarDeclaracionPorAbrirDeclaracion();
if (contribuyente.Rfc == declaracion.Rfc)
{
var idencriptado = declaracionTemporal.CodigoDeterminacionEncirptado(string.Empty);
vista = Redirect(string.Format(RecursoClasificador.UrlDeterminacion, idencriptado));
}
else
{
var ex = new Exception("Rfc no es el mismo");
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, RecursoClasificador.ErrorEnAutenticacion,
limpio, null, origen: System.Reflection.MethodBase.GetCurrentMethod().Name);
}
}
else
{
var ex = new Exception("Intento entrar");
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, RecursoClasificador.ErrorEnAutenticacion, limpio, null, origen: System.Reflection.MethodBase.GetCurrentMethod().Name);
}
}
}
}
}
}
}
catch (Exception ex)
{
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, RecursoClasificador.ErrorEnAutenticacion, null, null, origen: System.Reflection.MethodBase.GetCurrentMethod().Name);
}
return(vista);
}
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);
}
public ActionResult AlmacenarDeclaracionTemporal(string data = "")
{
ResultadoViewModel resultado = new ResultadoViewModel();
ContribuyenteInfo contribuyente = this.ContribuyenteAutenticado();
try
{
if (!string.IsNullOrEmpty(data))
{
dynamic parametro = Newtonsoft.Json.JsonConvert.DeserializeObject(data);
string xmldeclaracion = parametro.xmldeclaracion;
string rfc = contribuyente.Rfc;
string idDeclaracion = parametro.iddeclaracion;
int ejercicio = parametro.ejercicio;
string periodo = parametro.periodo;
string periodoDescripcion = parametro.periododesc;
string periodicidad = parametro.periodicidad;
string periodicidadDescripcion = parametro.periodicidaddesc;
string tipoDeclaracion = parametro.tipodeclaracion;
string tipoDeclaracionDescripcion = parametro.tipodeclaraciondesc;
string tipoComplementaria = parametro.tipocomplementaria;
string tipoComplementariaDescripcion = parametro.tipocomplementariadesc;
string NoReforma = parametro.noreforma;
bool contieneErrores = parametro.errores ?? false;
string uriBlob = string.Empty;
using (var declaracion = new Declaracion())
{
uriBlob = declaracion.AlmacenarDeclaracionTemporal(xmldeclaracion, rfc, idDeclaracion, ejercicio,
periodo, periodoDescripcion, periodicidad, periodicidadDescripcion,
tipoDeclaracion, tipoDeclaracionDescripcion, tipoComplementaria, tipoComplementariaDescripcion, NoReforma,
contieneErrores);
}
if (string.IsNullOrWhiteSpace(uriBlob))
{
resultado = new ResultadoViewModel()
{
Excepcion = "Error desconocido.",
EsValido = false,
Mensaje = "Se generó un error al guardar la declaración. Inténtelo nuevamente."
};
var ex =
new Exception("Se generó un error al guardar la declaración, URI vacío en AlmacenarDeclaracionTemporal");
RegistroEvento.Error(
ref ex,
CodigoEvento.ErrorNegocio,
"DeclaracionController",
rfc: rfc,
regimen: idDeclaracion,
ejercicio: ejercicio.ToString(),
tipoDeclaracion: tipoDeclaracion,
origen: "Portal");
}
else
{
/*Se regresa el idDeclaración encriptado para envíos en claro desde la url*/
resultado = new ResultadoViewModel()
{
EsValido = true,
Mensaje = new Sat.DyP.Herramientas.Encripcion.Encripcion().EncriptaCadena(idDeclaracion, Sat.DyP.Herramientas.Encripcion.TipoEncripcion.Base64URL)
};
}
}
else
{
string mensajeError =
string.Format(
"El parametro viene vacio en AlmacenarDeclaracionTemporal para el RFC: {0}",
contribuyente != null && !string.IsNullOrEmpty(contribuyente.Rfc)
? contribuyente.Rfc
: "NULO");
RegistroEvento.Informacion(
mensajeError,
CodigoEvento.InformacionNegocio,
"DeclaracionController",
null);
resultado = new ResultadoViewModel()
{
Excepcion =
"El parámetro data viene vecío en AlmacenarDeclaracionTemporal",
EsValido = false,
Mensaje = mensajeError
};
}
}
catch (Exception ex)
{
resultado = new ResultadoViewModel()
{
EsValido = false,
Mensaje =
"Se generó un error al guardar la declaración. Inténtelo nuevamente."
};
RegistroEvento.Error(
ref ex,
CodigoEvento.ErrorNegocio,
"DeclaracionController",
rfc: contribuyente != null && !string.IsNullOrEmpty(contribuyente.Rfc) ? contribuyente.Rfc : "NULO");
}
return(this.Json(resultado, JsonRequestBehavior.AllowGet));
}
public ActionResult RecibeDeclaracionFirmada(string data)
{
ResultadoViewModel resultado = null;
try
{
ContribuyenteInfo contribuyente = this.ContribuyenteAutenticado();
string uriArchivoAcuse = string.Empty;
var parametro = System.Web.Helpers.Json.Decode(data);
string mensajeError;
string rfc = contribuyente.Rfc;
string idDeclaracion = parametro["idDeclaracion"];
string numeroCertificado = parametro["numeroCertificado"];
string firma = parametro["firma"];
string folioFirmado = parametro["folioStampCertificado"];
using (var declaracion = new Declaracion())
{
uriArchivoAcuse = declaracion.RecibeDeclaracionFirmada(
new Sat.DyP.Herramientas.Entidad.Declaracion.ReciboDeclaracionFirmada()
{
rfc = rfc,
firma = firma,
folioFirmado = folioFirmado,
idDeclaracion = idDeclaracion,
numeroCertificado = numeroCertificado
}, out mensajeError);
}
if (string.IsNullOrEmpty(mensajeError))
{
resultado = new ResultadoViewModel()
{
EsValido = true,
Archivo = uriArchivoAcuse,
Mensaje = ""
};
}
else
{
resultado = new ResultadoViewModel()
{
EsValido = false, Mensaje = mensajeError
};
}
}
catch (Exception ex)
{
resultado = new ResultadoViewModel()
{
EsValido = false,
Mensaje =
"Se generó un error al recibir la declaración. Inténtelo nuevamente."
};
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, "DeclaracionController");
}
var jsonResult = this.Json(resultado, JsonRequestBehavior.AllowGet);
jsonResult.MaxJsonLength = int.MaxValue;
return(jsonResult);
}
public ActionResult ObtenerPlantilla(string data)
{
ResultadoViewModel resultado = null;
try
{
ContribuyenteInfo contribuyente = this.ContribuyenteAutenticado();
string idAlscEmpleado = string.Empty;
string rfcEmpleado = string.Empty;
string mensaje = string.Empty;
string formulario = "new";
int codigoRespuesta = (int)CodigoRespuestaGeneral.OK;
List <string> xmlBase64 = new List <string>();
if (contribuyente == null)
{
new HomeController().ObtieneInfoFederacion();
contribuyente = MemberCache.Instancia.UsuarioActual;
}
if (ConfiguracionApp.AdaptadorCloud.RecuperarBoolean("IsPortalEmpleado"))
{
idAlscEmpleado = MemberCache.Instancia.EmpleadoActual.Alsc;
rfcEmpleado = MemberCache.Instancia.EmpleadoActual.Rfc;
}
dynamic parametro = JsonConvert.DeserializeObject(data);
parametro.Rfc = contribuyente.Rfc;
parametro.TipoContribuyente = contribuyente.TipoContribuyente;
parametro.MetodoAutenticacion = contribuyente.MetodoAutenticacion;
parametro.idAlscEmpleado = idAlscEmpleado;
parametro.rfcEmpleado = rfcEmpleado;
var declaracion = new Sat.DeclaracionesAnuales.Portal.Negocio.Declaraciones.Declaracion();
declaracion.obtieneTotales += (r, e, p, d) => {
return(new Sat.DyP.Clasificador.Negocio.AdministradorTotalesClasificador(int.Parse(e)).ObtenerTotalesGuardadosCalculados(r, int.Parse(e), int.Parse(p), int.Parse(d)));
};
xmlBase64 = declaracion.ObtenerPlantillaObligaciones(parametro, out formulario, out codigoRespuesta);
resultado = new ResultadoViewModel()
{
EsValido = (CodigoRespuestaGeneral)codigoRespuesta == CodigoRespuestaGeneral.OK,
Xml = xmlBase64,
Formulario = formulario,
Contribuyente = contribuyente
};
}
catch (Exception ex)
{
resultado = new ResultadoViewModel()
{
EsValido = false,
Mensaje = "Se generó un error al obtener la plantilla de la declaración. Inténtelo nuevamente."
};
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, "DeclaracionController");
}
var jsonResult = this.Json(resultado, JsonRequestBehavior.AllowGet);
jsonResult.MaxJsonLength = int.MaxValue;
return(jsonResult);
}
public ActionResult Abrir(string id)
{
ActionResult vista = this.View(RecursoClasificador.ParcialErrorEnPermisos);
var encabezado = new EncabezadoDypClasificador();
try
{
ContribuyenteInfo contribuyente = this.ContribuyenteAutenticado();
// TODO: Incluir la petición desde lugar referido
// this.PeticionDesdeLugarReferido() :
if (!string.IsNullOrEmpty(id) && contribuyente.Espms)
{
DeclaracionClasificador declaracion = DeclaracionClasificadorComplementos.ObtenerDeclaracionDedeUrl(id);
var encriptador = new Sat.DyP.Herramientas.Encripcion.Encripcion();
var limpio = encriptador.DesencriptaCadena(id, Sat.DyP.Herramientas.Encripcion.TipoEncripcion.Base64URL);
this.ImportarDatos(declaracion);
if (contribuyente.Rfc == declaracion.Rfc)
{
declaracion.ActualizarDeclaracionPorAbrirDeclaracion();
var pago = new DeterminacionPagoDyP();
var respuesta = pago.ConsultarOpcPagoISREnClasificador(declaracion.Ejercicio, declaracion.Rfc);
bool ocisr = string.IsNullOrEmpty(respuesta);
var idencriptado = declaracion.CodigoEncirptado(contribuyente.Token);
encabezado = declaracion.ObtenerEncabezado();
/********************************************************************************************************************/
var parameters = new Dictionary <int, Dictionary <string, string> >();
string IdDeclaracion = limpio.Split(',').Where(i => i.Contains("idd")).FirstOrDefault().Split(':')[1];
string IdReforma = limpio.Split(',').Where(i => i.Contains("ref")).FirstOrDefault().Split(':')[1];
//if (limpio.Split(',').Where(i => i.Contains("redi")).FirstOrDefault() == null)
//{
// vista = Redirect("VistaPrevia/" + encriptador.EncriptaCadena("r:" + declaracion.Rfc + ",idd:" + IdDeclaracion + ",ref:" + IdReforma + "redi:0", Sat.DyP.Herramientas.Encripcion.TipoEncripcion.Base64URL));
//}
//else
//{
parameters.Add(0, new Dictionary <string, string>()
{
{ "NoReforma", IdReforma },
{ "OpcionCalculoISR", ocisr ? "-1" : respuesta }
});
parameters.Add(1, new Dictionary <string, string>()
{
{ "NoDeclaracion", IdDeclaracion },
{ "presentaDeclaracion", "true" },
{ "muestraOCISR", ocisr ? "1" : "0" }
});
/********************************************************************************************************************/
this.ViewBag.Info = declaracion.ParametrosVistaPrevia(parameters);
ViewBag.idencriptado = idencriptado;
vista = View("VistaPrevia");
//}
}
}
}
catch (Exception ex)
{
RegistroEvento.Error(ref ex, CodigoEvento.ErrorNegocio, RecursoClasificador.ErrorEnAutenticacion, null, null, origen: RecursoClasificador.ClasificadorOrigen);
}
TempData[TEMP_DATA_ENCABEZADO] = encabezado;
return(vista);
}