Beispiel #1
0
        public ActionResult Create(Aviso a)
        {
            bool resultado = gw.IntroducirAviso(a);

            ViewBag.res = resultado;
            return(RedirectToAction("Create", "Aviso", resultado));
        }
        public async Task <IActionResult> Create([FromBody] AvisoResource avisoResource)
        {
            if (avisoResource == null)
            {
                return(NotFound());
            }
            try
            {
                var aviso = new Aviso();
                if (ModelState.IsValid)
                {
                    aviso = AvisoMapper.ResourceToModel(avisoResource, aviso);
                }

                _unitOfWork.Avisos.Add(aviso);
                await _unitOfWork.CompleteAsync();

                return(Ok(aviso));
            }
            catch (Exception exception)
            {
                LogError.LogErrorWithSentry(exception);
                return(BadRequest());
            }
        }
        public Coincidencia GenerarCoincidencia(Aviso aviso)
        {
            int          PuntajeMaximo   = CalcularPuntajeMaximo(aviso);
            int          PuntajeEmpleado = 0;
            Coincidencia coincidencia;

            if (Empleado.Aptitud != null && aviso.AptitudesBuscadas != null)
            {
                foreach (AptitudPorAviso aptitudAviso in aviso.AptitudesBuscadas)
                {
                    int i = 0;
                    while (i < Empleado.Aptitud.Count && aptitudAviso.Aptitud.Id != Empleado.Aptitud[i].Id)
                    {
                        i++;
                    }
                    if (i != Empleado.Aptitud.Count)
                    {
                        PuntajeEmpleado += (int)aptitudAviso.Prioridad;
                    }
                }
                coincidencia = new Coincidencia((float)Math.Round((float)PuntajeEmpleado / (float)PuntajeMaximo * 100), Empleado, aviso);
            }
            else
            {
                coincidencia = null;
            }
            return(coincidencia);
        }
