Esempio n. 1
0
        public CartelActividadesStandardMatching(Preferencia preferencia, Usuario user, Actividad a)
        {
            InitializeComponent();
            this.a           = a;
            this.user        = user;
            this.preferencia = preferencia;

            this.labelName.Text      = a.NombreAct;
            this.lDescripcion.Text   = a.DescAct;
            this.lNumPlazas.Text     = a.NumPlazas.ToString();
            this.lTipoActividad.Text = a.TipoAct.ToString();
            this.lShowIni.Text       = a.FechaInicio.ToShortDateString() + " - " + a.FechaFin.ToShortDateString();
            this.lShowOrg.Text       = a.Organizador.Nombre;
            if (a.Imagen != null)
            {
                pict.Image = a.Imagen;
            }

            if (a.Responsable != null)
            {
                this.lShowResp.Text = a.Responsable.Nombre + " " + a.Responsable.Apellido1 + " " + a.Responsable.Apellido2;
            }
            else
            {
                lResp.Visible     = false;
                lShowResp.Visible = false;
            }
            CalcularCompatibilidad();
        }
        /*--------------------------------------------------------------------
        * Metodo que retorna os dados relativos às preferencias de um
        * determinado cliente
        * TESTADO E FUNCIONAL
        *  --------------------------------------------------------------------*/
        public Preferencia GetDadosPreferencia(string usernameCli)
        {
            Preferencia        p            = null;
            List <Ingrediente> ingrs        = GetDadosListaIngredientes(usernameCli);
            List <string>      prefsCozinha = GetDadosTipoCozinha(usernameCli);

            try
            {
                myConnection.Open();
                SqlDataReader myReader  = null;
                SqlCommand    myCommand = new SqlCommand("SELECT Cliente.OrdemPreferencia FROM Cliente " +
                                                         "WHERE Cliente.Username = '******';", myConnection);

                int ordem = (-1);
                myReader = myCommand.ExecuteReader();
                if (myReader.Read())
                {
                    ordem = Convert.ToInt16(myReader["OrdemPreferencia"].ToString());
                }
                myReader.Close();
                myConnection.Close();

                p = new Preferencia(ordem, prefsCozinha, ingrs);
            }
            catch (Exception e) { Console.WriteLine(e); }
            return(p);
        }
        public IHttpActionResult PutPreferencia(int id, Preferencia preferencia)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != preferencia.id_preferencia)
            {
                return(BadRequest());
            }

            db.Entry(preferencia).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!PreferenciaExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
Esempio n. 4
0
        private Dictionary <string, int> GetCaracteristicasNumeroVezes(Preferencia preferencia)
        {
            if (preferencia == null)
            {
                return(new Dictionary <string, int>());
            }

            var caracteristicas = new List <Caracteristica>();

            caracteristicas.AddRange(preferencia.Caracteristicas);

            var auxiliarNumeroVezes = new Dictionary <string, int>();

            foreach (var caracteristica in caracteristicas)
            {
                int nrVezes = 0;

                auxiliarNumeroVezes.TryGetValue(caracteristica.Nome, out nrVezes);

                if (DataRecente(caracteristica.Data))
                {
                    auxiliarNumeroVezes.Add(caracteristica.Nome, nrVezes + 4);
                }
                else if (DataMedia(caracteristica.Data))
                {
                    auxiliarNumeroVezes.Add(caracteristica.Nome, nrVezes + 1);
                }
            }

            return(auxiliarNumeroVezes);
        }
