private static string GetUrl(PlainArticleField field)
{
if (field == null) return null;
var value = field.Value;
if (value == null) return null;
if
(field.FieldId.HasValue &&
!string.IsNullOrEmpty(field.Value)
&& (field.PlainFieldType == PlainFieldType.File
|| field.PlainFieldType == PlainFieldType.DynamicImage
|| field.PlainFieldType == PlainFieldType.Image)
)
{
string baseUri = ObjectFactoryBase.Resolve<IDBConnector>().GetUrlForFileAttribute(field.FieldId.Value);
return $"{baseUri}/{field.Value}";
}
else if (field.PlainFieldType == PlainFieldType.String || field.PlainFieldType == PlainFieldType.StringEnum)
{
return field.Value;
}
else
{
return null;
}
}
private static bool HasEqualNativeValues(
PlainArticleField plainArticleField, PlainArticleField otherPlainArticleField)
{
return(plainArticleField.NativeValue == null
? otherPlainArticleField.NativeValue == null
: plainArticleField.NativeValue.Equals(otherPlainArticleField.NativeValue));
}
private void ComparePlainArticleField(PlainArticleField dbField, PlainArticleField tntField, string path)
{
Assert.Multiple(() =>
{
CompareArticleField(dbField, tntField, path);
Assert.That(dbField.Value, Is.EqualTo(tntField.Value), $"{path}_Value");
Assert.That(dbField.NativeValue, Is.EqualTo(tntField.NativeValue), $"{path}_NativeValue");
Assert.That(dbField.PlainFieldType, Is.EqualTo(tntField.PlainFieldType), $"{path}_PlainFieldType");
});
}
public string GetFileUrl(PlainArticleField field)
{
if (field != null &&
field.FieldId.HasValue &&
!string.IsNullOrEmpty(field.Value) &&
(field.PlainFieldType == PlainFieldType.File ||
field.PlainFieldType == PlainFieldType.DynamicImage ||
field.PlainFieldType == PlainFieldType.Image))
{
string baseUri = ObjectFactoryBase.Resolve <IDBConnector>().GetUrlForFileAttribute(field.FieldId.Value);
return($"{baseUri}/{field.Value}");
}
else
{
return("javascript:void();");
}
}
private object GetPlainArticleFieldValue(PlainArticleField plainArticleField)
{
var fieldId = plainArticleField.FieldId ?? 0;
var shortFieldUrl = _dbConnector.GetUrlForFileAttribute(fieldId, true, true);
var longFieldUrl = _dbConnector.GetUrlForFileAttribute(fieldId, false, false);
var value = plainArticleField.Value;
if (plainArticleField.NativeValue == null || string.IsNullOrWhiteSpace(value))
{
return null;
}
switch (plainArticleField.PlainFieldType)
{
case PlainFieldType.File:
{
var valueUrl = $@"{shortFieldUrl}/{value}";
var size = Common.GetFileSize(_factory, _loaderProperties, _dbConnector, fieldId, value, $"{longFieldUrl}/{value}");
return new PlainFieldFileInfo
{
Name = Common.GetFileNameByUrl(_dbConnector, fieldId, valueUrl),
FileSizeBytes = size,
AbsoluteUrl = valueUrl
};
}
case PlainFieldType.Image:
case PlainFieldType.DynamicImage:
{
return $@"{shortFieldUrl}/{value}";
}
case PlainFieldType.Boolean:
return (decimal)plainArticleField.NativeValue == 1;
default:
return plainArticleField.NativeValue;
}
}
private object ConvertPlainField(PlainArticleField plainArticleField)
{
if (plainArticleField.NativeValue == null)
{
return(null);
}
switch (plainArticleField.PlainFieldType)
{
case PlainFieldType.Boolean:
return((decimal)plainArticleField.NativeValue == 1);
case PlainFieldType.O2MRelation:
return((int)plainArticleField.NativeValue);
case PlainFieldType.Classifier:
return(_contentService.Read((int)(decimal)plainArticleField.NativeValue).NetName);
default:
return(plainArticleField.NativeValue);
}
}
private object ConvertValue(PlainArticleField article, CallContext ctx)
{
var renderFileAsImage = GetBoolProperty(article, RenderFileFieldAsImage);
var value = article.Value;
if (article.PlainFieldType == PlainFieldType.VisualEdit || article.PlainFieldType == PlainFieldType.Textbox)
{
if (GetBoolProperty(article, RenderTextFieldAsXmlName))
{
XElement parsedElement;
try
{
parsedElement = XElement.Parse("<r>" + value + "</r>");
}
catch (Exception ex)
{
throw new Exception(string.Format("Ошибка при парсинге xml из поля {0}: {1}", article.FieldId, ex.Message), ex);
}
return(parsedElement.Nodes());
}
return(new XCData(value));
}
if (article.PlainFieldType == PlainFieldType.DateTime || article.PlainFieldType == PlainFieldType.Date)
{
if (!string.IsNullOrWhiteSpace(value))
{
if (DateTime.TryParse(value, out var dt))
{
return(dt.ToString("yyyy-MM-ddTHH:mm:ss"));
}
}
}
if (article.PlainFieldType == PlainFieldType.Numeric)
{
if (!string.IsNullOrWhiteSpace(value))
{
if (decimal.TryParse(value, out var dt))
{
return(dt.ToString(CultureInfo.InvariantCulture).Replace(",", "."));
//при десериализации всегда нужна точка
}
}
}
var fieldId = article.FieldId ?? 0;
if (!string.IsNullOrWhiteSpace(value) && (
article.PlainFieldType == PlainFieldType.Image ||
article.PlainFieldType == PlainFieldType.DynamicImage ||
article.PlainFieldType == PlainFieldType.File
))
{
var cnn = ctx.Cnn;
var fieldUrl = cnn.GetUrlForFileAttribute(fieldId, false, false);
var shortFieldUrl = cnn.GetUrlForFileAttribute(fieldId, true, true);
var valueUrl = $@"{shortFieldUrl}/{value}";
if (article.PlainFieldType == PlainFieldType.File && !renderFileAsImage)
{
var size = Common.GetFileSize(_factory, _loaderProperties, cnn, fieldId, value, $@"{fieldUrl}/{value}");
return(new[]
{
new XElement("Name", Common.GetFileNameByUrl(cnn, fieldId, valueUrl)),
new XElement("FileSizeBytes", size),
new XElement("AbsoluteUrl", valueUrl)
});
}
return(valueUrl);
}
return(value);
}
private ArticleField DeserializePlainField(Quantumart.QP8.BLL.Field plainFieldFromQP, IProductDataSource productDataSource, DBConnector connector)
{
var field = new PlainArticleField
{
PlainFieldType = (PlainFieldType)plainFieldFromQP.ExactType
};
switch (field.PlainFieldType)
{
case PlainFieldType.Date:
case PlainFieldType.DateTime:
DateTime?dt = productDataSource.GetDateTime(plainFieldFromQP.Name);
if (dt.HasValue)
{
field.Value = dt.ToString();
field.NativeValue = dt;
}
break;
case PlainFieldType.Numeric:
case PlainFieldType.O2MRelation:
{
object number;
if (plainFieldFromQP.IsInteger ||
plainFieldFromQP.RelationType == RelationType.OneToMany)
{
number = productDataSource.GetInt(plainFieldFromQP.Name);
}
else
{
var dec = productDataSource.GetDecimal(plainFieldFromQP.Name);
number = !plainFieldFromQP.IsDecimal && dec.HasValue ? (object)Convert.ToDouble(dec) : dec;
}
if (number != null)
{
field.Value = number.ToString();
field.NativeValue = number;
}
}
break;
case PlainFieldType.Image:
string imageUrl = productDataSource.GetString(plainFieldFromQP.Name);
if (imageUrl != null)
{
string imageName = Common.GetFileNameByUrl(connector, plainFieldFromQP.Id, imageUrl);
field.NativeValue = field.Value = imageName;
}
break;
case PlainFieldType.File:
if (productDataSource is EditorJsonProductDataSource)
{
string fileName = productDataSource.GetString(plainFieldFromQP.Name);
field.NativeValue = field.Value = fileName;
}
else
{
IProductDataSource fileContainer = productDataSource.GetContainer(plainFieldFromQP.Name);
if (fileContainer != null)
{
string fileUrl = fileContainer.GetString("AbsoluteUrl");
string fileName = Common.GetFileNameByUrl(connector, plainFieldFromQP.Id, fileUrl);
field.NativeValue = field.Value = fileName;
}
}
break;
case PlainFieldType.Boolean:
{
decimal?number = productDataSource.GetDecimal(plainFieldFromQP.Name);
if (number != null)
{
field.Value = number.ToString();
field.NativeValue = number;
}
}
break;
default:
field.NativeValue = field.Value = productDataSource.GetString(plainFieldFromQP.Name);
break;
}
field.Value = field.Value ?? string.Empty;
return(field);
}
private Article GetProduct(JToken productToken, JToken contentToken)
{
int contentId = contentToken.Value <int>("ContentId");
int statusTypeId = productToken.Value <int>("STATUS_TYPE_ID");
string statusName = _statusProvider.GetStatusName(statusTypeId);
bool isPublished = statusName == PublishedStatusd;
var product = new Article
{
Id = productToken.Value <int>("Id"),
Archived = productToken.Value <bool>("ARCHIVE"),
Visible = productToken.Value <bool>("VISIBLE"),
IsPublished = isPublished,
Status = statusName,
Created = productToken.Value <DateTime>("CREATED"),
Modified = productToken.Value <DateTime>("MODIFIED"),
ContentId = contentId,
ContentName = contentToken.Value <string>("ContentName"),
ContentDisplayName = contentToken.Value <string>("ContentDisplayName"),
};
foreach (var fieldToken in contentToken["PlainField"])
{
var plainField = new PlainArticleField
{
ContentId = product.ContentId,
PlainFieldType = GetFieldType(fieldToken)
};
var numberType = GetNumberType(fieldToken);
UpdateField(plainField, fieldToken);
SetValue(plainField, productToken, numberType);
product.Fields[plainField.FieldName] = plainField;
}
foreach (var fieldToken in contentToken["EntityField"])
{
var fieldType = GetFieldType(fieldToken);
if (fieldType == PlainFieldType.M2MRelation || fieldType == PlainFieldType.M2ORelation)
{
var multiField = new MultiArticleField {
ContentId = product.ContentId
};
UpdateField(multiField, fieldToken);
var articleTokens = productToken[multiField.FieldName];
if (articleTokens != null)
{
foreach (var articleToken in articleTokens)
{
var childContentToken = fieldToken["Content"];
var article = GetProduct(articleToken, childContentToken);
multiField.Items.Add(article.Id, article);
}
}
product.Fields[multiField.FieldName] = multiField;
}
else if (fieldType == PlainFieldType.O2MRelation)
{
var singleField = new SingleArticleField {
ContentId = product.ContentId
};
UpdateField(singleField, fieldToken);
var articleToken = productToken[singleField.FieldName];
if (articleToken != null)
{
var childContentToken = fieldToken["Content"];
var article = GetProduct(articleToken, childContentToken);
singleField.Item = article;
}
product.Fields[singleField.FieldName] = singleField;
}
else
{
throw new Exception($"EntityField has unsupportable type {fieldType}");
}
}
foreach (var fieldToken in contentToken["ExtensionField"])
{
var extensionField = new ExtensionArticleField {
ContentId = product.ContentId
};
UpdateField(extensionField, fieldToken);
var extensionId = productToken.Value <int>(extensionField.FieldName);
var childContentToken = fieldToken["Contents"].FirstOrDefault(c => c.Value <int>("ContentId") == extensionId);
if (childContentToken != null)
{
var article = GetProduct(productToken, childContentToken);
article.Id = 0;
extensionField.Value = childContentToken.Value <string>("ContentId");
extensionField.Item = article;
product.Fields[extensionField.FieldName] = extensionField;
}
}
foreach (var fieldToken in contentToken["BackwardRelationField"])
{
var backwardField = new BackwardArticleField
{
ContentId = product.ContentId,
};
UpdateField(backwardField, fieldToken);
var articleToken = productToken[backwardField.FieldName];
if (articleToken != null)
{
foreach (var t in articleToken)
{
var childContentToken = fieldToken["Content"];
var article = GetProduct(t, childContentToken);
backwardField.Items.Add(article.Id, article);
}
}
product.Fields[backwardField.FieldName] = backwardField;
}
return(product);
}
private object SetValue(PlainArticleField field, JToken productToken, NumberType numberType)
{
switch (field.PlainFieldType)
{
case PlainFieldType.Date:
case PlainFieldType.Time:
case PlainFieldType.DateTime:
var dt = productToken.Value <DateTime?>(field.FieldName);
if (dt.HasValue)
{
field.Value = dt.Value.ToString(CultureInfo.CurrentCulture);
field.NativeValue = dt;
}
break;
case PlainFieldType.Numeric:
{
object number = null;
switch (numberType)
{
case NumberType.Int32:
number = productToken.Value <int?>(field.FieldName);
break;
case NumberType.Int64:
number = productToken.Value <long?>(field.FieldName);
break;
case NumberType.Decimal:
number = productToken.Value <decimal?>(field.FieldName);
break;
case NumberType.Double:
number = productToken.Value <double?>(field.FieldName);
break;
default:
break;
}
;
if (number != null)
{
field.Value = number.ToString();
field.NativeValue = number;
}
}
break;
case PlainFieldType.Boolean:
{
var number = productToken.Value <bool?>(field.FieldName);
if (number != null)
{
var val = number.Value ? 1m : 0m;
field.NativeValue = val;
field.Value = val.ToString(CultureInfo.InvariantCulture);
}
}
break;
default:
field.Value = productToken.Value <string>(field.FieldName);
field.NativeValue = field.Value;
break;
}
field.Value = field.Value ?? string.Empty;
return(field);
}
private ArticleField CloneField(ArticleField field, string fieldName, Dictionary <Article, Article> articleMap)
{
var pField = field as PlainArticleField;
var sField = field as SingleArticleField;
var mField = field as MultiArticleField;
var eField = field as ExtensionArticleField;
var bField = field as BackwardArticleField;
var vField = field as VirtualArticleField;
var vmField = field as VirtualMultiArticleField;
ArticleField clonnedField;
if (pField != null)
{
clonnedField = new PlainArticleField
{
NativeValue = pField.NativeValue,
Value = pField.Value,
PlainFieldType = pField.PlainFieldType
};
}
else if (eField != null)
{
clonnedField = new ExtensionArticleField
{
Aggregated = eField.Aggregated,
SubContentId = eField.SubContentId,
Item = eField.Item == null ? null : articleMap[eField.Item],
Value = eField.Value
};
}
else if (sField != null)
{
clonnedField = new SingleArticleField
{
Aggregated = sField.Aggregated,
SubContentId = sField.SubContentId,
Item = sField.Item == null ? null : articleMap[sField.Item]
};
}
else if (bField != null)
{
clonnedField = new BackwardArticleField
{
SubContentId = bField.SubContentId,
Items = bField.Items.ToDictionary(itm => itm.Key, itm => articleMap[itm.Value]),
RelationGroupName = bField.RelationGroupName
};
}
else if (mField != null)
{
clonnedField = new MultiArticleField
{
SubContentId = mField.SubContentId,
Items = mField.Items.ToDictionary(itm => itm.Key, itm => articleMap[itm.Value])
};
}
else if (vField != null)
{
clonnedField = new VirtualArticleField
{
Fields = vField.Fields
};
}
else if (vmField != null)
{
clonnedField = new VirtualMultiArticleField
{
VirtualArticles = vmField.VirtualArticles
.Select(f => CloneField(f, fieldName, articleMap) as VirtualArticleField)
.ToArray()
};
}
else
{
throw new Exception($"Cant't process field {field.FieldName} for localization");
}
clonnedField.FieldName = fieldName;
clonnedField.ContentId = field.ContentId;
clonnedField.FieldId = field.FieldId;
clonnedField.CustomProperties = field.CustomProperties;
clonnedField.FieldDisplayName = field.FieldDisplayName;
return(clonnedField);
}
