private static void LoadFields(ref XMLEntity entity, XmlNode fields_node)
{
if (fields_node == null)
{
return;
}
foreach (XmlNode field_node in fields_node.ChildNodes)
{
FieldPrefab field_prefab = new FieldPrefab();
field_prefab.name = field_node.Attributes["name"].Value;
field_prefab.type = Enum.Parse <VarType>(field_node.Attributes["type"].Value);
field_prefab.save = bool.Parse(field_node.Attributes["save"].Value);
field_prefab.sync = bool.Parse(field_node.Attributes["sync"].Value);
field_prefab.desc = field_node.Attributes["desc"].Value;
entity.SelfFields.Add(field_prefab);
}
}
private async Task CallbackField(Nuid id, string field_name, FieldEvent field_event, NList args)
{
string entity_type = Global.NULL_STRING;
Entity entity = EntityManager.Get(id);
if (entity != null)
{
entity_type = entity.Type;
}
else
{
entity_type = await GetCacheType(id);
}
EntityPrefab entity_prefab = Prefabs.GetEntity(entity_type);
if (entity_prefab == null)
{
return;
}
if (entity_prefab.ancestors != null && entity_prefab.ancestors.Count > 0)
{
for (int i = entity_prefab.ancestors.Count - 1; i >= 0; i--)
{
string parent_type = entity_prefab.ancestors[i];
await NModule.CallbackField(this, id, parent_type, field_name, field_event, args);
}
}
await NModule.CallbackField(this, id, entity_type, field_name, field_event, args);
FieldPrefab field_prefab = entity_prefab.fields[field_name];
if (field_prefab != null && field_prefab.sync)
{
NList msg = NList.New().Add(id).Add(field_name).Add((int)field_event).Append(args);
await SyncField(id, msg);
}
}
private async Task PushPersistFields(Entity entity)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type);
if (entity_prefab == null)
{
return;
}
var database = _IMongoClient.GetDatabase(PersistUtils.ENTITY_DB);
var collection = database.GetCollection <BsonDocument>(entity.Type);
Dictionary <string, object> models = new Dictionary <string, object>();
models.Add(Global.MARK_ORIGIN, entity.Id.Origin);
models.Add(Global.MARK_UNIQUE, entity.Id.Unique);
Field[] fields = entity.GetFields();
foreach (Field field in fields)
{
FieldPrefab field_prefab = entity_prefab.fields[field.Name];
if (field_prefab == null)
{
continue;
}
if (!field_prefab.save)
{
continue;
}
switch (field_prefab.type)
{
case VarType.Bool:
{
models.Add(field_prefab.name, field.Get <bool>());
}
break;
case VarType.Int:
{
models.Add(field_prefab.name, field.Get <int>());
}
break;
case VarType.Float:
{
models.Add(field_prefab.name, field.Get <float>());
}
break;
case VarType.Long:
{
models.Add(field_prefab.name, field.Get <long>());
}
break;
case VarType.Nuid:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <Nuid>()));
models.Add(field_prefab.name, document);
}
break;
case VarType.Time:
{
models.Add(field_prefab.name, field.Get <DateTime>());
}
break;
case VarType.String:
{
models.Add(field_prefab.name, field.Get <string>());
}
break;
case VarType.List:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <NList>()));
models.Add(field_prefab.name, document);
}
break;
}
}
FilterDefinitionBuilder <BsonDocument> builder = Builders <BsonDocument> .Filter;
FilterDefinition <BsonDocument> filter = builder.And(builder.Eq("unique", entity.Id.Unique), builder.Eq("origin", entity.Id.Origin));
var found = await collection.FindOneAndUpdateAsync(filter, new BsonDocument(models));
if (found == null)
{
await collection.InsertOneAsync(new BsonDocument(models));
}
}
private async Task SavePersistEntities()
{
IReadOnlyList <Entity> entities = null;
if (NodeType == Abstractions.NodeType.Grain)
{
entities = EntityManager.GetEntities();
}
else if (NodeType == Abstractions.NodeType.Cache)
{
entities = await GetCacheEntities();
}
if (entities == null || entities.Count == 0)
{
return;
}
EntityList entity_list = new EntityList();
entity_list.entities = new List <EntityChild>();
entity_list.origin = Identity;
entity_list.node = NodeType;
var database = _IMongoClient.GetDatabase(PersistUtils.ENTITY_DB);
foreach (Entity entity in entities)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type);
if (entity_prefab == null)
{
continue;
}
Dictionary <string, object> entity_models = new Dictionary <string, object>();
entity_models.Add(Global.MARK_UNIQUE, entity.Id.Unique);
Field[] fields = entity.GetFields();
foreach (Field field in fields)
{
FieldPrefab field_prefab = entity_prefab.fields[field.Name];
if (field_prefab == null)
{
continue;
}
if (!field_prefab.save)
{
continue;
}
switch (field_prefab.type)
{
case VarType.Bool:
{
entity_models.Add(field_prefab.name, field.Get <bool>());
}
break;
case VarType.Int:
{
entity_models.Add(field_prefab.name, field.Get <int>());
}
break;
case VarType.Float:
{
entity_models.Add(field_prefab.name, field.Get <float>());
}
break;
case VarType.Long:
{
entity_models.Add(field_prefab.name, field.Get <long>());
}
break;
case VarType.Nuid:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <Nuid>()));
entity_models.Add(field_prefab.name, document);
}
break;
case VarType.String:
{
entity_models.Add(field_prefab.name, field.Get <string>());
}
break;
case VarType.List:
{
BsonDocument document = BsonDocument.Parse(JsonUtils.ToJson(field.Get <NList>()));
entity_models.Add(field_prefab.name, document);
}
break;
default:
break;
}
}
Table[] tables = entity.GetTables();
foreach (Table base_table in tables)
{
BsonArray table_model = new BsonArray();
TablePrefab table_prefab = entity_prefab.tables[base_table.GetName()];
switch (table_prefab.primary_key.type)
{
case VarType.Bool:
{
UpdateTableKeyValue <bool>();
}
break;
case VarType.Int:
{
UpdateTableKeyValue <int>();
}
break;
case VarType.Long:
{
UpdateTableKeyValue <long>();
}
break;
case VarType.Float:
{
UpdateTableKeyValue <float>();
}
break;
case VarType.String:
{
UpdateTableKeyValue <string>();
}
break;
case VarType.Nuid:
{
UpdateTableKeyValue <Nuid>();
}
break;
default:
break;
}
void UpdateTableKeyValue <TPrimaryKey>()
{
Table <TPrimaryKey> table = base_table as Table <TPrimaryKey>;
foreach (TPrimaryKey key in table.GetPrimaryKeys())
{
Dictionary <string, object> key_value_models = new Dictionary <string, object>();
key_value_models.Add(nameof(TablePrefab.primary_key), key);
NList key_value = table.GetKeyValue(key);
for (int col = 0; col < table_prefab.cols; col++)
{
TablePrefab.ColumnPrefab col_prefab = table_prefab.columns[col];
switch (col_prefab.type)
{
case VarType.Bool:
{
bool col_value = key_value.Get <bool>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Int:
{
int col_value = key_value.Get <int>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Long:
{
long col_value = key_value.Get <long>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Float:
{
float col_value = key_value.Get <float>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.String:
{
string col_value = key_value.Get <string>(col);
key_value_models.Add(col_prefab.name, col_value);
}
break;
case VarType.Nuid:
{
Nuid col_value = key_value.Get <Nuid>(col);
key_value_models.Add(col_prefab.name, BsonDocument.Parse(JsonUtils.ToJson(col_value)));
}
break;
case VarType.List:
{
NList col_value = key_value.Get <NList>(col);
key_value_models.Add(col_prefab.name, BsonDocument.Parse(JsonUtils.ToJson(col_value)));
}
break;
default:
break;
}
}
table_model.Add(new BsonDocument(key_value_models));
}
}
entity_models.Add(base_table.GetName(), table_model);
}
entity_list.entities.Add(new EntityChild()
{
unique = entity.Id.Unique, type = entity.Type, entity = new BsonDocument(entity_models)
});
}
var collection = database.GetCollection <EntityList>(PersistUtils.ENTITIES);
var filter = Builders <EntityList> .Filter.And(Builders <EntityList> .Filter.Eq(n => n.origin, Identity));
EntityList found = await collection.FindOneAndReplaceAsync(filter, entity_list);
if (found == null)
{
await collection.InsertOneAsync(entity_list);
}
}
private async Task SetCacheEntities(IReadOnlyList <Entity> entities)
{
IRedisDatabase db = GetCache();
ITransaction trans = db.Database.CreateTransaction();
{
string key = CacheUtils.BuildEntities(Nuid.New(Identity, Identity));
HashEntry[] hashFields = new HashEntry[entities.Count];
for (int i = 0; i < entities.Count; i++)
{
hashFields[i] = new HashEntry(entities[i].Id.Unique, entities[i].Type);
}
Task _ = trans.HashSetAsync(key, hashFields);
}
{
foreach (Entity entity in entities)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(entity.Type);
if (entity_prefab == null)
{
continue;
}
string fields_key = CacheUtils.BuildFields(entity.Id);
Field[] fields = entity.GetFields();
List <HashEntry> cache_fields = new List <HashEntry>();
for (int i = 0; i < fields.Length; i++)
{
FieldPrefab field_prefab = entity_prefab.fields[fields[i].Name];
if (field_prefab == null)
{
continue;
}
string field_value = "";
switch (field_prefab.type)
{
case VarType.Bool:
field_value = JsonUtils.ToJson(fields[i].Get <bool>());
break;
case VarType.Int:
field_value = JsonUtils.ToJson(fields[i].Get <int>());
break;
case VarType.Long:
field_value = JsonUtils.ToJson(fields[i].Get <long>());
break;
case VarType.Float:
field_value = JsonUtils.ToJson(fields[i].Get <float>());
break;
case VarType.String:
field_value = JsonUtils.ToJson(fields[i].Get <string>());
break;
case VarType.Nuid:
field_value = JsonUtils.ToJson(fields[i].Get <Nuid>());
break;
case VarType.List:
field_value = JsonUtils.ToJson(fields[i].Get <NList>());
break;
default:
break;
}
cache_fields.Add(new HashEntry(fields[i].Name, field_value));
}
Task _ = trans.HashSetAsync(fields_key, cache_fields.ToArray());
Table[] tables = entity.GetTables();
foreach (Table table in tables)
{
string table_key = CacheUtils.BuildTable(entity.Id, table.GetName());
TablePrefab table_prefab = entity_prefab.tables[table.GetName()];
if (table_prefab == null)
{
continue;
}
List <HashEntry> cache_key_values = new List <HashEntry>();
void SetCacheKeyValue <TPrimaryKey>()
{
Table <TPrimaryKey> t = table as Table <TPrimaryKey>;
IReadOnlyList <TPrimaryKey> keys = t.GetPrimaryKeys();
foreach (TPrimaryKey key in keys)
{
string json = JsonUtils.ToJson(t.GetKeyValue(key));
cache_key_values.Add(new HashEntry(key.ToString(), json));
}
}
switch (table_prefab.primary_key.type)
{
case VarType.Bool:
SetCacheKeyValue <bool>();
break;
case VarType.Int:
SetCacheKeyValue <int>();
break;
case VarType.Long:
SetCacheKeyValue <long>();
break;
case VarType.Float:
SetCacheKeyValue <float>();
break;
case VarType.String:
SetCacheKeyValue <string>();
break;
case VarType.Nuid:
SetCacheKeyValue <Nuid>();
break;
default:
break;
}
Task __ = trans.HashSetAsync(table_key, cache_key_values.ToArray());
}
}
bool redis_execute = await trans.ExecuteAsync();
if (!redis_execute)
{
throw new Exception("trans ExecuteAsync ERROR!!");
}
}
}
async Task <Entity> BuildCacheEntity(EntityTransaction trans)
{
EntityPrefab entity_prefab = Prefabs.GetEntity(trans.Type);
if (entity_prefab == null)
{
throw new Exception($"Prefabs.GetEntity cant found {trans.Type}");
}
HashEntry[] fields = await trans.Fields;
foreach (HashEntry entry in fields)
{
FieldPrefab field_prefab = entity_prefab.fields[entry.Name];
if (field_prefab == null)
{
continue;
}
switch (field_prefab.type)
{
case VarType.Bool:
{
SetFieldValue <bool>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.Int:
{
SetFieldValue <int>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.Float:
{
SetFieldValue <float>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.Long:
{
SetFieldValue <long>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.String:
{
SetFieldValue <string>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.Nuid:
{
SetFieldValue <Nuid>(entry.Name, entry.Value, ref trans.Entity);
}
break;
case VarType.List:
{
SetFieldValue <NList>(entry.Name, entry.Value, ref trans.Entity);
}
break;
default:
break;
}
void SetFieldValue <T>(string field_name, RedisValue field_value, ref Entity entity)
{
T value = JsonUtils.ToObject <T>(field_value);
Field field = entity.GetField(field_name);
if (field == null)
{
return;
}
NList res = NList.Empty;
field.TrySet(value, out res);
}
}
foreach (KeyValuePair <string, Task <HashEntry[]> > table_task in trans.Tables)
{
TablePrefab table_prefab = entity_prefab.tables[table_task.Key];
if (table_prefab == null)
{
continue;
}
Table table_trans = trans.Entity.GetTable(table_task.Key);
if (table_trans == null)
{
continue;
}
HashEntry[] table_key_values = await table_task.Value;
switch (table_prefab.primary_key.type)
{
case VarType.Bool:
{
Table <bool> table = table_trans as Table <bool>;
foreach (HashEntry entry in table_key_values)
{
bool key = bool.Parse(entry.Name);
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
case VarType.Int:
{
Table <int> table = table_trans as Table <int>;
foreach (HashEntry entry in table_key_values)
{
int key = int.Parse(entry.Name);
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
case VarType.Long:
{
Table <long> table = table_trans as Table <long>;
foreach (HashEntry entry in table_key_values)
{
long key = long.Parse(entry.Name);
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
case VarType.String:
{
Table <string> table = table_trans as Table <string>;
foreach (HashEntry entry in table_key_values)
{
string key = entry.Name;
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
case VarType.Nuid:
{
Table <Nuid> table = table_trans as Table <Nuid>;
foreach (HashEntry entry in table_key_values)
{
Nuid key = Nuid.Parse(entry.Name);
NList key_value = JsonUtils.ToObject <NList>(entry.Value);
table.TrySetKeyValue(key, key_value, out _);
}
}
break;
default:
break;
}
}
return(trans.Entity);
}
