public Dictionary <Object, dynamic> insertMaterialTypeFromMaintenance()
{
if (String.IsNullOrEmpty(data["description"]))
{
return(result(Result.Failed, Result.Empty, null));
}
try
{
string oldContent, newContent;
TipoMaterial materialType = CreateMaterialType();
oldContent = "";
newContent = materialType.toString();
Bitacora materialTypeLog = createLog(Log.Insert, Log.MaterialType, oldContent, newContent);
db.TipoMaterial.Add(materialType);
db.Bitacora.Add(materialTypeLog);
db.SaveChanges();
return(result(Result.Processed, Result.Inserted, null));
}
catch (Exception ex)
{
return(result(Result.Failed, "Se ha generado un error: " + ex.Message, null));
}
}
public Dictionary <Object, dynamic> deleteMaterialType(TipoMaterial registeredMaterialType)
{
try
{
TipoMaterial delMaterialType = db.TipoMaterial.Find(data["id"]);
string oldContent = delMaterialType.toString();
delMaterialType.Eliminado = 1;
delMaterialType.IdEstado = Status.Inactive;
string newContent = delMaterialType.toString();
db.Entry(delMaterialType).State = System.Data.Entity.EntityState.Modified;
Bitacora paymentLog = createLog(Log.Delete, Log.MaterialType, oldContent, newContent);
db.Bitacora.Add(paymentLog);
db.SaveChanges();
return(result(Result.Processed, Result.Deleted, null));
}
catch (Exception ex)
{
return(result(Result.Failed, "Error al eliminar el registro: " + ex.Message, null));
}
}
public Dictionary <Object, dynamic> modifyMaterialType(TipoMaterial registeredMaterial, TipoMaterial modifiedMaterial)
{
if (String.IsNullOrEmpty(modifiedMaterial.Descripcion))
{
return(result(Result.Failed, Result.Empty, null));
}
if (registeredMaterial.Descripcion.Equals(modifiedMaterial.Descripcion))
{
return(result(Result.Failed, Result.Same, null));
}
try
{
string oldContent = registeredMaterial.toString();
string newContent = modifiedMaterial.toString();
TipoMaterial newMaterialType = db.TipoMaterial.Find(modifiedMaterial.IdTipoMaterial);
db.Entry(newMaterialType).CurrentValues.SetValues(modifiedMaterial);
db.Entry(newMaterialType).State = System.Data.Entity.EntityState.Modified;
Bitacora MaterialTypeLog = createLog(Log.Modify, Log.MaterialType, oldContent, newContent);
db.Bitacora.Add(MaterialTypeLog);
db.SaveChanges();
return(result(Result.Processed, Result.Modified, null));
}
catch (Exception ex)
{
return(result(Result.Failed, "Error al modificar el registro: " + ex.Message, null));
}
}
private Material createMaterial()
{
int idMaterialType = data["type"];
int idProvider = data["provider"];
var queryType = from type in db.TipoMaterial
where type.IdTipoMaterial == idMaterialType
select type;
var queryProvider = from prov in db.Proveedor
where prov.IdProveedor == idProvider
select prov;
TipoMaterial materialType = queryType.FirstOrDefault();
Proveedor provider = queryProvider.FirstOrDefault();
return(new Material()
{
Descripcion = data["description"],
FechaAgrega = DateTime.Now,
FechaElimina = null,
UsuarioAgrega = data["user"],
Eliminado = data["deleted"],
IdEstado = data["status"],
TipoMaterial = materialType,
Proveedor = provider
});
}
public Boolean guardar(clsTipoMaterial ctm, ref string Mensaje)
{
try
{
using (INVENTARIOEntities te = new INVENTARIOEntities())
{
TipoMaterial tm = new TipoMaterial();
tm.IdEmpresa = Convert.ToInt32(ctm.empresa);
tm.IdTipoMaterial = ctm.codigo;
tm.Descripcion = ctm.descripcion;
// IdUsuario = Convert.ToInt32(ctm.usuario),
tm.IdEstado = Convert.ToInt32(ctm.estado);
te.AddToTipoMaterial(tm);
te.SaveChanges();
}
return(true);
}
catch (Exception e)
{
Mensaje = "ERROR" + e.InnerException + e.Message;
//Console.WriteLine("ERROR" + e);
return(false);
}
}
private void modBtnSaveMaterialType_Click(object sender, EventArgs e)
{
this.controller = new MaterialTypeController();
Dictionary <string, dynamic> data = new Dictionary <string, dynamic>();
TipoMaterial modifiedMaterialType = new TipoMaterial()
{
IdTipoMaterial = registeredMaterialType.IdTipoMaterial,
Descripcion = txtDescription.Text.TrimStart().TrimEnd(),
FechaAgrega = registeredMaterialType.FechaAgrega,
FechaElimina = registeredMaterialType.FechaElimina,
UsuarioAgrega = registeredMaterialType.UsuarioAgrega,
Eliminado = registeredMaterialType.Eliminado,
IdEstado = registeredMaterialType.IdEstado
};
data["user"] = Session.getInstance().session["identification"];
controller.data = data;
Dictionary <Object, dynamic> result = controller.modifyMaterialType(registeredMaterialType, modifiedMaterialType);
if (result["code"] == Result.Processed)
{
this.loadCombos();
}
MessageBox.Show(result["msg"]);
}
public async Task <IHttpActionResult> PutTipoMaterial(int id, TipoMaterial tipoMaterial)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tipoMaterial.IdTipoMaterial)
{
return(BadRequest());
}
db.Entry(tipoMaterial).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoMaterialExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
if (Request["cod"] != null)
{
btnguardar.Enabled = false;
btnactualizar.Enabled = true;
int codigo = Convert.ToInt32(Request["cod"]);
tipoMaterialInfo = TipoMaterialLogica.ObtenertipoID(codigo);
if (tipoMaterialInfo != null)
{
try
{
lblcodigo.Text = tipoMaterialInfo.Id_TipoMaterial.ToString();
txtnombreMat.Text = tipoMaterialInfo.TMat_Nombre.ToString();
}
catch (Exception)
{
throw;
}
}
else
{
btnguardar.Enabled = true;
btnactualizar.Enabled = false;
}
}
this.Form.Attributes.Add("autocomplete", "off");
cargarTipo();
}
}
public TipoMaterial SalvarTipoMaterial(TipoMaterial tipomaterial)
{
try
{
if (tipomaterial.IdTipoMaterial > 0)
{
Context.Entry(tipomaterial).State = EntityState.Modified;
}
else
{
Context.TipoMaterial.Add(tipomaterial);
}
Context.SaveChanges();
return(tipomaterial);
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
}
public void IngresaTipoMaterial(EntityConnectionStringBuilder connection, TipoMaterial tm)
{
var context = new samEntities(connection.ToString());
context.INSERT_tipo_material_MDL(tm.MTART,
tm.MTBEZ_ES,
tm.MTBEZ_EN);
}
public ActionResult DeleteConfirmed(int id)
{
TipoMaterial tipomaterial = db.TipoMateriales.Find(id);
db.TipoMateriales.Remove(tipomaterial);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public TipoMaterial Update(TipoMaterial tipoMaterial)
{
var entity = _db.TipoMateriales.Attach(tipoMaterial);
entity.State = EntityState.Modified;
return(tipoMaterial);
}
public ActionResult Edit([Bind(Include = "tipoMaterialId,nombre")] TipoMaterial tipomaterial)
{
if (ModelState.IsValid)
{
db.Entry(tipomaterial).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipomaterial));
}
public async Task <IHttpActionResult> GetTipoMaterial(int id)
{
TipoMaterial tipoMaterial = await db.TipoMaterials.FindAsync(id);
if (tipoMaterial == null)
{
return(NotFound());
}
return(Ok(tipoMaterial));
}
public ActionResult Create([Bind(Include = "tipoMaterialId,nombre")] TipoMaterial tipomaterial)
{
if (ModelState.IsValid)
{
db.TipoMateriales.Add(tipomaterial);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipomaterial));
}
public static void Modify(TipoMaterial tipo)
{
try
{
dc.SubmitChanges();
}
catch (Exception ex)
{
throw new ArgumentException("Los Datos No han sido Modificados </br>" + ex.Message);
}
}
public static void Delete(TipoMaterial tipo)
{
try
{
tipo.TMat_Estado = 'E';
dc.SubmitChanges();
}
catch (Exception ex)
{
throw new ArgumentException("los datos no han sido eliminados" + ex.Message);
}
}
public async Task <IHttpActionResult> PostTipoMaterial(TipoMaterial tipoMaterial)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.TipoMaterials.Add(tipoMaterial);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = tipoMaterial.IdTipoMaterial }, tipoMaterial));
}
public async Task <IActionResult> Manage(TipoMaterial TipoMaterial)
{
try
{
ViewBag.accion = TipoMaterial.TipoMaterialId == 0 ? "Crear" : "Editar";
if (ModelState.IsValid)
{
var existeRegistro = false;
if (TipoMaterial.TipoMaterialId == 0)
{
if (!await db.TipoMaterial.AnyAsync(c => c.DescripcionTipoMaterial.ToUpper().Trim() == TipoMaterial.DescripcionTipoMaterial.ToUpper().Trim()))
{
await db.AddAsync(TipoMaterial);
}
else
{
existeRegistro = true;
}
}
else
{
if (!await db.TipoMaterial.Where(c => c.DescripcionTipoMaterial.ToUpper().Trim() == TipoMaterial.DescripcionTipoMaterial.ToUpper().Trim()).AnyAsync(c => c.TipoMaterialId != TipoMaterial.TipoMaterialId))
{
var CurrentTipoMaterial = await db.TipoMaterial.Where(x => x.TipoMaterialId == TipoMaterial.TipoMaterialId).FirstOrDefaultAsync();
CurrentTipoMaterial.DescripcionTipoMaterial = TipoMaterial.DescripcionTipoMaterial;
}
else
{
existeRegistro = true;
}
}
if (!existeRegistro)
{
await db.SaveChangesAsync();
return(this.Redireccionar($"{Mensaje.MensajeSatisfactorio}|{Mensaje.Satisfactorio}"));
}
else
{
TempData["Mensaje"] = $"{Mensaje.Error}|{Mensaje.ExisteRegistro}";
}
return(View(TipoMaterial));
}
return(View(TipoMaterial));
}
catch (Exception)
{
return(this.Redireccionar($"{Mensaje.Error}|{Mensaje.Excepcion}"));
}
}
public static void Save(TipoMaterial tipo)
{
try
{
tipo.TMat_Estado = 'A';
dc.TipoMaterial.InsertOnSubmit(tipo);
dc.SubmitChanges();
}
catch (Exception ex)
{
throw new ArgumentException("Los Datos No han sido Guardados </br>" + ex.Message);
}
}
/// <summary>
/// Recupera o tipo de material.
/// </summary>
/// <param name="tipo"></param>
/// <returns></returns>
private static string ObterTipoMaterial(TipoMaterial tipo)
{
switch (tipo)
{
case TipoMaterial.Laminado:
return("Laminated");
case TipoMaterial.Monolitico:
return("Monolithic");
default:
return("");
}
}
// GET: /TipoMaterial/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoMaterial tipomaterial = db.TipoMateriales.Find(id);
if (tipomaterial == null)
{
return(HttpNotFound());
}
return(View(tipomaterial));
}
public async Task <IHttpActionResult> DeleteTipoMaterial(int id)
{
TipoMaterial tipoMaterial = await db.TipoMaterials.FindAsync(id);
if (tipoMaterial == null)
{
return(NotFound());
}
db.TipoMaterials.Remove(tipoMaterial);
await db.SaveChangesAsync();
return(Ok(tipoMaterial));
}
private void GuardarDatos(int id)
{
if (id == 0)
{
Guardar();
}
else
{
tipoMaterialInfo = TipoMaterialLogica.ObtenertipoID(id);
if (tipoMaterialInfo != null)
{
Modificar(tipoMaterialInfo);
}
}
}
public IActionResult OnGet(int?id)
{
if (id == null)
{
return(NotFound());
}
TipoMaterial = _tipoMaterialData.GetById(id);
if (TipoMaterial == null)
{
return(NotFound());
}
return(Page());
}
public static Figuras lerRetangulo()
{
try
{
//Retangulo Largura e Altura >> 1 = L10.0 A5.0 >> 3 = L4.0 A2.0
Console.WriteLine("Selecionado Retangulo: ");
Console.Write("Largura: ");
double largura = double.Parse(Console.ReadLine());
Console.Write("altura: ");
double altura = double.Parse(Console.ReadLine());
Console.Write("Cor: ");
Cor cor = (Cor)int.Parse(Console.ReadLine());
Console.Write("Mes de Construcao: ");
MesEnum mes = (MesEnum)int.Parse(Console.ReadLine());
Console.Write("Informa Material? (s/n): ");
char chcor = char.Parse(Console.ReadLine());
if (chcor == 's')
{
Console.Write("Material: ");
TipoMaterial material = (TipoMaterial)int.Parse(Console.ReadLine());
//quebra de linha.
Console.WriteLine();
//instanciando um objeto abstrato figura como um retangulo, usando polimorfismo.
//instanciando o objeto com material.
return(new Retangulos(largura, altura, cor, mes, material));
}
else
{
//quebra de linha.
Console.WriteLine();
//instanciando um objeto abstrato figura como um retangulo, usando polimorfismo.
//adicionando o objeto Retangulo na lista de objetos da superclasse Figuras, podendo ser triangulos ou retangulos oq caracteriza polimorfismo.
return(new Retangulos(largura, altura, cor, mes));
}
}
catch (Exception e)
{
throw new OperacaoException(e.ToString());
}
}
private void Modificar(TipoMaterial tipoMaterialInfo)
{
try
{
lblmensaje.Text = "";
tipoMaterialInfo.TMat_Nombre = txtnombreMat.Text;
TipoMaterialLogica.Modify(tipoMaterialInfo);
lblmensaje.Visible = true;
lblmensaje.Text = "Datos Actualizados </br>";
Regresar();
}
catch (Exception)
{
lblmensaje.Visible = true;
lblmensaje.Text = "Datos no Actualizados </br>";
}
}
public static Triangulos lerTriangulo()
{
try
{
//triangulo lados A, B e C. >> 2 = LA3.0 LB4.0 LC5.0
Console.WriteLine("Selecionado Triangulo: ");
Console.Write("lado a: ");
double A = double.Parse(Console.ReadLine());
Console.Write("Lado b: ");
double B = double.Parse(Console.ReadLine());
Console.Write("lado c: ");
double C = double.Parse(Console.ReadLine());
Console.Write("Cor: ");
Cor cor = (Cor)int.Parse(Console.ReadLine());
Console.Write("Mes Construcao: ");
MesEnum mes = (MesEnum)int.Parse(Console.ReadLine());
Console.Write("Informa material? (s/n) ");
char chMat = char.Parse(Console.ReadLine());
if (chMat == 's')
{
Console.Write("Material: ");
TipoMaterial material = (TipoMaterial)int.Parse(Console.ReadLine());
Console.WriteLine();
//Adicionando o triangulo com material na lista de abstract class ou superclasse, que é a Figuras.
return(new Triangulos(A, B, C, cor, mes, material));
}
else
{
Console.WriteLine();
//instanciando a superclasse Figuras como um objeto Triangulo utilizando polimorfismo.
return(new Triangulos(A, B, C, cor, mes));
}
}
catch (Exception e)
{
throw new OperacaoException(e.ToString());
}
}
public async Task <IActionResult> Update(TipoMaterial tipoMaterial)
{
try
{
if (tipoMaterial == null)
{
return(BadRequest("Entrada nula"));
}
var putTipoMaterial = await _tipoMaterialBusiness.Update(tipoMaterial);
return(CreatedAtRoute("GetByIdTipoMaterial", new { id = putTipoMaterial.Id }));
}
catch (Exception ex)
{
return(BadRequest($"{ex.Message}"));
}
}
public async Task <IActionResult> Create([FromBody] TipoMaterial tipoMaterial)
{
try
{
if (!ModelState.IsValid || tipoMaterial == null)
{
return(BadRequest(ModelState));
}
var newtipomaterial = await _tipoMaterialBusiness.Create(tipoMaterial);
return(CreatedAtRoute("GetByIdTipoMaterial", new { id = newtipomaterial.Id }));
}
catch (Exception ex)
{
return(BadRequest($"{ex.Message}"));
}
}
