private IEnumerable <CategoriaNotizia> RecuperaCategorieNotiziePrivate()
        {
            List <CategoriaNotizia> categorieNotizia = new List <CategoriaNotizia>();

            SqlServerExecuteObject sseo = null;
            SqlDataReader          dr   = null;

            string sSql = "SELECT CategoriaNotiziaID, Nome_IT, Nome_EN FROM dbo.TBL_CategorieNotizie;";

            sseo             = new SqlServerExecuteObject();
            sseo.CommandText = sSql;
            sseo.CommandType = CommandType.Text;

            dr = SqlProvider.ExecuteReaderObject(sseo);

            while (dr.Read())
            {
                CategoriaNotizia categoriaNotizia = RiempiIstanza(dr);
                categorieNotizia.Add(categoriaNotizia);
            }

            if (dr != null)
            {
                dr.Close();
                dr.Dispose();
            }

            return(categorieNotizia);
        }
        public ActionResult Edita(NotiziaEditaModel model)
        {
            ActionResult result  = null;
            Notizia      notizia = null;

            if (ModelState.IsValid)
            {
                int id = 0;
                CategoriaNotizia categoria = null;
                ContenutoService cs        = new ContenutoService();

                categoria = CategoriaNotiziaRepository.Instance.RecuperaCategoriaNotizia(model.CategoriaNotiziaID.Value);

                if (model.ID != 0)
                {
                    notizia                = NotiziaRepository.Instance.RecuperaNotizia(model.ID);
                    notizia.Categoria      = categoria;
                    notizia.ImmagineID     = model.ImmagineID.Value;
                    notizia.Data           = model.Data;
                    notizia.Titolo_IT      = model.Titolo_IT;
                    notizia.Titolo_EN      = model.Titolo_EN;
                    notizia.TitoloBreve_IT = model.TitoloBreve_IT;
                    notizia.TitoloBreve_EN = model.TitoloBreve_EN;
                    notizia.Abstract_IT    = model.Abstract_IT;
                    notizia.Abstract_EN    = model.Abstract_EN;
                    notizia.Testo_IT       = UrlUtility.VAHtmlReplaceRealUrls(model.Testo_IT);
                    notizia.Testo_EN       = UrlUtility.VAHtmlReplaceRealUrls(model.Testo_EN);
                    //notizia.Stato = model.StatoNotizia;
                }
                else
                {
                    notizia = cs.CreaNotizia(categoria, model.ImmagineID.Value, model.Data, model.Titolo_IT, model.Titolo_EN, model.TitoloBreve_IT, model.TitoloBreve_EN, model.Abstract_IT, model.Abstract_EN, model.Testo_IT, model.Testo_EN);
                }

                id = cs.SalvaNotizia(notizia);

                result = RedirectToAction("Edita", new { id = id });
            }
            else
            {
                if (model.ID != 0)
                {
                    notizia       = NotiziaRepository.Instance.RecuperaNotizia(model.ID);
                    model.Notizia = notizia;
                }
                model.CategorieSelectList = ModelUtils.CreaCategoriaNotiziaSelectList(true);
                model.ImmaginiSelectList  = ModelUtils.CreaImmaginiSelectList(true);
                model.StatiSelectList     = ModelUtils.CreaStatoNotiziaSelectList(false);

                result = View(model);
            }

            return(result);
        }
        private ActionResult ElencoNotizie(ComunicazioneNotizieModel model, CategoriaNotiziaEnum categoriaEnum)
        {
            int categoriaID            = (int)categoriaEnum;
            CategoriaNotizia categoria = CategoriaNotiziaRepository.Instance.RecuperaCategoriaNotizia(categoriaID);
            int totale = 0;

            List <Notizia> notizie = NotiziaRepository.Instance.RecuperaNotizie(CultureHelper.GetCurrentCultureShortName(), model.Testo, null, null, categoria.ID, true, StatoNotiziaEnum.Pubblicabile, model.IndiceInizio, model.IndiceInizio + model.DimensionePagina, out totale);

            model.Notizie         = notizie;
            model.Categoria       = categoria;
            model.TotaleRisultati = totale;

            switch (categoriaEnum)
            {
            case CategoriaNotiziaEnum.Nessuna:
                break;

            case CategoriaNotiziaEnum.EventiENotizie:
                model.ActionDettaglio = "DettaglioNotizia";
                model.ActionAttuale   = "EventiNotizie";
                break;

            case CategoriaNotiziaEnum.LaDirezioneInforma:
                model.ActionDettaglio = "DettaglioDirezione";
                model.ActionAttuale   = "DirezioneInforma";
                break;

            case CategoriaNotiziaEnum.AreaGiuridica:
                model.ActionDettaglio = "DettaglioAreaGiuridica";
                model.ActionAttuale   = "AreaGiuridica";
                break;

            case CategoriaNotiziaEnum.UltimiProvvedimenti:
                model.ActionDettaglio = "DettaglioUltimiProvvedimenti";
                model.ActionAttuale   = "UltimiProvvedimenti";
                break;

            default:
                break;
            }

            VoceMenu voce = VoceMenuRepository.Instance.RecuperaVoceMenu(model.ActionAttuale);

            model.VoceMenu = voce;

            return(View("NotizieElenco", model));
        }
        private CategoriaNotizia RiempiIstanza(SqlDataReader dr)
        {
            if (dr == null)
            {
                throw new ArgumentNullException("dr");
            }

            CategoriaNotizia categoriaNotizia = new CategoriaNotizia();

            categoriaNotizia.ID       = dr.GetInt32(0);
            categoriaNotizia._nome_IT = dr.GetString(1);
            categoriaNotizia._nome_EN = dr.GetString(2);

            categoriaNotizia.Enum = (CategoriaNotiziaEnum)categoriaNotizia.ID;

            return(categoriaNotizia);
        }
        public Notizia CreaNotizia(CategoriaNotizia categoria, int immagineID, DateTime data, string titolo_IT,
                                   string titolo_EN, string titoloBreve_IT, string titoloBreve_EN, string abstract_IT,
                                   string abstract_EN, string testo_IT, string testo_EN)
        {
            Notizia notizia = null;

            if (string.IsNullOrWhiteSpace(titolo_IT))
            {
                throw new ArgumentException("L'argomento non può essere null, vuoto o contenere solo spazi.", "titolo_IT");
            }


            if (categoria == null)
            {
                throw new ArgumentNullException("L'argomento non può essere null, vuoto o contenere solo spazi.", "categoria");
            }

            notizia                    = new Notizia();
            notizia.Pubblicata         = false;
            notizia.Stato              = StatoNotiziaEnum.Bozza;
            notizia.ID                 = 0;
            notizia.DataInserimento    = DateTime.Now;
            notizia.DataUltimaModifica = notizia.DataInserimento;

            notizia.Data           = data;
            notizia.Titolo_IT      = titolo_IT;
            notizia.Titolo_EN      = titolo_EN ?? "";
            notizia.TitoloBreve_IT = titoloBreve_IT ?? "";
            notizia.TitoloBreve_EN = titoloBreve_EN ?? "";
            notizia.Abstract_IT    = abstract_IT ?? "";
            notizia.Abstract_EN    = abstract_EN ?? "";
            notizia.Testo_IT       = testo_IT ?? "";
            notizia.Testo_EN       = testo_EN ?? "";
            notizia.Categoria      = categoria;
            notizia.ImmagineID     = immagineID;

            return(notizia);
        }
