public override string RenderData()
        {
            StringBuilder sb = new StringBuilder("<ul>");

            Urls urls = new Urls();

            HttpContext context = HttpContext.Current;
            if(context != null)
            {
                TemplatedThemePage ttp = context.Handler as TemplatedThemePage;
                if(ttp != null && ttp.PostId > 0)
                {
                    Post p = new Post(ttp.PostId);
                    if (RolePermissionManager.GetPermissions(p.CategoryId, GraffitiUsers.Current).Edit)
                    {
                        sb.AppendFormat("<li><a href=\"{0}\">{1}</a></li>\n", urls.Edit(ttp.PostId), "Edit this Post");
                    }
                }
            }

            if (RolePermissionManager.CanViewControlPanel(GraffitiUsers.Current))
            {
                sb.AppendFormat("<li><a href=\"{0}\">{1}</a></li>\n", urls.Write, "Write a new Post");
                sb.AppendFormat("<li><a href=\"{0}\">{1}</a></li>\n", urls.Admin, "Control Panel");
            }

            sb.AppendFormat("<li><a href=\"{0}\">{1}</a></li>\n", urls.Logout, "Logout");
            sb.Append("</ul>\n");

            return sb.ToString();
        }
Beispiel #2
0
        public override string RenderData()
        {
            if (PostIds == null || PostIds.Length == 0)
                return string.Empty;

            PostCollection pc = ZCache.Get<PostCollection>(DataCacheKey);
            if (pc == null)
            {

                pc = new PostCollection();
                foreach(int i in PostIds)
                {
                    Post p = new Post(i);
                    if(!p.IsNew && !p.IsDeleted && p.IsPublished )
                        pc.Add(p);
                }

                ZCache.InsertCache(DataCacheKey, pc, 180);
            }

            StringBuilder sb = new StringBuilder("<ul>");
            foreach(Post p in pc)
            {
                sb.AppendFormat("<li><a href=\"{0}\">{1}</a></li>", p.Url, p.Title);
            }

            sb.Append("</ul>");

            return sb.ToString();
        }
        /// <summary>
        /// Formats the prefix.
        /// </summary>
        /// <param name="post">The post.</param>
        /// <param name="prefix">The prefix.</param>
        /// <returns>The prefix.</returns>
        protected virtual string FormatPrefix(Post post, string prefix)
        {
            if (String.IsNullOrEmpty(prefix))
                return String.Empty;

            return String.Format("{0}:", prefix.Replace(":", ""));
        }
        public ItemStatistics PostItemStatistics(Post post)
        {
            if (post != null)
                return DataHelper.GetMarketplacePostStats(post.Id);

            return new ItemStatistics();
        }
		public static EventRegistrationResult AlreadyRegisteredFor(Post post)
		{
			return new EventRegistrationResult
			       {
			       	Post = post,
			       	AlreadyRegistered = true
			       };
		}
		public static EventRegistrationResult SuccessfullyRegisteredFor(Post post, bool onWaitingList)
		{
			return new EventRegistrationResult
			       {
			       	Post = post,
			       	OnWaitingList = onWaitingList
			       };
		}
		public static EventRegistrationResult NotAllowedFor(Post post)
		{
			return new EventRegistrationResult
			       {
			       	Post = post,
			       	ErrorOccurred = true
			       };
		}
		public virtual void Save(Post post)
		{
			if (post == null)
			{
				throw new ArgumentNullException("post");
			}

			post.Save();
		}
		public string GetCategoryNameOf(Post post)
		{
			if (post == null)
			{
				throw new ArgumentNullException("post");
			}

			return post.Category.Name;
		}
		public ICalendar CreateCalendarForEvent(Post post)
		{
			ICalendar calendar = new Calendar(HttpUtility.HtmlDecode(post.Title), false);
			var item = CreateCalendarItem(post);
			if (item != null)
			{
				calendar.Items.Add(item);
			}
			return calendar;
		}
