public ResponseMessageModel Upsert(Channel model)
        {
            if (model.ChannelId > 0)
            {
                var modelOld = _db.Channel.First(e => e.ChannelId == model.ChannelId);
                var chSched = modelOld.ChannelSchedule.First();
                modelOld.Name = model.Name;
                modelOld.Timestamp = DateTime.Now;
                chSched.MediaId = model.MediaId;
                chSched.Timestamp = DateTime.Now;
            }
            else
            {
                if (FillInfoChannel(model) == false)
                {
                    return new ResponseMessageModel
                    {
                        HasError = true,
                        Title = ResShared.TITLE_REGISTER_FAILED,
                        Message = ResShared.ERROR_INVALID_MODEL
                    };
                }
                _db.Channel.Add(model);
            }

            _db.SaveChanges();

            return new ResponseMessageModel
            {
                HasError = false,
                Title = ResShared.TITLE_REGISTER_SUCCESS,
                Message = ResShared.INFO_REGISTER_SAVED
            };
        }
        public ActionResult DoUpsert(Channel model)
        {
            try
            {
                if (ModelState.IsValid == false)
                {
                    return Json(new ResponseMessageModel
                    {
                        HasError = true,
                        Title = ResShared.TITLE_REGISTER_FAILED,
                        Message = ResShared.ERROR_INVALID_MODEL
                    });
                }

                var service = new ChannelService(Db);
                model.UserId = User.Identity.GetUserId();
                var respMsg = service.Upsert(model);
                return Json(respMsg);
            }
            catch (Exception ex)
            {
                SharedLogger.LogError(ex, model.Name, model.ChannelId, model.UserId);
                return Json(new ResponseMessageModel
                {
                    HasError = true,
                    Title = ResShared.TITLE_REGISTER_FAILED,
                    Message = ResShared.ERROR_UNKOWN
                });
            }
        }
        public bool FillInfoChannel(Channel model)
        {
            try
            {
                model.ChannelSchedule = new List<ChannelSchedule>
                {
                    new ChannelSchedule
                    {
                        MediaId = model.MediaId,
                        StartTime = null,
                        EndTime = null,
                        Day = null,
                        Year = null,
                        Timestamp = DateTime.Now
                    }
                };

                model.Timestamp = DateTime.Now;
                return true;
            }
            catch (Exception ex)
            {
                SharedLogger.LogError(ex, model.Name, model.ChannelId, model.UserId);
                return false;
            }
        }
        public ActionResult Upsert(int? id)
        {
            Channel model;

            try
            {
                var lstMedias = CatSharedRepository.GetLstMedias(Db);
                if (id.HasValue)
                {
                    model = Db.Channel.Single(e => e.ChannelId == id.Value);
                    model.MediaId = model.ChannelSchedule.First().Media.MediaId;
                }
                else
                {
                    model  = new Channel
                    {
                        ChannelId = EntityConstants.NULL_VALUE,
                        MediaId = lstMedias.Select(e => e.IdLg).First()
                    };
                }

                ViewBag.LstMedias = new SelectList(lstMedias, "IdLg", "Value", model.MediaId);

            }
            catch (Exception ex)
            {
                SharedLogger.LogError(ex);
                return new HttpStatusCodeResult(HttpStatusCode.InternalServerError);
            }
            return View(model);
        }