/// <summary> /// Get an entity via an id that can be either an integer, Guid or UDI /// </summary> /// <param name="id"></param> /// <returns></returns> /// <remarks> /// This object has it's own contextual cache for these lookups /// </remarks> internal IEntitySlim GetEntityFromId(string id) { return(_entityCache.GetOrAdd(id, s => { IEntitySlim entity; if (Guid.TryParse(s, out var idGuid)) { entity = Services.EntityService.Get(idGuid, UmbracoObjectType); } else if (int.TryParse(s, out var idInt)) { entity = Services.EntityService.Get(idInt, UmbracoObjectType); } else if (Udi.TryParse(s, out var idUdi)) { var guidUdi = idUdi as GuidUdi; entity = guidUdi != null ? Services.EntityService.Get(guidUdi.Guid, UmbracoObjectType) : null; } else { entity = null; } return entity; })); }
/// <summary> /// Get an entity via an id that can be either an integer, Guid or UDI /// </summary> /// <param name="id"></param> /// <returns></returns> internal IUmbracoEntity GetEntityFromId(string id) { IUmbracoEntity entity; Guid idGuid; int idInt; Udi idUdi; if (Guid.TryParse(id, out idGuid)) { entity = Services.EntityService.GetByKey(idGuid, UmbracoObjectType); } else if (int.TryParse(id, out idInt)) { entity = Services.EntityService.Get(idInt, UmbracoObjectType); } else if (Udi.TryParse(id, out idUdi)) { var guidUdi = idUdi as GuidUdi; entity = guidUdi != null?Services.EntityService.GetByKey(guidUdi.Guid, UmbracoObjectType) : null; } else { return(null); } return(entity); }
private IEnumerable <(int?intId, GuidUdi udi, string tagValue)> FindLocalLinkIds(string text) { // Parse internal links var tags = LocalLinkPattern.Matches(text); foreach (Match tag in tags) { if (tag.Groups.Count > 0) { var id = tag.Groups[1].Value; //.Remove(tag.Groups[1].Value.Length - 1, 1); //The id could be an int or a UDI if (Udi.TryParse(id, out var udi)) { var guidUdi = udi as GuidUdi; if (guidUdi != null) { yield return(null, guidUdi, tag.Value); } } if (int.TryParse(id, out var intId)) { yield return(intId, null, tag.Value); } } } }
/// <summary> /// this will parse the string into either a GUID or INT /// </summary> /// <param name="id"></param> /// <returns></returns> internal Tuple <Guid?, int?> GetIdentifierFromString(string id) { Guid idGuid; int idInt; Udi idUdi; if (Guid.TryParse(id, out idGuid)) { return(new Tuple <Guid?, int?>(idGuid, null)); } if (int.TryParse(id, out idInt)) { return(new Tuple <Guid?, int?>(null, idInt)); } if (Udi.TryParse(id, out idUdi)) { var guidUdi = idUdi as GuidUdi; if (guidUdi != null) { return(new Tuple <Guid?, int?>(guidUdi.Guid, null)); } } return(null); }
protected override void AddSingleValue(Document doc, object value) { base.AddSingleValue(doc, value); if (value is string valueString) { var ids = valueString.Split(','); foreach (var id in ids) { if (Udi.TryParse(id, out Udi udi) == true) { var content = _publishedContentHelper.GetByUdi(udi); if (content != null) { if (content.UrlSegment != null) { doc.Add(new Field(_aliasPrefix + FieldName, content.UrlSegment, Field.Store.YES, Field.Index.ANALYZED)); } } } } } }
private void AppendPath(StringBuilder sb, UmbracoObjectTypes objectType, int[] startNodeIds, string searchFrom, bool ignoreUserStartNodes, IEntityService entityService) { if (sb == null) { throw new ArgumentNullException("sb"); } if (entityService == null) { throw new ArgumentNullException("entityService"); } Udi udi; Udi.TryParse(searchFrom, true, out udi); searchFrom = udi == null ? searchFrom : entityService.GetIdForUdi(udi).Result.ToString(); int searchFromId; var entityPath = int.TryParse(searchFrom, out searchFromId) && searchFromId > 0 ? entityService.GetAllPaths(objectType, searchFromId).FirstOrDefault() : null; if (entityPath != null) { // find... only what's underneath sb.Append("+__Path:"); AppendPath(sb, entityPath.Path, false); sb.Append(" "); } else if (startNodeIds.Length == 0) { // make sure we don't find anything sb.Append("+__Path:none "); } else if (startNodeIds.Contains(-1) == false && ignoreUserStartNodes == false) // -1 = no restriction { var entityPaths = entityService.GetAllPaths(objectType, startNodeIds); // for each start node, find the start node, and what's underneath // +__Path:(-1*,1234 -1*,1234,* -1*,5678 -1*,5678,* ...) sb.Append("+__Path:("); var first = true; foreach (var ep in entityPaths) { if (first) { first = false; } else { sb.Append(" "); } AppendPath(sb, ep.Path, true); } sb.Append(") "); } }
protected override void AddSingleValue(Document doc, object value) { if (value is string valueString) { if (Udi.TryParse(valueString, out Udi udi) == true) { doc.Add(new Field(FieldName, udi.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED)); } } }
// TODO: Replace mediaCache with media url provider internal static string ParseInternalLinks(string text, UrlProvider urlProvider, IPublishedMediaCache mediaCache) { if (urlProvider == null) { throw new ArgumentNullException(nameof(urlProvider)); } if (mediaCache == null) { throw new ArgumentNullException(nameof(mediaCache)); } // Parse internal links var tags = LocalLinkPattern.Matches(text); foreach (Match tag in tags) { if (tag.Groups.Count > 0) { var id = tag.Groups[1].Value; //.Remove(tag.Groups[1].Value.Length - 1, 1); //The id could be an int or a UDI if (Udi.TryParse(id, out var udi)) { var guidUdi = udi as GuidUdi; if (guidUdi != null) { var newLink = "#"; if (guidUdi.EntityType == Constants.UdiEntityType.Document) { newLink = urlProvider.GetUrl(guidUdi.Guid); } else if (guidUdi.EntityType == Constants.UdiEntityType.Media) { newLink = mediaCache.GetById(guidUdi.Guid)?.Url; } if (newLink == null) { newLink = "#"; } text = text.Replace(tag.Value, "href=\"" + newLink); } } if (int.TryParse(id, out var intId)) { var newLink = urlProvider.GetUrl(intId); text = text.Replace(tag.Value, "href=\"" + newLink); } } } return(text); }
/// <summary> /// Get paged child entities by id /// </summary> /// <param name="id"></param> /// <param name="type"></param> /// <param name="pageNumber"></param> /// <param name="pageSize"></param> /// <param name="orderBy"></param> /// <param name="orderDirection"></param> /// <param name="filter"></param> /// <returns></returns> public PagedResult <EntityBasic> GetPagedChildren( string id, UmbracoEntityTypes type, int pageNumber, int pageSize, string orderBy = "SortOrder", Direction orderDirection = Direction.Ascending, string filter = "", Guid?dataTypeId = null) { int intId; if (int.TryParse(id, out intId)) { return(GetPagedChildren(intId, type, pageNumber, pageSize, orderBy, orderDirection, filter)); } Guid guidId; if (Guid.TryParse(id, out guidId)) { //Not supported currently throw new HttpResponseException(HttpStatusCode.NotFound); } Udi udiId; if (Udi.TryParse(id, out udiId)) { //Not supported currently throw new HttpResponseException(HttpStatusCode.NotFound); } //so we don't have an INT, GUID or UDI, it's just a string, so now need to check if it's a special id or a member type if (id == Constants.Conventions.MemberTypes.AllMembersListId) { //the EntityService can search paged members from the root intId = -1; return(GetPagedChildren(intId, type, pageNumber, pageSize, orderBy, orderDirection, filter, dataTypeId)); } //the EntityService cannot search members of a certain type, this is currently not supported and would require //quite a bit of plumbing to do in the Services/Repository, we'll revert to a paged search long total; var searchResult = _treeSearcher.ExamineSearch(Umbraco, filter ?? "", type, pageSize, pageNumber - 1, out total, id); return(new PagedResult <EntityBasic>(total, pageNumber, pageSize) { Items = searchResult }); }
public GuidUdi GetShareImageUdi( //IContentService _contentService ) { Udi udi; if (Udi.TryParse(ShareImage, out udi)) { return(udi as GuidUdi); // return _contentService.GetById(guidUdi.Guid); } return(null); }
public IEnumerable <UmbracoEntityReference> GetReferences(object value) { var asString = value is string str ? str : value?.ToString(); if (string.IsNullOrEmpty(asString)) { yield break; } if (Udi.TryParse(asString, out var udi)) { yield return(new UmbracoEntityReference(udi)); } }
public IEnumerable <UmbracoEntityReference> GetReferences(object value) { var asString = value == null ? string.Empty : value is string str ? str : value.ToString(); var udiPaths = asString.Split(Constants.CharArrays.Comma); foreach (var udiPath in udiPaths) { if (Udi.TryParse(udiPath, out var udi)) { yield return(new UmbracoEntityReference(udi)); } } }
private ElementsImage GetImageFromCache(string id, int width, int height) { IPublishedContent media = null; if (Udi.TryParse(id, out Udi udi)) { media = Umbraco.Media(udi); } else if (int.TryParse(id, out int numericId)) { media = Umbraco.Media(numericId); } return(media == null ? null : new ElementsImage(media, width, height)); }
private ElementsImage GetImageFromService(string id, int width, int height) { IMedia media = null; if (Udi.TryParse(id, out Udi udi) && udi is GuidUdi guidUdi) { media = Services.MediaService.GetById(guidUdi.Guid); } else if (int.TryParse(id, out int numericId)) { media = Services.MediaService.GetById(numericId); } return(media == null ? null : new ElementsImage(media, width, height)); }
protected override void AddSingleValue(Document doc, object value) { if (value is string valueString) { var ids = valueString.Split(new[] { Separator }, StringSplitOptions.RemoveEmptyEntries); foreach (var id in ids) { if (Udi.TryParse(id, out Udi udi) == true) { doc.Add(new Field(FieldName, udi.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED)); } } } }
/// <summary> /// Get paged child entities by id /// </summary> /// <param name="id"></param> /// <param name="type"></param> /// <param name="pageNumber"></param> /// <param name="pageSize"></param> /// <param name="orderBy"></param> /// <param name="orderDirection"></param> /// <param name="filter"></param> /// <returns></returns> public PagedResult <EntityBasic> GetPagedChildren( string id, UmbracoEntityTypes type, int pageNumber, int pageSize, string orderBy = "SortOrder", Direction orderDirection = Direction.Ascending, string filter = "") { if (int.TryParse(id, out var intId)) { return(GetPagedChildren(intId, type, pageNumber, pageSize, orderBy, orderDirection, filter)); } if (Guid.TryParse(id, out _)) { //Not supported currently throw new HttpResponseException(HttpStatusCode.NotFound); } if (Udi.TryParse(id, out _)) { //Not supported currently throw new HttpResponseException(HttpStatusCode.NotFound); } //so we don't have an INT, GUID or UDI, it's just a string, so now need to check if it's a special id or a member type if (id == Constants.Conventions.MemberTypes.AllMembersListId) { //the EntityService can search paged members from the root intId = -1; return(GetPagedChildren(intId, type, pageNumber, pageSize, orderBy, orderDirection, filter)); } //the EntityService cannot search members of a certain type, this is currently not supported and would require //quite a bit of plumbing to do in the Services/Repository, we'll revert to a paged search //TODO: We should really fix this in the EntityService but if we don't we should allow the ISearchableTree for the members controller // to be used for this search instead of the built in/internal searcher var searchResult = _treeSearcher.ExamineSearch(filter ?? "", type, pageSize, pageNumber - 1, out long total, id); return(new PagedResult <EntityBasic>(total, pageNumber, pageSize) { Items = searchResult }); }
public IEnumerable <UmbracoEntityReference> GetReferences(object value) { // This is the same as the media picker, it will just try to parse the value directly as a UDI var asString = value is string str ? str : value?.ToString(); if (string.IsNullOrEmpty(asString)) { yield break; } if (Udi.TryParse(asString, out var udi)) { yield return(new UmbracoEntityReference(udi)); } }
/// <remarks>Had to change to internal for testing.</remarks> internal static bool ConvertIdObjectToUdi(object id, out Udi guidId) { switch (id) { case string s: return(Udi.TryParse(s, out guidId)); case Udi u: guidId = u; return(true); default: guidId = default; return(false); } }
public IEnumerable <UmbracoEntityReference> GetReferences(object value) { var asString = value is string str ? str : value?.ToString(); if (string.IsNullOrEmpty(asString)) { yield break; } foreach (var udiStr in asString.Split(Constants.CharArrays.Comma)) { if (Udi.TryParse(udiStr, out var udi)) { yield return(new UmbracoEntityReference(udi)); } } }
/// <summary> /// Parses out media UDIs from an html string based on 'data-udi' html attributes /// </summary> /// <param name="text"></param> /// <returns></returns> public IEnumerable <Udi> FindUdisFromDataAttributes(string text) { var matches = DataUdiAttributeRegex.Matches(text); if (matches.Count == 0) { yield break; } foreach (Match match in matches) { if (match.Groups.Count == 2 && Udi.TryParse(match.Groups[1].Value, out var udi)) { yield return(udi); } } }
/// <inheritdoc/> public async Task <IImageResolver> GetAsync(HttpContext context) { if (!Udi.TryParse(context.Request.Host + context.Request.Path, out Udi udi) || udi.EntityType != Constants.UdiEntityTypes.MediaFile || udi.EntityType.Type != UdiType.ClosedString) { return(null); } IFileSystemEntry file = await this.fileSystem.GetFileAsync(udi.Id, default); if (file is null) { return(null); } return(new FileSystemImageResolver(file)); }
public IPublishedContent GetByString(string id) { if (int.TryParse(id, out int intId) == true) { return(GetByInt(intId)); } if (Guid.TryParse(id, out Guid guidId) == true) { return(GetByGuid(guidId)); } if (Udi.TryParse(id, out Udi udi) == true) { return(GetByUdi(udi)); } return(null); }
private void InitPublishedContent() { if (!_publishedContentInitialized) { _publishedContentInitialized = true; if (UmbracoContext.Current == null) { return; } if (Udi.TryParse(_linkItem.Value <string>("udi"), out _udi)) { _content = _udi.ToPublishedContent(); _id = _content?.Id; } else { var helper = new UmbracoHelper(UmbracoContext.Current); // there were no Udi so let's try the legacy way _id = _linkItem.Value <int?>("id"); if (_id.HasValue) { bool isMedia = _linkItem.Value <bool>("isMedia"); if (_linkItem.Value <bool>("isMedia")) { _content = helper.TypedMedia(_id.Value); } else { _content = helper.TypedContent(_id.Value); } SetUdi(); } } } }
public void RangeTest() { // can parse open string udi var stringUdiString = "umb://" + Constants.UdiEntityType.AnyString; Udi stringUdi; Assert.IsTrue(Udi.TryParse(stringUdiString, out stringUdi)); Assert.AreEqual(string.Empty, ((StringUdi)stringUdi).Id); // can parse open guid udi var guidUdiString = "umb://" + Constants.UdiEntityType.AnyGuid; Udi guidUdi; Assert.IsTrue(Udi.TryParse(guidUdiString, out guidUdi)); Assert.AreEqual(Guid.Empty, ((GuidUdi)guidUdi).Guid); // can create a range var range = new UdiRange(stringUdi, Constants.DeploySelector.ChildrenOfThis); // cannot create invalid ranges Assert.Throws <ArgumentException>(() => new UdiRange(guidUdi, "x")); }
/// <summary> /// Parses the string looking for the {localLink} syntax and updates them to their correct links. /// </summary> /// <param name="text"></param> /// <param name="urlProvider"></param> /// <returns></returns> public static string ParseInternalLinks(string text, UrlProvider urlProvider) { if (urlProvider == null) { throw new ArgumentNullException("urlProvider"); } // Parse internal links var tags = LocalLinkPattern.Matches(text); foreach (Match tag in tags) { if (tag.Groups.Count > 0) { var id = tag.Groups[1].Value; //.Remove(tag.Groups[1].Value.Length - 1, 1); //The id could be an int or a UDI Udi udi; if (Udi.TryParse(id, out udi)) { var guidUdi = udi as GuidUdi; if (guidUdi != null) { var newLink = urlProvider.GetUrl(guidUdi.Guid); text = text.Replace(tag.Value, "href=\"" + newLink); } } int intId; if (int.TryParse(id, out intId)) { var newLink = urlProvider.GetUrl(intId); text = text.Replace(tag.Value, "href=\"" + newLink); } } } return(text); }
public void KnownTypes() { Udi udi; // cannot parse an unknown type, udi is null // this will scan Assert.IsFalse(Udi.TryParse("umb://whatever/1234", out udi)); Assert.IsNull(udi); Udi.ResetUdiTypes(); // unless we want to know Assert.IsFalse(Udi.TryParse("umb://whatever/1234", true, out udi)); Assert.AreEqual(Constants.UdiEntityType.Unknown, udi.EntityType); Assert.AreEqual("Umbraco.Core.Udi+UnknownTypeUdi", udi.GetType().FullName); Udi.ResetUdiTypes(); // not known Assert.IsFalse(Udi.TryParse("umb://foo/A87F65C8D6B94E868F6949BA92C93045", true, out udi)); Assert.AreEqual(Constants.UdiEntityType.Unknown, udi.EntityType); Assert.AreEqual("Umbraco.Core.Udi+UnknownTypeUdi", udi.GetType().FullName); // scanned Assert.IsTrue(Udi.TryParse("umb://foo/A87F65C8D6B94E868F6949BA92C93045", out udi)); Assert.IsInstanceOf <GuidUdi>(udi); // known Assert.IsTrue(Udi.TryParse("umb://foo/A87F65C8D6B94E868F6949BA92C93045", true, out udi)); Assert.IsInstanceOf <GuidUdi>(udi); // can get method for Deploy compatibility var method = typeof(Udi).GetMethod("Parse", BindingFlags.Static | BindingFlags.Public, null, new[] { typeof(string), typeof(bool) }, null); Assert.IsNotNull(method); }
/// <inheritdoc/> public override string GetValue(GridValue.GridControl control, Property property, ICollection <ArtifactDependency> dependencies) { // cancel if there's no values if (control.Value == null || control.Value.HasValues == false) { return(null); } // Often there is only one entry in cell.Value, but with LeBlender // min/max you can easily get 2+ entries so we'll walk them all var newItemValue = new List <object>(); foreach (var properties in control.Value) { // create object to store resolved properties var resolvedProperties = new JObject(); foreach (var leBlenderPropertyWrapper in properties) { if (leBlenderPropertyWrapper.HasValues == false) { continue; } var leBlenderProperty = leBlenderPropertyWrapper.First.ToObject <LeBlenderGridCellValue>(); // get the data type of the property var dataType = _dataTypeService.GetDataTypeDefinitionById(leBlenderProperty.DataTypeGuid); if (dataType == null) { throw new ArgumentNullException( $"Unable to find the data type for editor '{leBlenderProperty.EditorName}' ({leBlenderProperty.EditorAlias} {leBlenderProperty.DataTypeGuid}) referenced by '{property.Alias}'."); } // add the datatype as a dependency dependencies.Add(new ArtifactDependency(dataType.GetUdi(), false, ArtifactDependencyMode.Exist)); // if it's null or undefined value there is no need to do any more processing if (leBlenderProperty.Value.Type == JTokenType.Null || leBlenderProperty.Value.Type == JTokenType.Undefined) { resolvedProperties.Add(leBlenderProperty.EditorAlias, JObject.FromObject(leBlenderProperty)); continue; } Udi udi; // if the value is an Udi then add it as a dependency if (Udi.TryParse(leBlenderProperty.Value.ToString(), out udi)) { dependencies.Add(new ArtifactDependency(udi, false, ArtifactDependencyMode.Exist)); resolvedProperties.Add(leBlenderProperty.EditorAlias, JObject.FromObject(leBlenderProperty)); continue; } var tempDependencies = new List <Udi>(); // try to convert the value with the macro parser - this is mainly for legacy editors var value = _macroParser.ReplaceAttributeValue(leBlenderProperty.Value.ToString(), dataType.PropertyEditorAlias, tempDependencies, Direction.ToArtifact); foreach (var dependencyUdi in tempDependencies) { // if the macro parser was able to convert the value it will mark the Udi as dependency // and we want that added as a artifact dependency dependencies.Add(new ArtifactDependency(dependencyUdi, false, ArtifactDependencyMode.Exist)); } // test if the macroparser converted the value to an Udi if (Udi.TryParse(value, out udi)) { leBlenderProperty.Value = value; resolvedProperties.Add(leBlenderProperty.EditorAlias, JObject.FromObject(leBlenderProperty)); continue; } // if the macro parser didn't convert the value then try to find a value connector that can and convert it var propertyType = new PropertyType(dataType.PropertyEditorAlias, dataType.DatabaseType); propertyType.DataTypeDefinitionId = dataType.Id; var propValueConnector = ValueConnectors.Get(propertyType); if (leBlenderProperty.Value.Type == JTokenType.Array) { // if the value is an array then we should try and convert each item instead of the whole array var array = new JArray(); foreach (var child in leBlenderProperty.Value) { var mockProperty = new Property(propertyType, child.Value <object>()); var convertedValue = propValueConnector.GetValue(mockProperty, dependencies); array.Add(new JValue(convertedValue)); } leBlenderProperty.Value = array; } else { var mockProperty = new Property(propertyType, leBlenderProperty.Value); value = propValueConnector.GetValue(mockProperty, dependencies); leBlenderProperty.Value = value; } resolvedProperties.Add(leBlenderProperty.EditorAlias, JObject.FromObject(leBlenderProperty)); } newItemValue.Add(resolvedProperties); } return(JsonConvert.SerializeObject(newItemValue)); }
public string GetValue(Property property, ICollection <ArtifactDependency> dependencies) { if (property.Value == null) { return(null); } var value = property.Value.ToString(); var prevalues = _dataTypeService.GetPreValuesCollectionByDataTypeId(property.PropertyType.DataTypeDefinitionId).PreValuesAsDictionary; PreValue prevalue; //Fetch the Prevalues for the current Property's DataType (if its an 'Archetype config') if (!prevalues.TryGetValue("archetypeconfig", out prevalue) && !prevalues.TryGetValue("archetypeConfig", out prevalue)) { throw new InvalidOperationException("Could not find Archetype configuration."); } var archetypePreValue = prevalue == null ? null : JsonConvert.DeserializeObject <ArchetypePreValue>(prevalue.Value); RetrieveAdditionalProperties(ref archetypePreValue); var archetype = JsonConvert.DeserializeObject <ArchetypeModel>(value); RetrieveAdditionalProperties(ref archetype, archetypePreValue); if (archetype == null) { throw new InvalidOperationException("Could not parse Archetype value."); } var properties = archetype.Fieldsets.SelectMany(x => x.Properties); foreach (var archetypeProperty in properties) { if (archetypeProperty.DataTypeGuid == null) { continue; } // get the data type of the property var dataType = _dataTypeService.GetDataTypeDefinitionById(Guid.Parse(archetypeProperty.DataTypeGuid)); if (dataType == null) { throw new ArgumentNullException( $"Unable to find the data type for editor '{archetypeProperty.PropertyEditorAlias}' ({archetypeProperty.DataTypeGuid}) referenced by '{property.Alias}'."); } // add the datatype as a dependency dependencies.Add(new ArtifactDependency(new GuidUdi(Constants.UdiEntityType.DataType, dataType.Key), false, ArtifactDependencyMode.Exist)); // if it's null or undefined value there is no need to do any more processing if (archetypeProperty.Value == null || archetypeProperty.Value.ToString() == string.Empty) { continue; } Udi udi; // if the value is an Udi then add it as a dependency and continue if (Udi.TryParse(archetypeProperty.Value.ToString(), out udi)) { dependencies.Add(new ArtifactDependency(udi, false, ArtifactDependencyMode.Exist)); continue; } var tempDependencies = new List <Udi>(); // try to convert the value with the macro parser - this is mainly for legacy editors var archetypeValue = archetypeProperty.Value != null ? _macroParser.ReplaceAttributeValue(archetypeProperty.Value.ToString(), dataType.PropertyEditorAlias, tempDependencies, Direction.ToArtifact) : null; foreach (var dependencyUdi in tempDependencies) { // if the macro parser was able to convert the value it will mark the Udi as dependency // and we want that added as a artifact dependency dependencies.Add(new ArtifactDependency(dependencyUdi, false, ArtifactDependencyMode.Exist)); } // test if the macroparser converted the value to an Udi so we can just continue if (Udi.TryParse(archetypeValue, out udi)) { archetypeProperty.Value = archetypeValue; continue; } // if the macro parser didn't convert the value then try to find a value connector that can and convert it var propertyType = new PropertyType(dataType.PropertyEditorAlias, dataType.DatabaseType); propertyType.DataTypeDefinitionId = dataType.Id; var propValueConnector = ValueConnectors.Get(propertyType); var mockProperty = new Property(propertyType, archetypeProperty.Value); archetypeValue = propValueConnector.GetValue(mockProperty, dependencies); archetypeProperty.Value = archetypeValue; } value = archetype.SerializeForPersistence(); return(value); }
public override string GetValue(GridValue.GridControl control, Property property, ICollection <ArtifactDependency> dependencies) { // cancel if there's no values if (control.Value == null || control.Value.HasValues == false) { return(null); } var docTypeGridEditorContent = JsonConvert.DeserializeObject <DocTypeGridEditorValue>(control.Value.ToString()); // if an 'empty' dtge item has been added - it has no ContentTypeAlias set .. just return and don't throw. if (docTypeGridEditorContent == null || string.IsNullOrWhiteSpace(docTypeGridEditorContent.ContentTypeAlias)) { return(null); } // check if the doc type exist - else abort packaging var contentType = _contentTypeService.GetContentType(docTypeGridEditorContent.ContentTypeAlias); if (contentType == null) { throw new InvalidOperationException( $"Could not resolve the Content Type for the Doc Type Grid Editor property: {docTypeGridEditorContent.ContentTypeAlias}"); } // add content type as a dependency dependencies.Add(new ArtifactDependency(contentType.GetUdi(), false, ArtifactDependencyMode.Match)); // find all properties var propertyTypes = contentType.CompositionPropertyTypes; foreach (var propertyType in propertyTypes) { // test if there's a value for the given property object value; if (!docTypeGridEditorContent.Value.TryGetValue(propertyType.Alias, out value) || value == null) { continue; } Udi udi; // if the value is an Udi then add it as a dependency if (Udi.TryParse(value.ToString(), out udi)) { dependencies.Add(new ArtifactDependency(udi, false, ArtifactDependencyMode.Match)); continue; } // throws if not found - no need for a null check var propValueConnector = ValueConnectors.Get(propertyType); var mockProperty = new Property(propertyType, value); var parsedValue = propValueConnector.GetValue(mockProperty, dependencies); // test if the value is a json object (thus could be a nested complex editor) // if that's the case we'll need to add it as a json object instead of string to avoid it being escaped var jtokenValue = parsedValue != null && parsedValue.DetectIsJson() ? JToken.Parse(parsedValue) : null; if (jtokenValue != null) { docTypeGridEditorContent.Value[propertyType.Alias] = jtokenValue; } else { docTypeGridEditorContent.Value[propertyType.Alias] = parsedValue; } } var resolvedValue = JsonConvert.SerializeObject(docTypeGridEditorContent); return(resolvedValue); }
public void SetValue(IContentBase content, string alias, string value) { if (string.IsNullOrWhiteSpace(value)) { content.SetValue(alias, value); return; } if (value.DetectIsJson() == false) { return; } var property = content.Properties[alias]; if (property == null) { throw new NullReferenceException($"Property not found: '{alias}'."); } var prevalues = _dataTypeService.GetPreValuesCollectionByDataTypeId(property.PropertyType.DataTypeDefinitionId).FormatAsDictionary(); PreValue prevalue = null; //Fetch the Prevalues for the current Property's DataType (if its an 'Archetype config') if (!prevalues.TryGetValue("archetypeconfig", out prevalue) && !prevalues.TryGetValue("archetypeConfig", out prevalue)) { throw new InvalidOperationException("Could not find Archetype configuration."); } var archetypePreValue = prevalue == null ? null : JsonConvert.DeserializeObject <ArchetypePreValue>(prevalue.Value); RetrieveAdditionalProperties(ref archetypePreValue); var archetype = JsonConvert.DeserializeObject <ArchetypeModel>(value); if (archetype == null) { throw new InvalidOperationException("Could not parse Archetype value."); } RetrieveAdditionalProperties(ref archetype, archetypePreValue); var properties = archetype.Fieldsets.SelectMany(x => x.Properties); foreach (var archetypeProperty in properties) { if (archetypeProperty.Value == null || string.IsNullOrEmpty(archetypeProperty.DataTypeGuid)) { continue; } // get the data type of the property var dataType = _dataTypeService.GetDataTypeDefinitionById(Guid.Parse(archetypeProperty.DataTypeGuid)); if (dataType == null) { throw new ArgumentNullException( $"Unable to find the data type for editor '{archetypeProperty.PropertyEditorAlias}' ({archetypeProperty.DataTypeGuid}) referenced by '{property.Alias}'."); } // try to convert the value with the macro parser - this is mainly for legacy editors var archetypeValue = _macroParser.ReplaceAttributeValue(archetypeProperty.Value.ToString(), dataType.PropertyEditorAlias, null, Direction.FromArtifact); Udi udi; // test if the macroparser converted the value to an Udi if (Udi.TryParse(archetypeValue, out udi)) { archetypeProperty.Value = archetypeValue; continue; } // if the macro parser didn't convert the value then try to find a value connector that can and convert it var propertyType = new PropertyType(dataType.PropertyEditorAlias, dataType.DatabaseType, "mockPropertyTypeAlias"); propertyType.DataTypeDefinitionId = dataType.Id; var propValueConnector = ValueConnectors.Get(propertyType); var mockProperty = new Property(propertyType); var mockContent = new Content("mockContent", -1, new ContentType(-1), new PropertyCollection(new List <Property> { mockProperty })); propValueConnector.SetValue(mockContent, mockProperty.Alias, archetypeProperty.Value.ToString()); archetypeProperty.Value = mockContent.GetValue(mockProperty.Alias); } value = archetype.SerializeForPersistence(); content.SetValue(alias, value); }