Example #1
0
        // PUT /tbNews/token/
        public HttpResponseMessage Put(string token, [FromBody] tbNews param)
        {
            tbLogAcessoUsuario log = new tbLogAcessoUsuario();

            try
            {
                log = Bibliotecas.LogAcaoUsuario.New(token, JsonConvert.SerializeObject(param), "Put");

                HttpResponseMessage retorno = new HttpResponseMessage();
                if (Permissoes.Autenticado(token))
                {
                    GatewayTbNews.Update(token, param);
                    log.codResposta = (int)HttpStatusCode.OK;
                    Bibliotecas.LogAcaoUsuario.Save(log);
                    return(Request.CreateResponse(HttpStatusCode.OK));
                }
                else
                {
                    log.codResposta = (int)HttpStatusCode.Unauthorized;
                    Bibliotecas.LogAcaoUsuario.Save(log);
                    return(Request.CreateResponse(HttpStatusCode.Unauthorized));
                }
            }
            catch (Exception e)
            {
                log.codResposta = (int)HttpStatusCode.InternalServerError;
                log.msgErro     = e.Message;
                Bibliotecas.LogAcaoUsuario.Save(log);
                throw new HttpResponseException(HttpStatusCode.InternalServerError);
            }
        }
Example #2
0
        /// <summary>
        /// Altera tbNews
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public static void Update(string token, tbNews param)
        {
            try
            {
                // Atualiza o contexto
                ((IObjectContextAdapter)_db).ObjectContext.Refresh(RefreshMode.StoreWins, _db.ChangeTracker.Entries().Select(c => c.Entity));

                tbNews value = _db.tbNewss
                               .Where(e => e.idNews.Equals(param.idNews))
                               .First <tbNews>();

                // OBSERVAÇÂO: VERIFICAR SE EXISTE ALTERAÇÃO NO PARAMETROS


                //if (param.idNews != null && param.idNews != value.idNews)
                //    value.idNews = param.idNews;
                if (param.dsNews != null && param.dsNews != value.dsNews)
                {
                    value.dsNews = param.dsNews;
                }
                if (param.dtNews.Year > 1900 && param.dtNews != value.dtNews)
                {
                    value.dtNews = param.dtNews;
                }
                if (param.cdEmpresaGrupo != null && param.cdEmpresaGrupo != value.cdEmpresaGrupo)
                {
                    value.cdEmpresaGrupo = param.cdEmpresaGrupo;
                }
                if (param.cdCatalogo != 0 && param.cdCatalogo != value.cdCatalogo)
                {
                    value.cdCatalogo = param.cdCatalogo;
                }
                if (param.cdCanal != 0 && param.cdCanal != value.cdCanal)
                {
                    value.cdCanal = param.cdCanal;
                }
                if (param.dsReporter != null && param.dsReporter != value.dsReporter)
                {
                    value.dsReporter = param.dsReporter;
                }
                if (param.dtEnvio != null && param.dtEnvio != value.dtEnvio)
                {
                    value.dtEnvio = param.dtEnvio;
                }
                _db.SaveChanges();
            }
            catch (Exception e)
            {
                if (e is DbEntityValidationException)
                {
                    string erro = MensagemErro.getMensagemErro((DbEntityValidationException)e);
                    throw new Exception(erro.Equals("") ? "Falha ao alterar TbNews" : erro);
                }
                throw new Exception(e.InnerException == null ? e.Message : e.InnerException.InnerException == null ? e.InnerException.Message : e.InnerException.InnerException.Message);
            }
        }
Example #3
0
        //
        // GET: /News/Details/5

        public ActionResult Details(int id = 0)
        {
            tbNews tbnews = db.tbNews.Find(id);

            if (tbnews == null)
            {
                return(HttpNotFound());
            }
            return(View(tbnews));
        }
