protected void AgregarButton_Click(object sender, EventArgs e)
{
Entrada entrada = new Entrada();
decimal total = 0;
int productoID = Utils.ToIntObjetos(ProductoDropdownList.SelectedValue);
string descripcion = Metodo.Descripcion(productoID);
entrada.Detalle = new List <EntradaDetalle>();
if (IsValid)
{
DateTime date = DateTime.Now.AddDays(7);
entrada = (Entrada)ViewState["Entrada"];
decimal Importe = Convert.ToDecimal(CantidadTextBox.Text) * Convert.ToDecimal(CostoTextBox.Text);
entrada.AgregarDetalle
(0, Utils.ToInt(IdTextBox.Text), Utils.ToInt(ProductoDropdownList.SelectedValue), descripcion, Convert.ToDecimal(CantidadTextBox.Text),
Convert.ToDecimal(CostoTextBox.Text), Importe, date);
ViewState["Entrada"] = entrada;
this.BindGrid();
foreach (var item in entrada.Detalle)
{
total += item.Importe;
}
TotalTextBox.Text = total.ToString();
}
}
public void showpic()
{
explode.Stop();
Metodo m = new Metodo();
m.spic(ducpic);
pictureBox1.Image = Properties.Resources.pixelheart;
switch (pato.Text)
{
case "Red Head":
m.Setpic(new setRedhead());
m.show();
break;
case "Mallard":
m.Setpic(new Setype());
m.show();
break;
case "Rubber":
m.Setpic(new setRubber());
m.show();
break;
case "Toy":
m.Setpic(new Settrum());
m.show();
break;
case "Decoy":
m.Setpic(new setDecoy());
m.show();
break;
}
}
private IMetodoLectura Crear(Metodo metodo)
{
IMetodoLectura instancia = null;
switch (metodo)
{
case Metodo.Tipo:
instancia = new MetodoLecturaTipo(this, _lector);
break;
case Metodo.ObjetoDatos:
instancia = new MetodoLecturaObjetoDatos(this, _lector);
break;
case Metodo.Referencia:
instancia = new MetodoLecturaReferencia(this, _lector);
break;
case Metodo.Asociacion:
instancia = new MetodoLecturaAsociacion(this, _lector);
break;
}
return(instancia);
}
static void Main(string[] args)
{
Metodo misMetdos = new Metodo();
Console.WriteLine(misMetdos.Saludar());
Console.ReadKey();
}
static void Main(string[] args)
{
Metodos obj = new Metodos();
Metodo m1 = obj.Method1;
Metodo m2 = obj.Method2;
Metodo m3 = NomeMetodo;
}
public object ejecutar(Contexto ctx, Stuff stuff)
{
String tipo = (esVoid) ?"el metodo":"la función";
if (global)
{
Metodo m = ctx.findGlobalMethod(id, cantidad_params);
if (m != null)
{
stuff.error("Semántico", "'DECLARACION METODO GLOBAL', " + tipo + "'" + id + "' ya está definido, utilice una cantidad distinta de parametros.", fila, columna, ctx);
}
else
{
m = new Metodo(esVoid, id, decl_parametros, cantidad_params, ins);
ctx.metodos_globales.Add(m);
}
return(null);
}
else
{
Metodo m = ctx.findLocalMethod(id, cantidad_params);
if (m != null)
{
stuff.error("Semántico", "'DECLARACION METODO', " + tipo + "'" + id + "' ya está definido, utilice una cantidad distinta de parametros.", fila, columna, ctx);
}
else
{
m = new Metodo(esVoid, id, decl_parametros, cantidad_params, ins);
ctx.metodos.Add(m);
}
return(null);
}
}
private void MostrarDatos()
{
Metodo oRegistro = new Metodo();
oRegistro = (Metodo)oRegistro.Get(typeof(Metodo), int.Parse(Request["id"].ToString()));
txtNombre.Text = oRegistro.Nombre;
}
public virtual JsonResult Crear(Metodo entidad)
{
var jsonResponse = new JsonResponse { Success = false };
if (ModelState.IsValid)
{
try
{
entidad.UsuarioCreacion = UsuarioActual.IdUsuario.ToString();
entidad.UsuarioModificacion = UsuarioActual.IdUsuario.ToString();
// dato temporal
if (entidad.MET_NombreIngles == null)
entidad.MET_NombreIngles = "";
if (entidad.MET_Descripcion == null)
entidad.MET_Descripcion = "";
// fin dato
MetodoBL.Instancia.Add(entidad);
jsonResponse.Success = true;
jsonResponse.Message = "Se Proceso con éxito";
}
catch (Exception ex)
{
logger.Error(string.Format("Mensaje: {0} Trace: {1}", ex.Message, ex.StackTrace));
jsonResponse.Message = "Ocurrio un error, por favor intente de nuevo o más tarde.";
}
}
else
{
jsonResponse.Message = "Por favor ingrese todos los campos requeridos";
}
return Json(jsonResponse, JsonRequestBehavior.AllowGet);
}
public void Save(MetodoPostDto metodoPost)
{
VerifyExists(metodoPost, CommonMessages.InformacoesEntrada);
var metodo = new Metodo
{
Nome = metodoPost.Nome,
Descricao = metodoPost.Descricao,
IdTipoRetorno = metodoPost.IdTipoRetorno,
Exemplo = metodoPost.Exemplo,
ComponenteId = metodoPost.ComponenteId,
DataUltimaAlteracao = DateTime.Now,
IdUsuarioUltimaAlteracao = IdUsuario,
ParametrosMetodo = metodoPost.ParametrosMetodo.Select(y => new ParametroMetodo
{
Nome = y.Nome,
Descricao = y.Descricao,
TipoId = y.TipoId,
Obrigatorio = y.Obrigatorio,
DataUltimaAlteracao = DateTime.Now,
IdUsuarioUltimaAlteracao = IdUsuario
}).ToList()
};
Validate(metodo);
_uow.MetodoRepository.Add(metodo);
_uow.Commit();
}
/// <summary>
/// Registra un mensaje con un nivel de importancia en el flujo del método actual.
/// Requiere que el inicio y el retorno del método esté logeado.
/// </summary>
/// <example>
/// public class UsuarioBO
/// {
/// private UsuarioDAO dao = new UsuarioDAO();
///
/// public void Agregar(UsuarioTO usuario)
/// {
/// log.Mensaje("Antes de llamar al DAO", Nivel.INFO);
/// dao.Agregar(usuario);
/// log.Mensaje("Luego de llamar al DAO", Nivel.INFO);
/// }
/// }
/// </example>
/// <remarks>
/// <para>
/// <h2 class="groupheader">Registro de versiones</h2>
/// <ul>
/// <li>1.0.0</li>
/// <table>
/// <tr style="font-weight: bold;">
/// <td>Autor</td>
/// <td>Fecha</td>
/// <td>Descripción</td>
/// </tr>
/// <tr>
/// <td>Marcos Abraham Hernández Bravo.</td>
/// <td>11/11/2016</td>
/// <td>Versión Inicial.</td>
/// </tr>
/// </table>
/// </ul>
/// </para>
/// </remarks>
/// <param name="mensaje">Mensaje a registrar.</param>
/// <param name="nivel">Nivel de importancia o tipo del mensaje.</param>
private void _Mensaje(string mensaje, Nivel nivel)
{
Llamada++;
RegistroInLineTO registro = new RegistroInLineTO()
{
ThreadGUID = ThreadGUID,
MethodGUID = _MethodGUID,
Namespace = Metodo.DeclaringType.Namespace,
Clase = Metodo.DeclaringType.Name,
Metodo = Metodo.ToString(),
Mensaje = mensaje,
Nivel = nivel,
Correlativo = Llamada,
Tipo = Tipo.Mensaje
};
foreach (ALogWriter writer in Writers)
{
if (writer.PermiteNivel(nivel))
{
writer.Guardar(registro);
}
}
}
public List <Metodo> Construya(SyntaxList <MemberDeclarationSyntax> losNodos, string elIdSolucion)
{
List <MethodDeclarationSyntax> losMetodosDeclarados = new List <MethodDeclarationSyntax>();
List <Metodo> losMetodosConvertidos = new List <Metodo>();
if (losNodos != null && losNodos.Count != 0)
{
Convertidor elConvertidor = new Convertidor();
losMetodosDeclarados = elConvertidor.Convierta(losNodos, elIdSolucion);
foreach (MethodDeclarationSyntax elMetodo in losMetodosDeclarados)
{
try
{
Metodo elMetodoConvertido = new Metodo();
elMetodoConvertido.NombreMetodo = elMetodo.Identifier.Text;
elMetodoConvertido.Retorno = elMetodo.ReturnType.ToString();
FileLinePositionSpan lineSpan = elMetodo.SyntaxTree.GetLineSpan(elMetodo.Span);
elMetodoConvertido.LineaComienzo = lineSpan.StartLinePosition.Line;
elMetodoConvertido.LineaFinal = lineSpan.EndLinePosition.Line;
string elModificador;
if (elMetodo.Modifiers.Count == 0)
{
elModificador = "";
}
else
{
elModificador = elMetodo.Modifiers.First().ToString();
}
elMetodoConvertido.Visibilidad = elModificador;
Parametros.Constructor elConstructorDeParametros = new Parametros.Constructor();
elMetodoConvertido.Parametros = elConstructorDeParametros.Construya(elMetodo.ParameterList.Parameters, elIdSolucion).ToArray();
Controles.Constructor elConstructorDeControles = new Controles.Constructor();
if (elMetodo.Body != null)
{
elMetodoConvertido.Controles = elConstructorDeControles.Construya(elMetodo.Body.Statements, elIdSolucion).ToArray();
}
else
{
elMetodoConvertido.Controles = new List <Control>().ToArray();
}
losMetodosConvertidos.Add(elMetodoConvertido);
}
catch (Exception laExcepcion)
{
Bitacoras.Registrador elRegistrador = new Bitacoras.Registrador();
elRegistrador.Registre(laExcepcion, elIdSolucion, BC.Componentes.AnalizadorCodigoFuente);
}
}
}
return(losMetodosConvertidos);
}
static void Main(string[] args)
{
double n1 = Metodo.InserisciLato();
double n2 = Metodo.InserisciLato();
double n3 = Metodo.InserisciLato();
Metodo.Classificazione(n1, n2, n3);
Console.WriteLine($"Il suo perimetro è {Metodo.Perimetro(n1, n2, n3)}");
}
public string Obtener(string accion, Metodo metodo, string json)
{
var tarea = Task.Run(async() =>
{
return(await ObtenerRespuesta(Sufijo() + accion, metodo, json));
});
return(tarea.Result);
}
public TEntity Obtener<TEntity>(string accion, Metodo metodo, string json)
{
var tarea = Task.Run(async () =>
{
return await GetStreamFromUrl(clase + "/" + accion, metodo, json);
});
string jsonResult = tarea.Result;
return JsonConvert.DeserializeObject<TEntity>(jsonResult);
}
public List<T> Seleccionar(string accion, Metodo metodo)
{
var tarea = Task.Run(async () =>
{
return await GetStreamFromUrl(clase + "/" + accion, metodo);
});
var json = tarea.Result;
return JsonConvert.DeserializeObject<List<T>>(json);
}
private int sommaDueNumeri(int a, int b, Metodo quandoHaFinito)
{
int result = a + b;
// Chiama il metodo di callback, se passato in input
quandoHaFinito?.Invoke();
return(result);
}
public static void CreateMethodsDCS()
{
foreach (string key in VersionParser.d_commandsbyversion.Keys) //por versiones
{
if (!Directory.Exists(VKxmlParser.GetDestination() + "/Internals"))
{
Directory.CreateDirectory(VKxmlParser.GetDestination() + "/Internals");
}
StreamWriter sw = File.CreateText(VKxmlParser.GetDestination() + "/Internals/" + "Vulkan" + key.Replace(".", "") + "d.cs");
sw.WriteLine("// Document Created with VulkanParser.");
sw.WriteLine("// " + DateTime.Now.ToString("HH:mm:ss dd/mm/yyyy"));
sw.WriteLine("// by BROTHERHOOD OF THE BLACK SWORD.");
sw.WriteLine();
sw.WriteLine("namespace " + VKxmlParser.GetNamespace());
sw.WriteLine("{");
sw.WriteLine("\t" + "internal static class VK" + key.Replace(".", "") + "Delegates"); //Agrupar metodos en clase internal dentro de namespace de version
sw.WriteLine("\t" + "{");
foreach (string keygroups in VersionParser.d_commandsbyversion[key].grupocomandos.Keys) //por grupos
{
List <string> listametodos = VersionParser.d_commandsbyversion[key].grupocomandos[keygroups];
for (int i = 0; i < listametodos.Count; i++)
{
Metodo mtd = CommandParser.Metodos[listametodos[i]]; //Rescatar metodo del CommandParser
string smetodo = "internal delegate " + mtd.ValueReturned + " " + mtd.Nombre + "("; //confecionar string de metodo
foreach (string keyParams in mtd.Parametros.Keys) //Añadir Parametyros del método
{
Parametro param = mtd.Parametros[keyParams];
if (param.constante)
{
smetodo += "const ";
}
string stipovalor = param.TipoValor;
if (param.puntero)
{
stipovalor += "*";
}
string svalorfinparam = Tools.VariableType(stipovalor);
smetodo += svalorfinparam + " " + param.Nombre + ", ";
}
smetodo = smetodo.Remove(smetodo.Length - 2, 2) + ");"; //quitar comay espacio tras último parametro y cerrar parentesis.
sw.WriteLine("\t" + "\t" + smetodo); //escribir enunciado de metodo.
sw.WriteLine();
}
//sw.WriteLine();
}
sw.WriteLine("\t" + "}");
sw.WriteLine("}");
sw.WriteLine();
sw.Close();
}
}
public TEntity Obtener <TEntity>(string accion, Metodo metodo, string json)
{
var tarea = Task.Run(async() =>
{
return(await ObtenerRespuesta(Sufijo() + accion, metodo, json));
});
string jsonResult = tarea.Result;
return(JsonConvert.DeserializeObject <TEntity>(jsonResult));
}
public List <T> Seleccionar(string accion, Metodo metodo)
{
var tarea = Task.Run(async() =>
{
return(await ObtenerRespuesta(Controlador + "/" + accion, metodo));
});
var json = tarea.Result;
return(JsonConvert.DeserializeObject <List <T> >(json));
}
public IActionResult Registrar([Bind(Prefix = "met")] Metodo objContacto)
{
if (ModelState.IsValid)
{
_context.Add(objContacto);
_context.SaveChanges();
return(RedirectToAction("ListarMetodo"));
}
return(View("index", objContacto));
}
public static void VKDelegatorMake()
{
StreamWriter sw = File.CreateText(VKxmlParser.GetDestination() + "VKDelegatesTools.cs"); // + key.Replace(".", "") + ".cs");
sw.WriteLine("// Document Created with VulkanParser.");
sw.WriteLine("// " + DateTime.Now.ToString("HH:mm:ss dd/mm/yyyy"));
sw.WriteLine("// by BROTHERHOOD OF THE BLACK SWORD.");
sw.WriteLine();
sw.WriteLine("using System;");
sw.WriteLine("using System.Runtime.InteropServices;");
sw.WriteLine("using " + VKxmlParser.GetNamespace() + ";");
sw.WriteLine();
sw.WriteLine("namespace " + VKxmlParser.GetNamespace());
sw.WriteLine("{");
sw.WriteLine("\t" + "internal static class VKDelegator");
sw.WriteLine("\t" + "{");
sw.WriteLine("\t" + "\t" + "internal static void InitDelegatesVK(VKDevice vkdevice)");
sw.WriteLine("\t" + "\t" + "{");
sw.WriteLine("\t" + "\t" + "\t" + "IntPtr ptr_mehod;");
foreach (string key in VersionParser.d_commandsbyversion.Keys) //por versiones
{
foreach (string keygroups in VersionParser.d_commandsbyversion[key].grupocomandos.Keys) //por grupos
{
string s_grupo = keygroups.Split(new string[] { " (" }, StringSplitOptions.RemoveEmptyEntries)[0].Replace(" ", "_");
string sp_grupo = char.ToUpper(s_grupo[0]) + s_grupo.Substring(1);
List <string> listametodos = VersionParser.d_commandsbyversion[key].grupocomandos[keygroups];
for (int i = 0; i < listametodos.Count; i++) //Recorrer Metodos
{
Metodo mtd = CommandParser.Metodos[listametodos[i]]; //Rescatar metodo del CommandParser
sw.WriteLine("\t" + "\t" + "\t" + "ptr_mehod = GetVKMethodAdress(vkdevice, \"" + mtd.Nombre + "\");");
sw.WriteLine("\t" + "\t" + "\t" + "if (ptr_mehod != IntPtr.Zero)");
sw.WriteLine("\t" + "\t" + "\t" + "{");
string s_metodo = "";
s_metodo = "vkdevice.VK" + key.Replace(".", "") + "." + sp_grupo + ".p_" + mtd.Nombre + " = (" + VKxmlParser.GetNamespace() + ".VKDelegates.VK" + key.Replace(".", "") + "." + sp_grupo + "." + mtd.Nombre + ")";
s_metodo += "Marshal.GetDelegateForFunctionPointer<" + VKxmlParser.GetNamespace() + ".VKDelegates.VK" + key.Replace(".", "") + "." + sp_grupo + "." + mtd.Nombre + " >(ptr_mehod);";
sw.WriteLine("\t" + "\t" + "\t" + "\t" + s_metodo); //Escribir Fila De Declaracion de delegado.
sw.WriteLine("\t" + "\t" + "\t" + "}");
}
}
sw.WriteLine();
}
sw.WriteLine("\t" + "\t" + "}");
GetAdress(sw); //Escribit metodo de obtención de direccion de metodo.
sw.WriteLine("\t" + "}");
sw.WriteLine("}");
sw.WriteLine();
sw.Close();
}
private string ExecutarMetodo(Modelo modelo, Metodo metodo)
{
try
{
return(Convert.ToString(Acesso.MetodoPersistencia(CommandType.StoredProcedure, "usp" + modelo.ToString() + metodo.ToString())));
}
catch (ConexaoException mensagem)
{
return(mensagem.Message);
}
}
public Listado <T> Seleccionar(string accion, Metodo metodo, object objeto, int pagina)
{
var tarea = Task.Run(async() =>
{
string jsonEntrada = JsonConvert.SerializeObject(objeto);
return(await ObtenerRespuesta(Controlador + "/" + accion + $"/{(pagina == 0 ? 1 : pagina)}", metodo, jsonEntrada));
});
var json = tarea.Result;
return(JsonConvert.DeserializeObject <Listado <T> >(json));
}
public Stream ObtenerArchivo(string accion, Metodo metodo, string json)
{
var tarea = Task.Run(async() =>
{
return(await ObtenerRespuestaArchivo(Sufijo() + accion, metodo, json));
});
var memoriaArchivo = tarea.Result;
memoriaArchivo.Seek(0, SeekOrigin.Begin);
return(memoriaArchivo);
}
//Obtengo el metodo que ha de aplicar x Regla
private Metodo obtenerMetodo(ParseTreeNode nodo)
{
if (nodo.Term.Name.Equals("M2"))
{
Metodo meto = new Metodo(nodo.ChildNodes[0].Token.Text, nodo.ChildNodes[2].Term.Name);
return(meto);
}
Metodo metos = new Metodo(nodo.ChildNodes[0].Token.Text);
return(metos);
}
public bool Validate(Metodo metodo)
{
if (metodo == null)
{
throw new DomainException(string.Format(CommonMessages.Required, "Método"));
}
if (string.IsNullOrWhiteSpace(metodo.Nome))
{
throw new DomainException(string.Format(CommonMessages.Required, "Nome"));
}
return(true);
}
private void Eliminar(object p)
{
Metodo oRegistro = new Metodo();
oRegistro = (Metodo)oRegistro.Get(typeof(Metodo), int.Parse(p.ToString()));
Usuario oUser = new Usuario();
oRegistro.Baja = true;
oRegistro.IdUsuarioRegistro = (Usuario)oUser.Get(typeof(Usuario), int.Parse(Session["idUsuario"].ToString()));
oRegistro.FechaRegistro = DateTime.Now;
oRegistro.Save();
}
private R2PBMetodo ConstruyaElMetodo(Metodo elMetodo, int elIdClase, int elIdPaquete, int elIdProyecto)
{
R2PBMetodo elMetodoConvertido = new R2PBMetodo();
elMetodoConvertido.IdClase = elIdClase;
elMetodoConvertido.Nombre = elMetodo.NombreMetodo;
elMetodoConvertido.Retorno = elMetodo.Retorno;
elMetodoConvertido.Visibilidad = elMetodo.Visibilidad;
elMetodoConvertido.IdPaquete = elIdPaquete;
elMetodoConvertido.IdProyecto = elIdProyecto;
elMetodoConvertido.LineaComienzo = elMetodo.LineaComienzo;
elMetodoConvertido.LineaFinal = elMetodo.LineaFinal;
return(elMetodoConvertido);
}
private void Guardar(Metodo oRegistro)
{
Usuario oUser = new Usuario();
oUser = (Usuario)oUser.Get(typeof(Usuario), int.Parse(Session["idUsuario"].ToString()));
oRegistro.Nombre = txtNombre.Text;
oRegistro.IdEfector = oUser.IdEfector; // (Efector)oEfector.Get(typeof(Efector), "IdEfector", 5);
oRegistro.IdUsuarioRegistro = oUser;
oRegistro.FechaRegistro = DateTime.Now;
oRegistro.Save();
}
public override void EmpacotarParametros(object objeto, Metodo metodo)
{
ContaT operacao = (ContaT)objeto;
Acesso.LimparParametros();
if (metodo == Metodo.Alterar || metodo == Metodo.Excluir)
{
Acesso.AdicionarParametros("@Id", operacao.Id);
}
if (metodo == Metodo.Alterar || metodo == Metodo.Inserir)
{
Acesso.AdicionarParametros("@Nome", operacao.Nome);
Acesso.AdicionarParametros("@TipoConta", operacao.TipoConta);
Acesso.AdicionarParametros("@Saldo", operacao.Saldo);
}
}
private ResultadoAnalise CriarResultadoAnalise(dynamic resultadoAnaliseJSON)
{
List <Analise> analises = new List <Analise>();
dynamic analisesJSON = resultadoAnaliseJSON.analises;
foreach (var a in analisesJSON)
{
List <Metodo> metodos = new List <Metodo>();
dynamic metodosJSON = a.metodos;
foreach (var m in metodosJSON)
{
Metodo metodo = new Metodo
{
Nome = m.nomeMetodo,
InterpretacaoNeg = m.interpretacaoNeg,
InterpretacaoPos = m.interpretacaoPos,
ValorReferenciaNeg = m.valorReferenciaNeg,
ValorReferenciaPos = m.valorReferenciaPos,
ResultadoNumerico = m.resultadoNumerico,
Resultado = m.resultadoTexto,
};
metodos.Add(metodo);
}
Analise analise = new Analise
{
AmostraId = a.amostraId,
Nome = a.nomeAnalise,
Data = DateTime.Today,
Metodos = metodos
};
analises.Add(analise);
}
ResultadoAnalise resultadoAnalise = new ResultadoAnalise
{
Data = DateTime.Today,
Analises = analises
};
return(resultadoAnalise);
}
public virtual ActionResult Crear()
{
try
{
var entidad = new Metodo
{
MET_Nombre = string.Empty
};
PrepararDatos(ref entidad, "Crear");
return PartialView("Edit", entidad);
}
catch (Exception ex)
{
logger.Error(string.Format("Mensaje: {0} Trace: {1}", ex.Message, ex.StackTrace));
return new HttpNotFoundWithViewResult("Error");
}
}
private void PrepararDatos(ref Metodo entidad, string accion)
{
entidad.Accion = accion;
ViewData["idMenu"] = this.IdMenu;
entidad.IdMenu = this.IdMenu;
entidad.IdModulo = this.IdModulo;
entidad.Estados = Utils.EnumToList<TipoEstado>();
}