Esempio n. 5
0
        /// <summary>
        /// Propósito: Método Insertar de la clase de negocios. Este método inserta una fila nueva en la base de datos.
        /// </summary>
        /// <returns>True si tuvo éxito, sino genera una Exception. </returns>
        /// <remarks>
        /// Propiedades necesarias para este método:
        /// <UL>
        ///		 <LI>Fk_idProfesor</LI>
        ///		 <LI>Fk_idCurso</LI>
        ///		 <LI>Fk_idfranjaHoraria</LI>
        ///		 <LI>Preferencia</LI>
        ///		 <LI>Fk_idSede</LI>
        ///		 <LI>Fk_idPeriodo. May be SqlInt32.Null</LI>
        /// </UL>
        /// Propiedades actualizadas luego de una llamada exitosa a este método:
        /// <UL>
        ///		 <LI>IdPreferenciaCurso</LI>
        ///		 <LI>CodError</LI>
        /// </UL>
        /// </remarks>
        public override bool Insertar()
        {
            string operacion;

            //SeguridadSoapClient wsseg = new SeguridadSoapClient();
            try
            {
                //Construir aqui el string a guardar en la bitacora.
                operacion = "Insertar cPreferenciasCurso;"
                            + "Fk_idProfesor:" + Fk_idProfesor.ToString() + ";"
                            + "Fk_idCurso:" + Fk_idCurso.ToString() + ";"
                            + "Fk_idfranjaHoraria:" + Fk_idfranjaHoraria.ToString() + ";"
                            + "Preferencia:" + Preferencia.ToString() + ";"
                            + "Fk_idSede:" + Fk_idSede.ToString() + ";"
                            + "Fk_idPeriodo:" + Fk_idPeriodo.ToString() + ";";
                //wsseg.BitacoraRegistrarUso(_COD_APLICACIONBitacora, _COD_FUNCIONALIDADBitacora, _COD_SEDEBitacora, eTipoEventoBitacora.UsoFuncionalidad, _ID_USUARIOBitacora,operacion);
                return(base.Insertar());
            }
            catch (Exception ex)
            {
                //Construir el string a guardar en la bitácora en caso de error.
                operacion = "Error Insertar cPreferenciasCurso;" + ex.Message;
                //wsseg.BitacoraRegistrarUso(_COD_APLICACIONBitacora, _COD_FUNCIONALIDADBitacora, _COD_SEDEBitacora, eTipoEventoBitacora.Error, _ID_USUARIOBitacora,operacion);
                throw ex;
            }
        }
        public IHttpActionResult PostPreferencia(Preferencia preferencia)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.Preferencia.Add(preferencia);

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateException)
            {
                if (PreferenciaExists(preferencia.id_preferencia))
                {
                    return(Conflict());
                }
                else
                {
                    throw;
                }
            }

            return(CreatedAtRoute("DefaultApi", new { id = preferencia.id_preferencia }, preferencia));
        }
Esempio n. 7
0
 public void CargarPreferencias()
 {
     listPreferencias.Items.Clear();
     foreach (Preferencia pref in Preferencia.ListaPreferencias(user))
     {
         listPreferencias.Items.Add(pref);
     }
 }
Esempio n. 8
0
        public Preferencia RemoverPreferencia(int id)
        {
            Preferencia preferencia = ObterPreferencia(id);

            contexto.Preferencias.Remove(preferencia);
            contexto.SaveChanges();
            return(preferencia);
        }
Esempio n. 9
0
        int mod;    //0 si Viendo; 1 si Modificando

        public VerPreferencia(Preferencia p, Usuario usr)
        {
            InitializeComponent();
            this.p   = p;
            this.usr = usr;

            modificarInvisible();
            visualizarVisible();
        }
