private TreeViewItem GetLeaf([NotNull] ValidationIssue issue, [NotNull] string text, [CanBeNull] Icon icon)
{
Debug.ArgumentNotNull(issue, nameof(issue));
Debug.ArgumentNotNull(text, nameof(text));
var header = new LeafHeader
{
Text = text
};
header.DoubleClick += delegate
{
var itemVersionUri = new ItemVersionUri(issue.ItemUri, LanguageManager.CurrentLanguage, Data.Version.Latest);
AppHost.OpenContentEditor(itemVersionUri);
};
if (icon != null)
{
header.Icon = icon;
}
var result = new TreeViewItem
{
Header = header,
Tag = issue
};
return(result);
}
public override void Execute(object parameter)
{
var context = parameter as ContentEditorContext;
if (context == null)
{
return;
}
var contentModel = context.ContentEditor.ContentModel;
if (contentModel.IsEmpty || contentModel.IsMultiple)
{
return;
}
var item = contentModel.FirstItem;
var deletedVersionUri = item.Uri;
item.Uri.Site.DataService.RemoveVersion(item.Uri);
var versionUri = new ItemVersionUri(item.Uri.ItemUri, item.Uri.Language, Version.Latest);
AppHost.OpenContentEditor(versionUri);
Notifications.RaiseVersionRemoved(this, deletedVersionUri, versionUri);
}
public override void Execute(object parameter)
{
var context = parameter as ContentTreeContext;
if (context == null)
{
return;
}
var itemTreeViewItem = context.SelectedItems.FirstOrDefault() as ItemTreeViewItem;
if (itemTreeViewItem == null)
{
return;
}
var item = itemTreeViewItem.Item;
if (!CanDesign(item))
{
return;
}
var layoutUri = new ItemVersionUri(new ItemUri(item.ItemUri.DatabaseUri, item.StandardValuesId), LanguageManager.CurrentLanguage, Version.Latest);
GetValueCompleted <Item> completed = i => AppHost.Env.LayoutDesigner().Open("PageDesigner" + i.Uri, i);
item.ItemUri.Site.DataService.GetItemFieldsAsync(layoutUri, completed);
}
private Item GetItem([NotNull] ItemVersionUri uri, [NotNull] XmlElement root)
{
Debug.ArgumentNotNull(uri, nameof(uri));
Debug.ArgumentNotNull(root, nameof(root));
return(WebServiceMethods.GetItem.Call(uri, root));
}
protected override void ExecuteAddVersionAsync(ItemVersionUri uri, EventHandler <NewWebService.AddVersionCompletedEventArgs> callback)
{
Debug.ArgumentNotNull(uri, nameof(uri));
Debug.ArgumentNotNull(callback, nameof(callback));
DataService.AddVersionAsync(uri.ItemId.ToString(), uri.Language.Name, uri.ItemUri.DatabaseName.Name, GetCredentials(), callback);
}
public override void AddVersion(ItemVersionUri uri, GetValueCompleted <Version> callback)
{
Assert.ArgumentNotNull(uri, nameof(uri));
Assert.ArgumentNotNull(callback, nameof(callback));
EventHandler <AddVersionCompletedEventArgs> c = delegate(object sender, AddVersionCompletedEventArgs args)
{
if (!HandleAsyncOperation(args, () => args.Result))
{
callback(Version.Empty);
return;
}
var result = args.Result;
var data = result.SelectSingleNode(@"/data/data");
if (data == null)
{
callback(Version.Empty);
return;
}
int version;
if (!int.TryParse(data.InnerText, out version))
{
callback(Version.Empty);
return;
}
callback(new Version(version));
};
Execute(() => ExecuteAddVersionAsync(uri, c));
}
private void HandleDropFiles([NotNull] string[] droppedFilePaths)
{
Diagnostics.Debug.ArgumentNotNull(droppedFilePaths, nameof(droppedFilePaths));
var site = Item.ItemUri.Site;
if (!site.DataService.CanExecuteAsync("Media.Upload"))
{
AppHost.MessageBox(string.Format(Rocks.Resources.MediaSkinListBox_HandleDropFiles_, site.DataServiceName), Rocks.Resources.Information, MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
GetValueCompleted <ItemHeader> uploadCompleted = delegate(ItemHeader value)
{
if (droppedFilePaths.Length != 1)
{
return;
}
var item = new ItemTreeViewItem(value);
Items.Add(item);
var itemVersionUri = new ItemVersionUri(value.ItemUri, LanguageManager.CurrentLanguage, Data.Version.Latest);
AppHost.OpenContentEditor(itemVersionUri);
};
MediaManager.Upload(Item.ItemUri.DatabaseUri, Item.Path, droppedFilePaths, uploadCompleted);
}
public override void AddVersion(ItemVersionUri uri, GetValueCompleted <Version> callback)
{
Assert.ArgumentNotNull(uri, nameof(uri));
Assert.ArgumentNotNull(callback, nameof(callback));
callback(Version.Empty);
}
public override void Execute(object parameter)
{
var context = parameter as IItemSelectionContext;
if (context == null)
{
return;
}
var item = context.Items.First();
if (item == null)
{
return;
}
if (!CanDesign(item))
{
return;
}
var itemUri = new ItemVersionUri(item.ItemUri, LanguageManager.CurrentLanguage, Version.Latest);
GetValueCompleted <Item> completed = i => AppHost.Env.LayoutDesigner().Open("PageDesigner" + itemUri, i);
itemUri.Site.DataService.GetItemFieldsAsync(itemUri, completed);
}
public override void Execute(object parameter)
{
var context = parameter as ContentEditorFieldContext;
if (context == null)
{
return;
}
var fieldControl = context.Field.Control;
if (fieldControl == null)
{
return;
}
var value = fieldControl.GetValue();
Guid id;
if (!Guid.TryParse(value, out id))
{
return;
}
var field = context.Field.FieldUris.First();
var itemId = new ItemId(id);
var uri = new ItemVersionUri(new ItemUri(field.ItemVersionUri.ItemUri.DatabaseUri, itemId), field.Language, Data.Version.Latest);
AppHost.OpenContentEditor(uri);
}
public override void Execute(object parameter)
{
var context = parameter as ContentEditorContext;
if (context == null)
{
return;
}
var contentModel = context.ContentEditor.ContentModel;
if (contentModel.IsEmpty || contentModel.IsMultiple)
{
return;
}
var item = contentModel.FirstItem;
GetValueCompleted <Version> callback = delegate(Version value)
{
if (value == Version.Empty)
{
AppHost.MessageBox(Resources.Failed_to_add_a_new_version, Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var newUri = new ItemVersionUri(item.Uri.ItemUri, item.Uri.Language, value);
AppHost.OpenContentEditor(newUri);
Notifications.RaiseVersionAdded(this, newUri);
};
item.Uri.Site.DataService.AddVersion(item.Uri, callback);
}
private void AddInsertOption([NotNull] ItemHeader itemHeader, [NotNull] ItemUri templateUri)
{
Debug.ArgumentNotNull(itemHeader, nameof(itemHeader));
Debug.ArgumentNotNull(templateUri, nameof(templateUri));
var itemUri = itemHeader.ItemUri;
if (itemHeader.StandardValuesId != ItemId.Empty)
{
var options = new TaskDialogOptions
{
Title = "Add to Insert Options",
CommonButtons = TaskDialogCommonButtons.None,
MainInstruction = "Where do you want to add the Insert Option?",
MainIcon = VistaTaskDialogIcon.Information,
DefaultButtonIndex = 0,
CommandButtons = new[]
{
"Standard Values Item",
string.Format("The \"{0}\" Item", itemHeader.Name)
},
AllowDialogCancellation = true
};
var r = TaskDialog.Show(options).CommandButtonResult;
if (r == null)
{
return;
}
if (r == 0)
{
itemUri = new ItemUri(itemUri.DatabaseUri, itemHeader.StandardValuesId);
}
}
var itemVersionUri = new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Version.Latest);
GetValueCompleted <Item> completed = delegate(Item item)
{
var fieldId = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Insert Options/Insert Options/__Masters");
var value = templateUri.ItemId.ToString();
var field = item.Fields.FirstOrDefault(f => f != null && f.FieldUris.First().FieldId == fieldId);
if (field == null)
{
return;
}
if (!string.IsNullOrEmpty(field.Value) && !field.Value.Contains(value))
{
value = field.Value + @"|" + value;
}
AppHost.Server.UpdateItem(itemUri, fieldId, value);
};
AppHost.Server.GetItem(itemVersionUri, completed);
}
public void GetItem([NotNull] ItemVersionUri itemVersionUri, [NotNull] GetValueCompleted <Item> completed)
{
Assert.ArgumentNotNull(itemVersionUri, nameof(itemVersionUri));
Assert.ArgumentNotNull(completed, nameof(completed));
itemVersionUri.Site.DataService.GetItemFieldsAsync(itemVersionUri, completed);
}
public void Save()
{
Refresh();
var writer = new StringWriter();
var output = new XmlTextWriter(writer);
output.WriteStartElement(@"fields");
foreach (var template in Model)
{
foreach (var field in template.Fields)
{
if (!field.Modified)
{
continue;
}
output.WriteStartElement(@"field");
output.WriteAttributeString(@"id", field.TemplateFieldId.ToString());
output.WriteAttributeString(@"sortorder", field.SortOrder.ToString());
output.WriteAttributeString(@"sectionsortorder", field.SectionSortOrder.ToString());
output.WriteEndElement();
field.Modified = false;
}
}
output.WriteEndElement();
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
Modified = false;
var fieldId = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Appearance/Appearance/__Sortorder");
foreach (var template in Model)
{
foreach (var field in template.Fields)
{
var itemVersionUri = new ItemVersionUri(new ItemUri(template.TemplateUri.DatabaseUri, field.TemplateFieldId), LanguageManager.CurrentLanguage, Data.Version.Latest);
var fieldUri = new FieldUri(itemVersionUri, fieldId);
Notifications.RaiseFieldChanged(this, fieldUri, field.SortOrder.ToString());
itemVersionUri = new ItemVersionUri(new ItemUri(template.TemplateUri.DatabaseUri, new ItemId(new Guid(field.SectionId))), LanguageManager.CurrentLanguage, Data.Version.Latest);
fieldUri = new FieldUri(itemVersionUri, fieldId);
Notifications.RaiseFieldChanged(this, fieldUri, field.SortOrder.ToString());
}
}
};
TemplateUri.Site.DataService.ExecuteAsync("Templates.SaveTemplateFieldSorterFields", completed, TemplateUri.DatabaseName.ToString(), writer.ToString());
}
protected override bool ExecuteGetItemFieldsAsync(ItemVersionUri itemVersionUri, EventHandler <NewWebService.GetItemFieldsCompletedEventArgs> callback)
{
Debug.ArgumentNotNull(itemVersionUri, nameof(itemVersionUri));
Debug.ArgumentNotNull(callback, nameof(callback));
DataService.GetItemFieldsAsync(itemVersionUri.ItemUri.ItemId.ToString(), itemVersionUri.Language.Name, itemVersionUri.Version.ToString(), true, itemVersionUri.ItemUri.DatabaseName.Name, GetCredentials(), callback);
return(true);
}
public void UpdateItem([NotNull] ItemVersionUri itemVersionUri, [NotNull] string fieldName, [NotNull] string value)
{
Assert.ArgumentNotNull(itemVersionUri, nameof(itemVersionUri));
Assert.ArgumentNotNull(fieldName, nameof(fieldName));
Assert.ArgumentNotNull(value, nameof(value));
ItemModifier.Edit(itemVersionUri, fieldName, value);
}
public override void Execute(object parameter)
{
var context = parameter as ContentTreeContext;
if (context == null)
{
return;
}
var item = context.SelectedItems.FirstOrDefault() as ItemTreeViewItem;
if (item == null)
{
return;
}
var parentUri = item.ItemUri;
// create __Standard Values item
var templateUri = item.ItemUri;
var standardValuesItemUri = parentUri.Site.DataService.AddFromTemplate(parentUri, templateUri, @"__Standard Values");
if (standardValuesItemUri == ItemUri.Empty)
{
return;
}
// set "Standard Values" field
var standardValuesFieldId = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Advanced/Advanced/__Standard values");
var standardValuesField = new Field
{
Value = standardValuesItemUri.ItemId.ToString(),
HasValue = true
};
standardValuesField.FieldUris.Add(new FieldUri(new ItemVersionUri(item.ItemUri, LanguageManager.CurrentLanguage, Version.Latest), standardValuesFieldId));
var fields = new List <Field>
{
standardValuesField
};
ItemModifier.Edit(standardValuesItemUri.DatabaseUri, fields, true);
// expand tree
context.ContentTree.ExpandTo(standardValuesItemUri);
var itemVersionUri = new ItemVersionUri(standardValuesItemUri, LanguageManager.CurrentLanguage, Version.Latest);
item.Item.StandardValuesId = standardValuesItemUri.ItemId;
item.Item.StandardValuesField = standardValuesItemUri.ItemId;
AppHost.OpenContentEditor(itemVersionUri);
Notifications.RaiseItemAdded(this, itemVersionUri, parentUri);
}
private void Save()
{
var publishFrom = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Publishing/Publishing/__Publish");
var publishTo = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Publishing/Publishing/__Unpublish");
var neverPublish = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Publishing/Publishing/__Never publish");
var validTo = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Lifetime/Lifetime/__Valid to");
var validFrom = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Lifetime/Lifetime/__Valid from");
var hideVersion = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Lifetime/Lifetime/__Hide version");
var publishingGroups = IdManager.GetFieldId("/sitecore/templates/System/Templates/Sections/Publishing/Publishing/__Publishing groups");
var fields = new List <Tuple <FieldUri, string> >();
fields.Add(new Tuple <FieldUri, string>(new FieldUri(ItemUri, publishFrom), ToIsoDateTime(ItemPublishFrom.Value)));
fields.Add(new Tuple <FieldUri, string>(new FieldUri(ItemUri, publishTo), ToIsoDateTime(ItemPublishTo.Value)));
fields.Add(new Tuple <FieldUri, string>(new FieldUri(ItemUri, neverPublish), ItemPublishable.IsChecked == true ? string.Empty : @"1"));
foreach (var restriction in restrictions)
{
var itemVersionUri = new ItemVersionUri(ItemUri.ItemUri, ItemUri.Language, new Data.Version(restriction.Version));
fields.Add(new Tuple <FieldUri, string>(new FieldUri(itemVersionUri, validFrom), ToIsoDateTime(restriction.PublishFrom)));
fields.Add(new Tuple <FieldUri, string>(new FieldUri(itemVersionUri, validTo), ToIsoDateTime(restriction.PublishTo)));
fields.Add(new Tuple <FieldUri, string>(new FieldUri(itemVersionUri, hideVersion), restriction.Publishable ? string.Empty : @"1"));
}
var targets = string.Empty;
foreach (var item in PublishingTargets.Items)
{
var listBoxItem = item as ListBoxItem;
if (listBoxItem == null)
{
continue;
}
if (!listBoxItem.IsSelected)
{
continue;
}
var publishingTarget = listBoxItem.Tag as PublishingTarget;
if (publishingTarget == null)
{
continue;
}
if (!string.IsNullOrEmpty(targets))
{
targets += @"|";
}
targets += publishingTarget.Id;
}
fields.Add(new Tuple <FieldUri, string>(new FieldUri(ItemUri, publishingGroups), targets));
ItemModifier.Edit(ItemUri.DatabaseUri, fields);
}
public static void ChangeTemplate([NotNull] this DataService dataService, [NotNull] ItemVersionUri itemUri, [NotNull] ItemUri templateUri, [NotNull] ExecuteCompleted callback)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(itemUri, nameof(itemUri));
Assert.ArgumentNotNull(templateUri, nameof(templateUri));
Assert.ArgumentNotNull(callback, nameof(callback));
dataService.ExecuteAsync("Sitecore.Rocks.Server.Requests.Templates.ChangeTemplate", callback, itemUri.ItemId.ToString(), templateUri.ItemId.ToString(), itemUri.DatabaseName.Name);
}
public override bool GetItemFieldsAsync(ItemVersionUri uri, GetValueCompleted <Item> getItemFieldsCallback)
{
Assert.ArgumentNotNull(uri, nameof(uri));
Assert.ArgumentNotNull(getItemFieldsCallback, nameof(getItemFieldsCallback));
getItemFieldsCallback(Item.Empty);
return(true);
}
private void GoToItemId([NotNull] string itemId)
{
Debug.ArgumentNotNull(itemId, nameof(itemId));
var databaseUri = layoutSourceField.FieldUris[0].ItemVersionUri.DatabaseUri;
var itemUri = new ItemUri(databaseUri, new ItemId(new Guid(itemId)));
var itemVersionUri = new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Data.Version.Latest);
AppHost.OpenContentEditor(itemVersionUri);
}
public PublishingRestrictions([NotNull] ItemVersionUri itemUri)
{
Assert.ArgumentNotNull(itemUri, nameof(itemUri));
InitializeComponent();
this.InitializeDialog();
ItemUri = itemUri;
LoadItemRestrictions();
}
private void LoadRows([NotNull] ResultDataTable dataTable, [NotNull] XElement element)
{
Debug.ArgumentNotNull(dataTable, nameof(dataTable));
Debug.ArgumentNotNull(element, nameof(element));
var itemsElement = element.Element(@"rows");
if (itemsElement == null)
{
return;
}
if (!itemsElement.Elements().Any())
{
var dataRow = (ResultDataRow)dataTable.NewRow();
dataTable.Rows.Add(dataRow);
return;
}
foreach (var item in itemsElement.Elements())
{
var fieldArray = new List <FieldUri>();
var columnArray = new List <string>();
var languageName = item.GetAttributeValue("language", LanguageManager.CurrentLanguage.Name) ?? "en";
var itemUri = new ItemUri(DatabaseUri, new ItemId(new Guid(item.GetAttributeValue("id"))));
var itemVersionUri = new ItemVersionUri(itemUri, new Language(languageName), Data.Version.Latest);
foreach (var field in item.Elements())
{
FieldUri fieldUri = null;
var id = field.GetAttributeValue("id");
if (!string.IsNullOrEmpty(id))
{
fieldUri = new FieldUri(itemVersionUri, new FieldId(new Guid(id)));
}
fieldArray.Add(fieldUri);
columnArray.Add(field.Value);
}
var dataRow = (ResultDataRow)dataTable.NewRow();
dataRow.Name = item.GetAttributeValue("name");
dataRow.Icon = new Icon(DatabaseUri.Site, item.GetAttributeValue("icon"));
dataRow.ItemUri = itemUri;
dataRow.FieldArray = fieldArray.ToArray();
dataRow.ItemArray = columnArray.ToArray();
dataTable.Rows.Add(dataRow);
}
}
public void OpenContentEditor([NotNull] ItemVersionUri itemVersionUri)
{
Assert.ArgumentNotNull(itemVersionUri, nameof(itemVersionUri));
var uris = new List <ItemVersionUri>
{
new ItemVersionUri(itemVersionUri.ItemUri, LanguageManager.CurrentLanguage, Data.Version.Latest)
};
AppHost.Windows.OpenContentEditor(uris, LoadItemsOptions.Default);
}
private void Edit([NotNull] object sender, [NotNull] RoutedEventArgs e)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
var text = DataSourceTextBox.Text ?? string.Empty;
var itemUri = new ItemUri(Rendering.ItemUri.DatabaseUri, new ItemId(new Guid(text)));
var itemVersionUri = new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, Data.Version.Latest);
AppHost.OpenContentEditor(itemVersionUri);
}
private void ParseValidationElement([NotNull] XElement element)
{
Debug.ArgumentNotNull(element, nameof(element));
validations.Clear();
foreach (var item in element.Elements())
{
var severity = SeverityLevel.None;
var severityText = item.GetAttributeValue("severity").ToLowerInvariant();
switch (severityText)
{
case "error":
severity = SeverityLevel.Error;
break;
case "warning":
severity = SeverityLevel.Warning;
break;
case "suggestion":
severity = SeverityLevel.Suggestion;
break;
case "hint":
severity = SeverityLevel.Hint;
break;
}
var record = new ValidationDescriptor(item.GetAttributeValue("name"), severity, item.GetAttributeValue("category"), item.GetElementValue("title"), item.GetElementValue("problem"), item.GetElementValue("solution"))
{
ExternalLink = item.GetAttributeValue("link")
};
var id = item.GetAttributeValue("item");
if (!string.IsNullOrEmpty(id))
{
var parts = id.Split('/');
var databaseUri = new DatabaseUri(ItemUri.Site, new DatabaseName(parts[0]));
var itemUri = new ItemUri(databaseUri, new ItemId(Guid.Parse(parts[1])));
var itemVersionUri = new ItemVersionUri(itemUri, new Language(parts[2]), new Data.Version(int.Parse(parts[3])));
record.ItemUri = itemVersionUri;
record.ItemPath = item.GetAttributeValue("itempath");
}
validations.Add(record);
}
RenderValidations();
}
public static void RaiseVersionAdded([NotNull] object sender, [NotNull] ItemVersionUri newItemVersionUri)
{
Assert.ArgumentNotNull(sender, nameof(sender));
Assert.ArgumentNotNull(newItemVersionUri, nameof(newItemVersionUri));
var versionAdded = VersionAdded;
if (versionAdded != null)
{
versionAdded(sender, newItemVersionUri);
}
}
public override void Execute(Hit hit, object parameter)
{
Assert.ArgumentNotNull(hit, nameof(hit));
Assert.ArgumentNotNull(parameter, nameof(parameter));
var context = parameter as IItemSelectionContext;
if (context == null)
{
return;
}
var parentItem = context.Items.First();
var templateItemHeader = hit.Tag as ItemHeader;
if (templateItemHeader == null)
{
return;
}
var d = new AddInsertOptionDialog();
d.NewItemName.Text = string.Format(Resources.InsertOptions_CreateItem_New__0_, templateItemHeader.Name);
if (AppHost.Shell.ShowDialog(d) != true)
{
return;
}
var newName = d.ItemName;
var templateId = templateItemHeader.ItemUri.ItemId;
var templateUri = new ItemUri(parentItem.ItemUri.DatabaseUri, templateId);
var newItemUri = AppHost.Server.AddFromTemplate(parentItem.ItemUri, templateUri, newName);
if (newItemUri == ItemUri.Empty)
{
return;
}
var itemVersionUri = new ItemVersionUri(newItemUri, LanguageManager.CurrentLanguage, Version.Latest);
Notifications.RaiseItemAdded(this, itemVersionUri, parentItem.ItemUri);
if (AppHost.CurrentContentTree != null)
{
AppHost.CurrentContentTree.Locate(newItemUri);
}
AppHost.OpenContentEditor(itemVersionUri);
}
public override void Execute(object parameter)
{
var context = parameter as ContentEditorContext;
if (context == null)
{
return;
}
var uri = new ItemVersionUri(TemplateUri, LanguageManager.CurrentLanguage, Version.Latest);
AppHost.OpenContentEditor(uri);
}
protected override XmlElement ExecuteRemoveVersion(ItemVersionUri uri)
{
Debug.ArgumentNotNull(uri, nameof(uri));
var service = DataService;
if (service == null)
{
return(null);
}
return(service.RemoveVersion(uri.ItemUri.ItemId.ToString(), uri.Language.Name, uri.Version.ToString(), uri.ItemUri.DatabaseName.Name, GetCredentials()));
}
/// <summary>The execute.</summary>
/// <param name="parameter">The parameter.</param>
public override void Execute(object parameter)
{
var context = parameter as ContentTreeContext;
if (context == null)
{
return;
}
var item = context.SelectedItems.FirstOrDefault() as ItemTreeViewItem;
if (item == null)
{
return;
}
var newName = string.Format(Resources.SetName_Process_Copy_of__0_, item.Item.Name);
newName = AppHost.Prompt(Resources.SetName_Process_Enter_the_Name_of_the_New_Item_, Resources.SetName_Process_Duplicate, newName);
if (newName == null)
{
return;
}
Site.RequestCompleted completed = delegate(string response)
{
var newItemUri = new ItemUri(item.ItemUri.DatabaseUri, new ItemId(new Guid(response)));
var itemVersionUri = new ItemVersionUri(newItemUri, LanguageManager.CurrentLanguage, VisualStudio.Data.Version.Latest);
Notifications.RaiseItemDuplicated(this, newItemUri, item.ItemUri);
if (AppHost.CurrentContentTree != null)
{
AppHost.CurrentContentTree.Locate(newItemUri);
}
AppHost.OpenContentEditor(itemVersionUri);
};
item.ItemUri.Site.Execute("Items.DuplicateLatestVersionOnly", completed, item.ItemUri.DatabaseName.ToString(), item.ItemUri.ItemId.ToString(), Language.Current.ToString(), newName);
}
/// <summary>Execute the command.</summary>
/// <param name="parameter">The parameter.</param>
public override void Execute(object parameter)
{
var context = parameter as IItemSelectionContext;
if (context == null)
{
return;
}
var item = context.Items.First();
var dialog = new OpenFileDialog
{
Title = "Upload files",
CheckFileExists = true,
Filter = @"All files|*.*",
Multiselect = true
};
if (dialog.ShowDialog() != true)
{
return;
}
GetValueCompleted<ItemHeader> uploadCompleted = delegate(ItemHeader value)
{
var itemVersionUri = new ItemVersionUri(value.ItemUri, LanguageManager.CurrentLanguage, VisualStudio.Data.Version.Latest);
AppHost.OpenContentEditor(itemVersionUri);
};
MediaManager.Upload(item.ItemUri.DatabaseUri, @"/upload", dialog.FileNames, uploadCompleted);
}
/// <summary>The execute psi transaction.</summary>
/// <param name="solution">The solution.</param>
/// <param name="progress">The progress.</param>
/// <returns>The <see cref="Action"/>.</returns>
protected override Action<ITextControl> ExecutePsiTransaction([NotNull] ISolution solution, [NotNull] IProgressIndicator progress)
{
var site = this.Site;
var itemUri = new ItemUri(new DatabaseUri(site, new DatabaseName("master")), new ItemId(this.Guid));
var itemVersionUri = new ItemVersionUri(itemUri, LanguageManager.CurrentLanguage, VisualStudio.Data.Version.Latest);
AppHost.OpenContentEditor(itemVersionUri);
return null;
}
