/// <summary>
/// Get fields
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="propertyNames">Property names</param>
/// <returns>Return properties relation entity fields</returns>
internal static IEnumerable <EntityField> GetFields(DatabaseServerType serverType, Type entityType, IEnumerable <string> propertyNames)
{
if (propertyNames.IsNullOrEmpty())
{
return(Array.Empty <EntityField>());
}
var allFields = EntityManager.GetEntityConfiguration(entityType)?.AllFields;
if (allFields.IsNullOrEmpty())
{
return(Array.Empty <EntityField>());
}
DatabaseServerEntityFields.TryGetValue(serverType.GetDatabaseServerEntityFormatKey(entityType), out var entityServerFields);
List <EntityField> resultFields = new List <EntityField>();
foreach (var propertyName in propertyNames)
{
if (string.IsNullOrWhiteSpace(propertyName))
{
continue;
}
EntityField propertyField = null;
entityServerFields?.TryGetValue(propertyName, out propertyField);
if (propertyField == null)
{
allFields.TryGetValue(propertyName, out propertyField);
}
if (propertyField != null)
{
resultFields.Add(propertyField);
}
}
return(resultFields);
}
/// <summary>
/// Get query fields
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="query">Query object</param>
/// <returns>Return entity fields</returns>
public static List <EntityField> GetQueryFields(DatabaseServerType serverType, Type entityType, IQuery query)
{
string key = serverType.GetDatabaseServerEntityFormatKey(entityType);
if (string.IsNullOrWhiteSpace(key))
{
return(new List <EntityField>(0));
}
DatabaseServerEntityQueryFields.TryGetValue(key, out var fields);
if (fields.IsNullOrEmpty())
{
ConfigureEntity(key, entityType);
DatabaseServerEntityQueryFields.TryGetValue(key, out fields);
}
if (fields.IsNullOrEmpty())
{
throw new Exception("empty fields");
}
if (query.QueryFields.IsNullOrEmpty() && query.NotQueryFields.IsNullOrEmpty())
{
return(fields);
}
var queryFields = query.GetActuallyQueryFields(entityType, true, true);
return(fields.Intersect(queryFields).ToList());
}
/// <summary>
/// Get fields
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="propertyNames">Property names</param>
/// <returns>Return properties relation entity fields</returns>
public static List <EntityField> GetFields(DatabaseServerType serverType, Type entityType, IEnumerable <string> propertyNames)
{
if (propertyNames.IsNullOrEmpty())
{
return(new List <EntityField>(0));
}
var propertyFields = propertyNames.Select <string, EntityField>(p => p).ToList();
var key = serverType.GetDatabaseServerEntityFormatKey(entityType);
if (string.IsNullOrWhiteSpace(key))
{
return(propertyFields);
}
DatabaseServerEntityFields.TryGetValue(key, out var allFields);
if (allFields.IsNullOrEmpty())
{
ConfigureEntity(key, entityType);
DatabaseServerEntityFields.TryGetValue(key, out allFields);
if (allFields.IsNullOrEmpty())
{
return(propertyFields);
}
}
for (var p = 0; p < propertyFields.Count; p++)
{
var propertyField = propertyFields[p];
if (allFields.TryGetValue(propertyField.PropertyName, out var nowField) && nowField != null)
{
propertyFields[p] = nowField;
}
}
return(propertyFields);
}
/// <summary>
/// Configure entity object name
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="objectName">Object name</param>
internal static void ConfigureEntityObjectName(DatabaseServerType serverType, Type entityType, string objectName)
{
if (entityType == null || string.IsNullOrWhiteSpace(objectName))
{
return;
}
DatabaseServerEntityObjectNames[serverType.GetDatabaseServerEntityFormatKey(entityType)] = objectName;
}
/// <summary>
/// Configure entity fields
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="fields">Fields</param>
/// <param name="cover">Whether conver current fields</param>
public static void ConfigureEntityFields(DatabaseServerType serverType, Type entityType, IEnumerable <EntityField> fields, bool cover = true)
{
if (entityType == null)
{
return;
}
var key = serverType.GetDatabaseServerEntityFormatKey(entityType);
ConfigureEntityFields(key, entityType, fields, cover);
}
/// <summary>
/// Configure entity object name
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="objectName">Object name</param>
/// <param name="cover">Whether cover current object name</param>
public static void ConfigureEntityObjectName(DatabaseServerType serverType, Type entityType, string objectName, bool cover = true)
{
if (entityType == null)
{
return;
}
var key = serverType.GetDatabaseServerEntityFormatKey(entityType);
ConfigureEntityObjectName(key, objectName, cover);
}
/// <summary>
/// Get edit fields
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <returns>Return entity edit fields</returns>
public static List <EntityField> GetEditFields(DatabaseServerType serverType, Type entityType)
{
string key = serverType.GetDatabaseServerEntityFormatKey(entityType);
if (string.IsNullOrWhiteSpace(key))
{
return(new List <EntityField>(0));
}
DatabaseServerEntityEditFields.TryGetValue(key, out var fields);
if (fields.IsNullOrEmpty())
{
ConfigureEntity(key, entityType);
DatabaseServerEntityEditFields.TryGetValue(key, out fields);
}
return(fields ?? new List <EntityField>(0));
}
/// <summary>
/// Get entity object name
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="defaultName">Default name</param>
/// <returns>Return Entity object name</returns>
public static string GetEntityObjectName(DatabaseServerType serverType, Type entityType, string defaultName = "")
{
string key = serverType.GetDatabaseServerEntityFormatKey(entityType);
if (string.IsNullOrWhiteSpace(key))
{
return(defaultName);
}
DatabaseServerEntityObjectNames.TryGetValue(key, out var cacheObjectName);
if (string.IsNullOrWhiteSpace(cacheObjectName))
{
ConfigureEntity(key, entityType);
DatabaseServerEntityObjectNames.TryGetValue(key, out cacheObjectName);
cacheObjectName = string.IsNullOrWhiteSpace(cacheObjectName) ? defaultName : cacheObjectName;
}
return(cacheObjectName ?? string.Empty);
}
/// <summary>
/// Configure server type entity
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="entityConfiguration">Entity configuration</param>
static void ConfigureDatabaseServerEntity(DatabaseServerType serverType, Type entityType, DataEntityConfiguration entityConfiguration, bool cover = true)
{
if (entityConfiguration == null)
{
return;
}
string key = serverType.GetDatabaseServerEntityFormatKey(entityType);
if (string.IsNullOrWhiteSpace(key))
{
return;
}
//Configure object name
ConfigureEntityObjectName(key, entityConfiguration.TableName, cover);
//Configure fields
ConfigureEntityFields(key, entityType, entityConfiguration.Fields, cover);
}
/// <summary>
/// Configure entity fields
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="fields">Fields</param>
internal static void ConfigureEntityFields(DatabaseServerType serverType, Type entityType, IEnumerable <EntityField> fields)
{
if (entityType == null || fields.IsNullOrEmpty())
{
return;
}
var key = serverType.GetDatabaseServerEntityFormatKey(entityType);
DatabaseServerEntityFields.TryGetValue(key, out var nowFields);
nowFields ??= new Dictionary <string, EntityField>();
foreach (var field in fields)
{
if (field == null)
{
continue;
}
nowFields[field.PropertyName] = field;
}
DatabaseServerEntityFields[key] = nowFields;
InitDatabaseEntityConfiguration(serverType, entityType.GUID);
}
/// <summary>
/// Get default field
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <returns>Return default field</returns>
public static EntityField GetDefaultField(DatabaseServerType serverType, Type entityType)
{
string key = serverType.GetDatabaseServerEntityFormatKey(entityType);
if (string.IsNullOrWhiteSpace(key))
{
return(string.Empty);
}
DatabaseServerEntityQueryFields.TryGetValue(key, out var fields);
if (fields.IsNullOrEmpty())
{
ConfigureEntity(key, entityType);
DatabaseServerEntityQueryFields.TryGetValue(key, out fields);
}
EntityField field = null;
if (fields?.Count > 0)
{
field = fields[0];
}
field = field ?? string.Empty;
return(field);
}
/// <summary>
/// Get field
/// </summary>
/// <param name="serverType">Database server type</param>
/// <param name="entityType">Entity type</param>
/// <param name="propertyName">Property name</param>
/// <returns>Return property relation entity field</returns>
public static EntityField GetField(DatabaseServerType serverType, Type entityType, string propertyName)
{
if (string.IsNullOrWhiteSpace(propertyName))
{
return(string.Empty);
}
string key = serverType.GetDatabaseServerEntityFormatKey(entityType);
if (string.IsNullOrWhiteSpace(key))
{
return(string.Empty);
}
DatabaseServerEntityFields.TryGetValue(key, out var allFields);
if (allFields.IsNullOrEmpty())
{
//configure entity
ConfigureEntity(key, entityType);
DatabaseServerEntityFields.TryGetValue(key, out allFields);
}
EntityField field = null;
allFields?.TryGetValue(propertyName, out field);
return(field ?? propertyName);
}
