/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
/// <param name="itemHeader"></param>
public ItemOccurence(ItemHeader itemHeader)
{
this.PresentationOptions = OccurencePresentationOptions.DefaultOptions;
this.ItemName = itemHeader.Name;
this.ParentPath = itemHeader.ParentPath;
this.ItemUri = itemHeader.ItemUri;
this.Icon = itemHeader.Icon;
}
private SitecoreTemplateSection GetSection(ItemHeader itemHeader)
{
return new SitecoreTemplateSection
{
Id = itemHeader.ItemId.ToString(),
Name = itemHeader.Name,
Icon = GetIconPath(itemHeader.Icon),
Fields = GetFields(itemHeader.ItemUri)
};
}
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);
}
private bool GetVisible([NotNull] ItemHeader item, [NotNull] List <string> updatedBy, [NotNull] string path, int year, int month, int day)
{
Debug.ArgumentNotNull(item, nameof(item));
Debug.ArgumentNotNull(updatedBy, nameof(updatedBy));
Debug.ArgumentNotNull(path, nameof(path));
if (updatedBy.Count > 0)
{
if (!Contains(updatedBy, item.UpdatedBy))
{
return(false);
}
}
if (!string.IsNullOrEmpty(path))
{
if (!item.Path.StartsWith(path, StringComparison.InvariantCultureIgnoreCase))
{
return(false);
}
}
if (year != 0)
{
if (item.Updated.Year != year)
{
return(false);
}
}
if (month != 0)
{
if (item.Updated.Month != month)
{
return(false);
}
}
if (day != 0)
{
if (item.Updated.Day != day)
{
return(false);
}
}
return(true);
}
public ItemTreeViewItem([NotNull] ItemHeader item) : base(item.ItemUri.Site)
{
Assert.ArgumentNotNull(item, nameof(item));
Item = item;
Text = item.Name;
Icon = item.Icon;
ToolTip = string.Empty;
adorner = new ControlDragAdorner(ItemHeader, ControlDragAdornerPosition.All);
RefreshStatusIcons();
ToolTipOpening += OpenToolTip;
Notifications.RegisterItemEvents(this, renamed: ItemRenamed, deleted: ItemDeleted, serialized: ItemSerialized);
Notifications.RegisterFieldEvents(this, FieldChanged);
}
public ListBoxItemHeader([NotNull] ItemHeader itemHeader)
{
Assert.ArgumentNotNull(itemHeader, nameof(itemHeader));
InitializeComponent();
var path = itemHeader.Path;
var n = path.LastIndexOf('/');
if (n >= 0)
{
path = path.Left(n);
}
HeaderTextBox.Text = itemHeader.Name;
PathTextBox.Text = string.Format("(in {0})", path);
}
private ListBoxItem RenderItem([NotNull] ItemHeader itemHeader)
{
Debug.ArgumentNotNull(itemHeader, nameof(itemHeader));
var header = GetHeader(itemHeader);
var listBoxItem = new ListBoxItem
{
Content = header,
Tag = itemHeader
};
// listBoxItem.ToolTipOpening += delegate { listBoxItem.ToolTip = ToolTipBuilder.BuildToolTip(itemHeader); };
ListBox.Items.Add(listBoxItem);
return(listBoxItem);
}
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);
}
private void CopyItemBatch([NotNull] DragCopyPipeline pipeline)
{
Debug.ArgumentNotNull(pipeline, nameof(pipeline));
pipeline.Suspend();
var sourceItemIds = string.Join(",", pipeline.Items.Select(i => i.ItemUri.ItemId.ToString()));
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
pipeline.Abort();
return;
}
var root = response.ToXElement();
if (root == null)
{
pipeline.Abort();
return;
}
foreach (var element in root.Elements())
{
var itemHeader = ItemHeader.Parse(pipeline.Target.ItemUri.DatabaseUri, element);
var newItem = new DragCopyPipeline.NewItem
{
Item = itemHeader,
NewName = itemHeader.Name,
NewItemUri = itemHeader.ItemUri
};
pipeline.NewItems.Add(newItem);
}
pipeline.Owner = pipeline.Target;
pipeline.Anchor = null;
pipeline.Resume();
};
AppHost.Server.Items.CopyItems(sourceItemIds, pipeline.Target.ItemUri, completed);
}
public void CanItemHeaderBeConstructed(SecsFormat expectedSecsFormat, int expectedItemLength, byte expectedNumberOfLengthBytes, byte expectedRawHeaderDataSize)
{
ItemHeader itemHeader = new ItemHeader(expectedSecsFormat, expectedItemLength);
Assert.IsTrue(itemHeader.IsValid, nameof(itemHeader.IsValid));
Assert.AreEqual(expectedSecsFormat, itemHeader.Format, nameof(itemHeader.Format));
Assert.AreEqual(expectedItemLength, itemHeader.ItemLength, nameof(itemHeader.ItemLength));
Assert.AreEqual(expectedNumberOfLengthBytes, itemHeader.NumberOfLengthBytes, nameof(itemHeader.NumberOfLengthBytes));
Assert.AreEqual(expectedRawHeaderDataSize, itemHeader.RawHeaderDataSize, nameof(itemHeader.RawHeaderDataSize));
byte[] expectedRawHeaderData = new byte[expectedRawHeaderDataSize];
expectedRawHeaderData[0] = (byte)((int)expectedSecsFormat | expectedNumberOfLengthBytes);
switch (expectedNumberOfLengthBytes)
{
case 1:
expectedRawHeaderData[1] = (byte)expectedItemLength;
break;
case 2:
expectedRawHeaderData[1] = (byte)(expectedItemLength >> 8);
expectedRawHeaderData[2] = (byte)expectedItemLength;
break;
case 3:
expectedRawHeaderData[1] = (byte)(expectedItemLength >> 16);
expectedRawHeaderData[2] = (byte)(expectedItemLength >> 8);
expectedRawHeaderData[3] = (byte)expectedItemLength;
break;
default:
throw new ArgumentOutOfRangeException(nameof(expectedNumberOfLengthBytes), expectedNumberOfLengthBytes, "The argument must be 1, 2 or 3.");
}
byte[] actualRawHeaderData = itemHeader.GetRawHeaderData();
CollectionAssert.AreEqual(expectedRawHeaderData, actualRawHeaderData);
byte[] expectedItemBufferWithRawHeaderData = new byte[expectedRawHeaderDataSize + expectedItemLength];
Array.Copy(expectedRawHeaderData, 0, expectedItemBufferWithRawHeaderData, 0, expectedRawHeaderData.Length);
var(actualItemBufferWithRawHeaderData, actualOffset) = itemHeader.GetItemBufferWithRawHeaderData();
Assert.AreEqual(expectedRawHeaderDataSize, actualOffset, nameof(actualOffset));
CollectionAssert.AreEqual(expectedItemBufferWithRawHeaderData, actualItemBufferWithRawHeaderData);
}
private void LoadFilters([NotNull] ItemHeader item)
{
Debug.ArgumentNotNull(item, nameof(item));
LoadFiltersAll();
LoadFilterValue(Templates.Items, new Tuple <string, string>(item.TemplateName, item.TemplateName));
LoadFilterValue(Authors.Items, new Tuple <string, string>(item.UpdatedBy, item.UpdatedBy));
LoadFilterValue(Categories.Items, new Tuple <string, string>(item.Category, item.Category));
var path = string.Empty;
var parts = new List <Tuple <string, string> >();
foreach (var s in item.Path.Split('/', StringSplitOptions.RemoveEmptyEntries))
{
if (string.IsNullOrEmpty(s))
{
continue;
}
path += @"/" + s;
parts.Add(new Tuple <string, string>(path, s));
}
LoadFilterTree(Paths.Items, parts, 0);
if (item.Updated == DateTime.MinValue)
{
return;
}
var year = item.Updated.Year.ToString();
var month = item.Updated.Month.ToString();
var day = item.Updated.Day.ToString();
var tuples = new List <Tuple <string, string> >
{
new Tuple <string, string>(year, year),
new Tuple <string, string>(year + @"/" + month, item.Updated.ToString(@"MMMM")),
new Tuple <string, string>(year + @"/" + month + @"/" + day, day)
};
LoadFilterTree(Updated.Items, tuples, 0);
}
public void Load()
{
var context = Commandy.Parameter as LayoutDesignerContext;
if (context == null)
{
return;
}
var first = context.Items.FirstOrDefault();
if (first == null)
{
return;
}
renderingItems.Clear();
var databaseUri = first.ItemUri.DatabaseUri;
ExecuteCompleted completed = (response, executeResult) =>
{
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
var items = root.Elements().Select(element => ItemHeader.Parse(databaseUri, element)).ToList();
foreach (var itemHeader in items)
{
renderingItems.Add(new RenderingItem(null, itemHeader));
}
IsReady = true;
};
AppHost.Server.Layouts.GetRenderings(databaseUri, completed);
}
public void BrowseImage([NotNull] object sender, [NotNull] RoutedEventArgs e)
{
Assert.ArgumentNotNull(sender, nameof(sender));
Assert.ArgumentNotNull(e, nameof(e));
var dialog = new SelectItemDialog();
DatabaseUri databaseUri;
if (MediaUri == ItemUri.Empty)
{
databaseUri = sourceField.FieldUris.First().DatabaseUri;
dialog.Initialize(Rocks.Resources.Browse, databaseUri, "/sitecore/media library");
}
else
{
databaseUri = MediaUri.DatabaseUri;
dialog.Initialize(Rocks.Resources.Browse, MediaUri);
}
if (AppHost.Shell.ShowDialog(dialog) != true)
{
return;
}
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
var element = response.ToXElement();
if (element == null)
{
return;
}
var itemHeader = ItemHeader.Parse(databaseUri, element);
Update(itemHeader);
};
AppHost.Server.Items.GetItemHeader(dialog.SelectedItemUri, completed);
}
public void GetPublishingCandidates(int pageNumber)
{
var site = DatabaseUri.Site;
if (site == Site.Empty)
{
AppHost.MessageBox(Rocks.Resources.Search_HandleKeyDown_Please_select_a_database_first_, Rocks.Resources.Search_HandleKeyDown_Select_Database, MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
Loading.Visibility = Visibility.Collapsed;
List.Visibility = Visibility.Visible;
return;
}
var root = response.ToXElement();
if (root == null)
{
Loading.Visibility = Visibility.Collapsed;
List.Visibility = Visibility.Visible;
return;
}
var list = new List <ItemHeader>();
foreach (var element in root.Elements())
{
var itemHeader = ItemHeader.Parse(DatabaseUri, element);
list.Add(itemHeader);
}
LoadItems(list);
};
Loading.Visibility = Visibility.Visible;
List.Visibility = Visibility.Collapsed;
DatabaseUri.Site.DataService.ExecuteAsync("Publishing.GetPublishingQueue", c, DatabaseUri.DatabaseName.ToString(), pageNumber);
}
public override void Execute(object parameter)
{
var context = parameter as LayoutDesignerContext;
if (context == null)
{
return;
}
var fieldUri = context.LayoutDesigner.FieldUris.FirstOrDefault();
if (fieldUri == null)
{
SelectItemToPreview(context);
return;
}
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
var element = response.ToXElement();
if (element == null)
{
return;
}
var itemHeader = ItemHeader.Parse(fieldUri.DatabaseUri, element);
if (itemHeader.Name != "__Standard Values")
{
Browse(itemHeader.ItemUri);
return;
}
SelectItemToPreview(context);
};
AppHost.Server.Items.GetItemHeader(fieldUri.ItemVersionUri.ItemUri, completed);
}
private void SetRenderings([NotNull] string response, [NotNull] ExecuteResult executeResult)
{
Debug.ArgumentNotNull(response, nameof(response));
Debug.ArgumentNotNull(executeResult, nameof(executeResult));
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = response.ToXElement();
if (root == null)
{
return;
}
var items = root.Elements().Select(element => ItemHeader.Parse(DatabaseUri, element)).Where(MatchesSpeakCoreVersion).ToList();
renderings.AddRange(items);
foreach (var source in RenderingSelectorFilters)
{
source.SetRenderings(renderings);
}
var selectedItem = FilterListbox.SelectedItem as ListBoxItem;
if (selectedItem != null)
{
selectedItem.IsSelected = false;
selectedItem.IsSelected = true;
return;
}
var firstItem = FilterListbox.Items.OfType <ListBoxItem>().FirstOrDefault();
if (firstItem != null)
{
firstItem.IsSelected = true;
}
}
public override void Execute(object parameter)
{
var context = parameter as LayoutDesignerContext;
if (context == null)
{
return;
}
var item = context.SelectedItems.FirstOrDefault() as RenderingItem;
if (item == null)
{
return;
}
var databaseUri = context.LayoutDesigner.DatabaseUri;
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
var element = response.ToXElement();
if (element == null)
{
return;
}
var itemHeader = ItemHeader.Parse(databaseUri, element);
var activeContentTree = ActiveContext.ActiveContentTree;
if (activeContentTree != null)
{
activeContentTree.Locate(itemHeader.ItemUri);
}
};
databaseUri.Site.DataService.ExecuteAsync("Items.GetItemHeader", completed, item.DataSource, databaseUri.DatabaseName.ToString());
}
public int CompareTo(ItemHeader other)
{
if (language == other.language)
{
return(isPlatform ? other.isPlatform ? (int)platform - (int)other.platform : 1 : -1);
}
else
{
if (language == Language.Default)
{
return(-1);
}
else if (other.language == Language.Default)
{
return(1);
}
return((int)language - (int)other.language);
}
}
/// <summary>
/// Gets the menu header of a command for a source element.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="activeDocument">The active document.</param>
/// <param name="applicationName">The application name.</param>
/// <returns>The header.</returns>
protected virtual string GetItemHeader(ICommand command, IDocument?activeDocument, string?applicationName)
{
string ItemHeader;
switch (command)
{
case ActiveDocumentRoutedCommand AsActiveDocumentCommand:
if (activeDocument == null)
{
ItemHeader = AsActiveDocumentCommand.InactiveMenuHeader;
}
else
{
string CommandTextFormat = AsActiveDocumentCommand.MenuHeader;
ItemHeader = string.Format(CultureInfo.CurrentCulture, CommandTextFormat, activeDocument.Path.HeaderName);
}
break;
case LocalizedRoutedCommand AsLocalizedRoutedCommand:
ItemHeader = AsLocalizedRoutedCommand.MenuHeader;
if (ItemHeader.Contains(LocalizedRoutedCommand.ApplicationNamePattern) && applicationName != null)
{
ItemHeader = ItemHeader.Replace(LocalizedRoutedCommand.ApplicationNamePattern, applicationName);
}
break;
case ExtendedRoutedCommand AsExtendedRoutedCommand:
ItemHeader = AsExtendedRoutedCommand.MenuHeader;
break;
case RoutedUICommand AsUICommand:
ItemHeader = AsUICommand.Text;
break;
default:
throw new ArgumentOutOfRangeException(nameof(command));
}
return(ItemHeader);
}
public static void GetLinks([NotNull] this DataService dataService, [NotNull] ItemUri itemUri, [NotNull] GetLinksCompleted 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(string.Empty, Enumerable.Empty <ItemHeader>(), Enumerable.Empty <ItemHeader>());
return;
}
var root = Parse(response);
if (root == null)
{
callback(string.Empty, Enumerable.Empty <ItemHeader>(), Enumerable.Empty <ItemHeader>());
return;
}
var referencesElement = root.Element(@"references");
var referrersElement = root.Element(@"referrers");
if (referencesElement == null || referrersElement == null)
{
callback(string.Empty, Enumerable.Empty <ItemHeader>(), Enumerable.Empty <ItemHeader>());
return;
}
var name = root.GetAttributeValue("name");
var references = referencesElement.Elements().Select(element => ItemHeader.Parse(itemUri.DatabaseUri, element)).ToList();
var referrers = referrersElement.Elements().Select(element => ItemHeader.Parse(itemUri.DatabaseUri, element)).ToList();
callback(name, references, referrers);
};
dataService.ExecuteAsync("Sitecore.Rocks.Server.Requests.Links.GetLinks", c, itemUri.DatabaseName.Name, itemUri.ItemId.ToString());
}
public static void GetItemHeader([NotNull] this DataService dataService, [NotNull] ItemUri itemUri, [NotNull] GetValueCompleted <ItemHeader> getItemHeaderCompleted)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(itemUri, nameof(itemUri));
Assert.ArgumentNotNull(getItemHeaderCompleted, nameof(getItemHeaderCompleted));
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var root = Parse(response);
if (root != null)
{
getItemHeaderCompleted(ItemHeader.Parse(itemUri.DatabaseUri, root));
}
};
itemUri.Site.DataService.ExecuteAsync("Items.GetItemHeader", c, itemUri.ItemId.ToString(), itemUri.DatabaseName.Name);
}
public override void Execute(object parameter)
{
var context = parameter as LayoutDesignerContext;
if (context == null)
{
return;
}
var item = context.SelectedItems.FirstOrDefault() as RenderingItem;
if (item == null)
{
return;
}
var databaseUri = context.LayoutDesigner.DatabaseUri;
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result))
{
return;
}
var element = response.ToXElement();
if (element == null)
{
return;
}
var itemHeader = ItemHeader.Parse(databaseUri, element);
AppHost.OpenContentEditor(new ItemVersionUri(itemHeader.ItemUri, LanguageManager.CurrentLanguage, Version.Latest));
};
databaseUri.Site.DataService.ExecuteAsync("Items.GetItemHeader", completed, item.DataSource, databaseUri.DatabaseName.ToString());
}
private void LoadRenderingGallery([NotNull] LayoutDesigner layoutDesigner, [NotNull] InRibbonGallery gallery)
{
Debug.ArgumentNotNull(layoutDesigner, nameof(layoutDesigner));
Debug.ArgumentNotNull(gallery, nameof(gallery));
Site.RequestCompleted completed = delegate(string response)
{
var root = response.ToXElement();
if (root == null)
{
return;
}
var items = root.Elements().Select(element => ItemHeader.Parse(layoutDesigner.DatabaseUri, element)).Where(e => MatchesSpeakCoreVersion(e, layoutDesigner)).ToList();
var renderings = new List <RenderingButton>();
foreach (var item in items.OrderBy(i => i.ParentName).ThenBy(i => i.Name))
{
var button = new RenderingButton
{
Label = item.Name,
Icon = item.Icon,
Tag = item,
ToolTip = ToolTipBuilder.BuildToolTip(item)
};
button.PreviewMouseUp += (sender, args) => { AddRenderingFromRibbon(layoutDesigner, sender, button); };
renderings.Add(button);
}
renderings = renderings.OrderBy(i => i.Label).ToList();
gallery.ItemsSource = renderings;
};
layoutDesigner.DatabaseUri.Site.Execute("Layouts.GetRenderings", completed, layoutDesigner.DatabaseUri.DatabaseName.ToString());
}
public void Initialize([NotNull] ItemHeader itemHeader, int width, int height)
{
Assert.ArgumentNotNull(itemHeader, nameof(itemHeader));
ItemName.Text = itemHeader.Name;
IconImage.Width = width;
IconImage.Height = height;
Grid.MaxWidth = width;
var path = string.Format(@"{0}{1}.ashx?bc=White&db={2}&h={3}la=en&thn=1&w={4}", MediaManager.GetMediaUrl(itemHeader.ItemUri.Site), itemHeader.ItemId.ToShortId(), itemHeader.ItemUri.DatabaseName.Name, height, width);
var policy = new RequestCachePolicy(RequestCacheLevel.Default);
try
{
IconImage.Source = new BitmapImage(new Uri(path), policy);
}
catch (Exception ex)
{
AppHost.Output.LogException(ex);
IconImage.Source = null;
}
}
internal bool InternalAddItems([NotNull] string response, [NotNull] ExecuteResult executeresult)
{
Debug.ArgumentNotNull(response, nameof(response));
Debug.ArgumentNotNull(executeresult, nameof(executeresult));
if (!DataService.HandleExecute(response, executeresult))
{
return(false);
}
var root = response.ToXElement();
if (root == null)
{
return(false);
}
foreach (var element in root.Elements())
{
var databaseName = element.GetAttributeValue("database");
var databaseUri = new DatabaseUri(Site, new DatabaseName(databaseName));
var itemHeader = ItemHeader.Parse(databaseUri, element);
if (Items.Any(i => i.ItemUri == itemHeader.ItemUri))
{
continue;
}
var packageItem = new PackageItem(itemHeader);
Items.Add(packageItem);
}
return(true);
}
private void HandleTextChanged([NotNull] object sender, [NotNull] TextChangedEventArgs e)
{
Debug.ArgumentNotNull(sender, nameof(sender));
Debug.ArgumentNotNull(e, nameof(e));
if (string.IsNullOrEmpty(DataSourceTextBox.Text))
{
Path.Text = "[No Data Source]";
return;
}
Path.Text = "[Updating Data Source]";
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result, true))
{
Path.Text = "[Item not found]";
return;
}
var element = response.ToXElement();
if (element == null)
{
return;
}
var itemHeader = ItemHeader.Parse(Rendering.ItemUri.DatabaseUri, element);
Path.Text = itemHeader.Path;
};
Rendering.ItemUri.Site.DataService.ExecuteAsync("Items.GetItemHeader", completed, DataSourceTextBox.Text, Rendering.ItemUri.DatabaseName.Name);
EnableButtons();
}
public void Update([NotNull] ItemHeader header)
{
Debug.ArgumentNotNull(header, nameof(header));
var mediaPath = header.Path;
if (mediaPath.StartsWith(@"/sitecore/media library", StringComparison.OrdinalIgnoreCase))
{
mediaPath = mediaPath.Mid(23);
}
MediaUri = header.ItemUri;
MediaPath = mediaPath;
Src = @"~/media" + mediaPath;
var itemData = header as IItemData;
AltTextField.Text = itemData.GetData(@"ex.alt.text");
UpdateValue();
ReloadImage();
SetModifiedFlag();
UpdatePath();
}
public static void Upload([NotNull] this DataService dataService, [NotNull] DatabaseUri databaseUri, [NotNull] string filePath, [NotNull] byte[] file, [NotNull] GetValueCompleted <ItemHeader> uploadCompleted)
{
Assert.ArgumentNotNull(dataService, nameof(dataService));
Assert.ArgumentNotNull(databaseUri, nameof(databaseUri));
Assert.ArgumentNotNull(filePath, nameof(filePath));
Assert.ArgumentNotNull(file, nameof(file));
Assert.ArgumentNotNull(uploadCompleted, nameof(uploadCompleted));
var data = Convert.ToBase64String(file);
ExecuteCompleted c = delegate(string response, ExecuteResult executeResult)
{
if (!DataService.HandleExecute(response, executeResult))
{
return;
}
var r = Parse(response);
if (r == null)
{
return;
}
var element = r.Element(@"item");
if (element == null)
{
return;
}
var itemHeader = ItemHeader.Parse(databaseUri, element);
uploadCompleted(itemHeader);
};
databaseUri.Site.DataService.ExecuteAsync("Sitecore.Rocks.Server.Requests.Media.Upload", c, databaseUri.DatabaseName.Name, filePath, data);
}
public void AddIdProperty([NotNull] string text, [NotNull] string propertyName)
{
Assert.ArgumentNotNull(text, nameof(text));
Assert.ArgumentNotNull(propertyName, nameof(propertyName));
AddLabel(text);
var property = GetProperty(propertyName);
var binding = new Binding(property.Name);
var grid = new Grid();
grid.RowDefinitions.Add(new RowDefinition());
grid.ColumnDefinitions.Add(new ColumnDefinition());
grid.ColumnDefinitions.Add(new ColumnDefinition
{
Width = GridLength.Auto
});
var textBox = new TextBox();
textBox.SetBinding(TextBox.TextProperty, binding);
textBox.VerticalAlignment = VerticalAlignment.Center;
grid.Children.Add(textBox);
textBox.SetValue(Grid.ColumnProperty, 0);
var button = new Button
{
Content = "Browse",
Width = 75,
Height = 23,
Margin = new Thickness(2, 0, 0, 0)
};
button.Click += delegate
{
var container = RenderingItem.RenderingContainer;
if (container == null)
{
return;
}
var dialog = new SelectItemDialog();
dialog.Initialize("Browse", RenderingItem.ItemUri.DatabaseUri, textBox.Text ?? string.Empty);
if (AppHost.Shell.ShowDialog(dialog) != true)
{
return;
}
textBox.Text = dialog.SelectedItemUri.ItemId.ToString();
};
grid.Children.Add(button);
button.SetValue(Grid.ColumnProperty, 1);
Grid.Children.Add(grid);
var path = new TextBlock
{
Text = " ",
Margin = new Thickness(0, 0, 0, 4),
Foreground = SystemColors.GrayTextBrush,
TextTrimming = TextTrimming.CharacterEllipsis
};
Grid.Children.Add(new Border());
Grid.Children.Add(path);
textBox.TextChanged += delegate
{
path.Text = "[Updating path]";
ExecuteCompleted completed = delegate(string response, ExecuteResult result)
{
if (!DataService.HandleExecute(response, result, true))
{
path.Text = "[Item not found]";
return;
}
var element = response.ToXElement();
if (element == null)
{
path.Text = "[Item not found]";
return;
}
var itemHeader = ItemHeader.Parse(RenderingItem.ItemUri.DatabaseUri, element);
path.Text = string.IsNullOrEmpty(itemHeader.Path) ? " " : itemHeader.Path;
};
RenderingItem.ItemUri.Site.DataService.ExecuteAsync("Items.GetItemHeader", completed, textBox.Text, RenderingItem.ItemUri.DatabaseName.Name);
};
var selectedItem = property.Value;
textBox.Text = (selectedItem ?? string.Empty).ToString();
bindings.Add(BindingOperations.GetBindingExpressionBase(textBox, TextBox.TextProperty));
}
void IMediaSkin.Deleted(ItemHeader itemHeader)
{
Assert.ArgumentNotNull(itemHeader, nameof(itemHeader));
ListBox.Deleted(itemHeader);
}
public virtual void AddToRecent(ItemHeader itemHeader)
{
Assert.ArgumentNotNull(itemHeader, nameof(itemHeader));
}
public ProtoMessage AddProtoObject(ItemHeader header, object protoObject)
{
this.protoObjects.Add(new Tuple <ItemHeader, object>(header, protoObject));
return(this);
}
