private QueryDto GetSearchConditon(string folderPath)
{
if (!Directory.Exists(folderPath))
{
MessageBox.Show("不是有效的目录", "提示");
return(null);
}
//查询条件
QueryDto queryDto = new QueryDto();
queryDto.FileName = this.tb_fileName.Text;
if (cb_openkey.Checked)
{
queryDto.OpenKey = true;
queryDto.ContentKey = tb_contentkey.Text;
}
else
{
queryDto.OpenKey = false;
queryDto.ContentKey = "";
}
if (cb_fileOn.Checked)
{
queryDto.StartFileOn = dt_start.Value;
queryDto.EndFileOn = dt_end.Value;
}
return(queryDto);
}
/// <inheritdoc />
public virtual Task <TEntityDto> GetOne(QueryDto <TEntityFilterDto> queryDto,
CancellationToken cancellationToken = default)
{
return(QueryDtoMapper
.QueryDto(queryDto)
.MapQueryOneAsync(cancellationToken: cancellationToken));
}
public List <StatisticsDto> GetStatistics(QueryDto filter)
{
var query = from a in _dbContext.Orders
join b in _dbContext.Order_Foods
on a.Id equals b.OrderId
join c in _dbContext.FoodMenus
on b.FoodId equals c.Id
select new
{
a.CreateTime,
c.Name,
b.Count,
c.Price
};
if (filter.Start != null)
{
query = query.Where(x => x.CreateTime >= filter.Start);
}
if (filter.End != null)
{
query = query.Where(x => x.CreateTime <= filter.End);
}
var data = query.ToList();
var list = data.GroupBy(x => x.Name).Select(x => new StatisticsDto
{
FoodName = x.Key,
Count = x.Sum(y => y.Count),
Price = x.Sum(y => y.Price)
});
return(list.ToList());
}
/// <summary>
/// 获取统计报表
/// </summary>
/// <param name="dateRange">日期范围</param>
/// <param name="startDate">开始日期，仅当dateRange为0时才生效（即其他）</param>
/// <param name="endDate">结束日期，仅当dateRange为0时才生效（即其他）</param>
/// <returns></returns>
public List <StatItemDto> GetWorkReport(DateRangeEnum dateRange, string startDate, string endDate)
{
if (!QueryDto.CheckDateRange(dateRange, startDate, endDate, out var dateS, out var dateE))
{
return(app.ThrowException <List <StatItemDto> >("日期范围无效", AppExceptionType.ParameterError));
}
var query = GetHouseQuery(false, dateS, dateE);
query = query.Concat(GetMLSHouseQuery(false, dateS, dateE));
query = query.Concat(GetDemandQuery(false, dateS, dateE));
query = query.Concat(GetBrowerQuery(false, dateS, dateE));
query = query.Concat(GetContactTelephoneQuery(false, dateS, dateE));
query = query.Concat(GetContactCallMeQuery(false, dateS, dateE));
query = query.Concat(GetShareQuery(false, dateS, dateE));
query = query.Concat(GetVisitUserQuery(false, dateS, dateE));
query = query.Concat(GetConcernedQuery(false, dateS, dateE));
// todo djl 补充其他指标
var list = query.Select(x => new StatItemDto {
Type = (StatItemTypeEnum)x.ID, Value = x.Value
}).ToList();
// 联络指标
var telephoneValue = list.FirstOrDefault(x => x.Type == StatItemTypeEnum.Telephone)?.Value ?? 0;
var callMeValue = list.FirstOrDefault(x => x.Type == StatItemTypeEnum.CallMe)?.Value ?? 0;
list.Insert(4, new StatItemDto()
{
Type = StatItemTypeEnum.Contact, Value = (telephoneValue + callMeValue)
});
return(list);
}
public HttpResponseMessage GetFarms([FromUri] QueryDto queryDto)
{
if (ModelState.IsValid)
{
try
{
ScoreDoc[] hits;
try
{
hits = Query(queryDto);
}
catch (StorageException)
{
//AzureDirectory had an error, recreate indexer and try again
hits = Query(queryDto);
}
List <FarmLocationDto> result = ConvertHitsToFarmLocationDtos(hits);
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
catch (ParseException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
/// <inheritdoc />
public virtual Task <IQueryResultDto <TEntityDto> > GetAll(QueryDto <TEntityFilterDto> queryDto,
CancellationToken cancellationToken = default)
{
return(QueryDtoMapper
.QueryDto(queryDto)
.MapQueryAsync(cancellationToken: cancellationToken));
}
/// <summary>
/// 查询
/// </summary>
/// <param name="request"></param>
public static QueryResponse Query(QueryDto request)
{
request.sign = EncryptUtil.GetSign(request);
var response = WebUtils.HttpPost <QueryDto, QueryResponse>("http://118.178.35.56/query", request);
return(response);
}
public ActionResult DownloadViewData(string para)
{
QueryDto dto = JsonConvert.DeserializeObject <QueryDto>(HttpUtility.UrlDecode(para));
var viewValue = ModuleSv.GetViewTable(dto);
var dt = viewValue.ViewTable;
var colNames = new List <string>();
foreach (var columList in viewValue.DisplayColumList)
{
if (columList.IsDisplayEnable)
{
dt.Columns[columList.DisplayColumn].ColumnName = columList.Name;
colNames.Add(columList.Name);
}
}
var dt1 = dt.Clone();
foreach (DataColumn dc in dt1.Columns)
{
if (!colNames.Contains(dc.ColumnName))
{
dt.Columns.Remove(dc.ColumnName);
}
}
MemoryStream stream = (new ExcelManager()).ExportToStream(dt, true);
stream.Seek(0, SeekOrigin.Begin);
return(File(stream, "application/vnd.ms-excel", DateTime.Now.ToString("yyyyMMddhhmmss") + ".xls"));
}
/// <summary>
/// Query view.
/// </summary>
/// <param name="queryDto">Query information data transfer object.</param>
/// <returns>Returns view of the input query.</returns>
public IActionResult Query([Bind("QueryString, Facets")] QueryDto queryDto)
{
if (queryDto == null)
{
queryDto = new QueryDto();
}
queryDto.Results = new List <AnonymousObject>();
if (queryDto.Facets == null || queryDto.Facets.Count == 0)
{
queryDto.Facets = this.GetInitialFacets();
}
else if (this.HasSelected(queryDto.Facets, out List <FacetDto> facetsWithSelected))
{
queryDto.Results = this.PerformFacet(facetsWithSelected);
}
if (!string.IsNullOrWhiteSpace(queryDto.QueryString))
{
queryDto.Results = this.CombineFacetQuery(queryDto.Results, this.PerformQuery(queryDto.QueryString));
}
return(this.View(queryDto));
}
public async Task <IEnumerable <object> > GetData(QueryDto query)
{
var clazz = Type.GetType(Constants.NAMESPACE_FOR_ENTITIES + query.Entity + Constants.BINARY_FOR_ENTITIES);
dynamic param = Activator.CreateInstance(clazz);
return(await GetData(param, query));
}
private async Task <IEnumerable <T> > GetData <T>(T param, QueryDto query) where T : BaseModel
{
IQueryable <T> entities = GetDbSet(param);
IOrderedQueryable orderedQueryable;
foreach (var criteria in query.Criterias)
{
entities = AddCriteria(param, entities, criteria);
}
if (query.OrderBy != null)
{
orderedQueryable = OrderBy(param, entities, query.OrderBy);
}
else if (query.OrderByDescending != null)
{
orderedQueryable = OrderByDescending(param, entities, query.OrderByDescending);
}
else
{
orderedQueryable = entities.OrderBy(x => x.Id);
}
return(await entities.ToArrayAsync());
}
public FriendshipRequestSpecification(QueryDto query, string requesteeId = null, bool pendingOnly = false)
{
var criteria = query.Criteria?.Select(kvp => new Criteria(kvp.Key, "FriendshipRequests", kvp.Value));
base.AddCriteria(criteria);
if (requesteeId != null)
{
var requesterCriteria = new Criteria("Requestee", "FriendshipRequests", requesteeId);
base.AddCriteria(new[] { requesterCriteria });
}
if (pendingOnly)
{
base.AddExcludeCriteria(new[] {
new Criteria("Outcome", "FriendshipRequests", "accepted"),
new Criteria("Outcome", "FriendshipRequests", "rejected")
});
}
if (query.Pagination != null)
{
base.AddPaging(query.Pagination.Limit, query.Pagination.Offset);
}
}
public async Task <IActionResult> GetChats(QueryDto query)
{
var authHelper = new AuthHelperBuilder()
.AllowSystem()
.RequirePermissions("users.view_others")
.Build();
if (!authHelper.Authorize(_identityService))
{
return(Unauthorized());
}
if (!ModelState.IsValid)
{
return(BadRequest(new ErrorResponse(ModelState)));
}
var userId = _identityService.GetUserIdentity();
var(chats, total) = userId == AuthorizationConstants.System ?
await _chatQueries.GetChats(new ChatSpecification(query)) :
await _chatQueries.GetChatsForOwnerOrMemberAsync(new ChatSpecification(query), userId);
return(Ok(new ArrayResponse <ChatDto>(chats, total)));
}
public async Task <ActionResult> Cuotas(QueryDto query)
{
var Rates = await ConsumeApi.ConsumeApi
.GetInstance(_configuration)
.CallApiGETAsync <AgeRageDto>("api/agerate");
var age = Calculations.CalculateAge(query.DateOfBirth);
var higher = Rates.Where(x => x.Age > age).ToList();
var less = Rates.Where(x => x.Age <= age).ToList();
ViewBag.Months = await ConsumeApi.ConsumeApi
.GetInstance(_configuration)
.CallApiGETAsync <MonthDto>("api/month");
if (higher.Count != 0 && less.Count != 0)
{
query.ConsultationDate = DateTime.Now;
var request = await ConsumeApi.ConsumeApi
.GetInstance(_configuration).CallApiPOSTAsync <QueryDto>("api/Calculation", query);
if (request == "InternalServerError")
{
ViewBag.Error = "Error en el servidor.";
return(View(query));
}
else if (request == "NotFound")
{
ViewBag.Error = "El recurso que esta solicitando no se a encontrado.";
return(View(query));
}
else if (request == "BadRequest")
{
ViewBag.Error = "Peticion incorrecta.";
return(View());
}
else if (request == "NoContent")
{
ViewBag.Successful = "Cálculo exitoso";
return(View());
}
}
if (higher.Count == 0)
{
ViewBag.Error = "Favor pasar por una de nuestras sucursales para evaluar su caso.";
}
else if (less.Count == 0)
{
ViewBag.Error = "Lo sentimos aun no cuenta con la edad para solicitar este producto";
}
return(View(query));
}
private static SubscriptionQuery ParseQuery(string id, QueryDto query)
{
var queryObject = query.ToQuery <SubscriptionQuery>(true);
queryObject.UserId = id;
return(queryObject);
}
/// <summary>
/// 分页查询
/// </summary>
/// <param name="model">分页查询实体</param>
/// <returns></returns>
public virtual PageResult <List <TEntity> > QueryableByPage(QueryDto model)
{
PageResult <List <TEntity> > result = new PageResult <List <TEntity> >();
var page = _repository.QueryableByPage(model.ConditionalModels, model.order, model.page, model.limit);
result.data = page.Item1;
result.count = page.Item2;
return(result);
}
/// <inheritdoc cref="IQueryDtoMapper{TEntity,TResultDto}.QueryDto{TFilter}" />
/// />
public virtual IQueryDtoMapper <TEntity, TResultDto> QueryDto <TFilter>(QueryDto <TFilter> queryDto, bool updateQuery)
where TFilter : class
{
_queryDto = queryDto;
MapFilter <TFilter>(updateQuery);
return(this);
}
public UpdateQueryCommand([NotNull] QueryDto query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
Query = query;
}
public Response <IEnumerable <Operations> > Query([FromBody] QueryDto querydto)
{
return(Extension.Try <IEnumerable <Operations> >(() =>
{
var Restul = this.serviceCalculators.Query(querydto.Id);
return Restul;
}, _logger));
}
public void SetQuery()
{
var mockQuery = new Mock <IQueryBase>();
var q = new QueryDto(2, 20);
q.SetQuery(mockQuery.Object);
mockQuery.Verify(m => m.SetParam(QueryDto.PARAM_OFFSET, DbType.Int32, 40));
mockQuery.Verify(m => m.SetParam(QueryDto.PARAM_LIMIT, DbType.Int32, 20));
}
public void SetPagination_ShouldSetOffset()
{
var q = new QueryDto();
q.SetPagination(2, 20);
Assert.AreEqual(2, q.Page);
Assert.AreEqual(20, q.PerPage);
Assert.AreEqual(40, q.Offset);
}
public async Task <IActionResult> GetMedias(string appId, [FromQuery] QueryDto q)
{
var medias = await mediaStore.QueryAsync(appId, q.ToQuery <MediaQuery>(), HttpContext.RequestAborted);
var response = new ListResponseDto <MediaDto>();
response.Items.AddRange(medias.Select(x => MediaDto.FromDomainObject(x, appId, urlGenerator)));
response.Total = medias.Total;
return(Ok(response));
}
public async Task <IActionResult> GetTopics(string appId, [FromQuery] QueryDto q)
{
var topics = await topicStore.QueryAsync(appId, q.ToQuery <TopicQuery>(), HttpContext.RequestAborted);
var response = new ListResponseDto <TopicDto>();
response.Items.AddRange(topics.Select(TopicDto.FromTopic));
response.Total = topics.Total;
return(Ok(response));
}
public async Task <IActionResult> GetEvents(string appId, [FromQuery] QueryDto q)
{
var topics = await eventStore.QueryAsync(appId, q.ToQuery <EventQuery>(), HttpContext.RequestAborted);
var response = new ListResponseDto <EventDto>();
response.Items.AddRange(topics.Select(x => EventDto.FromDomainObject(x, App)));
response.Total = topics.Total;
return(Ok(response));
}
public async Task <IActionResult> GetSubscriptions(string appId, string id, [FromQuery] QueryDto q)
{
var subscriptions = await subscriptionStore.QueryAsync(appId, ParseQuery(id, q), HttpContext.RequestAborted);
var response = new ListResponseDto <SubscriptionDto>();
response.Items.AddRange(subscriptions.Select(SubscriptionDto.FromDomainObject));
response.Total = subscriptions.Total;
return(Ok(response));
}
public async Task <IActionResult> GetContentsPost(string app, string schema, [FromBody] QueryDto query)
{
var contents = await contentQuery.QueryAsync(Context, schema, query?.ToQuery() ?? Q.Empty, HttpContext.RequestAborted);
var response = Deferred.AsyncResponse(() =>
{
return(ContentsDto.FromContentsAsync(contents, Resources, Schema, contentWorkflow));
});
return(Ok(response));
}
public async Task <IActionResult> GetTemplates(string appId, [FromQuery] QueryDto q)
{
var templates = await templateStore.QueryAsync(appId, q.ToQuery <TemplateQuery>(), HttpContext.RequestAborted);
var response = new ListResponseDto <TemplateDto>();
response.Items.AddRange(templates.Select(TemplateDto.FromDomainObject));
response.Total = templates.Total;
return(Ok(response));
}
private Task <IQueryResultDto <UserIpDto> > GetResultAsync(IQueryDtoMapper <UserIp, UserIpDto> mapper,
UserIpFilterDto filter)
{
var queryDto = new QueryDto <UserIpFilterDto>
{
Filter = filter,
WithCount = true
};
return(mapper.QueryDto(queryDto).MapQueryAsync());
}
public async Task <IActionResult> GetAssetsPost(string app, [FromBody] QueryDto query)
{
var assets = await assetQuery.QueryAsync(Context, query?.ParentId, query?.ToQuery() ?? Q.Empty, HttpContext.RequestAborted);
var response = Deferred.Response(() =>
{
return(AssetsDto.FromAssets(assets, Resources));
});
return(Ok(response));
}
public async Task <IActionResult> GetLogs(string appId, [FromQuery] QueryDto q)
{
var medias = await logStore.QueryAsync(appId, q.ToQuery <LogQuery>(true), HttpContext.RequestAborted);
var response = new ListResponseDto <LogEntryDto>();
response.Items.AddRange(medias.Select(LogEntryDto.FromDomainObject));
response.Total = medias.Total;
return(Ok(response));
}
