public async virtual Task <IEnumerable <SpeedWagonContent> > Descendants(SpeedWagonContent model, IDictionary <string, string> filters) { var descendants = await Descendants(model); var filteredDescendants = new List <SpeedWagonContent>(); foreach (var descendant in descendants) { var include = true; foreach (var filter in filters) { var key = filter.Key; var value = filter.Value; if ( (descendant.Content.ContainsKey(key) && descendant.Content[key] != value) || (HasProperty(descendant, key) && GetPropertyValue(descendant, key) != value) ) { include = false; } } if (include) { filteredDescendants.Add(descendant); } } return(filteredDescendants); }
public async Task <IActionResult> Add(ContentTypeViewModel model) { if (!ModelState.IsValid) { model.ContentTypes = await this._speedWagon.ContentTypeService.List(); return(View("~/Views/SpeedWagon/ContentType/List.cshtml", model)); } this._speedWagon.ContentTypeService.Add(model.Name, User.Identity.Name.MaskEmail(), model.Root, model.Children); if (!string.IsNullOrEmpty(model.CopyProperties)) { SpeedWagonContent contentType = await this._speedWagon.ContentTypeService.Get(model.Name); SpeedWagonContent master = await this._speedWagon.ContentTypeService.Get(model.CopyProperties); contentType.Content["Editors"] = master.Content["Editors"]; this._speedWagon.ContentTypeService.Save(contentType, User.Identity.Name.MaskEmail()); } return(RedirectToAction("List", new { id = model.Name })); }
public async Task <IActionResult> Edit(string url = null) { if (string.IsNullOrEmpty(url)) { return(RedirectToAction("List")); } SpeedWagonContent content = await this._speedWagon.GetContent(url); SpeedWagonContent parent = await this._speedWagon.ContentService.Parent(content); SpeedWagonContent contentType = await this._speedWagon.ContentTypeService.Get(content.Type); IEnumerable <SpeedWagonContent> editors = await this._speedWagon.EditorService.List(); IEnumerable <ContentTypeEditor> properties = this._speedWagon.ContentTypeService.GetEditors(contentType); EditContentViewModel viewModel = new EditContentViewModel(); viewModel.Url = content.RelativeUrl; viewModel.Parent = parent.RelativeUrl; viewModel.Content = content; viewModel.Editors = editors; viewModel.ContentType = contentType; viewModel.ContentTypeProperties = properties; viewModel.ViewEngine = this._viewEngine; viewModel.Values = this._speedWagon.WebContentService.GetValues(content, properties); return(View("~/Views/SpeedWagon/Content/Edit.cshtml", viewModel)); }
public async Task <IActionResult> List(string url = null) { SpeedWagonContent contentRoot = await this._speedWagon.WebContentService.GetContent(url); IEnumerable <SpeedWagonContent> contents = await this._speedWagon.ContentService.Children(contentRoot); contents = contents.OrderBy(x => x.SortOrder); IEnumerable <SpeedWagonContent> contentTypes = null; if (string.IsNullOrEmpty(url) || url == "/content") { contentTypes = await this._speedWagon.ContentTypeService.ListRootTypes(); } else { contentTypes = await this._speedWagon.ContentTypeService.ListAllowedChildren(contentRoot.Type); } IList <SelectListItem> contentTypeSelct = SelectListHelper.GetSelectList(contentTypes); ContentViewModel viewModel = new ContentViewModel(); viewModel.AvailableContentTypes = contentTypeSelct; viewModel.Content = contentRoot; viewModel.Contents = contents; viewModel.ContentService = this._speedWagon.ContentService; return(View("~/Views/SpeedWagon/Content/List.cshtml", viewModel)); }
public async Task <IActionResult> Edit(EditContentTypeViewModel viewModel) { SpeedWagonContent contentType = await this._speedWagon.ContentTypeService.Get(viewModel.Name); if (!ModelState.IsValid) { IEnumerable <SpeedWagonContent> editors = await this._speedWagon.EditorService.List(); IEnumerable <SpeedWagonContent> contentTypes = await this._speedWagon.ContentTypeService.List(); viewModel.ContentType = contentType; viewModel.Root = contentType.GetValue <bool>("Root"); viewModel.Children = contentType.GetValue <string[]>("Children"); viewModel.Name = contentType.Name; viewModel.Url = contentType.RelativeUrl; viewModel.AvailableContentTypes = SelectListHelper.GetSelectList(contentTypes); viewModel.AvailableEditors = SelectListHelper.GetSelectList(editors); viewModel.Editors = this._speedWagon.ContentTypeService.GetEditors(contentType); return(View(viewModel)); } contentType.Content["Root"] = viewModel.Root; contentType.Content["Children"] = viewModel.Children; this._speedWagon.ContentTypeService.Save(contentType, User.Identity.Name.MaskEmail()); return(RedirectToAction("Edit", new { url = contentType.Name, operation = "edited" })); }
public async Task <IActionResult> MoveDown(ContentOperationViewModel model) { SpeedWagonContent content = await this._speedWagon.ContentService.GetContent(model.Url); SpeedWagonContent parent = await this._speedWagon.ContentService.Parent(content); IEnumerable <SpeedWagonContent> children = await this._speedWagon.ContentService.Children(parent); children = children.OrderBy(x => x.SortOrder); SpeedWagonContent[] childArray = children.ToArray(); for (int index = 0; index < childArray.Length; index++) { if (childArray[index].Url == content.Url && index < childArray.Length - 1) { childArray[index + 1].SortOrder--; childArray[index].SortOrder++; this._speedWagon.WebContentService.Save(childArray[index + 1], User.Identity.Name.MaskEmail()); this._speedWagon.WebContentService.Save(childArray[index], User.Identity.Name.MaskEmail()); } } return(RedirectToAction("List")); }
public void Save(SpeedWagonContent contentType, string user) { contentType.WriterName = user; contentType.UpdateDate = DateTime.Now; this._cachelessContentService.AddContent(contentType); }
private Document GetLuceneDocument(SpeedWagonContent content) { var d = new Document(); d.Add(new Field("Url", content.Url, Field.Store.YES, Field.Index.NOT_ANALYZED)); d.Add(new TextField("Name", content.Name, Field.Store.YES)); d.Add(new Field("CreateDate", content.CreateDate.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED)); d.Add(new Field("UpdateDate", content.UpdateDate.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED)); d.Add(new Field("Type", content.Type, Field.Store.YES, Field.Index.NOT_ANALYZED)); d.Add(new Field("CreatorName", content.CreatorName, Field.Store.YES, Field.Index.NOT_ANALYZED)); d.Add(new Field("WriterName", content.WriterName, Field.Store.YES, Field.Index.NOT_ANALYZED)); d.Add(new Field("RelativeUrl", content.RelativeUrl, Field.Store.YES, Field.Index.NOT_ANALYZED)); d.Add(new Field("Template", SafeFieldValue(content.Template), Field.Store.YES, Field.Index.NOT_ANALYZED)); d.Add(new Field("SortOrder", content.SortOrder.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED)); d.Add(new Field("Level", content.Level.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED)); foreach (var property in content.Content) { var value = property.Value == null ? string.Empty : property.Value.ToString(); value = StripHtml(value); string key = property.Key.Replace(" ", ""); d.Add(new TextField(key, value, Field.Store.YES)); } return(d); }
public async virtual Task <SpeedWagonContent> Parent(SpeedWagonContent model) { string parentUrl = model.Url.Substring(0, model.Url.LastIndexOf("/")); IEnumerable <SpeedWagonContent> content = await FromUrls(new[] { parentUrl }); return(content.FirstOrDefault()); }
public async virtual Task <IEnumerable <SpeedWagonContent> > TopNavigation(SpeedWagonContent model) { var urls = await TopNavigationUrls(model); IEnumerable <SpeedWagonContent> content = await FromUrls(urls); return(content.Where(x => x != null)); }
public async Task <IEnumerable <SpeedWagonContent> > List() { SpeedWagonContent contentTypeRoot = await this._cachelessContentService.GetContent(RationalisePath(Root)); IEnumerable <SpeedWagonContent> content = await this._cachelessContentService.Children(contentTypeRoot); return(content.OrderBy(x => x.Name)); }
public void DeleteEditor(SpeedWagonContent contentType, string editor) { IEnumerable <ContentTypeEditor> editors = GetEditors(contentType).ToList(); editors = editors.Where(x => x.Name != editor); SetEditors(contentType, editors.ToArray()); }
public async Task <IActionResult> DeleteEditor(ContentTypeEditor model) { SpeedWagonContent contentType = await this._speedWagon.ContentTypeService.Get(model.Name); this._speedWagon.ContentTypeService.DeleteEditor(contentType, model.Editor); this._speedWagon.ContentTypeService.Save(contentType, User.Identity.Name.MaskEmail()); return(RedirectToAction("Edit", new { url = model.Name })); }
void PlaceInCache(string url, SpeedWagonContent content) { if (content == null) { return; } content.CacheTime = DateTime.Now; this._customCache.Set <SpeedWagonContent>(url, content); }
public async Task <IEnumerable <SpeedWagonContent> > ListAllowedChildren(string type) { IEnumerable <SpeedWagonContent> contentTypes = await List(); SpeedWagonContent contentType = await Get(type); IEnumerable <string> children = contentType.GetValue <string[]>("Children"); return(contentTypes.Where(x => children.Contains(x.Name))); }
public void Add(string name, string user) { SpeedWagonContent editor = new SpeedWagonContent(name.ToTitleCasedName(), RationalisePath(name), "editor", user); string viewName = name.ToTitleCasedName().Replace("-", "") + ".cshtml"; editor.Template = "~/Views/SpeedWagon/Editors/" + viewName; this._cachelessContentService.AddContent(editor); }
public static string WebUrl(this SpeedWagonContent content) { string[] segments = content.RelativeUrl.Split('/'); if (segments.Length < 3) { return(content.RelativeUrl); } return("/" + string.Join("/", segments.Skip(3))); }
private void SetEditors(SpeedWagonContent contentType, ContentTypeEditor[] editors) { if (!contentType.Content.ContainsKey("Editors")) { contentType.Content.Add("Editors", editors); } else { contentType.Content["Editors"] = editors; } }
public void Add(string parent, string name, string type, string user) { string urlName = RationalisePath(parent) + "/" + name.ToUrlName(); SpeedWagonContent content = new SpeedWagonContent(name.ToTitleCasedName(), urlName, "content", user); string viewName = type.ToTitleCasedName(); content.Template = viewName; content.Type = type; this._cachelessContentService.AddContent(content); }
public async Task <SpeedWagonContent> ContentFor(HttpRequest request, string path) { string url = SPEEDWAGON_HOST + "/content/" + request.Host.Host + path; SpeedWagonContent content = await this._cachedContentService.GetContent(url); if (content == null) { return(new SpeedWagonContent("404NotFound", request.Path)); } return(content); }
public ContentTypeEditor[] GetEditors(SpeedWagonContent contentType) { if (contentType.Content.ContainsKey("Editors")) { return(((JArray)contentType.Content["Editors"]).ToObject <ContentTypeEditor[]>()); } else { contentType.Content.Add("Editors", new List <ContentTypeEditor>()); } return(new ContentTypeEditor[] { }); }
public async virtual Task <IEnumerable <SpeedWagonContent> > BreadCrumb(SpeedWagonContent model) { IList <SpeedWagonContent> crumb = new List <SpeedWagonContent>(); SpeedWagonContent parent = model; while (parent != null && parent.Level > 0) { crumb.Add(parent); parent = await Parent(parent); } return(crumb.Reverse()); }
public static string GetValue(this SpeedWagonContent model, string key) { if (model == null || model.Content == null || !model.Content.ContainsKey(key)) { return(string.Empty); } if (model.Content[key] == null) { return(string.Empty); } return(model.Content[key].ToString()); }
private async Task <IEnumerable <SpeedWagonContent> > FromUrls(IEnumerable <string> urls) { var content = new List <SpeedWagonContent>(); foreach (var url in urls) { SpeedWagonContent c = await GetContent(url); content.Add(c); // var p = Path.Combine(_pathMapper.ContentFolder(path), _pathMapper.GetContentFileName()); // content.Add(FromFile(p)); } return(content); }
public void Index(SpeedWagonContent model) { var doc = GetLuceneDocument(model); using (Directory directory = FSDirectory.Open(this._directory)) { using (IndexWriter writer = new IndexWriter(directory, new IndexWriterConfig(LuceneVersion.LUCENE_CURRENT, SetupAnalyzer()))) { writer.DeleteDocuments(new Term("Url", doc.Get("Url"))); writer.Commit(); writer.AddDocument(doc); writer.Commit(); } } }
public async Task <IActionResult> Edit(EditContentViewModel model) { if (!ModelState.IsValid) { return(RedirectToAction("List", "SpeedWagonContent", new { url = model.Url })); } SpeedWagonContent content = await this._speedWagon.GetContent(model.Url); this._speedWagon.WebContentService.SetValues(content, model.Values); this._speedWagon.WebContentService.Save(content, User.Identity.Name.MaskEmail()); SpeedWagonContent parent = await this._speedWagon.ContentService.Parent(content); return(RedirectToAction("List", "SpeedWagonContent", new { url = parent.RelativeUrl })); }
public void MoveEditorDown(SpeedWagonContent contentType, string editor) { ContentTypeEditor[] editors = GetEditors(contentType); int index = Array.FindIndex(editors, row => row.Name == editor); if (index < editors.Length - 1) { ContentTypeEditor src = editors[index + 1]; ContentTypeEditor dst = editors[index]; editors[index + 1] = dst; editors[index] = src; } SetEditors(contentType, editors); }
public void Add(string name, string user, bool root, string[] children) { SpeedWagonContent contentType = new SpeedWagonContent(name.ToTitleCasedName(), RationalisePath(name), "content-type", user); string viewName = name.ToTitleCasedName() + ".cshtml"; contentType.Template = "~/Views/SpeedWagon/ContentType/" + viewName; if (children == null) { children = new string[] { }; } contentType.Content.Add("Root", root); contentType.Content.Add("Children", children); this._cachelessContentService.AddContent(contentType); }
public static T GetValue <T>(this SpeedWagonContent model, string key) { var v = model.GetValue(key); if (v == null || !CanChangeType(v, typeof(T))) { return((T)Activator.CreateInstance(typeof(T))); } try { return((T)Convert.ChangeType(v, typeof(T))); } catch (Exception ex) { return(JsonConvert.DeserializeObject <T>(v)); } }
public async Task <IActionResult> EditProperty(string name, string property) { SpeedWagonContent contentType = await this._speedWagon.ContentTypeService.Get(name); ContentTypeEditor[] properties = this._speedWagon.ContentTypeService.GetEditors(contentType); IEnumerable <SpeedWagonContent> editors = await this._speedWagon.EditorService.List(); ContentTypeEditor prop = properties.FirstOrDefault(x => x.Name == property); EditProperty model = new EditProperty(); model.ContentTypeName = contentType.Name; model.Property = prop; model.AvailableEditors = SelectListHelper.GetSelectList(editors); return(View("~/Views/SpeedWagon/ContentType/EditProperty.cshtml", model)); }