private void Form1_Load(object sender, EventArgs e)
{
GF5 = new FiniteField(5);
GF56Primitive = new Polynomial(GF5, 2, 0, 1, 4, 1, 0, 1);
ExtF = new ExtensionField(GF56Primitive);
lblInfo.Text = "Current Field Info: " + ExtF.ToString();
}
private static JObject ProcessEntityField(ExtensionField x, List <Content> visited, Context context)
{
JObject f = ProcessFieldBase(x);
f["Contents"] = new JArray(x.GetContents().Select(c => VisitDefinition(c, visited, context)));
return(f);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
var target = new ExtensionField[10];
//将JSON值填充到目标对象中。
serializer.Populate(jsonObject.CreateReader(), target);
return(target);
}
public static ExtensionFieldData ToViewData(this ExtensionField node, CategoryDictionary suffix = CategoryDictionary.None)
{
if (node == null)
{
return(null);
}
var model = new ExtensionFieldData()
{
Id = node.Id,
Database = node.Database,
Schema = node.Schema,
Table = node.Table,
Column = node.Column,
JoinId = node.JoinId,
StartTime = node.StartTime,
FinishTime = node.FinishTime,
Value = node.Value,
ValueType = node.ValueType,
ChineseName = node.ChineseName,
EnglishName = node.EnglishName,
Enable = node.Enable,
Description = node.Description
};
var tableName = node.Table;
CategoryDictionary dict = (CategoryDictionary)Enum.Parse(typeof(CategoryDictionary), tableName);
if ((suffix & dict) == dict)
{
try
{
var type = Type.GetType("WxPay2017.API.BLL." + tableName + "BLL");
var bll = Activator.CreateInstance(type);
model.RelatedObject = type.GetMethod("Find", new Type[] { typeof(object[]) }).Invoke(bll, new object[1] {
new object[] { node.JoinId }
});
var type2 = Type.GetType("WxPay2017.API.BLL." + tableName + "Extension");
System.Reflection.Assembly assm = System.Reflection.Assembly.Load("DAL");
Type typeModel = assm.GetType("" + tableName);
model.RelatedObject = type2.GetMethod("ToViewData", new Type[] { typeModel, typeof(CategoryDictionary) }).Invoke(model.RelatedObject, new object[2] {
model.RelatedObject, CategoryDictionary.None
});
}catch {
model.RelatedObject = null;
}
}
return(model);
}
public string AddField(ExtensionField field)
{
try
{
string sql = string.Format(@"alter table dbo.[{0}] add {1} {2} {3} ", field.TableName, field.ColumnName,
getDBType(field.Type, field.Length), getDefault(field.Type, field.Defaultval));
string dessql =
string.Format(
@"EXECUTE sp_addextendedproperty N'MS_Description', '{0}', N'user', N'dbo', N'TABLE', N'{1}', N'column', N'{2}'",
field.Des, field.TableName, field.ColumnName);
SqlHelper.ExecuteNonQuery(ConnectionString, CommandType.Text, sql);
SqlHelper.ExecuteNonQuery(ConnectionString, CommandType.Text, dessql);
}
catch (Exception ex)
{
return(ex.Message);
}
return(string.Empty);
}
private ArticleField DeserializeExtensionField(ExtensionField fieldInDef, Quantumart.QP8.BLL.Field qpField, IProductDataSource productDataSource, DBConnector connector, Context context)
{
var extensionArticleField = new ExtensionArticleField();
string fieldName = string.IsNullOrEmpty(fieldInDef.FieldName) ? qpField.Name : fieldInDef.FieldName;
string contentName = productDataSource.GetString(fieldName);
if (!string.IsNullOrEmpty(contentName))
{
Models.Configuration.Content valueDef = fieldInDef.ContentMapping.Values.FirstOrDefault(x => _contentService.Read(x.ContentId).NetName == contentName);
if (valueDef == null)
{
throw new Exception(
$"'{contentName}' value is not found in an available extension content list, id = {fieldInDef.FieldId}");
}
extensionArticleField.Value = valueDef.ContentId.ToString();
extensionArticleField.SubContentId = valueDef.ContentId;
IProductDataSource extensionDataSource = productDataSource.GetExtensionContainer(fieldName, contentName);
extensionArticleField.Item = DeserializeArticle(extensionDataSource, valueDef, connector, context);
if (extensionArticleField.Item.Id == productDataSource.GetArticleId())
{
var id = GetExtensionId(connector, valueDef.ContentId, fieldInDef.FieldId, extensionArticleField.Item.Id);
if (id.HasValue)
{
extensionArticleField.Item.Id = id.Value;
}
else
{
context.AddExtensionArticle(extensionArticleField.Item.Id, extensionArticleField.Item);
extensionArticleField.Item.Id = default(int);
}
}
}
return(extensionArticleField);
}
private void CreateInstance(ExtensionField field)
{
if (field.targetType == null)
{
UnityEngine.Debug.Log($"[Area::{this.name}]: Unable to load extesion type of \"{field.targetType}\".");
return;
}
ExtensionBase extensionInstance = ExtensionSingletons
.Where(t => t.GetType().IsAssignableFrom(field.targetType))
.FirstOrDefault();
if (extensionInstance == null)
{
extensionInstance = (ExtensionBase)System.Activator.CreateInstance(field.targetType);
ExtensionSingletons.Add(extensionInstance);
}
System.Threading.CancellationToken token = WorkerTokenSource.Token;
workers[field.targetType] = extensionInstance.GetWorker(token, this);
}
protected void Page_Load(object sender, EventArgs e)
{
this.Args = this.PageEngine.GetWindowArgs <Dictionary <string, string> >();
//if (!string.IsNullOrWhiteSpace(Args["id"]))
//{
//}
//else
//{
//}
this.Model = new ExtensionField();
if (!string.IsNullOrWhiteSpace(Args["type"]))
{
this.Model.TableName = Args["type"];
}
if (!IsPostBack)
{
this.FillForm(this.Model);
}
}
/// <exception cref="NotSupportedException" />
/// <exception cref="InvalidOperationException" />
private FieldSchema GetExtensionFieldSchema(
ExtensionField extensionField, Quantumart.QP8.BLL.Field qpField, SchemaContext context, string path)
{
var contentSchemas = new Dictionary <string, IContentSchema>();
foreach (Content content in extensionField.ContentMapping.Values)
{
var qpContent = _contentService.Read(content.ContentId);
if (!String.IsNullOrEmpty(qpContent.NetName) &&
!contentSchemas.ContainsKey(qpContent.NetName))
{
var contentSchema = GetContentSchema(content, context, $"{path}/{qpContent.NetName}");
contentSchema.ForExtension = true;
contentSchemas[qpContent.NetName] = contentSchema;
}
}
return(new ExtensionFieldSchema
{
Changeable = qpField.Changeable,
ExtensionContents = contentSchemas
});
}
public static string AddExtensionField(ExtensionField field)
{
return(UserInfoRepo.AddField(field));
}
public string AddField(ExtensionField field)
{
return(string.Empty);
}
/// <exception cref="NotSupportedException" />
/// <exception cref="InvalidOperationException" />
private void MergeExtensionFieldSchema(
ExtensionField field, Quantumart.QP8.BLL.Field qpField, JSchema contentSchema, SchemaContext context)
{
JSchema extensionSchema = AttachFieldData(qpField, new JSchema { Type = JSchemaType.String });
foreach (Content content in field.ContentMapping.Values)
{
var qpContent = _contentService.Read(content.ContentId);
if (!String.IsNullOrWhiteSpace(qpContent.NetName))
{
extensionSchema.Enum.Add(qpContent.NetName);
}
}
contentSchema.Properties.Add(field.FieldName, extensionSchema);
var fieldGroups = field.ContentMapping.Values
.SelectMany(extContent =>
{
var fields = extContent.Fields
.Select(extField => new
{
extField.FieldName,
FieldSchema = GetFieldSchema(
extField, _fieldService.Read(extField.FieldId), context, false)
});
if (extContent.LoadAllPlainFields)
{
var qpFields = _fieldService.List(extContent.ContentId).ToArray();
var fieldsToAdd = qpFields
.Where(f => f.RelationType == Quantumart.QP8.BLL.RelationType.None
&& extContent.Fields.All(y => y.FieldId != f.Id))
.Where(f => !context.IgnoredFields
.Any(t => t.Item1.Equals(extContent) && t.Item2.FieldId == f.Id));
fields = fields.Concat(fieldsToAdd.Select(extQpField => new
{
FieldName = extQpField.Name,
FieldSchema = GetPlainFieldSchema(extQpField)
}));
}
return fields;
})
.GroupBy(x => x.FieldName);
foreach (var fieldGroup in fieldGroups)
{
JSchema[] groupSchemas = fieldGroup.Select(pair => pair.FieldSchema).ToArray();
JSchema sameNameExtensionFieldsSchema;
if (groupSchemas.Length > 1)
{
sameNameExtensionFieldsSchema = new JSchema { Type = JSchemaType.Object };
foreach (JSchema extFieldSchema in groupSchemas)
{
sameNameExtensionFieldsSchema.OneOf.Add(extFieldSchema);
}
}
else
{
sameNameExtensionFieldsSchema = groupSchemas[0];
}
contentSchema.Properties[fieldGroup.Key] = sameNameExtensionFieldsSchema;
}
}
/// <summary>
///
/// </summary>
/// <param name="rootContent"></param>
/// <param name="notFoundInDef"></param>
/// <param name="entityIds">int c id поля для невиртуальных полей и string с именем поля для виртуальных</param>
/// <returns></returns>
private object GetObjectFromDef(Content rootContent, out bool notFoundInDef, IEnumerable <object> entityIds)
{
object[] entityIdsToSearch = entityIds
.Skip(1) //корень ровно один поэтому первый компонент пути нам не нужен
.ToArray();
object currentPositionObj = rootContent;
notFoundInDef = false;
foreach (object entityId in entityIdsToSearch)
{
if (currentPositionObj is Content)
{
var currContent = (Content)currentPositionObj;
if (entityId is int)
{
currentPositionObj = currContent.Fields.SingleOrDefault(x => x.FieldId == (int)entityId);
}
else
{
currentPositionObj = currContent.Fields.SingleOrDefault(x => x.FieldName == (string)entityId && x is BaseVirtualField);
}
if (currentPositionObj == null)
{
//дурацкая система что Dictionaries это поле с id=0
if (entityId is int && (int)entityId == 0)
{
notFoundInDef = true;
return(new Dictionaries());
}
if (entityId is int)
{
int enitityIdInt = (int)entityId;
var qpField = _fieldService.Read(enitityIdInt);
if (qpField == null)
{
notFoundInDef = true;
return(null);
}
if (qpField.RelationType == RelationType.None && !qpField.IsClassifier)
{
currentPositionObj = new PlainField {
FieldId = enitityIdInt, FieldName = qpField.Name
};
notFoundInDef = !currContent.LoadAllPlainFields;
}
else
{
using (_fieldService.CreateQpConnectionScope())
{
if (qpField.ContentId == currContent.ContentId)
{
if (!qpField.IsClassifier)
{
currentPositionObj = new EntityField
{
FieldId = enitityIdInt,
FieldName = qpField.Name,
CloningMode = CloningMode.UseExisting,
Content =
new Content {
ContentId = qpField.RelateToContentId.Value, ContentName = qpField.RelatedToContent.Name
}
}
}
}
;
else
{
currentPositionObj = new ExtensionField
{
FieldId = qpField.Id,
FieldName = qpField.Name,
CloningMode = CloningMode.UseExisting
};
var classifierContents = _fieldService.ListRelated(qpField.ContentId)
.Where(x => x.Aggregated)
.Select(x => x.Content);
foreach (var classifierContent in classifierContents)
{
((ExtensionField)currentPositionObj).ContentMapping.Add(
classifierContent.Id,
new Content {
ContentId = classifierContent.Id, ContentName = classifierContent.Name
});
}
}
else
{
currentPositionObj = new BackwardRelationField
{
FieldId = qpField.Id,
FieldName = qpField.Name,
Content = new Content {
ContentId = qpField.ContentId, ContentName = qpField.Content.Name
},
CloningMode = CloningMode.UseExisting
};
}
}
notFoundInDef = !qpField.IsClassifier || !currContent.LoadAllPlainFields;
}
}
public void Test_ConfigurationSerializer_001()
{
Content entity = new Content
{
ContentId = 288,
ContentName = "Продукты",
LoadAllPlainFields = true,
};
var mp = new Content();
mp.CachePeriod = TimeSpan.FromMinutes(30);
mp.Fields.Add(new EntityField {
FieldName = "Categories"
});
mp.Fields.Add(new EntityField {
FieldName = "Family"
});
mp.Fields.Add(new EntityField {
FieldName = "Tabs"
});
mp.Fields.Add(new EntityField {
FieldName = "MarketingSign"
});
mp.Fields.Add(new EntityField {
FieldName = "Modifiers"
});
entity.Fields.Add(new EntityField
{
FieldName = "MarketingProduct",
FieldId = 1115,
CloningMode = CloningMode.UseExisting,
DeletingMode = DeletingMode.Keep,
Content = mp
});
var n = new EntityField
{
FieldName = "Regions",
FieldId = 1228,
CloningMode = CloningMode.UseExisting,
DeletingMode = DeletingMode.Keep,
Content = new Content()
};
entity.Fields.Add(n);
var t = new ExtensionField
{
FieldName = "Type"
};
t.ContentMapping.Add(305, new Content {
LoadAllPlainFields = true
});
t.ContentMapping.Add(312, new Content {
LoadAllPlainFields = true
});
entity.Fields.Add(t);
entity.Fields.Add(new EntityField
{
FieldName = "Parameters",
FieldId = 1193,
CloningMode = CloningMode.Copy,
DeletingMode = DeletingMode.Delete,
Content = new Content()
});
// Attach behavior
XmlMappingBehavior.SetBehavior(n, new XmlMappingBehavior
{
ExportField = "Title",
ExportMode = ExportMode.ExportFieldOnly
});
var text = Tools.ConfigurationSerializer.GetXml(entity);
Console.WriteLine(text);
}
public static string AddExtensionField(ExtensionField field)
{
return(OrganizationInfoRepo.AddField(field));
}
