public List <Dictionary <string, FieldBizData> > ToBizDataDictionaryList(QueryPiplineContext queryPiplineContext, List <BsonDocument> bsonElements)
{
//接口配置的字段字典
var interfaceMetaFieldsDic = queryPiplineContext.MetaFieldsCodeDicByFieldListId;
List <Dictionary <string, FieldBizData> > resultList = new List <Dictionary <string, FieldBizData> >();
if (bsonElements != null && bsonElements.Any())
{
foreach (var elements in bsonElements)
{
Dictionary <string, FieldBizData> keyValuePairs = new Dictionary <string, FieldBizData>();
foreach (var field in interfaceMetaFieldsDic)
{
//如果当前结果集包含字段
if (elements.Contains(field.Key))
{
keyValuePairs.Add(field.Key, new FieldBizData
{
Name = field.Key,
Text = elements[field.Key]?.ToString(),
Value = elements[field.Key]
});
}
}
resultList.Add(keyValuePairs);
}
}
return(resultList);
}
public List <Column> GetColumnDataByFieldListId(QueryPiplineContext queryPiplineContext)
{
var fieldListMetaFields = queryPiplineContext.FieldListMetaFieldsOfFieldListId;
if (fieldListMetaFields != null && fieldListMetaFields.Any())
{
List <Column> columns = new List <Column>();
foreach (var item in fieldListMetaFields)
{
columns.Add(new Column
{
CmpData = new ColumnCmpData
{
Name = item.Name,
Title = item.Text,
Type = item.FieldType.ToString(),
Visible = TrueFalseTranslator.ToBoolean(item.IsVisible),
IsLink = TrueFalseTranslator.ToBoolean(item.IsLink),
ShowIndex = item.SortNumber
}
});
}
return(columns);
}
return(null);
}
public T RunTriggerScript <T>(QueryPiplineContext queryPiplineContext, TriggerPoint triggerPoint, string functionName, T result, params object[] parameters)
{
var triggerScripts = queryPiplineContext.TriggerScriptsOfOneServiceType?.Where(t => t.TriggerPoint == (int)triggerPoint).ToList();
if (triggerScripts != null && triggerScripts.Any())
{
foreach (var script in triggerScripts)
{
var dynamicScript = script.ToDynamicScript();
dynamicScript.FunctionName = functionName;
dynamicScript.ProjectName = queryPiplineContext.ApplicationCode;
dynamicScript.Parameters = parameters;
var executeResult = _scriptEngineProvider.RunScript <T>(dynamicScript);
if (!executeResult.IsSuccess && (OnFailurePolicy)script.OnFailurePolicy == OnFailurePolicy.Break)
{
throw new Exception(executeResult.Message);
}
else
{
result = executeResult.Data;
}
}
}
return(result);
}
public IActionResult Post([FromQuery] QueryArgs queryArgs, [FromBody] JObject jObj)
{
try
{
var json = jObj.ToString();
var bson = BsonDocument.Parse(json);
if (bson == null || !bson.Any())
{
return(JsonResultModel.Error("Parameter invalid:jObj = null 业务数据为空"));
}
//Pretreatment create queryContext
QueryPiplineContext queryContext = PretreatmentAndCreateQueryPiplineContext(queryArgs);
queryContext.MetaObject = metaObjectService.GetById(queryContext.MetaObjectId);
if (queryContext.MetaObject == null)
{
return(JsonResultModel.Error($"未能找到对象Id为[{queryContext.MetaObjectId}]对应的对象信息"));
}
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_Add);
//trigger before
bson = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_Add_Before, bson, CurrentApplicationContext, queryContext.InterfaceCode, bson);
//check data by form
if (queryContext.FormId != default(int))
{
var formCheckResult = _formMetaFieldService.ValidateFormData(queryContext.FormId, bson);
if (!formCheckResult.IsSuccess)
{
return(formCheckResult.ToJsonResultModel());
}
}
//add data
var addResult = dataAccessService.Add(queryContext.TenantId, queryContext.MetaObject, bson);
//trigger after
_triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_Add_After, bson, CurrentApplicationContext, queryContext.InterfaceCode, bson);
return(addResult.ToJsonResultModel());
}
catch (ArgumentNullException argNullEx)
{
return(JsonResultModel.Error(argNullEx.Message));
}
catch (ArgumentException argEx)
{
return(JsonResultModel.Error(argEx.Message));
}
catch (Exception ex)
{
return(JsonResultModel.Error(ex.Message));
}
}
public IActionResult Update([FromQuery] QueryArgs queryArgs, [FromBody] JObject jObj)
{
try
{
var json = jObj.ToString();
var bson = BsonDocument.Parse(json);
if (bson == null || !bson.Any())
{
return(JsonResultModel.Error("Parameter invalid:jObj = null 业务数据为空"));
}
//Pretreatment create queryContext
QueryPiplineContext queryContext = PretreatmentAndCreateQueryPiplineContext(queryArgs);
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_Update);
//查询条件
FilterDefinition <BsonDocument> filter = conditionAggregationService.AnalysisConditionToFilterDefinitionByConditionId(queryContext, queryContext.ArgumentsDic);
//trigger before
bson = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_Update_Before, bson, CurrentApplicationContext, queryContext.InterfaceCode, bson, filter);
//check data by form
if (queryContext.FormId != default(int))
{
var formCheckResult = _formMetaFieldService.ValidateFormData(queryContext.FormId, bson);
if (!formCheckResult.IsSuccess)
{
return(formCheckResult.ToJsonResultModel());
}
}
//update data
dataAccessService.Update(queryContext.TenantId, queryContext.MetaObjectId, filter, bson);
//trigger after
_triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_Update_After, bson, CurrentApplicationContext, queryContext.InterfaceCode, bson);
return(JsonResultModel.Success("success"));
}
catch (ArgumentNullException argNullEx)
{
return(JsonResultModel.Error(argNullEx.Message));
}
catch (ArgumentException argEx)
{
return(JsonResultModel.Error(argEx.Message));
}
catch (Exception ex)
{
return(JsonResultModel.Error(ex.Message));
}
}
public SingleObjectComponent GetSingleObjectComponent(QueryPiplineContext queryPiplineContext, FilterDefinition <BsonDocument> condition)
{
var fieldMetas = fieldListAggregationService.GetColumnDataByFieldListId(queryPiplineContext);
var document = Get(queryPiplineContext.TenantId, queryPiplineContext.MetaObjectId, condition, fieldMetas?.Select(t => t.CmpData.Name)?.ToArray());
SingleObjectComponent singleObjectComponent = new SingleObjectComponent
{
BizData = fieldBizDataService.ToBizDataDictionary(queryPiplineContext, document),
ColunmDatas = fieldMetas?.OrderBy(t => t.CmpData.ShowIndex)?.ToList()
};
return(singleObjectComponent);
}
public TableListComponent GetTableListComponent(QueryPiplineContext queryPiplineContext, FilterDefinition <BsonDocument> condition, int pageIndex, int pageSize, SortDefinition <BsonDocument> sort, out int count)
{
var fieldMetas = fieldListAggregationService.GetColumnDataByFieldListId(queryPiplineContext);
var documents = GetList(queryPiplineContext.TenantId, queryPiplineContext.MetaObjectId, condition, pageIndex, pageSize, sort, out count, fieldMetas?.Select(t => t.CmpData.Name)?.ToArray());
TableListComponent tableListComponent = new TableListComponent
{
BizData = fieldBizDataService.ToBizDataDictionaryList(queryPiplineContext, documents),
BizDataTotalCount = count,
Columns = fieldMetas?.OrderBy(t => t.CmpData.ShowIndex)?.ToList()
};
if (pageSize != 0)
{
tableListComponent.PageCount = count / pageSize;
}
return(tableListComponent);
}
public SortDefinition <BsonDocument> GetSortDefinitionBySortFields(QueryPiplineContext queryPiplineContext, SortField[] sortFields)
{
var builder = new SortDefinitionBuilder <BsonDocument>();
if (sortFields == null || !sortFields.Any())
{
return(builder.Ascending("_id"));
}
//获取全部字段
SortDefinition <BsonDocument> sort = null;
var metaFieldDic = queryPiplineContext.MetaFieldsUnDeletedCodeDic;
foreach (var item in sortFields)
{
if (!metaFieldDic.ContainsKey(item.Column))
{
throw new ArgumentNullException(item.Column, $"field of {item.Column} is not exist in current MetaObject");
}
if (item.IsDesc)
{
if (sort == null)
{
sort = builder.Descending(item.Column);
}
else
{
sort = sort.Descending(item.Column);
}
}
else
{
if (sort == null)
{
sort = builder.Ascending(item.Column);
}
else
{
sort = sort.Ascending(item.Column);
}
}
}
return(sort);
}
/// <summary>
/// 1.预处理统一的参数验证逻辑
/// 2.根据接口信息创建查询管道上下文
/// </summary>
/// <param name="queryArgs"></param>
/// <returns></returns>
private QueryPiplineContext PretreatmentAndCreateQueryPiplineContext(QueryArgs queryArgs)
{
//args check
if (queryArgs == null)
{
throw new Exception($"Parameter invalid:queryArgs = null");
}
queryArgs.QueryArgsCheck();
//argumentsDic generate
Dictionary <string, object> argumentsDic = new Dictionary <string, object>();
foreach (var item in Request.Query)
{
argumentsDic.AddOrUpdate(item.Key.ToUpperInvariant(), item.Value);
}
//get interface info
var interfaceAggregation = interfaceAggregationService.GetByInterfaceAggregationCode(queryArgs._interface);
if (interfaceAggregation == null)
{
throw new Exception($"未能找到接口编码为[{queryArgs._interface}]对应的接口信息");
}
//create queryContext
QueryPiplineContext queryContext = new QueryPiplineContext();
queryContext.InterfaceCode = queryArgs._interface;
queryContext.ArgumentsDic = argumentsDic;
queryContext.ApplicationCode = interfaceAggregation.Code.Split('.')[0];
queryContext.MetaObjectId = interfaceAggregation.MetaObjectId;
queryContext.SearchConditionId = interfaceAggregation.SearchConditionId;
queryContext.FieldListId = interfaceAggregation.FieldListId;
queryContext.DataSourceId = interfaceAggregation.DataSourceId;
queryContext.InterfaceType = (InterfaceType)interfaceAggregation.InterfaceType;
//设置ApplicationCode到Session
SetApplictionCodeToSession(queryContext.ApplicationCode);
return(queryContext);
}
public IActionResult Delete([FromQuery] QueryArgs queryArgs)
{
try
{
//Pretreatment create queryContext
QueryPiplineContext queryContext = PretreatmentAndCreateQueryPiplineContext(queryArgs);
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_Delete);
//查询条件
FilterDefinition <BsonDocument> filter = conditionAggregationService.AnalysisConditionToFilterDefinitionByConditionId(queryContext, queryContext.ArgumentsDic);
//trigger before
filter = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_Delete_Before, filter, CurrentApplicationContext, queryContext.InterfaceCode, filter);
//queryResult
var queryDatas = dataAccessService.GetList(queryContext.TenantId, queryContext.MetaObjectId, filter, null);
//delete
dataAccessService.Delete(queryContext.TenantId, queryContext.MetaObjectId, filter);
//trigger after
_triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_Delete_After, filter, CurrentApplicationContext, queryContext.InterfaceCode, queryDatas);
return(JsonResultModel.Success("success"));
}
catch (ArgumentNullException argNullEx)
{
return(JsonResultModel.Error(argNullEx.Message));
}
catch (ArgumentException argEx)
{
return(JsonResultModel.Error(argEx.Message));
}
catch (Exception ex)
{
return(JsonResultModel.Error(ex.Message));
}
}
public Dictionary <string, FieldBizData> ToBizDataDictionary(QueryPiplineContext queryPiplineContext, BsonDocument bsonElement)
{
if (bsonElement != null && bsonElement.Any())
{
//接口配置的字段字典
var interfaceMetaFieldsDic = queryPiplineContext.MetaFieldsCodeDicByFieldListId;
Dictionary <string, FieldBizData> keyValuePairs = new Dictionary <string, FieldBizData>();
foreach (var field in interfaceMetaFieldsDic)
{
//如果当前结果集包含字段
if (bsonElement.Contains(field.Key))
{
keyValuePairs.Add(field.Key, new FieldBizData
{
Name = field.Key,
Text = bsonElement[field.Key]?.ToString(),
Value = bsonElement[field.Key]
});
}
}
return(keyValuePairs);
}
return(null);
}
public object RunDataSourceScript(QueryPiplineContext queryPiplineContext, params object[] parameters)
{
var dataSource = _dataSourceService.GetById(queryPiplineContext.DataSourceId);
if (dataSource != null)
{
var dynamicScript = new DynamicScript();
dynamicScript.Script = dataSource.Script;
dynamicScript.Language = DynamicScriptLanguage.CSharp;
dynamicScript.FunctionName = FunctionName_DataSource;
dynamicScript.ProjectName = queryPiplineContext.ApplicationCode;
dynamicScript.Parameters = parameters;
var executeResult = _scriptEngineProvider.RunScript <object>(dynamicScript);
if (executeResult.IsSuccess)
{
return(executeResult.Data);
}
else
{
throw new Exception(executeResult.Message);
}
}
return(null);
}
public IActionResult Post([FromQuery] QueryArgs queryArgs, [FromBody] JArray jArray)
{
try
{
if (jArray == null || !jArray.Any())
{
return(JsonResultModel.Error($"Parameter invalid:data = null"));
}
//Pretreatment create queryContext
QueryPiplineContext queryContext = PretreatmentAndCreateQueryPiplineContext(queryArgs);
queryContext.MetaObject = metaObjectService.GetById(queryContext.MetaObjectId);
if (queryContext.MetaObject == null)
{
return(JsonResultModel.Error($"未能找到对象Id为[{queryContext.MetaObjectId}]对应的对象信息"));
}
int successCount = 0;
int errorCount = 0;
List <BsonDocument> documents = new List <BsonDocument>();
foreach (var item in jArray)
{
try
{
var json = item.ToString();
documents.Add(BsonDocument.Parse(json));
successCount++;
}
catch (Exception)
{
errorCount++;
}
}
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_BatchAdd);
//trigger before
documents = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_BatchAdd_Before, documents, CurrentApplicationContext, queryContext.InterfaceCode, documents);
//check data by form
if (queryContext.FormId != default(int))
{
var formCheckResult = _formMetaFieldService.ValidateFormData(queryContext.FormId, documents);
if (!formCheckResult.IsSuccess)
{
return(formCheckResult.ToJsonResultModel());
}
}
//add data
var addResult = dataAccessService.BatchAdd(queryContext.TenantId, queryContext.MetaObject, documents);
//trigger after
_triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_BatchAdd_After, documents, CurrentApplicationContext, queryContext.InterfaceCode, documents);
return(addResult.ToJsonResultModel());
}
catch (ArgumentNullException argNullEx)
{
return(JsonResultModel.Error(argNullEx.Message));
}
catch (ArgumentException argEx)
{
return(JsonResultModel.Error(argEx.Message));
}
catch (Exception ex)
{
return(JsonResultModel.Error(ex.Message));
}
}
private FilterDefinition <BsonDocument> AnalysisConditionToFilterDefinition(QueryPiplineContext queryPiplineContext, List <SearchConditionNode> conditions, Dictionary <string, object> conditionValueDic, bool isIgnoreArgumentsCheck = false)
{
var bf = Builders <BsonDocument> .Filter;
//全部字段字典缓存
Dictionary <int, MetaField> metaFieldIdDic = queryPiplineContext.MetaFieldsUnDeletedIdDic;
//获取全部条件表达式
if (conditions == null || !conditions.Any())
{
return(null);
}
SearchConditionNode condition = conditions.FirstOrDefault(t => t.ParentId == -1);
if (condition == null)
{
return(null);
}
//如果valueType==-1，则表明这个是连接条件
if (condition.ValueType == -1)
{
//通过链接条件解析器进行解析
return(ConditionRouter(condition));
}
//valueType!=-1 则表明这是个语句
else
{
//通过条件表达式语句解析器解析
return(ConditionValue(condition));
}
//连接条件解析器。如果是连接条件， 则执行下面逻辑将左...右子条件解析
FilterDefinition <BsonDocument> ConditionRouter(SearchConditionNode routeCondition)
{
FilterDefinition <BsonDocument> filterDefinition = Builders <BsonDocument> .Filter.Empty;
//将子节点全部取出
var routeConditionChildren = conditions.Where(t => t.ParentId == routeCondition.Id).ToList();
var first = routeConditionChildren.FirstOrDefault();
if (first != null)
{
//如果字节点是连接条件
if (first.ValueType == -1)
{
filterDefinition = ConditionRouter(first);
}
//如果是语句
else
{
filterDefinition = ConditionValue(first);
//根据根节点的连接条件执行不同的连接操作
switch (routeCondition.ConditionType)
{
case (int)ConditionJoint.And:
//子节点全部是与逻辑
foreach (var item in routeConditionChildren.Except(new[] { first }))
{
//如果valueType==-1 则表明是连接条件
if (item.ValueType == -1)
{
var tempCondition = ConditionRouter(item);
if (tempCondition != null)
{
filterDefinition = bf.And(filterDefinition, tempCondition);
}
}
//如果是表达式语句
else
{
var tempCondition = ConditionValue(item);
if (tempCondition != null)
{
filterDefinition = bf.And(filterDefinition, tempCondition);
}
}
}
break;
case (int)ConditionJoint.Or:
//子节点全部是或逻辑
foreach (var item in routeConditionChildren.Except(new[] { first }))
{
//如果valueType==-1 则表明是连接条件
if (item.ValueType == -1)
{
var tempCondition = ConditionRouter(item);
if (tempCondition != null)
{
filterDefinition = bf.Or(filterDefinition, tempCondition);
}
}
//如果是表达式语句
else
{
var tempCondition = ConditionValue(item);
if (tempCondition != null)
{
filterDefinition = bf.Or(filterDefinition, tempCondition);
}
}
}
break;
default:
return(null);
}
}
return(filterDefinition);
}
return(null);
}
//条件值解析器
FilterDefinition <BsonDocument> ConditionValue(SearchConditionNode routeCondition)
{
//如果条件值来自参数,则从参数列表里面获取
if (routeCondition.Value.Equals("?"))
{
//从参数获取到值
string key = routeCondition.FieldCode;
var keyUpper = key.ToUpperInvariant();
//如果没有传递参数值，则抛出异常
if (!conditionValueDic.ContainsKey(keyUpper))
{
//如果忽略参数检查，则直接返回null
if (isIgnoreArgumentsCheck)
{
return(Builders <BsonDocument> .Filter.Empty);
}
//如果不忽略参数检查，则抛出异常
else
{
throw new ArgumentNullException(key, $"Conditions define field parameters [{key}] but do not provide values.");
}
}
object argumentValue = conditionValueDic.SafeGet(keyUpper);
//将值转化为字段同类型的类型值
object value = metaFieldService.CheckAndGetFieldValueByFieldType(metaFieldIdDic[routeCondition.FieldId], argumentValue).Data;
switch (routeCondition.ConditionType)
{
case (int)ConditionType.Equal:
return(bf.Eq(key, value));
case (int)ConditionType.GreaterThan:
return(bf.Gt(key, value));
case (int)ConditionType.GreaterThanEqual:
return(bf.Gte(key, value));
case (int)ConditionType.LessThan:
return(bf.Lt(key, value));
case (int)ConditionType.LessThanEqual:
return(bf.Lte(key, value));
case (int)ConditionType.NotEqual:
return(bf.Ne(key, value));
default:
return(Builders <BsonDocument> .Filter.Empty);
}
}
//如果来自配置，则直接从配置里面获取到值
else
{
//校验字段以及转换字段值为目标类型
var convertResult = metaFieldService.CheckAndGetFieldValueByFieldType(metaFieldIdDic[routeCondition.FieldId], routeCondition.Value);
if (!convertResult.IsSuccess)
{
throw new ArgumentException("配置的字段值不符合字段的类型");
}
switch (routeCondition.ConditionType)
{
case (int)ConditionType.Equal:
return(bf.Eq(routeCondition.FieldCode, convertResult.Data));
case (int)ConditionType.GreaterThan:
return(bf.Gt(routeCondition.FieldCode, convertResult.Data));
case (int)ConditionType.GreaterThanEqual:
return(bf.Gte(routeCondition.FieldCode, convertResult.Data));
case (int)ConditionType.LessThan:
return(bf.Lt(routeCondition.FieldCode, convertResult.Data));
case (int)ConditionType.LessThanEqual:
return(bf.Lte(routeCondition.FieldCode, convertResult.Data));
case (int)ConditionType.NotEqual:
return(bf.Ne(routeCondition.FieldCode, convertResult.Data));
default:
return(Builders <BsonDocument> .Filter.Empty);
}
}
}
}
/// <summary>
/// 将条件配置解析成mongodb可以执行的条件
/// </summary>
/// <param name="metaObjectId">条件id</param>
/// <param name="searchConditionId">从http请求中传递过来的参数值集合</param>
/// <param name="conditionValueDic">参数</param>
/// <param name="isIgnoreArgumentsCheck">是否忽略参数校验,如果为true，需要的参数未传递会抛出异常；如果为false，需要的参数不存在条件返回null</param>
/// <returns></returns>
public FilterDefinition <BsonDocument> AnalysisConditionToFilterDefinitionByConditionId(QueryPiplineContext queryPiplineContext, Dictionary <string, object> conditionValueDic, bool isIgnoreArgumentsCheck = false)
{
List <SearchConditionNode> conditions = GetListBySearchConditionId(queryPiplineContext.SearchConditionId);
return(AnalysisConditionToFilterDefinition(queryPiplineContext, conditions, conditionValueDic, isIgnoreArgumentsCheck));
}
public IActionResult Get([FromQuery] QueryArgs queryArgs)
{
try
{
//Pretreatment create queryContext
QueryPiplineContext queryContext = PretreatmentAndCreateQueryPiplineContext(queryArgs);
//查询条件
FilterDefinition <BsonDocument> filter = FilterDefinition <BsonDocument> .Empty;
//【SingleObject,TableList,Count】预处理一些逻辑
if (new InterfaceType[] { InterfaceType.SingleObject, InterfaceType.TableList, InterfaceType.Count }.Contains(queryContext.InterfaceType))
{
//缓存对象下的全部未删除字段信息
queryContext.MetaFieldsUnDeleted = metaFieldService.GetEntitiesUnDeletedByMetaObjectId(queryContext.MetaObjectId);
//组织查询条件
filter = conditionAggregationService.AnalysisConditionToFilterDefinitionByConditionId(queryContext, queryContext.ArgumentsDic);
//缓存列字段信息
if (queryContext.InterfaceType == InterfaceType.SingleObject || queryContext.InterfaceType == InterfaceType.TableList)
{
queryContext.FieldListMetaFieldsOfFieldListId = _fieldListMetaFieldService.GetByFieldListId(queryContext.FieldListId);
}
}
switch (queryContext.InterfaceType)
{
case InterfaceType.SingleObject:
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_SingleObject);
filter = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_SingleObject_Before, filter, CurrentApplicationContext, queryContext.InterfaceCode, filter);
var singleObjectComponent = dataAccessService.GetSingleObjectComponent(queryContext, filter);
singleObjectComponent = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_SingleObject_After, singleObjectComponent, CurrentApplicationContext, queryContext.InterfaceCode, singleObjectComponent);
return(JsonResultModel.Success("get single data success", singleObjectComponent));
case InterfaceType.TableList:
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_TableList);
filter = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_TableList_Before, filter, CurrentApplicationContext, queryContext.InterfaceCode, filter);
var sort = metaFieldService.GetSortDefinitionBySortFields(queryContext, new[] { new SortField {
Column = "ModifyTime", IsDesc = true
} });
var tableListComponent = dataAccessService.GetTableListComponent(queryContext, filter, queryArgs._pageIndex, queryArgs._pageSize, sort, out int totalCount);
tableListComponent = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_TableList_After, tableListComponent, CurrentApplicationContext, queryContext.InterfaceCode, tableListComponent);
return(JsonResultModel.Success("get data list success", tableListComponent));
case InterfaceType.Count:
//缓存某个服务下的全部触发器脚本，包括before和after
queryContext.TriggerScriptsOfOneServiceType = _triggerScriptService.GetTriggerScriptsUnDeletedByMetaObjectIdAndServiceType(queryContext.MetaObjectId, (int)ServiceType.Interface_Count);
filter = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.Before, TriggerScriptService.FunctionName_MetaObject_Interface_Count_Before, filter, CurrentApplicationContext, queryContext.InterfaceCode, filter);
var count = dataAccessService.GetCount(queryContext.TenantId, queryContext.MetaObjectId, filter);
count = _triggerScriptService.RunTriggerScript(queryContext, TriggerPoint.After, TriggerScriptService.FunctionName_MetaObject_Interface_Count_After, count, CurrentApplicationContext, queryContext.InterfaceCode, filter, count);
return(JsonResultModel.Success("get data count success", count));
case InterfaceType.JsonDataSource:
return(new JsonResult(Newtonsoft.Json.JsonConvert.DeserializeObject(_dataSourceService.GetById(queryContext.DataSourceId).Script)));
case InterfaceType.ExecutableScriptDataSource:
object triggerScriptDataSourceResult = _triggerScriptService.RunDataSourceScript(queryContext, CurrentApplicationContext, queryContext.InterfaceCode, queryContext.ArgumentsDic);
return(JsonResultModel.Success("get trigger script result success", triggerScriptDataSourceResult));
default:
break;
}
return(JsonResultModel.Success("success,no data"));
}
catch (ArgumentNullException argNullEx)
{
return(JsonResultModel.Error(argNullEx.Message));
}
catch (ArgumentException argEx)
{
return(JsonResultModel.Error(argEx.Message));
}
catch (Exception ex)
{
return(JsonResultModel.Error(ex.Message));
}
}
