public List <Activity> Find(ActivityFilter filters)
{
List <Activity> activities = new List <Activity>();
using (DataBase dataBase = new DataBase())
{
// build sql
String sql = "SELECT * FROM activity WHERE title like '%@title%'";
// build parameters
Dictionary <string, string> parameters = new Dictionary <string, string>();
//if (!String.IsNullOrEmpty(filters.Title))
//{
// parameters.Add("title", filters.Title);
//}
// execute sql
using (DbDataReader reader = dataBase.ExecuteQuery(sql, parameters))
{
while (reader.Read())
{
activities.Add(ActivityBuilder(reader));
}
}
}
return(activities);
}
public async Task <IActionResult> Create(ActivityViewModel model)
{
if (!ModelState.IsValid)
{
model.AgeGroups = _dbContext.Filters.Where(f => f.Category == Filter.FilterCategory.AgeGroup).ToList();
model.Genders = _dbContext.Filters.Where(f => f.Category == Filter.FilterCategory.Gender).ToList();
return(View(model));
}
Activity activity = _mapper.Map <Activity>(model);
await _dbContext.Activities.AddAsync(activity);
// Create age group filters for activity
await CreateActivityFilters(model.AgeGroups, activity);
// Create gender filters for activity
await CreateActivityFilters(model.Genders, activity);
// Create activity type filter for activity
Filter filter = _dbContext.Filters.FirstOrDefault(f => f.Id == model.ActivityTypeId);
if (filter != null)
{
ActivityFilter activityFilter = new ActivityFilter
{
Activity = activity,
Filter = filter
};
await _dbContext.ActivityFilters.AddAsync(activityFilter);
}
await _dbContext.SaveChangesAsync();
return(View("Details", model));
}
public IEnumerable <Activity> Find(ActivityFilter activityFilter)
{
return(_context.Activities
.Include(c => c.PracticaUser.CompanyProfile)
.Where(c => passFilterActivity(c, activityFilter))
.ToList());
}
private bool passFilterActivity(Activity activity, ActivityFilter activityFilter)
{
if (activity.PublishDate == null && activity.ExpirationDate == null)
{
return(false);
}
if (activity.PublishDate > DateTime.Today || activity.ExpirationDate <= DateTime.Today)
{
return(false);
}
if (!String.IsNullOrEmpty(activityFilter.City) && !activity.City.Equals(activityFilter.City))
{
return(false);
}
if (!String.IsNullOrEmpty(activityFilter.SearchKey) &&
activity.Title.IndexOf(activityFilter.SearchKey, StringComparison.OrdinalIgnoreCase) == -1 &&
!activity.Type.Equals(activityFilter.SearchKey, StringComparison.CurrentCultureIgnoreCase) &&
!activity.City.Equals(activityFilter.SearchKey, StringComparison.CurrentCultureIgnoreCase) &&
!activity.Country.Equals(activityFilter.SearchKey, StringComparison.CurrentCultureIgnoreCase)
)
{
return(false);
}
return(true);
}
public async Task <IEnumerable <Activity> > GetRecentActivityByAccountAlias(IEnumerable <string> aliases, int recordCountLimit = 10, CancellationToken cancellationToken = default(CancellationToken))
{
var filter = new ActivityFilter {
Accounts = aliases, Limit = recordCountLimit
};
return(await _httpClient.PostAsync <IEnumerable <Activity> >("search/activities", filter, cancellationToken));
}
private void SelectActiveNewsFeedFilter()
{
ActivityFilter activeFilter = ServiceProvider.ViewManager.ActiveNewsFeedFilter;
if (activeFilter != null)
{
this.FilterTabs.SelectedItem = activeFilter;
}
}
/// <summary>
/// Populate Filter
/// </summary>
public ActivityFilter PopulateFilter()
{
ActivityFilter filter = new ActivityFilter();
filter.ActivityType = SelectedActivityType();
filter.SectorIds = SelectedValues(this.lbActivitySector);
filter.ActivityIds = SelectedValues(this.lbActivities);
return(filter);
}
private static string GetActivityAnnexI(ActivityFilter filter)
{
ActivityFilter.Level level = filter.SearchLevel();
// return value: string describing the activity
string value = "";
if (level == ActivityFilter.Level.Sector)
{
if (filter.SectorIds.Count() == 1)
{
value = LOVResources.AnnexIActivityName(filter.SectorIds.First());
}
else
{
value = Resources.GetGlobal("Common", "SeveralSectors");
}
}
else if (level == ActivityFilter.Level.Activity)
{
if (filter.ActivityIds.Count() == 1)
{
value = LOVResources.AnnexIActivityName(filter.ActivityIds.First());
}
else
{
//only only sector will be selected
string sector = LOVResources.AnnexIActivityName(filter.SectorIds.First());
value = string.Format(Resources.GetGlobal("Common", "SeveralActivities"), sector);
}
}
else if (level == ActivityFilter.Level.SubActivity)
{
if (filter.SubActivityIds.Count() == 1)
{
int id = filter.SubActivityIds.First();
if (id.Equals(ActivityFilter.SubActivitiesUnspecifiedID))
{
value = Resources.GetGlobal("Common", "Unspecified");
}
else
{
value = LOVResources.AnnexIActivityName(id);
}
}
else
{
//only one activity will be selected
string activity = LOVResources.AnnexIActivityName(filter.ActivityIds.First());
value = string.Format(Resources.GetGlobal("Common", "SeveralSubActivities"), activity);
}
}
return(value);
}
public static ActivityFilter GetActivityFilter(HttpRequest request)
{
if (HasActivityFilter(request))
{
ActivityFilter filter = new ActivityFilter();
filter.ActivityType = toEnum <ActivityFilter.Type>(request.QueryString[ACTIVITYTYPE]);
filter.SectorIds = toList(request.QueryString[SECTORS], ActivityFilter.AllSectorsID);
filter.ActivityIds = toList(request.QueryString[ACTIVITIES], ActivityFilter.AllActivitiesInSectorID);
filter.SubActivityIds = toList(request.QueryString[SUBACTIVITIES], ActivityFilter.AllSubActivitiesInActivityID);
return(filter);
}
return(null);
}
// --------------------------------------------------------------------------------------------------------------------
// Activity filter
// --------------------------------------------------------------------------------------------------------------------
#region ActivityFilter
private static string SerializeToUrl(ActivityFilter filter)
{
string result = String.Empty;
if (filter != null)
{
result += addParameter(ACTIVITYTYPE, filter.ActivityType.ToString());
result += addParameter(SECTORS, listOfValues(filter.SectorIds, ActivityFilter.AllSectorsID));
result += addParameter(ACTIVITIES, listOfValues(filter.ActivityIds, ActivityFilter.AllActivitiesInSectorID));
result += addParameter(SUBACTIVITIES, listOfValues(filter.SubActivityIds, ActivityFilter.AllSubActivitiesInActivityID));
}
return(result);
}
/// <summary>
/// GetActivityFilter
/// </summary>
/// <param name="searchActivityFilter">Input filter is discarded after this method is run</param>
/// <param name="code">Note: code can be sector, activity or subactivity code</param>
/// <param name="parentCode"></param>
/// <returns></returns>
public static ActivityFilter GetActivityFilter(ActivityFilter searchActivityFilter, string code, string parentCode)
{
//for total-rows the activityfilter corresponds to the filter from the search
if (TreeListRow.CODE_TOTAL.Equals(code))
{
return(searchActivityFilter == null ? null : searchActivityFilter.Clone() as ActivityFilter);
}
ActivityFilter activityfilter = new ActivityFilter();
LOV_ANNEXIACTIVITY parent = ListOfValues.GetAnnexIActicvity(parentCode);
LOV_ANNEXIACTIVITY selected = ListOfValues.GetAnnexIActicvity(code);
if (parent == null)
{
//selected is on sectorlevel
activityfilter.SectorIds.Add(selected.LOV_AnnexIActivityID);
activityfilter.ActivityIds.Add(ActivityFilter.AllActivitiesInSectorID);
activityfilter.SubActivityIds.Add(ActivityFilter.AllSubActivitiesInActivityID);
}
else
{
//selected is on sectorlevel or activity
if (parent.ParentID == null)
{
//selected is on activity level
activityfilter.SectorIds.Add(parent.LOV_AnnexIActivityID);
activityfilter.ActivityIds.Add(selected.LOV_AnnexIActivityID);
activityfilter.SubActivityIds.Add(ActivityFilter.AllSubActivitiesInActivityID);
}
else
{
//selected is on subactivity level
LOV_ANNEXIACTIVITY sector = ListOfValues.GetAnnexIActicvity((int)parent.ParentID);
activityfilter.SectorIds.Add(sector.LOV_AnnexIActivityID);
activityfilter.ActivityIds.Add(parent.LOV_AnnexIActivityID);
if (TreeListRow.CODE_UNSPECIFIED.Equals(code))
{
activityfilter.SubActivityIds.Add(ActivityFilter.SubActivitiesUnspecifiedID);
}
else
{
activityfilter.SubActivityIds.Add(selected.LOV_AnnexIActivityID);
}
}
}
return(activityfilter);
}
public void TestActivityFilter()
{
// arrange
var activityService = new ActivityService(_activityQueryRepository);
ActivityFilter activityFilter = new ActivityFilter("");
var activityQueryRepositoryResult = getActivityQueryRepositoryResult();
_activityQueryRepository.Find(activityFilter).Returns(activityQueryRepositoryResult);
// act
var result = activityService.Find(activityFilter);
// assert
Assert.AreEqual(2, result.Count);
}
private static string GetActivityNACE(ActivityFilter filter)
{
ActivityFilter.Level level = filter.SearchLevel();
// return value: string describing the activity
string value = "";
if (level == ActivityFilter.Level.Sector)
{
if (filter.SectorIds.Count() == 1)
{
value = LOVResources.NaceActivityName(filter.SectorIds.First());
}
else
{
value = Resources.GetGlobal("Common", "SeveralSectors");
}
}
else if (level == ActivityFilter.Level.Activity)
{
if (filter.ActivityIds.Count() == 1)
{
value = LOVResources.NaceActivityName(filter.ActivityIds.First());
}
else
{
//only one sector is selceted
string sector = LOVResources.NaceActivityName(filter.SectorIds.First());
value = string.Format(Resources.GetGlobal("Common", "SeveralActivities"), sector);
}
}
else if (level == ActivityFilter.Level.SubActivity)
{
if (filter.SubActivityIds.Count() == 1)
{
//NACE cannot be unspecified
value = LOVResources.NaceActivityName(filter.SubActivityIds.First());
}
else
{
//only one activity is selcted
string activity = LOVResources.NaceActivityName(filter.ActivityIds.First());
value = string.Format(Resources.GetGlobal("Common", "SeveralSubActivities"), activity);
}
}
return(value);
}
public void GetRecentActivityByAccountAlias_PerformsCorrectRequest()
{
ActivityFilter expectedFilter = new ActivityFilter {
Accounts = new[] { "alias1", "alias2" }, Limit = 5
};
ActivityFilter actualFilter = null;
var expectedToken = new CancellationTokenSource().Token;
_client.Setup(x => x.PostAsync <IEnumerable <Activity> >("search/activities", It.IsAny <ActivityFilter>(), expectedToken))
.Callback <string, object, CancellationToken>((uri, filter, token) => actualFilter = filter as ActivityFilter)
.Returns(Task.FromResult(new List <Activity>().AsEnumerable()));
_testObject.GetRecentActivityByAccountAlias(expectedFilter.Accounts, expectedFilter.Limit, expectedToken).Wait();
_client.VerifyAll();
Assert.NotNull(actualFilter);
CollectionAssert.AreEqual(expectedFilter.Accounts, actualFilter.Accounts);
Assert.AreEqual(expectedFilter.Limit, actualFilter.Limit);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
Filter = LinkSearchBuilder.GetActivityFilter(Request);
if (Filter == null)
{
populateSectors(SelectedActivityType());
}
else
{
populateSectors(Filter.ActivityType);
populateActivityType(Filter.ActivityType);
}
}
// Only show warning image if activity type is Annex I
imgAlert.Visible = (SelectedActivityType() == ActivityFilter.Type.AnnexI);
}
private async Task CreateActivityFilters(List <Filter> filters, Activity activity)
{
// Exit if all filters are checked
if (!filters.Any(f => f.Selected == false))
{
return;
}
foreach (var filter in filters)
{
if (filter.Selected)
{
Filter f = _dbContext.Filters.FirstOrDefault(f => f.Id == filter.Id);
ActivityFilter activityFilter = new ActivityFilter
{
Activity = activity,
Filter = f
};
await _dbContext.ActivityFilters.AddAsync(activityFilter);
}
}
}
public IActionResult GetActivities([FromQuery] string SearchKey, [FromQuery] string City)
{
try
{
ActivityFilter activityFilter = new ActivityFilter()
{
SearchKey = SearchKey,
City = City
};
var activities = _activityRepository.Find(activityFilter);
List <ActivityCardViewDto> activitiesCardDto = new List <ActivityCardViewDto>();
foreach (var activity in activities)
{
ActivityCardViewDto activityCardDto = new ActivityCardViewDto()
{
Id = activity.Id,
Type = activity.Type,
Title = activity.Title,
Description = activity.Description,
City = activity.City,
CompanyId = activity.UserId,
CompanyName = activity.PracticaUser?.CompanyProfile?.Name,
CompanyLogo = activity.PracticaUser?.CompanyProfile?.Logo,
CompanyLogoExtension = activity.PracticaUser?.CompanyProfile?.LogoExtension
};
activitiesCardDto.Add(activityCardDto);
}
return(Ok(activitiesCardDto));
}
catch (Exception ex)
{
_logger.LogCritical($"An exception was thrown: ", ex);
return(StatusCode(500, "A problem happend while handeling your request."));
}
}
/// <summary>
/// creates header for Area and adds to dictionary
/// </summary>
protected static void addActivity(Dictionary <string, string> header, ActivityFilter filter)
{
if (filter != null)
{
// set the key
string key;
switch (filter.ActivityType)
{
case ActivityFilter.Type.AnnexI:
key = Resources.GetGlobal("Activity", "AnnexI");
break;
case ActivityFilter.Type.NACE:
key = Resources.GetGlobal("Activity", "NACE");
break;
case ActivityFilter.Type.IPPC:
key = Resources.GetGlobal("Activity", "IPPC");
break;
default:
key = "";
break;
}
// set the value
string value = string.Empty;
ActivityFilter.Level level = filter.SearchLevel();
if (level == ActivityFilter.Level.All)
{
value = Resources.GetGlobal("Common", "AllSectors");
}
else
{
switch (filter.ActivityType)
{
case ActivityFilter.Type.AnnexI:
{
value = GetActivityAnnexI(filter);
break;
}
case ActivityFilter.Type.NACE:
{
value = GetActivityNACE(filter);
break;
}
case ActivityFilter.Type.IPPC:
{
//value = GetActivityIPPC(filter);
break;
}
default:
{
break;
}
}
}
header.Add(key, value);
}
}
public override IEnumerable <ActivityLogRecord> GetActivityRecordsFor(Logger logger, ActivityFilter filter)
{
var filesList = GetSuitableFiles(logger, filter);
var result = new List <ActivityLogRecord>();
var store = GetCurrentStorage(logger);
foreach (var file in filesList)
{
result.AddRange(store.Where(x => x.FileName == file).SelectMany(x => x.ActivityDto.Records));
}
return(result);
}
public ActivityTreeListRowComparer(ActivityFilter activityFilter)
{
this.activityFilter = activityFilter;
}
public static List <FactActivity> GetActivities(this API api, DateTime from, DateTime to, Dictionary <string, DimTracker> trackers)
{
List <ActivityFilter> filterList = trackers.Keys.Select(x => new ActivityFilter {
from = from, to = to, serial = x
}).ToList();
Parameter body = new Parameter("application/json", ActivityFilter.Serialize(filterList).ToString(Newtonsoft.Json.Formatting.None), ParameterType.RequestBody);
Parameter timeFilter = new Parameter("timeFilter", "byMessageTime", ParameterType.QueryString);
Parameter[] parameters = new Parameter[] { body, timeFilter };
List <FactActivity> output = new List <FactActivity>();
while (filterList.Count != 0)
{
body.Value = ActivityFilter.Serialize(filterList).ToString(Newtonsoft.Json.Formatting.None);
JArray jResponse = api.Call(@"/api/v2/devices/data/aggregated/activity", Method.POST, parameters, true);
output.AddRange(
jResponse
.Where(x => x["data"] != null)
.Select(x => {
return(x["data"]
.Select(y => new FactActivity
{
Id = y["id"].Value <long>(),
Serial = x["serial"].Value <string>(),
Evttime = DateTime.Parse(y["time"].Value <string>()),
Inserttime = DateTime.Parse(y["insertTime"].Value <string>()),
Evttype = y["state"].Value <string>(),
Lat = y["lat"]?.Value <double?>(),
Lon = y["lng"]?.Value <double?>(),
Src = y["source"].Value <string>(),
Accuracy = y["accuracy"]?.Value <int?>(),
Address = y["address"]?.Value <string>(),
Geozones = y["geozones"]?.ToString(Newtonsoft.Json.Formatting.None),
Trackerrecid = trackers[x["serial"].Value <string>()].Recid
}).ToList());
})
.SelectMany(x => x)
.ToList()
);
filterList.Clear();
foreach (var obj in jResponse)
{
if (obj["truncated"].Value <bool>())
{
filterList.Add(new ActivityFilter
{
from = obj["data"].Max(x => DateTime.Parse(x["time"].Value <string>())).AddSeconds(1),
to = to,
serial = obj["serial"].Value <string>()
});
}
else if (obj["skipped"].Value <bool>())
{
filterList.Add(new ActivityFilter
{
from = from,
to = to,
serial = obj["serial"].Value <string>()
});
}
}
}
return(output);
}
public List <Activity> Find(ActivityFilter filters)
{
return(_activityRepository.Find(filters));
}