Example #4
0
        public ActionResult DeleteConfirmed(int id)
        {
            tbNews tbnews = db.tbNews.Find(id);

            tbnews.Is_Delete       = true;
            db.Entry(tbnews).State = EntityState.Modified;
            db.SaveChanges();
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
Example #5
0
 public ActionResult Edit(tbNews tbnews)
 {
     if (ModelState.IsValid)
     {
         tbnews.Release_Time    = DateTime.Now;
         db.Entry(tbnews).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(tbnews));
 }
Example #6
0
        public ActionResult Create(tbNews tbnews)
        {
            if (ModelState.IsValid)
            {
                tbnews.Release_Time = DateTime.Now;
                db.tbNews.Add(tbnews);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(tbnews));
        }
Example #7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="idNews"></param>
        /// <returns></returns>
        public static List <int> getIdUsersFromNews(tbNews noticias)
        {
            List <int> ids = new List <int>();

            using (var _db = new painel_taxservices_dbContext())
            {
                ids = _db.webpages_Users
                      .Where(u => u.tbAssinantes
                             .Where(c => c.tbCatalogo.tbNews
                                    .Where(n => n.idNews == noticias.idNews).Count() > 0)
                             .Count() > 0)
                      .Where(u => noticias.cdEmpresaGrupo != null ? u.id_grupo == noticias.cdEmpresaGrupo.Value : true)
                      .Select(u => u.id_users)
                      .ToList <int>();
            }
            return(ids);
        }
Example #8
0
        /// <summary>
        /// Adiciona nova TbNews
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public static Int32 Add(string token, tbNews param)
        {
            try
            {
                // Atualiza o contexto
                ((IObjectContextAdapter)_db).ObjectContext.Refresh(RefreshMode.StoreWins, _db.ChangeTracker.Entries().Select(c => c.Entity));

                _db.tbNewss.Add(param);
                _db.SaveChanges();
                return(param.idNews);
            }
            catch (Exception e)
            {
                if (e is DbEntityValidationException)
                {
                    string erro = MensagemErro.getMensagemErro((DbEntityValidationException)e);
                    throw new Exception(erro.Equals("") ? "Falha ao salvar TbNews" : erro);
                }
                throw new Exception(e.InnerException == null ? e.Message : e.InnerException.InnerException == null ? e.InnerException.Message : e.InnerException.InnerException.Message);
            }
        }
Example #9
0
 public IActionResult Create(tbNews News)
 {
     try
     {
         if (ModelState.IsValid)
         {
             context.tbNews.Add(News);
             context.SaveChanges();
             return(RedirectToAction("Index", "tbNews"));
         }
         else
         {
             ViewBag.Msg = "Fail...";
         }
     }
     catch (Exception e)
     {
         ViewBag.Msg = e.Message;
     }
     return(View());
 }
Example #10
0
        /// <summary>
        /// Get TbDispositivoUsuario/TbDispositivoUsuario
        /// </summary>
        /// <param name="colecao"></param>
        /// <param name="campo"></param>
        /// <param name="orderby"></param>
        /// <param name="pageSize"></param>
        /// <param name="pageNumber"></param>
        /// <param name="queryString"></param>
        /// <returns></returns>
        private static IQueryable <tbDispositivoUsuario> getQuery(int colecao, int campo, int orderby, int pageSize, int pageNumber, Dictionary <string, string> queryString)
        {
            // DEFINE A QUERY PRINCIPAL
            var entity = _db.tbDispositivoUsuarios.AsQueryable();

            #region WHERE - ADICIONA OS FILTROS A QUERY

            // ADICIONA OS FILTROS A QUERY
            foreach (var item in queryString)
            {
                int    key        = Convert.ToInt16(item.Key);
                CAMPOS filtroEnum = (CAMPOS)key;
                switch (filtroEnum)
                {
                case CAMPOS.IDDISPOSITIVOUSUARIO:
                    Int32 idDispositivoUsuario = Convert.ToInt32(item.Value);
                    entity = entity.Where(e => e.idDispositivoUsuario.Equals(idDispositivoUsuario)).AsQueryable <tbDispositivoUsuario>();
                    break;

                case CAMPOS.IDUSER:
                    Int32 idUser = Convert.ToInt32(item.Value);
                    entity = entity.Where(e => e.idUser.Equals(idUser)).AsQueryable <tbDispositivoUsuario>();
                    break;

                case CAMPOS.DSPLATAFORMA:
                    string dsPlataforma = Convert.ToString(item.Value);
                    entity = entity.Where(e => e.dsPlataforma.Equals(dsPlataforma)).AsQueryable <tbDispositivoUsuario>();
                    break;

                case CAMPOS.DSMODELO:
                    string dsModelo = Convert.ToString(item.Value);
                    entity = entity.Where(e => e.dsModelo.Equals(dsModelo)).AsQueryable <tbDispositivoUsuario>();
                    break;

                case CAMPOS.DSVERSAO:
                    string dsVersao = Convert.ToString(item.Value);
                    entity = entity.Where(e => e.dsVersao.Equals(dsVersao)).AsQueryable <tbDispositivoUsuario>();
                    break;

                case CAMPOS.IDIONIC:
                    string idIONIC = Convert.ToString(item.Value);
                    entity = entity.Where(e => e.idIONIC.Equals(idIONIC)).AsQueryable <tbDispositivoUsuario>();
                    break;

                case CAMPOS.IDUSERIONIC:
                    string idUserIONIC = Convert.ToString(item.Value);
                    entity = entity.Where(e => e.idUserIONIC.Equals(idUserIONIC)).AsQueryable <tbDispositivoUsuario>();
                    break;

                case CAMPOS.CDTOKENVALIDO:
                    string cdTokenValido = Convert.ToString(item.Value);
                    entity = entity.Where(e => e.cdTokenValido.Equals(cdTokenValido)).AsQueryable <tbDispositivoUsuario>();
                    break;

                case CAMPOS.TMLARGURA:
                    short tmLargura = short.Parse(item.Value);
                    entity = entity.Where(e => e.tmLargura.Equals(tmLargura)).AsQueryable <tbDispositivoUsuario>();
                    break;

                case CAMPOS.TMALTURA:
                    short tmAltura = short.Parse(item.Value);
                    entity = entity.Where(e => e.tmAltura.Equals(tmAltura)).AsQueryable <tbDispositivoUsuario>();
                    break;


                // RELACIONAMENTOS
                case CAMPOS.IDNEWS:
                    Int32  idNews  = Convert.ToInt32(item.Value);
                    tbNews noticia = _db.tbNewss.Where(n => n.idNews == idNews).FirstOrDefault();
                    if (noticia == null)
                    {
                        continue;
                    }
                    List <int> ids = iMessenger.getIdUsersFromNews(noticia);

                    List <int> listFilter = _db.tbDispositivoUsuarios
                                            .GroupBy(e => new { e.idUser })
                                            .Select(e => e.Max(l => l.idDispositivoUsuario)
                                                    ).ToList <int>();
                    entity = entity
                             .Where(e => listFilter.Contains(e.idDispositivoUsuario))
                             .Where(e => ids.Contains(e.idUser))
                             .AsQueryable <tbDispositivoUsuario>();
                    break;
                }
            }
            #endregion

            #region ORDER BY - ADICIONA A ORDENAÇÃO A QUERY
            // ADICIONA A ORDENAÇÃO A QUERY
            CAMPOS filtro = (CAMPOS)campo;
            switch (filtro)
            {
            case CAMPOS.IDDISPOSITIVOUSUARIO:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.idDispositivoUsuario).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.idDispositivoUsuario).AsQueryable <tbDispositivoUsuario>();
                }
                break;

            case CAMPOS.IDUSER:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.idUser).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.idUser).AsQueryable <tbDispositivoUsuario>();
                }
                break;

            case CAMPOS.DSPLATAFORMA:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.dsPlataforma).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.dsPlataforma).AsQueryable <tbDispositivoUsuario>();
                }
                break;

            case CAMPOS.DSMODELO:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.dsModelo).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.dsModelo).AsQueryable <tbDispositivoUsuario>();
                }
                break;

            case CAMPOS.DSVERSAO:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.dsVersao).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.dsVersao).AsQueryable <tbDispositivoUsuario>();
                }
                break;

            case CAMPOS.IDIONIC:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.idIONIC).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.idIONIC).AsQueryable <tbDispositivoUsuario>();
                }
                break;

            case CAMPOS.IDUSERIONIC:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.idUserIONIC).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.idUserIONIC).AsQueryable <tbDispositivoUsuario>();
                }
                break;

            case CAMPOS.CDTOKENVALIDO:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.cdTokenValido).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.cdTokenValido).AsQueryable <tbDispositivoUsuario>();
                }
                break;

            case CAMPOS.TMLARGURA:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.tmLargura).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.tmLargura).AsQueryable <tbDispositivoUsuario>();
                }
                break;

            case CAMPOS.TMALTURA:
                if (orderby == 0)
                {
                    entity = entity.OrderBy(e => e.tmAltura).AsQueryable <tbDispositivoUsuario>();
                }
                else
                {
                    entity = entity.OrderByDescending(e => e.tmAltura).AsQueryable <tbDispositivoUsuario>();
                }
                break;
            }
            #endregion

            return(entity);
        }