private static string contentReplace(string content, IContentBase entity)
{
var ptypes = entity.PropertyTypes;
string contenttypename = ApplicationContext.Current.Services.EntityService.Get(entity.ContentTypeId, true).Name;
foreach (var ptype in ptypes)
{
PreValueCollection coll = ApplicationContext.Current.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(ptype.DataTypeDefinitionId);
if (coll.PreValuesAsDictionary.Count == 0)
{
string value = entity.GetValue <string>(ptype.Alias);
content = content.Replace("{{" + contenttypename + "." + ptype.Alias + "}}", entity.GetValue <string>(ptype.Alias));
}
else
{
foreach (var item in coll.PreValuesAsDictionary)
{
var kk = entity.GetValue <int>(ptype.Alias);
if (item.Value.Id.Equals(entity.GetValue <int>(ptype.Alias)))
{
string strval = item.Value.Value;
content = content.Replace("{{" + contenttypename + "." + ptype.Alias + "}}", strval);
}
}
}
}
return(content);
}
/// <summary>
/// Gets the url segment for a specified content and culture.
/// </summary>
/// <param name="content">The content.</param>
/// <param name="culture">The culture.</param>
/// <returns>
/// The url segment.
/// </returns>
/// <remarks>
/// This is for when Umbraco is capable of managing more than one url
/// per content, in 1-to-1 multilingual configurations. Then there would be one
/// url per culture.
/// </remarks>
public string GetUrlSegment(IContentBase content, CultureInfo culture)
{
if (content.GetContentType().Alias != "realEstate")
{
return(null);
}
var segment = _provider.GetUrlSegment(content);
return($"{content.GetValue("type")}-{content.GetValue<string>("city")}-{segment}".ToUrlSegment());
}
public static IEmailServer EmailService()
{
IContentBase home = Services.ContentService.GetById(Config[EnvKey.HomeId]);
var host = (string)home.GetValue("emailHost");
var ports = G.Int32((string)home.GetValue("emailPort"), 0);
var user = (string)home.GetValue("emailUser");
var password = (string)home.GetValue("emailPassword");
var ssl = G.ToBool(home.GetValue("emailSsl"));
IEmailServer es = new SPXEmailServer(host, ports, user, password, ssl);
return(es);
}
internal static void AutoPopulateFileMetaDataProperties(this IContentBase model, string propertyAlias, string relativefilePath = null)
{
var mediaFileSystem = FileSystemProviderManager.Current.GetFileSystemProvider <MediaFileSystem>();
var uploadFieldConfigNode =
UmbracoConfig.For.UmbracoSettings().Content.ImageAutoFillProperties
.FirstOrDefault(x => x.Alias == propertyAlias);
if (uploadFieldConfigNode != null && model.Properties.Contains(propertyAlias))
{
if (relativefilePath == null)
{
relativefilePath = model.GetValue <string>(propertyAlias);
}
//now we need to check if there is a path
if (!string.IsNullOrEmpty(relativefilePath))
{
var fullPath = mediaFileSystem.GetFullPath(mediaFileSystem.GetRelativePath(relativefilePath));
var umbracoFile = new UmbracoMediaFile(fullPath);
FillProperties(uploadFieldConfigNode, model, umbracoFile);
}
else
{
//for now I'm just resetting this
ResetProperties(uploadFieldConfigNode, model);
}
}
}
private static string GetUrlSegmentSource(IContentBase content)
{
string source = null;
if (content.HasProperty(Constants.Conventions.Content.UrlName))
source = (content.GetValue<string>(Constants.Conventions.Content.UrlName) ?? string.Empty).Trim();
if (string.IsNullOrWhiteSpace(source))
source = content.Name;
return source;
}
public string GetUrlSegment(IContentBase content, string culture = null)
{
if (content.ContentType.Alias != "productPage")
{
return(null);
}
var segment = provider.GetUrlSegment(content, culture);
var productSku = content.GetValue(propertyTypeAlias: "productSku", culture: culture, segment: null, published: true);
return(string.Format("{0}-{1}", segment, productSku));
}
private async Task ImportFirstImageAsync(IContentBase postNode, BlogMLPost post)
{
var imageMimeTypes = new List <string> {
"image/jpeg", "image/gif", "image/png"
};
var attachment = post.Attachments.FirstOrDefault(p => imageMimeTypes.Contains(p.MimeType));
if (attachment == null)
{
return;
}
var imageSaved = false;
if (!attachment.Content.IsNullOrWhiteSpace())
{
//the image is base64
var bytes = Convert.FromBase64String(attachment.Content);
using (var stream = new MemoryStream(bytes))
{
postNode.SetValue(_contentTypeBaseServiceProvider, "postImage", attachment.Url.OriginalString, stream);
imageSaved = true;
}
}
else if (attachment.ExternalUri != null && attachment.ExternalUri.IsAbsoluteUri)
{
try
{
using (var client = new HttpClient())
{
using (var stream = await client.GetStreamAsync(attachment.ExternalUri))
{
postNode.SetValue(_contentTypeBaseServiceProvider, "postImage", Path.GetFileName(attachment.ExternalUri.AbsolutePath), stream);
imageSaved = true;
}
}
}
catch (Exception exception)
{
_logger.Error <BlogMlImporter>(exception, "Exception retrieving {AttachmentUrl}; post {PostId}", attachment.Url, post.Id);
}
}
if (imageSaved)
{
//this is a work around for the SetValue method to save a file, since it doesn't currently take into account the image cropper
//which we are using so we need to fix that.
var propType = postNode.Properties["postImage"].PropertyType;
var cropperValue = CreateImageCropperValue(propType, postNode.GetValue("postImage"), _dataTypeService);
postNode.SetValue("postImage", cropperValue);
}
}
private void InjectTagsWithoutComma(IndexingNodeDataEventArgs e, IContentBase node)
{
foreach (var prop in node.PropertyTypes.Where(p => p.PropertyEditorAlias == Constants.PropertyEditors.TagsAlias))
{
var prevalues = prop.GetPrevalues();
if (prevalues["storageType"].Value.ToLower() == "json")
{
dynamic values = JsonConvert.DeserializeObject(node.GetValue <string>(prop.Alias));
StringBuilder newValues = new StringBuilder();
foreach (var value in values)
{
newValues.AppendLine(value.ToString());
}
e.Fields.Add("_" + prop.Alias, newValues.ToString());
}
else
{
e.Fields.Add("_" + prop.Alias, node.GetValue <string>(prop.Alias).Replace(",", " "));
}
}
}
private static string GetUrlSegmentSource(IContentBase content, string culture)
{
string source = null;
if (content.HasProperty(Constants.Conventions.Content.UrlName))
{
source = (content.GetValue <string>(Constants.Conventions.Content.UrlName, culture) ?? string.Empty).Trim();
}
if (string.IsNullOrWhiteSpace(source))
{
source = content.GetCultureName(culture);
}
return(source);
}
public string GetUrlSegment(IContentBase content)
{
if (!content.HasProperty(PropertyName)) return null;
try
{
var metadata = JsonConvert.DeserializeObject<SeoMetadata>(content.GetValue<string>(PropertyName));
if (metadata == null || String.IsNullOrWhiteSpace(metadata.UrlName)) return null;
return metadata.UrlName.ToUrlSegment();
}
catch
{
return null;
}
}
public string GetUrlSegment(IContentBase content)
{
if (content != null)
{
var contentType = Services.ContentTypeService.GetContentType(content.ContentTypeId);
if (contentType != null && contentType.Alias == "Vacancyitem")
{
//This will add the level before the node name.
//For example /developer/ becomes /junior-developer/
var level = content.GetValue <VacancyLevel>("level");
return(level.ToString().ToUrlSegment() + "-" + content.Name.ToUrlSegment());
}
}
return(null);
}
public string GetUrlSegment(IContentBase content)
{
if (content != null)
{
var contentType = Services.ContentTypeService.GetContentType(content.ContentTypeId);
if (contentType != null && contentType.Alias == "Vacancyitem")
{
//This will add the level before the node name.
//For example /developer/ becomes /junior-developer/
var level = content.GetValue<VacancyLevel>("level");
return level.ToString().ToUrlSegment() + "-" + content.Name.ToUrlSegment();
}
}
return null;
}
public string GetUrlSegment(IContentBase content)
{
if (!content.HasProperty(PropertyName))
{
return(null);
}
try
{
var seoMetadata = JsonConvert.DeserializeObject <SeoMetaData>(content.GetValue <string>(PropertyName));
return(string.IsNullOrWhiteSpace(seoMetadata?.UrlName) ? null : seoMetadata.UrlName.ToUrlSegment());
}
catch
{
return(null);
}
}
public string GetUrlSegment(IContentBase content, CultureInfo culture)
{
// only for product doctypes
var productContentType = PublishedContentModels.Product.ModelTypeAlias;
if (content.GetContentType().Alias != productContentType)
{
return(null);
}
var segment = _provider.GetUrlSegment(content);
// Watch the "ToUrlSegment()"
var productName = content.GetValue <string>("productName")?.ToUrlSegment();
return($"{segment}-{productName}");
}
private static string GetUrlSegmentSource(IContentBase content, string culture)
{
string source = null;
if (content.HasProperty(Constants.Conventions.Content.UrlName))
{
source = (content.GetValue <string>(Constants.Conventions.Content.UrlName, culture) ?? string.Empty).Trim();
}
if (string.IsNullOrWhiteSpace(source))
{
// If the name of a node has been updated, but it has not been published, the url should use the published name, not the current node name
// If this node has never been published (GetPublishName is null), use the unpublished name
source = (content is IContent document) && document.Edited && document.GetPublishName(culture) != null
? document.GetPublishName(culture)
: content.GetCultureName(culture);
}
return(source);
}
/// <summary>
/// Sets the default value.
/// </summary>
/// <param name="content">The content to set default values for.</param>
/// <param name="model">The model.</param>
private static void SetDefaultValue(IContentBase content, PropertyType model)
{
if (!model.HasDefaultValue)
{
return;
}
var value = content.GetValue(model.Alias);
if (value != null)
{
return;
}
if (!CanSetDefaultValue(model.Type, model.DefaultValue))
{
return;
}
content.SetValue(model.Alias, model.DefaultValue);
}
/// <summary>
/// Munge the fields into a new one identified by key for searching.
/// </summary>
/// <param name="e"></param>
/// <param name="node"></param>
/// <param name="key"></param>
/// <param name="fields"></param>
private void AggregateFields(IndexingNodeDataEventArgs e, IContentBase node, string key, string[] fields)
{
var combinedFields = new StringBuilder();
foreach (var prop in node.PropertyTypes.Where(p => fields.Contains(p.Alias)))
{
switch (prop.PropertyEditorAlias)
{
// We want to attempt to retrieve the relevant fields from the properties that return JSON content.
case Constants.PropertyEditors.NestedContentAlias:
case "Our.Umbraco.StackedContent":
{
var editor = PropertyEditorResolver.Current.GetByAlias(prop.PropertyEditorAlias).ValueEditor;
var scJson = editor.ConvertDbToEditor(node.Properties.Single(p => p.Alias == prop.Alias),
prop,
ApplicationContext.Current.Services.DataTypeService) as JToken;
combinedFields.AppendLine(IndexNestedJObject(scJson, fields));
break;
}
case Constants.PropertyEditors.GridAlias:
{
var editor = PropertyEditorResolver.Current.GetByAlias(prop.PropertyEditorAlias).ValueEditor;
var gridJson = editor.ConvertDbToEditor(node.Properties.Single(p => p.Alias == prop.Alias),
prop,
ApplicationContext.Current.Services.DataTypeService) as JToken;
combinedFields.AppendLine(IndexNestedJObject(gridJson, new[] { "value", "caption" }));
break;
}
default:
combinedFields.AppendLine(node.GetValue <string>(prop.Alias));
break;
}
}
e.Fields.Add(key, combinedFields.ToString());
}
private Document GetDocumentToIndex(IContentBase content, SearchField[] searchFields)
{
try
{
var c = new Document();
var type = content.GetType();
foreach (var field in GetStandardUmbracoFields())
{
try
{
object propertyValue = null;
// handle special case properties
switch (field.Name)
{
case "SearchablePath":
propertyValue = content.Path.TrimStart('-');
break;
case "Path":
propertyValue = content.Path.Split(',');
break;
case "CreatorName":
propertyValue = content.GetCreatorProfile(UmbracoContext.Current.Application.Services.UserService).Name;
break;
case "ParentID":
propertyValue = content.ParentId;
break;
default:
// try get model property
PropertyInfo modelProperty;
if (!_propertyCache.ContainsKey(type.Name))
{
_propertyCache[type.Name] = new Dictionary <string, PropertyInfo>();
}
var cache = _propertyCache[type.Name];
if (cache.ContainsKey(field.Name))
{
modelProperty = cache[field.Name];
}
else
{
modelProperty = type.GetProperty(field.Name);
cache[field.Name] = modelProperty;
}
if (modelProperty != null)
{
propertyValue = modelProperty.GetValue(content);
}
else
{
// try get umbraco property
if (content.HasProperty(field.Name))
{
propertyValue = content.GetValue(field.Name);
}
}
break;
}
// handle datatypes
switch (field.Type.ToString())
{
case "Edm.String":
propertyValue = propertyValue?.ToString();
break;
case "Edm.Boolean":
bool.TryParse((propertyValue ?? "False").ToString(), out var val);
propertyValue = val;
break;
}
if (propertyValue?.ToString().IsNullOrWhiteSpace() == false)
{
c[field.Name] = propertyValue;
}
}
catch (Exception ex)
{
throw;
}
}
switch (type.Name)
{
case "Media":
c["IsMedia"] = true;
break;
case "Content":
c["IsContent"] = true;
break;
case "Member":
c["IsMember"] = true;
break;
}
bool cancelIndex = AzureSearch.FireContentIndexing(
new AzureSearchEventArgs()
{
Item = content,
Entry = c
});
if (cancelIndex)
{
// cancel was set in an event, so we don't index this item.
return(null);
}
var umbracoFields = searchFields.Where(x => !x.IsComputedField()).ToArray();
var computedFields = searchFields.Where(x => x.IsComputedField()).ToArray();
c = FromUmbracoContentBase(c, content, umbracoFields);
c = FromComputedFields(c, content, computedFields);
// todo: content isn't actually indexed at this point, consider moving the event to the callback from azure after sending to index
AzureSearch.FireContentIndexed(
new AzureSearchEventArgs()
{
Item = content,
Entry = c
});
return(c);
}
catch (Exception ex)
{
throw;
}
}
private void CopyPropertyValueToModel(IContentBase content, object objectInstance, PropertyRegistration registration)
{
var umbracoStoredValue = content.GetValue(registration.Alias);
SetPropertyValueOnModel(objectInstance, registration, umbracoStoredValue);
}
private static string contentReplace(string content, IContentBase entity)
{
var ptypes = entity.PropertyTypes;
string contenttypename = ApplicationContext.Current.Services.EntityService.Get(entity.ContentTypeId, true).Name;
foreach (var ptype in ptypes)
{
PreValueCollection coll = ApplicationContext.Current.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(ptype.DataTypeDefinitionId);
if (coll.PreValuesAsDictionary.Count == 0)
{
string value = entity.GetValue<string>(ptype.Alias);
content = content.Replace("{{" + contenttypename + "." + ptype.Alias + "}}", entity.GetValue<string>(ptype.Alias));
}
else
{
foreach (var item in coll.PreValuesAsDictionary)
{
var kk = entity.GetValue<int>(ptype.Alias);
if (item.Value.Id.Equals(entity.GetValue<int>(ptype.Alias)))
{
string strval = item.Value.Value;
content = content.Replace("{{" + contenttypename + "." + ptype.Alias + "}}", strval);
}
}
}
}
return content;
}
private void ExtractAuthorData(IndexingNodeDataEventArgs e, IContentBase node)
{
// Munge the author for searching.
foreach (var prop in node.PropertyTypes.Where(p => p.Alias == "author"))
{
var authorNode = ApplicationContext.Current.Services.ContentService.GetById(node.GetValue <Guid>(prop.Alias));
if (authorNode != null)
{
StringBuilder authorString = new StringBuilder();
authorString.AppendLine(authorNode.Name);
foreach (var authorProp in authorNode.Properties.AsEnumerable())
{
authorString.AppendLine($" {authorProp.Value}");
}
e.Fields.Add("_" + prop.Alias, authorString.ToString());
}
}
}
