/// <summary>
        ///
        /// </summary>
        /// <param name="id">Main Id</param>
        /// <returns></returns>
        public ActionResult Restart(int?id)
        {
            if (id.HasValue && MainObject.CheckUserHasWriteAccess(id.Value))
            {
                MainObject.GetMain(id.Value)?.ReStart();
            }

            return(RedirectToAction("Index", new { id }));
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public ActionResult ConferenceSave(ConferenceModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();
            }

            return(null);
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public ActionResult AbstractSave(AbstractModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();
            }

            return(null);
        }
        public ActionResult MarkCompleted(int?id)
        {
            if (id.HasValue && MainObject.CheckUserHasWriteAccess(id.Value))
            {
                MainObject.GetMain(id.Value)?.MarkReviewComplete();
            }

            return(RedirectToAction("Index", new { id }));
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public ActionResult AddContact(ContactModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();

                return(PartialView("Partials/_contactList", ContactObject.GetContacts(model.MainId)));
            }

            return(null);
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public JsonResult AddAttachment(AttachmentModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();

                return(Json(model.AttachmentId));
            }

            return(null);
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public ActionResult AddIntellectual(IntellectualModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();

                return(PartialView("Partials/_intellectualList", IntellectualPropertyObject.GetIntellectualProperties(model.MainId)));
            }

            return(null);
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public ActionResult AddAuthor(AuthorModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();

                return(GetAuthorListPartial(model.MainId));
            }

            return(null);
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public ActionResult AddSponsor(MetadataModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();

                return(PartialView("Partials/_sponsorOrgList", MetaDataObject.GetMetaDatas(model.MainId, MetaDataTypeEnum.SponsoringOrgs)));
            }

            return(null);
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public ActionResult AddFunding(FundingModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();

                return(PartialView("Partials/_fundingList", FundingObject.GetFundings(model.MainId)));
            }

            return(null);
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public ActionResult AddCoreCapabilities(MetadataModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();

                return(PartialView("Partials/_coreCapabilitiesList", MetaDataObject.GetMetaDatas(model.MainId, MetaDataTypeEnum.CoreCapabilities)));
            }

            return(null);
        }
        public ActionResult FollowOn(int?id)
        {
            if (id.HasValue && MainObject.CheckUserHasWriteAccess(id.Value))
            {
                MainObject.FollowOn(id.Value);

                return(RedirectToAction("Index", new { id }));
            }

            return(RedirectToAction("Index", "Home"));
        }
        [HttpPost]/*, ValidateAntiForgeryToken]*/
        public ActionResult AddReviewer(ReviewerModel model)
        {
            if (ModelState.IsValid && MainObject.CheckUserHasWriteAccess(model.MainId))
            {
                model.Save();

                return(GetReviewersList(model.MainId));
            }

            return(null);
        }
        public ActionResult CreateRevision(int?id)
        {
            if (id.HasValue && MainObject.CheckUserHasWriteAccess(id.Value))
            {
                int?newId = MainObject.CreateRevision(id.Value);
                if (newId.HasValue)
                {
                    return(RedirectToAction("Index", new { id = newId }));
                }
            }

            return(RedirectToAction("Index", "Home"));
        }
        public JsonResult AddContactToAuthor(int?id)
        {
            string title   = "Error adding Contact as Author";
            string message = "Unable to determain the Contact.";
            bool   isAdded = false;

            if (id.HasValue)
            {
                var contact = ContactObject.GetContact(id.Value);
                if (contact != null && MainObject.CheckUserHasWriteAccess(contact.MainId))
                {
                    isAdded = contact.SaveAsAuthor(ref title, ref message);
                }
            }

            return(Json(new{ title, message, isAdded }));
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="id">Attachment Id</param>
        /// <returns></returns>
        public ActionResult DeleteAttachment(int?id)
        {
            int mid = 0;

            if (id.HasValue)
            {
                var asa = AttachmentObject.GetAttachment(id.Value);
                if (asa != null)
                {
                    mid = asa.MainId;
                    if (MainObject.CheckUserHasWriteAccess(mid))
                    {
                        asa.Delete();
                    }
                }
            }

            return(GetAttachments(mid));
        }
        public ActionResult RemoveContact(int?id)
        {
            int mid = 0;

            if (id.HasValue)
            {
                var contact = ContactObject.GetContact(id.Value);
                if (contact != null)
                {
                    mid = contact.MainId;
                    if (MainObject.CheckUserHasWriteAccess(mid))
                    {
                        contact.Delete();
                    }
                }
            }

            return(PartialView("Partials/_contactList", ContactObject.GetContacts(mid)));
        }
        public ActionResult RemoveKeyword(int?id)
        {
            int mid = 0;

            if (id.HasValue)
            {
                var meta = MetaDataObject.GetMetaData(id.Value);
                if (meta != null)
                {
                    mid = meta.MainId;
                    if (MainObject.CheckUserHasWriteAccess(mid))
                    {
                        meta.Delete();
                    }
                }
            }

            return(PartialView("Partials/_keywordsList", MetaDataObject.GetMetaDatas(mid, MetaDataTypeEnum.Keywords)));
        }
        public ActionResult RemoveFunding(int?id)
        {
            int mid = 0;

            if (id.HasValue)
            {
                var funding = FundingObject.GetFunding(id.Value);
                if (funding != null)
                {
                    mid = funding.MainId;
                    if (MainObject.CheckUserHasWriteAccess(mid))
                    {
                        funding.Delete();
                    }
                }
            }

            return(PartialView("Partials/_fundingList", FundingObject.GetFundings(mid)));
        }
        public ActionResult RemoveIntellectual(int?id)
        {
            int mid = 0;

            if (id.HasValue)
            {
                var data = IntellectualPropertyObject.GetIntellectualProperty(id.Value);
                if (data != null)
                {
                    mid = data.MainId;
                    if (MainObject.CheckUserHasWriteAccess(mid))
                    {
                        data.Delete();
                    }
                }
            }

            return(PartialView("Partials/_intellectualList", IntellectualPropertyObject.GetIntellectualProperties(mid)));
        }
        public ActionResult ReactivateReviewer(int?id)
        {
            int mid = 0;

            if (id.HasValue)
            {
                var review = ReviewObject.GetReview(id.Value);
                if (review != null)
                {
                    mid = review.MainId;
                    if (MainObject.CheckUserHasWriteAccess(mid))
                    {
                        review.ReActivate();
                    }
                }
            }

            return(GetReviewersList(mid));
        }
        public ActionResult SetPrimaryAuthor(int?id)
        {
            int mid = 0;

            if (id.HasValue)
            {
                var author = AuthorObject.GetAuthor(id.Value);
                if (author != null)
                {
                    mid = author.MainId;
                    if (MainObject.CheckUserHasWriteAccess(mid))
                    {
                        author.SetAsPrimary();
                    }
                }
            }

            return(GetAuthorListPartial(mid));
        }