Ejemplo n.º 6
0
        public ActionResult EditaInEvidenza(WidgetInEvidenzaEditaModel model)
        {
            ActionResult result = null;
            Widget       widget = null;

            if (ModelState.IsValid)
            {
                int id = 0;
                CategoriaNotizia categoria = null;
                ContenutoService cs        = new ContenutoService();

                categoria = CategoriaNotiziaRepository.Instance.RecuperaCategoriaNotizia(model.EditaCategoriaNotiziaID.Value);

                if (model.ID != 0)
                {
                    widget         = WidgetRepository.Instance.RecuperaWidget(model.ID);
                    widget.Nome_IT = model.EditaNome.Trim();
                    widget.Nome_EN = model.EditaNome.Trim();
                }
                else
                {
                    widget         = cs.CreaWidget(model.EditaNome.Trim(), TipoWidget.InEvidenza);
                    widget.Nome_EN = widget.Nome_IT;
                }

                widget.Categoria = categoria;

                switch (widget.Categoria.Enum)
                {
                case CategoriaNotiziaEnum.Nessuna:
                    break;

                case CategoriaNotiziaEnum.EventiENotizie:
                    widget.VoceMenuID = 44;
                    break;

                case CategoriaNotiziaEnum.LaDirezioneInforma:
                    widget.VoceMenuID = 45;
                    break;

                case CategoriaNotiziaEnum.AreaGiuridica:
                    widget.VoceMenuID = 46;
                    break;

                default:
                    break;
                }

                widget.NotiziaID = model.EditaNotiziaInEvidenza;

                id = cs.SalvaWidget(widget);

                result = RedirectToAction("EditaInEvidenza", new { id = id });
            }
            else
            {
                if (model.ID != 0)
                {
                    widget       = WidgetRepository.Instance.RecuperaWidget(model.ID);
                    model.Widget = widget;
                }

                model.CategorieSelectList = ModelUtils.CreaCategoriaNotiziaSelectList(false);
                model.NotizieSelectList   = ModelUtils.CreaNotiziaSelectList(widget?.Categoria?.ID ?? 0);

                model.EditaNotiziaInEvidenza = widget?.NotiziaID;

                result = View(model);
            }

            return(result);
        }