public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier, String defaultValue = null)
{
try {
try {
lock (_groups)
return(_groups[qualifier.Part.ToString()].GetQualified(qualifier));
}
catch (KeyNotFoundException e) {
throw new ValueNotFoundException(qualifier, e);
}
}
catch (ValueNotFoundException) {
if (defaultValue != null)
{
CreateValue(qualifier, defaultValue);
return(GetQualifiedValue(qualifier));
}
if (_insertDummyValues)
{
CreateValue(qualifier, "[-" + qualifier.Key + "-]");
return(GetQualifiedValue(qualifier));
}
throw;
}
}
public void CreateValue(Qualifier.Unique qualifier, string value)
{
var group = GetOrCreateGroupNode(qualifier.Part);
group.SetOrCreateValue(qualifier, value);
Save();
}
public void DeleteValue(Qualifier.Unique qualifier)
{
if (AllValues.ContainsKey(qualifier))
{
AllValues.Remove(qualifier);
}
}
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 string GetValue(Qualifier.Unique qualifier, String defaultValue = null)
{
if (defaultValue == null)
{
throw new ValueNotFoundException(qualifier);
}
return(defaultValue);
}
public IEnumerable <QualifiedValue> DeleteValue(Qualifier.Unique qualifier)
{
var request = new DeleteValueRequest {
Qualifier = qualifier
};
var response = MakeRequest(request);
return(response.AllValues);
}
public IEnumerable <QualifiedValue> CreateValue(Qualifier.Unique qualifier, String value)
{
var request = new CreateValueRequest {
Qualifier = qualifier, Value = value
};
var response = MakeRequest(request);
return(response.AllValues);
}
public void RemoveValue(Qualifier.Unique qualifier, Action <GroupNode> killNode)
{
Content[qualifier.Key].Remove(qualifier.Locale.ToString());
if (Content[qualifier.Key].Count == 0)
{
Content.Remove(qualifier.Key);
}
SuicideIfEmpty(killNode);
}
public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier, String defaultValue = null)
{
if (defaultValue == null)
{
throw new ValueNotFoundException(qualifier);
}
return(new QualifiedValue(qualifier, defaultValue));
}
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)
{
try
{
return(new QualifiedValue(qualifier, Values[qualifier]));
}
catch
{
throw new ValueNotFoundException(qualifier);
}
}
public string GetValue(Qualifier.Unique qualifier)
{
try
{
return(Values[qualifier].DecodedContent);
}
catch
{
throw new ValueNotFoundException(qualifier);
}
}
public JsonResult ChangeValue(String part, String locale, String key, String value)
{
if (!_context.DebugMode)
{
throw new Exception("Unauthorized!");
}
var qualifier = new Qualifier.Unique(Part.Parse(part), new Locale(locale), key);
_context.Repository.Values.SetValue(qualifier, value);
return(Json(new { Success = true, Value = _context.Repository.Values.GetValue(qualifier) }));
}
public String GetValue(Qualifier.Unique qualifier, String defaultValue = null)
{
try
{
return(Values[qualifier]);
}
catch
{
Values[qualifier] = defaultValue;
return(defaultValue);
}
}
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 IEnumerable <QualifiedValue> GetAllValuesQualified()
{
foreach (var localization in _localizedValues)
{
foreach (var keyBasedLocalization in localization.Value.GetAllKeyBasedLocales())
{
foreach (var languageBasedLocalization in keyBasedLocalization.Value.GetAllLocaleBasedValues())
{
var qualifier = new Qualifier.Unique(localization.Key, new Locale(languageBasedLocalization.Key), keyBasedLocalization.Key);
yield return(new QualifiedValue(qualifier, languageBasedLocalization.Value));
}
}
}
}
public JsonResult TransUpdate(String part, String locale, String key, String value)
{
var localization = Session["translationProviderPair"] as ProviderPair;
if (localization == null)
{
throw new Exception("Localization not loaded!");
}
var qualifier = new Qualifier.Unique(Part.Parse(part), new Locale(locale), key);
localization.ValueManager.UpdateCreateValue(new QualifiedValue(qualifier, new Value(ContentType.Unspecified, value)));
return(Json(new { ok = true }));
}
public JsonResult SyncRemove(String side, String part, String locale, String key)
{
var localization = Session["synchronization" + side + "ProviderPair"] as ProviderPair;
if (localization == null)
{
throw new Exception("Localization not loaded!");
}
var qualifier = new Qualifier.Unique(Part.Parse(part), new Locale(locale), key);
localization.ValueManager.DeleteValue(qualifier);
return(Json(new { ok = true }));
}
public void SetValue(Qualifier.Unique qualifier, String value)
{
try
{
Content[qualifier.Key][qualifier.Locale.ToString()] = value;
}
catch (KeyNotFoundException)
{
if (Parent == null)
{
throw new ValueNotFoundException(qualifier);
}
Parent.SetValue(qualifier, value);
}
}
public String GetValue(Qualifier.Unique qualifier)
{
try
{
return(Content[qualifier.Key][qualifier.Locale.ToString()]);
}
catch (KeyNotFoundException)
{
if (Parent == null)
{
throw new ValueNotFoundException(qualifier);
}
return(Parent.GetValue(qualifier));
}
}
public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier)
{
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);
}
}
throw new ValueNotFoundException(qualifier);
}
public JsonResult SyncDuplicate(String side, String part, String locale, String key)
{
var localizationFrom = Session["synchronization" + side + "ProviderPair"] as ProviderPair;
var localizationTo = Session["synchronization" + (side == "Right" ? "Left" : "Right") + "ProviderPair"] as ProviderPair;
if (localizationFrom == null || localizationTo == null)
{
throw new Exception("Localization not loaded!");
}
var qualifier = new Qualifier.Unique(Part.Parse(part), new Locale(locale), key);
localizationTo.ValueManager.UpdateCreateValue(localizationFrom.ValueManager.GetQualifiedValue(qualifier));
return(Json(new { ok = true }));
}
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 }));
}
public void SetOrCreateValue(Qualifier.Unique qualifier, String value)
{
if (!Content.ContainsKey(qualifier.Key))
{
Content.Add(qualifier.Key, new Dictionary <String, String>());
}
var keyContent = Content[qualifier.Key];
if (!keyContent.ContainsKey(qualifier.Locale.ToString()))
{
keyContent.Add(qualifier.Locale.ToString(), value);
}
else
{
keyContent[qualifier.Locale.ToString()] = value;
}
}
public QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier, String defaultValue = null)
{
var part = qualifier.Part;
do
{
if (_localizedValues.ContainsKey(part))
{
var content = _localizedValues[part].GetLocaleValueContainerFor(qualifier.Key).GetValueFor(qualifier.Locale.Name);
return(new QualifiedValue(new Qualifier.Unique(part, qualifier.Locale, qualifier.Key), content));
}
part = part.Parent;
} while (part != null);
throw new KeyNotFoundException();
}
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 QualifiedValue GetQualifiedValue(Qualifier.Unique qualifier)
{
try {
try {
lock (_groups)
return(_groups[qualifier.Part.ToString()].GetQualified(qualifier));
}
catch (KeyNotFoundException e) {
throw new ValueNotFoundException(qualifier, e);
}
}
catch (ValueNotFoundException) {
if (!_insertDummyValues)
{
throw;
}
CreateValue(qualifier, "[" + qualifier.Key + "]");
return(GetQualifiedValue(qualifier));
}
}
public ActionResult Import(String providerConfigName, String locale, HttpPostedFileBase postedFile)
{
var providerPair = FetchProviderPair(providerConfigName);
var allValues = providerPair.ValueManager.GetAllValuesQualified().ToArray();
var selectedLocale = new Locale(locale);
var valuesByPartKey = allValues
.Where(value => value.Qualifier.Locale.Equals(selectedLocale))
.ToDictionary(v => new Qualifier.Unique(v.Qualifier.Part, selectedLocale, v.Qualifier.Key));
var extention = postedFile.FileName.Split('.').Last();
var records = new List <ImportExportRecord>();
switch (extention)
{
case "csv":
using (var reader = new CsvReader(new StreamReader(postedFile.InputStream))) {
reader.Configuration.Delimiter = ";";
records.AddRange(reader.GetRecords <ImportExportRecord>());
}
break;
case "xml":
// ReSharper disable PossibleNullReferenceException
var document = XDocument.Load(postedFile.InputStream);
records.AddRange(document.Root.Descendants("Localization").Select(
xel => new ImportExportRecord(xel.Element("Part").Value, xel.Element("Key").Value, xel.Element("Value").Value)
{
DeleteOnImport = xel.Element("DeleteOnImport").Value.Trim().ToLowerInvariant() != "false"
}
));
// ReSharper restore PossibleNullReferenceException
break;
}
var inserts = new List <QualifiedValue>();
var updates = new List <Tuple <QualifiedValue, ImportExportRecord> >();
var deletes = new List <QualifiedValue>();
foreach (var record in records)
{
QualifiedValue correspondingValue;
var recordQualfier = new Qualifier.Unique(Part.Parse(record.Part), selectedLocale, record.Key);
if (valuesByPartKey.TryGetValue(recordQualfier, out correspondingValue))
{
if (record.DeleteOnImport)
{
deletes.Add(correspondingValue);
}
else if (!record.Value.Equals(correspondingValue.Value.Content))
{
updates.Add(Tuple.Create(correspondingValue, record));
}
}
else if (!record.DeleteOnImport)
{
inserts.Add(new QualifiedValue(recordQualfier, new Value(ContentType.Unspecified, record.Value)));
}
}
return(View(new ImportReportData(providerConfigName, postedFile.FileName, selectedLocale, inserts, updates, deletes)));
}
public QualifiedLocalization(Qualifier.Unique qualifier, String value, DateTime lastAccess)
{
Qualifier = qualifier;
Value = value;
LastAcces = lastAccess;
}
public void DeleteValue(Qualifier.Unique qualifier)
{
_groups[qualifier.Part.ToString()].RemoveValue(qualifier, node => { lock (_groups) { _groups.Remove(node.ToString()); } });
}
