/// <summary>
/// Sync table from entity framework
/// </summary>
/// <param name="tableModel"></param>
/// <param name="tableId"></param>
/// <returns></returns>
public async Task SyncEntityFromEntityFramework(SynchronizeTableViewModel tableModel, Guid tableId)
{
var fieldTypeList = await _context.TableFieldTypes.ToListAsync();
var fieldConfigList = await _context.TableFieldConfigs.ToListAsync();
foreach (var item in tableModel.Fields)
{
if (item.Configurations != null)
{
foreach (var configViewModel in item.Configurations)
{
configViewModel.Name = fieldConfigList.FirstOrDefault(x => x.Code == configViewModel.ConfigCode)?.Name;
}
}
// Save field model in the dataBase
var configValues = new List <TableFieldConfigValue>();
var fieldType = fieldTypeList.FirstOrDefault(x => x.Code == item.TableFieldCode);
if (fieldType == null)
{
continue;
}
var model = new TableModelField
{
DataType = item.DataType,
DisplayName = item.DisplayName,
TableId = tableId,
Description = item.Description,
Name = item.Name,
AllowNull = item.AllowNull,
Synchronized = true,
TableFieldTypeId = fieldType.Id,
};
if (item.Configurations != null)
{
foreach (var configItem in item.Configurations)
{
var config = fieldConfigList.FirstOrDefault(x => x.Code == configItem.ConfigCode);
if (config == null)
{
continue;
}
configValues.Add(new TableFieldConfigValue
{
TableFieldConfigId = config.Id,
TableModelFieldId = model.Id,
Value = configItem.Value,
});
}
}
model.TableFieldConfigValues = configValues;
_context.TableFields.Add(model);
await _context.SaveAsync();
}
}
/// <summary>
/// Get Input Body
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
private async Task <string> GetInputBody(TableModelField field)
{
//TODO: On config type render inout body
var configurations = await _dbContext.TableFieldConfigValues
.Include(x => x.TableFieldConfig)
.Where(x => x.TableModelFieldId == field.Id).ToListAsync();
var content = string.Empty;
switch (field.DataType)
{
case "nvarchar":
{
content = FormField.GetInputTextField(field.Id.ToString());
}
break;
}
if (configurations.Any())
{
//Ignore
}
return(content);
}
/// <summary>
/// Get table field html body
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
private async Task <string> GetTableFieldBody(TableModelField field)
{
return(string.Format(FormField.FieldBodyTemplate, field.Id, await GetInputBody(field), field.Description, field.DisplayName ?? field.Name));
}
/// <summary>
/// Complete sync entity
/// </summary>
/// <param name="tableModel"></param>
/// <param name="table"></param>
private async Task SyncEntityFieldsAsync(SynchronizeTableViewModel tableModel, TableModel table)
{
var resultModel = await _context.Table
.AsNoTracking()
.Include(x => x.TableFields)
.FirstOrDefaultAsync(x => x.Id == table.Id);
if (resultModel == null)
{
return;
}
{
if (tableModel.IsStaticFromEntityFramework)
{
await SyncEntityFromEntityFramework(tableModel, resultModel.Id);
}
else
{
var fieldTypeList = _context.TableFieldTypes.ToList();
var fieldConfigList = _context.TableFieldConfigs.ToList();
foreach (var item in tableModel.Fields)
{
foreach (var configViewModel in item.Configurations)
{
configViewModel.Name = fieldConfigList.FirstOrDefault(x => x.Code == configViewModel.ConfigCode)?.Name;
if (configViewModel.ConfigCode != "9999")
{
continue;
}
if (configViewModel.Value == "systemcore")
{
configViewModel.Value = table.EntityType;
}
}
var insertField = _tablesService.AddFieldSql(item, tableModel.Name, _connectionString, true, table.EntityType);
// Save field model in the dataBase
if (!insertField.Result)
{
continue;
}
{
var configValues = new List <TableFieldConfigValue>();
var tableFieldType = fieldTypeList.FirstOrDefault(x => x.Code == item.TableFieldCode);
if (tableFieldType == null)
{
continue;
}
var model = new TableModelField
{
DataType = item.DataType,
TableId = resultModel.Id,
Description = item.Description,
Name = item.Name,
DisplayName = item.DisplayName,
AllowNull = item.AllowNull,
Synchronized = true,
TableFieldTypeId = tableFieldType.Id
};
foreach (var configItem in item.Configurations)
{
var config = fieldConfigList.FirstOrDefault(x => x.Code == configItem.ConfigCode);
if (config == null)
{
continue;
}
configValues.Add(new TableFieldConfigValue
{
TableFieldConfigId = config.Id,
TableModelFieldId = model.Id,
Value = configItem.Value,
});
}
model.TableFieldConfigValues = configValues;
_context.TableFields.Add(model);
var dbResult = await _context.SaveAsync();
if (!dbResult.IsSuccess)
{
Debug.WriteLine(dbResult.Errors);
}
}
}
}
}
}
public async Task <IActionResult> AddField(CreateTableFieldViewModel field)
{
var entitiesList = _entityService.Tables;
var table = entitiesList.FirstOrDefault(x => x.Id == field.TableId);
var tableName = table?.Name;
var schema = table?.EntityType;
field.EntitiesList = entitiesList.Select(x => x.Name).ToList();
if (table == null)
{
ModelState.AddModelError(string.Empty, "Table not found");
return(View(field));
}
var baseEntityProps = BaseModel.GetPropsName().Select(x => x.ToLower()).ToList();
if (baseEntityProps.Contains(field.Name.Trim().ToLower()))
{
ModelState.AddModelError(string.Empty, "This field name can't be used, is system name!");
return(View(field));
}
var configurationsRq = await _entityService.RetrieveConfigurationsOnAddNewTableFieldAsyncTask(field);
if (configurationsRq.IsSuccess)
{
field.Configurations = configurationsRq.Result.ToList();
}
field = field.CreateSqlField();
var insertField = _tablesService.AddFieldSql(field, tableName, ConnectionString, true, schema);
// Save field model in the dataBase
if (!insertField.Result)
{
ModelState.AddModelError(string.Empty, "Fail to apply changes to database!");
return(View(field));
}
if (!table.IsCommon)
{
var isDynamic = true;
var isReference = false;
var referenceIsCommon = true;
var tenants = _organizationService.GetAllTenants().Where(x => x.MachineName != GearSettings.DEFAULT_ENTITY_SCHEMA).ToList();
if (field.Parameter == FieldType.EntityReference)
{
isReference = true;
var referenceTableName = field.Configurations
.FirstOrDefault(x => x.Name == nameof(TableFieldConfigCode.Reference.ForeingTable))?.Value;
if (!referenceTableName.IsNullOrEmpty())
{
var refTable = await Context.Table.FirstOrDefaultAsync(x =>
x.Name.Equals(referenceTableName) && x.EntityType.Equals(GearSettings.DEFAULT_ENTITY_SCHEMA) ||
x.Name.Equals(referenceTableName) && x.IsPartOfDbContext);
if (refTable.IsPartOfDbContext)
{
isDynamic = false;
}
else if (!refTable.IsCommon)
{
referenceIsCommon = false;
}
}
}
foreach (var tenant in tenants)
{
if (isDynamic && isReference && !referenceIsCommon)
{
var schemaConf = field.Configurations?.FirstOrDefault(x =>
x.ConfigCode.Equals(TableFieldConfigCode.Reference.ForeingSchemaTable));
if (schemaConf != null)
{
var index = field.Configurations.IndexOf(schemaConf);
schemaConf.Value = tenant.MachineName;
field.Configurations = field.Configurations.Replace(index, schemaConf).ToList();
}
}
_tablesService.AddFieldSql(field, tableName, ConnectionString, true, tenant.MachineName);
}
}
var configs = field.Configurations.Select(item => new TableFieldConfigValue
{
TableFieldConfigId = item.ConfigId,
Value = item.Value,
}).ToList();
var model = new TableModelField
{
DataType = field.DataType,
TableId = field.TableId,
Description = field.Description,
Name = field.Name,
DisplayName = field.DisplayName,
AllowNull = field.AllowNull,
Synchronized = true,
TableFieldTypeId = field.TableFieldTypeId,
TableFieldConfigValues = configs
};
Context.TableFields.Add(model);
var result = await Context.SaveAsync();
if (result.IsSuccess)
{
RefreshRuntimeTypes();
return(RedirectToAction("Edit", "Table", new { id = field.TableId, tab = "two" }));
}
ModelState.AppendResultModelErrors(result.Errors);
return(View(field));
}
/// <inheritdoc />
/// <summary>
/// Get table field configurations
/// </summary>
/// <param name="field"></param>
/// <param name="schema"></param>
/// <returns></returns>
public virtual async Task <IEnumerable <FieldConfigViewModel> > GetTableFieldConfigurations(TableModelField field, string schema)
{
Arg.NotNull(field, nameof(TableModelField));
var fieldType = await _context.TableFieldTypes.FirstOrDefaultAsync(x => x.Id == field.TableFieldTypeId);
var fieldTypeConfig = _context.TableFieldConfigs.Where(x => x.TableFieldTypeId == fieldType.Id).ToList();
var configFields = new List <FieldConfigViewModel>();
//TODO: if config not defined, load it
foreach (var y in field.TableFieldConfigValues)
{
var fTypeConfig = fieldTypeConfig.FirstOrDefault(x => x.Id == y.TableFieldConfigId);
if (fTypeConfig == null)
{
continue;
}
var config = new FieldConfigViewModel
{
Name = fTypeConfig.Name,
Type = fTypeConfig.Type,
ConfigId = y.TableFieldConfigId,
Description = fTypeConfig.Description,
ConfigCode = fTypeConfig.Code,
Value = y.Value
};
if (fTypeConfig.Code.Equals(TableFieldConfigCode.Reference.ForeingSchemaTable))
{
var tableName = field.TableFieldConfigValues
.FirstOrDefault(x => x.TableFieldConfig.Code
.Equals(TableFieldConfigCode.Reference.ForeingTable));
if (tableName != null)
{
var table = _context.Table.FirstOrDefault(x =>
x.Name.Equals(tableName.Value) && x.EntityType == GearSettings.DEFAULT_ENTITY_SCHEMA);
if (table != null && !table.IsPartOfDbContext && !table.IsSystem && !table.IsCommon)
{
config.Value = schema;
}
}
}
configFields.Add(config);
}
return(configFields);
}
