public Tipo(Tipos tipo, string tipoId = "", SimboloStruct symStruct = null, int dimension = 0)
{
this.tipo = tipo;
this.tipoId = tipoId;
this.symStruct = symStruct;
this.dimension = dimension;
}
public static void AjustarReta(this DadosAjuste o, Tipos tipo)
{
switch (tipo)
{
case Tipos.Reta:
DadosRetaExpAjustada entrada = o as DadosRetaExpAjustada;
AjustarReta(entrada.QtdePontos, entrada.PontosTabelados, out entrada.A, out entrada.B, out entrada.Y, out entrada.Erro);
break;
case Tipos.Polinomial:
DadosPoliAjustada entrada1 = o as DadosPoliAjustada;
AjustarPoli(entrada1.QtdePontos, entrada1.PontosTabelados, entrada1.GrauPoli, out entrada1.CoefAjust, out entrada1.Y, out entrada1.Erro);
break;
case Tipos.Exponencial1:
DadosRetaExpAjustada entrada2 = o as DadosRetaExpAjustada;
AjustarExp1(entrada2.QtdePontos, entrada2.PontosTabelados, out entrada2.A, out entrada2.B, out entrada2.Y, out entrada2.Erro);
break;
case Tipos.Exponencial2:
DadosRetaExpAjustada entrada3 = o as DadosRetaExpAjustada;
AjustarExp2(entrada3.QtdePontos, entrada3.PontosTabelados, out entrada3.A, out entrada3.B, out entrada3.Y, out entrada3.Erro);
break;
}
}
public static void Tocar(Tipos tipo = Tipos.Interface)
{
if (tocador && Dados.somLigado)
{
tocador.PlayOneShot(sons[(int)tipo]);
}
}
private void btnTipos_Click(object sender, EventArgs e)
{
using (Tipos uf = new Tipos())
{
uf.ShowDialog();
}
}
public ActionResult CargaTipos(Tipos tipos)
{
ManagerSolcitudes mang = new ManagerSolcitudes();
var dto_ret = mang.CargarTipos(tipos.Id.ToString());
return(Json(dto_ret.Where(x => x.Id == 113 || x.Id == 110)));
}
public Boolean Save(ref Tipos Item)
{
try
{
Boolean m_isCorrect = true;
Infrastructure.Aspect.DataAccess.DataAccessEnterpriseSQL.DABeginTransaction();
switch (Item.Instance)
{
case Infrastructure.Aspect.BusinessEntity.InstanceEntity.Added:
m_isCorrect = Insert(ref Item); break;
case Infrastructure.Aspect.BusinessEntity.InstanceEntity.Modified:
m_isCorrect = Update(ref Item); break;
case Infrastructure.Aspect.BusinessEntity.InstanceEntity.Deleted:
m_isCorrect = Delete(ref Item); break;
}
if (m_isCorrect)
{
GenerarXML(); Infrastructure.Aspect.DataAccess.DataAccessEnterpriseSQL.DACommitTransaction();
}
else
{
Infrastructure.Aspect.DataAccess.DataAccessEnterpriseSQL.DARollbackTransaction();
}
return(m_isCorrect);
}
catch (Exception)
{ Infrastructure.Aspect.DataAccess.DataAccessEnterpriseSQL.DARollbackTransaction(); throw; }
}
public Processo()
{
PID++;
this._PId = PID;
this._Tempo = 0;
this._Tipo = Tipos.CPUBound;
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nombre")] Tipos tipos)
{
if (id != tipos.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tipos);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TiposExists(tipos.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tipos));
}
private void maisTipo_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
Tipos t = new Tipos(cdUsuario, grupo);
t.ShowDialog();
AtualizarTipos();
}
public BATCH_ARTICLE BATCH_ARTICLE_NEW(AFN_LOTE_ARTICULOS lote_old)
{
var lote_new = new BATCH_ARTICLE();
lote_new.aproval_state_id = EstadoAprobacion.ByCode(lote_old.estado_aprov).id;
lote_new.descrip = lote_old.descripcion;
lote_new.purchase_date = (DateTime)lote_old.fecha_compra;
lote_new.initial_price = (decimal)lote_old.precio_inicial;
lote_new.initial_life_time = (int)lote_old.vida_util_inicial;
lote_new.account_date = (DateTime)lote_old.fecha_ing;
lote_new.origin_id = origenes.ByCode(lote_old.origen).id;
lote_new.type_asset_id = Tipos.ByDescrip(lote_old.consistencia).id;
//Analizo documento a migrar
if (lote_old.num_doc != DOCUMENTS.defaultDocument)
{
var new_doc = DOCUMENT_NEW_PREV(lote_old);
var new_rel = new DOCS_BATCH();
new_rel.DOCUMENT = new_doc;
new_rel.BATCHS_ARTICLES = lote_new;
_context.DOCS_BATCH.AddObject(new_rel);
}
else
{
//ingreso solo lote, sin documento asociado
_context.BATCHS_ARTICLES.AddObject(lote_new);
}
_context.SaveChanges();
_load_batches_articles();
return(lote_new);
}
//Constructor para definicion de funciones
public Simbolo(string id, Tipos tipo, LinkedList <Simbolo> listaParam)
{
this.id = id;
this.tipo = tipo;
this.listaParam = listaParam;
funcion = true;
}
public Simbolo(Tipos tipo, string id, object valor)
{
this.tipo = tipo;
this.id = id;
this.valor = valor;
funcion = false;
}
public Processo(int Tempo)
{
PID++;
this._PId = PID;
this._Tempo = Tempo;
this._Tipo = Tipos.CPUBound;
}
private Tipos SelectOne(String TIPO_CodTabla, String TIPO_CodTipo)
{
try
{
Tipos item = new Tipos();
DataAccessEnterpriseSQL.DAAsignarProcedure("T_SP_CONSULTAR_Tipos");
DataAccessEnterpriseSQL.DAAgregarParametro("@pchrTIPO_CodTabla", TIPO_CodTabla, SqlDbType.Char, 3, ParameterDirection.Input);
DataAccessEnterpriseSQL.DAAgregarParametro("@pchrTIPO_CodTipo", TIPO_CodTipo, SqlDbType.Char, 3, ParameterDirection.Input);
using (IDataReader reader = DataAccessEnterpriseSQL.DAExecuteReader())
{
if (reader.Read())
{
Loader.LoadEntity(reader, item);
item.Instance = InstanceEntity.Unchanged;
}
else
{
throw new Exception("No se encontro el registro.");
}
}
return(item);
}
catch (Exception ex)
{ throw ex; }
}
/**
* @fn public Simbolo(Tipos tipo, string identificador, object valor)
*
* @brief Constructor que se utiliza pripalmente para inicializacion de
* parámetros en las llamadas a metodos.
*
* @author Javier Estuardo Navarro
* @date 26/08/2018
*
* @param tipo Tipo específico de la variable, Entero, Decimal,
* Cadena, OBJETO, etc. del Simbolo.
* @param identificador Identificador del Simbolo.
* @param valor El valor específico de la variable, ya sea que se
* trate de un valor primitivo o de un objeto.
*/
public Simbolo(Tipos Tipo, string Identificador, object Valor)
{
this.Tipo = Tipo;
this.Identificador = Identificador;
this.Valor = Valor;
Funcion = false;
}
public PatoModel(int id, Posicao posicoes, bool vivo, Tipos tipo)
{
Id = id;
Posicoes = posicoes;
Vivo = vivo;
Tipo = tipo;
}
public List <int[]> posicoesJogadorX(int jogador)
{
//retorna todas as posicões (x, y) das peças de um jogador X
int lin, col, pecaAtual;
List <int[]> posicoes = new List <int[]>();
int[] posicao = new int[2];
int tamanho = Tabuleiro.instance.getTamanhoTabuleiro();
for (lin = 0; lin < tamanho; lin++)
{
for (col = 0; col < tamanho; col++)
{
pecaAtual = tabuleiro[lin, col];
if (Tipos.isJogadorX(pecaAtual, jogador))
{
posicao[0] = lin;
posicao[1] = col;
posicoes.Add((int[])posicao.Clone());
}
}
}
return(posicoes);
}
public Produtos(int id, string n, Tipos t, double p)
{
Id = id;
Nome = n;
Tipo = t;
Preco = p;
}
public List <Tipos> ListarTipo()
{
SqlCommand cmd = null;
List <Tipos> lista = new List <Tipos>();
try
{
SqlConnection cn = Conexion.Instancia.conectar();
cmd = new SqlCommand("listarTipo", cn);
cmd.CommandType = CommandType.StoredProcedure;
cn.Open();
SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
Tipos bo = new Tipos();
bo.CodigoTipo = Convert.ToInt16(dr["CodigoTipo"]);
bo.Nombre = dr["Nombre"].ToString();
bo.Caracteristica = dr["Caracteristica"].ToString();
bo.estado = Convert.ToBoolean(dr["estado"]);
lista.Add(bo);
}
}
catch (Exception e)
{
throw e;
}
finally { cmd.Connection.Close(); }
return(lista);
}
static void Main(string[] args)
{
//Console.Write("Entra un número: ");
//Numeros valor = (Numeros)Int32.Parse(Console.ReadLine());
//switch (valor)
//{
// case Numeros.Uno:
// Console.WriteLine("Entraste un uno");
// break;
// case Numeros.Dos:
// Console.WriteLine("Entraste un dos");
// break;
//}
DiasSemana lunes = DiasSemana.Sabado;
Console.WriteLine("El día {0} se representa con {1}", lunes, (int)lunes);
Tipos modo = Tipos.Lectura | Tipos.Oculto | Tipos.Sistema;
if ((modo & Tipos.Todos) == Tipos.Lectura)
{
Console.WriteLine("Solo está activo el bit de lectura");
}
else
{
Console.WriteLine("Hay más bits activos");
}
}
public void Borrar()
{
if (TipoSeleccionado.Delete())
{
Tipos.Remove(TipoSeleccionado);
}
}
private bool verificarTipo(Tipos tipo, object result)
{
if (tipo == Tipos.INT && result is int)
{
return(true);
}
if (tipo == Tipos.STRING && result is string)
{
return(true);
}
else if (tipo == Tipos.CHAR && result is char)
{
return(true);
}
else if (tipo == Tipos.DOUBLE && result is Double)
{
return(true);
}
else if (tipo == Tipos.BOOL && result is bool)
{
return(true);
}
else if (tipo == Tipos.OBJETO && result is Objeto)
{
return(true);
}
else
{
return(false);
}
}
public object GetValor(Entorno e)
{
Tipos tipoNuevo = GetTipo(e);
if (tipoNuevo.Equals(Tipos.NULL))
{
Console.WriteLine("No se pudo operar el casta entre los tipos " + tipoPrincipal + " y " + tipoaAsignar);
return(null);
}
//Si es un cast valido
if (valor == null)
{
Console.WriteLine("No se puede convertir un valor null a ningun otro tipo");
return(null);
}
if (tipoNuevo.Equals(Tipos.INT))
{
return(Convert.ToInt32(valor));
}
if (tipoNuevo.Equals(Tipos.DOUBLE))
{
return(Convert.ToDouble(valor));
}
return(null);
}
public async Task GetAll()
{
Tipos = await _dbContext.Tipos
.ToListAsync();
TiposNaoCadastrados = !Tipos.Any();
}
public object ejecutar(Entorno ent, AST arbol)
{
object valor_simbolo = valor.getValorImplicito(ent, arbol);
Tipos tipoResultado = valor.getTipo(ent, arbol);
if (ent.existe(id))
{
Simbolo simbolo = ent.getSimbolo(id);
if (simbolo.tipo == tipoResultado)
{
simbolo.valor = valor_simbolo;
ent.reemplazar(id, simbolo);
}
else
{
Form1.Consola.AppendText("Error semantico en Asignacion, no se permiten asignar valores de diferentes tipos en linea " + linea + " y columna " + columna + "\n");
return(false);
}
}
else
{
Form1.Consola.AppendText("Error semantico no existe el id " + id + " " + linea + " y columna " + columna + "\n");
return(null);
}
return(null);
}
public static SqlDataReader ObtenerDataReader(String SQL, Tipos Descripcion, List <SqlParameter> Parametros)
{
SqlCommand comando = new SqlCommand();
comando.CommandText = SQL;
foreach (SqlParameter par in Parametros)
{
comando.Parameters.Add(par);
}
switch (Descripcion)
{
case Tipos.Text:
comando.CommandType = CommandType.Text;
break;
case Tipos.StoreProcedure:
comando.CommandType = CommandType.StoredProcedure;
break;
case Tipos.TableDirect:
comando.CommandType = CommandType.TableDirect;
break;
default:
break;
}
comando.Connection = ObtenerConexion();
SqlDataReader DataReader = comando.ExecuteReader();
return(DataReader);
}
/**
* @fn public Simbolo(string Identificador, Tipos Tipo, LinkedList<Simbolo> ListaParametros)
*
* @brief Constructor que se utiliza para definición de funciones.
*
* @author Javier Estuardo Navarro
* @date 26/08/2018
*
* @param Identificador Identificador del Simbolo.
* @param Tipo Tipo específico de la variable, Entero, Decimal,
* Cadena, OBJETO, etc. del Simbolo.
* @param ListaParametros La lista parametros de la funcion.
*/
public Simbolo(string Identificador, Tipos Tipo, LinkedList <Simbolo> ListaParametros)
{
this.Identificador = Identificador;
this.Tipo = Tipo;
this.ListaParametros = ListaParametros;
Funcion = true;
}
private bool Delete(ref Tipos item)
{
try
{
if (item.Instance == Infrastructure.Aspect.BusinessEntity.InstanceEntity.Deleted)
{
DataAccessEnterpriseSQL.DAAsignarProcedure("T_SP_ELIMINAR_Tipos");
DataAccessEnterpriseSQL.DAAgregarParametro("@pchrTIPO_CodTabla", item.TIPO_CodTabla, SqlDbType.Char, 3, ParameterDirection.Input);
DataAccessEnterpriseSQL.DAAgregarParametro("@pchrTIPO_CodTipo", item.TIPO_CodTipo, SqlDbType.Char, 3, ParameterDirection.Input);
if (DataAccessEnterpriseSQL.DAExecuteNonQuery() > 0)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
catch (Exception ex)
{ throw ex; }
}
public Boolean InsertarTipo(Tipos bol)
{
SqlCommand cmd = null;
Boolean inserta = false;
try
{
SqlConnection cn = Conexion.Instancia.conectar();
cmd = new SqlCommand("InsertarTipo", cn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Nombre", bol.Nombre);
cmd.Parameters.AddWithValue("@Caracteristica", bol.Caracteristica);
cmd.Parameters.AddWithValue("@Estado", bol.estado);
cn.Open();
int i = cmd.ExecuteNonQuery();
if (i > 0)
{
inserta = true;
}
}
catch (Exception e)
{
throw e;
}
finally { cmd.Connection.Close(); }
return(inserta);
}
private void MatrizPecasParaMatrizPosicoes()
{
int lin, col, atual;
int pecasPretas = 0;
int pecasVermelhas = 0;
Posicao posicaoAtual;
int tamanho = getTamanhoTabuleiro();
//TODO verificar se é dama ou não
//se essa função for ser utilizada para outro propósito sem ser a inicialização isso será necessário
for (lin = 0; lin < tamanho; lin++)
{
for (col = 0; col < tamanho; col++)
{
atual = matrizTabuleiroInt[lin, col];
posicaoAtual = matrizTabuleiroPosicoes[lin, col].gameObject.GetComponent <Posicao>();
posicaoAtual.lin = lin;
posicaoAtual.col = col;
if (Tipos.isJogador1(atual))
{
posicaoAtual.peca = pedrasPretas.transform.GetChild(pecasPretas).gameObject;
pecasPretas++;
}
else if (Tipos.isJogador2(atual))
{
posicaoAtual.peca = pedrasVermelhas.transform.GetChild(pecasVermelhas).gameObject;
pecasVermelhas++;
}
}
}
}
private static Brush GetByTipo(Tipos tipos)
{
switch (tipos)
{
case Tipos.TipoA:
return Brushes.Red;
case Tipos.TipoB:
return Brushes.Purple;
case Tipos.TipoC:
return Brushes.RoyalBlue;
case Tipos.TipoBVirado:
return Brushes.Purple;
case Tipos.TipoCVirado:
return Brushes.RoyalBlue;
}
throw new NotImplementedException();
}
public static int[] GetTamByTipo(Tipos tipos)
{
switch (tipos)
{
case Tipos.TipoA:
return new[] { 3, 3 };
case Tipos.TipoB:
return new[] { 5, 1 };
case Tipos.TipoC:
return new[] { 4, 2 };
case Tipos.TipoBVirado:
return new[] { 1, 5 };
case Tipos.TipoCVirado:
return new[] { 2, 4 };
}
throw new Exception();
}
/// <summary>
/// Gera uma nova Carga a Partir do Tipo e da Quantidade
/// </summary>
/// <param name="v"></param>
/// <param name="tam"></param>
/// <param name="tipo"></param>
private static void GeraTipo(ref List<ClassCarga> v, int tam, Tipos tipo)
{
for (var i = 0; i < tam; i++)
{
var posX = Random.Next(0, 9);
var posY = Random.Next(0, 9);
v.Add(new ClassCarga
{
posX = posX,
posY = posY,
Tipo = tipo,
Largura = GetTamByTipo(tipo)[0],
Altura = GetTamByTipo(tipo)[1]
});
}
}
public frmEquipos()
{
InitializeComponent();
objEquipos = new Equipos();
objTipos = new Tipos();
}
public void d_InserirCidadesTiposTicketETicketEViagem()
{
Tipos<Cidade> repositorioCidades = new Tipos<Cidade>();
Cidade saoPaulo = new Cidade("São Paulo");
Cidade recife = new Cidade("Recife");
Cidade brasilia = new Cidade("Brasília");
repositorioCidades.Salvar(saoPaulo);
repositorioCidades.Salvar(recife);
repositorioCidades.Salvar(brasilia);
Cidades = new List<Cidade>();
Cidades.Add(saoPaulo);
Cidades.Add(recife);
Cidades.Add(brasilia);
InserirTipoTickets();
InserirTickets();
InserirViagens();
InserirDiarias();
}
public void InserirTipoTickets()
{
Tipos<TipoTicket> repositorioTipoTicket = new Tipos<TipoTicket>();
TipoTicket diaria = new TipoTicket("Diária");
TipoTicket taxi = new TipoTicket("Taxi");
TipoTicket refeicao = new TipoTicket("Refeição");
TipoTicket passagem = new TipoTicket("Passagem");
repositorioTipoTicket.Salvar(diaria);
repositorioTipoTicket.Salvar(taxi);
repositorioTipoTicket.Salvar(refeicao);
repositorioTipoTicket.Salvar(passagem);
Tipos = new List<TipoTicket>();
Tipos.Add(diaria);
Tipos.Add(taxi);
Tipos.Add(refeicao);
Tipos.Add(passagem);
}
private void criar_time_com_sucesso()
{
Time = new Time("barcelona");
Tipos<TipoCredito> tipo = new Tipos<TipoCredito>();
TipoCredito tipoCredito = tipo.Obter(1);
CreditoPatrocinador credito = new CreditoPatrocinador(tipoCredito, DateTime.Now, 10);
var receberPagamento = typeof(Patrocinado).GetMethod("ReceberPagamento", BindingFlags.NonPublic | BindingFlags.Instance);
receberPagamento.Invoke(Time, new object[] { credito });
Patrocinados.Salvar(Time);
}
