public void Execute_Returns_Correct_Result(EventsQuery sut)
{
var result = sut.Execute(TestData.EventName);
Func<Event, bool> containsSearchTerm = e =>
e.Location == TestData.EventName || e.Name == TestData.EventName;
result.Count().Should().BeGreaterOrEqualTo(1);//avoid vacuous truth
result.All(containsSearchTerm).Should().BeTrue();
}
public async Task <IList <Event> > Handle(EventsQuery query, CancellationToken cancellationToken)
{
IQueryable <Event> result = db.Events.Include(e => e.EventTranslations).Include(e => e.Image);
if (query.Ids != null && query.Ids.Length > 0)
{
result = result.Where(item => query.Ids.Contains(item.EventId));
}
IList <Event> events = await result.ToListAsync();
return(events);
}
public IEnumerator <ITask> EventsQueryHandler(EventsQuery query)
{
EventsQueryRequestType request = query.Body;
EventsQueryResponse response = new EventsQueryResponse();
response.Events = new List <EventListEntry>();
foreach (EventListEntry entry in _state.SpeechEvents)
{
if (entry.Timestamp > request.NewerThanTimestamp)
{
response.Events.Add(entry);
}
}
query.ResponsePort.Post(response);
yield break;
}
public Expression <Func <PortalEvents, bool> > FilterEvents(EventsQuery query)
{
var predicate = PredicateBuilder.True <PortalEvents>();
if (!string.IsNullOrEmpty(query.SearchText))
{
string searchParameter = query.SearchText.ToLower();
var search = PredicateBuilder.False <PortalEvents>();
search = search.Or(p => p.EventDesc.ToLower().Contains(searchParameter));
search = search.Or(p => p.EventTitle.ToLower().Contains(searchParameter));
search = search.Or(p => p.PortalEventType.EventTypeName.ToLower().Contains(searchParameter));
predicate = predicate.And(search);
}
if (query.PortalEventTypeId.HasValue)
{
predicate = predicate.And(p => p.PortalEventType.Id == query.PortalEventTypeId.Value);
}
return(predicate);
}
public async Task <QueryResult <Event> > ListAsync(EventsQuery query)
{
// include all the fields. no tracking for performance.
IQueryable <Event> queryable = _context.Events.Include(evt => evt.Fields).AsNoTracking();
if (query.GameId.HasValue && query.GameId.Value > 0)
{
queryable = queryable.Where(evt => evt.GameId == query.GameId);
}
// get total count first
int recordCount = await queryable.CountAsync();
// get the records
List <Event> events = await queryable.OrderBy(evt => evt.TimeUtc).Skip(query.StartIndex).Take(query.FetchSize).ToListAsync();
// return the combination
return(new QueryResult <Event>
{
Items = events,
RecordCount = recordCount,
});
}
/// <summary>
/// Events HTTP query handler
/// </summary>
/// <param name="query"></param>
/// <param name="parameters"></param>
/// <returns></returns>
private IEnumerator <ITask> EventsHttpQueryHandler(HttpQuery query, NameValueCollection parameters)
{
// Parse timestamp (TryParse sets the timestamp to zero if parsing fails)
long timestamp;
long.TryParse(parameters["timestamp"], out timestamp);
// Send EventsQuery message to own service
EventsQueryRequestType eventsQueryRequest = new EventsQueryRequestType();
eventsQueryRequest.NewerThanTimestamp = timestamp;
EventsQuery eventsQuery = new EventsQuery();
eventsQuery.Body = eventsQueryRequest;
_mainPort.Post(eventsQuery);
DsspResponsePort <EventsQueryResponse> eventsResponse = eventsQuery.ResponsePort;
yield return((Choice)eventsResponse);
Fault eventsFault = (Fault)eventsResponse;
if (eventsFault != null)
{
LogError(eventsFault);
query.ResponsePort.Post(new HttpResponseType(
HttpStatusCode.InternalServerError,
eventsFault
));
yield break;
}
// Return EventsQuery result
query.ResponsePort.Post(new HttpResponseType(
HttpStatusCode.OK,
(EventsQueryResponse)eventsResponse
));
yield break;
}
public async Task Get()
{
var logger = testConfig.GetLoggerFactory().CreateLogger <EventGetHandler>();
EventGetHandler eventHandlers = new EventGetHandler(testConfig.GetDbContext(), logger);
EventsQuery query = new EventsQuery();
IList <Event> res = await eventHandlers.Handle(query, new CancellationToken());
Assert.AreEqual(3, res.Count);
EventsQuery queryWithId = new EventsQuery()
{
Ids = new int[] { 1 }
};
IList <Event> resWithId = await eventHandlers.Handle(queryWithId, new CancellationToken());
Assert.AreEqual(1, resWithId.Count);
Assert.AreEqual("Name", resWithId.First().Name);
Assert.AreEqual(2, resWithId.First().EventTranslations.Count);
EventsQuery queryWithIds = new EventsQuery()
{
Ids = new int[] { 1, 3 }
};
IList <Event> resWithIds = await eventHandlers.Handle(queryWithIds, new CancellationToken());
Assert.AreEqual(2, resWithIds.Count);
EventsQuery queryWithNotExistId = new EventsQuery()
{
Ids = new int[] { 1, 4 }
};
IList <Event> resWithNotExistId = await eventHandlers.Handle(queryWithNotExistId, new CancellationToken());
Assert.AreEqual(1, resWithNotExistId.Count);
}
public EventsSchema(EventsQuery query, EventsMutation mutation, IDependencyResolver resolver)
{
Query = query;
Mutation = mutation;
DependencyResolver = resolver;
}
public ReturnData <List <PortalEvents> > GetEvents(string searchText, string tokenString, string userCode, int?offset = null, int?itemsPerPage = null, int?eventsType = null)
{
try
{
var portalUser = _context.Users.FirstOrDefault(u => u.UserName.ToUpper().Equals(userCode.ToUpper()));
if (portalUser == null)
{
return new ReturnData <List <PortalEvents> >
{
Success = false,
Message = "Server Error, Please try latter",
}
}
;
var userGroup = _context.UserGroups.FirstOrDefault(g => g.Id == portalUser.UserGroupsId);
var response = new ReturnData <List <PortalEvents> >();
int?userGroupId = null;
if (!string.IsNullOrEmpty(tokenString))
{
var token = _context.UserTokens.FirstOrDefault(k => k.Value == tokenString);
if (token != null)
{
var user = _context.Users.FirstOrDefault(l => l.Id == token.UserId);
if (user != null)
{
userGroupId = user.UserGroupsId;
}
}
}
var query = new EventsQuery
{
SearchText = searchText,
EndDate = null,
Skip = offset,
StartDate = null,
Take = itemsPerPage,
UserGroup = userGroup.Id,
PortalEventTypeId = eventsType
};
IQueryable <PortalEvents> queryResult = _context.PortalEvents.OrderByDescending(e => e.Id).Where(e => e.EventEndDate > DateTime.Now).AsQueryable().AsNoTracking();
if (userGroup.Role == Role.Admin)
{
query.UserGroup = null;
queryResult = queryResult.Where(filters.FilterEvents(query));
}
else
{
var uId = userGroup.Id.ToString();
queryResult = queryResult.Where(e => e.CreatedBy == userCode || (e.TargetGroups.Contains(uId) && e.TargetGroups != null)).Where(filters.FilterEvents(query));
}
var data = queryResult
.Include(n => n.PortalEventType)
.OrderBy(n => n.Id).ToList();
if (query.Skip.HasValue)
{
data = data.Skip(query.Skip.Value).ToList();
}
if (query.Take.HasValue)
{
data = data.Take(query.Take.Value).ToList();
}
if (query.Skip.HasValue && query.Take.HasValue)
{
data = data.Skip(query.Skip.Value).Take(query.Take.Value).ToList();
}
if (portalUser.Role == Role.Student)
{
var classStatus = _context.Settings.FirstOrDefault()?.ClassStatus ?? "Active";
var result = _unisolApiProxy.GetStudentDetails(userCode, classStatus).Result;
var jData = JsonConvert.DeserializeObject <ReturnData <dynamic> >(result);
string department = jData.Data.studentDeparment.department ?? "";
string school = jData.Data.studentDeparment.school ?? "";
string campus = jData.Data.studentClass.campus ?? "";
string yearOfStudy = jData.Data.studentClass.yearOfStudy ?? "";
data = data.Where(e => (string.IsNullOrEmpty(e.Department) || e.Department.ToUpper().Contains(department.ToUpper())) &&
(string.IsNullOrEmpty(e.School) || e.School.ToUpper().Contains(school.ToUpper())) &&
(string.IsNullOrEmpty(e.Campus) || e.Campus.ToUpper().Contains(campus.ToUpper())) &&
(string.IsNullOrEmpty(e.YearOfStudy) || e.YearOfStudy.ToUpper().Contains(yearOfStudy.ToUpper()))).ToList();
}
response.Success = data.Count() > 0;
response.TotalItems = data.Count();
response.Data = data;
return(response);
}
catch (Exception ex)
{
return(new ReturnData <List <PortalEvents> >
{
Success = false,
Message = "Server Error, Please try latter",
});
}
}
public IHttpActionResult Get()
{
var result = new EventsQuery().Execute();
return(Ok(result));
}
public async Task <IActionResult> Get([FromQuery] EventsQuery query)
{
IEnumerable <Event> result = await mediatr.Send(query);
return(Json(result));
}
public Task <QueryResult <Event> > ListAsync(EventsQuery query)
{
// return directly
return(this._eventRepository.ListAsync(query));
}
