public void Ejecutar()
{
reiniciarEjecucion();
definirContextoGlobal();
Contexto local = new Contexto();
foreach (ParseTreeNode declaracion in variables)
{
Declaracion decla = new Declaracion(declaracion);
decla.ejecutar(local, Constantes.GLOBAL);
}
Console.WriteLine("contexto global creado");
if (Principal == null)
{
ListaErrores.getInstance().nuevoErrorGeneral("El metodo principal no ha sido definido", archivo);
return;
}
Cuerpo _principal = new Cuerpo(Principal.ChildNodes[0], false);
_principal.ejecutar(local, Constantes.GLOBAL + 1);
Console.WriteLine("Ejecucion Exitosa");
Console.WriteLine("Salida");
Interprete.getContextoGlobal().reporte();
local.reporte();
Console.WriteLine(Interprete.Salida);
}
private Instruccion getInstruccion(ParseTreeNode instr)
{
switch (instr.Term.Name)
{
case Constantes.expresion: //para las llamadas
{
int noHijos = instr.ChildNodes.Count;
ExpresionLlamada nuevaLlamada;
if (instr.ChildNodes[noHijos - 1].Term.Name.Equals(Constantes.llamada, StringComparison.OrdinalIgnoreCase))
{
nuevaLlamada = new ExpresionLlamada(instr);
return(nuevaLlamada);
}
else
{
ErrorA err = new ErrorA(Constantes.errorSemantico, "En invalido colocar este tipo de expresion, debe ser una llamada", instr.Token);
Form1.errores.addError(err);
return(null);
}
}
case Constantes.declaracion: {
Declaracion nuevo = new Declaracion(instr);
return(nuevo);
}
}
return(null);
}
public async Task Add(Declaracion declaracion)
{
using (IDbConnection db = new SqlConnection(connectionString))
{
string sqlCommand = "INSERT INTO [dbo].[Declaraciones] ([ID],[Gestion],[FuncionarioID],[FechaLlenado],[Estado],[FechaCreacion],[FechaActualización],[DeclaracionAnteriorID])";
sqlCommand = sqlCommand + " VALUES(@ID, @Gestion, @FuncionarioID, @FechaLlenado, @Estado, @FechaCreacion, @FechaActualizacion, @DeclaracionAnteriorID)";
DynamicParameters declaracionParameters = new DynamicParameters();
declaracionParameters.Add("@ID", declaracion.ID);
declaracionParameters.Add("@Gestion", declaracion.Gestion.Anio, DbType.Int32);
declaracionParameters.Add("@FuncionarioID", declaracion.FuncionarioID, DbType.Int32);
declaracionParameters.Add("@FechaLlenado", declaracion.FechaLlenado, DbType.DateTime);
declaracionParameters.Add("@Estado", declaracion.Estado, DbType.Int32);
declaracionParameters.Add("@FechaCreacion", DateTime.Now, DbType.DateTime);
declaracionParameters.Add("@FechaActualizacion", DateTime.Now, DbType.DateTime);
if (declaracion.DeclaracionAnterior != null)
{
declaracionParameters.Add("@DeclaracionAnteriorID", declaracion.DeclaracionAnterior.ID);
}
else
{
declaracionParameters.Add("@DeclaracionAnteriorID", DBNull.Value);
}
int rows = await db.ExecuteAsync(sqlCommand, declaracionParameters);
}
}
public async Task <Declaracion> Get(Gestion gestion, int funcionarioID)
{
using (IDbConnection db = new SqlConnection(connectionString))
{
string declaracionSQL = "SELECT * FROM Declaraciones WHERE Gestion = @Anio AND FuncionarioID = @funcionarioID Order by FechaActualización DESC";
Entities.DeclaracionPatrimonial declaracion = await db
.QueryFirstOrDefaultAsync <Entities.DeclaracionPatrimonial>(declaracionSQL, new { gestion.Anio, funcionarioID });
if (declaracion == null)
{
return(null);
}
var declaracionID = declaracion.ID;
DepositoCollection depositosCollection = await ReadDepositoCollection(declaracionID, db);
DeudaBancariaCollection deudasCollection = await ReadDeudasCollection(declaracionID, db);
InmuebleCollection inmueblesCollection = await ReadInmueblesCollection(declaracionID, db);
OtroIngresoCollection otrosIngresosCollection = await ReadOtrosIngresosCollection(declaracionID, db);
ValorNegociableCollection valoresNegociablesCollection = await ReadValoresNegociablesCollection(declaracionID, db);
VehiculoCollection vehiculosCollection = await ReadVehiculosCollection(declaracionID, db);
Declaracion result = Declaracion.Load(declaracion.ID, declaracion.FuncionarioID, gestion, declaracion.FechaLlenado, (EstadoDeclaracion)Enum.Parse(typeof(EstadoDeclaracion), declaracion.Estado),
depositosCollection, deudasCollection, inmueblesCollection, otrosIngresosCollection, valoresNegociablesCollection, vehiculosCollection, null);
return(result);
}
}
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 GeneradorNecesidadBasica(IContenedorMetodos <TDestino> contenedorMetodos) : base(contenedorMetodos)
{
_declaracion = new Declaracion();
RegistrarMetodo(f => f.Id, (tr, persona) => ConsultarDeclaracion(tr, persona).Id);
RegistrarMetodo(f => f.Barrio, (tr, persona) => ConsultarContacto(tr, persona, ContactoBarrioId).Descripcion);
RegistrarMetodo(f => f.Celular, (tr, persona) => ConsultarContacto(tr, persona, ContactoCelularId).Descripcion);
RegistrarMetodo(f => f.Declaracion, (tr, persona) => ConsultarDeclaracion(tr, persona).Numero_Declaracion);
RegistrarMetodo(f => f.Direccion, (tr, declaracion) => ConsultarContacto(tr, declaracion, ContactoDireccionId).Descripcion);
RegistrarMetodo(f => f.EnLinea, (tr, persona) => ConsultarDescripcionPorId(tr, ConsultarDeclaracion(tr, persona).Id_EnLinea));
RegistrarMetodo(f => f.FechaAtencion, (tr, persona) => ConsultarFechaAtencion(tr, persona));
RegistrarMetodo(f => f.FechaDeclaracion, (tr, persona) => ConsultarDeclaracion(tr, persona).Fecha_Declaracion);
RegistrarMetodo(f => f.FechaDesplazamiento, (tr, persona) => ConsultarDeclaracion(tr, persona).Fecha_Desplazamiento);
RegistrarMetodo(f => f.FechaRadicacion, (tr, persona) => ConsultarDeclaracion(tr, persona).Fecha_Radicacion);
RegistrarMetodo(f => f.Fuente, (tr, persona) => ConsultarDescripcionPorId(tr, ConsultarDeclaracion(tr, persona).Id_Fuente));
RegistrarMetodo(f => f.Grupo, (tr, persona) => ConsultarDescripcionPorId(tr, ConsultarDeclaracion(tr, persona).Id_Grupo));
RegistrarMetodo(f => f.Horario, (tr, persona) => ConsultarDeclaracion(tr, persona).Horario);
RegistrarMetodo(f => f.Identificacion, (tr, persona) => persona.Identificacion);
RegistrarMetodo(f => f.MunicipioAtencion, (tr, persona) => ConsultarDescripcionPorId(tr, ConsultarDeclaracion(tr, persona).Id_lugar_fuente));
RegistrarMetodo(f => f.PrimerApellido, (tr, persona) => persona.Primer_Apellido);
RegistrarMetodo(f => f.PrimerNombre, (tr, persona) => persona.Primer_Nombre);
RegistrarMetodo(f => f.Regional, (tr, persona) => ConsultarDescripcionPorId(tr, ConsultarDeclaracion(tr, persona).Id_Regional));
RegistrarMetodo(f => f.SegundoApellido, (tr, persona) => persona.Segundo_Apellido);
RegistrarMetodo(f => f.SegundoNombre, (tr, persona) => persona.Segundo_Nombre);
RegistrarMetodo(f => f.Telefono, (tr, declaracion) => ConsultarContacto(tr, declaracion, ContactoTelefonoId).Descripcion);
RegistrarMetodo(f => f.TFE, (tr, persona) => ConsultarTFE(tr, persona));
RegistrarMetodo(f => f.TFR, (tr, persona) => ConsultarTFR(tr, persona));
RegistrarMetodo(f => f.TI, (tr, persona) => ConsultarDescripcionPorId(tr, persona.Id_Tipo_Identificacion));
RegistrarMetodo(f => f.TipoDeclarante, (tr, persona) => ConsultarDescripcionPorId(tr, ConsultarDeclaracion(tr, persona).Tipo_Declaracion));
}
public void ValorADeclararCeroConEmplazamiento()
{
var fechaDeclaracion = DateTime.Parse("01/05/2018 8:34:01");
var fechaDeclarar = DateTime.Parse("13/05/2018 8:34:01");
var valor = 0;
Declaracion declaracion = new Declaracion(valor, fechaDeclarar, fechaDeclaracion, true);
Assert.AreEqual("Sanción por extemporaneidad: 624984", declaracion.LiquidarSancion());
}
public async Task <Declaracion> Get(Guid declaracionID, bool loadDeclaracionAnterior = false)
{
using (IDbConnection db = new SqlConnection(connectionString))
{
string declaracionSQL = "SELECT * FROM Declaraciones WHERE ID = @declaracionID";
var declaracion = await db
.QueryFirstOrDefaultAsync <Entities.DeclaracionPatrimonial>(declaracionSQL, new { declaracionID });
if (declaracion == null)
{
return(null);
}
var gestion = await db.QueryFirstOrDefaultAsync <Entities.GestionSchema>("SELECT * FROM Gestiones WHERE Gestion = @gestion", new { declaracion.Gestion });
DepositoCollection depositosCollection = await ReadDepositoCollection(declaracionID, db);
DeudaBancariaCollection deudasCollection = await ReadDeudasCollection(declaracionID, db);
InmuebleCollection inmueblesCollection = await ReadInmueblesCollection(declaracionID, db);
OtroIngresoCollection otrosIngresosCollection = await ReadOtrosIngresosCollection(declaracionID, db);
ValorNegociableCollection valoresNegociablesCollection = await ReadValoresNegociablesCollection(declaracionID, db);
VehiculoCollection vehiculosCollection = await ReadVehiculosCollection(declaracionID, db);
Declaracion declaracionAnterior = null;
if (loadDeclaracionAnterior && declaracion.DeclaracionAnteriorID != Guid.Empty)
{
var declaracionAnteriorID = declaracion.DeclaracionAnteriorID;
DepositoCollection depositosAnteriorCollection = await ReadDepositoCollection(declaracionAnteriorID, db);
DeudaBancariaCollection deudasAnteriorCollection = await ReadDeudasCollection(declaracionAnteriorID, db);
InmuebleCollection inmueblesAnteriorCollection = await ReadInmueblesCollection(declaracionAnteriorID, db);
OtroIngresoCollection otrosAnteriorIngresosCollection = await ReadOtrosIngresosCollection(declaracionAnteriorID, db);
ValorNegociableCollection valoresAnteriorNegociablesCollection = await ReadValoresNegociablesCollection(declaracionAnteriorID, db);
VehiculoCollection vehiculosAnteriorCollection = await ReadVehiculosCollection(declaracionAnteriorID, db);
declaracionAnterior = Declaracion.Load(declaracionAnteriorID, declaracion.FuncionarioID, Gestion.For(gestion.Gestion,
gestion.FechaInicio, gestion.FechaFinal, gestion.Vigente), declaracion.FechaLlenado, (EstadoDeclaracion)Enum.Parse(typeof(EstadoDeclaracion), declaracion.Estado),
depositosAnteriorCollection, deudasAnteriorCollection, inmueblesAnteriorCollection, otrosAnteriorIngresosCollection, valoresAnteriorNegociablesCollection,
vehiculosAnteriorCollection, null);
}
Declaracion result = Declaracion.Load(declaracion.ID, declaracion.FuncionarioID, Gestion.For(gestion.Gestion,
gestion.FechaInicio, gestion.FechaFinal, gestion.Vigente), declaracion.FechaLlenado, (EstadoDeclaracion)Enum.Parse(typeof(EstadoDeclaracion), declaracion.Estado),
depositosCollection, deudasCollection, inmueblesCollection, otrosIngresosCollection, valoresNegociablesCollection, vehiculosCollection, declaracionAnterior);
return(result);
}
}
public async Task Update(Declaracion declaracion)
{
var declaracionAnterior = _context.Declaraciones
.Where(c => c.ID == declaracion.ID)
.SingleOrDefault();
declaracionAnterior = declaracion;
await Task.CompletedTask;
}
public void TestDeclararMayorACeroSinEmplazamiento()
{
// TODO: Add your test code here
var fechaDeclaracion = DateTime.Parse("01/05/2018 8:34:01");
var fechaDeclarar = DateTime.Parse("13/05/2018 8:34:01");
var valor = 1000000;
Declaracion declaracion = new Declaracion(valor, fechaDeclarar, fechaDeclaracion, false);
Assert.AreEqual("Sanción por extemporaneidad: 600000,00", declaracion.LiquidarSancion());
}
/*
* METODO QUE GENERA UN IDENTIFICADOR CON LA DECLARACION DE PARAMETROS
* @return string con identificador
*/
private string generarIdentificadorDeclaracion()
{
string result = "";
foreach (InstruccionCQL i in parametros)
{
Declaracion d = (Declaracion)i;
result += "_" + d.tipo;
}
return(result);
}
protected Declaracion ConsultarDeclaracion(TablasRango tablasRango, Personas persona)
{
(_declaracion.Id != persona.Id_Declaracion)
.SiCumpleEntonces(() => {
_declaracion = tablasRango.Declaracion
.FirstOrDefault(x => x.Id == persona.Id_Declaracion)
?? new Declaracion();
});
return(_declaracion);
}
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);
}
private string getIdentificador(string id, LinkedList <listaParametros> lista)
{
string identificador = id;
foreach (listaParametros parametro in lista)
{
foreach (InstruccionCQL ins in parametro.lista)
{
Declaracion d = (Declaracion)ins;
identificador += "_" + d.tipo;
}
}
return(identificador);
}
public async Task Execute(Guid declaracionID)
{
var declaracion = await _declaracionReadOnlyRepository.Get(declaracionID, true);
var gestiones = await _gestionReadOnlyRepository.GetAll();
var gestionVigente = gestiones.Where(c => c.Vigente).FirstOrDefault();
declaracion.CambiarEstado(EstadoDeclaracion.Anulada);
await _declaracionWriteOnlyRepository.UpdateEstado(declaracionID, EstadoDeclaracion.Anulada);
var declaracionAnterior = declaracion.DeclaracionAnterior != null ?
declaracion.DeclaracionAnterior :
Declaracion.Load(Guid.NewGuid(), declaracion.FuncionarioID, Gestion.For(gestionVigente.Anio, gestionVigente.FechaInicio, gestionVigente.FechaFinal, gestionVigente.Vigente),
DateTime.Now, EstadoDeclaracion.Pendiente,
new DepositoCollection(), new DeudaBancariaCollection(), new InmuebleCollection(), new OtroIngresoCollection(),
new ValorNegociableCollection(), new VehiculoCollection(), null);
var declaracionNueva = Declaracion.Load(Guid.NewGuid(), declaracionAnterior.FuncionarioID, Gestion.For(gestionVigente.Anio, gestionVigente.FechaInicio, gestionVigente.FechaFinal, gestionVigente.Vigente),
DateTime.Now, EstadoDeclaracion.Pendiente, declaracionAnterior.Depositos, declaracionAnterior.DeudasBancarias, declaracionAnterior.Inmuebles,
declaracionAnterior.OtrosIngresos, declaracionAnterior.ValoresNegociables, declaracionAnterior.Vehiculos, declaracionAnterior);
await _declaracionWriteOnlyRepository.Add(declaracionNueva);
foreach (var item in declaracionAnterior.Depositos.GetItems())
{
await _depositoWriteOnlyRepository.Add(new Domain.Depositos.DepositoMayor10K(declaracionNueva.ID, item.InstitucionFinanciera, item.TipoDeCuenta, item.Saldo));
}
foreach (var item in declaracionAnterior.Inmuebles.GetItems())
{
await _inmuebleWriteOnlyRepository.Add(new Domain.Inmuebles.Inmueble(declaracionNueva.ID, item.Direccion, item.TipoDeInmueble, item.PorcentajeParticipacion,
item.ValorComercial, item.SaldoHipoteca, item.Banco));
}
foreach (var item in declaracionAnterior.Vehiculos.GetItems())
{
await _vehiculoWriteOnlyRepository.Add(new Domain.Vehiculos.Vehiculo(declaracionNueva.ID, item.Marca, item.TipoVehiculo, item.Anio, item.ValorAproximado, item.SaldoDeudor, item.Banco));
}
foreach (var item in declaracionAnterior.OtrosIngresos.GetItems())
{
await _otroIngresoWriteOnlyRepository.Add(new Domain.OtrosIngresos.OtroIngreso(declaracionNueva.ID, item.Concepto, item.IngresoMensual));
}
foreach (var item in declaracionAnterior.ValoresNegociables.GetItems())
{
await _valorNegociableWriteOnlyRepository.Add(new Domain.ValoresNegociables.ValorNegociableMayor10K(declaracionNueva.ID, item.Descripcion, item.TipoValor, item.ValorAproximado));
}
foreach (var item in declaracionAnterior.DeudasBancarias.GetItems())
{
await _deudaBancariaWriteOnlyRepository.Add(new Domain.DeudasBancarias.DeudaBancariaMayor10K(declaracionNueva.ID, item.InstitucionFinanciera, item.Monto, item.Tipo));
}
}
private Comando ParsearComando()
{
Comando result = null;
TokenType tipo = lexer.tokenActual.Type;
switch (tipo)
{
case TokenType.print:
result = ParsearComandoPrint();
break;
case TokenType.procedure:
Declaracion declaracion = ParsearDeclaracionDeProcedimiento();
result = new ComandoNulo(declaracion);
break;
case TokenType.IF:
result = ParsearComandoIf();
break;
case TokenType.FOR:
result = ParsearComandoFor();
break;
case TokenType.begin:
result = ParsearBloque();
break;
case TokenType.id:
result = ParserComandoCreateOCall();
break;
case TokenType.EVAL:
result = ParsearComandoEval();
break;
case TokenType.comentarioDeLinea:
result = ParserComentarioDeLinea();
break;
default:
string hileraConProblemas = lexer.tokenActual.Valor;
throw new LanguageException("Se encontró con un '" + hileraConProblemas + "' donde se esperaba que inicie un comando.");
}
ultimoComandoValido = result;
return(result);
}
public async Task <bool> Execute(string webServerURL, string fromAddress)
{
var queueItems = await _getNotificationQUserCase.ExecuteList(QueueStatus.Queued);
var result = false;
foreach (var item in queueItems)
{
try
{
var userProfile = await _funcionarioUsuarioReadOnlyRepository.Get(item.UserName);
if (userProfile == null)
{
throw new ApplicationException($"El usuario {item.UserName} no tiene un Funcionario asociado");
}
var cabeceraNotificacion = new CabeceraEmailOutput(fromAddress, userProfile.Email, String.Empty, "SRDP - Se ha creado un nuevo formulario de Declaración Patrimonial para su usuario", DateTime.Now);
var gestionVigente = await _getGestionesUserCase.GestionVigente();
var declaracion = new Declaracion(item.FuncionarioID,
new Gestion(gestionVigente.Anio, gestionVigente.FechaInicio, gestionVigente.FechaFinal, gestionVigente.Vigente), DateTime.Now, EstadoDeclaracion.Nueva);
await _declaracionWriteOnlyRepository.Add(declaracion);
string mensaje = CreateMensajeBody(webServerURL, declaracion);
var notificacion = new Notificacion(item.FuncionarioID, TipoNotificacion.Email, cabeceraNotificacion.JsonSerialize(), mensaje, false, false);
await _sendNotificacionUserCase.Execute(new NotificacionOutput(notificacion.ID, notificacion.FuncionarioID, notificacion.TipoNotificacion.ToString(),
notificacion.Cabecera, notificacion.Mensaje, notificacion.Procesado, notificacion.Leido, notificacion.FechaCreacion, notificacion.FechaModificacion));
var notificacionProcesada = await _updateNotificationQUserCase.Execute(new NotificacionQueueItem(item.FuncionarioID, item.UserName, ActionType.Alta, QueueStatus.Processed));
var queueItem = NotificacionQueueItem.Load(item.ID, item.FuncionarioID, item.UserName, ActionType.Alta, QueueStatus.Processed, item.CreateDate, DateTime.Now, String.Empty);
await _updateNotificationQUserCase.Execute(queueItem);
result = result && true;
}
catch (Exception ex)
{
var queueItem = NotificacionQueueItem.Load(item.ID, item.FuncionarioID, item.UserName, ActionType.Alta, QueueStatus.Error, item.CreateDate, DateTime.Now, ex.Message);
await _updateNotificationQUserCase.Execute(queueItem);
throw;
}
}
return(result);
}
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 async Task <ICollection <AlertaGeneralOutput> > ExecuteList(int gestion, decimal monto, string operador, decimal porcentaje)
{
var declaracionesAlerta = await _alertaGeneralReadOnlyRepository.GetFromGestion(gestion);
var result = new List <AlertaGeneralOutput>();
foreach (var item in declaracionesAlerta)
{
var declaracionActual = await _declaracionReadOnlyRepository.Get(item.DeclaracionID);
var declaracionAnterior = await _declaracionReadOnlyRepository.Get(item.DeclaracionAnteriorID);
var declaracion = Declaracion.Load(declaracionActual.ID, declaracionActual.FuncionarioID, declaracionActual.Gestion,
declaracionActual.FechaLlenado, declaracionActual.Estado, declaracionActual.Depositos, declaracionActual.DeudasBancarias, declaracionActual.Inmuebles,
declaracionActual.OtrosIngresos, declaracionActual.ValoresNegociables, declaracionActual.Vehiculos, declaracionAnterior);
item.SetMontosPatrimonio(declaracion.PatrimonioNeto, declaracion.PatrimonioNetoGestionAnterior,
declaracion.DiferenciaPatrimonio, declaracion.VariacionPorcentual);
result.Add(item);
}
if (monto > 0 && porcentaje > 0 && !String.IsNullOrEmpty(operador))
{
var condicionAlerta = new CondicionAlerta(operador);
switch (condicionAlerta.Operador)
{
case Domain.Enumerations.OperadorAlerta.Y:
result = result.Where(c => c.DiferenciaPatrimonio > monto && c.VariacionPorcentual > porcentaje).ToList();
break;
case Domain.Enumerations.OperadorAlerta.O:
result = result.Where(c => c.DiferenciaPatrimonio > monto || c.VariacionPorcentual > porcentaje).ToList();
break;
default:
break;
}
}
return(result);
}
public DeclaracionOutput(Declaracion declaracion, Funcionario funcionario, List <DepositoOutput> depositos,
List <DeudaBancariaOutput> deudasBancarias, List <InmuebleOutput> inmuebles, List <OtroIngresoOutput> otrosIngresos,
List <ValorNegociableOutput> valoresNegociables, List <VehiculoOutput> vehiculos, decimal patrimonioNeto, List <string> importante)
{
DeclaracionID = declaracion.ID;
Codigo = funcionario.Codigo;
Gestion = declaracion.Gestion.Anio;
NombreCompleto = funcionario.NombreFuncionario.ToString();
CedulaIdentidad = funcionario.CI.ToString();
FechaNacimiento = funcionario.FechaNacimiento;
EstadoCivil = funcionario.EstadoCivil.ToString();
FechaLlenado = declaracion.FechaLlenado;
Depositos = depositos;
DeudasBancarias = deudasBancarias;
Inmuebles = inmuebles;
OtrosIngresos = otrosIngresos;
ValoresNegociables = valoresNegociables;
Vehiculos = vehiculos;
PatrimonioNeto = patrimonioNeto;
Estado = declaracion.Estado.ToString();
EsEditable = declaracion.EsEditable;
Importante = importante;
}
public void EliminarAtributo(string atributo)
{
foreach (IInstruccion declaracion in declaraciones)
{
if (declaracion is Declaracion)
{
Declaracion dec = ((Declaracion)declaracion);
if (dec.identificadores.Contains(atributo))
{
declaraciones.Remove(declaracion);
return;
}
}
if (declaracion is DeclaracionStructComoAtributo)
{
DeclaracionStructComoAtributo dec = (DeclaracionStructComoAtributo)declaracion;
if (dec.id.Equals(atributo, System.StringComparison.InvariantCultureIgnoreCase))
{
declaraciones.Remove(declaracion);
return;
}
}
}
}
public async Task <ICollection <Declaracion> > GetByGestion(Gestion gestion)
{
using (IDbConnection db = new SqlConnection(connectionString))
{
string declaracionSQL = "SELECT * FROM Declaraciones WHERE Gestion = @Anio";
var declaraciones = await db.QueryAsync <Entities.DeclaracionPatrimonial>(declaracionSQL, new { gestion.Anio });
var outputResult = new List <Declaracion>();
if (declaraciones == null)
{
return(outputResult);
}
foreach (var declaracion in declaraciones)
{
outputResult.Add(Declaracion.Load(declaracion.ID, declaracion.FuncionarioID, gestion, declaracion.FechaLlenado,
(EstadoDeclaracion)Enum.Parse(typeof(EstadoDeclaracion), declaracion.Estado),
new DepositoCollection(), new DeudaBancariaCollection(), new InmuebleCollection(), new OtroIngresoCollection(),
new ValorNegociableCollection(), new VehiculoCollection(), null));
}
return(outputResult);
}
}
/*
* Metodo de la implementacion
* @ts tabla de simbolos global
* @user usuario que ejecuta la accion
* @baseD base de datos donde estamos ejecutando todo
* @mensajes linkedlist con la salida deseada
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje ms = new Mensaje();
TablaDeSimbolos newAmbito = new TablaDeSimbolos();
foreach (Simbolo s in ambito.tablaPadre)
{
newAmbito.AddLast(s);
}
if (tamanioTotalParametros() == valores.Count())
{
int index = 0;
//-------------------------------------------- CREACION Y ASIGNACION DE PARAMETROS --------------------------------------------------------------
for (int i = 0; i < parametros.Count(); i++)
{
LinkedList <InstruccionCQL> parametro = parametros.ElementAt(i).lista;
for (int j = 0; j < parametro.Count(); j++)
{
Declaracion d = (Declaracion)parametro.ElementAt(j);
d.parametro = true;
object rd = d.ejecutar(newAmbito, ambito, tsT);
if (rd == null)
{
return(null);
}
Asignacion a = new Asignacion(d.id, l, c, valores.ElementAt(index), "ASIGNACION");
a.tPadre = ts;
object ra = a.ejecutar(newAmbito, ambito, tsT);
if (ra == null)
{
return(null);
}
index++;
}
}
//--------------------------------------------------- INSTRUCCIONES DEL PROCEDURE ----------------------------------------------
foreach (InstruccionCQL ins in cuerpo)
{
object r = ins.ejecutar(newAmbito, ambito, tsT);
if (r == null)
{
return(null);
}
else if (r.GetType() == typeof(Retorno))
{
object re = ((Retorno)r).valor;
if (re != null)
{
LinkedList <object> temp;
if (re.GetType() == typeof(LinkedList <object>))
{
temp = (LinkedList <object>)re;
}
else
{
temp = new LinkedList <object>();
temp.AddLast(re);
}
string idGenerado = idOut(temp);
if (idGenerado == null)
{
return(null);
}
if (idGenerado.Equals(identificadorRetornos))
{
return(temp);
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("numberreturnsexception", "La cantidad de valores retornados no concuerda con el valor de parametros se esperaba: " + identificadorRetornos + " se obtuvo " + idGenerado));
ambito.mensajes.AddLast(ms.error("La cantidad de valores retornados no concuerda con el valor de parametros se esperaba: " + identificadorRetornos + " se obtuvo " + idGenerado, l, c, "Semantico"));
return(null);
}
}
return(null);
}
}
if (identificadorRetornos.Equals(""))
{
return("");
}
else
{
ambito.listadoExcepciones.AddLast(new Excepcion("numberreturnsexception", "Se necesita retornar valores de tipo: " + identificadorRetornos));
ambito.mensajes.AddLast(ms.error("Se necesita retornar valores de tipo: " + identificadorRetornos, l, c, "Semantico"));
return(null);
}
}
else
{
ambito.mensajes.AddLast(ms.error("La cantidad de valores no concuerda con la cantidad de parametros", l, c, "Semantico"));
}
return(null);
}
public override Expresion getValor(Entorno ent)
{
//ent en este caso es el main
LinkedList <Expresion> resueltos = new LinkedList <Expresion>();
MasterClass.PilaMF.AddFirst(MasterClass.TipoMF.Metodo_Funcion);
//Creamos un nuevo entorno para ejecutar el metodo
Entorno nuevo = new Entorno(ent); //El global es el del objeto
//creamos un literal para poder regresar
Expresion retorno = null;
//Modificamos el nombre
String aux = "";
String a2 = this.id;
String a3 = a2.Substring(0, 1);
if (!a3.Equals("#"))
{
aux = "#";
}
String nombreFuncion2 = this.id + aux;
//ahora ejecutamos las expresiones -> parametros enviados si esque tiene
if (this.enviados != null)
{
//recorremos los parametros enviados
//Aqui se le puede enviar un id -> debemos ir a buscarlo
foreach (Expresion parametro in this.enviados)
{
var parametroType = parametro.GetType();
var listaAccesosType = new Lista_Accesos().GetType();
if (typeof(Lista_Accesos).IsInstanceOfType(parametro))
{
Lista_Accesos a = (Lista_Accesos)parametro;
Expresion retAcceso = a.getValor(nuevo);
nombreFuncion2 += retAcceso.tipo.tipo.ToString();
resueltos.AddLast(retAcceso);
/*
* foreach (Id id in a.accesos)
* {
* Variable sim = id.getSimbolo(nuevo);
* Primitivo l = new Primitivo(sim.tipo, sim.valor);
* nombreFuncion2 += l.tipo.tipo.ToString();
* resueltos.AddLast(l);
* }
*/
}
else
{
nombreFuncion2 += parametro.getValor(nuevo).tipo.tipo.ToString();
resueltos.AddLast(parametro.getValor(nuevo));
}
}
}
//adjuntar el último valor modificado para el método
/*
* if (!aux.Equals("", StringComparison.InvariantCultureIgnoreCase))
* {
*
* Id id = acceso.accesos.Last.Value;
* acceso.accesos.RemoveLast();
* acceso.accesos.AddLast(new Id(nombreFuncion2, id.linea, id.columna));
*
* }
*/
nuevo.global = ent.global;
Variable f;
//luego buscamos la funcion
f = nuevo.buscar(nombreFuncion2, linea, columna, "La Funcion");
//si lo encontro
if (f != null)
{
//aqui pedimos el tipo
//creamos una variable (exit)
LinkedList <String> lista = new LinkedList <String>();
lista.AddLast(id);
Declaracion nombreFuncionDec = new Declaracion(f.tipo, lista, 0, 0);
nombreFuncionDec.ejecutar(nuevo);
//creamos un iterador
int iterador = 0;
//si tiene parametros y tambien tiene parametros enviados
//transformamos el simbolo encontrado a un simbolo nuevo de tipo metodo_Funcion para obtener la lista de parametros
if (enviados != null && ((Tipo_MF)f.valor).getparametros() != null)
{
//resolvemos los parametros enviados para tener el valor
foreach (Expresion enviado in enviados)
{
resueltos.AddLast(enviado.getValor(ent));
}
int cont = 0;
//Ejecutamos la lista de declaraciones para crear las variables
//y le asignamos el valor del enviado correspondiente para que sea asignado de una vez
foreach (Instruccion declaracion in ((Tipo_MF)f.valor).getparametros())
{
//((Declaracion)declaracion).valor = resueltos.ElementAt(iterador);
Tipo tipe = new Tipo(((Declaracion)declaracion).tipo.tipo);
foreach (String identify in ((Declaracion)declaracion).IDS)
{//Identificador a,b:integer m:integer
if (((Declaracion)declaracion).PorReferencia)
{
if (typeof(Lista_Accesos).IsInstanceOfType(this.enviados.ElementAt(cont)))
{
Lista_Accesos accesopos = (Lista_Accesos)this.enviados.ElementAt(cont);
Entorno temporal = nuevo;
Variable sim = null;
for (var temp = accesopos.accesos.First; temp != null; temp = temp.Next)
{
sim = temporal.buscar(temp.Value.id, linea, columna, "La variable");
if (sim != null)
{
if (temp.Next != null)
{
//esperamos un objeto
}
}
else
{
//error no se encontro la variable
return(null);
}
}
if (tipe.tipo == sim.tipo.tipo && sim.tipo.referencia == tipe.referencia)
{
nuevo.insertar(identify, sim, linea, columna, "La variable");
}
}
else
{
//Se esperaba un valor por referencia
}
}
else
{
Declaracion temp = new Declaracion(tipe, identify, resueltos.ElementAt(iterador), 0, 0);
((Declaracion)temp).valor = resueltos.ElementAt(iterador);//Expresion 1,2
temp.ejecutar(nuevo);
iterador++;
}
cont += 1;
}
}
}
/*
* Ejecucion como tal de la lista de declaraciones y de la lista de instrucciones (bloque)
*/
if (((Tipo_MF)f.valor).listaDeclaraciones != null)
{
foreach (Instruccion declaration in ((Tipo_MF)f.valor).listaDeclaraciones)
{
declaration.ejecutar(nuevo);
}
}
if (((Tipo_MF)f.valor).getbloque() == null)
{
foreach (Instruccion ins in ((Tipo_MF)f.valor).listaInstrucciones)
{
retorno = (Expresion)ins.ejecutar(nuevo);
}
}
else
{
//ejecutamos el bloque de instrucciones
retorno = (Expresion)((Tipo_MF)f.valor).getbloque().ejecutar(nuevo);
}
//verificamos si enviaron un return
if (retorno != null)
{
Primitivo sim = (Primitivo)retorno;
//validamos el retorno dentro del metodo o funcion
if (f.tipo.tipo == Tipo.enumTipo.Void && ((Expresion)retorno).tipo.tipo != Tipo.enumTipo.Void) //viene exit vacio
{
//error, porque si retorna algo no debe ser null
MasterClass.Instance.addError(new C_Error("Semantico", "No se esperaba retorno en metodo: " + nombreFuncion2, linea, columna));
retorno = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
}
else
{
//como no es void tiene tipo y verificamos que sea el mismo que la expresion recibida
if (f.tipo.tipo != sim.tipo.tipo)
{
//si no es el mismo entonces es un error
MasterClass.Instance.addError(new C_Error("Semantico", "El tipo de retorno y funcion no coinciden: " + sim.tipo.tipo + " = " + f.tipo.tipo, linea, columna));
retorno = new Primitivo(new Tipo(Tipo.enumTipo.error), "@error@");
}
}
}
else
{
//buscamos la variable con el mismo de la funcion
Variable nombreFuncionVar = nuevo.buscar(id, linea, columna, "La variable");
retorno = new Primitivo(f.tipo, nombreFuncionVar.valor);
}
}
else
{
MasterClass.Instance.addError(new C_Error("Semantico", "El metodo " + nombreFuncion2 + " no existe en el contexto", linea, columna));
}
MasterClass.PilaMF.RemoveLast();
return(retorno);
}
public async Task Add(Declaracion declaracion)
{
_context.Declaraciones.Add(declaracion);
await Task.CompletedTask;
}
/*
* Metodo de la implementacion
* @ts tabla de simbolos global
* @user usuario que ejecuta la accion
* @baseD base de datos donde estamos ejecutando todo
* @mensajes linkedlist con la salida deseada
*/
public object ejecutar(TablaDeSimbolos ts, Ambito ambito, TablaDeSimbolos tsT)
{
Mensaje ms = new Mensaje();
object res = ts.getValor(id);
if (!res.Equals("none"))
{
if (res.GetType() == typeof(TypeCursor))
{
TypeCursor tabla = (TypeCursor)res;
if (tabla.tabla != null)
{
generarIdentificador(tabla.tabla);
if (tabla.tabla.columnas.Count() == parametros.Count())
{
string identificadorParametros = generarIdentificadorDeclaracion();
if (identificadorParametros.Equals(identificador))
{
foreach (Data data in tabla.tabla.datos)
{
TablaDeSimbolos newAmbito = new TablaDeSimbolos();
foreach (Simbolo s in ambito.tablaPadre)
{
newAmbito.AddLast(s);
}
//-------------------------------------- ASIGNARLE A LOS PARAMETROS LOS VALORES DE LA CONSULTA ----------------------------
for (int i = 0; i < parametros.Count(); i++)
{
Declaracion d = (Declaracion)parametros.ElementAt(i);
d.parametro = true;
object rd = d.ejecutar(newAmbito, ambito, tsT);
if (rd == null)
{
return(null);
}
Atributo atributo = data.valores.ElementAt(i);
newAmbito.setValor(d.id, atributo.valor);
}
//---------------------------------------- EJECUTAR INSTRUCCIONES DENTRO DEL FOREACH -----------------------------------------
foreach (InstruccionCQL i in cuerpo)
{
object resultado = i.ejecutar(newAmbito, ambito, tsT);
if (resultado == null)
{
return(null);
}
else if (resultado.GetType() == typeof(Retorno))
{
return((Retorno)resultado);
}
else if (i.GetType() == typeof(Continue) || resultado.GetType() == typeof(Continue))
{
break;
}
}
}
return("");
}
else
{
ambito.mensajes.AddLast(ms.error("No coinciden el tipo de parametros con el tipo de columnas", l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("No coincide la cantidad de parametros con la cantidad de columnas", l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("El cursor: " + id + " no ha sido abierto", l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("La variable tiene que ser de tipo Cursor no se reconoce: " + res, l, c, "Semantico"));
}
}
else
{
ambito.mensajes.AddLast(ms.error("La variable : " + id + " no existe en este ambito", l, c, "Semantico"));
}
return(null);
}
public Task Update(Declaracion declaracion)
{
throw new NotImplementedException();
}
public Resultado ejecutar(ParseTreeNode raiz)
{
Resultado resultado = null;
foreach (ParseTreeNode hijo in raiz.ChildNodes)
{
if (resultado != null)
{
return(resultado);
}
String tipoAccion = hijo.Term.Name;
switch (tipoAccion)
{
case "CREARDB":
Form1.sistemaArchivos.crearBase(hijo);
break;
case "CREARTABLA":
Form1.sistemaArchivos.crearTabla(hijo);
break;
case "CONTAR":
Form1.sistemaArchivos.contar(hijo);
break;
case "DECLARACION": //jose
Declaracion declaracion = new Declaracion();
Boolean estado = declaracion.declaracion(hijo);
break;
case "SELECCIONAR":
Form1.sistemaArchivos.realizarConsulta(hijo);
break;
case "RESTAURARBD":
Form1.sistemaArchivos.restaurar(hijo);
break;
case "BACKUP":
Form1.sistemaArchivos.backup(hijo);
break;
case "USAR":
Form1.sistemaArchivos.setBaseActual(hijo.ChildNodes[0]);
guardarMetodos(raiz, raizCompleta);
break;
case "IMPRIMIR":
opL = new Logica();
Form1.Mensajes.Add(opL.operar(hijo.ChildNodes[0]).valor + "");
break;
case "USUARIO":
Form1.sistemaArchivos.crearUsuario(hijo);
break;
case "ACTUALIZAR":
Form1.sistemaArchivos.actualizar(hijo);
break;
case "ALTERARTABLA":
Form1.sistemaArchivos.alterarTabla(hijo);
break;
case "ALTERAROBJETO":
Form1.sistemaArchivos.alterarObjeto(hijo);
break;
case "ALTERARUSUARIO":
Form1.sistemaArchivos.alterarUsuario(hijo);
break;
case "BORRAR": // Borrar registro en la tupla
Form1.sistemaArchivos.borrar(hijo);
break;
case "INSERTAR":
Form1.sistemaArchivos.insertar(hijo);
break;
case "PERMISOS":
Form1.sistemaArchivos.permisos(hijo);
break;
case "ELIMINAR":
Form1.sistemaArchivos.eliminar(hijo);
break;
case "CREAROBJETO": //jose
String nombreObjeto = hijo.ChildNodes[0].Token.Text;
ParseTreeNode atributos = hijo.ChildNodes[1];
Objeto objeto = new Objeto(nombreObjeto);
foreach (ParseTreeNode nodoAtributo in atributos.ChildNodes)
{
Atributo atributo = new Atributo(nodoAtributo.ChildNodes[0].ChildNodes[0].Token.Text, nodoAtributo.ChildNodes[1].Token.Text, null);
objeto.addAtributo(atributo);
}
Form1.sistemaArchivos.getBase().agregarObjeto(objeto, hijo.Span.Location.Line, hijo.Span.Location.Column);
break;
case "ASIGNAROBJ":
Asignacion asignacion = new Asignacion();
asignacion.asignar(hijo);
break;
case "LLAMADA":
nivel++;
Llamada llamada = new Llamada(this);
Resultado r = llamada.ejecutar(hijo);
nivel--;
break;
case "RETORNO":
opL = new Logica();
resultado = opL.operar(hijo.ChildNodes[0]);
return(resultado);
case "SENTSI":
Si si = new Si(this);
resultado = si.ejecutar(hijo);
break;
case "MIENTRAS":
Mientras mientras = new Mientras(this);
resultado = mientras.ejecutar(hijo);
break;
case "DETENER":
resultado = new Resultado("Error", null);
resultado.detener = true;
return(resultado);
case "PARA":
Para para = new Para(this);
resultado = para.ejecutar(hijo);
break;
case "SENTSELECCIONA":
Selecciona selecciona = new Selecciona(this);
resultado = selecciona.ejecutar(hijo);
break;
}
}
return(resultado);
}
public void codigoaEvaluar(string strCodigoaEvaluar)
{
//MessageBox.Show("" + codF);
Analizadores.Analizador analizar = new Analizador(new Gramatica());
ParseTree arbol = analizar.isValid(strCodigoaEvaluar);
if (arbol != null)
{
ConstructorAst constAst = new ConstructorAst();
AST arbolAux = constAst.Analizar(arbol.Root);
Ambito global = new Ambito(null);
try {
if (arbolAux != null)
{
foreach (Instruccion inst in arbolAux.Instrucciones)
{
//if (inst is Funcion) {
//}
if (inst is Declaracion)
{
Declaracion declaracion = (Declaracion)inst;
declaracion.ejecutar(global, arbolAux);
}
//toca deficion clase
}
foreach (Instruccion ins in arbolAux.Instrucciones)
{
if (ins is Funcion)
{
Funcion funcion = (Funcion)ins;
global.agregar(funcion.Id, funcion);
foreach (NodoAST instruccion in funcion.LLInstrucciones)
{
//if (instruccion is DefinicionStruct)
//{
// DefinicionStruct crear = (DefinicionStruct)instruccion;
// crear.ejecutar(global, auxArbol);
//}
}
}
if (ins is Declaracion)
{
Declaracion declaracion = (Declaracion)ins;
declaracion.ejecutar(global, arbolAux);
}
//if (ins is DefinicionStruct)
//{
// DefinicionStruct crear = (DefinicionStruct)ins;
// crear.ejecutar(global, auxArbol);
//}
}
foreach (Instruccion ins in arbolAux.Instrucciones)
{
if (ins is Principal)
{
Principal main = (Principal)ins;
Ambito local = new Ambito(global);
main.ejecutar(local, arbolAux);
}
}
}
else
{
MessageBox.Show("Cadena invalida");
}
}
catch (Exception ex) {
MessageBox.Show(ex.ToString());
}
//analizar.parse(arbol, new PrimeraPasada());
MessageBox.Show("Cadena Valida");
}
else
{
MessageBox.Show("No Valida");
}
}
protected List <Personas> ConsultarPersonasDeclaracion(TablasRango tr, Declaracion declaracion)
{
return(tr.Personas
.Where(x => x.Id_Declaracion == declaracion.Id)
.ToList());
}
