public void UpdateCreateValue(QualifiedValue value)
{
var group = GetOrCreateGroupNode(value.Qualifier.Part);
group.SetOrCreateValue(value.Qualifier, value.Value.Content);
Save();
}
public FlattenedQualifiedValue(QualifiedValue value)
{
Part = value.Qualifier.Part.ToString();
Locale = value.Qualifier.Locale.ToString();
Key = value.Qualifier.Key;
Value = value.Value.DecodedContent;
}
private static KeyValuePair <Qualifier.Unique, QualifiedValue> CreateValuePair(Part part, string key, string value)
{
var qualifier = new Qualifier.Unique(part, Locale, key);
var qualifiedValue = new QualifiedValue(qualifier, new Value(ContentType.Text, value));
return(new KeyValuePair <Qualifier.Unique, QualifiedValue>(qualifier, qualifiedValue));
}
public IEnumerable <QualifiedValue> UpdateCreateValue(QualifiedValue value)
{
var request = new UpdateCreateValueRequest {
QualifiedValue = value
};
var response = MakeRequest(request);
return(response.AllValues);
}
private static String JsonQv(QualifiedValue qv, IEnumerable <KeyValuePair <string, string> > replacements)
{
return(String.Format("'{2}':{{part:'{0}', locale:'{1}', key: '{2}', value: '{3}', origvalue: '{4}', replacements: [{5}] }}",
qv.Qualifier.Part.ToString().Replace("'", @"\'").Replace(@"\", @"\\"),
qv.Qualifier.Locale.ToString().Replace("'", @"\'").Replace(@"\", @"\\"),
qv.Qualifier.Key.Replace("'", @"\'").Replace(@"\", @"\\"),
qv.Value.DecodedContent.Replace("'", @"\'").Replace(@"\", @"\\"),
qv.Value.Content.Replace("'", @"\'").Replace(@"\", @"\\"),
JsonRepl(replacements)
));
}
public void SetValue(Qualifier.Unique qualifier, string value)
{
if (AllValues.ContainsKey(qualifier))
{
AllValues[qualifier] = new QualifiedValue(qualifier, new Value(ContentType.Text, value));
}
else
{
AllValues.Add(qualifier, new QualifiedValue(qualifier, new Value(ContentType.Text, value)));
}
}
public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier, String defaultValue = null)
{
try
{
return(new QualifiedValue(qualifier, Values[qualifier]));
}
catch
{
var qualifiedValue = new QualifiedValue(qualifier, defaultValue);
Values[qualifier] = qualifiedValue.Value;
return(qualifiedValue);
}
}
public JsonResult Create(String part, String locale, String key, String contentType, String content)
{
var localization = Session["manualProviderPair"] as ProviderPair;
if (localization == null)
{
throw new Exception("Localization not loaded!");
}
var qualifier = new Qualifier.Unique(Part.Parse(part), new Locale(locale), key);
var value = new Value(ContentType.Spoof(contentType), content);
var qualifiedValue = new QualifiedValue(qualifier, value);
localization.ValueManager.UpdateCreateValue(qualifiedValue);
return(Json(new { ok = true }));
}
private QualifiedValue GetQualifiedValue(int qualifierId)
{
var resultCandidate = Volatile.Read(ref m_qualifiedValues[qualifierId]);
if (resultCandidate != null)
{
return(resultCandidate);
}
var newCandidate = new QualifiedValue();
// Changing the array if the value is still null.
var oldValue = Interlocked.CompareExchange(ref m_qualifiedValues[qualifierId], newCandidate, null);
// CompareExchange returns null if we won, so need to null-coalesce with a new value in this case.
return(oldValue ?? newCandidate);
}
public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier, string defaultValue = null)
{
var testQualifier = qualifier;
while (testQualifier.Part.Parent != null)
{
testQualifier = new Qualifier.Unique(testQualifier.Part.Parent, testQualifier.Locale, testQualifier.Key);
QualifiedValue value;
if (AllValues.TryGetValue(testQualifier, out value))
{
return(value);
}
}
var qualifiedValue = new QualifiedValue(qualifier, defaultValue);
AllValues.Add(qualifier, qualifiedValue);
return(qualifiedValue);
}
public DoubleQualifiedValue(QualifiedValue left, QualifiedValue right)
{
Left = left;
Right = right;
}
public string ToHtmlString()
{
if (!(IsDisplayed || DebugMode))
{
return(String.Empty);
}
var builder = new TagBuilder(TagName);
var innerHtml = String.Empty;
QualifiedValue innerHtmlValue = null;
if (!String.IsNullOrEmpty(LocalizedHtmlKey.Key))
{
innerHtmlValue = Repository.GetQualified(LocalizedHtmlKey.Key, LocalizedHtmlKey.Default);
var decodedValue = Processors.Aggregate(
innerHtmlValue.Value.DecodeWithReplacements(Replacements),
(value, processor) => processor(value)
);
builder.InnerHtml = decodedValue;
}
foreach (var attribute in LocalizedAttributes)
{
var value = Repository.GetQualified(attribute.Value.Key, attribute.Value.Default);
builder.MergeAttribute(attribute.Key, Processors.Aggregate(
value.Value.DecodeWithReplacements(Replacements),
(val, processor) => processor(val)
));
if (!DebugMode)
{
continue;
}
var key = "data-loc-attribute-" + attribute.Key + "-";
builder.MergeAttribute(key + "part", value.Qualifier.Part.ToString());
builder.MergeAttribute(key + "content", value.Value.Content);
}
if (DebugMode)
{
builder.MergeAttribute("data-loc-debug", "true");
if (innerHtmlValue != null)
{
builder.MergeAttribute("data-loc-inner-part", innerHtmlValue.Qualifier.Part.ToString());
builder.MergeAttribute("data-loc-inner-key", innerHtmlValue.Qualifier.Key);
builder.MergeAttribute("data-loc-inner-value", innerHtmlValue.Value.Content);
}
if (LocalizedAttributes.Any())
{
var localizations = String.Join(((char)31).ToString(CultureInfo.InvariantCulture), LocalizedAttributes.Select(localization => localization.Key + (char)30 + localization.Value));
builder.MergeAttribute("data-loc-localizations", localizations);
}
if (Replacements.Any())
{
var replacements = String.Join(((char)31).ToString(CultureInfo.InvariantCulture), Replacements.Select(replacement => replacement.Key + (char)30 + replacement.Value));
builder.MergeAttribute("data-loc-replacements", replacements);
}
}
if (!String.IsNullOrEmpty(OtherHtml))
{
innerHtml += OtherHtml;
}
if (!String.IsNullOrEmpty(innerHtml))
{
builder.InnerHtml = innerHtml;
}
foreach (var attribute in OtherAttributes)
{
builder.MergeAttribute(attribute.Key, attribute.Value);
}
return(builder.ToString());
}
public void UpdateCreateValue(QualifiedValue value)
{
Reload(_connector.UpdateCreateValue(value));
}
public void UpdateCreateValue(QualifiedValue value)
{
SetValue(value.Qualifier, value.Value.Content);
}
private void Delete(bool execute, ProviderPair targetPair, Dictionary <Qualifier.Unique, LocalizationAudit> sourceAudits, Dictionary <Qualifier.Unique, LocalizationAudit> targetAudits, QualifiedValue targetQualifiedValue, SynchronizationResult result)
{
if (execute)
{
if (sourceAudits.ContainsKey(targetQualifiedValue.Qualifier))
{
targetAudits[targetQualifiedValue.Qualifier] = sourceAudits[targetQualifiedValue.Qualifier];
}
targetPair.ValueManager.DeleteValue(targetQualifiedValue.Qualifier);
}
result.Removed.Add(new Removal(targetPair.Name, targetQualifiedValue.Qualifier.ToString(), targetQualifiedValue.Value));
}
private void Create(bool execute, ProviderPair targetPair, Dictionary <Qualifier.Unique, LocalizationAudit> sourceAudits, Dictionary <Qualifier.Unique, LocalizationAudit> targetAudits, QualifiedValue sourceQualifiedValue, SynchronizationResult result)
{
if (execute)
{
if (sourceAudits.ContainsKey(sourceQualifiedValue.Qualifier))
{
targetAudits[sourceQualifiedValue.Qualifier] = sourceAudits[sourceQualifiedValue.Qualifier];
}
targetPair.ValueManager.CreateValue(sourceQualifiedValue.Qualifier, sourceQualifiedValue.Value);
}
result.Created.Add(new Creation(targetPair.Name, sourceQualifiedValue.Qualifier.ToString(), sourceQualifiedValue.Value));
}