Esempio n. 10
0
        public void GravarInteresse(Evento evento)
        {
            Preferencia preferencia = new Preferencia();

            preferencia.UsuarioId = (string)HttpContext.Current.Session["UserId"];
            preferencia.EventoId  = evento.EventoId;
            contexto.Preferencias.Add(preferencia);
            contexto.SaveChanges();
        }
        public int Delete(int id)
        {
            pre = new TB_PREFERENCIA();

            pre = (TB_PREFERENCIA) new Preferencia().ProducarPeloId(id).Objeto[0];

            int retorno = new Preferencia().Remover(pre).CodigoErro;

            return(retorno);
        }
        public IHttpActionResult GetPreferencia(int id)
        {
            Preferencia preferencia = db.Preferencia.Find(id);

            if (preferencia == null)
            {
                return(NotFound());
            }

            return(Ok(preferencia));
        }
        public void getPreferencias()
        {
            Preferencia pref = new Preferencia("DEFAULT DATABASE", "One DB");

            dao.Adicionar(pref);

            Dictionary <string, Preferencia> dict = dao.getPreferenciasDict();

            Assert.IsNotNull(dict);

            Assert.AreEqual("One DB", dict["DEFAULT DATABASE"].Value);
        }
        public IHttpActionResult DeletePreferencia(int id)
        {
            Preferencia preferencia = db.Preferencia.Find(id);

            if (preferencia == null)
            {
                return(NotFound());
            }

            db.Preferencia.Remove(preferencia);
            db.SaveChanges();

            return(Ok(preferencia));
        }
Esempio n. 15
0
 private void bBorrarPref_Click(object sender, EventArgs e)
 {
     try
     {
         Preferencia p = (Preferencia)listPreferencias.SelectedItem;
         listPreferencias.Items.Remove(p);
         p.RemovePreferencia();
         user.RemovePrefrencia(p);
         CargarPreferencias();
     }
     catch (NullReferenceException)
     {
         MessageBox.Show("Debe seleccionar una Preferencia", "ATENCIÓN", MessageBoxButtons.OK);
     }
 }
Esempio n. 16
0
 /// <summary>
 /// Funcion encargada de guardar un nuevo registro en la base de datos
 /// </summary>
 /// <param name="nPreferencia">variable de tipo modelo Preferencia</param>
 public static void RegistrarNuevaPreferencia(Preferencia nPreferencia)
 {
     try
     {
         using (var ctx = new DataModel())
         {
             ctx.Preferencias.Add(nPreferencia);
             ctx.SaveChanges();
         }
     }
     catch (Exception)
     {
         throw;
     }
 }
Esempio n. 17
0
 /// <summary>
 /// Funcion encargada de modificar un registro de la base de datos
 /// </summary>
 /// <param name="nPreferencia">variable de tipo modelo Preferencia</param>
 public static void Modificar(Preferencia nPreferencia)
 {
     try
     {
         using (var ctx = new DataModel())
         {
             ctx.Preferencias.Attach(nPreferencia);
             ctx.Entry(nPreferencia).State = EntityState.Modified;
             ctx.SaveChanges();
         }
     }
     catch (Exception)
     {
         throw;
     }
 }
Esempio n. 18
0
        public ActionResult preferenciaFabricante(int idFabricante, int idUsuario)
        {
            var preferencia = DBConfig.Instance.PreferenciaRepository.PrimeiraPorMarca(idFabricante);

            if (preferencia == null)
            {
                var usu = DBConfig.Instance.UsuarioRepository.PrimeiroUsuario(idUsuario);
                var fab = DBConfig.Instance.FabricanteRepository.PrimeiroFabricante(idFabricante);

                var pref = new Preferencia();
                pref.Usuario    = usu;
                pref.Fabricante = fab;

                DBConfig.Instance.PreferenciaRepository.Salvar(pref);
            }

            return(RedirectToAction("Index", "Home"));
        }
Esempio n. 19
0
        public VerCompatibilidad(Preferencia pref, Actividad act, Usuario user)
        {
            InitializeComponent();
            this.Location            = System.Windows.Forms.Cursor.Position;
            this.gradientPanel1.Size = this.Size;
            this.pref = pref;
            this.act  = act;
            this.user = user;

            CompararTipoActividad();
            CompararGrado();
            CompararAsignatura();
            CompararCompetencias();
            CompararTurno();
            CompararHoras();
            CompararTipoTrabajo();
            CompararAmbitoTrabajo();
        }
