public void GetTemplates([NotNull] DatabaseUri databaseUri, [NotNull] GetItemsCompleted <TemplateHeader> completed)
{
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(completed, nameof(completed));
databaseUri.Site.DataService.GetTemplatesAsync(databaseUri, completed);
}
public override bool GetChildren(GetChildrenDelegate callback, bool async)
{
Assert.ArgumentNotNull(callback, nameof(callback));
bool[] busy =
{
true
};
GetItemsCompleted <ItemHeader> completed = delegate(IEnumerable <ItemHeader> children)
{
if (!busy[0])
{
return;
}
Dispatcher.Invoke(new Action(() => GetChildren(children.ToList(), callback)));
busy[0] = false;
};
Site.DataService.GetChildrenAsync(ItemUri, completed);
if (!async)
{
if (AppHost.DoEvents(ref busy[0]))
{
return(false);
}
}
return(true);
}
public void GetTemplates([NotNull] DatabaseUri databaseUri, [NotNull] GetItemsCompleted <TemplateHeader> completed, bool includeBranches)
{
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(completed, nameof(completed));
ExecuteCompleted callback = delegate(string response, ExecuteResult executeResult)
{
var root = response.ToXElement();
if (root == null)
{
completed(Enumerable.Empty <TemplateHeader>());
return;
}
var result = new List <TemplateHeader>();
foreach (var child in root.Elements())
{
var itemId = new ItemId(new Guid(child.GetAttributeValue("id")));
var itemUri = new ItemUri(databaseUri, itemId);
var parentPath = (Path.GetDirectoryName(child.GetAttributeValue("path")) ?? string.Empty).Replace("\\", "/");
var template = new TemplateHeader(itemUri, child.Value, child.GetAttributeValue("icon"), child.GetAttributeValue("path"), parentPath, child.Name == "branch");
result.Add(template);
}
completed(result);
};
databaseUri.Site.DataService.ExecuteAsync("Templates.GetTemplates", callback, databaseUri.DatabaseName.ToString(), includeBranches ? "true" : "false");
}
public override bool GetChildrenAsync(ItemUri itemUri, GetItemsCompleted <ItemHeader> getChildrenCallback)
{
Assert.ArgumentNotNull(itemUri, nameof(itemUri));
Assert.ArgumentNotNull(getChildrenCallback, nameof(getChildrenCallback));
return(false);
}
public override void GetTemplatesAsync(DatabaseUri databaseUri, GetItemsCompleted <TemplateHeader> getTemplatesCallback)
{
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(getTemplatesCallback, nameof(getTemplatesCallback));
getTemplatesCallback(Enumerable.Empty <TemplateHeader>());
}
public override void Search(CommandyContext context)
{
Assert.ArgumentNotNull(context, nameof(context));
var mode = context.Mode as SearchBasedMode;
if (mode == null)
{
return;
}
if (string.IsNullOrEmpty(context.Text) || context.Text == text)
{
return;
}
mode.IsReady = false;
text = context.Text;
var s = context.Commandy.Parameter as ISiteSelectionContext;
if (s == null)
{
return;
}
GetItemsCompleted <ItemHeader> completed = delegate(IEnumerable <ItemHeader> items)
{
var hits = new List <Hit>();
foreach (var itemHeader in items)
{
var rank = 2;
if (itemHeader.Name.StartsWith(context.Text, StringComparison.InvariantCultureIgnoreCase))
{
rank = 0;
}
else if (itemHeader.Name.IsFilterMatch(context.Text))
{
rank = 1;
}
var hit = new Hit(string.Format(@"{0} - [{1}, {2}]", itemHeader.Name, itemHeader.TemplateName, itemHeader.Path), itemHeader, rank);
hits.Add(hit);
}
context.Commandy.AddHits(hits);
mode.IsReady = true;
};
s.Site.DataService.Search(context.Text, new DatabaseUri(s.Site, DatabaseName.Master), string.Empty, string.Empty, ItemUri.Empty, 0, completed);
}
protected virtual void Handle([NotNull] NewItemWizardPipeline pipeline, [NotNull] DatabaseName databaseName, [NotNull] ProjectItem projectItem, [NotNull] string itemPath, [NotNull] ProcessedEventHandler callback)
{
Debug.ArgumentNotNull(pipeline, nameof(pipeline));
Debug.ArgumentNotNull(databaseName, nameof(databaseName));
Debug.ArgumentNotNull(projectItem, nameof(projectItem));
Debug.ArgumentNotNull(itemPath, nameof(itemPath));
Debug.ArgumentNotNull(callback, nameof(callback));
var projectFile = (ProjectFileItem)projectItem;
var site = projectItem.Project.Site;
if (site == null)
{
return;
}
var databaseUri = new DatabaseUri(site, databaseName);
var name = Path.GetFileNameWithoutExtension(projectItem.Path);
GetItemsCompleted <ItemPath> completed = delegate(IEnumerable <ItemPath> items)
{
if (!items.Any())
{
callback(this, new ProcessedEventArgs(Resources.PathBasedFileItemHandler_Create_failed, Resources.PathBasedFileItemHandler_Create_Path_was_not_created));
return;
}
// create item
var parentUri = items.First().ItemUri;
var templateuri = new ItemUri(databaseUri, TemplateId);
var itemUri = site.DataService.AddFromTemplate(parentUri, templateuri, name);
UpdateFields(pipeline, projectItem, itemUri);
// done
projectFile.Items.Add(itemUri);
callback(this, new ProcessedEventArgs(Resources.PathBasedFileItemHandler_Create_created, Path.GetDirectoryName(itemPath) + @"/" + name));
Notifications.RaiseItemAdded(this, new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Version.Latest), parentUri);
if (AppHost.CurrentContentTree != null)
{
AppHost.CurrentContentTree.Locate(itemUri);
}
};
site.DataService.CreateItemPath(databaseUri, (Path.GetDirectoryName(itemPath) ?? string.Empty).Replace('\\', '/'), completed);
}
public override bool GetChildrenAsync(ItemUri itemUri, GetItemsCompleted <ItemHeader> getChildrenCallback)
{
Assert.ArgumentNotNull(itemUri, nameof(itemUri));
Assert.ArgumentNotNull(getChildrenCallback, nameof(getChildrenCallback));
EventHandler <GetChildrenCompletedEventArgs> callback = delegate(object sender, GetChildrenCompletedEventArgs args)
{
try
{
// ReSharper disable UnusedVariable
var element = args.Result;
// ReSharper restore UnusedVariable
}
catch
{
// SitecoreApplication.HandleException(ex);
AppHost.MessageBox(Resources.WebDataService_GetChildrenAsync_The_item_was_not_found__It_may_have_been_deleted_, Resources.Error, MessageBoxButton.OK, MessageBoxImage.Information);
getChildrenCallback(Enumerable.Empty <ItemHeader>());
return;
}
if (!HandleAsyncOperation(args, () => args.Result))
{
getChildrenCallback(Enumerable.Empty <ItemHeader>());
return;
}
try
{
var result = args.Result;
var items = new List <ItemHeader>();
foreach (XmlNode child in result)
{
items.Add(GetItemHeader(child, itemUri.DatabaseUri));
}
getChildrenCallback(items);
}
catch (Exception ex)
{
AppHost.Output.LogException(ex);
getChildrenCallback(Enumerable.Empty <ItemHeader>());
}
};
AppHost.Usage.ReportRequest("GetChildren");
return(Execute(() => ExecuteGetChildrenAsync(itemUri, callback), false));
}
public void Refresh()
{
Items.Clear();
GetItemsCompleted <ItemHeader> completed = delegate(IEnumerable <ItemHeader> headers)
{
foreach (var itemHeader in headers)
{
items.Add(itemHeader);
}
};
DatabaseUri.Site.DataService.Search(SearchText, DatabaseUri, string.Empty, string.Empty, ItemUri.Empty, 0, completed);
}
public override bool GetChildren(GetChildrenDelegate callback, bool async)
{
Assert.ArgumentNotNull(callback, nameof(callback));
var busy = true;
GetItemsCompleted <ItemHeader> c = delegate(IEnumerable <ItemHeader> items)
{
var result = new List <TemplatedTreeViewItem>();
var count = items.Count();
if (count > 100)
{
count = LoadManyItemsDialog.Execute(count);
if (count < 0)
{
callback(result);
return;
}
}
for (var n = 0; n < count; n++)
{
var item = items.ElementAt(n);
var i = GetTreeViewItem(item.ItemUri, item.Name, item.Icon, item.TemplateId, item.TemplateName);
result.Add(i);
}
callback(result);
busy = false;
};
DatabaseUri.Site.DataService.SelectItems(GetQueryText(), DatabaseUri, c);
if (!async)
{
while (busy)
{
AppHost.DoEvents();
}
}
return(true);
}
private void Refresh()
{
var databaseUri = DatabaseUri;
if (databaseUri == null || databaseUri == DatabaseUri.Empty)
{
AppHost.MessageBox("Please a database first.", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
var queryText = Text ?? string.Empty;
if (string.IsNullOrEmpty(queryText))
{
return;
}
var settingsKey = SettingsKey;
if (!string.IsNullOrEmpty(settingsKey))
{
AppHost.Settings.SetString("SearchBuilder", settingsKey, Code.Text);
}
GetItemsCompleted <ItemHeader> completed = delegate(IEnumerable <ItemHeader> itemHeaders)
{
items.Clear();
foreach (var itemHeader in itemHeaders)
{
items.Add(new ResultItem(itemHeader));
}
RenderResult();
};
Loading.ShowLoading(ResultList);
databaseUri.Site.DataService.Search(queryText, databaseUri, string.Empty, string.Empty, ItemUri.Empty, 0, completed);
}
private void Opened([NotNull] object sender, [NotNull] RoutedEventArgs e)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
var menuItem = e.Source as MenuItem;
if (menuItem == null)
{
return;
}
if (menuItem.Items.Count != 1)
{
return;
}
var m = menuItem.Items[0] as MenuItem;
if (m == null || m.Tag as string != @"loading")
{
return;
}
if (Context == null)
{
return;
}
var to = DateTime.Now.AddDays(1).ToString(@"yyyyMMdd");
var from = DateTime.Now.AddDays(-7).ToString(@"yyyyMMdd");
var query = string.Format(@"[{0} TO {1}]", from, to);
var fieldUri = Context.Field.FieldUris.First();
var root = new ItemUri(fieldUri.ItemVersionUri.DatabaseUri, IdManager.GetItemId("/sitecore/media library"));
GetItemsCompleted <ItemHeader> callback = items => LoadRecentMedia(menuItem, items);
fieldUri.Site.DataService.SearchMedia(query, fieldUri.ItemVersionUri.DatabaseUri, "__updated", string.Empty, root, 0, callback);
}
public override void GetTemplatesAsync(DatabaseUri databaseUri, GetItemsCompleted <TemplateHeader> getTemplatesCallback)
{
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(getTemplatesCallback, nameof(getTemplatesCallback));
EventHandler <GetTemplatesCompletedEventArgs> callback = delegate(object sender, GetTemplatesCompletedEventArgs args)
{
if (!HandleAsyncOperation(args, () => args.Result))
{
getTemplatesCallback(Enumerable.Empty <TemplateHeader>());
return;
}
var result = args.Result;
if (result == null)
{
return;
}
if (!ProcessStatus(result))
{
return;
}
var list = new List <TemplateHeader>();
foreach (XmlNode child in result)
{
list.Add(GetTemplateHeader(child, databaseUri));
}
list.Sort(this);
getTemplatesCallback(list);
};
AppHost.Usage.ReportRequest("GetTemplates");
Execute(() => ExecuteGetTemplatesAsync(databaseUri.DatabaseName, callback));
}
public static void SelectItems([NotNull] this DataService dataService, [NotNull] string queryText, [NotNull] DatabaseUri databaseUri, [NotNull] GetItemsCompleted <ItemHeader> callback)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(queryText, nameof(queryText));
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(callback, nameof(callback));
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var root = Parse(response);
if (root == null)
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var items = root.Elements().Select(element => ItemHeader.Parse(databaseUri, element)).ToList();
callback(items);
};
dataService.ExecuteAsync("Search.SelectItems", c, queryText, databaseUri.DatabaseName.ToString());
}
public static void SearchMedia([NotNull] this DataService dataService, [NotNull] string queryText, [NotNull] DatabaseUri databaseUri, [Localizable(false), NotNull] string field, [NotNull] string condition, [NotNull] ItemUri root, int pageNumber, [NotNull] GetItemsCompleted <ItemHeader> callback)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(queryText, nameof(queryText));
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(field, nameof(field));
Assert.ArgumentNotNull(condition, nameof(condition));
Assert.ArgumentNotNull(root, nameof(root));
Assert.ArgumentNotNull(callback, nameof(callback));
var databaseName = databaseUri.DatabaseName.Name;
var itemId = string.Empty;
if (root != ItemUri.Empty)
{
databaseName = root.DatabaseName.ToString();
itemId = root.ItemId.ToString();
}
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var r = Parse(response);
if (r == null)
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var result = new List <ItemHeader>();
foreach (var element in r.Elements())
{
result.Add(ItemHeader.Parse(databaseUri, element));
}
callback(result);
};
dataService.ExecuteAsync("Media.Search", c, queryText, field, condition, databaseName, itemId, pageNumber);
}
public static void Query([NotNull] this DataService dataService, [NotNull] string queryText, [NotNull] DatabaseUri databaseUri, [NotNull] GetItemsCompleted <ItemHeader> callback)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(queryText, nameof(queryText));
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(callback, nameof(callback));
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var root = Parse(response);
if (root == null)
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var result = new List <ItemHeader>();
foreach (var element in root.Elements())
{
result.Add(ItemHeader.Parse(databaseUri, element));
}
callback(result);
};
dataService.ExecuteAsync("Sitecore.Rocks.Server.Requests.Query", c, queryText);
}
public static void GetLayoutsAsync([NotNull] this DataService dataService, [NotNull] DatabaseUri databaseUri, [NotNull] GetItemsCompleted <LayoutHeader> completed)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(completed, nameof(completed));
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
completed(Enumerable.Empty <LayoutHeader>());
return;
}
var list = new List <LayoutHeader>();
var doc = GetDocument(response);
if (doc == null)
{
completed(Enumerable.Empty <LayoutHeader>());
return;
}
var root = doc.Root;
if (root == null)
{
completed(Enumerable.Empty <LayoutHeader>());
return;
}
foreach (var child in root.Elements())
{
var itemId = new ItemId(new Guid(child.GetAttributeValue("id")));
var itemUri = new ItemUri(databaseUri, itemId);
var parentPath = (Path.GetDirectoryName(child.GetAttributeValue("path")) ?? string.Empty).Replace("\\", "/");
var layout = new LayoutHeader(itemUri, child.Value, child.GetAttributeValue("icon"), child.GetAttributeValue("path"), parentPath);
list.Add(layout);
}
completed(list);
};
dataService.ExecuteAsync("Layouts.GetLayouts", c, databaseUri.DatabaseName.ToString());
}
public static void GetInsertOptions([NotNull] this DataService dataService, [NotNull] ItemUri itemUri, [NotNull] GetItemsCompleted <ItemHeader> callback)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(itemUri, nameof(itemUri));
Assert.ArgumentNotNull(callback, nameof(callback));
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var root = Parse(response);
if (root == null)
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var result = root.Elements().Select(element => ItemHeader.Parse(itemUri.DatabaseUri, element)).ToList();
callback(result);
};
dataService.ExecuteAsync("Sitecore.Rocks.Server.Requests.GetInsertOptions", c, itemUri.DatabaseName.Name, itemUri.ItemId.ToString());
}
public static void GetFiles([NotNull] this DataService dataService, [NotNull] DatabaseUri databaseUri, [NotNull] string folder, [NotNull] GetItemsCompleted <ItemHeader> callback)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(folder, nameof(folder));
Assert.ArgumentNotNull(callback, nameof(callback));
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var root = Parse(response);
if (root == null)
{
callback(Enumerable.Empty <ItemHeader>());
return;
}
var result = new List <ItemHeader>();
foreach (var element in root.Elements())
{
var name = element.GetAttributeValue("name");
var path = element.GetAttributeValue("path");
var type = element.GetAttributeValue("type");
var updated = element.GetAttributeIsoDateTime("updated", DateTime.MinValue);
var item = new ItemHeader
{
Name = name,
Path = path,
ItemUri = new ItemUri(databaseUri, ItemId.Empty),
HasChildren = type == @"folder",
Updated = updated
};
item.SetData("ServerFileName", element.GetAttributeValue("filename"));
result.Add(item);
}
callback(result);
};
dataService.ExecuteAsync("Sitecore.Rocks.Server.Requests.GetFiles", c, folder);
}
public override void GetTemplates(TemplateSelectorFiltersParameters parameters, GetItemsCompleted <TemplateHeader> completed)
{
Assert.ArgumentNotNull(parameters, nameof(parameters));
Assert.ArgumentNotNull(completed, nameof(completed));
var templates = Templates;
if (templates == null)
{
completed(Enumerable.Empty <TemplateHeader>());
return;
}
var templateList = templates.ToList();
var recent = RecentTemplateManager.GetTemplates(parameters.DatabaseUri);
var result = recent.Where(templateHeader => templateList.Any(t => t.TemplateUri == templateHeader.TemplateUri)).ToList();
completed(result);
}
public abstract void GetRenderings(RenderingSelectorFilterParameters parameters, GetItemsCompleted <ItemHeader> completed);
public void SelectItems([NotNull] DatabaseUri databaseUri, [NotNull] string queryText, [NotNull] GetItemsCompleted <ItemHeader> completed)
{
Assert.ArgumentNotNull(queryText, nameof(queryText));
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(completed, nameof(completed));
databaseUri.Site.DataService.SelectItems(queryText, databaseUri, completed);
}
public override void GetRenderings(RenderingSelectorFilterParameters parameters, GetItemsCompleted <ItemHeader> completed)
{
Assert.ArgumentNotNull(parameters, nameof(parameters));
Assert.ArgumentNotNull(completed, nameof(completed));
if (Renderings == null)
{
completed(Enumerable.Empty <ItemHeader>());
return;
}
var filtered = Renderings;
if (!string.IsNullOrEmpty(FilterText))
{
filtered = filtered.Where(r => r.Name.IsFilterMatch(FilterText)).ToList();
}
if (!string.IsNullOrEmpty(RootPath))
{
filtered = filtered.Where(r => r.Path.StartsWith(RootPath, StringComparison.InvariantCultureIgnoreCase)).ToList();
}
completed(filtered);
}
public abstract bool GetChildrenAsync([NotNull] ItemUri itemUri, [NotNull] GetItemsCompleted <ItemHeader> getChildrenCallback);
public override void Handle(DatabaseName databaseName, ProjectItem projectItem, string itemPath, ProcessedEventHandler callback)
{
Assert.ArgumentNotNull(databaseName, nameof(databaseName));
Assert.ArgumentNotNull(projectItem, nameof(projectItem));
Assert.ArgumentNotNull(itemPath, nameof(itemPath));
Assert.ArgumentNotNull(callback, nameof(callback));
var projectFile = (ProjectFileItem)projectItem;
var serverPath = @"/" + projectFile.Path.Replace('\\', '/');
var site = projectItem.Project.Site;
if (site == null)
{
return;
}
var databaseUri = new DatabaseUri(site, databaseName);
if (string.IsNullOrEmpty(itemPath))
{
itemPath = GetItemPath(projectItem);
}
var name = Path.GetFileNameWithoutExtension(projectItem.Path) ?? string.Empty;
GetItemsCompleted <ItemPath> completed = delegate(IEnumerable <ItemPath> items)
{
if (!items.Any())
{
callback(this, new ProcessedEventArgs(Resources.PathBasedFileItemHandler_Create_failed, Resources.PathBasedFileItemHandler_Create_Path_was_not_created));
return;
}
// create item
var parentUri = items.First().ItemUri;
var templateuri = new ItemUri(databaseUri, TemplateId);
var itemUri = site.DataService.AddFromTemplate(parentUri, templateuri, name);
// set "Path" field
var pathField = new Field
{
Value = serverPath,
HasValue = true
};
pathField.FieldUris.Add(new FieldUri(new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Version.Latest), FieldId));
var fields = new List <Field>
{
pathField
};
site.DataService.Save(databaseName, fields);
// done
projectFile.Items.Add(itemUri);
callback(this, new ProcessedEventArgs(Resources.PathBasedFileItemHandler_Create_created, Path.GetDirectoryName(itemPath) + @"/" + name));
Notifications.RaiseItemAdded(this, new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Version.Latest), parentUri);
if (AppHost.CurrentContentTree != null)
{
AppHost.CurrentContentTree.Locate(itemUri);
}
};
site.DataService.CreateItemPath(databaseUri, (Path.GetDirectoryName(itemPath) ?? string.Empty).Replace('\\', '/'), completed);
}
public static void Validate([NotNull] this DataService dataService, [NotNull] DatabaseUri databaseUri, [NotNull] List <Field> fields, [NotNull] GetItemsCompleted <Validator> callback)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(fields, nameof(fields));
Assert.ArgumentNotNull(callback, nameof(callback));
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
callback(Enumerable.Empty <Validator>());
return;
}
var root = Parse(response);
if (root == null)
{
callback(Enumerable.Empty <Validator>());
return;
}
var result = new List <Validator>();
foreach (var element in root.Elements())
{
var fieldId = element.GetAttributeValue("fieldid");
var validate = new Validator
{
Text = element.Value,
Result = (ValidatorResult)int.Parse(element.GetAttributeValue("result")),
FieldId = string.IsNullOrEmpty(fieldId) ? Guid.Empty : new Guid(fieldId),
ValidatorId = new Guid(element.GetAttributeValue("validatorid"))
};
result.Add(validate);
}
callback(result);
};
dataService.ExecuteAsync("Sitecore.Rocks.Server.Requests.Validate", c, databaseUri.DatabaseName.Name, GetFieldsXml(fields, false));
}
public static void CreateItemPath([NotNull] this DataService dataService, [NotNull] DatabaseUri databaseUri, [NotNull] string path, [NotNull] GetItemsCompleted <ItemPath> callback)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(path, nameof(path));
Assert.ArgumentNotNull(callback, nameof(callback));
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
callback(Enumerable.Empty <ItemPath>());
return;
}
var root = Parse(response);
if (root == null)
{
callback(Enumerable.Empty <ItemPath>());
return;
}
var result = new List <ItemPath>();
foreach (var element in root.Elements())
{
var itemPath = new ItemPath
{
Name = element.GetAttributeValue("name"),
ItemUri = new ItemUri(databaseUri, new ItemId(new Guid(element.GetAttributeValue("id"))))
};
result.Add(itemPath);
}
callback(result);
};
dataService.ExecuteAsync("Sitecore.Rocks.Server.Requests.CreateItemPath", c, databaseUri.DatabaseName.Name, path);
}
public override void GetTemplates(TemplateSelectorFiltersParameters parameters, GetItemsCompleted <TemplateHeader> completed)
{
Assert.ArgumentNotNull(parameters, nameof(parameters));
Assert.ArgumentNotNull(completed, nameof(completed));
if (Templates == null)
{
completed(Enumerable.Empty <TemplateHeader>());
return;
}
completed(Templates);
}
public abstract void GetTemplatesAsync([NotNull] DatabaseUri databaseUri, [NotNull] GetItemsCompleted <TemplateHeader> getTemplatesCallback);
public override void GetRenderings(RenderingSelectorFilterParameters parameters, GetItemsCompleted <ItemHeader> completed)
{
Assert.ArgumentNotNull(parameters, nameof(parameters));
Assert.ArgumentNotNull(completed, nameof(completed));
var renderings = Renderings;
if (renderings == null)
{
completed(Enumerable.Empty <ItemHeader>());
return;
}
var list = AppHost.Settings.Get(ControlsRenderingSelectorRecent, GetStorageKey(parameters.DatabaseUri), string.Empty) as string;
if (string.IsNullOrEmpty(list))
{
completed(Enumerable.Empty <ItemHeader>());
return;
}
var result = new List <ItemHeader>();
var items = list.Split('|');
foreach (var item in items)
{
var parts = item.Split('^');
if (parts.Length != 4)
{
continue;
}
var name = parts[0];
var itemId = new ItemId(new Guid(parts[1]));
var templateName = parts[2];
var path = parts[3];
var itemUri = new ItemUri(parameters.DatabaseUri, itemId);
if (renderings.All(t => t.ItemUri != itemUri))
{
continue;
}
var itemHeader = new ItemHeader
{
Name = name,
ItemUri = itemUri,
ParentName = Resources.Recent,
Path = path,
TemplateName = templateName
};
result.Add(itemHeader);
}
completed(result);
}
