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);
        }
        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 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 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;
        }
Example #6
0
        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;
        }
Example #7
0
        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;
        }
        public static async Task<bool> DeleteACourse(ToracGolfContext dbContext, int courseId)
        {
            //grab the course
            var courseToDelete = await dbContext.Course.FirstAsync(x => x.CourseId == courseId).ConfigureAwait(false);

            //now flip the flag on the course
            courseToDelete.IsActive = false;

            //save the changes
            await dbContext.SaveChangesAsync().ConfigureAwait(false);

            //return a positive result
            return true;
        }
        public static async Task<bool> MakeSeasonAsCurrent(ToracGolfContext dbContext, int userId, int currentSeasonId)
        {
            //grab the user record
            var user = await dbContext.Users.FirstAsync(x => x.UserId == userId).ConfigureAwait(false);

            //set the current season now
            user.CurrentSeasonId = currentSeasonId;

            //save the changes
            await dbContext.SaveChangesAsync().ConfigureAwait(false);

            //return a postive result
            return true;
        }
Example #10
0
        public static async Task<bool> DeleteSeason(ToracGolfContext dbContext, int userId, int seasonIdToDelete)
        {
            //go grab the season to delete
            var seasonToDelete = await dbContext.UserSeason.FirstAsync(x => x.UserId == userId && x.SeasonId == seasonIdToDelete).ConfigureAwait(false);

            //remove it from the context
            dbContext.UserSeason.Remove(seasonToDelete);

            //save it now
            await dbContext.SaveChangesAsync().ConfigureAwait(false);

            //return a postive result
            return true;
        }