Beispiel #11
0
        public string FileDownloader(Post post)
        {
            // If the "download" querystring attrib exists, stream the download file
            if (!string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["download"]))
            {
                return string.Format("<iframe src=\"{0}\" width=\"1\" height=\"1\"></iframe>", "");
            }

            return string.Empty;
        }
		static Post CreatePost(string title, DateTime createdOn, DateTime? eventDate)
		{
			var post = new Post { Title = title, CategoryId = 2, CreatedOn = createdOn };

			if (eventDate.HasValue)
			{
				post.CustomFields().Add(StartDateField, eventDate.Value.ToString("d"));
			}

			return post;
		}
		protected override void Establish_context()
		{
			var postRepository = MockRepository.GenerateMock<IPostRepository>();
			_sut = new EventPlugin(postRepository,
								   MockRepository.GenerateMock<IMapper<NameValueCollection, Settings>>(),
								   MockRepository.GenerateMock<IValidator<Settings>>()) { CategoryName = "Event category" };

			_post = new Post();

			postRepository.Stub(x => x.GetCategoryNameOf(_post)).Return("Some other category");
		}
        public static int CommitPost(Post p, IGraffitiUser user, bool isFeaturedPost, bool isFeaturedCategory)
        {
            Permission perm = RolePermissionManager.GetPermissions(p.CategoryId, user);
            bool isMan = perm.Publish;
            bool isEdit = GraffitiUsers.IsAdmin(user);

            if (isMan || isEdit)
            {
                p.IsPublished = (p.PostStatus == PostStatus.Publish);
            }
            else
            {
                p.IsPublished = false;

                if(p.PostStatus != PostStatus.Draft && p.PostStatus != PostStatus.PendingApproval)
                {
                    p.PostStatus = PostStatus.Draft;
                }
            }

            p.ModifiedBy = user.Name;

            if(p.IsNew) //No VERSION WORK, just save it.
            {
                p.Version = 1;
                p.Save(user.Name,SiteSettings.CurrentUserTime);
            }
            else if(p.IsPublished) //Make a copy of the current post, then save this one.
            {
                Post old_Post = new Post(p.Id);

                //if(old_Post.PostStatus == PostStatus.Publish)
                VersionPost(old_Post);

                p.Version = GetNextVersionId(p.Id, p.Version);
                p.Save(user.Name);
            }
            else
            {
                p.Version = GetNextVersionId(p.Id, p.Version);
                VersionPost(p);
                Post.UpdatePostStatus(p.Id,p.PostStatus);
            }

            ProcessFeaturedPosts(p, user, isFeaturedPost, isFeaturedCategory);

            if(p.PostStatus == PostStatus.PendingApproval)
                SendPReqiresApprovalMessage(p,user);
            else if(p.PostStatus == PostStatus.RequiresChanges)
                SendRequestedChangesMessage(p,user);

            return p.Id;
        }
        /// <summary>
        /// Formats the post into 140 characters or less.
        /// </summary>
        /// <param name="post">The post.</param>
        /// <param name="prefix">The prefix for the twitter post.</param>
        /// <returns>140 characters or less to link to the post.</returns>
        /// <remarks>
        /// Classes implementing this function do not necessarily need to stick to
        /// 140 characters or less - if more than 140 characters are returned the
        /// output will not be used.
        /// </remarks>
        public virtual string Format(Post post, string prefix)
        {
            StringBuilder text = new StringBuilder(FormatPrefix(post, prefix));

            text.AppendFormat(" {0} {1}", FormatTitle(post), FormatUrl(post));

            string tags = FormatTags(post);
            if (!String.IsNullOrEmpty(tags))
                text.AppendFormat(" {0}", tags);

            return text.ToString().Trim();
        }
