private void ConstructObject(IDataReader dr_, enDebateAdvertisement enDebateAdvertisement_)
 {
     enDebateAdvertisement_.ID        = Convert.ToInt32(dr_["ID"]);
     enDebateAdvertisement_.DateTo    = Convert.ToDateTime(dr_["DateTo"]);
     enDebateAdvertisement_.DateFrom  = Convert.ToDateTime(dr_["DateFrom"]);
     enDebateAdvertisement_.TimeTo    = TimeSpan.Parse(dr_["TimeTo"].ToString());
     enDebateAdvertisement_.TimeFrom  = TimeSpan.Parse(dr_["TimeFrom"].ToString());
     enDebateAdvertisement_.CreatedOn = Convert.ToDateTime(dr_["CreatedOn"].ToString());
 }
        public ActionResult Index(enDebateAdvertisement enDebateAdvertisement_)
        {
            var objBLDebateAdvertisement = new blDebateAdvertisement(enDebateAdvertisement_);

            try
            {
                objBLDebateAdvertisement.Create();
            }
            catch (Exception ex)
            {
                return(RedirectToAction("error", "misc"));
            }
            return(RedirectToAction("list"));
        }
        public List <enDebateAdvertisement> ReadAll()
        {
            var listOfDebateAdvertisements = new List <enDebateAdvertisement>();

            using (IDataReader idr = base.Read(_enDebateAdvertisement.ID, _enDebateAdvertisement.GetByDate))
            {
                while (idr.Read())
                {
                    var objENDebateAdvertisement = new enDebateAdvertisement();
                    ConstructObject(idr, objENDebateAdvertisement);
                    listOfDebateAdvertisements.Add(objENDebateAdvertisement);
                }
            }
            return(listOfDebateAdvertisements);
        }
        public ActionResult List()
        {
            var objENDebateAdvertisement = new enDebateAdvertisement();
            var objBLDebateAdvertisement = new blDebateAdvertisement(objENDebateAdvertisement);
            List <enDebateAdvertisement> listOfDebateAdvertisements = new List <enDebateAdvertisement>();

            try
            {
                listOfDebateAdvertisements = objBLDebateAdvertisement.ReadAll();
            }
            catch (Exception ex)
            {
                return(RedirectToAction("error", "misc"));
            }

            return(View(listOfDebateAdvertisements));
        }
        public ActionResult Delete(int id)
        {
            var objENDebateAdvertisement = new enDebateAdvertisement()
            {
                ID = id
            };
            var objBLDebateAdvertisement = new blDebateAdvertisement(objENDebateAdvertisement);

            try
            {
                objBLDebateAdvertisement.Delete();
            }
            catch
            {
                return(RedirectToAction("error", "misc"));
            }
            return(RedirectToAction("list"));
        }
        public ActionResult Update(int id)
        {
            var objENDebateAdvertisement = new enDebateAdvertisement()
            {
                ID = id
            };
            var objBLDebateAdvertisement = new blDebateAdvertisement(objENDebateAdvertisement);
            List <enDebateAdvertisement> listOfDebateAdvertisements = new List <enDebateAdvertisement>();

            try
            {
                objBLDebateAdvertisement.Read();
            }
            catch
            {
                RedirectToAction("error", "misc");
            }
            return(View("index", objENDebateAdvertisement));
        }
        public ActionResult Update(int id, enDebateAdvertisement enDebateAdvertisement_)
        {
            var objENDebateAdvertisement = new enDebateAdvertisement()
            {
                ID = id
            };
            var objBLDebateAdvertisement = new blDebateAdvertisement(objENDebateAdvertisement);

            enDebateAdvertisement_.CreatedOn = objENDebateAdvertisement.CreatedOn;
            objBLDebateAdvertisement         = new blDebateAdvertisement(enDebateAdvertisement_);
            try
            {
                objBLDebateAdvertisement.Update();
            }
            catch
            {
                RedirectToAction("error", "misc");
            }

            return(RedirectToAction("List"));
        }
 public blDebateAdvertisement(enDebateAdvertisement enDebateAdvertisement_)
 {
     this._enDebateAdvertisement = enDebateAdvertisement_;
 }
 public dlDebateAdvertisement(enDebateAdvertisement enDebateAdvertisement_)
     : base("DebateAdvertisement")
 {
     this._enDebateAdvertisement = enDebateAdvertisement_;
 }
        public ActionResult DebateRoom(int debateID)
        {
            var objENDebate = new enDebate()
            {
                ID = debateID
            };
            var objBLDebate = new blDebate(objENDebate);

            try
            {
                objBLDebate.Read();
            }
            catch (Exception ex)
            {
                Log.Error("Hangout.UI.DebateController.DebateRoom() Error while Read() Debate  Exception:-" + ex.ToString());
            }
            ViewBag.DebateTopic       = objENDebate.Topic;
            ViewBag.DebateDescription = objENDebate.Description;

            var objENComment = new enComment()
            {
                Debate_ID = debateID
            };
            var objBLComment = new blComment(objENComment);
            List <enComment> listOfComments = new List <enComment>();

            try
            {
                listOfComments = objBLComment.ReadAllAndAggregate(null, null, typeof(enUser), typeof(enLikeCounter));
            }
            catch (Exception ex)
            {
                Log.Error("Hangout.UI.DebateController.DebateRoom() Error while Read() Comment  Exception:-" + ex.ToString());
            }

            if (listOfComments.Count > 0)
            {
                List <enComment> listOfDistinctID = listOfComments.DistinctBy(x => x.User_ID).ToList();
                ViewBag.DistinctID = listOfDistinctID;
            }
            var objCommentModel = new CommentModel();

            objCommentModel.listOfComments = listOfComments.OrderBy(x => x.ID).ToList();


            ViewBag.ForListOfComments     = listOfComments.FindAll(x => x.Type == (int)CommentType.FOR).OrderBy(x => x.InsertedOn);
            ViewBag.AgainstListOfComments = listOfComments.FindAll(x => x.Type == (int)CommentType.AGAINST).OrderBy(x => x.InsertedOn);

            objCommentModel.Comments_ = objENComment;
            ViewBag.UserID            = CookieDetail.UserID;

            var objENDebateAdvertisement = new enDebateAdvertisement()
            {
                GetByDate = 1
            };
            var objBLDebateAdvertisement = new blDebateAdvertisement(objENDebateAdvertisement);
            List <enDebateAdvertisement> listOfDebaetAdvertisements = new List <enDebateAdvertisement>();

            try
            {
                listOfDebaetAdvertisements = objBLDebateAdvertisement.ReadAllAndAggregate(typeof(enDebateAdvertisementImage));
            }
            catch (Exception ex)
            {
            }

            var count = listOfDebaetAdvertisements.FirstOrDefault().ListOfDebateAdvertisementImage_.Count;

            if (count > 0)
            {
                var half            = count / 2;
                var secondlistIndex = count - half;
                ViewBag.LeftDebateAdvertisementImage  = listOfDebaetAdvertisements.FirstOrDefault().ListOfDebateAdvertisementImage_.GetRange(0, half);
                ViewBag.RightDebateAdvertisementImage = listOfDebaetAdvertisements.FirstOrDefault().ListOfDebateAdvertisementImage_.GetRange(half, secondlistIndex);
            }



            return(View(objCommentModel));
        }