public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var fechaHora = DateTime.Now;
ENTRADA ingreso = new ENTRADA
{
ID_PROVEEDOR = model.ID_PROVEEDOR,
ID_USUARIO = model.ID_USUARIO,
TIPO_COMPROBANTE = model.TIPO_COMPROBANTE,
SERIE_COMPROBANTE = model.SERIE_COMPROBANTE,
NUM_COMPROBANTE = model.NUM_COMPROBANTE,
FECHA_HORA = fechaHora,
IMPUESTO = model.IMPUESTO,
TOTAL = model.TOTAL,
ESTADO = "Aceptado"
};
try
{
_context.Entrada.Add(ingreso);
await _context.SaveChangesAsync();
var id = ingreso.ID_ENTRADA;
foreach (var det in model.detalles)
{
DETALLE_ENTRADA detalle = new DETALLE_ENTRADA
{
ID_INGRESO = id,
ID_ARTICULO = det.ID_ARTICULO,
CANTIDAD = det.CANTIDAD,
PRECIO = det.PRECIO
};
_context.detalle.Add(detalle);
}
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var fechaHora = DateTime.Now;
Ingreso ingreso = new Ingreso
{
idproveedor = model.idproveedor,
idusuario = model.idusuario,
tipo_comprobante = model.tipo_comprobante,
num_comprobante = model.num_comprobante,
serie_comprobante = model.serie_comprobante,
fecha_hora = fechaHora,
impuesto = model.impuesto,
total = model.total,
estado = "Aceptado"
};
try
{
_context.Ingresos.Add(ingreso);
await _context.SaveChangesAsync();
var id = ingreso.idingreso;
foreach (var det in model.detalles)
{
DetalleIngreso detalle = new DetalleIngreso
{
idingreso = id,
idarticulo = det.idarticulo,
cantidad = det.cantidad,
precio = det.precio
};
_context.DetallesIngresos.Add(detalle);
}
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest(ex));
}
return(Ok());
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Venta venta = new Venta
{
idcliente = model.idcliente,
idusuario = model.idusuario,
dias = model.dias,
procen_interes = model.procen_interes,
intereses = model.intereses,
total_venta = model.total_venta,
total_deuda = model.total_deuda,
tipo_interes = model.tipo_interes,
estado = "Aceptado"
};
try
{
_context.Ventas.Add(venta);
await _context.SaveChangesAsync();
var id = venta.idventa;
foreach (var det in model.detalles)
{
DetalleVenta detalle = new DetalleVenta
{
idventa = id,
idarticulo = det.idarticulo,
cantidad = det.cantidad,
precio = det.precio,
descuento = det.descuento
};
_context.DetallesVentas.Add(detalle);
}
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var fechaHora = DateTime.Now;
Venta venta = new Venta
{
idcliente = model.idcliente,
idusuario = model.idusuario,
tipo_comprobante = model.tipo_comprobante,
serie_comprobante = model.serie_comprobante,
num_comprobante = model.num_comprobante,
fecha_hora = fechaHora,
impuesto = model.impuesto,
total = model.total,
estado = "Aceptado"
};
try
{
_context.Ventas.Add(venta);
await _context.SaveChangesAsync();
var id = venta.idventa;
foreach (var det in model.detalles)
{
DetalleVenta detalle = new DetalleVenta
{
idventa = id,
idarticulo = det.idarticulo,
cantidad = det.cantidad,
precio = det.precio,
descuento = det.descuento
};
_context.DetallesVentas.Add(detalle);
}
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public async Task <ActionResult <ClienteViewModel> > Crear([FromBody] CrearViewModel model)
{
if (model == null)
{
return(this.BadRequest());
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var fecha = DateTime.Now;
this._passwordHelper.CrearPasswordHash(model.Password, out byte[] passwordHash);
var cliente = new Cliente
{
Email = model.Email.ToUpperInvariant().Trim(),
PasswordHash = passwordHash,
FechaNac = fecha,
CreatedAt = fecha,
UpdatedAt = fecha,
};
await this._context.Clientes.AddAsync(cliente).ConfigureAwait(false);
try
{
await this._context.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateConcurrencyException)
{
return(this.BadRequest("Hubo un error al guardar sus datos."));
}
var clienteModel = new ClienteViewModel
{
Id = cliente.Id,
Email = cliente.Email,
FechaNac = cliente.FechaNac,
CreatedAt = cliente.CreatedAt,
UpdatedAt = cliente.UpdatedAt,
};
return(this.CreatedAtAction("Mostrar", new { id = cliente.Id }, clienteModel));
}
public async Task <bool> Crear(CrearViewModel model)
{
await this.AgregarToken().ConfigureAwait(false);
var modelJson =
new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json");
var response = await this._httpClient.PostAsync($"crear", modelJson).ConfigureAwait(false);
modelJson.Dispose();
if (response.StatusCode == HttpStatusCode.Created)
{
return(true);
}
return(false);
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var CreateON = DateTime.Now;
VPS vPS = new VPS
{
idclient = model.idclient,
vmname = model.vmname,
vm_uuid = model.vm_uuid,
vcpus = model.vcpus,
ram = model.ram,
hdisk = model.hdisk,
bandw = model.bandw,
idnw = model.idnw,
idos = model.idos,
idversion = model.idversion,
idsql = model.idsql,
idsqlversion = model.idsqlversion,
internal_ip = model.internal_ip,
external_ip = model.external_ip,
createon = CreateON,
idusuario = model.idusuario,
dnsname = model.dnsname,
idvmtype = model.idvmtype,
idpool = model.idpool,
notes = model.notes,
rmtaccesssal = model.rmtaccesssal,
estado = true
};
try
{
_context.VPSs.Add(vPS);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public ActionResult Crear(CrearViewModel model)
{
using (PrimeraExpoContext db = new PrimeraExpoContext())
{
var Persona = db.Personas.SingleOrDefault(persona => persona.PersonaId == model.PersonaId);
var Factura = new Factura
{
Descripcion = model.Descripcion,
Precio = model.Precio,
Persona = Persona
};
db.Facturas.Add(Factura);
db.SaveChanges();
ViewBag.Confirmacion = "Factura creada";
return(View());
}
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
// Valida los data annotation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var email = model.email.ToLower();
if (await _context.Usuarios.AnyAsync(u => u.email == email))
{
return(BadRequest("El Email ya existe"));
}
// encode del password
CrearPasswordHash(model.password, out byte[] passwordHash, out byte[] passwordSalt);
Usuario usuario = new Usuario
{
idrol = model.idrol,
nombre = model.nombre,
tipo_documento = model.tipo_documento,
num_documento = model.num_documento,
direccion = model.direccion,
telefono = model.telefono,
email = model.email.ToLower(),
password_hash = passwordHash,
password_salt = passwordSalt,
condicion = true
};
_context.Usuarios.Add(usuario);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var email = model.email.ToLower();
if (await _context.Personas.AnyAsync(p => p.email == email))
{
return(BadRequest("El email ya existe"));
}
if (await _context.Personas.AnyAsync(p => p.num_documento == model.num_documento) && await _context.Personas.AnyAsync(p => p.tipo_documento == model.tipo_documento))
{
return(BadRequest("Ya hay un registro con el mismo tipo de identidad y número de documento " + model.tipo_documento + "-" + model.num_documento));
}
Persona persona = new Persona
{
//idusuario = 0,
tipo_persona = model.tipo_persona,
nombre = model.nombre,
tipo_documento = model.tipo_documento,
num_documento = model.num_documento,
direccion = model.direccion,
telefono = model.telefono,
email = model.email.ToLower()
};
_context.Personas.Add(persona);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public async Task <ActionResult <PagoViewModel> > Crear([FromForm] CrearViewModel model)
{
if (model == null)
{
return(this.BadRequest());
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var fecha = DateTime.Now;
var pago = new Pago
{
OrdenId = model.OrdenId,
Monto = model.Monto,
CreatedAt = fecha,
UpdatedAt = fecha,
};
await this._context.Pagos.AddAsync(pago).ConfigureAwait(false);
try
{
await this._context.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateConcurrencyException)
{
return(this.BadRequest("Hubo un error al guardar sus datos."));
}
var pagoModel = new PagoViewModel
{
Id = pago.Id,
OrdenId = pago.OrdenId,
Monto = pago.Monto,
Estado = pago.Estado,
CreatedAt = pago.CreatedAt,
UpdatedAt = pago.UpdatedAt,
};
return(this.CreatedAtAction("Mostrar", new { id = pago.Id }, pagoModel));
}
public IActionResult Crear(CrearViewModel crearViewModel)
{
if (!ModelState.IsValid)
{
return(View(crearViewModel));
}
if (!_context.Cursos.Any(c => c.Nombre == crearViewModel.Nombre))
{
_context.Cursos.Add(new Curso()
{
Nombre = crearViewModel.Nombre, Codigo = crearViewModel.Codigo, CarreraId = crearViewModel.CarreraId
});
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View());
}
public IActionResult Crear(CrearViewModel crearViewModel)
{
if (!ModelState.IsValid)
{
return(View(crearViewModel));
}
if (!_context.Becas.Any(c => c.Nombre == crearViewModel.Nombre))
{
_context.Becas.Add(new Beca()
{
Nombre = crearViewModel.Nombre, Porcentaje = crearViewModel.Porcentaje
});
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View());
}
public IActionResult Crear(CrearViewModel crearViewModel)
{
if (!ModelState.IsValid)
{
return(View(crearViewModel));
}
if (!_context.Grupos.Any(c => c.NumeroGrupo == crearViewModel.NumeroGrupo))
{
_context.Grupos.Add(new Grupos()
{
NumeroGrupo = crearViewModel.NumeroGrupo, Horario = crearViewModel.Horario, CursoId = crearViewModel.CursoId
});
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View());
}
public IActionResult Create()
{
CrearViewModel modelo = new CrearViewModel();
var carrera = (from c in _context.Carreras select new Model.Carreras {
IdCarrera = c.IdCarrera, NombreCarrera = c.NombreCarrera
}).ToList();
modelo.Carreras = carrera;
var cursos = (from c in _context.Cursos select new Model.Cursos {
IdCurso = c.IdCurso, Descripcion = c.Descripcion
}).ToList();
modelo.Cursos = cursos;
//string id = "Carrera0002";
//modelo.CarreraId = id;
return(View(modelo));
}
public IActionResult Create(CrearViewModel modelo)
{
if (ModelState.IsValid)
{
//var carrera = (from c in _context.Carreras select c.IdCarrera);
////se ocupa generar una tabla secuencias donde se almacenan los ids de las entidades
//string id = "Carrera02";
var db = (from c in _context.Secuencias where c.Descripcion == "Carreras" select c.Value).ToList();
int Id = 0;
foreach (var item in db)
{
Id = int.Parse(item.ToString());
}
var index = (from c in _context.Secuencias where c.Descripcion == "Carreras" select new { c.Value, c.Descripcion }).FirstOrDefault();
//index.Value = index.Value + 1;
//FINALIZA
string id = "Carrera" + Id;
_context.Carreras.Add(new Model.Carreras
{
NombreCarrera = modelo.NombreCarrera,
Cursos = null,
IdCarrera = id,
IdPersona = modelo.PersonaAsignada
});
_context.SaveChanges();
return(RedirectToAction("Index", new Microsoft.AspNetCore.Routing.RouteValueDictionary(
new { controller = "Home", action = "Index" })));
}
return(View());
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)//permite realizar validaciones segun los data annotation
{
return(BadRequest(ModelState));
}
//Validar email no repetido
var email = model.email.ToLower(); //convierto a mayuscula
if (await baseDatos.Usuarios.AnyAsync(u => u.email == email)) //u.email obtengo el email del context
{
return(BadRequest("El email ya existe"));
}
//llamo a metodo para crear las claves
CrearPasswordHash(model.password, out byte[] passwordHash, out byte[] passwordSalt);;
Usuario usuario = new Usuario //entidad como tal Usuarios
{
idrol = model.idrol,
nombre = model.nombre, //indico a mi objeto categoria que el nombre va a ser igual al del modelo
tipo_documento = model.tipo_documento,
num_documento = model.num_documento,
direccion = model.direccion,
telefono = model.telefono,
email = model.email,
password_hash = passwordHash,//password encriptado
password_salt = passwordSalt,
condicion = true
};
baseDatos.Usuarios.Add(usuario);// me agregue esa Usuario
try
{
await baseDatos.SaveChangesAsync();//guarda los cambios
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public IActionResult Create()
{
CrearViewModel modelo = new CrearViewModel();
//se debe crear un profesor en la base
var cursos = (from c in _context.Cursos where c.IdPersona.Equals("Persona01") select new Model.Cursos {
IdCurso = c.IdCurso, Descripcion = c.Descripcion
}).ToList();
//var grupos = (from gru in _context.Grupos
// join cur in _context.Cursos on gru.IdCurso equals cur.IdCurso
// where cur.IdCurso == gru.IdCurso
// select new Model.Grupos
// { IdGrupo = gru.IdGrupo, Descripcion = gru.Descripcion });
////es una tarea asincrona, ya que carga un segundo combobox
modelo.Cursos = cursos;
return(View(modelo));
}
public IActionResult Create()
{
CrearViewModel modelo = new CrearViewModel();
var tipos = (from c in _context.TipoPersona select c).ToList();
var carne = (from ca in _context.Secuencias where ca.Descripcion == "Carnet" select ca).ToList();
var carreras = (from c in _context.Carreras select c).ToList();
var carne_valor = 0;
foreach (var item in carne)
{
carne_valor = int.Parse(item.Value.ToString());
}
modelo.Carnet = "2018" + carne_valor;
modelo.Tipos = tipos;
//modelo.Carreras = carreras;
return(View(modelo));
}
public IActionResult Create(CrearViewModel modelo)
{
if (ModelState.IsValid)
{
var cursos = (from c in _context.Cursos select c.IdCarrera);
_context.Rubros.Add(new Model.Rubros
{
//Id = modelo.CursoSeleccionado,
NombreRubro = modelo.NombreRubro,
Porcentaje = modelo.Porcentaje,
IdRubro = "Rubro01",
});
_context.SaveChanges();
return(RedirectToAction("Index", new Microsoft.AspNetCore.Routing.RouteValueDictionary(
new { controller = "Home", action = "Index" })));
}
return(View());
}
public ActionResult Crear()
{
var model = new CrearViewModel();
using (PrimeraExpoContext db = new PrimeraExpoContext())
{
var lista = new List <SelectListItem>();
var personas = db.Personas.ToList();
foreach (var persona in personas)
{
lista.Add(new SelectListItem()
{
Value = persona.PersonaId.ToString(), Text = persona.Nombre + " " + persona.Apellidos
});
}
model.ListaItems = lista;
}
return(View(model));
}
public IActionResult Create(CrearViewModel modelo)
{
if (ModelState.IsValid)
{
var cursos = (from c in _context.Cursos select c.IdCurso);
_context.Cursos.Add(new Model.Cursos
{
IdCurso = modelo.CursoSeleccionado,
Grupos = modelo.Grupos,
IdPersona = modelo.Persona.ToString(),
});
_context.SaveChanges();
return(RedirectToAction("Index", new Microsoft.AspNetCore.Routing.RouteValueDictionary(
new { controller = "Home", action = "Index" })));
}
return(View());
}
public async Task <ActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var fechaHora = DateTime.Now;
OC oc = new OC
{
idProveedor = model.idProveedor,
precio = model.precio,
idCotizacion = model.idCotizacion,
fechaRegistro = fechaHora
};
try
{
_context.OCs.Add(oc);
await _context.SaveChangesAsync();
var id = oc.idOc;
foreach (var det in model.detalles)
{
Detalles_OC detalle = new Detalles_OC
{
idOc = id,
idProducto = det.idProducto,
cantidad = det.cantidad
};
_context.Detalles_OCs.Add(detalle);
}
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest(ex));
}
return(Ok());
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var email = model.Email.ToLower();
if (await _context.Usuarios.AnyAsync(u => u.Email == email))
{
return(BadRequest("Ya hay un usuario registrado con el email " + email));
}
CrearPasswordHash(model.Password, out byte[] passwordHash, out byte[] passwordSalt);
Usuario usuario = new Usuario
{
IDRol = model.IDRol,
Nombre = model.Nombre,
TipoDocumento = model.TipoDocumento,
NumeroDocumento = model.NumeroDocumento,
Direccion = model.Direccion,
Telefono = model.Telefono,
Email = model.Email.ToLower(),
PasswordHash = passwordHash,
PasswordSalt = passwordSalt,
Condicion = true
};
_context.Usuarios.Add(usuario);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var email = model.email.ToLower();
if (await _context.Usuarios.AnyAsync(u => u.EMAIL == email))
{
return(BadRequest("El email ya existe"));
}
CrearPasswordHash(model.password, out byte[] passwordHash, out byte[] passwordSalt);
USUARIO usuario = new USUARIO
{
ID_ROL = model.idrol,
NOMBRE = model.nombre,
TIPO_OCUMENTO = model.tipo_documento,
NUM_DOCUMENTO = model.num_documento,
DIRECCION = model.direccion,
TELEFONO = model.telefono,
EMAIL = model.email.ToLower(),
PASSWORD_HAS = passwordHash,
PASSWORD_SALT = passwordSalt,
CONDICION = true
};
_context.Usuarios.Add(usuario);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public async Task <ActionResult <Usuario> > Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
BadRequest(ModelState);
}
var email = model.email.ToLower();
if (await _context.Usuarios.AnyAsync(u => u.email == email))
{
return(BadRequest("Email Ya existente."));
}
CrearPasswordHash(model.password, out byte[] passwordHash, out byte[] passwordSalt);
Usuario usuario = new Usuario
{
idrol = model.idrol,
nombre = model.nombre,
tipo_documento = model.tipo_documento,
num_documento = model.num_documento,
direccion = model.direccion,
email = model.email.ToLower(),
telefono = model.telefono,
condicion = true,
password_hash = passwordHash,
password_salt = passwordSalt
};
_context.Usuarios.Add(usuario);
try
{
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(BadRequest());
}
return(Ok());
//return CreatedAtAction("GetCategoria", new { id = categoria.idcategoria }, categoria);
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var email = model.emailusuario.ToLower();
if (await _context.Usuarios.AnyAsync(u => u.emailusuario == email))
{
return(BadRequest("El email ya existe"));
}
CrearPasswordHash(model.password, out byte[] passwordHash, out byte[] passwordSalt);
Usuario usuario = new Usuario
{
rolidrol = model.idrol,
areaidarea = model.idarea,
puestoidpuesto = model.idpuesto,
nomusuario = model.nomusuario,
emailusuario = model.emailusuario.ToLower(),
user = model.user,
password_hash = passwordHash,
password_salt = passwordSalt,
condicion = true
};
_context.Usuarios.Add(usuario);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public ActionResult Crear(CrearViewModel crearVM)
{
if (ModelState.IsValid)
{
try
{
crearVM.completarAdministrador();
administradorBL.registrar(crearVM.administrador);
return(RedirectToAction("ListaAdministradores"));
}
catch (ProyectoException ex)
{
ViewBag.Mensaje = ex.Message;
return(View("~/Views/Shared/_Mensajes.cshtml"));
}
}
else
{
return(View(crearVM));
}
}
public async Task <IActionResult> Crear([FromBody] CrearViewModel model)
{
// Valida los data annotation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var email = model.email.ToLower();
if (await _context.Personas.AnyAsync(p => p.email == email))
{
return(BadRequest("El Email ya existe"));
}
Persona persona = new Persona
{
tipo_persona = model.tipo_persona,
nombre = model.nombre,
tipo_documento = model.tipo_documento,
num_documento = model.num_documento,
direccion = model.direccion,
telefono = model.telefono,
email = model.email.ToLower()
};
_context.Personas.Add(persona);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
public async Task <ActionResult> RegistrarUsuario([FromBody] CrearViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var revisarUsuario = model.Usuario.ToLower();
if (await _context.Usuarios.AnyAsync(u => u.Usuario == revisarUsuario))
{
return(BadRequest("El usuario ya existe."));
}
EncriptarContrasena(model.Contrasena, out byte[] contrasenaHash, out byte[] contrasenaLlave);
Usuarios usuario = new Usuarios
{
Correo = model.Correo.ToLower(),
Usuario = model.Usuario,
Contrasena = contrasenaHash,
Llave = contrasenaLlave,
Estatus = true,
Sexo = model.Sexo,
FechaCreacion = DateTime.Now
};
_context.Usuarios.Add(usuario);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok(new { codigo = 200 }));
}
