public async Task <T[]> QueryDataAsync <T>(string soql, CancellationToken token = default)
{
try
{
token.ThrowIfCancellationRequested();
_logger?.LogDebug($"Running SOQL query: {soql}");
HttpRequestMessage request;
HttpResponseMessage response;
QueryResultModel <T> responseResult = default;
bool queryComplete = true;
T[] result = null;
do
{
request = _messageService.BuildQueryMessage(queryComplete ? soql : responseResult.NextRecordsUrl, !queryComplete);
response = await _client.SendAsync(request, token).ConfigureAwait(false);
responseResult = await _messageService.ProcessResponseAsync <QueryResultModel <T> >(response, token).ConfigureAwait(false);
queryComplete = responseResult.Done;
if (!queryComplete || result != null)
{
result ??= new T[responseResult.TotalSize];
Array.Copy(responseResult.Records, 0, result, FindFirstNull(result), responseResult.Records.Length);
}
} while (!queryComplete);
return(result ?? responseResult.Records);
}
catch (OperationCanceledException)
{
return(await Task.FromCanceled <T[]>(token).ConfigureAwait(false));
}
}
public void SelectQueryRecord()
{
QueryTable table = QueryTable.Instance(new QueryDataAccess());
QueryResultModel expectedResult = new QueryResultModel()
{
QueryID = 2,
CustomerUUID = "CustUUID02",
Frequency = "Freq02",
PriceLimit = "PriceLimit02",
Category = "Cat02",
CategoryID = "CatID02"
};
QueryResultModel result = table.SelectRecord(new SelectQueryModel()
{
CustomerUUID = "CustUUID02"
});
Assert.AreEqual(expectedResult.QueryID, result.QueryID);
Assert.AreEqual(expectedResult.CustomerUUID, result.CustomerUUID);
Assert.AreEqual(expectedResult.Frequency, result.Frequency);
Assert.AreEqual(expectedResult.PriceLimit, result.PriceLimit);
Assert.AreEqual(expectedResult.Category, result.Category);
Assert.AreEqual(expectedResult.CategoryID, result.CategoryID);
}
public async Task <IResultModel> Query(UserQueryModel model)
{
var result = new QueryResultModel <UserEntity>
{
Rows = _userRepository.Query(p => p.Name == model.Name).ToList(),
Total = model.TotalCount
};
var db = _roleRepository.DbContext;
foreach (var item in result.Rows)
{
item.Roles = (from user in db.Users
join userRole in db.UserRoles on user.Id equals userRole.UserId into t1
from tb1 in t1.DefaultIfEmpty()
join role in db.Roles on tb1.RoleId equals role.Id into t2
from tb2 in t2.DefaultIfEmpty()
select new OptionResultModel
{
Value = tb2.Id,
Label = tb2.Name
})
.ToList();
}
return(ResultModel.Success(result));
}
/// <summary>
/// Sets internal rows to query result
/// </summary>
/// <param name="resultModel"></param>
/// <param name="internalModel"></param>
public static void SetInternalRows(this QueryResultModel resultModel, QueryResultModel internalModel, List <string> groupBys)
{
foreach (var row in resultModel.Rows)
{
var internalRows = internalModel.Rows.Where(internalRow =>
{
for (int columnNumber = 0; columnNumber < row.Values.Count; columnNumber++)
{
if (!groupBys.Contains(resultModel.ColumnHeaders[columnNumber].Name))
{
continue;
}
if (row.Values[columnNumber] != internalRow.Values[columnNumber])
{
return(false);
}
}
return(true);
}).ToList();
row.Internal = new QueryResultModel
{
ColumnHeaders = internalModel.ColumnHeaders,
Rows = internalRows
};
}
}
public JsonResult QueryContractBasicInfo(String key, String value)
{
var result = new QueryResultModel();
var contractBasicInfoService = this.GetService <IContractBasicInfoService>();
result.Data = contractBasicInfoService.QueryContractBasicInfo(key, value);
return(Json(result));
}
public JsonResult QueryContractBasicInfoWithTotalActualPayment(int PageIndex, int PageSize)
{
var result = new QueryResultModel();
var contractBasicInfoService = this.GetService <IContractBasicInfoService>();
result.Data = contractBasicInfoService.QueryContractBasicInfoWithTotalActualPayment(PageIndex, PageSize);
result.Total = contractBasicInfoService.getTotalCount();
return(Json(result));
}
public async Task<IResultModel> Query(ProjectQueryModel model)
{
var result = new QueryResultModel<ProjectEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return ResultModel.Success(result);
}
/// <summary>
/// 获取所有分类数据
/// </summary>
/// <param name="categoryId"></param>
/// <returns></returns>
public async Task <IResultModel> GetList()
{
var result = new QueryResultModel <CategoryEntity>
{
Rows = await _repository.GetList()
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> QueryBySameOrg(UserQueryModel model)
{
var result = new QueryResultModel <UserEntity>
{
Rows = await _userRepository.QueryBySameOrg(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(ImportTemplateQueryModel model)
{
var result = new QueryResultModel <ImportTemplateEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public JsonResult loadPanel(Guid ContractGUID)
{
var result = new QueryResultModel();
int totalcount = 0;
var actualPaymentService = this.GetService <IActualPaymentService>();
result.Data = actualPaymentService.QueryActualPaymentByContractGuid(ContractGUID);
result.Total = totalcount;
return(Json(result));
}
public async Task <IResultModel> Query(UserLatestSelectQueryModel model)
{
var result = new QueryResultModel <UserLatestSelectEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(OnlineModuleQueryModel model)
{
var result = new QueryResultModel <OnlineModuleEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(ModuleInfoQueryModel model)
{
var result = new QueryResultModel <ModuleInfo>();
var paging = model.Paging();
result.Rows = await _repository.Query(paging, model.Name, model.Code);
result.Total = paging.TotalCount;
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(AttachmentQueryModel model)
{
var result = new QueryResultModel <AttachmentEntity>
{
Rows = await _attachmentRepository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(ModelPropertyQueryModel model)
{
var result = new QueryResultModel <ModelPropertyEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(DictionaryGroupQueryModel model)
{
var result = new QueryResultModel <DictionaryGroupEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(UserEducationHistoryQueryModel model)
{
var result = new QueryResultModel <UserEducationHistoryEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(PermissionQueryModel model)
{
var queryResult = new QueryResultModel <PermissionEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(queryResult));
}
public async Task <IResultModel> QueryLogin(LoginLogQueryModel model)
{
var result = new QueryResultModel <LoginLogEntity>
{
Rows = await _loginLogRepository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(ResourceFilterQueryModel model)
{
var result = new QueryResultModel <ResourceFilterEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(MenuQueryModel model)
{
var queryResult = new QueryResultModel <MenuEntity>
{
Rows = await _menuRepository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(queryResult));
}
public async Task <IResultModel> Query(JobQueryModel model)
{
var result = new QueryResultModel <JobEntity>
{
Rows = await _jobRepository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(ButtonQueryModel model)
{
var result = new QueryResultModel <Button>();
var paging = model.Paging();
result.Rows = await _buttonRepository.Query(paging, model.MenuId, model.Name);
result.Total = paging.TotalCount;
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(PermissionQueryModel model)
{
var queryResult = new QueryResultModel <Permission>();
var paging = model.Paging();
queryResult.Rows = await _permissionRepository.Query(paging, model.ModuleCode, model.Name, model.Controller, model.Action);
queryResult.Total = paging.TotalCount;
return(ResultModel.Success(queryResult));
}
public IResultModel Query(string moduleCode)
{
var list = _collection.GetByModule(moduleCode).ToList();
var result = new QueryResultModel <CacheKeyDescriptor>
{
Rows = list,
Total = list.Count
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(ConfigQueryModel model)
{
model.Type = ConfigType.Custom;
var result = new QueryResultModel <ConfigEntity>
{
Rows = await _repository.Query(model),
Total = model.TotalCount
};
return(ResultModel.Success(result));
}
public ActionResult DailyPurchase()
{
List <CustomerResultModel> customerList = customerTable.SelectAllRecords();
foreach (CustomerResultModel customer in customerList)
{
//Get customer's query prefrences
QueryResultModel queryPref = queryTable.SelectRecord(new SelectQueryModel()
{
CustomerUUID = customer.CustomerUUID
});
//Ask Ebay for items.
SearchPagedCollection itemCollection = BrowseAPI.ItemSummarySearch(queryPref.CategoryID, queryPref.PriceLimit);
try
{
//There were no items found for this query
if (itemCollection.itemSummaries.Length == 0)
{
continue;
}
//Get customer's address data
AddressResultModel customerAddress = addressTable.SelectRecord(new SelectAddressModel()
{
CustomerUUID = customer.CustomerUUID
});
//Initiate order with a randomly chosen index from itemCollection's itemSummaries
Random rand = new Random();
int itemIndex = rand.Next(itemCollection.itemSummaries.Length);
CheckoutSessionResponse response = OrderAPI.InitiateGuestCheckoutSession(itemCollection.itemSummaries[itemIndex].itemId, customer, customerAddress);
InsertCustomerOrderModel customerOrder = new InsertCustomerOrderModel()
{
CustomerUUID = customer.CustomerUUID,
CheckoutSessionID = response.checkoutSessionId,
ExpirationDate = response.expirationDate,
ImageURL = itemCollection.itemSummaries[itemIndex].image.imageUrl,
PurchasePrice = response.pricingSummary.total.value,
Title = response.lineItems[0].title
};
NonQueryResultModel orderResult = customerOrderTable.InsertRecord(customerOrder);
}
catch (Exception e)
{
}
}
return(Json(new { result = "Daily Purchases Complete" }));
}
public IResultModel Query(string moduleCode)
{
var list = _collection.Where(m => m.ModuleCode.EqualsIgnoreCase(moduleCode)).ToList();
var result = new QueryResultModel <CacheKeyDescriptor>
{
Rows = list,
Total = list.Count
};
return(ResultModel.Success(result));
}
public async Task <IResultModel> Query(MenuQueryModel model)
{
var queryResult = new QueryResultModel <Menu>();
var paging = model.Paging();
queryResult.Rows = await _menuRepository.Query(paging, model.Name, model.RouteName, model.ParentId);
queryResult.Total = paging.TotalCount;
return(ResultModel.Success(queryResult));
}
