public static Rect CalcScreenRect(GameObject gameObject, Camera camera, QueryConfig queryConfig)
{
AABB worldAABB = CalcWorldAABB(gameObject, queryConfig);
if (!worldAABB.IsValid)
{
return(new Rect(0.0f, 0.0f, 0.0f, 0.0f));
}
return(worldAABB.GetScreenRectangle(camera));
}
public static OBB CalcHierarchyWorldOBB(GameObject root, QueryConfig queryConfig)
{
AABB modelAABB = CalcHierarchyModelAABB(root, queryConfig);
if (!modelAABB.IsValid)
{
return(OBB.GetInvalid());
}
return(new OBB(modelAABB, root.transform));
}
public IHttpActionResult GetQueryConfig(Guid id)
{
QueryConfig queryConfig = db.QueryConfigs.Find(id);
if (queryConfig == null)
{
return(NotFound());
}
return(Ok(queryConfig));
}
public static OBB CalcWorldOBB(GameObject gameObject, QueryConfig queryConfig)
{
AABB modelAABB = CalcModelAABB(gameObject, queryConfig, gameObject.GetGameObjectType());
if (!modelAABB.IsValid)
{
return(OBB.GetInvalid());
}
return(new OBB(modelAABB, gameObject.transform));
}
public static AABB CalcWorldAABB(GameObject gameObject, QueryConfig queryConfig)
{
AABB modelAABB = CalcModelAABB(gameObject, queryConfig, gameObject.GetGameObjectType());
if (!modelAABB.IsValid)
{
return(modelAABB);
}
modelAABB.Transform(gameObject.transform.localToWorldMatrix);
return(modelAABB);
}
public object GetDateDefalutValueType()
{
try
{
var model = QueryConfig.GetEnumList(typeof(QueryConfig.DateDefalutValueType));
return(base.ToSuccessObject(model));
}
catch (Exception ex)
{
return(base.ToFailureObject(ex.Message));
}
}
public void ValidateQueryConfigurationTest_throw_exception_if_not_proper_document_returns()
{
_mockDbSvc.Setup(x => x.CollectionExists(It.IsAny <string>())).Returns(true);
_mockDbSvc.Setup(x => x.GetOneDocument(It.IsAny <string>())).Returns(new BsonDocument());
QueryConfig queryConfig = CreateQueryConfig();
Action test = () => _validator.ValidateQueryConfiguration(queryConfig);
test.Should().Throw <Exception>();
}
private void ReadAndSetSchema(QueryConfig config, QueueContext queueContext, Job job)
{
var fileUploader = new FileUploader(queueContext.Config.ElasticSearchUserName,
queueContext.Config.ElasticSearchPassword, job.Config.KeepIndexOnline);
if (config.UploadToElasticSearch && config.DropAndReloadIndex)
{
Task.Run(
async() =>
{
await fileUploader.DeleteIndex(config.Urls, queueContext.MainMappingUploadRelativeUrl, config.Index, config.Alias);
})
.Wait();
}
var tasks = new List <Task>();
// ReSharper disable once JoinDeclarationAndInitializer
IList <Task> newTasks;
var sqlGetSchemaQueue = queueContext.QueueManager
.CreateInputQueue <SqlGetSchemaQueueItem>(_stepNumber + 1);
sqlGetSchemaQueue.Add(new SqlGetSchemaQueueItem
{
Loads = job.Data.DataSources
});
sqlGetSchemaQueue.CompleteAdding();
newTasks = RunAsync(() => new SqlGetSchemaQueueProcessor(queueContext), 1, queueContext);
tasks.AddRange(newTasks);
newTasks = RunAsync(() => new SaveSchemaQueueProcessor(queueContext), 1, queueContext);
tasks.AddRange(newTasks);
if (config.UploadToElasticSearch)
{
newTasks = RunAsync(() => new MappingUploadQueueProcessor(queueContext), 1, queueContext);
}
else
{
newTasks = RunAsync(() => new DummyMappingUploadQueueProcessor(queueContext), 1, queueContext);
}
tasks.AddRange(newTasks);
Task.WaitAll(tasks.ToArray());
// set up aliases
if (config.UploadToElasticSearch)
{
fileUploader.SetupAlias(config.Urls, config.Index, config.Alias).Wait();
}
}
public static AABB CalcHierarchyWorldAABB(GameObject root, QueryConfig queryConfig)
{
AABB modelAABB = CalcHierarchyModelAABB(root, queryConfig);
if (!modelAABB.IsValid)
{
return(AABB.GetInvalid());
}
modelAABB.Transform(root.transform.localToWorldMatrix);
return(modelAABB);
}
public CachedIndexerQueryService(
ILogService <IndexerQueryService> logger
, Func <Indexer, IIndexer> getIndexer
, QueryConfig queryConfig
, IMemoryCache memoryCache
)
{
_queryService = new IndexerQueryService(logger, getIndexer);
_queryConfig = queryConfig;
_memoryCache = memoryCache;
}
/// <summary>
/// Gets configuration from config file (json) unless specified in attributes on the binding or entity
/// </summary>
/// <param name="binding"></param>
/// <param name="bindingExecution"></param>
/// <param name="entity"></param>
/// <returns></returns>
private HierarchicalConfiguration GetConfiguration(Binding binding, BindingExecution bindingExecution, Entity entity)
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
if (directoryName == null)
{
throw new InvalidOperationException("Could not find plugin configuration file base path.");
}
string fullPath = Path.Combine(directoryName, Resources.DefaultConfigFileName);
string json = File.ReadAllText(fullPath);
dynamic deserialized = JsonConvert.DeserializeObject(json);
dynamic databusConfiguration = deserialized.DatabusConfiguration;
var queryConfig = new QueryConfig
{
ConnectionString = this.BuildConnectionString(binding),
Url = this.BuildUrl(entity) ?? databusConfiguration.Url,
MaximumEntitiesToLoad = this.GetAttributeInt(binding.AttributeValues, AttributeNames.MaxEntitiesToLoad)
?? databusConfiguration.MaximumEntitiesToLoad,
EntitiesPerBatch = this.GetAttributeInt(binding.AttributeValues, AttributeNames.EntitiesPerBatch)
?? databusConfiguration.EntitiesPerBatch,
EntitiesPerUploadFile = this.GetAttributeInt(binding.AttributeValues, AttributeNames.EntitiesPerUploadFile)
?? databusConfiguration.EntitiesPerUploadFile,
LocalSaveFolder = this.BuildLocalSaveFolder(
binding.AttributeValues.GetAttributeTextValue(AttributeNames.LocalSaveFolder),
binding,
bindingExecution)
?? this.BuildLocalSaveFolder(Convert.ToString(databusConfiguration.LocalSaveFolder), binding, bindingExecution),
WriteTemporaryFilesToDisk = this.GetAttributeBool(binding.AttributeValues, AttributeNames.WriteTempFilesToDisk)
?? databusConfiguration.WriteTemporaryFilesToDisk,
WriteDetailedTemporaryFilesToDisk = this.GetAttributeBool(binding.AttributeValues, AttributeNames.DetailedTempFiles)
?? databusConfiguration.WriteDetailedTemporaryFilesToDisk,
CompressFiles = this.GetAttributeBool(binding.AttributeValues, AttributeNames.CompressFiles)
?? databusConfiguration.CompressFiles,
UploadToUrl = this.GetAttributeBool(binding.AttributeValues, AttributeNames.UploadToUrl)
?? databusConfiguration.UploadToUrl,
UrlMethod = this.GetHtmlMethod(entity.AttributeValues?.GetAttributeTextValue(AttributeNames.HttpMethod))
?? this.GetHtmlMethod(Convert.ToString(databusConfiguration.UrlMethod))
?? HttpMethod.Post
};
this.CreateLocalSaveFolderIfNotExists(queryConfig);
var hierarchicalConfig = new HierarchicalConfiguration
{
ClientSpecificConfiguration = this.GetClientSpecificConfiguration(entity, deserialized.ClientSpecificConfigurations),
DatabusConfiguration = queryConfig
};
return(hierarchicalConfig);
}
public async Task Handler_Finds_Multiple_Items_By_Single_Predicate_String_Property_Contains()
{
var handler = _serviceProvider
.GetService <IQueryConfigHandler <QueryConfig> >();
var config = new QueryConfig
{
QueryBy = new List <QueryPredicate>
{
new QueryPredicate
{
ColumnCode = "Name",
CompareWith = QueryPredicateConnective.Or,
Values = new List <QueryPredicateValue>
{
new QueryPredicateValue
{
Value = "oli",
CompareUsing = QueryPredicateComparison.Contains
}
}
}
}
};
var source = new List <TestItem>
{
new TestItem
{
Name = "Colin",
Id = 1
},
new TestItem
{
Name = "Brendan",
Id = 2
},
new TestItem
{
Name = "Drooling",
Id = 3
},
};
var result = await handler
.HandleAsync <TestItem, QueryResult <TestItem> >(config, source.AsQueryable())
.ConfigureAwait(false);
Assert.NotNull(result);
Assert.Equal(2, result.Total);
Assert.NotEmpty(result.Payload);
}
private void CreateLocalSaveFolderIfNotExists(QueryConfig queryConfig)
{
if (!queryConfig.WriteTemporaryFilesToDisk)
{
return;
}
if (!Directory.Exists(queryConfig.LocalSaveFolder))
{
Directory.CreateDirectory(queryConfig.LocalSaveFolder);
this.LogDebug($"Created local save folder: {queryConfig.LocalSaveFolder}");
}
}
public void ValidateQueryConfigurationTest_not_throw_exception_if_config_correct()
{
_mockDbSvc.Setup(x => x.CollectionExists(It.IsAny <string>())).Returns(true);
_mockDbSvc.Setup(x => x.GetOneDocument(It.IsAny <string>())).Returns(DataHelper.CreateBJson());
QueryConfig queryConfig = CreateQueryConfig();
Action test = () => _validator.ValidateQueryConfiguration(queryConfig);
test.Should().NotThrow <Exception>();
}
public async Task Handler_Finds_Single_Item_In_DbContext_By_Single_Predicate_String_Property_Equal()
{
var context = _serviceProvider
.GetService <TestDbContext>();
var handler = _serviceProvider
.GetService <IDataQueryConfigHandler <QueryConfig> >();
var config = new QueryConfig {
QueryBy = new List <QueryPredicate>()
};
var p1 = new QueryPredicate
{
ColumnCode = "Name",
CompareWith = QueryPredicateConnective.Or,
Values = new List <QueryPredicateValue>()
};
p1.Values.Add(new QueryPredicateValue {
Value = "June", CompareUsing = QueryPredicateComparison.Equal
});
config.QueryBy.Add(p1);
var source = new List <Parent>
{
new Parent {
Name = "Dre", Id = 1
},
new Parent {
Name = "June", Id = 2
}
};
await context.Parents
.AddRangeAsync(source)
.ConfigureAwait(false);
await context
.SaveChangesAsync(true)
.ConfigureAwait(false);
var result = await handler
.HandleAsync <Parent, QueryResult <Parent> >(config, context)
.ConfigureAwait(false);
Assert.NotNull(result);
Assert.Equal(1, result.Total);
Assert.NotEmpty(result.Payload);
}
public ActionResult Details(string[] areas, string data, string query, string action)
{
try
{
QueryConfig queries = _reportService.GetQueries();
ViewBag.Queries = queries.GetQueries();
var fylker = _registerService.GetFylker();
var kommuner = _registerService.GetKommuner();
ViewBag.fylker = fylker;
ViewBag.kommuner = kommuner;
Dictionary <string, string> codeList = new Dictionary <string, string>();
codeList = fylker.Union(kommuner).ToDictionary(k => k.Key, v => v.Value);
ViewBag.selectedAreas = areas;
ViewBag.data = data;
var queryConfig = queries.GetQuery(query, data);
ViewBag.query = queryConfig;
ReportQuery reportQuery = new ReportQuery();
reportQuery.Parameters = new List <ReportQueryParameter>();
reportQuery.QueryName = queryConfig.Value;
foreach (string area in areas)
{
reportQuery.Parameters.Add(new ReportQueryParameter {
Name = "area", Value = area
});
}
reportQuery.Parameters.Add(new ReportQueryParameter {
Name = "data", Value = data
});
ReportResult result = _reportService.GetQueryResult(reportQuery);
if (action == "Excel")
{
var fileStream = new ExcelReportGenerator().CreateExcelSheet(reportQuery, result, codeList);
var fileStreamResult = new FileStreamResult(fileStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
fileStreamResult.FileDownloadName = "Rapport-" + query + ".xlsx";
return(fileStreamResult);
}
else
{
return(View(result));
}
}
catch (Exception ex)
{
Log.Error(ex);
return(View("Error"));
}
}
private Optional <Snapshot> GetSnapshot(QueryConfig cfg)
{
cfg.EntityId.MustNotBeDefault();
lock (_sync)
{
var all = _snapshots.GetValueOrDefault(cfg.EntityId.Value, new List <Snapshot>()).ToArray();
if (!all.Any())
{
return(Optional <Snapshot> .Empty);
}
var snapshot = all.OrderByDescending(d => d.Version).FirstOrDefault();
return(snapshot == null?Optional <Snapshot> .Empty:new Optional <Snapshot>(snapshot));
}
}
public IHttpActionResult DeleteQueryConfig(Guid id)
{
QueryConfig queryConfig = db.QueryConfigs.Find(id);
if (queryConfig == null)
{
return(NotFound());
}
db.QueryConfigs.Remove(queryConfig);
db.SaveChanges();
return(Ok(queryConfig));
}
private async Task <Optional <Snapshot> > GetSnapshot(DbConnection db, QueryConfig cfg)
{
if (cfg.EntityId == null)
{
return(Optional <Snapshot> .Empty);
}
var row = await db.QueryRowAsync <Snapshot>(
q => q.From <Snapshot>()
.Where(d => d.EntityId == cfg.EntityId && d.TenantId == cfg.TenantId)
.OrderByDescending(d => d.Version)
.Limit(1)
.SelectAll(useAsterisk: true), CancellationToken.None).ConfigureFalse();
return(row == null ? Optional <Snapshot> .Empty :new Optional <Snapshot>(row));
}
/// <summary>
/// 主键配置
/// </summary>
static void PrimaryKeyConfig()
{
#region Sys
QueryConfig.SetPrimaryKey <UserEntity>(u => u.SysNo);
QueryConfig.SetPrimaryKey <RoleEntity>(u => u.SysNo);
QueryConfig.SetPrimaryKey <AuthorityEntity>(u => u.Code);
QueryConfig.SetPrimaryKey <AuthorityGroupEntity>(u => u.SysNo);
QueryConfig.SetPrimaryKey <AuthorityOperationEntity>(u => u.SysNo);
QueryConfig.SetPrimaryKey <AuthorityOperationGroupEntity>(u => u.SysNo);
QueryConfig.SetPrimaryKey <UserAuthorizeEntity>(u => u.User, u => u.Authority);
QueryConfig.SetPrimaryKey <RoleAuthorizeEntity>(u => u.Role, u => u.Authority);
#endregion
}
public TestQueryPaginator()
{
Logger = QueryTestHelper.GetLogger <TestQueryPaginator> ();
TestHandler.Connection = Connection;
QueryPersonInfo = new QueryConfig("Person",
new QueryField("FirstName"),
new QueryField("LastName"),
new QueryField(name: "Age", type: typeof(int)));
QueryPersonInfo.Provider = DatabaseProvider.SQLite;
QueryPersonInfo.ConnectionString = Connection;
}
/// <summary>
/// 数据库名设置
/// </summary>
static void DataBaseNameConfig()
{
#region Sys
QueryConfig.SetObjectName("Sys_User", typeof(UserEntity), typeof(UserQuery), typeof(AdminUserQuery));
QueryConfig.SetObjectName("Sys_Role", typeof(RoleEntity), typeof(RoleQuery));
QueryConfig.SetObjectName("Sys_UserRole", typeof(UserRoleEntity), typeof(UserRoleQuery));
QueryConfig.SetObjectName("Sys_Authority", typeof(AuthorityEntity), typeof(AuthorityQuery));
QueryConfig.SetObjectName("Sys_AuthorityBindOperation", typeof(AuthorityBindOperationEntity), typeof(AuthorityBindOperationQuery));
QueryConfig.SetObjectName("Sys_AuthorityGroup", typeof(AuthorityGroupEntity), typeof(AuthorityGroupQuery));
QueryConfig.SetObjectName("Sys_AuthorityOperation", typeof(AuthorityOperationEntity), typeof(AuthorityOperationQuery));
QueryConfig.SetObjectName("Sys_AuthorityOperationGroup", typeof(AuthorityOperationGroupEntity), typeof(AuthorityOperationGroupQuery));
QueryConfig.SetObjectName("Sys_UserAuthorize", typeof(UserAuthorizeEntity), typeof(UserAuthorizeQuery));
QueryConfig.SetObjectName("Sys_RoleAuthorize", typeof(RoleAuthorizeEntity), typeof(RoleAuthorizeQuery));
#endregion
}
public async Task <List <T> > QueryAsync <T>(QueryConfig query) where T : DynamoLog
{
switch (query.type)
{
case QueryConfig.QueryType.HashValueOnly:
return(await logsTableOperator.GetAllLogsWithUserId <T>(query.UserId));
case QueryConfig.QueryType.LSI:
return(await logsTableOperator.GetAllLogsWithUserIdAndDate <T>(query.UserId, query.DateMin, query.DateMax));
case QueryConfig.QueryType.GSI:
return(await logsTableOperator.GetAllLogsWithGSI <T>(query.GSIHashValue, query.GSI_Name));
default:
return(null);
}
}
/// <summary>
/// 取出部门列表
/// </summary>
/// <returns></returns>
public ICollection <ModuleQueryDTO> FindList(Pagination pagination, QueryParam queryParam)
{
var list = moduleQueryRepository.GetPaged <ModuleQueryDTO>(pagination, queryParam).ToList();
var dataTypeList = QueryConfig.GetEnumList(typeof(QueryConfig.DataType));
var contrlTypeList = QueryConfig.GetEnumList(typeof(QueryConfig.ControlType));
var defaultValueList = QueryConfig.GetEnumList(typeof(QueryConfig.DateDefalutValueType));
foreach (var m in list)
{
m.DataTypeLabel = dataTypeList.Where(d => d["Id"].ToString() == m.DataType.ToString()).FirstOrDefault()["Name"].ToString();
m.ControlTypeLabel = contrlTypeList.Where(d => d["Id"].ToString() == m.ControlType.ToString()).FirstOrDefault()["Name"].ToString();
if (m.ControlType.ToString() == "2")
{
m.DefaultValue = defaultValueList.Where(d => d["Id"].ToString() == m.DefaultValue).FirstOrDefault()["Name"].ToString();
}
}
return(list);
}
public ActionResult Index()
{
try
{
QueryConfig queries = _reportService.GetQueries();
ViewBag.Queries = queries.GetQueries();
ViewBag.fylker = _registerService.GetFylker();
ViewBag.kommuner = _registerService.GetKommuner();
ViewBag.selectedAreas = new string[] {};
}
catch (Exception ex)
{
Log.Error(ex);
return(View("Error"));
}
return(View());
}
public void Test_get_query_config_by_name(string queryName, bool expectedResult)
{
//arrange
_gisAppConfig.AddQueryConfigs(FakeData.GetConfigurationData());
//act
QueryConfig config = _gisAppConfig.GetQueryInstance(queryName);
//assert
if (!expectedResult)
{
config.Should().BeNull();
}
else
{
config.Should().NotBeNull();
config.Name.ToLower().Should().Be(queryName.ToLower());
}
}
/// <summary>
/// get object primary key value
/// </summary>
/// <returns></returns>
internal Dictionary <string, dynamic> GetPrimaryKeyValues()
{
var primaryKeys = QueryConfig.GetPrimaryKeys(typeof(T));
if (primaryKeys == null || primaryKeys.Count <= 0)
{
return(new Dictionary <string, dynamic>(0));
}
Dictionary <string, dynamic> values = new Dictionary <string, dynamic>(primaryKeys.Count);
foreach (var key in primaryKeys)
{
if (valueDic.ContainsKey(key))
{
values.Add(key, valueDic[key]);
}
}
return(values);
}
/// <summary>
/// get has modifed values
/// </summary>
/// <returns>values</returns>
internal Dictionary <string, dynamic> GetModifyValues()
{
if (_oldEntityData == null || _oldEntityData.PropertyValues == null)
{
return(valueDic);
}
Dictionary <string, dynamic> modifyValues = new Dictionary <string, dynamic>(valueDic.Count);
var oldValues = _oldEntityData.PropertyValues;
var versionField = QueryConfig.GetVersionField(typeof(T));
foreach (var valueItem in valueDic)
{
if (valueItem.Key != versionField && (!oldValues.ContainsKey(valueItem.Key) || oldValues[valueItem.Key] != valueItem.Value))
{
modifyValues.Add(valueItem.Key, valueItem.Value);
}
}
return(modifyValues);
}
/// <summary>
/// Modify Objects
/// </summary>
/// <param name="datas">datas</param>
protected async Task ModifyAsync(params ET[] datas)
{
Type entityType = typeof(ET);
var keys = QueryConfig.GetPrimaryKeys(entityType);
if (keys.IsNullOrEmpty())
{
throw new Exception(string.Format("Type:{0} is not set primary keys", entityType.FullName));
}
foreach (var data in datas)
{
IQuery query = QueryFactory.Create();
foreach (var key in keys)
{
query.Equal(key, data.GetPropertyValue(key));
}
UnitOfWork.UnitOfWork.RegisterCommand(await dataAccess.ModifyAsync(data, query).ConfigureAwait(false));
}
}
public async Task Handler_Finds_Single_Item_By_Single_Predicate_DateTime_Property_GreaterThanOrEqual()
{
var handler = _serviceProvider
.GetService <IQueryConfigHandler <QueryConfig> >();
var config = new QueryConfig {
QueryBy = new List <QueryPredicate>()
};
var p1 = new QueryPredicate
{
ColumnCode = "Start",
CompareWith = QueryPredicateConnective.Or,
Values = new List <QueryPredicateValue>()
};
p1.Values.Add(new QueryPredicateValue {
Value = "2020-01-15", CompareUsing = QueryPredicateComparison.GreaterThanOrEqual
});
config.QueryBy.Add(p1);
var source = new List <TestItem>
{
new TestItem {
Name = "Colin", Id = 1, Start = new DateTime(2020, 1, 1)
},
new TestItem {
Name = "Brendan", Id = 2, Start = new DateTime(2020, 2, 1)
},
new TestItem {
Name = "Lindsay", Id = 3, Start = new DateTime(2020, 1, 15)
}
};
var result = await handler
.HandleAsync <TestItem, QueryResult <TestItem> >(config, source.AsQueryable())
.ConfigureAwait(false);
Assert.NotNull(result);
Assert.Equal(2, result.Total);
Assert.NotEmpty(result.Payload);
}
