public void LoadStatistics()
{
ExecuteCompleted callback = delegate(string response, ExecuteResult executeResult)
{
Loading.Swap(StatisticsList);
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
ParseStatistics(root);
RenderStatistics();
};
Loading.ShowLoading(StatisticsList);
Context.Site.DataService.ExecuteAsync("Statistics.GetStatistics", callback);
}
protected override void Execute(DatabaseUri databaseUri, ExecuteCompleted callback)
{
Debug.ArgumentNotNull(databaseUri, nameof(databaseUri));
Debug.ArgumentNotNull(callback, nameof(callback));
databaseUri.Site.DataService.SerializeDatabase(databaseUri, callback);
}
public override void Execute(object parameter)
{
var context = parameter as IndexViewerContext;
if (context == null)
{
return;
}
var index = context.IndexViewer.GetSelectedIndex();
if (index == null)
{
return;
}
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
AppHost.MessageBox(string.Format("Rebuilding \"{0}\"...", index.Name), "Information", MessageBoxButton.OK, MessageBoxImage.Information);
};
context.IndexViewer.Context.Site.DataService.ExecuteAsync("Indexes.RebuildIndex", completed, index.Name);
}
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);
}
private void ControlLoaded([NotNull] object sender, [NotNull] RoutedEventArgs e)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
Loaded -= ControlLoaded;
ExecuteCompleted c = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
Loading.HideLoading(ValidationList);
return;
}
var root = response.ToXElement();
if (root == null)
{
Loading.HideLoading(ValidationList);
return;
}
ParseValidations(root);
GetCustomValidations();
RenderValidations();
};
Site.DataService.ExecuteAsync("Validations.GetValidations", c, "Site");
}
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 void Execute(object parameter)
{
var context = parameter as CacheViewerContext;
if (context == null)
{
return;
}
if (AppHost.MessageBox("Are you sure you want to clear all the caches?", "Confirmation", MessageBoxButton.OKCancel, MessageBoxImage.Question) != MessageBoxResult.OK)
{
return;
}
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
context.CacheViewer.LoadCaches();
};
context.CacheViewer.Context.Site.DataService.ExecuteAsync("Caches.ClearAll", completed);
}
public override void Execute(object parameter)
{
var context = parameter as IItemSelectionContext;
if (context == null)
{
return;
}
var item = context.Items.FirstOrDefault() as ITemplatedItem;
if (item == null)
{
return;
}
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
var placeHolders = AppHost.Prompt("Placeholders", "Placeholders", response);
if (placeHolders == null)
{
return;
}
AppHost.Server.UpdateItem(item.ItemUri, "Place Holders", placeHolders);
};
AppHost.Server.XmlLayouts.AnalyzePlaceholdersInView(item.ItemUri, completed);
}
public void LoadCaches()
{
if (Context.Site.SitecoreVersion < Constants.Versions.Version82)
{
AppHost.Shell.MessageBox("Cache management is not supported in Sitecore 8.1 and earlier", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
Loading.Swap(CacheList);
RenderCaches();
return;
}
ExecuteCompleted callback = delegate(string response, ExecuteResult executeResult)
{
Loading.Swap(CacheList);
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
ParseCaches(root);
RenderCaches();
};
Loading.ShowLoading(CacheList);
Context.Site.DataService.ExecuteAsync("Caches.GetCaches", callback);
}
public override void Execute(object parameter)
{
var context = parameter as IItemSelectionContext;
if (context == null)
{
return;
}
if (AppHost.MessageBox("Are you sure you want to remove ownership?", "Confirmation", MessageBoxButton.OKCancel, MessageBoxImage.Question) != MessageBoxResult.OK)
{
return;
}
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
var fieldId = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Security/Security/__Owner");
foreach (var item in context.Items)
{
var itemHeader = item as ItemTreeViewItem;
if (itemHeader == null)
{
continue;
}
itemHeader.Item.Ownership = string.Empty;
var fieldUri = new FieldUri(new ItemVersionUri(item.ItemUri, LanguageManager.CurrentLanguage, Version.Latest), fieldId);
Notifications.RaiseFieldChanged(this, fieldUri, string.Empty);
}
};
var itemList = new StringBuilder();
IItem first = null;
foreach (var item in context.Items)
{
if (first == null)
{
first = item;
}
else
{
itemList.Append("|");
}
itemList.Append(item.ItemUri.ItemId);
}
if (first != null)
{
first.ItemUri.Site.DataService.ExecuteAsync("Security.ClearOwnership", completed, first.ItemUri.DatabaseName.Name, itemList.ToString());
}
}
public override void Execute(object parameter)
{
var context = parameter as IItemSelectionContext;
if (context == null)
{
return;
}
if (string.IsNullOrEmpty(Script))
{
return;
}
var isBusy = true;
var item = context.Items.First();
ExecuteCompleted c = delegate(string response, ExecuteResult result)
{
DataService.HandleExecute(response, result, true);
isBusy = false;
};
item.ItemUri.DatabaseUri.Site.DataService.ExecuteAsync("QueryAnalyzer.Run", c, item.ItemUri.DatabaseUri.DatabaseName.ToString(), item.ItemUri.ItemId.ToString(), Script, "0");
// TODO: do timeout
while (isBusy)
{
AppHost.DoEvents();
}
}
public void LoadTerms()
{
ExecuteCompleted callback = delegate(string response, ExecuteResult executeResult)
{
Loading.HideLoading(ContextMenuPanel);
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
ParseTerms(root);
RenderTerms();
};
Loading.ShowLoading(ContextMenuPanel);
Site.DataService.ExecuteAsync("Indexes.GetTerms", callback, IndexName, FieldName);
}
public void Refresh()
{
if (IsLoading)
{
return;
}
Loading.ShowLoading(ListView);
ExecuteCompleted completed = delegate(string response, ExecuteResult executeresult)
{
Loading.HideLoading(ListView);
ListView.ItemsSource = null;
if (!DataService.HandleExecute(response, executeresult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
ParseItems(root, Site);
RenderItems();
};
var fromDate = DateTimeExtensions.ToIsoDate(FromDateTimeBox.Value ?? DateTime.UtcNow);
var toDate = DateTimeExtensions.ToIsoDate(ToDateTimeBox.Value ?? DateTime.UtcNow);
Site.DataService.ExecuteAsync("Items.GetModifiedItems", completed, string.Empty, fromDate, toDate);
}
private void TestClick([NotNull] object sender, [NotNull] RoutedEventArgs e)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
var type = ClassName.Text;
if (!string.IsNullOrEmpty(AssemblyName.Text))
{
type += "," + AssemblyName.Text;
}
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
if (response == "ok")
{
AppHost.MessageBox("Yes, it works!", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
AppHost.MessageBox("Nope, doesn't work!", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
};
Site.DataService.ExecuteAsync("Sites.TestTypeAndAssembly", completed, type);
}
private void HandleTextChanged([NotNull] object sender, [NotNull] TextChangedEventArgs e)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
if (string.IsNullOrEmpty(LayoutSelector.Text))
{
Path.Text = "[No Layout]";
return;
}
Path.Text = "[Updating Layout]";
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result, true))
{
Path.Text = "[Layout not found]";
return;
}
var element = response.ToXElement();
if (element == null)
{
return;
}
var itemHeader = ItemHeader.Parse(Device.DatabaseUri, element);
Path.Text = itemHeader.Path;
};
Device.DatabaseUri.Site.DataService.ExecuteAsync("Items.GetItemHeader", completed, LayoutSelector.Text, Device.DatabaseUri.DatabaseName.Name);
}
private void ControlLoaded([NotNull] object sender, [NotNull] RoutedEventArgs e)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
Loaded -= ControlLoaded;
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
Loading.HideLoading(Tabs);
if (!DataService.HandleExecute(response, result))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
Parse(root);
RenderAnalysis();
};
Loading.ShowLoading(Tabs);
Site.DataService.ExecuteAsync("Packages.AnalyzePackage", completed, ServerFileName);
}
private void Refresh()
{
if (ContentEditor.ContentModel.IsEmpty)
{
Links.Children.Clear();
return;
}
Loading.ShowLoading(Links);
var item = ContentEditor.ContentModel.FirstItem;
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
Loading.HideLoading(Links);
if (!DataService.HandleExecute(response, result))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
RenderLinks(root);
};
item.ItemUri.Site.DataService.ExecuteAsync("Items.GetItemUrls", completed, item.ItemUri.DatabaseName.ToString(), item.ItemUri.ItemId.ToString());
}
public void Save()
{
var layoutDefinition = SaveLayout();
if (!CheckSpeakCoreVersion())
{
return;
}
AppHost.Output.Log(@"Saving layout: " + layoutDefinition);
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
AppHost.Output.Log(@"Saved layout: " + response);
foreach (var fieldUri in FieldUris)
{
Notifications.RaiseFieldChanged(this, fieldUri, layoutDefinition);
}
};
foreach (var fieldUri in FieldUris)
{
fieldUri.Site.DataService.ExecuteAsync("Layouts.SaveLayout", completed, fieldUri.DatabaseName.ToString(), fieldUri.ItemId.ToString(), fieldUri.Language.ToString(), fieldUri.Version.ToString(), fieldUri.FieldId.ToString(), layoutDefinition);
}
Modified = false;
}
public void ExpandTo([NotNull] DatabaseUri databaseUri, [NotNull] string itemPath)
{
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(itemPath, nameof(itemPath));
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
Guid guid;
if (!Guid.TryParse(response, out guid))
{
return;
}
var itemUri = new ItemUri(databaseUri, new ItemId(guid));
ExpandTo(itemUri);
};
databaseUri.Site.DataService.ExecuteAsync("Items.GetItemId", completed, itemPath, databaseUri.DatabaseName.ToString());
}
private void LoadLayout([NotNull] string layout, [NotNull] Action loaded)
{
Debug.ArgumentNotNull(layout, nameof(layout));
Debug.ArgumentNotNull(loaded, nameof(loaded));
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
loaded();
return;
}
var layoutDefinition = response.ToXElement();
if (layoutDefinition == null)
{
loaded();
return;
}
isLoadingView = true;
try
{
LayoutDesignerView.LoadLayout(DatabaseUri, layoutDefinition);
loaded();
}
finally
{
isLoadingView = false;
}
};
AppHost.Server.GetLayout(layout, DatabaseUri, completed);
}
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 Edit([NotNull] ItemUri itemUri, [NotNull] string fieldName, [NotNull] string value)
{
Assert.ArgumentNotNull(itemUri, nameof(itemUri));
Assert.ArgumentNotNull(fieldName, nameof(fieldName));
Assert.ArgumentNotNull(value, nameof(value));
ExecuteCompleted callback = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var parts = response.Split(',');
Guid fieldGuid;
if (!Guid.TryParse(parts[0], out fieldGuid))
{
return;
}
var fieldUri = new FieldUri(new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Version.Latest), new FieldId(fieldGuid));
Notifications.RaiseFieldChanged(fieldUri, fieldUri, value);
};
itemUri.DatabaseUri.Site.DataService.ExecuteAsync("Items.SetFieldValue", callback, itemUri.DatabaseUri.DatabaseName.ToString(), itemUri.ItemId.ToString(), LanguageManager.CurrentLanguage.ToString(), Version.Latest.ToString(), fieldName, value);
}
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());
}
protected override string GetOutput()
{
var site = GetSite();
if (site == null)
{
return("// The Visual Studio project is not connected to a Sitecore web site. Right-click the project, select Sitecore and Connect.");
}
var databaseName = GetDatabaseName(InputFileContents);
string result = null;
ExecuteCompleted completed = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
result = string.Empty;
return;
}
result = response ?? string.Empty;
};
site.DataService.ExecuteAsync("CodeGeneration.XsltGenerator", completed, databaseName, InputFileContents);
while (result == null)
{
AppHost.DoEvents();
}
return(result);
}
public void LoadCacheKeys()
{
ExecuteCompleted callback = delegate(string response, ExecuteResult executeResult)
{
Loading.HideLoading(ContextMenuPanel);
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
ParseCacheKeys(root);
RenderCacheKeys();
Keyboard.Focus(CacheKeyList);
};
Loading.ShowLoading(ContextMenuPanel);
Site.DataService.ExecuteAsync("Caches.GetCacheKeys", callback, CacheName);
}
public void LoadIndexes()
{
ExecuteCompleted completed = delegate(string response, ExecuteResult executeResult)
{
Loading.Swap(IndexList);
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
ParseIndexes(root);
RenderIndexes();
};
Loading.ShowLoading(IndexList);
Context.Site.DataService.ExecuteAsync("Indexes.GetIndexes", completed);
}
protected override void Execute(ItemUri itemUri, ExecuteCompleted callback)
{
Debug.ArgumentNotNull(itemUri, nameof(itemUri));
Debug.ArgumentNotNull(callback, nameof(callback));
itemUri.Site.DataService.UpdateItem(itemUri, callback);
}
private void UpdatePath()
{
PathTextBlock.Text = "[Image has been updated]";
var fieldUri = sourceField.FieldUris.FirstOrDefault();
if (fieldUri == null)
{
return;
}
PathTextBlock.Text = "[Updating image]";
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result, true))
{
PathTextBlock.Text = "[Image not found]";
return;
}
var element = response.ToXElement();
if (element == null)
{
return;
}
var itemHeader = ItemHeader.Parse(fieldUri.DatabaseUri, element);
PathTextBlock.Text = itemHeader.Path;
};
AppHost.Server.Items.GetItemHeader(MediaUri, completed);
}
public void LoadLanguages()
{
ExecuteCompleted callback = delegate(string response, ExecuteResult executeResult)
{
Loading.Swap(LanguageList);
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
ParseLanguages(root);
RenderLanguages();
};
Loading.ShowLoading(LanguageList);
Context.DatabaseUri.Site.DataService.ExecuteAsync("Languages.GetLanguages", callback, Context.DatabaseUri.DatabaseName.ToString());
}
public void LoadFileFolders()
{
ExecuteCompleted callback = delegate(string response, ExecuteResult executeResult)
{
Loading.Swap(FolderList);
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
ParseFileFolders(root);
RenderFileFolders();
};
Loading.ShowLoading(FolderList);
Context.Site.DataService.ExecuteAsync("Files.GetTempFolders", callback);
}