Beispiel #16
0
        public static void SendPings(Post post, string pingUrls)
        {
            // Split ping urls into string array
            string[] pingUrlsArray = pingUrls.Split('\n');

            // Gather information to pass to ping service(s)
            string name = SiteSettings.Get().Title;
            string url = post.Category.IsUncategorized ? new Macros().FullUrl(new Urls().Home) : new Macros().FullUrl(post.Category.Url);
            string feedUrl = SiteSettings.Get().ExternalFeedUrl ?? new Macros().FullUrl(VirtualPathUtility.ToAbsolute("~/feed/"));

            XmlRpcPings pinger = new XmlRpcPings(name, url, feedUrl, pingUrlsArray);
            ManagedThreadPool.QueueUserWorkItem(new WaitCallback(pinger.SendPings));
        }
        /// <summary>
        /// Formats the tags.
        /// </summary>
        /// <param name="post">The post.</param>
        /// <returns>The post tags.</returns>
        protected virtual string FormatTags(Post post)
        {
            StringBuilder tags = new StringBuilder();
            foreach (string tag in post.TagList.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
            {
                if (tags.Length != 0)
                    tags.Append(" ");

                tags.AppendFormat("#{0}", tag);
            }

            return tags.ToString();
        }
		protected override void Establish_context()
		{
			base.Establish_context();

			_event = Create.New.Event()
				.Id(42)
				.StartingAt(DateTime.MinValue)
				.To(DateTime.MinValue.AddDays(10))
				.AtLocation("somewhere")
				.TheTopicIs("techno babble");
			PostRepository.Stub(x => x.GetById(42)).Return(_event);

			_calendar = MockRepository.GenerateMock<ICalendar>();
			CalendarItemRepository.Stub(x => x.CreateCalendarForEvent(_event))
				.Return(_calendar);
		}
        public static void SendPReqiresApprovalMessage(Post p, IGraffitiUser user)
        {
            List<IGraffitiUser> users = new List<IGraffitiUser>();
            foreach(IGraffitiUser u in GraffitiUsers.GetUsers("*"))
            {
                if (GraffitiUsers.IsAdmin(u) || RolePermissionManager.GetPermissions(p.CategoryId, u).Publish)
                    users.Add(u);
            }

            Macros m = new Macros();
            EmailTemplateToolboxContext pttc = new EmailTemplateToolboxContext();
            pttc.Put("sitesettings", SiteSettings.Get());
            pttc.Put("post", p);
            pttc.Put("user", user);
            pttc.Put("macros", m);
            pttc.Put("home", m.FullUrl(new Urls().Home));
            pttc.Put("adminUrl",
                     m.FullUrl(VirtualPathUtility.ToAbsolute("~/graffiti-admin/posts/write/")) + "?id=" + p.Id + "&v=" +
                     p.Version);

            string adminApprovalUrl = m.FullUrl(VirtualPathUtility.ToAbsolute("~/api/approve.ashx")) + "?key={0}&u={1}&id={2}&v={3}";

            EmailTemplate template = new EmailTemplate();
            template.Context = pttc;
            template.Subject = "You have content to approve: " + p.Title;
            template.TemplateName = "QueuedPost.view";

            foreach (IGraffitiUser admin in users)
            {
                template.Context.Put("adminApprovalUrl", string.Format(adminApprovalUrl, admin.UniqueId, admin.Name, p.Id, p.Version));

                try
                {
                    template.To = admin.Email;
                    Emailer.Send(template);

                    //Emailer.Send("QueuedPost.view", admin.Email, "You have content to approve: " + p.Title, pttc);
                }
                catch(Exception ex)
                {
                    Log.Error("Email Error", ex.Message);
                }
            }

            Log.Info("Post approval email", "{0} user(s) were sent an email to approve the post \"{1}\" (id: {2}).", users.Count,p.Title,p.Id);
        }
		protected override void Establish_context()
		{
			base.Establish_context();

			_sut = Container.Create<TalkPlugin>();
			_sut.CategoryName = "Talk category";

			_post = new Post();

			IoC.Resolve<IPostRepository>().Stub(x => x.GetCategoryNameOf(_post)).Return("Some other category");
			IoC.Resolve<ITalkValidator>()
				.Expect(x => x.Validate(_post))
				.Return(null)
				.Repeat.Never();

			Mocks.ReplayAll();
		}
		ICalendarItem CreateCalendarItem(Post post)
		{
			try
			{
				string postUrl = _settings.BaseUrl;

				try
				{
					postUrl += post.Url;
				}
					// ReSharper disable EmptyGeneralCatchClause
				catch
					// ReSharper restore EmptyGeneralCatchClause
				{
					// HACK: In unit-testing scenarios, accessing URL causes database access. Well done, telligent!
				}

				var calendarItem = new CalendarItem
				                   {
				                   	StartDate = post[_eventPluginConfigurationProvider.StartDateField].AsEventDate(),
				                   	EndDate = post[_eventPluginConfigurationProvider.EndDateField].AsEventDate(),
				                   	Location = post[_eventPluginConfigurationProvider.LocationUnknownField].IsSelected()
				                   	           	? _eventPluginConfigurationProvider.UnknownText
				                   	           	: post[_eventPluginConfigurationProvider.LocationField],
				                   	Subject = HttpUtility.HtmlDecode(post.Title),
				                   	Description = postUrl,
				                   	LastModified = post.Published,
				                   	Categories = HttpUtility.HtmlDecode(_settings.Title)
				                   };

				if (!calendarItem.IsValid())
				{
					return null;
				}

				return calendarItem;
			}
			catch (Exception ex)
			{
				Logger.Error(Create.New.LogMessage().WithTitle("Could not create calendar item from post {0}", post.Id), ex);
				return null;
			}
		}
Beispiel #22
0
        public static string GenerateTrackbackRDF(Post post)
        {
            Macros macros = new Macros();
            StringBuilder sb = new StringBuilder();

            string postUrl = macros.FullUrl(post.Url);
            string pingUrl = macros.FullUrl(string.Format("{0}?id={1}", VirtualPathUtility.ToAbsolute("~/trackback.ashx"), post.Id));

            sb.Append("\n<!--\n");
            sb.Append("<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"\n");
            sb.Append("xmlns:dc=\"http://purl.org/dc/elements/1.1/\"\n");
            sb.Append("xmlns:trackback=\"http://madskills.com/public/xml/rss/module/trackback/\">\n");
            sb.Append("<rdf:Description\n");
            sb.AppendFormat("rdf:about=\"{0}\"\n", postUrl);
            sb.AppendFormat("dc:identifier=\"{0}\"\n", postUrl);
            sb.AppendFormat("dc:title=\"{0}\"\n", post.Title);
            sb.AppendFormat("trackback:ping=\"{0}\" />\n", pingUrl);
            sb.Append("</rdf:RDF>\n");
            sb.Append("-->\n");

            return sb.ToString();
        }
Beispiel #23
0
		public string CommentUrl(Post post, IDictionary dictionary)
		{
			if (post == null)
			{
				return String.Empty;
			}

			string anchor = null;
			if (dictionary != null)
			{
				if (dictionary.Contains("anchor"))
				{
					anchor = String.Format("#{0}", HttpUtility.HtmlAttributeEncode(dictionary["anchor"] as string));
					dictionary.Remove("anchor");
				}
			}

			string linkText;
			if (post.CommentCount <= 0)
			{
				linkText = NoComments;
			}
			else if (post.CommentCount == 1)
			{
				linkText = SingleComment;
			}
			else
			{
				linkText = String.Format(ManyComments, post.CommentCount);
			}

			return String.Format("<a href=\"{0}{1}{2}\">{3}</a>",
			                     HttpUtility.HtmlAttributeEncode(post.Url),
			                     DictionaryToQueryString(dictionary),
			                     anchor,
			                     HttpUtility.HtmlEncode(linkText));
		}
 public PostEventArgs(Post post, PostRenderLocation renderLocation)
 {
     _post = post;
     _renderLocation = renderLocation;
 }
		protected override void Establish_context()
		{
			base.Establish_context();

			_sut = Container.Create<TalkPlugin>();
			_sut.CategoryName = "Talk category";

			_post = new Post();

			IoC.Resolve<IPostRepository>().Stub(x => x.GetCategoryNameOf(_post)).Return(_sut.CategoryName);
			IoC.Resolve<ITalkValidator>().Stub(x => x.Validate(_post)).Return(new ValidationReport
			                                                                   {
			                                                                   	new ValidationError("something"),
			                                                                   	new ValidationError("some other thing")
			                                                                   });

			Mocks.ReplayAll();
		}
Beispiel #26
0
        public void ProcessRequest(HttpContext context)
        {
            if (context.Request.RequestType != "POST" || !context.Request.IsAuthenticated)
                return;

            IGraffitiUser user = GraffitiUsers.Current;
            if (user == null)
                return;

            if (!RolePermissionManager.CanViewControlPanel(user))
                return;

            context.Response.ContentType = "text/plain";

            switch (context.Request.QueryString["command"])
            {
                case "deleteComment":

                    Comment c = new Comment(context.Request.Form["commentid"]);

                    if (RolePermissionManager.GetPermissions(c.Post.CategoryId, GraffitiUsers.Current).Publish)
                    {
                        Comment.Delete(context.Request.Form["commentid"]);
                        context.Response.Write("success");
                    }

                    break;

                case "deleteCommentWithStatus":

                    Comment c1 = new Comment(context.Request.Form["commentid"]);

                    if (RolePermissionManager.GetPermissions(c1.Post.CategoryId, GraffitiUsers.Current).Publish)
                    {
                        Comment.Delete(context.Request.Form["commentid"]);
                        context.Response.Write("The comment was deleted. <a href=\"javascript:void(0);\" onclick=\"Comments.unDelete('" + new Urls().AdminAjax + "'," + context.Request.Form["commentid"] + "); return false;\">Undo?</a>");
                    }
                    break;

                case "unDelete":
                    Comment c2 = new Comment(context.Request.Form["commentid"]);

                    if (RolePermissionManager.GetPermissions(c2.Post.CategoryId, GraffitiUsers.Current).Publish)
                    {
                        Comment comment = new Comment(context.Request.Form["commentid"]);
                        comment.IsDeleted = false;
                        comment.Save();
                        context.Response.Write("The comment was un-deleted. You may need to refresh the page to see it");
                    }
                    break;

                case "approve":
                    Comment c3 = new Comment(context.Request.Form["commentid"]);

                    if (RolePermissionManager.GetPermissions(c3.Post.CategoryId, GraffitiUsers.Current).Publish)
                    {
                        Comment cmt = new Comment(context.Request.Form["commentid"]);
                        cmt.IsDeleted = false;
                        cmt.IsPublished = true;
                        cmt.Save();
                        context.Response.Write("The comment was un-deleted and/or approved. You may need to refresh the page to see it");
                    }
                    break;

                case "deletePost":
                    try
                    {
                        Post postToDelete = new Post(context.Request.Form["postid"]);

                        Permission perm = RolePermissionManager.GetPermissions(postToDelete.CategoryId, user);

                        if (GraffitiUsers.IsAdmin(user) || perm.Publish)
                        {
                            postToDelete.IsDeleted = true;
                            postToDelete.Save(user.Name, DateTime.Now);

                            //Post.Delete(context.Request.Form["postid"]);
                            //ZCache.RemoveByPattern("Posts-");
                            //ZCache.RemoveCache("Post-" + context.Request.Form["postid"]);
                            context.Response.Write("The post was deleted. <a href=\"javascript:void(0);\" onclick=\"Posts.unDeletePost('" + new Urls().AdminAjax + "'," + context.Request.Form["postid"] + "); return false;\">Undo?</a>");
                        }
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                    }
                    break;

                case "unDeletePost":
                    Post p = new Post(context.Request.Form["postid"]);
                    p.IsDeleted = false;
                    p.Save();
                    //ZCache.RemoveByPattern("Posts-");
                    //ZCache.RemoveCache("Post-" + context.Request.Form["postid"]);
                    //context.Response.Write("The post was un-deleted. You may need to fresh the page to see it");
                    break;

                case "permanentDeletePost":
                    Post tempPost = new Post(context.Request.Form["postid"]);
                    Post.DestroyDeletedPost(tempPost.Id);
                    context.Response.Write(tempPost.Title);
                    break;

                case "createdWidget":
                    string widgetID = context.Request.Form["id"];
                    List<WidgetDescription> the_widgets = Widgets.GetAvailableWidgets();
                    Widget widget = null;
                    foreach (WidgetDescription wia in the_widgets)
                    {
                        if (wia.UniqueId == widgetID)
                        {
                            widget = Widgets.Create(wia.WidgetType);
                            break;
                        }
                    }

                    context.Response.Write(widget.Id.ToString());

                    break;

                case "updateWidgetsOrder":

                    try
                    {
                        string listID = context.Request.Form["id"];
                        string list = "&" + context.Request.Form["list"];

                        Widgets.ReOrder(listID, list);

                        //StreamWriter sw = new StreamWriter(context.Server.MapPath("~/widgets.txt"), true);
                        //sw.WriteLine(DateTime.Now);
                        //sw.WriteLine();
                        //sw.WriteLine(context.Request.Form["left"]);
                        //sw.WriteLine(context.Request.Form["right"]);
                        //sw.WriteLine(context.Request.Form["queue"]);
                        //sw.WriteLine();
                        //sw.Close();

                        context.Response.Write("Saved!");
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                    }
                    break;

                case "deleteWidget":

                    string deleteID = context.Request.Form["id"];
                    Widgets.Delete(deleteID);
                    context.Response.Write("The widget was removed!");

                    break;

                case "createTextLink":
                    DynamicNavigationItem di = new DynamicNavigationItem();
                    di.NavigationType = DynamicNavigationType.Link;
                    di.Text = context.Request.Form["text"];
                    di.Href = context.Request.Form["href"];
                    di.Id = Guid.NewGuid();
                    NavigationSettings.Add(di);
                    context.Response.Write(di.Id);

                    break;

                case "deleteTextLink":
                    Guid g = new Guid(context.Request.Form["id"]);
                    NavigationSettings.Remove(g);
                    context.Response.Write("Success");
                    break;

                case "reOrderNavigation":
                    try
                    {
                        string navItems = "&" + context.Request.Form["navItems"];
                        NavigationSettings.ReOrder(navItems);
                        context.Response.Write("Success");
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                    }
                    break;

                case "addNavigationItem":

                    try
                    {
                        if (context.Request.Form["type"] == "Post")
                        {
                            Post navPost = Post.FetchByColumn(Post.Columns.UniqueId, new Guid(context.Request.Form["id"]));
                            DynamicNavigationItem item = new DynamicNavigationItem();
                            item.PostId = navPost.Id;
                            item.Id = navPost.UniqueId;
                            item.NavigationType = DynamicNavigationType.Post;
                            NavigationSettings.Add(item);
                            context.Response.Write("Success");
                        }
                        else if (context.Request.Form["type"] == "Category")
                        {
                            Category navCategory = Category.FetchByColumn(Category.Columns.UniqueId, new Guid(context.Request.Form["id"]));
                            DynamicNavigationItem item = new DynamicNavigationItem();
                            item.CategoryId = navCategory.Id;
                            item.Id = navCategory.UniqueId;
                            item.NavigationType = DynamicNavigationType.Category;
                            NavigationSettings.Add(item);
                            context.Response.Write("Success");
                        }

                    }
                    catch (Exception exp)
                    {
                        context.Response.Write(exp.Message);
                    }

                    break;

                case "reOrderPosts":
                    try
                    {
                        Dictionary<int, Post> posts = new Dictionary<int, Post>();
                        DataBuddy.Query query = Post.CreateQuery();
                        query.AndWhere(Post.Columns.CategoryId, int.Parse(context.Request.QueryString["id"]));
                        foreach (Post post in PostCollection.FetchByQuery(query))
                        {
                            posts[post.Id] = post;
                        }

                        string postOrder = context.Request.Form["posts"];
                        int orderNumber = 1;
                        foreach (string sId in postOrder.Split('&'))
                        {
                            Post post = null;
                            posts.TryGetValue(int.Parse(sId), out post);
                            if (post != null && post.SortOrder != orderNumber)
                            {
                                post.SortOrder = orderNumber;
                                post.Save();
                            }

                            orderNumber++;
                        }

                        context.Response.Write("Success");
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                    }
                    break;

                case "reOrderHomePosts":
                    try
                    {
                        Dictionary<int, Post> posts = new Dictionary<int, Post>();
                        DataBuddy.Query query = Post.CreateQuery();
                        query.AndWhere(Post.Columns.IsHome, true);
                        foreach (Post post in PostCollection.FetchByQuery(query))
                        {
                            posts[post.Id] = post;
                        }

                        string postOrder = context.Request.Form["posts"];
                        int orderNumber = 1;
                        foreach (string sId in postOrder.Split('&'))
                        {
                            Post post = null;
                            posts.TryGetValue(int.Parse(sId), out post);
                            if (post != null && post.HomeSortOrder != orderNumber)
                            {
                                post.HomeSortOrder = orderNumber;
                                post.Save();
                            }

                            orderNumber++;
                        }

                        context.Response.Write("Success");
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                    }
                    break;

                case "categoryForm":

                    int selectedCategory = int.Parse(context.Request.QueryString["category"] ?? "-1");
                    int postId = int.Parse(context.Request.QueryString["post"] ?? "-1");
                    NameValueCollection nvcCustomFields;
                    if (postId > 0)
                        nvcCustomFields = new Post(postId).CustomFields();
                    else
                        nvcCustomFields = new NameValueCollection();

                    CustomFormSettings cfs = CustomFormSettings.Get(selectedCategory);

                    if (cfs.HasFields)
                    {
                        foreach (CustomField cf in cfs.Fields)
                        {
                            if (context.Request.Form[cf.Id.ToString()] != null)
                                nvcCustomFields[cf.Name] = context.Request.Form[cf.Id.ToString()];
                        }

                        context.Response.Write(cfs.GetHtmlForm(nvcCustomFields, (postId < 1)));
                    }
                    else
                        context.Response.Write("");

                    break;

                case "toggleEventStatus":

                    try
                    {
                        EventDetails ed = Events.GetEvent(context.Request.QueryString["t"]);
                        ed.Enabled = !ed.Enabled;

                        if (ed.Enabled)
                            ed.Event.EventEnabled();
                        else
                            ed.Event.EventDisabled();

                        Events.Save(ed);

                        context.Response.Write(ed.Enabled ? "Enabled" : "Disabled");
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                    }
                    break;

                case "buildMainFeed":
                    try
                    {
                        FileInfo mainFeedFileInfo = new FileInfo(HttpContext.Current.Server.MapPath("~/Feed/Default.aspx"));

                        if (!mainFeedFileInfo.Directory.Exists)
                            mainFeedFileInfo.Directory.Create();

                        using (StreamWriter sw = new StreamWriter(mainFeedFileInfo.FullName, false))
                        {
                            sw.WriteLine("<%@ Page Language=\"C#\" Inherits=\"Graffiti.Core.RSS\" %>");
                            sw.Close();
                        }

                        context.Response.Write("Success");
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                        return;
                    }

                    break;

                case "removeFeedData":
                    try
                    {
                        FeedManager.RemoveFeedData();
                        context.Response.Write("Success");
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                    }
                    break;

                case "buildCategoryPages":

                    try
                    {
                        CategoryCollection cc = new CategoryController().GetCachedCategories();
                        foreach (Category cat in cc)
                            cat.WritePages();

                        context.Response.Write("Success");
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                        return;
                    }

                    break;

                case "buildPages":

                    try
                    {

                        Query q = Post.CreateQuery();
                        q.PageIndex = Int32.Parse(context.Request.Form["p"]);
                        q.PageSize = 20;
                        q.OrderByDesc(Post.Columns.Id);

                        PostCollection pc = PostCollection.FetchByQuery(q);
                        if (pc.Count > 0)
                        {

                            foreach (Post postToWrite in pc)
                            {
                                postToWrite.WritePages();
                                foreach (string tagName in Util.ConvertStringToList(postToWrite.TagList))
                                {
                                    if (!string.IsNullOrEmpty(tagName))
                                        Tag.WritePage(tagName);
                                }

                            }

                            context.Response.Write("Next");
                        }
                        else
                        {
                            context.Response.Write("Success");
                        }

                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                        return;
                    }

                    break;

                case "importPosts":

                    try
                    {
                        Post newPost = new Post();
                        newPost.Title = HttpContext.Current.Server.HtmlDecode(context.Request.Form["subject"].ToString());

                        string postName = HttpContext.Current.Server.HtmlDecode(context.Request.Form["name"].ToString());

                        PostCollection pc = new PostCollection();

                        if (!String.IsNullOrEmpty(postName))
                        {
                            Query q = Post.CreateQuery();
                            q.AndWhere(Post.Columns.Name, Util.CleanForUrl(postName));
                            pc.LoadAndCloseReader(q.ExecuteReader());
                        }

                        if (pc.Count > 0)
                        {
                            newPost.Name = "[RENAME ME - " + Guid.NewGuid().ToString().Substring(0, 7) + "]";
                            newPost.Status = (int)PostStatus.Draft;
                        }
                        else if (String.IsNullOrEmpty(postName))
                        {
                            newPost.Name = "[RENAME ME - " + Guid.NewGuid().ToString().Substring(0, 7) + "]";
                            newPost.Status = (int)PostStatus.Draft;
                        }
                        else
                        {
                            newPost.Name = postName;
                            newPost.Status = (int)PostStatus.Publish;
                        }

                        if (String.IsNullOrEmpty(newPost.Title))
                            newPost.Title = newPost.Name;

                        newPost.PostBody = HttpContext.Current.Server.HtmlDecode(context.Request.Form["body"].ToString());
                        newPost.CreatedOn = Convert.ToDateTime(context.Request.Form["createdon"]);
                        newPost.CreatedBy = context.Request.Form["author"];
                        newPost.ModifiedBy = context.Request.Form["author"];
                        newPost.TagList = context.Request.Form["tags"];
                        newPost.ContentType = "text/html";
                        newPost.CategoryId = Convert.ToInt32(context.Request.Form["category"]);
                        newPost.UserName = context.Request.Form["author"];
                        newPost.EnableComments = true;
                        newPost.Published = Convert.ToDateTime(context.Request.Form["createdon"]);
                        newPost.IsPublished = Convert.ToBoolean(context.Request.Form["published"]);

                        // this was causing too many posts to be in draft status.
                        // updated text on migrator to flag users to just move their content/binary directory
                        // into graffiti's root
                        //if (context.Request.Form["method"] == "dasBlog")
                        //{
                        //    if (newPost.Body.ToLower().Contains("/content/binary/"))
                        //        newPost.Status = (int)PostStatus.Draft;
                        //}

                        newPost.Save(GraffitiUsers.Current.Name);

                        int postid = Convert.ToInt32(context.Request.Form["postid"]);

                        IMigrateFrom temp = null;

                        switch (context.Request.Form["method"])
                        {
                            case "CS2007Database":

                                CS2007Database db = new CS2007Database();
                                temp = (IMigrateFrom)db;

                                break;
                            case "Wordpress":

                                Wordpress wp = new Wordpress();
                                temp = (IMigrateFrom)wp;

                                break;

                            case "BlogML":

                                BlogML bml = new BlogML();
                                temp = (IMigrateFrom)bml;

                                break;

                            case "CS21Database":
                                CS21Database csDb = new CS21Database();
                                temp = (IMigrateFrom)csDb;

                                break;

                            case "dasBlog":
                                dasBlog dasb = new dasBlog();
                                temp = (IMigrateFrom)dasb;

                                break;
                        }

                        List<MigratorComment> comments = temp.GetComments(postid);

                        foreach (MigratorComment cmnt in comments)
                        {
                            Comment ct = new Comment();
                            ct.PostId = newPost.Id;
                            ct.Body = cmnt.Body;
                            ct.Published = cmnt.PublishedOn;
                            ct.IPAddress = cmnt.IPAddress;
                            ct.WebSite = cmnt.WebSite;
                            ct.Email = string.IsNullOrEmpty(cmnt.Email) ? "" : cmnt.Email;
                            ct.Name = string.IsNullOrEmpty(cmnt.UserName) ? "" : cmnt.UserName;
                            ct.IsPublished = cmnt.IsPublished;
                            ct.IsTrackback = cmnt.IsTrackback;
                            ct.SpamScore = cmnt.SpamScore;
                            ct.DontSendEmail = true;
                            ct.DontChangeUser = true;

                            ct.Save();

                            Comment ctemp = new Comment(ct.Id);
                            ctemp.DontSendEmail = true;
                            ctemp.DontChangeUser = true;
                            ctemp.Body = HttpContext.Current.Server.HtmlDecode(ctemp.Body);
                            ctemp.Save();
                        }

                        if (newPost.Status == (int)PostStatus.Publish)
                            context.Response.Write("Success" + context.Request.Form["panel"]);
                        else
                            context.Response.Write("Warning" + context.Request.Form["panel"]);
                    }
                    catch (Exception ex)
                    {

                        context.Response.Write(context.Request.Form["panel"] + ":" + ex.Message);
                    }

                    break;

                case "saveHomeSortStatus":

                    SiteSettings siteSettings = SiteSettings.Get();
                    siteSettings.UseCustomHomeList = bool.Parse(context.Request.Form["ic"]);
                    siteSettings.Save();
                    context.Response.Write("Success");

                    break;

                case "checkCategoryPermission":

                    try
                    {
                        int catID = Int32.Parse(context.Request.QueryString["category"]);
                        string permissionName = context.Request.QueryString["permission"];
                        Permission perm = RolePermissionManager.GetPermissions(catID, user);

                        bool permissionResult = false;
                        switch (permissionName)
                        {
                            case "Publish":
                                permissionResult = perm.Publish;
                                break;
                            case "Read":
                                permissionResult = perm.Read;
                                break;
                            case "Edit":
                                permissionResult = perm.Edit;
                                break;
                        }

                        context.Response.Write(permissionResult.ToString().ToLower());
                    }
                    catch (Exception ex)
                    {
                        context.Response.Write(ex.Message);
                    }
                    break;

            }
        }
 /// <summary>
 /// Shrinks the URL.
 /// </summary>
 /// <param name="post">The post.</param>
 /// <returns>The shortened URL.</returns>
 protected override string FormatUrl(Post post)
 {
     return this.urlShortener.Shorten(base.FormatUrl(post));
 }
		void Because(Post post)
		{
			_report = _sut.Validate(post);
		}
		protected override void Establish_context()
		{
			base.Establish_context();
			_post = CreatePost();
		}
		protected override void Establish_context()
		{
			var postRepository = MockRepository.GenerateMock<IPostRepository>();
			_sut = new EventPlugin(postRepository,
								   MockRepository.GenerateMock<IMapper<NameValueCollection, Settings>>(),
								   MockRepository.GenerateMock<IValidator<Settings>>())
			       {
			       	CategoryName = "Event category",
			       	LocationField = LocationField,
			       	LocationUnknownField = LocationUnknownField,
			       	RegistrationRecipientField = RegistrationRecipientField,
			       	MaximumNumberOfRegistrationsField = MaximumNumberOfRegistrationsField,
			       	DefaultLocation = DefaultLocation,
			       	DefaultRegistrationRecipient = DefaultRegistrationRecipient,
			       	DefaultMaximumNumberOfRegistrations = DefaultMaximumNumberOfRegistrations
			       };

			_post = new Post();

			postRepository.Stub(x => x.GetCategoryNameOf(_post)).Return(_sut.CategoryName);
		}