Esempio n. 20
0
        public ActionResult preferenciaCategoria(int idCategoria, int idUsuario)
        {
            var preferencia = DBConfig.Instance.PreferenciaRepository.PrimeiraPorCategoria(idCategoria);

            if (preferencia == null)
            {
                var usu = DBConfig.Instance.UsuarioRepository.PrimeiroUsuario(idUsuario);
                var cat = DBConfig.Instance.CategoriaRepository.PrimeiraCategoria(idCategoria);

                var pref = new Preferencia();
                pref.Usuario   = usu;
                pref.Categoria = cat;

                DBConfig.Instance.PreferenciaRepository.Salvar(pref);
            }

            return(RedirectToAction("Index", "Home"));
        }
Esempio n. 21
0
        /// <summary>
        /// Funcion encargada de eliminar un registro de la base de datos mediante una id
        /// </summary>
        /// <param name="pkPreferencia">variable de tipo entera</param>
        public static void Eliminar(int pkPreferencia)
        {
            try
            {
                using (var ctx = new DataModel())
                {
                    Preferencia nPreferencia = ManejoPreferencia.getById(pkPreferencia);
                    nPreferencia.bStatus = false;

                    ctx.Entry(nPreferencia).State = EntityState.Modified;
                    ctx.SaveChanges();
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
Esempio n. 22
0
        /*--------------------------------------------------------------------
        * Metodo auxiliar no processo de Login. Se os dados de acesso/login
        * forem corretos para um cliente, devolve as informações relativas ao
        * utilizador Cliente
        * TESTADO E FUNCIONAL
        *  --------------------------------------------------------------------*/
        private Utilizador GetDadosCliente(string username, string password)
        {
            int           idCli, idade;            string nome, usr, psw, email;
            StringBuilder s        = new StringBuilder();
            SqlDataReader myReader = null;

            try
            {
                myConnection.Open();

                SqlCommand myCommand = new SqlCommand("SELECT * FROM Cliente " +
                                                      "WHERE Cliente.Username = '******' " +
                                                      "AND Cliente.Password = '******'; ",
                                                      myConnection);

                myReader = myCommand.ExecuteReader();
                if (myReader.Read()) //Se encontrou na table cliente
                {
                    idCli = Convert.ToInt32(myReader["idCliente"].ToString());
                    nome  = myReader["Nome"].ToString();
                    idade = Convert.ToInt32(myReader["Idade"].ToString());
                    usr   = myReader["Username"].ToString();
                    psw   = myReader["Password"].ToString();
                    email = myReader["Email"].ToString();
                    myConnection.Close();  //Evitar conflitos com proximas conexões
                    Preferencia        p   = DAOpreferencias.GetDadosPreferencia(username);
                    List <Restaurante> fav = DAOpreferencias.GetDadosFavoritos(username);
                    List <Visita>      vis = DAOpreferencias.GetDadosVisitados(username);

                    return(new Cliente(idCli, nome, idade, usr, psw, email, p, fav, vis));
                }
            }
            catch (Exception e) { s.Append(e); }
            finally
            {
                //Evitar conflitos com proximas conexões
                myReader.Close();
                myConnection.Close();
            }

            return(null);
        }
Esempio n. 23
0
        public Preferencia ToDespreferencia()
        {
            List <Caracteristica> caracteristicas =
                Despreferencias?
                .Select(p => new Caracteristica(p.Data, p.Caracteristica))                 // map
                .ToList();

            if (caracteristicas == null)
            {
                caracteristicas = new List <Caracteristica>();
            }

            Preferencia preferencia = new Preferencia()
            {
                Id              = IdPreferencia,
                Petisco         = this.Petisco.ToPetisco(),
                Caracteristicas = caracteristicas
            };

            return(preferencia);
        }
        public int Put(int id, [FromBody] TB_PREFERENCIA value)
        {
            int retorno = new Preferencia().Atualizar(value).CodigoErro;

            return(retorno);
        }
Esempio n. 25
0
        private void bConfirmar_Click(object sender, EventArgs e)
        {
            Preferencia p = null;

            try
            {
                /*
                 *  CONTROL DE ERRORES
                 */
                if (textNombreComp.Text.Trim().Equals(""))
                {
                    throw new Exception("Nombre Preferencia no puede estar vacío");
                }
                if (comboTipo.SelectedItem == null)
                {
                    throw new Exception("Tipo de Actividad no puede ser vacía");
                }
                if (comboTurno.SelectedItem == null)
                {
                    throw new Exception("");
                }
                if (comboTipoTrab.SelectedItem == null)
                {
                    throw new Exception("Tipo de Trabajo no puede ser vacía");
                }
                if (comboAmbitoTrab.SelectedItem == null)
                {
                    throw new Exception("Ambito de Trabajo no puede ser vacía");
                }

                Asignatura a = null;
                Grado      g = null;

                if (!comboAsig.Text.Trim().Equals(""))
                {
                    a = (Asignatura)comboAsig.SelectedItem;
                }
                if (!comboGrado.Text.Trim().Equals(""))
                {
                    g = (Grado)comboGrado.SelectedItem;
                }

                p = new Preferencia(textNombreComp.Text, user);
                if (!comboGrado.Text.Equals(""))
                {
                    p.Grado = g;
                }
                if (!comboAsig.Text.Equals(""))
                {
                    p.Asignatura = a;
                }

                TipoActividadE resTipo;
                TurnoE         resTurno;

                Enum.TryParse <TurnoE>(comboTurno.Text, true, out resTurno);
                if (!comboTurno.Text.Equals(""))
                {
                    p.Turno = resTurno;
                }

                Enum.TryParse <TipoActividadE>(comboTipo.Text, true, out resTipo);
                if (!comboTipo.Text.Equals(""))
                {
                    p.TipoActividad = resTipo;
                }

                //
                // NUEVO AMBITO TIPO
                //
                if (comboAmbitoTrab.SelectedItem.Equals(null))
                {
                    throw new Exception("Ámbito de Trabajo no puede ser Vacío");
                }
                else
                {
                    p.AmbitoTrabajo = (AmbitoTrabajo)comboAmbitoTrab.SelectedItem;
                }
                if (comboTipoTrab.SelectedItem.Equals(null))
                {
                    throw new Exception("Tipo de Trabajo no puede ser Vacío");
                }
                else
                {
                    p.TipoTrabajo = (TipoTrabajo)comboTipoTrab.SelectedItem;
                }

                p.HorasPosibles = decimal.ToInt32(numericUpDown.Value);

                foreach (Competencia c in listCompetencias.SelectedItems)
                {
                    p.AddCompetencia(c);
                }

                user.AddPreferencia(p);
                MessageBox.Show("Preferencia insertada con éxito");
                this.Close();
            }catch (Exception ex)
            {
                MessageBox.Show("Error: " + ex.Message);
                if (p != null)
                {
                    p.RemovePreferencia();
                }
            }
        }
Esempio n. 26
0
 /// <summary>
 /// Funcion encargada de guardar un nuevo registro en la base de datos
 /// </summary>
 /// <param name="nSucursal">variable de tipo modelo Sucursal</param>
 /// <param name="nEmpresa">variable de tipo modelo Empresa</param>
 /// <param name="nPreferencia">variable de tipo modelo Preferencia</param>
 /// <param name="nCertificado">variable de tipo modelo CErtificado</param>
 public static void RegistrarNuevaSucursal(Sucursal nSucursal, Empresa nEmpresa, Preferencia nPreferencia, Certificado nCertificado)
 {
     try
     {
         using (var ctx = new DataModel())
         {
             nSucursal.preferencia_id = nPreferencia.idPreferencia;
             nSucursal.empresa_id     = nEmpresa.idEmpresa;
             nSucursal.certificado_id = nCertificado.idCertificado;
             ctx.Sucursales.Add(nSucursal);
             ctx.SaveChanges();
         }
     }
     catch (Exception)
     {
         throw;
     }
 }
        public int Post([FromBody] TB_PREFERENCIA value)
        {
            int retorno = new Preferencia().Cadastrar(value).CodigoErro;

            return(retorno);
        }