I have a custom value mapper that works fine when sending translation jobs, but for some reason prevents umbraco from publishing (was able to confirm my code was the cause, since publishing started working when I comment it out). When testing I discovered that Translation Manager is calling GetSourceValue on publish, but no errors occur in my code and no errors are reported by translation manager, so I'm at a bit of a loss as to what is going wrong. I also set the logs of Jumoo.TranslationManager to "Debug," but that didn't reveal anything useful.

Any ideas on what the problem is? Below is my value mapper code for reference.

using Jumoo.TranslationManager.Core.Models;
using Jumoo.TranslationManager.Core.ValueMappers;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json;
using Seed.DataTypes.FlexibleLinks.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Umbraco.Core.Services;
using Umbraco.Core.Logging;
using Seed.Sections.Widgets.Services;
using Newtonsoft.Json.Linq;
using Umbraco.Core;
using Umbraco.Core.Models;
using Jumoo.TranslationManager.Core;
using Jumoo.TranslationManager.Core.Extensions;

namespace Seed.Components.TranslationExtensions {
    public class WidgetValueMapper : BaseValueMapper, IValueMapper {
        private readonly IDataTypeService _dataTypeService;
        private readonly IContentTypeService _contentTypeService;
        private readonly IWidgetVariantService _widgetVariantService;
        public WidgetValueMapper(IContentService contentService, IDataTypeService dataTypeService, IContentTypeService contentTypeService, ILogger logger, IWidgetVariantService widgetVariantService) : base(contentService, dataTypeService, contentTypeService, logger) {
            _dataTypeService = dataTypeService;
            _contentTypeService = contentTypeService;
            _widgetVariantService = widgetVariantService;
        }
        public string Name => "Widget";
        public override string[] Editors => new string[] { "Umbraco.Grid.widget", "Umbraco.Grid.widgetEditor" };

        public TranslationValue GetSourceValue(string displayName, string propertyTypeAlias, object value, CultureInfoView culture) {
            return GetSourceValue(displayName, propertyTypeAlias, string.Empty, value, culture);
        }
        public TranslationValue GetSourceValue(string displayName, string propertyTypeAlias, string path, object value, CultureInfoView culture) {
            try {
                if (value == null) {
                    return null;
                }

                Attempt<string> attempt = value.TryConvertTo<string>();
                if (!attempt.Success) {
                    return null;
                }

                string result = attempt.Result;
                if (result.IsNullOrWhiteSpace()) {
                    return null;
                }

                JObject jObject = JsonConvert.DeserializeObject<JObject>(result);
                if (jObject == null || jObject["properties"] == null || jObject["variantKey"] == null) {
                    return null;
                }
                var variant = _widgetVariantService.GetByKey(Guid.Parse(jObject["variantKey"].ToString()));
                if (variant == null) {
                    return null;
                }
                var contentType = _contentTypeService.Get(variant.DocumentTypeAlias);
                if (contentType == null) {
                    return null;
                }
                path.AppendPath(variant.WidgetName);
                var translationValue = new TranslationValue(displayName, propertyTypeAlias, path);
                var properties = (JObject)jObject["properties"];
                var count = 0;
                foreach (var prop in contentType.CompositionPropertyTypes) {
                    count++;
                    if (!properties.ContainsKey(prop.Alias) || variant.Properties[prop.Alias].AccessLevel != Sections.Widgets.Core.Enums.PropertyAccessLevel.Open) {
                        continue;
                    }
                    var propVal = properties[prop.Alias];
                    if (propVal != null) {
                        TranslationValue mapperSource = ValueMapperFactory.GetMapperSource($"{displayName} ({variant.WidgetName} - {variant.Name}) {prop.Name}", prop.PropertyEditorAlias, path.AppendPath(prop.Alias), propVal.ToString(), culture);
                        if (mapperSource != null) {
                            mapperSource.SortOrder = count;
                            translationValue.InnerValues.Add(count.ToString(), mapperSource);
                        }
                    }
                }
                return translationValue;
            }
            catch (Exception e) {
                logger.Error<WidgetValueMapper>("Error Retrieving Data", new object[1] { e });
                return null;
            }
        }


        public object GetTargetValue(string propertyTypeAlias, object sourceValue, TranslationValue value, CultureInfoView sourceCulture, CultureInfoView targetCulture) {
            if (sourceValue == null) {
                return sourceValue;
            }

            Attempt<string> attempt = sourceValue.TryConvertTo<string>();
            if (!attempt.Success) {
                return sourceValue;
            }

            string result = attempt.Result;
            if (result.IsNullOrWhiteSpace()) {
                return sourceValue;
            }

            JObject jObject = JsonConvert.DeserializeObject<JObject>(result);
            if (jObject == null || jObject["properties"] == null || jObject["variantKey"] == null) {
                return sourceValue;
            }
            var variant = _widgetVariantService.GetByKey(Guid.Parse(jObject["variantKey"].ToString()));
            if (variant == null) {
                return sourceValue;
            }
            var contentType = _contentTypeService.Get(variant.DocumentTypeAlias);
            if (contentType == null) {
                return sourceValue;
            }
            var properties = jObject["properties"];
            var count = 0;
            foreach (var prop in contentType.CompositionPropertyTypes) {
                count++;
                if (variant.Properties[prop.Alias].AccessLevel != Sections.Widgets.Core.Enums.PropertyAccessLevel.Open) {
                    continue;
                }
                var propValue = value.GetInnerValue(count);
                var dataType = _dataTypeService.GetDataType(prop.DataTypeId);
                if (dataType != null) {
                    string editorAlias = dataType.EditorAlias;
                    IValueMapper mapper = ValueMapperFactory.GetMapper(editorAlias);
                    var val = properties[prop.Alias]?.ToString();
                    if (mapper == null || string.IsNullOrWhiteSpace(val)) {
                        continue;
                    }
                    var text = (string)mapper.GetTargetValue(editorAlias, val, propValue, sourceCulture, targetCulture);
                    if (text == null) {
                        continue;
                    }
                    if (IsJson(text)) {
                        try {
                            jObject[prop.Alias] = text.GetJsonTokenValue().ExpandAllJsonInToken();
                        }
                        catch (Exception e) {
                            logger.Error<WidgetValueMapper>("Error Parsing JSON", new object[1] { e });
                            jObject[prop.Alias] = text;
                        }
                    }
                    else {
                        jObject[prop.Alias] = text;
                    }
                }
            }
            return JsonConvert.SerializeObject(jObject, Formatting.Indented);
        }
        private bool IsJson(string val) {
            val = val.Trim();
            if (!val.StartsWith("{") || !val.EndsWith("}")) {
                if (val.StartsWith("[")) {
                    return val.EndsWith("]");
                }

                return false;
            }

            return true;
        }
    }
}

The data being translated is very similar to what's in the DocTypeGridEditorMapper, just with a custom "AccessLevel" property on the properties. The service calls are retrieving some cached data about the control, as that information isn't stored in the content like it is in DocTypeGridEditorMapper.

Versions

• Umbraco: 8.18.6
• Translation Manager: 8.7.11