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()); }