private string GetCvlFieldValue(string cvlId, string value, bool addValue)
{
if (string.IsNullOrWhiteSpace(value))
{
return(null);
}
string key = value.RemoveSpecialCharacters();
if (string.IsNullOrWhiteSpace(key))
{
return(null);
}
CVL cvl = _cvlRepository.GetCVL(cvlId);
if (cvl == null)
{
return(null);
}
CVLValue cvlValue = _cvlRepository.GetCVLValueByKey(cvl.Id, key);
if (cvlValue != null)
{
return(cvlValue.Key);
}
if (!addValue)
{
return(null);
}
if (cvl.DataType == DataType.String)
{
cvlValue = new CVLValue {
CVLId = cvl.Id, Key = key, Value = value
};
}
else if (cvl.DataType == DataType.LocaleString)
{
var localeString = new LocaleString();
foreach (CultureInfo culture in _supportedCultures.Values)
{
localeString[culture] = value;
}
cvlValue = new CVLValue {
CVLId = cvl.Id, Key = key, Value = localeString
};
}
else
{
return(null);
}
_cvlRepository.AddCVLValue(cvlValue);
return(key);
}
public string GetCVLValue(string cvlId, object key)
{
if (key == null)
{
return(string.Empty);
}
CVLValue cv = CVLValues.FirstOrDefault(cvl => cvl.CVLId.Equals(cvlId) && cvl.Key.Equals(key));
if (cv == null)
{
return(string.Empty);
}
return(cv.Value.ToString());
}
public CVLValue AddCVLValue(CVLValue cvlValue)
{
if (!_cvlValues.TryGetValue(cvlValue.CVLId, out List <CVLValue> cvlValues))
{
return(null);
}
if (cvlValues.Any(cv => cv.Key == cvlValue.Key))
{
return(null);
}
cvlValues.Add(cvlValue);
return(cvlValue);
}
private IEnumerable <string> GetCvlValues(FieldType fieldType, string[] newValues)
{
if (fieldType == null)
{
throw new ArgumentNullException(nameof(fieldType));
}
if (newValues == null ||
newValues.Length == 0)
{
yield break;
}
string cvlId = fieldType.CVLId;
List <CVLValue> knownValues = Context.ExtensionManager.ModelService.GetCVLValuesForCVL(cvlId);
foreach (string newValue in newValues)
{
string cvlKey = newValue.RemoveSpecialCharacters();
// If the key is already known, return it.
if (knownValues.Any(v => v.Key == cvlKey))
{
yield return(cvlKey);
continue;
}
// If the key is not known and adding new values is disabled, skip this.
if (!AddUnknownCvlValues)
{
continue;
}
// Add the new CVLValue and return the key.
CVLValue cvlValue = new CVLValue {
CVLId = cvlId, Key = cvlKey, Value = newValue
};
cvlValue = Context.ExtensionManager.ModelService.AddCVLValue(cvlValue);
Context.Log(LogLevel.Information, $"A new CVL value was added (Key: {cvlKey}; Value: {newValue}). ");
yield return(cvlValue.Key);
}
}
public CVLValue AddCVLValue(CVLValue cvlValue)
{
if (!_cvlValues.TryGetValue(cvlValue.CVLId, out Dictionary <string, CVLValue> cvlValues))
{
// Initialize list of CVL values.
GetCVLValuesForCVL(cvlValue.CVLId);
return(cvlValue);
}
if (cvlValues.TryGetValue(cvlValue.Key, out CVLValue existingCvlValue))
{
return(existingCvlValue);
}
cvlValue = _inRiverManager.ModelService.AddCVLValue(cvlValue);
cvlValues.Add(cvlValue.Key, cvlValue);
return(cvlValue);
}
private void AddCvlValue(string cvlId, string newCVLValueKey, string newCVLValue)
{
CVL cvl = RemoteManager.ModelService.GetCVL(cvlId);
CVLValue cvlVal = new CVLValue()
{
CVLId = cvlId, Key = newCVLValueKey
};
if (cvl.DataType == DataType.String)
{
cvlVal.Value = newCVLValue;
}
else if (cvl.DataType == DataType.LocaleString)
{
LocaleString locale = new LocaleString(RemoteManager.UtilityService.GetAllLanguages());
CultureInfo cultureInfo = new CultureInfo("en");
locale[cultureInfo] = newCVLValue;
cvlVal.Value = locale;
}
RemoteManager.ModelService.AddCVLValue(cvlVal);
}
private static void AddCvlValue(string cvlId, string newCVLValueKey, string newCVLValue)
{
CVL cvl = remoteManager.ModelService.GetCVL(cvlId);
bool newValue = false;
CVLValue cvlVal = remoteManager.ModelService.GetCVLValueByKey(newCVLValueKey, cvlId);
if (cvlVal == null)
{
newValue = true;
cvlVal = new CVLValue()
{
CVLId = cvlId, Key = newCVLValueKey
};
}
if (cvl.DataType == DataType.String)
{
cvlVal.Value = newCVLValue;
}
else if (cvl.DataType == DataType.LocaleString)
{
LocaleString locale = new LocaleString(remoteManager.UtilityService.GetAllLanguages());
CultureInfo cultureInfo = new CultureInfo("en");
locale[cultureInfo] = newCVLValue;
locale[new CultureInfo("sv")] = newCVLValue + "_SV";
cvlVal.Value = locale;
}
if (newValue)
{
remoteManager.ModelService.AddCVLValue(cvlVal);
}
else
{
remoteManager.ModelService.UpdateCVLValue(cvlVal);
}
}
public CVLValue UpdateCVLValue(CVLValue cvlValue)
{
throw new NotImplementedException();
}
public CVLValue AddCVLValue(CVLValue cvlValue)
{
return(cvlValue);
}
public List <XElement> GetCVLValues(Field field, Configuration configuration)
{
List <XElement> elemets = new List <XElement>();
if (field == null || field.IsEmpty())
{
if (field != null)
{
CVL cvl = CvLs.FirstOrDefault(c => c.Id.Equals(field.FieldType.CVLId));
if (cvl == null)
{
return(elemets);
}
if (cvl.DataType == DataType.LocaleString)
{
Dictionary <string, XElement> valuesPerLanguage = new Dictionary <string, XElement>
{
{
configuration.ChannelDefaultLanguage.Name,
new XElement("Data", new XAttribute("language", configuration.ChannelDefaultLanguage.Name.ToLower()))
}
};
if (!configuration.ActiveCVLDataMode.Equals(CVLDataMode.Keys))
{
foreach (KeyValuePair <CultureInfo, CultureInfo> keyValuePair in configuration.LanguageMapping)
{
if (!valuesPerLanguage.ContainsKey(keyValuePair.Key.Name))
{
valuesPerLanguage.Add(
keyValuePair.Key.Name,
new XElement("Data", new XAttribute("language", keyValuePair.Key.Name.ToLower())));
}
}
if (valuesPerLanguage.Count > 0)
{
foreach (string key in valuesPerLanguage.Keys)
{
elemets.Add(valuesPerLanguage[key]);
}
}
}
}
else
{
XElement dataElement = new XElement(
"Data",
new XAttribute("language", configuration.ChannelDefaultLanguage.Name.ToLower()));
elemets.Add(dataElement);
}
}
return(elemets);
}
if (configuration.ActiveCVLDataMode.Equals(CVLDataMode.Keys) ||
(field.FieldType.Settings.ContainsKey("EPiMetaFieldName") && field.FieldType.Settings["EPiMetaFieldName"].Equals("_ExcludedCatalogEntryMarkets")))
{
XElement dataElement = new XElement(
"Data",
new XAttribute("language", configuration.ChannelDefaultLanguage.Name.ToLower()));
if (field.FieldType.Multivalue)
{
foreach (string cvlKey in field.Data.ToString().Split(';'))
{
dataElement.Add(new XElement("Item", new XAttribute("value", cvlKey)));
}
}
else
{
dataElement.Add(new XAttribute("value", field.Data));
}
elemets.Add(dataElement);
}
else
{
CVL cvl = CvLs.FirstOrDefault(c => c.Id.Equals(field.FieldType.CVLId));
if (cvl == null)
{
return(elemets);
}
string[] keys = field.FieldType.Multivalue
? field.Data.ToString().Split(';')
: new[] { field.Data.ToString() };
Dictionary <string, XElement> valuesPerLanguage = new Dictionary <string, XElement>
{
{
configuration.ChannelDefaultLanguage.Name,
new XElement("Data", new XAttribute("language", configuration.ChannelDefaultLanguage.Name.ToLower()))
}
};
foreach (string key in keys)
{
CVLValue cvlValue = CVLValues.FirstOrDefault(cv => cv.CVLId.Equals(cvl.Id) && cv.Key.Equals(key));
if (cvlValue == null || cvlValue.Value == null)
{
continue;
}
if (cvl.DataType.Equals(DataType.LocaleString))
{
LocaleString ls = (LocaleString)cvlValue.Value;
foreach (KeyValuePair <CultureInfo, CultureInfo> keyValuePair in configuration.LanguageMapping)
{
if (!valuesPerLanguage.ContainsKey(keyValuePair.Key.Name))
{
valuesPerLanguage.Add(
keyValuePair.Key.Name,
new XElement("Data", new XAttribute("language", keyValuePair.Key.Name.ToLower())));
}
string value = ls[keyValuePair.Value];
if (configuration.ActiveCVLDataMode.Equals(CVLDataMode.KeysAndValues))
{
value = key + Configuration.CVLKeyDelimiter + value;
}
// MultiValue uses <Item> elements, SingleValue stores the value in the <Data> element.
if (field.FieldType.Multivalue)
{
valuesPerLanguage[keyValuePair.Key.Name].Add(
new XElement("Item", new XAttribute("value", value)));
}
else
{
valuesPerLanguage[keyValuePair.Key.Name].Add(new XAttribute("value", value));
}
}
}
else
{
string value = cvlValue.Value.ToString();
if (configuration.ActiveCVLDataMode.Equals(CVLDataMode.KeysAndValues))
{
value = key + Configuration.CVLKeyDelimiter + value;
}
// MultiValue uses <Item> elements, SingleValue stores the value in the <Data> element.
if (field.FieldType.Multivalue)
{
valuesPerLanguage[configuration.ChannelDefaultLanguage.Name].Add(
new XElement("Item", new XAttribute("value", value)));
}
else
{
valuesPerLanguage[configuration.ChannelDefaultLanguage.Name].Add(new XAttribute("value", value));
}
}
}
if (valuesPerLanguage.Count > 0)
{
foreach (string key in valuesPerLanguage.Keys)
{
elemets.Add(valuesPerLanguage[key]);
}
}
}
return(elemets);
}
/// <summary>
/// Returns the parsed cvl value.
/// Checks if the values exist in the CVL. If not they get added if the setting CREATE_MISSING_CVL_KEYS is true.
/// returns valid CVL values or null.
/// </summary>
/// <param name="field"></param>
/// <param name="values"></param>
/// <param name="result"></param>
/// <param name="singleVal">returns the first valid CVL value</param>
/// <returns></returns>
private string GeParsedCvlValueForField(Field field, List <string> values, WorkerResult result, out string singleVal)
{
singleVal = string.Empty;
if (values == null || values.Count == 0)
{
return(null);
}
List <string> validatedCvlKeys = new List <string>(values.Count);
List <CVLValue> cvlValues = _inRiverContext.ExtensionManager.ModelService.GetCVLValuesForCVL(field.FieldType.CVLId, true);
foreach (string cvlKey in values)
{
if (string.IsNullOrWhiteSpace(cvlKey))
{
continue;
}
if (cvlValues.Any(c => c.Key.Equals(cvlKey)))
{
validatedCvlKeys.Add(cvlKey);
continue;
}
string cleanCvlKey = cvlKey.ToStringWithoutControlCharactersForCvlKey();
if (cvlValues.Any(c => c.Key.Equals(cleanCvlKey)))
{
validatedCvlKeys.Add(cleanCvlKey);
continue;
}
// create new CVL value when the setting CREATE_MISSING_CVL_KEYS is true
if (GetConfiguredCreateMissingCvlKeys())
{
CVLValue newCvlValue = new CVLValue()
{
CVLId = field.FieldType.CVLId,
Key = cleanCvlKey,
Value = cvlKey
};
try
{
newCvlValue = _inRiverContext.ExtensionManager.ModelService.AddCVLValue(newCvlValue);
cvlValues.Add(newCvlValue);
validatedCvlKeys.Add(newCvlValue.Key);
}
catch (Exception e)
{
result.Messages.Add($"Could not add CVLKey '{cleanCvlKey}' ({cvlKey}).");
_inRiverContext.Log(LogLevel.Error, $"Could not add CVLKey '{cleanCvlKey}' ({cvlKey}).", e);
}
}
else
{
result.Messages.Add($"Missing CVLKey '{cleanCvlKey}' ({cvlKey}) has not been added.");
}
}
if (validatedCvlKeys.Any())
{
if (field.FieldType.Multivalue)
{
// cvlkeys are always separated by semicolon in inRiver
return(string.Join(";", validatedCvlKeys));
}
else
{
singleVal = validatedCvlKeys.FirstOrDefault();
return(singleVal);
}
}
return(null);
}
