public void Map(AppointmentInput input)
{
var date = DateTime.Parse(input.AppointmentDate);
var time = DateTime.Parse(input.AppointmentTime);
var created = input.CreateDate == "NULL" ? (DateTime?)null : DateTime.Parse(input.CreateDate);
var dob = input.DateOfBirth == "NULL" ? (DateTime?)null : DateTime.Parse(input.DateOfBirth);
Hour = time.Hour;
LeadTime = !created.HasValue ? 0 : ((float)(date - created.Value).TotalDays);
DayOfWeek = (int)date.DayOfWeek;
Season = CalcSeason(date);
Month = date.Month;
Week = ISOWeek.GetWeekOfYear(date);
DayOfYear = date.DayOfYear;
Minutes = input.Minutes;
Age = !dob.HasValue ? 0 : ((float)(date - dob.Value).TotalDays * 365);
Sex = input.Sex;
OMBWhite = input.OMBWhite == "1";
OMBAmericanIndian = input.OMBAmericanIndian == "1";
OMBAsian = input.OMBAsian == "1";
OMBBlack = input.OMBBlack == "1";
OMBHawaiian = input.OMBHawaiian == "1";
CDCCode = input.CDCCode;
HasEmergencyContact = input.HasEmergencyContact == "1";
LastAppointmentNoShow = input.LastAppointmentShowNoShow != "1";
PreviousNoShows = input.PreviousNoShows;
TotalScheduled = input.TotalScheduled;
IsFirstAppt = input.TotalScheduled == 0;
NoShowRatio = input.PreviousNoShows / input.TotalScheduled;
LastAppointmentScripts = input.LastAppointmentScripts;
IsRecurring = input.IsRecurring == "1";
IsFirstInRecurrence = input.IsFirstInRecurrence == "1";
Cancelled = input.ShowNoShow == 3 ? 1 : 0;
NoShow = input.ShowNoShow == 2;
}
public async Task <ActionResult <Dictionary <int, ICollection <object> > > > GetYearsAndWeeks([FromQuery] int years)
{
var dict = new Dictionary <int, List <object> >();
var currentYear = DateTime.Now.Year;
for (int i = currentYear - years; i <= currentYear; i++)
{
var numberOfWeeks = ISOWeek.GetWeeksInYear(i);
dict.Add(i, new List <object>());
for (int j = 1; j <= numberOfWeeks; j++)
{
if (i == DateTime.Now.Year && ISOWeek.GetWeekOfYear(DateTime.Now) - 1 < j)
{
break;
}
var weekString = ISOWeek.ToDateTime(i, j, DayOfWeek.Monday).ToString("dd.MM.yyyy")
+ " - "
+ ISOWeek.ToDateTime(i, j, DayOfWeek.Sunday).ToString("dd.MM.yyyy");
dict[i].Add(new { weekNum = j, week = weekString });
}
}
return(Ok(dict));
}
public static Week FromDate(DateTime date)
{
var year = ISOWeek.GetYear(date);
var weekNumber = ISOWeek.GetWeekOfYear(date);
return(FromYearAndWeekNumber(year, weekNumber));
}
static void Main(string[] args)
{
// represents a time interval
var timeSpan = new TimeSpan(60, 100, 200);
// Timespan converts all inputs to a representation of an actual time
// It automatically calculates correct amount of days, hours, minutes, seconds, milliseconds and ticks based on data
//Console.WriteLine(timeSpan.Days);
//Console.WriteLine(timeSpan.Hours);
//Console.WriteLine(timeSpan.Minutes);
//Console.WriteLine(timeSpan.Seconds);
//How to use Timespan
var startDate = DateTimeOffset.UtcNow;
var endDate = startDate.AddSeconds(50);
TimeSpan difference = endDate - startDate;
Console.WriteLine($"Difference in Seconds {difference.Seconds}");
//Get week of Year
var isoWeek = ISOWeek.GetWeekOfYear(startDate.DateTime);
Console.WriteLine($"It's Calendar Week: {isoWeek}");
//Extend Contract - Adding only 30 days can be false, if you for example want a contract to end at the end of a month
var contractdateToExtend = new DateTimeOffset(2020, 2, 28, 0, 0, 0, TimeSpan.Zero);
Console.WriteLine($"Extending Date {contractdateToExtend}. After adding 1 Month it will extend at {contractdateToExtend.ExtendContract(1)}");
}
public BonusDataReader(HttpClient client, ILogger <BonusDataReader> logger)
{
this.client = client;
this.logger = logger;
this.currentWeekOfYear = ISOWeek.GetWeekOfYear(DateTime.Now);
logger.LogInformation("Starting to get bonus from week {CurrentWeek}", this.currentWeekOfYear);
}
public async Task <IEnumerable <Tracking> > GetPersonTrackingsOfWeek(int year, int personId, int weekNum)
{
DateTime startDate;
DateTime endDate;
var possibleStartDate = ISOWeek.ToDateTime(year, weekNum, DayOfWeek.Monday);
if (possibleStartDate.Year > year)
{
throw new ArgumentException($"Week {weekNum} doesn`t exist in this year");
}
if (possibleStartDate.Year < year)
{
possibleStartDate = new DateTime(year, 1, 1);
}
startDate = possibleStartDate;
int daysToEnd = 7 - (int)startDate.DayOfWeek;
var possibleEndDate = startDate.AddDays(daysToEnd);
if (possibleEndDate.Year > startDate.Year)
{
endDate = new DateTime(startDate.Year, 12, 31);
}
else
{
endDate = possibleEndDate;
}
return(await repository.GetPersonTrackingsOfDateRange(personId, startDate, endDate));
}
public static void NoOfWeekCalc()
{
//using Calendar
var noOfWeekCalendar = calendar.GetWeekOfYear(dateForWeekCalc.DateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
Console.WriteLine($"Calendar:\t{noOfWeekCalendar}");
//iso8601
var noOfWeekISO8061 = ISOWeek.GetWeekOfYear(dateForWeekCalc.DateTime);
Console.WriteLine($"ISO8061:\t{noOfWeekISO8061}");
//iso8601 - obliczone samemu
//--week starts on Monday and 1st week of the year is the one that contains Thursday
DayOfWeek day = calendar.GetDayOfWeek(dateForWeekCalc.DateTime);
var noOfWeekISOself = calendar.GetWeekOfYear(dateForWeekCalc.DateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
if (day >= DayOfWeek.Monday && day <= DayOfWeek.Wednesday)
{
noOfWeekISOself = calendar.GetWeekOfYear(dateForWeekCalc.DateTime.AddDays(3),
CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
}
Console.WriteLine($"ISOself:\t{noOfWeekISOself}");
Console.WriteLine();
}
public (DateTime startDate, DateTime endDate) GetStartAndEndDateBasedOnWeek(int weekNumber)
{
//Should be an own class.
var startDate = ISOWeek.ToDateTime(DateTime.Now.Year, weekNumber, DayOfWeek.Monday);
var endDate = startDate.AddDays(6);
return(startDate, endDate);
}
public IEnumerable <EmployeeActivity> GetEmployeeActivitiePerWeek(int employeeId, int weekNumber)
{
var firstDayOfWeek = ISOWeek.ToDateTime(DateTime.Now.Year, weekNumber, DayOfWeek.Monday);
var lastDayOfWeek = ISOWeek.ToDateTime(DateTime.Now.Year, weekNumber, DayOfWeek.Sunday);
var r = GetEmployeeActivitiyPerPeriod(employeeId, a => a.Date.Date >= firstDayOfWeek.Date && a.Date.Date <= lastDayOfWeek.Date.Date);
return(r);
}
static void DateCalculations()
{
//Time Differnce
var timeSpan = new TimeSpan(60, 40, 4000);
var startDate = DateTimeOffset.UtcNow;
var endDate = startDate.AddMinutes(20).AddSeconds(24);
var differnce = endDate - startDate;
var calendar = CultureInfo.InvariantCulture.Calendar;
var startCalendar = DateTimeOffset.UtcNow;
var week = calendar.GetWeekOfYear(startCalendar.DateTime, CalendarWeekRule.FirstDay, DayOfWeek.Monday);
Console.WriteLine(week);
var isoWeek = ISOWeek.GetWeekOfYear(DateTimeOffset.UtcNow.DateTime);
Console.WriteLine(isoWeek);
//Last Bit
var dateTimeUTC = DateTimeOffset.UtcNow;
Console.WriteLine(dateTimeUTC);
Console.WriteLine(dateTimeUTC.ToLocalTime());
var datenow = System.DateTime.Now.ToString();
var dateUTC = System.DateTime.Parse(datenow, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal).ToUniversalTime();
var date = DateTimeOffset.Parse(datenow, CultureInfo.GetCultureInfo("en"));
var date2 = System.DateTimeOffset.Now.ToString("dd MMMM yyyy", CultureInfo.GetCultureInfo("sv-SE"));
var time = DateTimeOffset.Now;
Console.WriteLine(dateUTC);
// Get Timezone
foreach (var timezone in TimeZoneInfo.GetSystemTimeZones())
{
if (timezone.GetUtcOffset(time) == time.Offset)
{
Console.WriteLine(timezone);
}
}
//Convert from one time zone to another
var now = System.DateTime.Now;
var timeZoneInfos = TimeZoneInfo.GetSystemTimeZones();
foreach (var timezone in timeZoneInfos)
{
var converted = TimeZoneInfo.ConvertTime(now, timezone);
Console.WriteLine($"{ timezone.Id}-{converted}");
}
Console.ReadLine();
}
static void GetWeekNumber()
{
var start = new DateTimeOffset(2007, 12, 31, 0, 0, 0, TimeSpan.Zero);
var week = calendar.GetWeekOfYear(start.DateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
Console.WriteLine(week);
var isoWeek = ISOWeek.GetWeekOfYear(start.DateTime);
Console.WriteLine(isoWeek);
}
public void it_gets_isoweek_from_date()
{
// Arrange
var start = new DateTimeOffset(2007, 12, 31, 0, 0, 0, TimeSpan.Zero);
// Act
var weekOfYear = ISOWeek.GetWeekOfYear(start.DateTime);
// Assert
_testOutputHelper.WriteLine(weekOfYear.ToString());
}
public static Period FromWeekNumber(int year, int weekNumber)
{
if (year < 1900 || year > 2100)
{
throw new ArgumentOutOfRangeException(nameof(year), "Year is not in a reasonable range (1900-2100)");
}
var startDate = ISOWeek.ToDateTime(year, weekNumber, DayOfWeek.Monday);
var endDate = startDate.AddDays(6);
return(new Period(startDate, endDate));
}
private static DateTimeOffset ISOWeekChecking()
{
var startOff = new DateTimeOffset(2007, 12, 31, 0, 0, 0, TimeSpan.Zero);
var week = calendar.GetWeekOfYear(startOff.DateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
Console.WriteLine(week);
var isoWeek = ISOWeek.GetWeekOfYear(startOff.DateTime);
Console.WriteLine(isoWeek);
return(startOff);
}
public static Week FromYearAndWeekNumber(int year, int weekNumber)
{
var start = ISOWeek.ToDateTime(year, weekNumber, DayOfWeek.Monday);
var end = start.AddDays(7).AddMilliseconds(-1);
return(new Week
{
Year = year,
WeekNumber = weekNumber,
Start = start,
End = end
});
}
public async Task <List <CourseInstance> > GetAllCourseInstancesPerGivenWeek(int?weeknr, int?year)
{
// If no value is given for the week number and year, the current week and year are used
if (weeknr == null)
{
weeknr = ISOWeek.GetWeekOfYear(DateTime.Now);
}
if (year == null)
{
year = ISOWeek.GetYear(DateTime.Now);
}
return(await _courseInstanceContext.GetAllCourseInstancesPerGivenWeek(weeknr, year));
}
private DateRange GetStartAndEndDateForWeek(int week)
{
if (week < 1 || week > 53)
{
throw new ArgumentOutOfRangeException("The week parameter must be in the range 1 through 53");
}
var date = ISOWeek.ToDateTime(DateTime.Today.Year, week, DayOfWeek.Monday);
return(new DateRange
{
FirstDayInWeek = GetDateForSpecificDay(date),
LastDayInWeek = GetDateForSpecificDay(date).AddDays(6)
});
}
// Optional parameters for week and year default to the current week and year if no value is geven
public async Task <List <CourseInstance> > GetAllCourseInstancesPerGivenWeek(int?weeknr, int?year)
{
List <CourseInstance> instances = new List <CourseInstance>();
foreach (var instance in await GetAllCourseInstances())
{
var ciWeeknr = ISOWeek.GetWeekOfYear(instance.StartDate);
var ciYear = ISOWeek.GetYear(instance.StartDate);
if (weeknr == ciWeeknr && year == ciYear)
{
instances.Add(instance);
}
}
return(instances);
}
public async Task <IReadOnlyList <MeasuredBonusProduct> > GetRecentAndHistory()
{
var currentWeek = ISOWeek.GetWeekOfYear(DateTime.Now);
var currentYear = DateTime.Now.Year;
var result = new List <MeasuredBonusProduct>();
var query = @"select [Id]
,[Title]
,[BonusOccurance]
,[Brand]
,[Store]
,[Category]
,[Link]
,[StartDate]
,[EndDate]
,[FromPriceInCents]
,[ForPriceInCents]
,[Delta]
,[DiscountText]
,[UnitSize]
,[ActiveAtNumberOfProducts]
,[Week]
,[Year]
from [dbo].[vwBonusView] order by [Id], [Year] desc, [Week] desc";
using (var connection = new SqlConnection(this.ConnectionString))
{
var command = new SqlCommand(query, connection);
await connection.OpenAsync().ConfigureAwait(false);
using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false))
{
while (await reader.ReadAsync().ConfigureAwait(false))
{
var item = CreateMeassuredBonusProduct(reader);
if (item != null)
{
result.Add(item);
}
}
await reader.CloseAsync().ConfigureAwait(false);
}
}
result.RemoveAll(x => x.Prices.Count(y => y.Week == currentWeek && y.Year == currentYear) == 0);
return(result.OrderBy(x => x.RawCategory).ToList());
}
public static IEnumerable <Week> Group(IEnumerable <MDFile> files)
{
files = files.OrderByDescending(x => x.CreatedAt);
var days = files.GroupBy(x => x.CreatedAt.Date)
.OrderByDescending(x => x.Key);
var weeks = days.GroupBy(x => ISOWeek.GetWeekOfYear(x.Key));
return(weeks.Select(MapWeek));
Week MapWeek(IGrouping <int, IGrouping <DateTime, MDFile> > weekGroup)
=> new Week(weekGroup.Key,
weekGroup.Select(MapDay));
Day MapDay(IGrouping <DateTime, MDFile> dayGroup)
=> new Day(dayGroup.Key, dayGroup);
}
public async Task <IActionResult> Schedule(int laundryRoomId, int weekNumber)
{
if (laundryRoomId == 0)
{
return(RedirectToAction("Index"));
}
if (weekNumber == 0)
{
weekNumber = ISOWeek.GetWeekOfYear(DateTime.Today);
}
var schedule = await _bookingSessionService.GetSchedule(laundryRoomId, weekNumber);
var scheduleViewModel = _mapper.Map <ScheduleViewModel>(schedule);
return(View(scheduleViewModel));
}
public async Task <IEnumerable <Activity> > GetActivities(int year, int week, string?teamName = null)
{
var weekEnd = new DateTimeOffset(ISOWeek.ToDateTime(year, week, DayOfWeek.Sunday));
var weekEndFilter = Builders <Activity> .Filter.Lte(a => a.DateTime, weekEnd);
var weekStart = weekEnd.Subtract(TimeSpan.FromDays(6));
var startWeekFilter = Builders <Activity> .Filter.Gte(a => a.DateTime, weekStart);
var cursor = await _db.GetCollection <Activity>("Activities").FindAsync(weekEndFilter & startWeekFilter);
var activities = await cursor.ToListAsync();
if (teamName != null)
{
return(activities.Where(a => a.User.Team.Equals(teamName, StringComparison.InvariantCultureIgnoreCase)));
}
return(activities);
}
public async Task <Tax> PostTaxWeekly(TaxDto taxDto)
{
Frequency frequency = Frequency.Weekly;
// provide dates for weekly schedule
int year = DateTime.Now.Year;
DateTime startDate = ISOWeek.ToDateTime(year, taxDto.Week, DayOfWeek.Monday);
DateTime endDate = ISOWeek.ToDateTime(year, taxDto.Week, DayOfWeek.Sunday);
Tax tax = new Tax()
{
Municipality = taxDto.Municipality,
Frequency = frequency,
StartDate = startDate,
EndDate = endDate,
TaxAmount = taxDto.TaxAmount
};
return(await AddTax(tax));
}
public EmployeeSeed()
{
faker = new Faker();
string[] statusNames = new[] { EmployeeStatus.Enabled.CodeName, EmployeeStatus.Disabled.CodeName };
float[] statusWeights = new[] { .98f, .02f };
employeeGenerator = new DomainFaker <EmployeeDetail>(faker => new EmployeeDetail(Guid.NewGuid()))
.RuleFor(e => e.Department, f => f.PickRandom(EmployeeDepartment.All.Select(s => s.CodeName).ToList()))
.RuleFor(e => e.FirstName, f => f.Name.FirstName())
.RuleFor(e => e.LastName, f => f.Name.LastName())
.RuleFor(e => e.EmploymentStartedOn, f => f.Date.PastOffset(10))
.RuleFor(e => e.Phone, f => f.Phone.PhoneNumber())
.RuleFor(e => e.Title, f => f.Name.JobTitle())
.RuleFor(e => e.Status, f => f.Random.WeightedRandom(statusNames, statusWeights))
.RuleFor(e => e.Email, (f, e) => f.Internet.Email(e.FirstName, e.LastName));
employeePayrollGenerator = new DomainFaker <EmployeePayroll>(faker => new EmployeePayroll(Guid.NewGuid()))
.RuleFor(e => e.CheckDate, f => f.Date.Past())
.RuleFor(e => e.GrossPayroll, f => f.Finance.Amount(300, 2_500))
.RuleFor(e => e.PayrollPeriod, (f, e) => (ISOWeek.GetWeekOfYear(e.CheckDate.DateTime) / 2).ToString().PadLeft(2, '0'));
}
public async Task InsertRanks(int year, int week, IEnumerable <RankInputModel> input)
{
var ranksCollection = this.db.GetCollection <Rank>("Ranks");
var t = ISOWeek.GetWeeksInYear(year - 1);
Expression <Func <Rank, bool> > filter;
if (week == 1)
{
filter = rank => rank.Year == year - 1 && rank.Week == t;
}
else
{
filter = rank => rank.Year == year && rank.Week == week - 1;
}
var previousRanks = (await ranksCollection.AsQueryable()
.Where(filter)
.Select(rank => new { rank.PlayerId, rank.RankNumber })
.ToListAsync())
.ToDictionary(rank => rank.PlayerId, rank => rank.RankNumber);
var ranks = mapper.Map <IEnumerable <Rank> >(input).ToList();
ranks.ForEach(rank =>
{
rank.Year = year;
rank.Week = week;
rank.WeekDuration =
ISOWeek.ToDateTime(year, week, DayOfWeek.Monday).ToString("dd.MM.yyyy")
+ " - "
+ ISOWeek.ToDateTime(year, week, DayOfWeek.Sunday).ToString("dd.MM.yyyy");
rank.PreviousRankNumber = previousRanks.ContainsKey(rank.PlayerId) ? previousRanks[rank.PlayerId] : 0;
});
await ranksCollection.InsertManyAsync(ranks);
}
public ActionResult About()
{
///////////////////////////////////////// Manipulating Dates
///Timespan is usefull to manipulate dates
var timespan = new TimeSpan(60, 100, 200);
ViewBag.timespan = timespan;
ViewBag.timespann = timespan.Hours;
ViewBag.timespannd = timespan.TotalHours;
ViewBag.Message = "Your application description page.";
/////////////////// making use of timespan to calculate
var start = DateTime.UtcNow;
var end = start.AddSeconds(45);
TimeSpan difference = end - start;
ViewBag.difference = difference.Seconds;
/////////////////get week number
Calendar calender = CultureInfo.InvariantCulture.Calendar;
var startweek = new DateTimeOffset(2007, 12, 31, 0, 0, 0, TimeSpan.Zero);
var week = calender.GetWeekOfYear(startweek.DateTime, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
var Isoweek = ISOWeek.GetIso8601WeekOfYear(startweek.DateTime);
ViewBag.week = week;
ViewBag.Isoweek = Isoweek;
//////////////////////////////////// extending dates
var extendweek = new DateTimeOffset(2007, 12, 31, 0, 0, 0, TimeSpan.Zero);
ViewBag.extendweek = extendweek;
ViewBag.extended = ExtendDates.ExtendMonths(extendweek, 6);
return(View());
}
public async Task <IEnumerable <RankOutputModel> > GetTopRatedPlayers(int year, int week, int topCount)
{
if (year == 0 || week == 0)
{
var currentDate = DateTime.Now.AddDays(-7);
year = ISOWeek.GetYear(currentDate);
week = ISOWeek.GetWeekOfYear(currentDate);
}
var ranksCollection = this.db.GetCollection <Rank>("Ranks");
var playersCollection = this.db.GetCollection <Player>("Players");
var ranks = (await ranksCollection.AsQueryable()
.Where(rank => rank.Year == year && rank.Week == week)
.OrderBy(rank => rank.RankNumber)
.Take(topCount)
.Join(playersCollection,
rank => rank.PlayerId,
player => player.Id,
(rank, player) => new
{
Picture = player.Picture,
Model = new RankOutputModel
{
FirstName = player.FirstName,
LastName = player.LastName,
PlayerId = player.Id,
Points = rank.Points,
Country = player.Country,
PreviousRank = rank.PreviousRankNumber,
Rank = rank.RankNumber,
}
})
.ToListAsync());
return(ranks.Select(x => { x.Model.Picture = Encoding.Unicode.GetString(x.Picture); return x.Model; }));
}
public override Task <ActionResult <EmployeePayroll> > HandleAsync([FromBody] EmployeePayrollCreateRequest request, CancellationToken token) =>
queryDispatcher
.Dispatch(new EmployeeQuery(request.EmployeeId), token)
.Bind(employee =>
{
string payrollPeriod = (ISOWeek.GetWeekOfYear(request.CheckDate.DateTime) / 2).ToString().PadLeft(2, '0');
var newPayroll = new EmployeePayrollNew
{
CheckDate = request.CheckDate,
GrossPayroll = request.GrossPayroll,
PayrollPeriod = payrollPeriod
};
var newPayrollId = generator.Generate();
var command = new EmployeePayrollCreateCommand(employee, newPayrollId, newPayroll);
return(commandDispatcher.Dispatch(command).ToTryOption());
})
.Match <EmployeePayroll, ActionResult <EmployeePayroll> >(
employeePayroll => employeePayroll,
() => NotFound($"Could not find employee [{request.EmployeeId}]"),
ex => new APIErrorResult(ex.Message));
public void RequestActivitySummaryLeaderboardDataMessageHandler(RequestActivitySummaryLeaderboardDataMessage message, Player player)
{
using var ctx = new UchuContext();
// Get current year and week number according to ISO 8601
var yearAndWeek = ISOWeek.GetYear(DateTime.Now) * 100 + ISOWeek.GetWeekOfYear(DateTime.Now);
// Find leaderboard entries for this activity
// If weekly leaderboard is requested, only return results from current week
var leaderboardQueryable = ctx.ActivityScores
.Where(score => score.Activity == message.GameId &&
(message.Weekly ? score.Week == yearAndWeek : score.Week == 0));
// Find leaderboard type
var activity = ClientCache.Find <Activities>(message.GameId);
var leaderboardType = (LeaderboardType)(activity?.LeaderboardType ?? -1);
// For some reason, whoever made this in 2011 gave the the NS and NT footraces the
// same activity ID. So for footraces, we filter by zone ID to ensure we don't mix
// the leaderboards. But this check shouldn't be done for other leaderboards, as
// Survival minigames have their leaderboards accessible from multiple zones.
if (leaderboardType == LeaderboardType.Footrace)
{
leaderboardQueryable = leaderboardQueryable.Where(score => score.Zone == (int)player.Zone.ZoneId);
}
// Order either by time ascending or time descending depending on which kind of activity it is
if (leaderboardType == LeaderboardType.Footrace ||
leaderboardType == LeaderboardType.AvantGardensSurvival ||
leaderboardType == LeaderboardType.BattleOfNimbusStation)
{
leaderboardQueryable = leaderboardQueryable.OrderByDescending(score => score.Time);
}
else
{
leaderboardQueryable = leaderboardQueryable.OrderBy(score => score.Time);
}
var leaderboard = leaderboardQueryable.ToList();
// Dictionary <rank, score>
// Rank is what the client will show as position on the leaderboard
var toSend = new Dictionary <int, ActivityScore>();
switch (message.QueryType)
{
case QueryType.TopSocial:
// TODO: Friends.
break;
case QueryType.TopAll:
// Top 10.
for (var i = message.ResultsStart; i < message.ResultsEnd && i < leaderboard.Count; i++)
{
toSend.Add(i + 1, leaderboard[i]);
}
break;
case QueryType.TopCharacter:
// Leaderboard around this player's rank.
var playerIndex = leaderboard.FindIndex(score => score.CharacterId == player.Id);
// If player is not in leaderboard, return (client will show a friendly message telling the player
// to first complete the activity)
if (playerIndex == -1)
{
break;
}
var availableBefore = playerIndex;
var availableAfter = leaderboard.Count - playerIndex;
// By default we show 5 scores before this player's, and 4 after (last index isn't included).
var includeBefore = 5;
var includeAfter = 5;
// For every step we can't go before, add one to after
includeAfter += Math.Max(0, 5 - availableBefore);
// For every step we can't go after, add one to before
includeBefore += Math.Max(0, 5 - availableAfter);
// Ensure we don't go outside the leaderboard limits
var startIndex = Math.Max(0, playerIndex - includeBefore);
var stopIndex = Math.Min(leaderboard.Count, playerIndex + includeAfter);
for (var i = startIndex; i < stopIndex; i++)
{
toSend.Add(i + 1, leaderboard[i]);
}
break;
}
// "Properly" implementing this odd nested-dictionaries-and-arrays-inside-LDF didn't seem
// particularly fun and/or useful; this implementation just does everything needed for leaderboards.
var data = new LegoDataDictionary
{
{ "ADO.Result", true },
{ "Result.Count", 1 },
{ "Result[0].Index", "RowNumber" },
{ "Result[0].RowCount", toSend.Count },
};
var index = 0;
foreach (var(rank, activityScore) in toSend)
{
var characterName = ctx.Characters.FirstOrDefault(c => c.Id == activityScore.CharacterId)?.Name
?? "Deleted Character";
data.Add($"Result[0].Row[{index}].CharacterID", activityScore.CharacterId);
data.Add($"Result[0].Row[{index}].LastPlayed", activityScore.LastPlayed);
data.Add($"Result[0].Row[{index}].NumPlayed", activityScore.NumPlayed);
data.Add($"Result[0].Row[{index}].RowNumber", rank);
data.Add($"Result[0].Row[{index}].Time", activityScore.Time);
data.Add($"Result[0].Row[{index}].Points", activityScore.Points);
data.Add($"Result[0].Row[{index}].name", characterName);
// TODO: ".Relationship" variable (int).
// (AGS client script: if not 0, FoundFriendGuild set to true. Teams?)
// data.Add($"Result[0].Row[{index}].Relationship", 0);
index++;
}
player.Message(new SendActivitySummaryLeaderboardDataMessage
{
Associate = player,
GameId = message.GameId,
InfoType = (int)message.QueryType,
LeaderboardData = data,
Throttled = false,
Weekly = message.Weekly,
});
}
public static DateTime FirstDateOfISO8601Week(int year, int weekNum) => ISOWeek.ToDateTime(year, weekNum, DayOfWeek.Monday);
