public static async Task<UserAccounts> RegisterUser(ToracGolfContext dbContext, SignUpEnteredDataBase signUpModel)
{
//go either get the ref season record or add it
var refSeasonRecord = await SeasonDataProvider.RefSeasonAddOrGet(dbContext, signUpModel.CurrentSeason).ConfigureAwait(false);
//user to add
var userToAdd = new UserAccounts
{
StateId = Convert.ToInt32(signUpModel.HomeState),
CreatedDate = DateTime.Now,
CurrentSeasonId = refSeasonRecord.SeasonId,
EmailAddress = signUpModel.Email,
FirstName = signUpModel.FirstName,
LastName = signUpModel.LastName,
Password = signUpModel.Password
};
//go try to add the user
dbContext.Users.Add(userToAdd);
//go save the changes
await dbContext.SaveChangesAsync().ConfigureAwait(false);
//add the user season now
await SeasonDataProvider.UserSeasonAdd(dbContext, userToAdd.UserId, refSeasonRecord).ConfigureAwait(false);
//return the user now
return await dbContext.Users.AsNoTracking().FirstAsync(x => x.UserId == userToAdd.UserId).ConfigureAwait(false);
}
private static Task<Last20Rounds[]> HandicapCalculatorRoundSelectorHelper(ToracGolfContext dbContext, int userId, int? seasonId)
{
//go build the base query
var query = (from myRounds in dbContext.Rounds.AsNoTracking()
join myTeeLocations in dbContext.CourseTeeLocations.AsNoTracking()
on new { myRounds.CourseId, myRounds.CourseTeeLocationId } equals new { myTeeLocations.CourseId, myTeeLocations.CourseTeeLocationId }
where myRounds.UserId == userId
orderby myRounds.RoundDate descending, myRounds.RoundId descending
select new
{
myRounds.RoundId,
myRounds.Score,
myRounds.SeasonId,
myTeeLocations.Rating,
myTeeLocations.Slope
}).Take(20).AsQueryable();
//do we need to add the season?
if (seasonId.HasValue)
{
//tack on the season
query = query.Where(x => x.SeasonId == seasonId.Value);
}
//go grab the last 20 rounds class and return the task
return query.Select(x => new Last20Rounds
{
RoundId = x.RoundId,
RoundScore = x.Score,
Rating = x.Rating,
Slope = x.Slope
}).ToArrayAsync();
}
public SecurityController(IMemoryCache cache, ICacheFactoryStore cacheFactoryStore, ToracGolfContext dbContext, IOptions<AppSettings> configuration, ILogger<SecurityController> logger)
{
DbContext = dbContext;
Cache = cache;
CacheFactory = cacheFactoryStore;
Configuration = configuration;
Logger = logger;
}
public static async Task ChangePassword(ToracGolfContext dbContext, int userId, string password)
{
var user = await dbContext.Users.FirstAsync(x => x.UserId == userId).ConfigureAwait(false);
user.Password = password;
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
public SettingsController(IMemoryCache cache, ICacheFactoryStore cacheFactoryStore, ToracGolfContext dbContext, IAntiforgery antiforgery, IOptions<AppSettings> configuration)
{
DbContext = dbContext;
Cache = cache;
CacheFactory = cacheFactoryStore;
Antiforgery = antiforgery;
Configuration = configuration;
}
public NewsFeedCommentRepository(ToracGolfContext dbContext)
{
DbContext = dbContext;
//just set the method....we are doing this so the calling user doesn't have to populate it in a variable first
SelectCommand = SelectCommentsBuilder();
//UserProfileFinder = userProfileFinder;
}
public static async Task<IDictionary<int, string>> SeasonSelectForUser(ToracGolfContext dbContext, int userId)
{
return await (from mySeasons in dbContext.UserSeason.AsNoTracking()
join refSeasons in dbContext.Ref_Season.AsNoTracking()
on mySeasons.SeasonId equals refSeasons.SeasonId
where mySeasons.UserId == userId
orderby mySeasons.Rounds.Select(x => x.RoundDate).DefaultIfEmpty(DateTime.MaxValue).Min() descending
select refSeasons).ToDictionaryAsync(x => x.SeasonId, x => x.SeasonText).ConfigureAwait(false);
}
private static IQueryable<DashboardRoundDisplay> BuildSelectStatement(ToracGolfContext dbContext, IOrderedQueryable<Round> sortedQuery)
{
return sortedQuery.Take(5).Select(x => new DashboardRoundDisplay
{
CourseId = x.Course.CourseId,
RoundDate = x.RoundDate,
Score = x.Score,
CourseName = x.Course.Name,
TeeBoxLocation = dbContext.CourseTeeLocations.FirstOrDefault(y => y.CourseTeeLocationId == x.CourseTeeLocationId).Description
});
}
public static async Task<int> CourseAdd(ToracGolfContext dbContext, int userId, CourseAddEnteredData CourseData, string courseSavePath)
{
//course record to add
var courseToAdd = new Course
{
Name = CourseData.CourseName,
Description = CourseData.Description,
IsActive = true,
Pending = true,
City = CourseData.City,
StateId = Convert.ToInt32(CourseData.StateListing),
UserIdThatCreatedCourse = userId,
OnlyAllow18Holes = CourseData.OnlyAllow18Holes,
CreatedDate = DateTime.Now
};
courseToAdd.CourseTeeLocations = CourseData.TeeLocations.Select((x, i) => new CourseTeeLocations
{
CourseId = courseToAdd.CourseId,
Description = x.Description,
TeeLocationSortOrderId = i,
Front9Par = x.Front9Par.Value,
Back9Par = x.Back9Par.Value,
Rating = x.Rating.Value,
Slope = x.Slope.Value,
Yardage = x.Yardage.Value,
FairwaysOnCourse = 18 - x.NumberOfPar3s.Value
}).ToArray();
//add the course to the context
dbContext.Course.Add(courseToAdd);
//go save it
await dbContext.SaveChangesAsync().ConfigureAwait(false);
//do we have a course image?
if (CourseData.CourseImage != null)
{
//grab the byte array for the file
var fileToSave = ToracLibrary.Core.Graphics.GraphicsUtilities.ImageFromJsonBase64String(CourseData.CourseImage);
//grab where we have the actual .jpg vs png
var indexOfSlash = fileToSave.MimeType.IndexOf(@"/");
//grab the file name to save
var fileNameToSave = System.IO.Path.Combine(courseSavePath, string.Format("{0}.{1}", courseToAdd.CourseId, fileToSave.MimeType.Substring(indexOfSlash + 1, fileToSave.MimeType.Length - indexOfSlash - 1)));
//go save the file
System.IO.File.WriteAllBytes(fileNameToSave, fileToSave.FileBytes);
}
//return the course id
return courseToAdd.CourseId;
}
public async Task<IEnumerable<NewsFeedCommentRow>> CommentSelect(ToracGolfContext dbContext, int userId, int id, NewsFeedItemModel.NewsFeedTypeId newsFeedTypeId, ImageFinder userImageFinder)
{
var data = await CommentRepository.GetComments().AsNoTracking()
.Where(x => x.AreaId == id && x.NewsFeedTypeId == (int)newsFeedTypeId)
.OrderByDescending(x => x.CreatedDate)
.Select(CommentRepository.SelectCommand).ToListAsync().ConfigureAwait(false);
data.ForEach(x => x.UserProfileUrl = userImageFinder.FindImage(x.UserIdThatMadeComment));
return data;
}
public static async Task<IEnumerable<CourseForRoundAddScreen>> ActiveCoursesSelectForState(ToracGolfContext dbContext, int stateId)
{
return await dbContext.Course.AsNoTracking()
.Where(x => x.StateId == stateId && x.IsActive)
.OrderBy(x => x.Name)
.Select(x => new CourseForRoundAddScreen
{
CourseId = x.CourseId,
Name = x.Name,
}).ToArrayAsync();
}
private static IQueryable<Round> BuildBaseQuery(ToracGolfContext dbContext, int userId, int? seasonId)
{
var baseQuery = dbContext.Rounds.AsNoTracking().Where(x => x.UserId == userId);
if (seasonId.HasValue)
{
baseQuery = baseQuery.Where(x => x.SeasonId == seasonId);
}
return baseQuery;
}
public RoundController(IMemoryCache cache,
ICacheFactoryStore cacheFactoryStore,
ToracGolfContext dbContext,
IAntiforgery antiforgery,
IOptions<AppSettings> configuration,
IListingFactory<RoundListingFactory.RoundListingSortEnum, Round, RoundListingData> roundListingFactory)
{
DbContext = dbContext;
Cache = cache;
CacheFactory = cacheFactoryStore;
Antiforgery = antiforgery;
Configuration = configuration;
RoundListingFactory = roundListingFactory;
}
public CourseController(IMemoryCache cache,
ICacheFactoryStore cacheFactoryStore,
ToracGolfContext dbContext,
IAntiforgery antiforgery,
IOptions<AppSettings> configuration,
IListingFactory<CourseListingFactory.CourseListingSortEnum, Course, CourseListingData> courseListingFactory)
{
DbContext = dbContext;
Cache = cache;
CacheFactory = cacheFactoryStore;
Antiforgery = antiforgery;
Configuration = configuration;
CourseListingFactory = courseListingFactory;
}
public static async Task<IEnumerable<KeyValuePair<string, int>>> RoundPieChart(ToracGolfContext dbContext, int userId, int? seasonId)
{
var baseQuery = BuildBaseQuery(dbContext, userId, seasonId);
var lst = new List<KeyValuePair<string, int>>();
lst.Add(new KeyValuePair<string, int>("70's", await baseQuery.CountAsync(x => x.Score < 80).ConfigureAwait(false)));
lst.Add(new KeyValuePair<string, int>("80's", await baseQuery.CountAsync(x => x.Score >= 80 && x.Score <= 89).ConfigureAwait(false)));
lst.Add(new KeyValuePair<string, int>("90's", await baseQuery.CountAsync(x => x.Score >= 90 && x.Score <= 99).ConfigureAwait(false)));
lst.Add(new KeyValuePair<string, int>("100's", await baseQuery.CountAsync(x => x.Score >= 100 && x.Score <= 109).ConfigureAwait(false)));
lst.Add(new KeyValuePair<string, int>("> 110", await baseQuery.CountAsync(x => x.Score >= 110).ConfigureAwait(false)));
return lst.Where(x => x.Value > 0).ToArray();
}
public HomeController(IMemoryCache cache,
ICacheFactoryStore cacheFactoryStore,
ToracGolfContext dbContext,
IAntiforgery antiforgery,
IOptions<AppSettings> configuration,
Lazy<NewsFeedDataProvider> newsFeedDataProvider)
{
DbContext = dbContext;
Cache = cache;
CacheFactory = cacheFactoryStore;
Antiforgery = antiforgery;
Configuration = configuration;
NewsFeedDataProvider = newsFeedDataProvider;
}
public static async Task<IEnumerable<DashboardHandicapScoreSplitDisplay>> ScoreHandicapGraph(ToracGolfContext dbContext, int userId, int? seasonId)
{
//var minDateToGrab = DateTime.Now.AddYears(-1);
//just grab the last year so we don't grab globs of data
return await BuildBaseQuery(dbContext, userId, seasonId).OrderBy(x => x.RoundDate).Take(20)
.Select(x => new DashboardHandicapScoreSplitDisplay
{
Month = x.RoundDate.Month,
Day = x.RoundDate.Day,
Year = x.RoundDate.Year,
Score = x.Score,
Handicap = dbContext.Handicap.FirstOrDefault(y => y.RoundId == x.RoundId).HandicapAfterRound
}).ToArrayAsync().ConfigureAwait(false);
}
public async Task<IEnumerable<NewsFeedCommentRow>> CommentAdd(ToracGolfContext dbContext, int userId, int id, NewsFeedItemModel.NewsFeedTypeId newsFeedTypeId, string commentToAdd, ImageFinder userImageFinder)
{
//lets go add the row
await CommentRepository.Add(new NewsFeedComment
{
AreaId = id,
NewsFeedTypeId = (int)newsFeedTypeId,
UserIdThatCommented = userId,
CreatedDate = DateTime.Now,
Comment = commentToAdd
});
//go return this posts comment
return await CommentSelect(dbContext, userId, id, newsFeedTypeId, userImageFinder);
}
public static async Task<HandicapProgression> HandicapProgression(ToracGolfContext dbContext, int userId, int? seasonId)
{
var query = dbContext.Rounds.Include(x => x.Handicap).AsNoTracking()
.Where(x => x.UserId == userId);
if (seasonId.HasValue)
{
query = query.Where(x => x.SeasonId == seasonId.Value);
}
return await query.OrderByDescending(x => x.RoundDate).OrderByDescending(x => x.RoundId).Select(x => new HandicapProgression
{
HandicapBeforeRound = x.Handicap.HandicapBeforeRound,
HandicapAfterRound = x.Handicap.HandicapAfterRound
}).FirstOrDefaultAsync().ConfigureAwait(false);
}
public static IQueryable<Course> CourseSelectQueryBuilder(ToracGolfContext dbContext,
IListingFactory<CourseListingFactory.CourseListingSortEnum, Course, CourseListingData> courseListingFactory,
string courseNameFilter,
int? stateFilter)
{
//build the queryable
var queryable = dbContext.Course.AsNoTracking().Where(x => x.IsActive).AsQueryable();
//go build the query
queryable = FilterBuilder.BuildQueryFilter(dbContext, queryable, courseListingFactory,
new KeyValuePair<string, object>(nameof(courseNameFilter), courseNameFilter),
new KeyValuePair<string, object>(nameof(stateFilter), stateFilter));
//return the queryable
return queryable;
}
public static async Task<IEnumerable<SeasonListingData>> SeasonListingForGrid(ToracGolfContext dbContext, int userId)
{
return await (from mySeasons in dbContext.UserSeason.AsNoTracking()
join refSeasons in dbContext.Ref_Season.AsNoTracking()
on mySeasons.SeasonId equals refSeasons.SeasonId
where mySeasons.UserId == userId
orderby mySeasons.Rounds.Select(x => x.RoundDate).DefaultIfEmpty(DateTime.MaxValue).Min() descending
select new SeasonListingData
{
Description = refSeasons.SeasonText,
SeasonId = refSeasons.SeasonId,
NumberOfRounds = mySeasons.Rounds.Count(),
TopScore = mySeasons.Rounds.Min(x => x.Score),
WorseScore = mySeasons.Rounds.Max(x => x.Score),
AverageScore = mySeasons.Rounds.Average(x => x.Score),
}).ToArrayAsync().ConfigureAwait(false);
}
public static async Task<UserSeason> UserSeasonAdd(ToracGolfContext dbContext, int userId, Ref_Season refSeasonRecord)
{
//record to add
var recordToAdd = new UserSeason
{
UserId = userId,
SeasonId = refSeasonRecord.SeasonId,
CreatedDate = DateTime.Now
};
//add the record
dbContext.UserSeason.Add(recordToAdd);
//go save the changes
await dbContext.SaveChangesAsync().ConfigureAwait(false);
//return the record now
return recordToAdd;
}
public static async Task<Ref_Season> RefSeasonAddOrGet(ToracGolfContext dbContext, string seasonText)
{
//let's first try to find the season with the same name
var seasonToAdd = await dbContext.Ref_Season.AsNoTracking().FirstOrDefaultAsync(x => x.SeasonText == seasonText).ConfigureAwait(false);
//didn't find a season with this name
if (seasonToAdd == null)
{
//create the new season
seasonToAdd = new Ref_Season { SeasonText = seasonText, CreatedDate = DateTime.Now };
//add the record
dbContext.Ref_Season.Add(seasonToAdd);
//we need to save it for foreign key
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
//return the record
return seasonToAdd;
}
public static async Task<int> SaveRound(ToracGolfContext dbContext, int userId, int seasonId, RoundAddEnteredData roundData)
{
//build the round record
var round = new Round
{
CourseId = roundData.CourseId,
CourseTeeLocationId = roundData.TeeLocationId,
RoundDate = roundData.RoundDate,
Is9HoleScore = roundData.NineHoleScore,
Score = roundData.Score.Value,
UserId = userId,
SeasonId = seasonId,
GreensInRegulation = roundData.GreensInRegulation,
Putts = roundData.Putts,
FairwaysHit = roundData.FairwaysHit
};
//go grab the tee location
var teeLocation = await dbContext.CourseTeeLocations.AsNoTracking().FirstAsync(x => x.CourseTeeLocationId == roundData.TeeLocationId).ConfigureAwait(false);
//add the round handicap now
round.RoundHandicap = Handicapper.CalculateHandicap(new Last20Rounds[] { new Last20Rounds { Rating = teeLocation.Rating, Slope = teeLocation.Slope, RoundScore = round.Score } }).Value;
//add the round
dbContext.Rounds.Add(round);
//save the round
//await dbContext.SaveChangesAsync();
dbContext.SaveChanges();
//we need to go add the handicap records
await RefreshHandicapRecords(dbContext, userId);
//return the round id
return round.RoundId;
}
public static async Task<IEnumerable<TeeBoxSelectForCourseSelect>> TeeBoxSelectForCourse(ToracGolfContext dbContext, int courseId, double? currentHandicap)
{
var dbResults = await dbContext.CourseTeeLocations.AsNoTracking()
.Where(x => x.CourseId == courseId).ToArrayAsync();
var lst = new List<TeeBoxSelectForCourseSelect>();
foreach (var teeBox in dbResults)
{
var teeBoxModel = new TeeBoxSelectForCourseSelect
{
Back9Par = teeBox.Back9Par,
Front9Par = teeBox.Front9Par,
CourseId = teeBox.CourseId,
CourseTeeLocationId = teeBox.CourseTeeLocationId,
Description = teeBox.Description,
Rating = teeBox.Rating,
Slope = teeBox.Slope,
Yardage = teeBox.Yardage,
TeeLocationSortOrderId = teeBox.TeeLocationSortOrderId
};
//now add the course handicap and the max score
teeBoxModel.CourseTeeBoxHandicap = Handicapper.CalculateCourseHandicap(currentHandicap, teeBoxModel.Slope);
//now calculate the score
teeBoxModel.MaxScorePerHole = Handicapper.MaxScorePerHole(teeBoxModel.CourseTeeBoxHandicap);
//add the tee box score
lst.Add(teeBoxModel);
}
//return the list
return lst;
}
public static async Task<bool> DeleteARound(ToracGolfContext dbContext, int roundIdToDelete)
{
//grab the round
var roundToDelete = await dbContext.Rounds.FirstOrDefaultAsync(x => x.RoundId == roundIdToDelete);
//remove the round
dbContext.Rounds.Remove(roundToDelete);
//save the changes
await dbContext.SaveChangesAsync().ConfigureAwait(false);
//return a true result
return true;
}
public static async Task<int> TotalNumberOfRounds(ToracGolfContext dbContext, IListingFactory<RoundListingFactory.RoundListingSortEnum, Round, RoundListingData> roundListingFactory, int userId, string roundNameFilter, int? StateFilter, DateTime? roundDateStartFilter, DateTime? roundDateEndFilter, bool onlyHandicappedRounds)
{
return await RoundSelectQueryBuilder(dbContext, roundListingFactory, userId, roundNameFilter, StateFilter, roundDateStartFilter, roundDateEndFilter, onlyHandicappedRounds).CountAsync().ConfigureAwait(false);
}
public static async Task<RoundSelectModel> RoundSelect(IListingFactory<RoundListingFactory.RoundListingSortEnum, Round, RoundListingData> roundListingFactory,
ToracGolfContext dbContext,
int userId,
int pageId,
RoundListingFactory.RoundListingSortEnum sortBy,
string courseNameFilter,
int? seasonFilter,
int recordsPerPage,
DateTime? roundDateStartFilter,
DateTime? roundDateEndFilter,
ImageFinder courseImageFinder,
bool handicappedRoundOnly)
{
//go grab the query
var queryable = RoundSelectQueryBuilder(dbContext, roundListingFactory, userId, courseNameFilter, seasonFilter, roundDateStartFilter, roundDateEndFilter, handicappedRoundOnly);
//go sort the data
var sortedQueryable = roundListingFactory.SortByConfiguration[sortBy](queryable, new ListingFactoryParameters(dbContext, userId)).ThenBy(x => x.RoundId);
//go return the queryable
var selectableQuery = sortedQueryable.Select(x => new RoundListingData
{
RoundId = x.RoundId,
CourseId = x.CourseId,
CourseName = x.Course.Name,
RoundDate = x.RoundDate,
Score = x.Score,
SeasonId = x.SeasonId,
TeeBoxLocation = x.CourseTeeLocation,
HandicapBeforeRound = x.Handicap.HandicapBeforeRound,
Putts = x.Putts,
FairwaysHit = x.FairwaysHit,
GreensInRegulation = x.GreensInRegulation,
RoundHandicap = x.RoundHandicap
});
//go run the query now
var dataSet = await EFPaging.PageEfQuery(selectableQuery, pageId, recordsPerPage).ToListAsync().ConfigureAwait(false);
//let's loop through the rounds and display the starts
foreach (var round in dataSet)
{
//calculate the adjusted score
round.AdjustedScore = Convert.ToInt32(Math.Round(round.Score - round.HandicapBeforeRound, 0));
//go calculate the round performance
round.RoundPerformance = (int)RoundPerformance.CalculateRoundPerformance(round.TeeBoxLocation.Front9Par + round.TeeBoxLocation.Back9Par, round.AdjustedScore);
//set the image path
round.CourseImagePath = courseImageFinder.FindImage(round.CourseId);
}
//go return the lookup now
return new RoundSelectModel(dataSet);
}
public static IQueryable<Round> RoundSelectQueryBuilder(ToracGolfContext dbContext,
IListingFactory<RoundListingFactory.RoundListingSortEnum, Round, RoundListingData> roundListingFactory,
int userId,
string courseNameFilter,
int? seasonFilter,
DateTime? roundDateStartFilter,
DateTime? roundDateEndFilter,
bool handicappedRoundsOnly)
{
//build the queryable
var queryable = dbContext.Rounds.AsNoTracking().Where(x => x.UserId == userId).AsQueryable();
//go build the query filters
queryable = FilterBuilder.BuildQueryFilter(dbContext, queryable, roundListingFactory,
new KeyValuePair<string, object>(nameof(courseNameFilter), courseNameFilter),
new KeyValuePair<string, object>(nameof(seasonFilter), seasonFilter),
new KeyValuePair<string, object>(nameof(roundDateStartFilter), roundDateStartFilter),
new KeyValuePair<string, object>(nameof(roundDateStartFilter), roundDateStartFilter),
new KeyValuePair<string, object>(nameof(handicappedRoundsOnly), handicappedRoundsOnly));
//if (handicappedRoundsOnly)
//{
// //how many rounds do we have?
// int roundsWeHaveInQuery = queryable.Count();
// //now check how many are in the calculation
// var howManyToCalculateWith = Handicapper.HowManyRoundsToUseInFormula(roundsWeHaveInQuery > 20 ? 20 : roundsWeHaveInQuery);
// //now just grab the last 20
// var last20RoundIds = queryable.OrderByDescending(x => x.RoundDate)
// .ThenByDescending(x => x.RoundId)
// .Take(20) //we only ever get the last 20...
// .OrderBy(x => x.RoundHandicap) //now grab the lowest rated rounds of how many we are going to calculate with
// .Take(howManyToCalculateWith) //then grab just those
// .Select(x => x.RoundId).ToArray();
// //add the round id's to the query
// queryable = queryable.Where(x => last20RoundIds.Contains(x.RoundId));
//}
//return the query
return queryable;
}
public static async Task<bool> RefreshHandicapRecords(ToracGolfContext dbContext, int userId)
{
//let's go delete all the handicap records
var roundsToDelete = await (from myData in dbContext.Rounds
join myHandicaps in dbContext.Handicap
on myData.RoundId equals myHandicaps.RoundId
where myData.UserId == userId
select myHandicaps).ToArrayAsync();
//delete all handicap records
dbContext.Handicap.RemoveRange(roundsToDelete);
//save the deletions
await dbContext.SaveChangesAsync();
//5. let's go rebuild all the handicap records
var roundsForUser = await dbContext.Rounds.Include(x => x.CourseTeeLocation).Where(x => x.UserId == userId)
.OrderBy(x => x.RoundDate).ThenBy(x => x.RoundId)
.Select(x => x).ToArrayAsync();
//func to go from rounds to last 20 rounds
Func<Round, Last20Rounds> roundToLast20 = x => new Last20Rounds
{
RoundId = x.RoundId,
RoundScore = x.Score,
Rating = x.CourseTeeLocation.Rating,
Slope = x.CourseTeeLocation.Slope
};
//lets loop through those rounds for the user
foreach (var roundToCalculate in roundsForUser)
{
//grab the 20 rounds before this round
var roundsToUse = roundsForUser
.Where(x => x.RoundDate < roundToCalculate.RoundDate)
.OrderByDescending(x => x.RoundDate)
.ThenByDescending(x => x.RoundId)
.Take(20)
.Select(roundToLast20).ToArray();
//current round we are up too
var currentRoundInArrayFormat = new Last20Rounds[] { roundToLast20(roundToCalculate) };
//rounds for the "After round handicap"
ICollection<Last20Rounds> roundsToCalculateAfterRoundHandicap;
//if we have 0 rounds, then use the round we are looking through
if (!roundsToUse.Any())
{
//set the current rounds to just this one guy
roundsToUse = currentRoundInArrayFormat;
//set it to just this round
roundsToCalculateAfterRoundHandicap = roundsToUse;
}
else
{
roundsToCalculateAfterRoundHandicap = roundsToUse.Concat(currentRoundInArrayFormat).ToArray();
}
//add the record to the context
dbContext.Handicap.Add(new Handicap
{
RoundId = roundToCalculate.RoundId,
HandicapBeforeRound = Handicapper.CalculateHandicap(roundsToUse).Value,
HandicapAfterRound = Handicapper.CalculateHandicap(roundsToCalculateAfterRoundHandicap).Value
});
}
//go save the changes for the course handicap
await dbContext.SaveChangesAsync();
//return a postive result
return true;
}