Beispiel #4
0
        private async Task SaveAsync()
        {
            var locator = CrossGeolocator.Current;

            locator.DesiredAccuracy = 50;
            var position = await locator.GetPositionAsync();

            var aviso = new Aviso
            {
                Id          = this.Id,
                Tipo        = this.Tipo,
                UriFoto     = this.UriFoto,
                Descripcion = this.Descripcion,
                cerrado     = false,
                lat         = position.Latitude,
                lon         = position.Longitude
            };

            await XamagramMobileService.Instance.
            AddOrUpdateAvisoAsync(aviso);


            Id          = "";
            Tipo        = "0";
            UriFoto     = "";
            Descripcion = "";

            //NavigationService.Instance.NavigateBack();
        }
        private List <Aviso> GerarAvisosDeFinanca()
        {
            try
            {
                List <Aviso>   avisos   = new List <Aviso>();
                List <Financa> financas = FinancaService.ObterFinancasOrdPorId().Where(f => f.EstadoPagamento == EstadosDePagamento.VENCIDO).ToList();

                if (financas != null)
                {
                    foreach (Financa f in financas)
                    {
                        Aviso aviso = new Aviso();
                        aviso.idObjeto = f.FinancaId;
                        aviso.Mensagem = "Finança de codigo: " + f.Codigo + ", está com pagamento atrasado";
                        aviso.Tipo     = TiposDeAviso.PAGAMENTO_VENCIDO;
                        avisos.Add(aviso);
                    }
                }
                return(avisos);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #6
0
 private void btnComprar_Click(object sender, EventArgs e)
 {
     try
     {
         int cant;
         if (Int32.TryParse(mtxtCantidad.Text.ToString(), out cant))
         {
             if (Convert.ToInt32(mtxtStock.Text) >= cant)
             {
                 Controller.Compras.GenerarCompra(this.idUsuario, this.idPublicacion, DateTime.Now, cant);
                 String     str      = Controller.Compras.ObtenerDatosVendedor(this.idPublicacion);
                 View.Aviso vtnAviso = new Aviso(this, "La Compra se ha generado correctamente." + str);
                 vtnAviso.Visible = true;
                 this.Enabled     = false;
             }
             else
             {
                 epCantidad.SetError(mtxtCantidad, "La Cantidad es superior al Stock Disponible.");
             }
         }
         else
         {
             epCantidad.SetError(mtxtCantidad, "La Cantidad no es Correcta.");
         }
     }
     catch (Exception ex)
     {
         View.Error.ErrorForm vtnError = new FrbaCommerce.View.Error.ErrorForm(ex.Message);
         vtnError.Visible = true;
     }
 }
 private List <Aviso> GerarAvisosDeAluguel()
 {
     try
     {
         List <Aviso>   avisos   = new List <Aviso>();
         List <Aluguel> alugueis = AluguelService.ObterAlugueisOrdPorId().Where(a => a.EstadoDoAluguel == EstadosAluguel.VENCIDO || a.EstadoDoPagamento == EstadosDePagamento.VENCIDO).ToList();
         if (alugueis != null)
         {
             foreach (Aluguel a in alugueis)
             {
                 Aviso aviso = new Aviso();
                 aviso.Tipo = TiposDeAviso.ALUGUEL_IRREGULAR;
                 if (a.EstadoDoAluguel == EstadosAluguel.VENCIDO)
                 {
                     aviso.Mensagem = "O Aluguel de ID: " + a.AluguelId + ", expirou";
                 }
                 if (a.EstadoDoPagamento == EstadosDePagamento.VENCIDO)
                 {
                     aviso.Mensagem = "O Aluguel de ID: " + a.AluguelId + ", está com o pagamento vencido";
                 }
                 aviso.idObjeto = a.AluguelId;
                 avisos.Add(aviso);
             }
         }
         return(avisos);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
 private List <Aviso> GerarAvisosDeVeiculo()
 {
     try
     {
         string         mp;
         List <Aviso>   avisos   = new List <Aviso>();
         List <Veiculo> veiculos = VeiculoService.ObterVeiculosOrdPorId()
                                   .Where(v => v.EstadoDoVeiculo == EstadosDeVeiculo.ACIDENTADO || v.EstadoDoVeiculo == EstadosDeVeiculo.SEM_COMBUSTIVEL)
                                   .ToList();
         if (veiculos != null)
         {
             foreach (Veiculo v in veiculos)
             {
                 mp = "Veiculo de Placa: " + v.Placa + ", se encontra ";
                 Aviso aviso = new Aviso();
                 aviso.idObjeto = v.VeiculoId;
                 aviso.Tipo     = TiposDeAviso.VEICULO_IRREGULAR;
                 if (v.EstadoDoVeiculo == EstadosDeVeiculo.SEM_COMBUSTIVEL)
                 {
                     aviso.Mensagem = mp + "sem combustível";
                 }
                 if (v.EstadoDoVeiculo == EstadosDeVeiculo.ACIDENTADO)
                 {
                     aviso.Mensagem = mp + "acidentado";
                 }
                 avisos.Add(aviso);
             }
         }
         return(avisos);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
        private List <Aviso> GerarAvisosDeViagem()
        {
            try
            {
                string        mp;
                List <Aviso>  avisos  = new List <Aviso>();
                List <Viagem> viagens = ViagemService.ObterViagensOrdPorId().Where(v => v.EstadoDaViagem == EstadosDeViagem.AGUARDANDO_INICIO && v.DataSaida < DateTime.Now).ToList();

                if (viagens != null)
                {
                    foreach (Viagem v in viagens)
                    {
                        mp = "Viagem de ID: " + v.ViagemId + ", ainda não foi iniciada e está atrasada";
                        Aviso aviso = new Aviso();
                        aviso.idObjeto = v.ViagemId;
                        aviso.Tipo     = TiposDeAviso.VIAGEM_IRREGULAR;
                        aviso.Mensagem = mp;
                        avisos.Add(aviso);
                    }
                }
                return(avisos);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #10
0
        public ActionResult AlteraAviso(Aviso obj)
        {
            AvisoDAO dao = new AvisoDAO();

            dao.altera(obj);
            return(RedirectToAction("frmBuscaAviso"));
        }
        private void btnGuardar_Click(object sender, EventArgs e)
        {
            try
            {
                if (validarDatos())
                {
                    int    stock   = Convert.ToInt32(mtxtStock.Text);
                    Double precio  = Convert.ToDouble(mtxtPrecio.Text);
                    int    cod     = Convert.ToInt32(mtxtCodPubli.Text);
                    int    idRubro = (int)cmbRubros.SelectedValue;//clbRubros.SelectedValue;


                    if (publicacion == null)
                    {
                        Controller.Publicaciones.IngresarPublicacionNueva((int)cmbTiposPublicaciones.SelectedValue, cod, (int)cmbRubros.SelectedValue, 1, Convert.ToDateTime(mtxtFechaInicio.Text), Convert.ToDateTime(mtxtFechaFin.Text), rtxtDescripcion.Text, stock, precio, idUsuario, chbPreguntas.Checked);
                    }
                    else
                    {
                        Controller.Publicaciones.ActualizarPublicacion(publicacion.IdPublicacion, (int)cmbTiposPublicaciones.SelectedValue, cod, (int)cmbRubros.SelectedValue, 1, Convert.ToDateTime(mtxtFechaInicio.Text), Convert.ToDateTime(mtxtFechaFin.Text), rtxtDescripcion.Text, stock, precio, idUsuario, chbPreguntas.Checked);
                    }

                    View.Aviso vtnAviso = new Aviso(this, "La publicacion se ha generado correctamente");
                    vtnAviso.Visible = true;
                    this.Enabled     = false;
                }
            }
            catch (Exception ex)
            {
                View.Error.ErrorForm vtnError = new FrbaCommerce.View.Error.ErrorForm(ex.Message);
                vtnError.Visible = true;
            }
        }
        public List <Coincidencia> GenerarListadoCoincidencias(Aviso avisoOrigen, IQueryable <UsuarioEmpleado> usuariosEmpleado)
        {
            //Inicialización
            List <Coincidencia>         listCoincidencias      = new List <Coincidencia>();
            CalculadorDePorcentajeAviso calculadorDePorcentaje = new CalculadorDePorcentajeAviso(avisoOrigen);

            //Se filtran todos los empleados que cumplan con los parámetros excluyentes
            List <UsuarioEmpleado> listCandidatos = usuariosEmpleado.Where(usEmp =>
                                                                           usEmp.Busqueda_Id.HasValue &&
                                                                           (avisoOrigen.HorasTrabajoPrioridad == Prioridad.Excluyente ? avisoOrigen.HorasTrabajo == usEmp.Busqueda.HorasTrabajo : true) &&
                                                                           (avisoOrigen.SueldoOfrecidoPrioridad == Prioridad.Excluyente ? avisoOrigen.SueldoOfrecido >= usEmp.Busqueda.SueldoMinimo : true) &&
                                                                           (avisoOrigen.TipoRelacionDeTrabajoPrioridad == Prioridad.Excluyente ? avisoOrigen.TipoRelacionDeTrabajo == usEmp.Busqueda.TipoRelacionDeTrabajo : true)
                                                                           ).ToList();

            listCandidatos = listCandidatos.Where(usEmp =>
                                                  avisoOrigen.AptitudesBuscadas.Where(x => x.Prioridad == Prioridad.Excluyente).Select(x => x.Aptitud).Intersect(usEmp.Aptitud).Count() == avisoOrigen.AptitudesBuscadas.Where(x => x.Prioridad == Prioridad.Excluyente).Count() &&
                                                  !avisoOrigen.UsuariosEmpleadoAprobados.Any(aviso => aviso.Id == usEmp.Id) &&
                                                  !avisoOrigen.UsuariosEmpleadoDesaprobados.Any(aviso => aviso.Id == usEmp.Id)
                                                  ).ToList();

            //Se generan las coincidencias
            foreach (var empleado in listCandidatos)
            {
                Coincidencia coincidencia = calculadorDePorcentaje.GenerarCoincidencia(empleado);
                listCoincidencias.Add(coincidencia);
            }

            //Se ordenan las coincidencias
            listCoincidencias = listCoincidencias.OrderByDescending(x => x.Porcentaje).ToList();

            return(listCoincidencias);
        }
Beispiel #13
0
        public ActionResult List(int Cod_Comum = 0)
        {
            var session = UserSession.Get(Request.HttpContext);
            var usuario = session.Usuario;

            if (Cod_Comum == 0 || !usuario.Admin)
            {
                Cod_Comum = usuario.Cod_Comum;
            }

            var lista      = Aviso.List(Cod_Comum, usuario.Admin, usuario.Instrutor, usuario.Oficializado, usuario.RJM, usuario.Aluno);
            int maxDbAviso = lista.Count != 0 ? lista.Max(e => e.Cod_Aviso) : 0;

            if (maxDbAviso > session.AvisoMax || maxDbAviso > session.Usuario.AvisoLido)
            {
                session.AvisoMax          = maxDbAviso;
                session.Usuario.AvisoLido = maxDbAviso;

                Usuario usuarioDb = Usuario.Find(session.Cod_Usuario());
                usuarioDb.AvisoLido = maxDbAviso;
                usuarioDb.UpdateAvisoLido();

                UserSession.Set(Request.HttpContext, session);
            }

            return(View(lista));
        }
Beispiel #14
0
        public ActionResult Save(Aviso model)
        {
            try{
                var usuario = UserSession.Get(Request.HttpContext).Usuario;
                if (model.Cod_Comum == 0 || !usuario.Admin)
                {
                    model.Cod_Comum = usuario.Cod_Comum;
                }

                if (usuario.Instrutor)
                {
                    model.Instrutor   = true;
                    model.Cod_Usuario = UserSession.Get(Request.HttpContext).Cod_Usuario();

                    char oper = model.Cod_Aviso == 0 ? 'C' : 'U';
                    model.Save();
                    Monitor.Add <Aviso>(HttpContext, oper, model.Nome);
                }

                return(Json("ok"));
            }
            catch (Exception ex) {
                return(Json(ex.Message));
            }
        }
Beispiel #15
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Mensagem,EscalaId")] Aviso Aviso)
        {
            if (id != Aviso.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try{
                    _context.Update(Aviso);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException) {
                    if (!AvisoExists(Aviso.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction("Index"));
            }
            return(View(Aviso));
        }
Beispiel #16
0
        public List <Aviso> setarObjeto(SqlDataReader dr)
        {
            List <Aviso> lstAviso = new List <Aviso>();

            try
            {
                if (dr.HasRows)
                {
                    while (dr.Read())
                    {
                        Aviso obj = new Aviso();
                        obj.id_aviso     = Convert.ToInt32(dr["ID_AVISO"].ToString());
                        obj.titulo       = Convert.ToString(dr["TITULO"].ToString());
                        obj.descricao    = Convert.ToString(dr["DESCRICAO"].ToString());
                        obj.data         = Convert.ToDateTime(dr["DT_AVISO"].ToString());
                        obj.ativo        = Convert.ToBoolean(dr["STS_ATIVO"].ToString());
                        obj.cond         = new Condominio();
                        obj.cond.id_cond = Convert.ToInt32(dr["ID_COND"].ToString());
                        obj.cond.nome    = Convert.ToString(dr["NOME_COND"].ToString());

                        lstAviso.Add(obj);
                    }
                }
            }

            catch (Exception ex)
            {
                dr.Dispose();
                throw ex;
            }

            return(lstAviso);
        }
        //GET: Aviso/Estadisticas/5
        public ActionResult Estadisticas(long id)
        {
            Aviso aviso = this.avisoService.GetById(id);

            int   PostulantesQueAprobaron          = avisoSPService.AprobacionesDeUsuarios((int)id);
            int   PostulantesQueDesaprobaron       = avisoSPService.DesaprobacionesDeUsuarios((int)id);
            float PorcentajeAprobadosPostulante    = avisoSPService.CalcularPorcentaje(PostulantesQueAprobaron, PostulantesQueDesaprobaron);
            float PorcentajeDesaprobadosPostulante = avisoSPService.CalcularPorcentaje(PostulantesQueDesaprobaron, PostulantesQueAprobaron);

            //Consulta para la cantidad de aprobaciones que tiene un Aviso.
            //No hace falta, actualmente Estadistica calculo esto apartir del Aviso.
            //cmd.CommandText = "SELECT COUNT(UsuarioEmpleado_Id) as TOTAL from AvisoUsuariosEmpleadosAprobados WHERE Aviso_Id = @query";
            //Consulta para cantidad de Postulantes que aprobaron el aviso.
            //cmd.CommandText = "SELECT COUNT(UsuarioEmpleado_Id) as TOTAL from UsuarioEmpleadoAviso WHERE Aviso_Id = @query";

            float PorcentajeAprobadosReclutador    = avisoSPService.CalcularPorcentaje(aviso.UsuariosEmpleadoAprobados.Count(), aviso.UsuariosEmpleadoDesaprobados.Count());
            float PorcentajeDesaprobadosReclutador = avisoSPService.CalcularPorcentaje(aviso.UsuariosEmpleadoDesaprobados.Count(), aviso.UsuariosEmpleadoAprobados.Count());

            List <RangoEstadistica> rangoEstadistica = avisoSPService.PorcentajeDePuntos((int)id);

            EstadisticaViewModel vista = new EstadisticaViewModel {
                TituloAviso = aviso.Titulo, PorcentajeApPost = PorcentajeAprobadosPostulante * 100, PorcentajeDesPost = PorcentajeDesaprobadosPostulante * 100, PorcentajeApRec = PorcentajeAprobadosReclutador * 100, PorcentajeDesRec = PorcentajeDesaprobadosReclutador * 100, RangosEstadistica = rangoEstadistica
            };

            return(View(vista));
        }
Beispiel #18
0
        public ActionResult DeleteConfirmed(int id)
        {
            Aviso aviso = avisoService.GetById(id);

            this.avisoService.RemoveEntity(aviso);
            return(RedirectToAction("Index"));
        }
Beispiel #19
0
        public async Task <IActionResult> Edit(int id, [Bind("AvisosId,AgendamentoId,Mensagem")] Aviso aviso)
        {
            if (id != aviso.AvisosId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(aviso);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!AvisoExists(aviso.AvisosId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["AvisosId"] = new SelectList(_context.Agendamento, "AgendamentoId", "AgendamentoId", aviso.AvisosId);
            return(View(aviso));
        }
Beispiel #20
0
        public ActionResult CadastrarAviso(Aviso obj)
        {
            AvisoDAO dao = new AvisoDAO();

            dao.cadastra(obj);
            return(RedirectToAction("frmBuscaAviso"));
        }
Beispiel #21
0
 private void btnAceptar_Click(object sender, EventArgs e)
 {
     try
     {
         if (validarDatos())
         {
             String msg;
             if (this.idRol == -1)
             {
                 Controller.Roles.IngresarNuevoRol(txtNombre.Text, ListarFuncionalidadesSeleccionadas());
                 msg = "El Rol se ha generado correctamente.";
             }
             else
             {
                 Controller.Roles.ActualizarRol(this.idRol, txtNombre.Text, ListarFuncionalidadesSeleccionadas());
                 msg = "El Rol se ha actualizado correctamente.";
             }
             View.Aviso vtnAviso = new Aviso(this, msg);
             vtnAviso.Visible = true;
             this.Enabled     = false;
         }
     }
     catch (Exception ex)
     {
         View.Error.ErrorForm vtnError = new FrbaCommerce.View.Error.ErrorForm(ex.Message);
         vtnError.Visible = true;
     }
 }
Beispiel #22
0
        public async Task DeleteAvisoAsync(Aviso aviso)
        {
            await InitializeAsync();

            await _avisoTable.DeleteAsync(aviso);

            await SynchronizeAsync();
        }
Beispiel #23
0
 public IActionResult Create(Aviso aviso)
 {
     if (ModelState.IsValid)
     {
         ViewBag.Message = "Aviso cadastrado com sucesso !!!";
     }
     return(View());
 }
 public void OnGet()
 {
     if (Item == null)
     {
         Item = new Aviso(); //se não existir item é pq não tem aviso, então crio uma instancia de um aviso
     }
     Item.Hora = DateTime.Now;
 }
        public ActionResult DeleteConfirmed(int id)
        {
            Aviso aviso = db.Avisos.Find(id);

            db.Avisos.Remove(aviso);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
        public void OnGet()
        {
            if (Item == null)
            {
                Item = new Aviso();
            }

            Item.Hora = DateTime.Now;
        }
Beispiel #27
0
        //GET: Aviso/Estadisticas/5
        public ActionResult Estadisticas(long id)
        {
            Aviso aviso = this.avisoService.GetById(id);

            int   PostulantesQueAprobaron          = avisoSPService.AprobacionesDeUsuarios((int)id);
            int   PostulantesQueDesaprobaron       = avisoSPService.DesaprobacionesDeUsuarios((int)id);
            float PorcentajeAprobadosPostulante    = avisoSPService.CalcularPorcentaje(PostulantesQueAprobaron, PostulantesQueDesaprobaron);
            float PorcentajeDesaprobadosPostulante = avisoSPService.CalcularPorcentaje(PostulantesQueDesaprobaron, PostulantesQueAprobaron);

            PorcentajeAprobadosPostulante    = (float)Math.Round(PorcentajeAprobadosPostulante, 4);
            PorcentajeDesaprobadosPostulante = (float)Math.Round(PorcentajeDesaprobadosPostulante, 4);


            //if (TotalPostulantes == 0)
            //{
            //    PorcentajeAprobadosPostulante = 0;
            //    PorcentajeDesaprobadosPostulante = 0;
            //} else
            //{
            //    PorcentajeAprobadosPostulante = PostulantesQueAprobaron / TotalPostulantes;
            //    PorcentajeDesaprobadosPostulante = PostulantesQueDesaprobaron / TotalPostulantes;
            //}


            //Consulta para la cantidad de aprobaciones que tiene un Aviso.
            //No hace falta, actualmente Estadistica calculo esto apartir del Aviso.
            //cmd.CommandText = "SELECT COUNT(UsuarioEmpleado_Id) as TOTAL from AvisoUsuariosEmpleadosAprobados WHERE Aviso_Id = @query";
            //Consulta para cantidad de Postulantes que aprobaron el aviso.
            //cmd.CommandText = "SELECT COUNT(UsuarioEmpleado_Id) as TOTAL from UsuarioEmpleadoAviso WHERE Aviso_Id = @query";
            float PorcentajeAprobadosReclutador    = avisoSPService.CalcularPorcentaje(aviso.UsuariosEmpleadoAprobados.Count(), aviso.UsuariosEmpleadoDesaprobados.Count());
            float PorcentajeDesaprobadosReclutador = avisoSPService.CalcularPorcentaje(aviso.UsuariosEmpleadoDesaprobados.Count(), aviso.UsuariosEmpleadoAprobados.Count());

            if (float.IsNaN(PorcentajeAprobadosReclutador))
            {
                PorcentajeAprobadosReclutador = 0;
            }
            else
            {
                PorcentajeAprobadosReclutador = (float)Math.Round(PorcentajeAprobadosReclutador, 4);
            }
            if (float.IsNaN(PorcentajeDesaprobadosReclutador))
            {
                PorcentajeDesaprobadosReclutador = 0;
            }
            else
            {
                PorcentajeDesaprobadosReclutador = (float)Math.Round(PorcentajeDesaprobadosReclutador, 4);
            }

            RangoEstadistica[] rangoEstadistica = avisoSPService.DevolverRangoEstadisticaOrdenado((int)id);

            EstadisticaViewModel vista = new EstadisticaViewModel {
                TituloAviso = aviso.Titulo, PorcentajeApPost = PorcentajeAprobadosPostulante * 100, PorcentajeDesPost = PorcentajeDesaprobadosPostulante * 100, PorcentajeApRec = PorcentajeAprobadosReclutador * 100, PorcentajeDesRec = PorcentajeDesaprobadosReclutador * 100, RangosEstadistica = rangoEstadistica
            };

            return(View(vista));
        }
Beispiel #28
0
 public ActionResult Edit(Aviso aviso)
 {
     if (ModelState.IsValid)
     {
         unitOfWork.AvisoRepository.Update(aviso);
         return(RedirectToAction("Index"));
     }
     return(View(aviso));
 }
Beispiel #29
0
 public ActionResult Edit([Bind(Include = "Id,Titulo,Descripcion,FechaInicio,FechaFin,UsuarioReclutador_Id,UsuarioEmpresa_Id,UsuarioReclutadorAsignado_Id")] Aviso aviso)
 {
     if (ModelState.IsValid)
     {
         this.avisoService.UpdateEntity(aviso);
         return(RedirectToAction("Index"));
     }
     return(View(aviso));
 }
Beispiel #30
0
        public List <Aviso> setarObjeto(SqlDataReader dr)
        {
            Aviso        obj      = new Aviso();
            List <Aviso> lstAviso = new List <Aviso>();

            try
            {
                if (dr.HasRows)
                {
                    while (dr.Read())
                    {
                        obj.id_aviso  = Convert.ToInt32(dr["ID_AVISO"].ToString());
                        obj.titulo    = Convert.ToString(dr["TITULO"].ToString());
                        obj.descricao = Convert.ToString(dr["DESCRICAO"].ToString());
                        obj.data      = Convert.ToDateTime(dr["DT_AVISO"].ToString());

                        obj.cond.id_cond = Convert.ToInt32(dr["ID_COND"].ToString());
                        obj.cond.nome    = Convert.ToString(dr["NOME_COND"].ToString());

                        lstAviso.Add(obj);
                    }
                }
                //for (int idx = 0; idx < dr.FieldCount; idx++)
                //{
                //    dr.GetName(idx).ToString();

                //    switch (dr.GetName(idx).ToUpper())
                //    {
                //        case "TITULO":
                //            obj.titulo = Convert.ToString(dr[idx]);
                //            break;
                //        case "DESCRICAO":
                //            obj.descricao = Convert.ToString(dr[idx]);
                //            break;
                //        case "DATA":
                //            obj.data = Convert.ToDateTime(dr[idx]);
                //            break;
                //        case "ID_AVISO":
                //            obj.id_aviso = Convert.ToInt32(dr[idx]);
                //            break;
                //        case "NOME_COND":
                //            obj.cond.nome = Convert.ToString(dr[idx]);
                //            break;
                //        case "ID_COND":
                //            obj.cond.id_cond = Convert.ToInt32(dr[idx]);
                //            break;
                //    }
                //}
            }
            catch (Exception ex)
            {
                dr.Dispose();
                throw ex;
            }

            return(lstAviso);
        }
        public void CriarAvisoValido()
        {
            //Arrange
            Aviso c = new Aviso() { Texto = "XXX YYY ZZZ" };

            //Act
            var result = (RedirectToRouteResult)_avisoController.Criar(new AvisoEditModel {Id = c.Id, Texto = c.Texto});

            //Assert
            _servicoMock.Verify(m => m.Criar(c), Times.Once);
            Assert.AreEqual("Index", result.RouteValues["action"]);
        }
        public void CriarAvisoInvalido()
        {
            // Arrange
            Aviso c = new Aviso() { Texto = "" };
            _avisoController.ModelState.AddModelError("Error", "Something went wrong");

            //Act
            var result = (ViewResult)_avisoController.Criar(new AvisoEditModel { Id = c.Id, Texto = c.Texto });

            //Assert
            _servicoMock.Verify(m => m.Criar(c), Times.Never);
            Assert.AreEqual("", result.ViewName);
        }
Beispiel #33
0
        public void CriarAviso()
        {
            //Arrange
            Aviso notice = new Aviso() { Texto = "xxx yyy zzz" };

            _setMock.Setup(m => m.Add(notice)).Returns((Aviso e) =>
                                                      {
                                                          e.Id = 1;
                                                          return e;
                                                      });

            //Act
            _servicoAvisoMock.Criar(notice);

            //Assert
            Assert.AreEqual(1, notice.Id);
            _contextMock.Verify(m => m.SaveChanges(), Times.Once());
        }
        public void CriarAviso()
        {
            //Arrange
            int Id = 1;
            Aviso aviso = new Aviso() { Texto = "xxx yyy zzz" };

            _setMock.Setup(m => m.Add(aviso)).Returns((Aviso e) =>
                                                      {
                                                          e.Id = Id;
                                                          return e;
                                                      });

            //Act
            _servicoAvisoMock.Criar(aviso);

            //Assert
            Assert.AreEqual(Id, aviso.Id);
            _contextoMock.Verify(m => m.SaveChanges(), Times.Once());
        }
Beispiel #35
0
        public ActionResult Criar([Bind(Include = "Texto")] AvisoEditModel model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var aviso = new Aviso { Texto = model.Texto };
                    _servicoAviso.Criar(aviso);
                    Success(Alerts.Success, true);

                    return RedirectToAction("Index");
                }
                catch (Exception exception)
                {
                    Erro(Alerts.Erro, true, exception);
                }
            }

            return View(model);
        }
Beispiel #36
0
 public Aviso Update(Aviso aviso)
 {
     Context.Entry(aviso).State = EntityState.Modified;
     Context.SaveChanges();
     return aviso;
 }
Beispiel #37
0
 public Aviso Add(Aviso aviso)
 {
     Context.Avisos.Add(aviso);
     Context.SaveChanges();
     return aviso;
 }
        public ActionResult Index(UsuarioViewModel usuario)
        {
            var resultado = this.usuarioAppService.Autenticar(usuario);

            if (resultado.ValidationResult.IsValid == false)
            {
                var aviso = new Aviso
                {
                    TipoMensagem = Aviso.Tipo.Erro,
                    TituloMensagem = "Problemas com o formulário:"
                };

                resultado.ValidationResult.Erros.ForEach(x => aviso.Mensagens.Add(x.Message));

                TempData["Aviso"] = aviso;
                return View("Index");
            }

            AuthUser(resultado);

            return RedirectToAction("Index", "Home");
        }