public override object ComputeFieldValue(IIndexable indexable)
{
Item scIndexable = indexable as SitecoreIndexableItem;
if (ShouldSkip(scIndexable))
{
return(null);
}
var media = GeFirstMediaItem(scIndexable, Configuration.Settings.Instance.BestImageFields?.ToArray());
if (media == null)
{
return(null);
}
var options = GetMediaOptions() ?? MediaUrlOptions.Empty;
var imageUrl = MediaManager.GetMediaUrl(media, options);
if (string.IsNullOrWhiteSpace(imageUrl))
{
return(null);
}
// Address improper urls if present
imageUrl = imageUrl.Replace("sitecore/shell/", string.Empty);
imageUrl = HashingUtils.ProtectAssetUrl(imageUrl);
return(imageUrl);
}
public static string GetImageUrl(this Item currentItem, int maxWidth = 0, int width = 0, int maxHeight = 0)
{
if (currentItem == null)
{
return(null);
}
var image = (MediaItem)currentItem;
// If there's options specified, add them to the options object.
if (width > 0 || maxWidth > 0 || maxHeight > 0)
{
var options = new MediaUrlOptions();
if (width > 0)
{
options.Width = width;
}
if (maxWidth > 0)
{
options.MaxWidth = maxWidth;
}
if (maxHeight > 0)
{
options.MaxHeight = maxHeight;
}
return(StringUtil.EnsurePrefix('/',
HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(image, options))));
}
// Otherwise, get the image with no options specified.
return(StringUtil.EnsurePrefix('/', MediaManager.GetMediaUrl(image)));
}
private string GetUrlFromField()
{
ImageField field = Field;
var targetImage = field.MediaItem;
if (targetImage != null)
{
var options = new MediaUrlOptions()
{
Language = targetImage.Language
};
int width;
if (int.TryParse(field.Width, out width) && width > 0)
{
options.Width = width;
}
int height;
if (int.TryParse(field.Height, out height) && height > 0)
{
options.Height = height;
}
var innerUrl = MediaManager.GetMediaUrl(targetImage, options);
var url = HashingUtils.ProtectAssetUrl(innerUrl);
return(url);
}
return(string.Empty);
}
private string BuildMediaItemLink(Item media, SiteContext siteContext)
{
string mediaUrl;
var options = GetMediaOptions() ?? MediaUrlOptions.Empty;
if (siteContext != null)
{
using (SiteContextSwitcher siteContextSwitcher = new SiteContextSwitcher(siteContext))
{
mediaUrl = MediaManager.GetMediaUrl(media, options);
}
}
else
{
mediaUrl = MediaManager.GetMediaUrl(media, options);
}
if (string.IsNullOrWhiteSpace(mediaUrl))
{
return(null);
}
// Address improper urls if present
mediaUrl = mediaUrl.Replace("sitecore/shell/", string.Empty);
mediaUrl = HashingUtils.ProtectAssetUrl(mediaUrl);
return(mediaUrl);
}
/// <summary>
/// Creates the user account.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="userProfileId">The user profile identifier.</param>
/// <returns></returns>
/// <exception cref="FormatException">
/// Email invalid
/// or
/// Password invalid
/// </exception>
public async Task <bool> CreateUserAccount(UserAccountCreateModel model, Guid userProfileId)
{
if (!ValidateUtils.IsMail(model.Email))
{
throw new FormatException("Email invalid");
}
if (model.Password.Length < 8)
{
throw new FormatException("Password invalid");
}
var passwordSalt = Guid.NewGuid();
var data = HashingUtils.GetHashData(model.Password + passwordSalt);
_userAccountRepository.Insert(new UserAccount
{
Email = model.Email,
PasswordHash = data.DataHashed,
PasswordHashAlgorithm = data.HashType,
UserProfileId = userProfileId,
PasswordSalt = passwordSalt,
UserAccountStatusCode = RefUserAccountStatusCode.Guest
});
await _unitOfWork.CommitAsync();
return(true);
}
/// <summary>
/// Gets a hash-protected imageUrl of the specified imageField, optionally with specific MediaUrlOptions
/// </summary>
/// <param name="imageField">The ImageField
/// </param>
/// <param name="options">MediaUrlOptions to supply width/height etc.
/// </param>
/// <returns>
/// Hash-protected URL of the resized image
/// </returns>
/// <exception cref="ArgumentNullException">Item does not exist exception.
/// </exception>
public static string ImageUrl(this ImageField imageField, MediaUrlOptions options = null)
{
if (imageField == null || imageField.MediaItem == null)
{
throw new ArgumentNullException("imageField");
}
if (options == null)
{
options = MediaUrlOptions.Empty;
int width, height;
if (int.TryParse(imageField.Width, out width))
{
options.Width = width;
}
if (int.TryParse(imageField.Height, out height))
{
options.Height = height;
}
}
return(HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(imageField.MediaItem, options)));
}
public TxTemplate SignTransaction(TxTemplate transaction, List <string> privateKeys)
{
var signedTx = (TxTemplate)transaction.Clone();
var serializedTransaction = JsonUtility.SerializeTransactionIntoCanonicalString(JsonConvert.SerializeObject(transaction));
var index = 0;
foreach (var privKey in privateKeys)
{
SignatureMetadata signatures = GetSignature(transaction, serializedTransaction, index, privKey);
bool verifyFullfill = signatures.Signature.VerifySignature(signatures.TransactionHash, signatures.PubKeyBuffer);
if (!verifyFullfill)
{
continue;
}
signedTx.Inputs[index].Fulfillment = GenerateFulfillmentUri(signatures.PubKeyBuffer, signatures.Signature);
index++;
}
var serializedSignedTransaction = JsonUtility.SerializeTransactionIntoCanonicalString(JsonConvert.SerializeObject(signedTx));
signedTx.Id = HashingUtils.ComputeSha3Hash(Encoding.UTF8.GetBytes(serializedSignedTransaction)).ToHex(false);
return(signedTx);
}
public static string GetImageUrlParameter(this Rendering rendering, string parameterName, MediaUrlOptions options = null)
{
if (rendering == null)
{
throw new ArgumentNullException(nameof(rendering));
}
// Check if this rendering parameter exists
// Also crude check to guess if this is actually XML.
var parameters = rendering.Parameters[parameterName];
if (string.IsNullOrEmpty(parameters) || !parameters.StartsWith("<"))
{
return(string.Empty);
}
// Try and parse the parameters into XML
var xml = XmlUtil.LoadXml(parameters);
if (xml == null)
{
return(string.Empty);
}
// Check if xml contains mediaid attribute
var imageId = XmlUtil.GetAttribute("mediaid", xml);
if (string.IsNullOrEmpty(imageId))
{
return(string.Empty);
}
// Check if mediaid exists in database
var imageItem = Context.Database.GetItem(imageId);
if (imageItem == null)
{
return(string.Empty);
}
// If no explicit options supplied, work out width and height from xml parameters
if (options == null)
{
options = MediaUrlOptions.Empty;
int width, height;
if (int.TryParse(XmlUtil.GetAttribute("width", xml), out width))
{
options.Width = width;
}
if (int.TryParse(XmlUtil.GetAttribute("height", xml), out height))
{
options.Height = height;
}
}
// Return hash protected URL.
return(HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(imageItem, options)));
}
private static HtmlString BuildEditableImageTag <TModel>(
GlassHtmlMvc <TModel> glassView,
object item,
bool isAdvancedImage,
AdvancedImageField advancedImageField,
bool useAdvancedImage,
object parameters = null,
bool outputHeightWidth = false,
float cropFactor = 0)
{
if (!isAdvancedImage)
{
return(glassView.RenderImage(item, itemField => itemField, parameters, true, outputHeightWidth));
}
var attributes = new SafeDictionary <string>();
var src = advancedImageField.Src;
if (useAdvancedImage)
{
src += $"?{advancedImageField.GetFocalPointParameters(advancedImageField.Width, cropFactor)}";
}
var protectedUrl = HashingUtils.ProtectAssetUrl(src);
attributes.Add("src", protectedUrl);
return(BuildImageTag(attributes, advancedImageField));
}
public virtual Tuple <string, string> GetImageUrlAndAlt(ImageField imageField, int?maxWidth = null, int?maxHeight = null)
{
if (imageField?.MediaItem != null)
{
var mo = new MediaUrlOptions
{
MaxWidth = 750,
MaxHeight = 450,
};
var url = MediaManager.GetMediaUrl(imageField.MediaItem, mo);
var protectedUrl = HashingUtils.ProtectAssetUrl(url);
return(new Tuple <string, string>(protectedUrl, imageField.Alt));
}
else
{
if (maxWidth != null && maxHeight != null)
{
return(new Tuple <string, string>($"http://placehold.it/{maxWidth}x{maxHeight}", "Dummy placeholder image"));
}
return(new Tuple <string, string>("#", "no image"));
}
}
/// <summary>
/// Gets the friendly URL of the MediaItem, including Media Asset Protection
/// </summary>
/// <param name="item">The Media Item</param>
/// <param name="options">The Url Options to use.</param>
/// <returns>a Media URL with Media Asset Protection hash (if enabled).</returns>
public static string GetUrl(this MediaItem item, MediaUrlOptions options)
{
var innerUrl = MediaManager.GetMediaUrl(item, options);
var url = HashingUtils.ProtectAssetUrl(innerUrl);
return(url);
}
/// <summary>
/// Gets media url for the image
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public string GetSourceUri(MediaUrlOptions options)
{
var disabler = Settings.DisableSecurityOnLinkGeneration ? new SecurityDisabler() : null;
if (!this.HasValue)
{
disabler?.Dispose();
return(string.Empty);
}
var mediaItem = this.ImageField.MediaItem;
if (mediaItem == null)
{
return(string.Empty);
}
if (options == null)
{
options = MediaUrlOptions.Empty;
}
var mediaUrl = MediaManager.GetMediaUrl(mediaItem, options);
var url = StringUtil.EnsurePrefix('/', mediaUrl);
var hashedUrl = HashingUtils.ProtectAssetUrl(url);
disabler?.Dispose();
return(hashedUrl);
}
public static string ImageUrl(this ImageField imageField, MediaUrlOptions options)
{
if (imageField?.MediaItem == null)
{
return(string.Empty);
}
return(options == null?imageField.ImageUrl() : HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(imageField.MediaItem, options)));
}
public void ProvidedString_ShouldReturnValidSha256Hash()
{
var stringToHash = "abc";
var expectedHash = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad";
var actualHash = HashingUtils.SHA256HexHashString(stringToHash);
Assert.AreEqual(expectedHash, actualHash);
}
public static string ImageUrl(this ImageField imageField, MediaUrlOptions options)
{
if (imageField?.MediaItem == null)
{
throw new ArgumentNullException(nameof(imageField));
}
return(options == null?imageField.ImageUrl() : HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(imageField.MediaItem, options)));
}
public static string ImageUrl(this ImageField imageField, MediaUrlOptions options)
{
if (imageField?.MediaItem == null)
{
throw new ArgumentNullException(nameof(imageField));
}
var imageUrl = options == null?imageField.ImageUrl() : HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(imageField.MediaItem, options));
return(imageUrl.Replace("/sitecore/shell", ""));
}
/// <summary>
/// The page_ load.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="e">
/// The event argument.
/// </param>
protected void Page_Load(object sender, EventArgs e)
{
if (Sitecore.Context.Item.Name == "Customer Details")
{
this.headerImage.ImageUrl = HashingUtils.ProtectAssetUrl("/images/ecommerce/checkout_header_first.gif");
}
else
{
this.headerImage.ImageUrl = HashingUtils.ProtectAssetUrl("/images/ecommerce/checkout_header_last.gif");
}
}
public static HtmlString AdvancedImageField(this SitecoreHelper helper, string fieldName, Item item, int width = 0, int height = 0, string alt = null, string cssClass = null, bool disableWebEditing = false)
{
/*
* Example usage in view @Html.Sitecore().AdvancedImageField("Cropped", Model.Item, 100, 400)
*
* */
if (item == null)
{
return(new HtmlString("No datasource set"));
}
ImageField imageField = new ImageField(item.Fields[fieldName]);
if (String.IsNullOrEmpty(imageField.Value))
{
return(new HtmlString(String.Empty));
}
XmlDocument xml = new XmlDocument();
xml.LoadXml(imageField.Value);
if (xml.DocumentElement == null)
{
return(new HtmlString("No cropping image parameters found."));
}
string cropx = xml.DocumentElement.HasAttribute("cropx") ? xml.DocumentElement.GetAttribute("cropx") : string.Empty;
string cropy = xml.DocumentElement.HasAttribute("cropy") ? xml.DocumentElement.GetAttribute("cropy") : string.Empty;
string focusx = xml.DocumentElement.HasAttribute("focusx") ? xml.DocumentElement.GetAttribute("focusx") : string.Empty;
string focusy = xml.DocumentElement.HasAttribute("focusy") ? xml.DocumentElement.GetAttribute("focusy") : string.Empty;
float.TryParse(cropx, out float cx);
float.TryParse(cropy, out float cy);
float.TryParse(focusx, out float fx);
float.TryParse(focusy, out float fy);
string imageSrc = MediaManager.GetMediaUrl(imageField.MediaItem);
string src = $"{imageSrc}?cx={cx}&cy={cy}&cw={width}&ch={height}";
string hash = HashingUtils.GetAssetUrlHash(src);
TagBuilder builder = new TagBuilder("img");
builder.Attributes.Add("src", $"{src}&hash={hash}");
builder.Attributes.Add("alt", !String.IsNullOrEmpty(imageField.Alt) ? imageField.Alt : alt);
if (!string.IsNullOrEmpty(cssClass))
{
builder.AddCssClass(cssClass);
}
return(MvcHtmlString.Create(builder.ToString(TagRenderMode.Normal)));
}
public static string ImageUrl(this MediaItem mediaItem, MediaUrlOptions options = null)
{
if (mediaItem == null)
{
throw new ArgumentNullException(nameof(mediaItem));
}
var url = MediaManager.GetMediaUrl(mediaItem, options ?? MediaUrlOptions.Empty);
var cleanUrl = StringUtil.EnsurePrefix('/', url);
var hashedUrl = HashingUtils.ProtectAssetUrl(cleanUrl);
return(hashedUrl);
}
public (byte[], byte[], byte[]) GetSignature(TxTemplate transaction, string serializedTransaction, int index, string privKey)
{
var pubKeyBuffer = Encoders.Base58.DecodeData(transaction.Outputs[index].PublicKeys[0]);
string transactionUniqueFulfillment = GetUniqueFulfillment(transaction, serializedTransaction, index);
var transactionHash = HashingUtils.ComputeSha3Hash(Encoding.UTF8.GetBytes(transactionUniqueFulfillment));
var signature = CryptographyUtility.Ed25519Sign(transactionHash, Encoders.Base58.DecodeData(privKey));
return(transactionHash, pubKeyBuffer, signature);
}
public static string MediaUrl(this SitecoreHelper sitecoreHelper, ID fieldId, Item item, MediaUrlBuilderOptions options)
{
ImageField imageField = item?.Fields[fieldId];
if (imageField == null || imageField.MediaItem == null)
{
return(string.Empty);
}
var url = options != null?MediaManager.GetMediaUrl(imageField.MediaItem, options) : MediaManager.GetMediaUrl(imageField.MediaItem);
return(HashingUtils.ProtectAssetUrl(url));
}
public static string ImageAbsoluteUrl(this ImageField imageField)
{
if (imageField?.MediaItem == null)
{
return(string.Empty);
}
MediaUrlOptions options = new MediaUrlOptions();
options.AlwaysIncludeServerUrl = true;
return(HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(imageField.MediaItem, options)));
}
/// <summary>
/// </summary>
/// <param name="dataItem"></param>
/// <param name="width"></param>
/// <returns></returns>
public static string GetMediaItemUrlWithHash(MediaItem dataItem, int width)
{
var mediaUrl = GetMediaItemUrl(dataItem, width);
try
{
return(!string.IsNullOrEmpty(mediaUrl) ? HashingUtils.ProtectAssetUrl(mediaUrl) : mediaUrl);
}
catch
{
return(mediaUrl);
}
}
/// <summary>
/// Gets the media view.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="db">The database.</param>
/// <returns>
/// Media view contract
/// </returns>
public MediaViewResponse GetMediaView(string id, string db)
{
this.SetDatabase(db);
var item = database.GetItem(new ID(id));
MediaViewResponse vr = null;
if (item.Paths.IsMediaItem && item.TemplateName != Constants.MediaFolderTemplateName)
{
vr = new MediaViewResponse
{
IsMedia = true,
Name = item.Name,
Id = item.ID.ToString(),
Path = item.Paths.FullPath,
Icon = GetIcon(item),
MimeType = item["Mime Type"],
Extenions = item["Extension"],
Size = item["Size"]
};
var mediaItem = new MediaItem(item);
vr.Src = MediaManager.GetMediaUrl(mediaItem);
if (Constants.VideoAudioTemplates.Contains(item.TemplateName))
{
vr.MediaType = "video";
}
else if (Constants.ImageTemplates.Contains(item.TemplateName))
{
vr.MediaType = "image";
vr.Src = HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(mediaItem, new MediaUrlOptions {
MaxWidth = 640
}));
}
else
{
vr.MediaType = "other";
}
}
else
{
vr = new MediaViewResponse
{
IsMedia = false
};
}
return(vr);
}
public void Run(PropertyContext pipelineContext, ProcessorSchema processorContext)
{
try
{
if (!pipelineContext.Faulted)
{
var mediaUrlOptions = new MediaUrlOptions();
if (processorContext.Options.ContainsKey(Width) &&
int.TryParse(processorContext.Options[Width].ToString(), out int width))
{
mediaUrlOptions.Width = width;
}
if (processorContext.Options.ContainsKey(Height) &&
int.TryParse(processorContext.Options[Height].ToString(), out int height))
{
mediaUrlOptions.Height = height;
}
switch (pipelineContext.Context)
{
case ImageField imageField when imageField.MediaItem != null:
pipelineContext.Context = HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(imageField.MediaItem, mediaUrlOptions));
break;
case MediaItem mediaItem:
pipelineContext.Context = HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(mediaItem, mediaUrlOptions));
break;
case Item item:
pipelineContext.Context = HashingUtils.ProtectAssetUrl(MediaManager.GetMediaUrl(item, mediaUrlOptions));
break;
default:
pipelineContext.Faulted = true;
break;
}
}
}
catch
{
pipelineContext.Faulted = true;
throw;
}
finally
{
Next();
}
}
public static string ImageUrl(this MediaItem mediaItem, int width, int height)
{
if (mediaItem == null)
{
throw new ArgumentNullException(nameof(mediaItem));
}
var options = new MediaUrlOptions {
Height = height, Width = width
};
var url = MediaManager.GetMediaUrl(mediaItem, options);
var cleanUrl = StringUtil.EnsurePrefix('/', url);
var hashedUrl = HashingUtils.ProtectAssetUrl(cleanUrl);
return(hashedUrl);
}
public static string GetResizedMediaUrl(this HtmlHelper helper, string url, int maxWidth,
string focalPointSettings = null)
{
if (string.IsNullOrWhiteSpace(url))
{
return(null);
}
var separator = url.Contains("?") ? "&" : "?";
var mediaUrl = focalPointSettings.HasValue()
? $"{url}{separator}{focalPointSettings}"
: $"{url}{separator}mw={maxWidth}";
var finalUrl = HashingUtils.ProtectAssetUrl(mediaUrl);
return(finalUrl);
}
public string GetThumbnailUrl(int maxWidth)
{
if (DefaultImage == null)
{
return(null);
}
var options = new MediaUrlOptions {
MaxWidth = maxWidth
};
var url = MediaManager.GetMediaUrl(DefaultImage, options);
var cleanUrl = StringUtil.EnsurePrefix('/', url);
var hashedUrl = HashingUtils.ProtectAssetUrl(cleanUrl);
return(hashedUrl);
}
private static string GenerateImageUrl(string baseUrl, int?maxWidth, int?maxHeight)
{
var url = new StringBuilder();
url.Append(baseUrl);
if (maxWidth > 0)
{
url.AppendFormat("?mw={0}", maxWidth);
}
if (maxHeight > 0)
{
url.AppendFormat("{0}mh={1}", maxWidth > 0 ? "&" : "?", maxHeight);
}
return(HashingUtils.ProtectAssetUrl(url.ToString()));
}
private static void UpdateSchemaProperties(IEnumerable <SchemaProperty> schemaProperties)
{
ItemUrlBuilderOptions urlOptions = new ItemUrlBuilderOptions {
AlwaysIncludeServerUrl = true, LanguageEmbedding = LanguageEmbedding.Never
};
MediaUrlBuilderOptions mediaurlOptions = new MediaUrlBuilderOptions();
mediaurlOptions.AlwaysIncludeServerUrl = true;
if (schemaProperties != null)
{
foreach (var item in schemaProperties)
{
if (item.ItemScope)
{
UpdateSchemaProperties(item.Properties);
}
else
{
if (item.FieldType.Value == Constants.SchemaFieldTypes.CurrentItemURL)
{
item.FieldValue = LinkManager.GetItemUrl(Sitecore.Context.Item, urlOptions);
}
else if (item.FieldType.Value == Constants.SchemaFieldTypes.FromField)
{
item.FieldValue = Sitecore.Context.Item.Fields[item.FieldValue]?.Value;
}
else if (item.FieldType.Value == Constants.SchemaFieldTypes.FromParent)
{
item.FieldValue = Sitecore.Context.Item.Parent?.Fields[item.FieldType.Value]?.Value;
}
else if (item.FieldType.Value == Constants.SchemaFieldTypes.Image)
{
Sitecore.Data.Fields.ImageField imgField = Sitecore.Context.Item.Fields[item.FieldValue];
if (imgField != null)
{
var theURL = MediaManager.GetMediaUrl(imgField.MediaItem, mediaurlOptions);
item.FieldValue = HashingUtils.ProtectAssetUrl(theURL);
}
}
}
}
}
}
