public async Task <GetTehnicians> GetTehniciansAsync(QueryResource query)
{
var tehnicians = await this.context.Tehnicians.ToListAsync();
if (query.FacilityId != null)
{
tehnicians = tehnicians.FindAll(d => d.FacilityId.ToString() == query.FacilityId);
}
if (query.UserId != 0)
{
tehnicians = tehnicians.FindAll(d => d.UserId == query.UserId);
}
if (query.Page <= 0)
{
query.Page = 1;
}
if (query.PageSize <= 0)
{
query.PageSize = tehnicians.Count();
}
var result = new GetTehnicians();
result.ItemsNumber = tehnicians.Count();
tehnicians = tehnicians.Skip((query.Page - 1) * query.PageSize).Take(query.PageSize).ToList();
result.Tehnicians = tehnicians;
return(result);
}
public async Task <GetTehnicianShifts> GetTehnicianShiftsAsync(QueryResource query)
{
var shifts = await this.context.TehniciansShifts.Include(s => s.Tehnician).ToListAsync();
var result = new GetTehnicianShifts();
if (query.TehnicianId.HasValue)
{
shifts = shifts.FindAll(s => s.TehnicianId == query.TehnicianId);
}
if (query.FacilityId != null)
{
shifts = shifts.FindAll(s => s.Tehnician.FacilityId == int.Parse(query.FacilityId));
}
shifts = shifts.OrderBy(s => s.Date).ToList();
if (query.Page <= 0)
{
query.Page = 1;
}
if (query.PageSize <= 0)
{
query.PageSize = shifts.Count();
}
result.ItemsNumber = shifts.Count();
shifts = shifts.Skip((query.Page - 1) * query.PageSize).Take(query.PageSize).ToList();
result.TehnicianShifts = shifts;
return(result);
}
/// <summary>
/// Gets a paginated list of reservations.
/// </summary>
/// <param name="queryResource">Paginating, sorting and searching query parameters.</param>
/// <returns>Paginated list of reservations.</returns>
public PagedResponse <List <ReservationResource> > ListAsync(QueryResource queryResource)
{
try
{
if (queryResource == null)
{
throw new ArgumentNullException(nameof(queryResource));
}
var reservations = _reservationRepository.DbSet()
.Include(r => r.Contact)
.Include(r => r.Place)
.Select(r => r);
if (!string.IsNullOrWhiteSpace(queryResource.SearchBy))
{
reservations = reservations.Where(c =>
c.Contact.Name.ToLower().Contains(queryResource.SearchBy.Trim().ToLower()) ||
c.Place.Name.ToLower().Contains(queryResource.SearchBy.Trim().ToLower()));
}
reservations = reservations.ApplyOrderToReservation(queryResource.SortOrder);
var pagedResponse = PagedResponse <Reservation> .ToPagedResponse(
reservations, queryResource.PageNumber, queryResource.PageSize);
return(_mapper.Map <PagedResponse <List <ReservationResource> > >(pagedResponse));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(new PagedResponse <List <ReservationResource> >(
ex.Message, queryResource.PageNumber, queryResource.PageSize));
}
}
public async Task <QueryResultResource <TicketResource> > GetTickets(QueryResource filterResource)
{
var filter = mapper.Map <QueryResource, ModelQuery>(filterResource);
var queryResult = await repository.GetTickets(filter);
return(mapper.Map <QueryResult <Ticket>, QueryResultResource <TicketResource> >(queryResult));
}
public async Task <QueryResultResource <EnrollmentResource> > GetEnrollments(QueryResource queryResource)
{
var query = mapper.Map <QueryResource, Query>(queryResource);
var queryResult = await enrollmentRepository.GetEnrollments(query);
return(mapper.Map <QueryResult <Enrollment>, QueryResultResource <EnrollmentResource> >(queryResult));
}
public async Task <QueryResultResource <RoleResource> > GetAll(QueryResource queryResource)
{
var query = mapper.Map <QueryResource, Query>(queryResource);
var queryResult = await repository.GetRoles(query);
return(mapper.Map <QueryResult <ApplicationRole>, QueryResultResource <RoleResource> >(queryResult));
}
public async Task <QueryResult <GetGroupResource> > GetGroups(QueryResource filterResource)
{
var filter = mapper.Map <QueryResource, ModelQuery>(filterResource);
var queryResult = await repository.GetGroups(filter);
return(queryResult);
}
public async Task <IEnumerable <Doctor> > GetDoctorsAsync(QueryResource query)
{
var doctors = await this.context.Doctors
.Include(d => d.Title)
.Include(d => d.Facility)
.ToListAsync();
if (query.FacilityId != null)
{
doctors = doctors.FindAll(d => d.FacilityId.ToString() == query.FacilityId);
}
if (query.UserId != 0)
{
doctors = doctors.FindAll(d => d.UserId == query.UserId);
}
if (query.Title != null)
{
doctors = doctors.FindAll(d => d.Title.Name == query.Title);
}
doctors = doctors.OrderBy(d => d.Name).ToList();
return(doctors);
}
/// <summary>
/// Gets a paginated list of contacts.
/// </summary>
/// <param name="queryResource">Paginating, sorting and searching query parameters.</param>
/// <returns>Paginated list of contacts.</returns>
public PagedResponse <List <ContactResource> > ListAsync(QueryResource queryResource)
{
try
{
if (queryResource == null)
{
throw new ArgumentNullException(nameof(queryResource));
}
var contacts = _contactRepository.DbSet();
if (!string.IsNullOrWhiteSpace(queryResource.SearchBy))
{
contacts = contacts.Where(
c => c.Name.ToLower().Contains(queryResource.SearchBy.Trim().ToLower()));
}
contacts = contacts.ApplyOrder(queryResource.SortOrder);
var pagedResponse = PagedResponse <Contact> .ToPagedResponse(
contacts, queryResource.PageNumber, queryResource.PageSize);
return(_mapper.Map <PagedResponse <List <ContactResource> > >(pagedResponse));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(new PagedResponse <List <ContactResource> >(
ex.Message, queryResource.PageNumber, queryResource.PageSize));
}
}
public async Task <IEnumerable <Appointment> > GetAppointmentsAsync(QueryResource query)
{
var appointments = await context.Appointments.Include(a => a.Time).ToListAsync();
if (query.DoctorId.HasValue)
{
appointments = appointments.FindAll(a => a.DoctorId == query.DoctorId);
}
if (query.Date.HasValue)
{
appointments = appointments.FindAll(a => a.Date == query.Date);
}
if (query.PatientId != 0)
{
{ appointments = appointments.FindAll(a => a.PatientId == query.PatientId); }
}
else
{ // Vraca samo appointment-e koji su dostupni za zakzaivanje
appointments = appointments.FindAll(a => a.PatientId == 0);
}
appointments = appointments.OrderBy(a => a.Time.AppointmentTime).ToList();
return(appointments);
}
public async Task <QueryResultResource <TagResource> > GetTags(QueryResource queryResource)
{
var query = mapper.Map <QueryResource, Query>(queryResource);
var queryResult = await repository.GetTags(query);
return(mapper.Map <QueryResult <Tag>, QueryResultResource <TagResource> >(queryResult));
}
public async Task <QueryResultResource <CategoryResource> > GetCategories(QueryResource queryResource)
{
var query = mapper.Map <QueryResource, Query>(queryResource);
var queryResult = await categoryRepository.GetCategories(query);
return(mapper.Map <QueryResult <Category>, QueryResultResource <CategoryResource> >(queryResult));
}
public async Task <QueryResultResource <GroupResource> > GetGroups(QueryResource queryResource)
{
var query = mapper.Map <QueryResource, Query>(queryResource);
var queryResult = await groupRepository.GetGroups(query);
return(mapper.Map <QueryResult <Group>, QueryResultResource <GroupResource> >(queryResult));
}
private QueryResourceRequest CreateRequest(
IEnumerable <KeyValuePair <string, StringValues> > queryParams,
QueryResource resourceType,
string studyInstanceUid = null,
string seriesInstanceUid = null)
{
return(new QueryResourceRequest(queryParams, resourceType, studyInstanceUid, seriesInstanceUid));
}
public async Task <QueryResultResource <ProjectResource> > GetProjects(QueryResource queryResource)
{
var query = mapper.Map <QueryResource, Query> (queryResource);
var queryResult = await projectRepository.GetProjects(query);
return(mapper.Map <QueryResult <Project>, QueryResultResource <ProjectResource> > (queryResult));
}
public async Task <QueryResultResource <ProductResource> > GetAll(QueryResource queryResource)
{
var queryObject = mapper.Map <QueryResource, Query>(queryResource);
var queryResult = await _productRepository.GetAll(queryObject);
return(mapper.Map <QueryResult <Product>, QueryResultResource <ProductResource> >(queryResult));
}
public virtual async Task <ActionResult <IEnumerable <TResource> > > Query(QueryResource queryResource)
{
if (await IsUnauthorized(Operations.Read))
{
return(Unauthorized());
}
return(await Application.Query(queryResource));
}
public async Task <QueryResultResource <BoardResource> > GetBoards(QueryResource queryResource)
{
var query = mapper.Map <QueryResource, Query>(queryResource);
var queryResult = await boardRepository.GetBoards(query);
return(mapper.Map <QueryResult <Board>, QueryResultResource <BoardResource> >(queryResult));
}
public async Task <QueryResultResource <LecturerResource> > GetLecturers(QueryResource queryResource)
{
var query = mapper.Map <QueryResource, Query>(queryResource);
var queryResult = await lecturerRepository.GetLecturers(query);
return(mapper.Map <QueryResult <Lecturer>, QueryResultResource <LecturerResource> >(queryResult));
}
public async Task <QueryResultResource <LecturerResource> > GetLecturersByMajor(int id)
{
QueryResource queryResource = new QueryResource();
var query = mapper.Map <QueryResource, Query>(queryResource);
var queryResult = await lecturerRepository.GetLecturersByMajor(id, query);
return(mapper.Map <QueryResult <Lecturer>, QueryResultResource <LecturerResource> >(queryResult));
}
public async Task <QueryResultResource <ProjectResource> > GetProjectsByMajor(int id)
{
QueryResource queryResource = new QueryResource();
var query = mapper.Map <QueryResource, Query> (queryResource);
var queryResult = await projectRepository.GetProjectsByMajor(id, query);
return(mapper.Map <QueryResult <Project>, QueryResultResource <ProjectResource> > (queryResult));
}
public async Task <QueryResultResource <ProjectResource> > GetSimilarProjects([FromBody] ProjectResource projectResource)
{
QueryResource queryResource = new QueryResource();
var query = mapper.Map <QueryResource, Query> (queryResource);
var queryResult = await projectRepository.GetSimilarProjects(query, projectResource);
return(mapper.Map <QueryResult <Project>, QueryResultResource <ProjectResource> > (queryResult));
}
public async Task <QueryResultResource <ArtworkResource> > GetCommunityArt([FromQuery] QueryResource query)
{
var artworkQuery = mapper.Map <QueryResource, Query>(query);
var queryResult = await artworkService.CommunityArtworkListAsync(artworkQuery);
var artworkResource = mapper.Map <QueryResult <Artwork>, QueryResultResource <ArtworkResource> >(queryResult);
return(artworkResource);
}
public static Task <QueryResourceResponse> QueryDicomResourcesAsync(
this IMediator mediator,
IEnumerable <KeyValuePair <string, StringValues> > requestQuery,
QueryResource resourceType,
string studyInstanceUid = null,
string seriesInstanceUid = null,
CancellationToken cancellationToken = default)
{
return(mediator.Send(new QueryResourceRequest(requestQuery, resourceType, studyInstanceUid, seriesInstanceUid), cancellationToken));
}
public async Task <IEnumerable <Admin> > GetAdminAsync(QueryResource query)
{
var admins = await context.Admins.Include(a => a.Facility).ToListAsync();
if (query.UserId != 0)
{
admins = admins.FindAll(a => a.UserId == query.UserId);
}
return(admins);
}
public void FillResourceInfo(string resourceName)
{
using (QueryResource qr = new QueryResource())
{
Resource res = qr.GetResource(resourceName);
if (res != null && res.ResourceProductionInfo != null)
{
txtResourceStatus.Text = res.ResourceProductionInfo.ResourceStatus.DisplayName;
txtLastStatusChangeDate.Text = res.ResourceProductionInfo.LastStatusChangeDate.ToString();
}
}
}
static void Main(string[] args)
{
// Find your Account Sid and Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
QueryResource.Delete(
pathAssistantSid: "UAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
pathSid: "UHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
);
}
public QueryResourceRequest(
IEnumerable <KeyValuePair <string, StringValues> > requestQuery,
QueryResource resourceType,
string studyInstanceUid = null,
string seriesInstanceUid = null)
{
EnsureArg.IsNotNull(requestQuery, nameof(requestQuery));
RequestQuery = requestQuery;
QueryResourceType = resourceType;
StudyInstanceUid = studyInstanceUid;
SeriesInstanceUid = seriesInstanceUid;
}
public QueryRequest Map <TResource>(QueryResource queryResource)
where TResource : Resource
{
var queryBase = QueryPhraseMapper.Map <TResource>(queryResource.QueryPhrase);
return(new QueryRequest()
{
Query = queryBase,
OrderBy = GetOrderBy(queryResource),
IsDecending = string.IsNullOrEmpty(queryResource.OrderBy),
Page = queryResource.Page,
PageSize = queryResource.PageSize
});
}
static void Main(string[] args)
{
// Find your Account Sid and Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
var query = QueryResource.Fetch(
pathAssistantSid: "UAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
pathSid: "UHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
);
Console.WriteLine(query.DateCreated);
}
private void QueryInternal(string mapName, QueryResource queryResource, EventHandler<QueryEventArgs> completed, EventHandler<FailedEventArgs> failed)
{
string uri = string.Format("{0}/maps/{1}/queryResults.json?returnContent={2}&returnCustomResult={3}", this._serviceUrl,
HttpUtility.UrlEncode(mapName), queryResource.QueryParameters.ReturnContent, queryResource.QueryParameters.ReturnCustomResult);
string queryJson = JsonConvert.SerializeObject(queryResource);
EventHandler<AsyncEventArgs<string>> callback = (sender, e) =>
{
if (completed != null)
{
QueryResult queryResult = null;
queryResult = JsonConvert.DeserializeObject<QueryResult>(e.Result);
completed(this, new QueryEventArgs(queryResult));
}
};
AsyncHttpRequest.UpLoadStringAsync(uri, HttpRequestMethod.POST, queryJson, null, callback, failed);
}
/// <summary>
/// 查询。
/// </summary>
/// <param name="mapName">地图名。</param>
/// <param name="queryResource">查询参数。</param>
/// <returns>查询结果。</returns>
internal QueryResult QueryInternal(string mapName, QueryResource queryResource)
{
string uri = string.Format("{0}/maps/{1}/queryResults.json?returnContent={2}&returnCustomResult={3}", this._serviceUrl,
HttpUtility.UrlEncode(mapName), queryResource.QueryParameters.ReturnContent, queryResource.QueryParameters.ReturnCustomResult);
string connect = JsonConvert.SerializeObject(queryResource);
string requestResultJson = SynchHttpRequest.GetRequestString(uri, connect);
QueryResult queryResult = null;
if (queryResource.QueryParameters.ReturnContent)
{
queryResult = JsonConvert.DeserializeObject<QueryResult>(requestResultJson);
}
else
{
queryResult = new QueryResult();
queryResult.ResourceInfo = JsonConvert.DeserializeObject<ResourceInfo>(requestResultJson);
}
return queryResult;
}
/// <summary>
/// 在指定的地图上，查找距离指定几何对象一定距离容限内最近的对象。
/// </summary>
/// <param name="mapName">地图名。</param>
/// <param name="geometry">几何对象。</param>
/// <param name="maxDistance">容限距离。</param>
/// <param name="queryParameterSet">查询参数集。可对某个地图的多个图层进行查询，单个图层的查询参数在queryParameters.queryParams[i]中进行设置。 </param>
/// <returns>查询结果对象。</returns>
public QueryResult FindNearest(string mapName, Geometry geometry, double maxDistance, QueryParameterSet queryParameterSet)
{
if (string.IsNullOrEmpty(mapName)) throw new ArgumentNullException("mapName", Resources.ArgumentIsNotNull);
QueryResource qrResource = new QueryResource();
if (queryParameterSet != null && queryParameterSet.QueryParams != null)
{
qrResource.QueryParameters = queryParameterSet;
}
else
{
throw new ArgumentNullException("queryParameterSet", Resources.ArgumentIsNotNull);
}
if (maxDistance > 0)
{
qrResource.Distance = maxDistance;
}
else
{
throw new ArgumentNullException("maxDistance", Resources.ArgumentMoreThanZero);
}
qrResource.QueryMode = "FindNearest";
qrResource.Geometry = geometry;
return QueryInternal(mapName, qrResource);
}
/// <summary>
/// 在指定的地图上，查询与指定的几何对象符合某种空间关系和查询条件的几何对象。
/// </summary>
/// <param name="mapName">地图名。</param>
/// <param name="geometry">几何对象。</param>
/// <param name="spatialQueryMode">空间几何对象间的查询模式
/// <para>空间几何对象间的查询模式定义了一些几何对象之间的空间位置关系，根据这些空间关系来构建过滤条件执行查询。</para>
/// <example>查询可被包含在面对象中的空间对象，与面有相离或者相邻关系的空间对象等。</example>
/// </param>
/// <param name="queryParameterSet">查询参数集。可对某个地图的多个图层进行查询，单个图层的查询参数在queryParameters.queryParams[i]中进行设置。 </param>
/// <returns>查询结果集。</returns>
public QueryResult QueryByGeometry(string mapName, Geometry geometry, SpatialQueryMode spatialQueryMode, QueryParameterSet queryParameterSet)
{
if (string.IsNullOrEmpty(mapName)) throw new ArgumentNullException("mapName", Resources.ArgumentIsNotNull);
QueryResource qrResource = new QueryResource();
if (geometry != null)
{
qrResource.Geometry = geometry;
}
else
{
throw new ArgumentNullException("geometry", Resources.ArgumentIsNotNull);
}
if (queryParameterSet != null && queryParameterSet.QueryParams != null)
{
qrResource.QueryParameters = queryParameterSet;
}
else
{
throw new ArgumentNullException("queryParameterSet", Resources.ArgumentIsNotNull);
}
qrResource.QueryMode = "SpatialQuery";
qrResource.SpatialQueryMode = spatialQueryMode.ToString();
return QueryInternal(mapName, qrResource);
}
private QueryResource BuildQueryResource(Geometry geometry, double? distance, QueryParameterSet queryParameterSet,
string queryMode, string spatialQueryMode, Rectangle2D bounds)
{
QueryResource qrResource = new QueryResource();
qrResource.Geometry = geometry;
if (distance != null && distance > 0.0)
{
qrResource.Distance = distance;
}
qrResource.QueryParameters = queryParameterSet;
qrResource.SpatialQueryMode = spatialQueryMode;
qrResource.Bounds = bounds;
qrResource.QueryMode = queryMode;
return qrResource;
}
/// <summary>
/// 在指定的地图上，查询距离指定几何对象一定范围内的几何对象。
/// </summary>
/// <param name="mapName">地图名。</param>
/// <param name="geometry">几何对象。</param>
/// <param name="distance">查询的距离范围。</param>
/// <param name="queryParameterSet">查询参数集。可对某个地图的多个图层进行查询，单个图层的查询参数在 queryParameters.queryParams[i] 中进行设置。
/// </param>
/// <returns>查询结果集。</returns>
/// <remarks>到指定几何对象的一定距离范围，实际是以指定几何对象为中心的一个圆，在这个圆内以及与圆相交的几何对象都能够被查询出来。
/// </remarks>
public QueryResult QueryByDistance(string mapName, Geometry geometry, double distance, QueryParameterSet queryParameterSet)
{
if (string.IsNullOrEmpty(mapName)) throw new ArgumentNullException("mapName", Resources.ArgumentIsNotNull);
QueryResource qrResource = new QueryResource();
if (geometry != null)
{
qrResource.Geometry = geometry;
}
else
{
throw new ArgumentNullException("geometry", Resources.ArgumentIsNotNull);
}
if (distance > 0)
{
qrResource.Distance = distance;
}
else
{
throw new ArgumentOutOfRangeException("distance", Resources.ArgumentMoreThanZero);
}
if (queryParameterSet != null && queryParameterSet.QueryParams != null)
{
qrResource.QueryParameters = queryParameterSet;
}
else
{
throw new ArgumentNullException("queryParameterSet", Resources.ArgumentIsNotNull);
}
qrResource.QueryMode = "DistanceQuery";
return QueryInternal(mapName, qrResource);
}
/// <summary>
/// 在指定的地图上，查询与指定的矩形范围以及符合某种空间关系和查询条件的几何对象。
/// </summary>
/// <param name="mapName">地图名。</param>
/// <param name="bounds">矩形范围。</param>
/// <param name="queryParameterSet">查询参数集。可对某个地图的多个图层进行查询，单个图层的查询参数在 queryParameters.queryParams[i] 中进行设置。 </param>
/// <returns>查询结果集。</returns>
public QueryResult QueryByBounds(string mapName, Rectangle2D bounds, QueryParameterSet queryParameterSet)
{
if (string.IsNullOrEmpty(mapName)) throw new ArgumentNullException("mapName", Resources.ArgumentIsNotNull);
QueryResource qrResource = new QueryResource();
if (queryParameterSet != null && queryParameterSet.QueryParams != null)
{
qrResource.QueryParameters = queryParameterSet;
}
else
{
throw new ArgumentNullException("queryParameterSet", Resources.ArgumentIsNotNull);
}
qrResource.QueryMode = "BoundsQuery";
if (bounds != null)
{
qrResource.Bounds = bounds;
}
else
{
throw new ArgumentNullException("bounds", Resources.ArgumentIsNotNull);
}
return QueryInternal(mapName, qrResource);
}
/// <summary>
/// 在指定的地图上，执行 SQL 查询。
/// </summary>
/// <param name="mapName">地图名。</param>
/// <param name="queryParameterSet">查询参数集。可对某个地图的多个图层进行查询，单个图层的查询参数在queryParameters.queryParams[i]中进行设置。 </param>
/// <returns>查询结果集。</returns>
public QueryResult QueryBySQL(string mapName, QueryParameterSet queryParameterSet)
{
if (string.IsNullOrEmpty(mapName)) throw new ArgumentNullException("mapName", Resources.ArgumentIsNotNull);
QueryResource qrResource = new QueryResource();
if (queryParameterSet != null && queryParameterSet.QueryParams != null)
{
qrResource.QueryParameters = queryParameterSet;
}
else
{
throw new ArgumentNullException("queryParameterSet", Resources.ArgumentIsNotNull);
}
qrResource.QueryMode = "SqlQuery";
return QueryInternal(mapName, qrResource);
}
