public ActionResult Delete(int id, PersonaViewModel collection)
{
try
{
PersonaRepository repository = new PersonaRepository(context);
var persona = repository.Query(e => e.Id == id).First();
context.Entry(persona).Collection(g => g.Medias).Load();
if (persona.Medias.Count() == 0)
{
persona.Status = false;
repository.Update(persona);
context.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("Index"));
}
}
catch
{
return(View());
}
}
public ActionResult Create(PersonaViewModel model)
{
try
{
if (ModelState.IsValid)
{
PersonaRepository repository = new PersonaRepository(context);
#region validacion
var topicQry = new Persona {
Name = model.Name
};
//Consulto los temas con el nombre y valido su existe un elemento
bool existeTopic = repository.QueryByExample(topicQry).Where(t => t.Status == true).Count() > 0;
if (existeTopic)
{
ModelState.AddModelError("Name", "El nombre del actor ya existe");
return(View(model));
}
#endregion
Persona persona = MapHelper.Map <Persona>(model);
persona.Status = true;
repository.Insert(persona);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View());
}
}
public ActionResult AddPersona(Persona per) //Esto se ejecuta cuando se decide grabar el registro
{
try
{
if (ModelState.IsValid) // esto es una comprobacion de que el modelo se ha cargado correctamente con todos sus campos llenos
{
PersonaRepository PerRepo = new PersonaRepository();
byte[] salt;
new RNGCryptoServiceProvider().GetBytes(salt = new byte[16]);
var pbkdf2 = new Rfc2898DeriveBytes(per.Persona_Password, salt, 10000);
byte[] hash = pbkdf2.GetBytes(20);
byte[] usr_hash = new byte[36];
Array.Copy(salt, 0, usr_hash, 0, 16);
Array.Copy(hash, 0, usr_hash, 16, 20);
string usr_pwd = Convert.ToBase64String(usr_hash);
per.Persona_Password = usr_pwd;
if (PerRepo.AddPersona(per))
{
ViewBag.Message = "Persona agregada"; // Si la funcion dentro del if devuelve true quiere decir que si logramos añadir un registro
}
else
{
ViewBag.Message = "Ocurrio un error"; //Si no ps mala suerte
}
}
return(RedirectToAction("GetPersonas")); // Haya añadido o no un registro lo que hacemos es que la vista vuelva al listado de Personas. Esto apunta al método de arrribbba
// si te das cuenta tiene que tener el nombre exacto
} catch
{
return(View()); //Esto en caso el modelo sea invalido se recargara la vista para que lo intente otra vez. OJO: No va ir al listado simplemente se esta llamando a su GET
}
}
public ActionResult EditPersona(Persona obj) // Guardamos el registro
{
try
{
if (ModelState.IsValid)
{
PersonaRepository PerRepo = new PersonaRepository();
if (PerRepo.UpdatePersona(obj)) // Atento a los nombres plss
{
ViewBag.Message = "Persona modificada";
}
else
{
ViewBag.Message = "Ocurrio un error";
}
return(RedirectToAction("GetPersonas")); //Guardado o no el registro regresamos al listado
}
return(View(obj)); //EN caso sea el modelo invalido recargamos
}
catch
{
return(RedirectToAction("GetPersonas")); // Al listadooooo
}
}
// GET: Persona/DeletePersona/5 ----- Este metodo solo tiene un GET ya que usualmente no hay vista cuando se quiere eliminar un registro.
// Por lo que no habrá un boton Guardar dentro de esa vista nueva al cual llamar para un POSt
public ActionResult DeletePersona(int?id) // Aqui viene el ban. Esto viene del boton eliminar que supuestamente deberia estar en la vista del LISTADO
{
try
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PersonaRepository PerRepo = new PersonaRepository();
if (PerRepo.DeletePersona(id))
{
ViewBag.AlertMsg = "Persona eliminado";
}
else
{
ViewBag.AlertMsg = "No se puedo eliminar";
}
return(RedirectToAction("GetPersonas"));
} catch
{
return(RedirectToAction("GetPersonas")); //Regresamos al listado. Aunque nunca nos fuimos asi que vendria a ser un refresh ;v
}
}
public bool Registrar(Cliente obj)
{
bool RLExists = false;
if (!String.IsNullOrWhiteSpace(obj.Ruc)) //EVALUO CAMPOS OBLIGATORIOS
{
if (!clienteRepository.Exists(obj.Ruc)) //EVALUO SI YA EXISTE
{
//Si tiene DNI, debe tener persona
if (!String.IsNullOrWhiteSpace(obj.DniRl))
{
if (obj.DniRlNavigation is null)//si no tiene, la creo
{
obj.DniRlNavigation = new Persona()
{
Dni = obj.DniRl, Tipo = "cli"
};
}
else
{
obj.DniRlNavigation.Dni = obj.DniRl;
obj.DniRlNavigation.Tipo = "cli";
}
PersonaRepository personaRepository = new PersonaRepository();
if (!personaRepository.Exists(obj.DniRlNavigation.Dni))
{
personaRepository.Insert(obj.DniRlNavigation);
}
else
{
RLExists = true;
obj.DniRl = null;
obj.DniRlNavigation = null;
}
}
//Primero verifico si se agrego de manera correcta a la DB
var Result = clienteRepository.Insert(obj);
if (RLExists == false)
{
return(Result);
}
else
{
throw new Exception("Se registro al cliente de manera correcta, pero no se pudo registrar al Representante Legal ya que ya existe en la Base de Datos y está relacionado con otra empresa");
}
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageCliente.AlreadyExists(obj.Ruc));
}
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageCliente.KeyIsNull());
}
}
public ActionResult Edit(int id, PersonaViewModel model)
{
try
{
if (ModelState.IsValid)
{
PersonaRepository repository = new PersonaRepository(context);
#region validacion
//Consulto los temas con el nombre y valido su existe un elemento
bool existePersona = repository.Query(x => x.Name == model.Name && x.Id != model.Id).Count > 0;
if (existePersona)
{
ModelState.AddModelError("Name", "El nombre del tema ya existe");
return(View(model));
}
#endregion
Persona persona = MapHelper.Map <Persona>(model);
repository.Update(persona);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult Edit(int id, MovieViewModel model)
{
PersonaRepository personaRepository = new PersonaRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
try
{
MovieRepository repository = new MovieRepository(context);
if (ModelState.IsValid)
{
var movie = MapHelper.Map <Movie>(model);
repository.UpdateComplete(movie, model.ActoresSeleccionados, model.GenerosSeleccionados);
context.SaveChanges();
return(RedirectToAction("Index"));
}
var actores = personaRepository.Query(a => a.Status == true);
var generos = generoRepository.Query(g => g.Activo == true);
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
return(View(model));
}
catch
{
var actores = personaRepository.Query(a => a.Status == true);
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
return(View(model));
}
}
/// <summary>
/// 1. Verifico que haya Ruc
/// 2. Verifico que exista ese Ruc en la lista
/// 3. Si existe, lo elimino de la lista in Memory
/// 4. lo mando el ID a la DB para que lo borre
/// </summary>
/// <param name="Ruc"></param>
/// <returns></returns>
public bool Eliminar(string Ruc)
{
if (!String.IsNullOrWhiteSpace(Ruc))//EVALUO CAMPOS OBLIGATORIOS
{
if (clienteRepository.Exists(Ruc))
{
bool resultp = true;
PersonaRepository personaRepository = new PersonaRepository();
if (clienteRepository.HasRepresent(Ruc, out string DniRepresent))
{
resultp = personaRepository.Delete(DniRepresent);
}
var result = clienteRepository.Delete(Ruc);
//if (result) listaClientes.Remove(listaClientes.FirstOrDefault(x => x.Ruc == Ruc));
return(result && resultp);
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageCliente.DoesNotExist(obj.Ruc));
}
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageCliente.KeyIsNull());
}
}
public bool Eliminar(string DNI)
{
if (!String.IsNullOrWhiteSpace(DNI))
{
if (conductorRepository.Exists(DNI))
{
var result = conductorRepository.Delete(DNI);
bool resultp = true;
PersonaRepository personaRepository = new PersonaRepository();
resultp = personaRepository.Delete(DNI);
return(result && resultp);
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageConductor.DoesNotExist(DNI));
}
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageConductor.KeyIsNull());
}
}
public UsuarioController(minubeDBContext context, JwtService jwtService)
{
_context = context;
_jwtService = jwtService;
personaRepository = new PersonaRepository(context);
usuarioRepository = new UsuarioRepository(context);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult Index()
{
this.repositorio = new PersonaRepository(PvUtilerias.Conexion.GetConnectionString("PuntoVentaWeb"));
this.repositorio.ConsultaPersona();
vPersonaController.personas = this.repositorio.LstPersonas;
return View(this.repositorio.LstPersonas);
}
public ActionResult Edit(int id, PersonaViewModel model)
{
try
{
if (ModelState.IsValid)
{
PersonaRepository repository = new PersonaRepository(context);
bool existeTopic = repository.Query(x => x.Nombre == model.Nombre && x.Id != model.Id).Count > 0;
if (existeTopic)
{
ModelState.AddModelError("Name", "El Nombre del ACtor ya Existe");
return(View(model));
}
Persona topic = MapHelper.Map <Persona>(model);
repository.Update(topic);
context.SaveChanges();
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
// GET: ManageSerie/Edit/5
public ActionResult Edit(int id)
{
//Repositorios necesarios
var repository = new SerieRepository(context);
var personaRepository = new PersonaRepository(context);
var generoRepository = new GeneroRepository(context);
// Expresión lambda para incluir las relaciones con actores y generos (No hay carga perezosa)
var includes = new Expression <Func <Serie, object> >[] { s => s.Actores, s => s.Generos };
//Creacion del modelo de la consulta obtenida
var serie = repository.QueryIncluding(s => s.MediaId == id, includes).SingleOrDefault();
var model = MapHelper.Map <ModificadoSerieViewModel>(serie);
//Obtención de todos los actores y generos disponibles
var actores = personaRepository.Query(a => a.Status == true);
var generos = generoRepository.Query(g => g.Activo == true);
//Establecimiento de los actores y generos que tiene nuestra serie
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
model.ActoresSeleccionados = serie.Actores.Select(a => a.Id.Value).ToArray();
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
model.GenerosSeleccionados = serie.Generos.Select(g => g.GeneroId.Value).ToArray();
return(View(model)); //Llama a la vista de edición y le pasa el modelo de la serie
}
public PersonaService()
{
correoRepository = new CorreoRepository();
personaRepository = new PersonaRepository();
preguntaRepository = new PreguntaRepository();
detalleRespuestaRepository = new DetalleRespuestaRepository();
corrreoService = new CorrreoService();
}
public SesionController(ILogger <SesionController> logger, IMapper mapper)
{
_mapper = mapper;
_logger = logger;
_sesionRepository = new SesionRepository();
_credencialRepository = new CredencialRepository();
_personaRepository = new PersonaRepository();
}
public PersonaController(ILogger <PersonaController> logger, IMapper mapper)
{
_logger = logger;
_personaRepository = new PersonaRepository();
_credencialRepository = new CredencialRepository();
_domicilioRepository = new DomicilioRepository();
_mapper = mapper;
}
// GET: Persona/Edit/5
public ActionResult Edit(int id)
{
PersonaRepository repository = new PersonaRepository(context);
var persona = repository.Query(t => t.Id == id).First();
var model = MapHelper.Map <PersonaViewModel>(persona);
return(View(model));
}
// GET: Persona
public ActionResult Index()
{
PersonaRepository repository = new PersonaRepository(context);
var lst = repository.Query(p => p.Status == true);
var models = MapHelper.Map <IEnumerable <PersonaViewModel> >(lst);
return(View(models));
}
/// <summary>
/// 1. Veo que la PK este
/// 2. Obtengo el cliente con ese Ruc
/// 3. Verifico que si exista ese cliente
/// 4. Mapeo los datos de cliente (siempre y cuando el dato que venga no este vacio ni null, para no sobreescribir en caso la data existente)
/// 5. Si el cliente actual no tiene DNI, se lo asigno del objeto nuevo
/// 6 si el DNI del objeto nuevo no es vacio paso a verificar
/// 7. si la persona es null, es decir no tiene, se la creo y le asigno el DNI
/// 8. si la persona no es null, es decir que si hay una persona. Paso a hacer otra verificacion
/// 9. si el curren.Persona es null, le referencio el obj.Persona que ha llegado
/// 10. si no es null, es decir si existe persona, mapeo los datos de obj.Persona
/// 11. El current persona lo mando al repository y retorno ese resultado
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public bool Actualizar(Cliente obj)
{
if (!String.IsNullOrWhiteSpace(obj.Ruc))//EVALUO CAMPOS OBLIGATORIOS
{
if (clienteRepository.Exists(obj.Ruc))
{
PersonaRepository personaRepository = new PersonaRepository();
#region PERSONAREPOSITORY
//Si tiene DNI, debe tener persona
if (!String.IsNullOrWhiteSpace(obj.DniRl))
{
if (obj.DniRlNavigation is null)//Si no tiene, la creo
{
obj.DniRlNavigation = new Persona()
{
Dni = obj.DniRl, Tipo = "cli"
};
}
else
{
obj.DniRlNavigation.Dni = obj.DniRl;
obj.DniRlNavigation.Tipo = "cli";
}
if (clienteRepository.HasRepresent(obj.Ruc, out string Dni) && Dni == obj.DniRlNavigation.Dni)
{
personaRepository.Update(obj.DniRlNavigation);
}
else
{
if (personaRepository.Exists(obj.DniRlNavigation.Dni))
{
obj.DniRl = null;
obj.DniRlNavigation = null;
throw new Exception("Este representante legal ya se encuentra registrado");
}
else
{
personaRepository.Insert(obj.DniRlNavigation);
}
}
//Si este cliente tiene representante legal, actualiza, si no tiene, verificar que no exista ya ese cliente para registrarlo
}
#endregion
return(clienteRepository.Update(obj));
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageCliente.DoesNotExist(obj.Ruc));
}
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageCliente.KeyIsNull());
}
}
public async Task <IList <IndicadorViewModel> > Buscar(BuscarIndicadorViewModel filtro)
{
Persona persona = await PersonaRepository.GetByUserName(filtro.PersonaLogueadaViewModel.NombreUsuario).FirstOrDefaultAsync();
IList <IndicadorViewModel> indicadores = AutoMapper.Mapper.Map <IList <IndicadorViewModel> >(IndicadorRepository.Buscar(filtro).ToList());
CargarPermisosAIndicadores(indicadores, persona);
return(indicadores);
}
// GET: Persona
public ActionResult Index()
{
PersonaRepository repository = new PersonaRepository(context);
//Consulte los Individuas del repositorio
var lst = repository.GetAll();
//Mapeamos la lista de Individuos
var models = MapHelper.Map <IEnumerable <PersonaViewModel> >(lst);
return(View(models));
}
public ActionResult GetPersonas() // Esto es la pagina de inicio del modelo respectivo. Este metodo va listar los elementos de la tabla.
{
PersonaRepository PerRepo = new PersonaRepository(); //llamamos al repositorio respectivo que creamos
TipoPersonaRepository TipoPerRepo = new TipoPersonaRepository();
ModelState.Clear(); // esto le das ctrl c ctrl v
return(View(PerRepo.ListarPersonas())); //Aqui es lo que va devolver esta funcion. Con esto se construye la vista.
// En este caso le decimos que construya la vista basandose en el resultado del metodo ListarPersonas() en el repositorio respectivo
// Osea que cuando la vista aparezca la tabla de ahi se va llenar con los registros que existen.
}
public ResultadoController(ILogger <PreguntaController> logger, IMapper mapper)
{
_logger = logger;
_mapper = mapper;
_habilidadRepository = new HabilidadRepository();
_carreraRepository = new CarreraRepository();
_areaRepository = new AreaRepository();
_resultadoRepository = new ResultadoRepository();
_sesionRepository = new SesionRepository();
_personaRepository = new PersonaRepository();
}
public SerieViewModel LinkLists(SerieViewModel model)
{
GeneroRepository generoRepository = new GeneroRepository(context);
PersonaRepository personaRepository = new PersonaRepository(context);
var lstGeneros = generoRepository.Query(g => g.Eliminado == false, "Nombre");
var lstPersonas = personaRepository.Query(p => p.Eliminado == false, "Nombre");
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(lstGeneros);
model.PersonasDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(lstPersonas);
return(model);
}
public void DeberiaMostrarElMensajeDeErrorGenericoSiNoPuedeAccederAlServicio()
{
const string noValidUri = "";
var configuration = MockConfigurationObject(noValidUri);
var mockMessageHandler = new Mock <HttpMessageHandler>(MockBehavior.Strict);
var httpClient = new HttpClient(mockMessageHandler.Object);
var sut = new PersonaRepository(configuration, httpClient);
var exception = Assert.Throws <Exception>(() => sut.All());
Assert.Equal(PersonaRepository.AccessErrorServiceMessage, exception.Message);
Assert.IsType <InvalidOperationException>(exception.InnerException);
}
public void DeberiaMostrarElMensajeDeErrorGenericoSiNoEncuentraElRecurso()
{
const string incorrectUri = "http://unknowhost";
var configuration = MockConfigurationObject(incorrectUri);
var notFoundResponseMessage = new HttpResponseMessage(HttpStatusCode.NotFound);
var mockMessageHandler = MockMessageHandler(notFoundResponseMessage);
var httpClient = new HttpClient(mockMessageHandler.Object);
var sut = new PersonaRepository(configuration, httpClient);
var exception = Assert.Throws <Exception>(() => sut.All());
Assert.Equal(PersonaRepository.AccessErrorServiceMessage, exception.Message);
}
// GET: Movie/Create
public ActionResult Create()
{
PersonaRepository personaRepository = new PersonaRepository(context);
GeneroRepository generoRepository = new GeneroRepository(context);
var model = new MovieViewModel();
var actores = personaRepository.Query(a => a.Status == true);
var generos = generoRepository.Query(g => g.Activo == true);
model.ActoresDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(actores);
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(generos);
return(View(model));
}
// GET: Movie/Create
public ActionResult Create()
{
var model = new MovieViewModel();
GeneroRepository generoRepository = new GeneroRepository(context);
PersonaRepository personaRepository = new PersonaRepository(context);
var lst = generoRepository.Query(g => g.Eliminado == false, "Nombre");
var lst2 = personaRepository.Query(p => p.Eliminado == false, "Nombre");
model.GenerosDisponibles = MapHelper.Map <ICollection <GeneroViewModel> >(lst);
model.PersonasDisponibles = MapHelper.Map <ICollection <PersonaViewModel> >(lst2);
model.estado = EEstatusMedia.VISIBLE;
return(View(model));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult InsertaPersona()
{
repositorio = new PersonaRepository(PvUtilerias.Conexion.GetConnectionString("PuntoVentaWeb"));
Persona p = new Persona();
repositorio.ConsultaTiposPersonas();
foreach (TipoPersona tp in repositorio.LstTiposPersonas)
{
SelectListItem sli = new SelectListItem();
sli.Text = tp.descripcion;
sli.Value = tp.id.ToString();
p.LstTiposPersonas.Add(sli);
}
return View(p);
}
/// <summary>
/// Inicializa y construye el sistema.
/// </summary>
/// <returns></returns>
public static Sistema BuildSistema()
{
DbContextOptions <ModelDbContext> options = new DbContextOptionsBuilder <ModelDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.EnableSensitiveDataLogging()
.Options;
DbContext dbContext = new ModelDbContext(options);
IPersonaRepository personas = new PersonaRepository(dbContext);
IRepository <Usuario> usuarios = new ModelRepository <Usuario>(dbContext);
return(new Sistema(personas, usuarios));
}
public bool Actualizar(Conductor obj)
{
if (!String.IsNullOrWhiteSpace(obj.Dni))
{
if (conductorRepository.Exists(obj.Dni))
{
PersonaRepository personaRepository = new PersonaRepository();
#region PERSONAREPOSITORY
//Si tiene DNI, debe tener persona
if (!String.IsNullOrWhiteSpace(obj.Dni))
{
if (obj.DniNavigation is null)//Si no tiene, la creo
{
obj.DniNavigation = new Persona()
{
Dni = obj.Dni, Tipo = "cli"
};
}
else
{
obj.DniNavigation.Dni = obj.Dni;
obj.DniNavigation.Tipo = "cli";
}
if (personaRepository.Exists(obj.DniNavigation.Dni))
{
personaRepository.Update(obj.DniNavigation);
}
else
{
personaRepository.Insert(obj.DniNavigation);
}
//Si este cliente tiene representante legal, actualiza, si no tiene, verificar que no exista ya ese cliente para registrarlo
}
#endregion
return(conductorRepository.Update(obj));
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageConductor.DoesNotExist(obj.Dni));
}
}
else
{
throw new Exception(ExceptionMessageManager.ExceptionMessageConductor.KeyIsNull());
}
}
public ActionResult InsertaRegistroPersona(Persona miPersona)
{
try
{
repositorio = new PersonaRepository(miPersona, PvUtilerias.Conexion.GetConnectionString("PuntoVentaWeb"));
repositorio.InsertaPersona();
resultado = new VistaResultadoModel(0, "Se ha insertado el registro !!!");
return PartialView("_Respuesta", resultado);
}
catch (Exception ex)
{
resultado = new VistaResultadoModel(1, ex.Message);
return PartialView("_Respuesta", resultado);
}
}
