//ACTUALIZAR
public string actualizarUsuariosTienda(UsuarioTienda usu_tienda)
{
string mensaje = "";
try
{
if (usu_tienda.ID_USU_TIENDA.Equals(""))
{
mensaje = "El codigo del usuario Tienda no es valido";
}
//CODIGO DEL USUARIO TIENDA VALIDO
else
{
//listar los usuarios tienda y filtrar el codigo del usuario tienda
var existeUsuarioTienda = usuarioDatos.ListarUsuariosTienda().
Any(x => x.ID_USU_TIENDA.Equals(usu_tienda.ID_USU_TIENDA));
if (existeUsuarioTienda)
{
//La validacion de los campos
usu_tienda.Validar();
usuarioDatos.actualizarUsuarioTienda(usu_tienda);
mensaje = "Usuario Tienda Actualizado Correctamente";
}
else
{
mensaje = "El Usuario Tienda no existe";
}
}
}
catch (Exception ex)
{
mensaje = "No llego a actualizar el usuario tienda : " + ex.Message;
}
return(mensaje);
}
public string RegistroUsuarioTienda(UsuarioTienda usu_tienda)
{
string mensaje = "";
mensaje = negocios.registroUsuarioTienda(usu_tienda);
return(mensaje);
}
public string ActualizarUsuariosTienda(UsuarioTienda usu_tienda)
{
string mensaje = "";
mensaje = negocios.actualizarUsuariosTienda(usu_tienda);
return(mensaje);
}
public UsuarioTienda GetUsuarioTiendaById(string id)
{
var lista = negocios.ListarUsuariosTienda();
UsuarioTienda usuariotienda = lista.FirstOrDefault(x => x.ID_USU_TIENDA.Equals(id));
return(usuariotienda);
}
public async Task <IActionResult> Edit(int id, [Bind("IdUsuarioTienda,IdUsuario,IdTienda")] UsuarioTienda usuarioTienda)
{
if (id != usuarioTienda.IdUsuarioTienda)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(usuarioTienda);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuarioTiendaExists(usuarioTienda.IdUsuarioTienda))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdTienda"] = new SelectList(_context.Tiendas, "IdTienda", "DescripcionTienda", usuarioTienda.IdTienda);
ViewData["IdUsuario"] = new SelectList(_context.AspNetUsers, "Id", "Id", usuarioTienda.IdUsuario);
return(View(usuarioTienda));
}
public string EliminarUsuariosTienda(UsuarioTienda usu_tienda)
{
string mensaje = "";
mensaje = negocios.eliminarUsuariosTienda(usu_tienda.ID_USU_TIENDA);
return(mensaje);
}
public ActionResult EditarUsuario(int id)
{
if (Session["Rol"] == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
if (Session["TiendaId"] == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
int tiendaId = (int)Session["TiendaId"];
Tienda tienda = db.Tienda.Find(tiendaId);
List <UsuarioTienda> usuariosTienda = tienda.UsuariosTienda.ToList();
UsuarioTienda ustienda = usuariosTienda.Where(ut => ut.UsuarioId == id).FirstOrDefault();
if (ustienda == null)
{
return(HttpNotFound());
}
if (ustienda.Usuario == null)
{
return(HttpNotFound());
}
ustienda.Usuario.RolEnTienda = ustienda.RolTienda;
return(View(ustienda.Usuario));
}
//LISTAR
public List <UsuarioTienda> ListarUsuariosTienda()
{
List <UsuarioTienda> usuariostienda = null;
string listita = "USP_LISTAR_USUARIO_TIENDA";
SqlCommand comando = new SqlCommand(listita, conexion);
comando.CommandType = System.Data.CommandType.StoredProcedure;
conexion.Open();
SqlDataReader reader = comando.ExecuteReader();
if (reader.HasRows)
{
usuariostienda = new List <UsuarioTienda>();
while (reader.Read())
{
UsuarioTienda usuariotienda = new UsuarioTienda();
usuariotienda.ID_USU_TIENDA = reader["ID_USU_TIENDA"].ToString();
usuariotienda.RAZON_SOCIAL = reader["RAZON_SOCIAL"].ToString();
usuariotienda.REP_LEGAL = reader["REP_LEGAL"].ToString();
usuariotienda.CORREO_UST = reader["CORREO_UST"].ToString();
usuariotienda.DIRECCION = reader["DIRECCION"].ToString();
usuariotienda.TELEFONO = reader["TELEFONO"].ToString();
usuariotienda.FECHA_CONSTITU = reader["FECHA_CONSTITU"].ToString();
usuariotienda.RUC = reader["RUC"].ToString();
usuariotienda.CONTRA_USU_TIENDA = reader["CONTRA_USU_TIENDA"].ToString();
usuariostienda.Add(usuariotienda);
}
}
conexion.Close();
return(usuariostienda);
}
public ActionResult EditarUsuario(Usuario model, int TiendaId)
{
if (model.NombreUsuario != null)
{
model.NombreUsuario = model.NombreUsuario.ToUpper();
}
if (model.Email != null)
{
model.Email = model.Email.ToUpper();
}
Usuario repetido = db.Usuarios.Where(u => u.NombreUsuario == model.NombreUsuario && u.Id != model.Id).FirstOrDefault();
Usuario mailRepetido = db.Usuarios.Where(u => u.Email == model.Email && u.Id != model.Id).FirstOrDefault();
ModelState.Clear();
model.Password = "******"; //para evitar que el ModelState falle por "ser obligatorio"
if (repetido != null || mailRepetido != null)
{
if (repetido != null)
{
ModelState.AddModelError("NombreUsuario", "El nombre de usuario ya se encuentra en uso");
}
if (mailRepetido != null)
{
ModelState.AddModelError("Email", "El email ya se encuentra en uso");
}
}
TryValidateModel(model);
if (ModelState.IsValid == false)
{
List <Tienda> tiendas = db.Tienda.ToList();
UsuarioTienda ust = db.UsuariosTienda.Where(ut => ut.Usuario.Id == model.Id).FirstOrDefault();
tiendas.Add(new Tienda()
{
Id = 0, Nombre = "No asignar"
});
tiendas.Reverse();
if (ust != null)
{
ViewBag.TiendaId = new SelectList(tiendas, "Id", "Nombre", ust.Tienda.Id);
}
else
{
ViewBag.TiendaId = new SelectList(tiendas, "Id", "Nombre");
}
return(View(model));
}
//Se supone que deberia mandar el RolEnTienda que escogí en la vista
Usuario.EditarUsuario(db, model, TiendaId, model.RolEnTienda);
return(RedirectToAction("ListaUsuarios"));
}
public async Task <IActionResult> Create([Bind("IdUsuarioTienda,IdUsuario,IdTienda")] UsuarioTienda usuarioTienda)
{
if (ModelState.IsValid)
{
_context.Add(usuarioTienda);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["IdTienda"] = new SelectList(_context.Tiendas, "IdTienda", "DescripcionTienda", usuarioTienda.IdTienda);
ViewData["IdUsuario"] = new SelectList(_context.AspNetUsers, "Id", "Id", usuarioTienda.IdUsuario);
return(View(usuarioTienda));
}
//ACTUALIZAR
public void actualizarUsuarioTienda(UsuarioTienda usu_tienda)
{
conexion.Open();
string sqlStatement = "USP_ACTUALIZAR_USUARIO_TIENDA";
SqlCommand comandos = new SqlCommand(sqlStatement, conexion);
comandos.CommandType = System.Data.CommandType.StoredProcedure;
comandos.Parameters.AddWithValue("@ID_USU_TIENDA", usu_tienda.ID_USU_TIENDA);
comandos.Parameters.AddWithValue("@REPRESENTANTE", usu_tienda.REP_LEGAL);
comandos.Parameters.AddWithValue("@CORREO_ELECTRONICO", usu_tienda.CORREO_UST);
comandos.Parameters.AddWithValue("@DIRECCION", usu_tienda.DIRECCION);
comandos.Parameters.AddWithValue("@TELEFONO", usu_tienda.TELEFONO);
comandos.ExecuteNonQuery();
conexion.Close();
}
//CRUDS DEL USUARIO Tienda
//REGISTRO
public string registroUsuarioTienda(UsuarioTienda usu_tienda)
{
string mensaje = "";
try
{
//La validacion de los campos
usu_tienda.Validar();
usuarioDatos.RegistroUsuarioTienda(usu_tienda);
mensaje = "Usuario Tienda Registrado Correctamente";
}
catch (Exception ex)
{
mensaje = "No llego a registrar el usuario tienda : " + ex.Message;
}
return(mensaje);
}
public ActionResult CrearMecanicoJS(HorarioTemporalTrabajadorList model)
{
if (Session["Rol"] == null)
{
return(Json(new
{
exito = false,
mensaje = "La sesión ha terminado."
}, JsonRequestBehavior.AllowGet));
}
if (Session["TiendaId"] == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
int idTienda = (int)Session["TiendaId"];
Tienda tienda = db.Tienda.Where(t => t.Id == idTienda).FirstOrDefault();
UsuarioTienda usuarioTienda = tienda.UsuariosTienda.Where(ut => ut.Id == model.UsuarioTiendaId).FirstOrDefault();
UsuarioTienda usuarioTiendaMecanico = UsuarioTiendaMecanico.CrearMecanico(db, usuarioTienda);
HorarioTrabajador.CrearHorarioPorDia(db, idTienda, usuarioTiendaMecanico.Id, HorarioTrabajador.DiaHorarioTrabajador.Lunes,
model.LunesList[0].Hora, model.LunesList[1].Hora, model.LunesList[2].Hora, model.LunesList[3].Hora, true);
HorarioTrabajador.CrearHorarioPorDia(db, idTienda, usuarioTiendaMecanico.Id, HorarioTrabajador.DiaHorarioTrabajador.Martes,
model.MartesList[0].Hora, model.MartesList[1].Hora, model.MartesList[2].Hora, model.MartesList[3].Hora, true);
HorarioTrabajador.CrearHorarioPorDia(db, idTienda, usuarioTiendaMecanico.Id, HorarioTrabajador.DiaHorarioTrabajador.Miercoles,
model.MiercolesList[0].Hora, model.MiercolesList[1].Hora, model.MiercolesList[2].Hora, model.MiercolesList[3].Hora, true);
HorarioTrabajador.CrearHorarioPorDia(db, idTienda, usuarioTiendaMecanico.Id, HorarioTrabajador.DiaHorarioTrabajador.Jueves,
model.JuevesList[0].Hora, model.JuevesList[1].Hora, model.JuevesList[2].Hora, model.JuevesList[3].Hora, true);
HorarioTrabajador.CrearHorarioPorDia(db, idTienda, usuarioTiendaMecanico.Id, HorarioTrabajador.DiaHorarioTrabajador.Viernes,
model.ViernesList[0].Hora, model.ViernesList[1].Hora, model.ViernesList[2].Hora, model.ViernesList[3].Hora, true);
HorarioTrabajador.CrearHorarioPorDia(db, idTienda, usuarioTiendaMecanico.Id, HorarioTrabajador.DiaHorarioTrabajador.Sabado,
model.SabadoList[0].Hora, model.SabadoList[1].Hora, model.SabadoList[2].Hora, model.SabadoList[3].Hora, true);
HorarioTrabajador.CrearHorarioPorDia(db, idTienda, usuarioTiendaMecanico.Id, HorarioTrabajador.DiaHorarioTrabajador.Domingo,
model.DomingoList[0].Hora, model.DomingoList[1].Hora, model.DomingoList[2].Hora, model.DomingoList[3].Hora, true);
return(Json(new { exito = true, id = model.UsuarioTiendaId }));
}
public ActionResult _CrearTienda(Tienda model)
{
ModelState.Clear();
if (model.Nombre == null || model.Nombre == "")
{
ModelState.AddModelError("Nombre", "El campo nombre es obligatorio");
}
else
{
Tienda repetido = db.Tienda.Where(u => u.Nombre.ToUpper() == model.Nombre.ToUpper()).FirstOrDefault();
if (repetido != null)
{
ModelState.AddModelError("Nombre", "El nombre de Tienda ya se encuentra en uso");
}
}
TryValidateModel(model);
if (ModelState.IsValid == false)
{
return(View(model));
}
if (Session["Id"] == null)
{
return(RedirectToAction("Registrate", "Login", new { nombreTienda = model.Nombre }));
}
else
{
int userId = (int)Session["Id"];
Tienda tienda = Models.Tienda.CrearNuevaTienda(db, model);
UsuarioTienda usTienda = UsuarioTienda.CrearUsuarioTienda(db, userId, tienda);
if (usTienda != null)
{
Session["TiendaId"] = usTienda.Tienda.Id;
Session["TiendaNombre"] = usTienda.Tienda.Nombre;
}
return(RedirectToAction("Index", "TiendaUser", new { id = tienda.Id }));
}
}
public ActionResult CrearMecanico(int?idUsuarioTienda)
{
if (idUsuarioTienda == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
if (Session["TiendaId"] == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
int idTienda = (int)Session["TiendaId"];
Tienda tienda = db.Tienda.Where(ut => ut.Id == idTienda).FirstOrDefault();
UsuarioTienda usuarioTienda = tienda.UsuariosTienda.Where(ut => ut.Id == idUsuarioTienda).FirstOrDefault();
return(View(usuarioTienda));
}
//CRUDS DEL USUARIO TIENDA
//REGISTRO
public void RegistroUsuarioTienda(UsuarioTienda usu_tienda)
{
conexion.Open();
string sqlStatement = "USP_REGISTRO_USUARIO_TIENDA";
SqlCommand comandos = new SqlCommand(sqlStatement, conexion);
comandos.CommandType = System.Data.CommandType.StoredProcedure;
comandos.Parameters.AddWithValue("@ID_USU_TIENDA", usu_tienda.ID_USU_TIENDA);
comandos.Parameters.AddWithValue("@RAZON_SOCIAL", usu_tienda.RAZON_SOCIAL);
comandos.Parameters.AddWithValue("@REPRESENTANTE", usu_tienda.REP_LEGAL);
comandos.Parameters.AddWithValue("@CORREO_ELECTRONICO", usu_tienda.CORREO_UST);
comandos.Parameters.AddWithValue("@DIRECCION", usu_tienda.DIRECCION);
comandos.Parameters.AddWithValue("@TELEFONO", usu_tienda.TELEFONO);
comandos.Parameters.AddWithValue("@FECHA_CONSTI", usu_tienda.FECHA_CONSTITU);
comandos.Parameters.AddWithValue("@RUC", usu_tienda.RUC);
comandos.Parameters.AddWithValue("@CONTRASEÑA_TIENDA", usu_tienda.CONTRA_USU_TIENDA);
comandos.ExecuteNonQuery();
conexion.Close();
}
public ActionResult EditarUsuario(int id)
{
if (Session["Rol"] == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
int rolSession = (int)Session["Rol"];
if (rolSession != (int)Usuario.TipoUsuario.SuperAdmin)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
List <Tienda> tiendas = db.Tienda.ToList();
tiendas.Add(new Tienda()
{
Id = 0, Nombre = "No asignar"
});
tiendas.Reverse();
Usuario user = db.Usuarios.Find(id);
UsuarioTienda ust = null;
if (user.UsuarioTiendas.Count > 0)
{
ust = user.UsuarioTiendas.First();
user.RolEnTienda = ust.RolTienda;
ViewBag.TiendaId = new SelectList(tiendas, "Id", "Nombre", ust.Tienda.Id);
}
else
{
ViewBag.TiendaId = new SelectList(tiendas, "Id", "Nombre");
}
return(View(user));
}
public UsuarioDataDto GetDatosUsuario(String Dni, String Contrasena)
{
UsuarioAccesoDto usuario = ValidateLogin(Dni, Contrasena);
List <RolUsuario> rolesUsuario;
List <RolUsuarioDataDto> rolesUsuarioData;
TiendaDataDto tiendaData;
FamiliaDataDto familiaData;
UsuarioFamilia usuarioFamilia = _context.UsuarioFamilias.SingleOrDefault(x => x.Dni == Dni);
if (usuarioFamilia != null)
{
Familia familia = _context.Familias.Single(x => x.FamiliaId == usuarioFamilia.FamiliaId);
familiaData = _mapper.Map <FamiliaDataDto>(familia);
}
else
{
familiaData = null;
}
UsuarioTienda usuarioTienda = _context.UsuarioTiendas.SingleOrDefault(x => x.Dni == Dni);
if (usuarioTienda != null)
{
Tienda tienda = _context.Tiendas.Single(x => x.TiendaId == usuarioTienda.TiendaId);
tiendaData = _mapper.Map <TiendaDataDto>(tienda);
}
else
{
tiendaData = null;
}
rolesUsuario = _context.RolUsuarios.Where(x => x.Dni == Dni).OrderBy(x => x.RolPerfilId).ToList();
rolesUsuarioData = _mapper.Map <List <RolUsuarioDataDto> >(rolesUsuario);
Solicitud solicitud = _context.Solicitudes.SingleOrDefault(x => x.Dni == Dni);
return(new UsuarioDataDto()
{
usuario = usuario, familia = familiaData, tienda = tiendaData, roles = rolesUsuarioData, solicitud = solicitud
});
}
public TiendaUsuarioDto PostUsuarioInTienda(int idTienda, string dni)
{
UsuarioTienda NewUsuarioTienda = null;
Usuario usuario = _context.Usuarios.SingleOrDefault(x => x.Dni == dni);
if (usuario != null)
{
int cantidadUsuarios = _context.UsuarioTiendas.Where(x => x.TiendaId == idTienda).Count();
Tienda tienda = _context.Tiendas.SingleOrDefault(x => x.TiendaId == idTienda);
if (cantidadUsuarios + 1 <= tienda.Limite)
{
NewUsuarioTienda = new UsuarioTienda()
{
Dni = dni,
TiendaId = idTienda
};
_context.Add(NewUsuarioTienda);
var entry = new RolUsuario
{
Dni = dni,
RolPerfilId = 4,
};
_context.RolUsuarios.Add(entry);
_context.SaveChanges();
return(new TiendaUsuarioDto()
{
Dni = dni, TiendaId = idTienda, Descripcion = tienda.Descripcion
});
}
else
{
throw new UserAddedShopExceedLimitException();
}
}
throw new UserAddedShopIncorrectException();
}
public ActionResult Tienda(int?id, int page = 1, int categoriaId = -1, string seccion = "producto", string search = "")
{
Tienda tienda = db.Tienda.Find(id);
if (tienda == null)
{
return(RedirectToAction("Index", "Home"));
}
IEnumerable <Producto> productosTienda = tienda.Productos;
IEnumerable <Servicio> serviciosTienda = tienda.Servicios;
TiendaHome tiendaHome = new TiendaHome();
tiendaHome.OrderByProductName = "";
tiendaHome.ViewProductEnumType = TiendaHome.ViewProductType.Grid;
tiendaHome.ViewTypeName = "Grid";
int productsPerPage = 12;
int start = (page - 1) * productsPerPage;
//Verificar si productos están en List o Grid
if (Session["ViewProductType"] != null)
{
tiendaHome.ViewProductEnumType = (TiendaHome.ViewProductType)Session["ViewProductType"];
if ((TiendaHome.ViewProductType)Session["ViewProductType"] == TiendaHome.ViewProductType.Grid)
{
tiendaHome.ViewTypeName = "Grid";
}
else if ((TiendaHome.ViewProductType)Session["ViewProductType"] == TiendaHome.ViewProductType.List)
{
tiendaHome.ViewTypeName = "List";
}
}
//ORDENAR PRODUCTOS Y SERVICIOS
if (Session["OrderByProduct"] != null)
{
Tuple <IEnumerable <Producto>, IEnumerable <Servicio>, string> tupleSort = TiendaHome.SortProduct(productosTienda, serviciosTienda, (TiendaHome.OrderByType)Session["OrderByProduct"]);
productosTienda = tupleSort.Item1;
serviciosTienda = tupleSort.Item2;
tiendaHome.OrderByProductName = tupleSort.Item3;
}
if (seccion.Equals("producto"))
{
//Realiza una busqueda
if (!search.Equals(""))
{
Tuple <List <Producto>, List <Servicio>, List <Tienda>, Boolean, Busqueda.BusquedaTipo, string> productosFiltrados = Busqueda.BuscarProductosPorCategoria(db, -1, search, seccion, true, tienda);
productosTienda = productosFiltrados.Item1;
}
//Categorias
ViewBag.Categorias = Busqueda.buscarCategoriasPorTienda(db, tienda.Productos, null, true);
if (categoriaId != -1)
{
productosTienda = productosTienda.Where(p => p.CategoriaId == categoriaId).ToList();
ViewBag.CategoriaFiltrada = db.Categorias.Find(categoriaId).NombreCategoria;
}
ViewBag.PageCount = Math.Ceiling(productosTienda.Count() / (double)productsPerPage);
productosTienda = productosTienda.Skip(start).Take(productsPerPage);
ViewBag.PaginatedProducts = productosTienda;
ViewBag.Seccion = seccion;
tiendaHome.Tienda = tienda;
tiendaHome.Productos = productosTienda;
}
else if (seccion.Equals("servicio"))
{
//Realiza una busqueda
if (!search.Equals(""))
{
Tuple <List <Producto>, List <Servicio>, List <Tienda>, Boolean, Busqueda.BusquedaTipo, string> serviciosFiltrados = Busqueda.BuscarProductosPorCategoria(db, -1, search, seccion, true, tienda);
serviciosTienda = serviciosFiltrados.Item2;
}
//Categorias
ViewBag.Categorias = Busqueda.buscarCategoriasPorTienda(db, null, tienda.Servicios, false);
if (categoriaId != -1)
{
serviciosTienda = serviciosTienda.Where(p => p.CategoriaId == categoriaId).ToList();
ViewBag.CategoriaFiltrada = db.Categorias.Find(categoriaId).NombreCategoria;
}
ViewBag.PageCount = Math.Ceiling(serviciosTienda.Count() / (double)productsPerPage);
serviciosTienda = serviciosTienda.Skip(start).Take(productsPerPage);
ViewBag.PaginatedProducts = serviciosTienda;
ViewBag.Seccion = seccion;
tiendaHome.Tienda = tienda;
tiendaHome.Servicios = serviciosTienda;
}
//SI LA TIENDA ESTÁ OCULTA, SOLO LA PUEDE VER EL ADMINISTRADOR.
if (tiendaHome.Tienda.EstadoTienda == Models.Tienda.Estado.Oculta)
{
if (Session["Id"] == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
int idUsuario = (int)Session["Id"];
UsuarioTienda existeUsuarioEnTienda = tiendaHome.Tienda.UsuariosTienda.Where(us => us.Usuario.Id == idUsuario).FirstOrDefault();
if (existeUsuarioEnTienda == null)
{
return(RedirectToAction("Index", "Home"));
}
else
{
return(View(tiendaHome));
}
}
return(View(tiendaHome));
}
public ActionResult EditarUsuario(Usuario model)
{
if (Session["Rol"] == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
if (Session["TiendaId"] == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
if (model.NombreUsuario != null)
{
model.NombreUsuario = model.NombreUsuario.ToUpper();
}
if (model.Email != null)
{
model.Email = model.Email.ToUpper();
}
int tiendaId = (int)Session["TiendaId"];
Tienda tienda = db.Tienda.Find(tiendaId);
List <UsuarioTienda> usuariosTienda = tienda.UsuariosTienda.ToList();
UsuarioTienda ustienda = usuariosTienda.Where(ut => ut.UsuarioId == model.Id).FirstOrDefault();
if (ustienda == null)
{
return(RedirectToAction("IniciarSesion", "Login"));
}
Usuario repetido = db.Usuarios.Where(u => u.NombreUsuario == model.NombreUsuario && u.Id != model.Id).FirstOrDefault();
Usuario mailRepetido = db.Usuarios.Where(u => u.Email == model.Email && u.Id != model.Id).FirstOrDefault();
ModelState.Clear();
model.Password = "******";//para evitar que el ModelState falle por "ser obligatorio"
if (repetido != null || mailRepetido != null)
{
if (repetido != null)
{
ModelState.AddModelError("NombreUsuario", "El nombre de usuario ya se encuentra en uso");
}
if (mailRepetido != null)
{
ModelState.AddModelError("Email", "El email ya se encuentra en uso");
}
}
TryValidateModel(model);
if (ModelState.IsValid == false)
{
return(View(model));
}
if (model.RolUsuario == Usuario.TipoUsuario.SuperAdmin)
{
model.RolUsuario = Usuario.TipoUsuario.Cliente;
}
Usuario.EditarUsuario(db, model, tiendaId, model.RolEnTienda);
return(RedirectToAction("ListaUsuarios"));
}
public ActionResult Registrate(Usuario model)
{
if (model.NombreUsuario != null)
{
model.NombreUsuario = model.NombreUsuario.ToUpper();
}
if (model.Email != null)
{
model.Email = model.Email.ToUpper();
}
Usuario repetido = db.Usuarios.Where(u => u.NombreUsuario == model.NombreUsuario).FirstOrDefault();
Usuario mailRepetido = db.Usuarios.Where(u => u.Email == model.Email).FirstOrDefault();
ModelState.Clear();
if (repetido != null || mailRepetido != null)
{
if (repetido != null)
{
ModelState.AddModelError("NombreUsuario", "El nombre de usuario ya se encuentra en uso");
}
if (mailRepetido != null)
{
ModelState.AddModelError("Email", "El email ya se encuentra en uso");
}
}
TryValidateModel(model);
if (ModelState.IsValid == false)
{
return(View(model));
}
model.RolUsuario = Usuario.TipoUsuario.Cliente;
int tiendaId = 0;
Tienda tiendaCreada = null;
if (creacionDeTiendaEnEspera != null)
{
tiendaCreada = Tienda.CrearNuevaTienda(db, creacionDeTiendaEnEspera);
tiendaId = tiendaCreada.Id;
}
Usuario usuarioCreado = Usuario.CrearNuevoUsuario(db, model, tiendaId);
MantenerSesion(usuarioCreado);
if (tiendaCreada != null)
{
UsuarioTienda usTienda = usuarioCreado.UsuarioTiendas.Where(ut => ut.Tienda.Id == tiendaCreada.Id).FirstOrDefault();
if (usTienda != null)
{
Session["TiendaId"] = usTienda.Tienda.Id;
Session["TiendaNombre"] = usTienda.Tienda.Nombre;
}
return(RedirectToAction("Index", "TiendaUser", new { id = tiendaCreada.Id }));
}
return(RedirectToAction("IniciarSesion"));
}
public ActionResult IniciarSesion(string nombreUsuario, string password)
{
if (nombreUsuario.Equals("") || password.Equals(""))
{
ViewBag.Mensaje = "Debe rellenar los campos";
return(View());
}
int numeroAdmins = db.Usuarios.Where(u => u.RolUsuario == Usuario.TipoUsuario.SuperAdmin).ToList().Count;
if (numeroAdmins == 0)
{
return(RedirectToAction("PrimerUsuario"));
}
bool usuarioExiste = ValidarUsuario(nombreUsuario, password);
if (usuarioExiste == false)
{
ViewBag.Mensaje = "El Nombre de Usuario & Contraseña no son válidos";
return(View());
}
Usuario user = db.Usuarios.Where(u => u.NombreUsuario.ToUpper() == nombreUsuario.ToUpper()).FirstOrDefault();
if (user.RolUsuario == Usuario.TipoUsuario.Bloqueado)
{
ViewBag.Mensaje = "Denegado el acceso. La cuenta se encuentra bloqueada.";
return(View());
}
MantenerSesion(user);
UsuarioTienda usTienda = db.UsuariosTienda.Where(ut => ut.Usuario.Id == user.Id).FirstOrDefault();
if (usTienda != null)
{
Session["TiendaId"] = usTienda.Tienda.Id;
Session["TiendaNombre"] = usTienda.Tienda.Nombre;
}
Carrocompra carroCompra = Carrocompra.CrearCarroCompra(user.Id, db);
Carrocompra.EliminarTodosLosProductosEnCarro(user, db);
if (CotizacionValuesData.SeleccionarHora)
{
return(RedirectToAction("SeleccionarHora", "Schedule", new { id = CotizacionValuesData.Id }));
}
if (user.RolUsuario == Usuario.TipoUsuario.SuperAdmin)
{
return(RedirectToAction("Index", "SuperAdmin"));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}