public IHttpActionResult PutOperadoresPorWorkCenter(int id, Operadores operadoresPorWorkCenter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != operadoresPorWorkCenter.Id)
{
return(BadRequest());
}
db.Entry(operadoresPorWorkCenter).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!OperadoresPorWorkCenterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public double RealizarLaOperacionBinaria(Operadores miOperador, double operandoUno, double operandoDos)
{
double resultado = 0.0;
switch (miOperador)
{
case Enumerados.Operadores.Suma:
var laSuma = new LogicaNegocio.Especificaciones.Suma();
resultado = laSuma.Calculo(operandoUno, operandoDos);
break;
case Enumerados.Operadores.Division:
var division = new LogicaNegocio.Especificaciones.Division();
resultado = division.Calculo(operandoUno, operandoDos);
break;
case Enumerados.Operadores.Multiplicacion:
var multiplicacion = new LogicaNegocio.Especificaciones.Multiplicacion();
resultado = multiplicacion.Calculo(operandoUno, operandoDos);
break;
case Enumerados.Operadores.Resta:
var resta = new LogicaNegocio.Especificaciones.Resta();
resultado = resta.Calculo(operandoUno, operandoDos);
break;
}
return (resultado);
}
public static void AsignarOrden(Ordenes ordenes, Operadores operadores)
{
Operador operador;
Orden proximaOrden;
bool salir = false;
do
{
Console.WriteLine("\t:::Asignación de ordenes:::");
operador = CustomInput.IngresarOperador(operadores);
proximaOrden = ordenes.ProximaOrdenNoAsignada();
proximaOrden.Operador = operador;
Input.WriteYellowLine(string.Format(
"Orden {0} asignada al operador {1}\n",
proximaOrden.NumeroOrden,
operador.NumeroOperador
));
if (!ordenes.QuedanOrdenesSinAsignar())
{
Input.WriteYellowLine("\nBuen trabajo!! Ya no quedan ordenes sin asignar");
break;
}
salir = Input.IngresoVerdaderoFalso("¿Desea continuar asignando ordenes?");
} while (salir);
}
static void ExecutarAulas()
{
Console.WriteLine("\n----- Aula01 -----");
Variaveis.Executar();
Console.WriteLine("\n----- Aula02 -----");
VariaveisEspeciais.Executar();
Console.WriteLine("\n----- Aula03 -----");
Curiosidades.Executar();
Console.WriteLine("\n----- Aula04 -----");
Globalization.Executar();
Console.WriteLine("\n----- Aula05 -----");
Strings.Executar();
Console.WriteLine("\n----- Aula06 -----");
Operadores.Executar();
Console.WriteLine("\n----- Aula07 -----");
Math.Executar();
Console.WriteLine("\n----- Aula08 -----");
Incrementar.Executar();
}
static void Main(string[] args)
{
/*
* Una empresa de cable necesita una aplicación para encolar las órdenes de instalación recibidas y asignarlas a los técnicos que las realizarán. Para ello se le solicita una aplicación que permita:
*/
/* o A) El ingreso de una cantidad de operadores (identificados por un número de operador).
*/
operadores = CustomInput.IngresoOperadores();
/* o B) El ingreso de una cantidad de órdenes de trabajo (identificadas por un número de órden).
*/
ordenes = CustomInput.IngresoOrdenes();
/* o C) La asignación de una orden a un operador. Para ello, el usuario indicará un número de operador y el sistema le asignará la próxima orden de trabajo no asignada, teniendo en cuenta el orden de carga del punto A), dando por terminada la asignación anterior en caso de existir una. Este proceso se repetirá tantas veces como indique el usuario.
*/
CustomInput.AsignarOrden(ordenes, operadores);
/* o D) Al terminar, reporte: cuántas órdenes cumplió cada operador, qué órdenes quedaron pendientes de asignar.
*/
Console.Clear();
CustomInput.Reporte(ordenes);
Input.PresionaUnaTeclaParaContinuar();
}
public ActionResult DeleteConfirmed(int id)
{
Operadores operadoresPorWorkCenter = db.Operadores.Find(id);
db.Operadores.Remove(operadoresPorWorkCenter);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public override global::System.Data.DataSet Clone()
{
Operadores cln = ((Operadores)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return(cln);
}
public WhereClause(string Campo, Type Tipo, Operadores Operador, string Valor, Condicional condicional)
{
this.campo = Campo;
this.tipo = Tipo;
this.operador = Operador;
this.valor = Valor;
this.condicional = condicional;
}
private string getTypeToken(string matchRgx) //El numero de retorno representa la jerarquia de la ER
{
Regex rgx1 = new Regex(@"(//((\w)|(\s)|(\p{P})|(\p{S}))+)");
Regex rgx21 = new Regex(@"^([0-9]+[.][0-9]*(E|e)([+]|[-])?[0-9]+)$");
Regex rgx22 = new Regex(@"^(0(x|X)([0-9]|[a-fA-F])+)$");
Regex rgx23 = new Regex(@"^([0-9]+[.][0-9]*)$");
Regex rgx24 = new Regex(@"^([0-9]+)$");
Regex rgx3 = new Regex(@"(""((\w)|(\s)|(\p{P})|(\p{S}))+)");
Regex rgx4 = new Regex(@"(""((\w)|(\s)|(\p{P})|(\p{S}))+"")");
Regex rgx5 = new Regex(@"([a-zA-Z]([\w]|[_])*)");
Regex rgx6 = new Regex(@"(<=|>=|==|!=|&&|[||])");
if (rgx1.IsMatch(matchRgx))
{
return("");
}
else if (rgx21.IsMatch(matchRgx))
{
return("2.1");
}
else if (rgx22.IsMatch(matchRgx))
{
return("2.2");
}
else if (rgx23.IsMatch(matchRgx))
{
return("2.3");
}
else if (rgx24.IsMatch(matchRgx))
{
return("2.4");
}
else if (matchRgx == "\"\"")
{
return("4");
}
else if (rgx4.IsMatch(matchRgx))
{
return("4");
}
else if (rgx3.IsMatch(matchRgx))
{
return("3");
}
else if (rgx5.IsMatch(matchRgx))
{
return("5");
}
else if (rgx6.IsMatch(matchRgx) || Operadores.Contains(matchRgx))
{
return("6");
}
else
{
return("8");
}
}
public IHttpActionResult GetOperadoresPorWorkCenter(int id)
{
Operadores operadoresPorWorkCenter = db.Operadores.Find(id);
if (operadoresPorWorkCenter == null)
{
return(NotFound());
}
return(Ok(operadoresPorWorkCenter));
}
public IHttpActionResult PostOperadoresPorWorkCenter(Operadores operadoresPorWorkCenter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Operadores.Add(operadoresPorWorkCenter);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = operadoresPorWorkCenter.Id }, operadoresPorWorkCenter));
}
public ActionResult Edit([Bind(Include = "Id,IdOperador,IdWorkCenter,Activo")] Operadores operadoresPorWorkCenter)
{
if (ModelState.IsValid)
{
db.Entry(operadoresPorWorkCenter).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IdOperador = new SelectList(db.Personas.Select(x => new { Id = x.Id, Nombre = x.Nombre + " " + x.Apellido1 + " " + x.Apellido2 }).OrderBy(x => x.Nombre), "Id", "Nombre");
ViewBag.IdWorkCenter = new SelectList(db.WorkCenters, "Id", "Nombre", operadoresPorWorkCenter.IdWorkCenter);
return(View(operadoresPorWorkCenter));
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(global::System.Xml.Schema.XmlSchemaSet xs)
{
Operadores ds = new Operadores();
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
global::System.Xml.Schema.XmlSchemaAny any = new global::System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace))
{
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext();)
{
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length))
{
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length) &&
(s1.ReadByte() == s2.ReadByte()));)
{
;
}
if ((s1.Position == s1.Length))
{
return(type);
}
}
}
}
finally {
if ((s1 != null))
{
s1.Close();
}
if ((s2 != null))
{
s2.Close();
}
}
}
xs.Add(dsSchema);
return(type);
}
public Operadores Adicionar(OperadoresDTO Operador)
{
Operadores Inserir = new Operadores
{
Matricula = Operador.Matricula,
Senha = Operador.Senha,
Nome = Operador.Nome
};
Operadores Retorno = this._operadoresRepositorio.Add(Inserir);
return(Retorno);
}
public Operadores Add(Operadores Operador)
{
try
{
Operador.Senha = MD5Hash.GerarHashMd5(Operador.Senha);
_contexto.Operadores.Add(Operador);
_contexto.SaveChanges();
return(Operador);
}
catch (Exception e)
{
throw new Exception("Erro ao inserir Operador: " + e.Message + " (" + e.InnerException + ")");
}
}
public IHttpActionResult DeleteOperadoresPorWorkCenter(int id)
{
Operadores operadoresPorWorkCenter = db.Operadores.Find(id);
if (operadoresPorWorkCenter == null)
{
return(NotFound());
}
db.Operadores.Remove(operadoresPorWorkCenter);
db.SaveChanges();
return(Ok(operadoresPorWorkCenter));
}
// GET: Seguridad/Operadores/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Operadores operadoresPorWorkCenter = db.Operadores.Find(id);
if (operadoresPorWorkCenter == null)
{
return(HttpNotFound());
}
return(View(operadoresPorWorkCenter));
}
public double RealizarLaOperacionBinaria(Operadores miOperador, double operandoUno, double operandoDos)
{
double resultado = 0.0;
switch (miOperador)
{
case Enumerados.Operadores.Suma:
var laSuma = new LogicaNegocio.Especificaciones.Suma();
resultado = laSuma.Calculo(operandoUno, operandoDos);
break;
}
return (resultado);
}
// GET: Seguridad/Operadores/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Operadores operadoresPorWorkCenter = db.Operadores.Find(id);
if (operadoresPorWorkCenter == null)
{
return(HttpNotFound());
}
ViewBag.IdOperador = new SelectList(db.Personas.Select(x => new { Id = x.Id, Nombre = x.Nombre + " " + x.Apellido1 + " " + x.Apellido2 }).OrderBy(x => x.Nombre), "Id", "Nombre");
ViewBag.IdWorkCenter = new SelectList(db.WorkCenters, "Id", "Nombre", operadoresPorWorkCenter.IdWorkCenter);
return(View(operadoresPorWorkCenter));
}
static int HacerCuenta(int i, int j, Operadores operador)
{
switch (operador)
{
case Operadores.Suma:
return(i + j);
case Operadores.Resta:
return(i - j);
case Operadores.Multiplicacion:
return(i * j);
case Operadores.Division:
return(i / j);
default:
throw new Exception("☁️");
}
}
static int HacerCuentaSwitch(int a, int b, Operadores operador)
{
switch (operador)
{
case Operadores.Suma:
return(a + b);
case Operadores.Resta:
return(a - b);
case Operadores.Division:
return(a / b);
case Operadores.Multiplicacion:
return(a * b);
default:
throw new Exception("humo");
}
}
public IContrato obtenerAdaptador(Operadores operador)
{
IContrato contrato = null;
switch (operador)
{
case Operadores.tigo:
contrato = new ContratoTigo();
break;
case Operadores.claro:
contrato = new ContratoClaro();
break;
case Operadores.movistar:
contrato = new ContratoMovistar();
break;
}
return(contrato);
}
public static Operador IngresarOperador(Operadores operadores)
{
Operador operador;
int input;
do
{
Console.WriteLine("\tIngrese un código de operador válido.");
input = Input.IngresoNumeroPositivo();
operador = operadores.buscarOperador(input);
if (operadores.ExisteOperador(operador))
{
break;
}
} while (true);
return(operador);
}
public static Operadores IngresoOperadores(
int salida = 0,
string Mensaje = "Escribe el código del operador"
)
{
Console.WriteLine("\n");
Operadores operadores = new Operadores();
Operador operador;
int input;
bool existe;
do
{
Console.WriteLine("\t" + Mensaje);
Input.WriteRedLine("\to \"" + salida + "\" para no ingresar mas Operadores");
input = Input.IngresoNumeroPositivo();
operador = operadores.buscarOperador(input);
existe = operadores.ExisteOperador(operador);
if (existe)
{
Input.WriteYellowLine("\tEl operadio con el código \"" + input + "\" ya existe.");
}
if (salida != input && !existe)
{
operadores.agregarOperador(input);
}
} while (salida != input && !existe);
return(operadores);
}
public IActionResult CadastrarOperador(OperadoresDTO Operador)
{
try
{
if (_operadoresBLL.ObterPorMatricula(Operador.Matricula) != null)
{
return(BadRequest(new SaidaAPI {
ExecutadoComSucesso = false, Mensagem = "Matrícula já existe na base de dados."
}));
}
Operadores Retorno = _operadoresBLL.Adicionar(Operador);
return(Created("api/Auth/operador?Matricula=" + Operador.Matricula, new SaidaAPI {
ExecutadoComSucesso = true, Data = Retorno
}));
}
catch (Exception e)
{
return(BadRequest(new SaidaAPI {
ExecutadoComSucesso = false, Mensagem = e.Message
}));
}
}
public IActionResult ObterPorMatricula(int Matricula)
{
try
{
Operadores Retorno = _operadoresBLL.ObterPorMatricula(Matricula);
if (Retorno == null)
{
return(NotFound(new SaidaAPI {
ExecutadoComSucesso = false, Mensagem = "Operador não encontrado com Matrícula: " + Matricula
}));
}
return(Ok(new SaidaAPI {
ExecutadoComSucesso = true, Data = Retorno
}));
}
catch (Exception e)
{
return(BadRequest(new SaidaAPI {
ExecutadoComSucesso = false, Mensagem = e.Message
}));
}
}
public IConfiguracaoQuery <TObjeto> Seja(Operadores operador, DbType tipo, object valor)
{
return(AdicionarCondicaoEConfiguracaoQuery(operador, tipo, valor));
}
public IConfiguracaoQuery <TObjeto> Seja(Operadores operador, DateTime?valor)
{
return(AdicionarCondicaoEConfiguracaoQuery(operador, DbType.DateTime, valor));
}
public IConfiguracaoQuery <TObjeto> Seja(Operadores operador, decimal?valor)
{
return(AdicionarCondicaoEConfiguracaoQuery(operador, DbType.Decimal, valor));
}
public IConfiguracaoQuery <TObjeto> Seja(Operadores operador, int?valor)
{
return(AdicionarCondicaoEConfiguracaoQuery(operador, DbType.Int32, valor));
}
/// <summary>
/// Método para la creación del árbol basado en la notación postfija
/// </summary>
/// <param name="expresionPostfija"></param>
public void CrearArbol(string expresionPostfija)
{
var pila = new Stack <Nodo>(); //Pila que guardará momentanemente los nodos para ir formando en orden el árbol
var contadorHojas = 1;
while (expresionPostfija.Length != 0)
{
var nuevoNodo = new Nodo();
if (!Operadores.Contains(expresionPostfija[0]) && expresionPostfija[0] != '#') //Si No es un operador y si NO es el estado de ACEPTACIÓN
{
nuevoNodo.ItemExpresion = expresionPostfija[0].ToString();
nuevoNodo.NumNodo = contadorHojas;
nuevoNodo.Follow = new List <Nodo>();
nuevoNodo.EsHoja = true;
contadorHojas++;
nuevoNodo.AsignarNulabilidad();
pila.Push(nuevoNodo);
}
else if (Operadores.Contains(expresionPostfija[0]) && expresionPostfija[0] != '#') //Si ES operador
{
if (pila.Count >= 2 && expresionPostfija[0] != '*' && expresionPostfija[0] != '+')
{
nuevoNodo.ItemExpresion = expresionPostfija[0].ToString();
nuevoNodo.DrchNodo = pila.Pop();
nuevoNodo.IzqNodo = pila.Pop();
nuevoNodo.AsignarNulabilidad();
}
else
{
nuevoNodo.ItemExpresion = expresionPostfija[0].ToString();
if (pila.Count > 0)
{
nuevoNodo.IzqNodo = pila.Pop();
}
nuevoNodo.AsignarNulabilidad();
}
pila.Push(nuevoNodo);
}
else if (expresionPostfija[0] == '#')
{
nuevoNodo.ItemExpresion = expresionPostfija[0].ToString();
nuevoNodo.NumNodo = contadorHojas;
nuevoNodo.EsHoja = true;
nuevoNodo.AsignarNulabilidad();
Raiz = pila.Pop();
Raiz.DrchNodo = nuevoNodo;
Raiz.AsignarNulabilidad();
}
expresionPostfija = expresionPostfija.Remove(0, 1);
}
}
public string ConsultarOperador(Operadores operador)
{
return(ConsultarSinalDoOperador(operador.GetHashCode()));
}
