public async Task <IHttpActionResult> PutClassRating(Guid id, ClassRating classRating)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != classRating.id)
{
return(BadRequest());
}
db.Entry(classRating).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClassRatingExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PostClassRating(ClassRating classRating)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.ClassRatings.Add(classRating);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ClassRatingExists(classRating.id))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = classRating.id }, classRating));
}
private ClassRating CreateClassRating(string className)
{
ClassRating classRating = new ClassRating()
{
ClassName = className,
PlayersRating = new DriversRating()
{
Rating = _simulatorRating.PlayersRating.Rating,
Deviation = _simulatorRating.PlayersRating.Deviation,
Volatility = _simulatorRating.PlayersRating.Volatility,
CreationTime = DateTime.Now,
Difficulty = _simulatorRating.PlayersRating.Difficulty,
},
DifficultyRating = new DriversRating()
{
Rating = _simulatorRating.PlayersRating.Rating,
Deviation = _simulatorRating.PlayersRating.Deviation,
Volatility = _simulatorRating.PlayersRating.Volatility,
CreationTime = DateTime.Now,
Difficulty = _simulatorRating.PlayersRating.Difficulty,
},
DifficultySettings = new DifficultySettings()
{
SelectedDifficulty = GetSuggestedDifficulty(_simulatorRating.PlayersRating.Rating),
WasUserSelected = true,
}
};
_simulatorRating.ClassRatings.Add(classRating);
Logger.Info($"Created Rating for {className}");
LogRating(classRating.PlayersRating);
return(classRating);
}
public async Task <ActionResult <ClassRatingResponse> > getClassRating(int classid)
{
GymClasses gymClass = await classRepository.getClassById(classid);
if (gymClass == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "Specified class does not exist!"));
}
ClassRating rating = await classRatingRepository.getRating(classid);
ClassRatingResponse response = new ClassRatingResponse();
if (rating == null)
{
response.classId = classid;
response.ratingCount = 0;
response.ratingSum = 0;
}
else
{
response.classId = rating.ClassIdForeignKey;
response.ratingCount = rating.RatingCount;
response.ratingSum = rating.RatingSum;
}
return(Ok(response));
}
public (DriversRating simRating, DriversRating difficultyRating) GetPlayerRating(string className)
{
ClassRating classRating = _simulatorRating.ClassRatings.FirstOrDefault(x => x.ClassName == className) ?? CreateClassRating(className);
Logger.Info($"Retreived Players Rating for Class {className}");
LogRating(classRating.PlayersRating);
return(FillDifficulty(UpdateDeviation(classRating.PlayersRating)), FillDifficulty(UpdateDeviation(classRating.DifficultyRating)));
}
public void SetSelectedDifficulty(int difficulty, bool wasUserSelected, string className)
{
ClassRating classRating = GetOrCreateClassRating(className);
classRating.DifficultySettings = new DifficultySettings()
{
SelectedDifficulty = difficulty,
WasUserSelected = wasUserSelected
};
}
public async Task <IHttpActionResult> GetClassRating(Guid id)
{
ClassRating classRating = await db.ClassRatings.FindAsync(id);
if (classRating == null)
{
return(NotFound());
}
return(Ok(classRating));
}
public async Task <IHttpActionResult> DeleteClassRating(Guid id)
{
ClassRating classRating = await db.ClassRatings.FindAsync(id);
if (classRating == null)
{
return(NotFound());
}
db.ClassRatings.Remove(classRating);
await db.SaveChangesAsync();
return(Ok(classRating));
}
public void UpdateRating(DriversRating newClassRating, DriversRating newDifficultyRating, DriversRating newSimRating, int difficulty, string trackName, DriverFinishState driverFinishState)
{
ClassRating classRating = GetOrCreateClassRating(driverFinishState.CarClass);
DriversRating oldClassRating = classRating.PlayersRating;
DriversRating oldDifficultyRating = classRating.DifficultyRating;
DriversRating oldSimRating = _simulatorRating.PlayersRating;
newSimRating = NormalizeRatingChange(oldSimRating, newSimRating);
newClassRating = NormalizeRatingChange(oldClassRating, newClassRating);
newSimRating = FillDifficulty(newSimRating);
newClassRating = FillDifficulty(newClassRating);
newDifficultyRating = NormalizeRatingChange(oldDifficultyRating, newDifficultyRating);
newDifficultyRating = FillDifficulty(newDifficultyRating);
classRating.PlayersRating = newClassRating;
classRating.DifficultyRating = newDifficultyRating;
_simulatorRating.PlayersRating = newSimRating;
if (!classRating.DifficultySettings.WasUserSelected)
{
classRating.DifficultySettings.SelectedDifficulty = classRating.DifficultyRating.Difficulty;
}
_simulatorRating.LastPlayerClass = driverFinishState.CarClass;
RaceResult result = new RaceResult()
{
CarName = driverFinishState.CarName,
ClassName = driverFinishState.CarClass,
CreationTime = DateTime.Now,
FinishingPosition = driverFinishState.FinishPosition,
TrackName = trackName,
Difficulty = difficulty,
SimulatorRatingChange = new RatingChange()
{
RatingBeforeChange = oldSimRating.Rating,
RatingAfterChange = newSimRating.Rating
},
ClassRatingChange = new RatingChange()
{
RatingBeforeChange = oldClassRating.Rating,
RatingAfterChange = newClassRating.Rating
},
};
_simulatorRating.Results.Add(result);
_simulatorRating.Results = _simulatorRating.Results.Take(500).ToList();
_ratingRepository.SaveRatings(_ratings);
NotifyRatingsChanges(CreateChangeArgs(oldClassRating, classRating.PlayersRating, driverFinishState.CarClass), CreateChangeArgs(oldSimRating, _simulatorRating.PlayersRating, SimulatorName), CreateChangeArgs(oldDifficultyRating, newDifficultyRating, driverFinishState.CarClass));
}
public async Task <ActionResult <AllClassRatingResponse[]> > getGymClassRatings(int gymid)
{
Gym gym = await gymRepository.getGymById(gymid);
if (gym == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "Specified gym does not exist!"));
}
GymClasses[] classes = await classRepository.getGymClasses(gymid);
AllClassRatingResponse[] responses = new AllClassRatingResponse[classes.Length];
for (int i = 0; i < classes.Length; i++)
{
ClassRating rating = await classRatingRepository.getRating(classes[i].ClassId);
if (rating == null)
{
rating = new ClassRating();
rating.ClassIdForeignKey = classes[i].ClassId;
rating.RatingCount = 0;
rating.RatingSum = 0;
}
responses[i] = new AllClassRatingResponse();
responses[i].Name = classes[i].Name;
responses[i].Instructor = classes[i].InstructorUsername;
responses[i].Day = classes[i].Day;
responses[i].Time = classes[i].StartTime;
responses[i].RatingSum = rating.RatingSum;
responses[i].RatingCount = rating.RatingCount;
}
return(Ok(responses));
}
public async Task <ActionResult <ClassRatingResponse> > rateClass(ClassRatingRequest request)
{
/* Validate User Exists */
Users user = await userRepository.getUser(request.username);
if (user == null)
{
return(StatusCode(StatusCodes.Status401Unauthorized, "User specified is not a valid user!"));
}
/* Validate Class Exists */
GymClasses gymClass = await classRepository.getClassById(request.classId);
if (gymClass == null)
{
return(StatusCode(StatusCodes.Status404NotFound, "Specified class does not exist!"));
}
/* Validate From Same Gym */
if (gymClass.GymIdForeignKey != user.GymIdForeignKey)
{
return(StatusCode(StatusCodes.Status401Unauthorized, "User rating the class is not from the same gym as the class!"));
}
/* Validate Not Instructor Of Class */
if (gymClass.InstructorUsername == user.Username)
{
return(StatusCode(StatusCodes.Status401Unauthorized, "Instructors cannot rate their own classes!"));
}
/* Validate Rating Out Of 5 */
if (request.rating > 5 || request.rating < 0)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Rating provided is out of allowed range!"));
}
/* Check if existing rating record exists */
ClassRating rating = await classRatingRepository.getRating(request.classId);
if (rating == null)
{
rating = new ClassRating();
rating.ClassIdForeignKey = request.classId;
rating.RatingCount = 0;
rating.RatingCount = 0;
if (!(await classRatingRepository.addRating(rating)))
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Something went wrong creating the rating record for the class!"));
}
}
rating.RatingCount++;
rating.RatingSum += request.rating;
if (!(await classRatingRepository.rateClass(rating)))
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Something went wrong adding your rating to the database!"));
}
ClassRatingResponse response = new ClassRatingResponse();
response.classId = rating.ClassIdForeignKey;
response.ratingCount = rating.RatingCount;
response.ratingSum = rating.RatingSum;
return(Ok(response));
}
public async Task <bool> rateClass(ClassRating rating)
{
context.Update(rating);
return((await context.SaveChangesAsync()) > 0);
}
public async Task <bool> addRating(ClassRating rating)
{
context.Add(rating);
return((await context.SaveChangesAsync()) > 0);
}