/// <summary>
/// Updates the user ater mission completion.
/// </summary>
/// <param name="missionRequest">The mission request.</param>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="appCountersService">The application counters service.(need to be passed for missions from the last set)</param>
/// <returns>
/// Points increase
/// </returns>
public static async Task <int> UpdateUserAfterMissionCompletion(
MissionRequest missionRequest,
IMissionRepository missionRepository,
AppCountersService appCountersService = null)
{
var currentLevelMax = levelMap[missionRequest.User.Level.Value]; //user level can't be null
var expIncrease = (ushort)(missionRequest.Mission.Difficulty * GameConstants.Experience.PerDifficultyPoint);
var pointsIncrease =
(int)Math.Round(expIncrease * GameConstants.Points.ExtraMultiplier * missionRequest.StarsCount.Value);
//stars after completion can't be null
missionRequest.User.LevelPoints += expIncrease;
missionRequest.User.Points = (missionRequest.User.Points ?? 0) + pointsIncrease;
if (missionRequest.User.LevelPoints >= currentLevelMax)
{
missionRequest.User.Level++;
missionRequest.User.LevelPoints = (ushort)(missionRequest.User.LevelPoints - currentLevelMax);
}
CalculatePersonQualities(missionRequest, true);
await MissionFinished(missionRequest, true, missionRepository, appCountersService);
return(expIncrease);
}
private async Task <MissionCompletionResult> ProcessTemporaryCommonPlace(
MissionRequest request,
string commonPlaceAlias,
GeoCoordinate passedCoordinate)
{
var result =
await _commonPlacesRepository.AddCommonPlace(request.UserId, commonPlaceAlias, passedCoordinate);
if (result.Status != OperationResultStatus.Success)
{
return(new MissionCompletionResult(
OperationResultStatus.Error,
"Невозможно добавить временное общее место"));
}
request.StarsCount = 3;
var recievedPoints =
await
RewardsCalculator.UpdateUserAfterMissionCompletion(request, _missionRepository, _appCountersService);
var requestResult = await _missionRequestRepository.AddMissionRequest(request);
if (requestResult.Status != OperationResultStatus.Success)
{
return(MissionCompletionResult.FromOperationResult(requestResult));
}
return(new MissionCompletionResult
{
Points = recievedPoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
});
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{MissionCompletionResult}.</returns>
public async Task <MissionCompletionResult> ProcessRequest(MissionRequest request)
{
request.Mission.TriesFor1Star = 7;
request.Mission.TriesFor2Stars = 4;
request.Mission.TriesFor3Stars = 2;
if (request.Proof.Coordinates == null || !request.Proof.Coordinates.Any())
{
return(new MissionCompletionResult(OperationResultStatus.Error, "Not enough data"));
}
var oupostCoordinate = request.Proof.Coordinates.First();
double distanceError;
if (!CheckOutpost(oupostCoordinate, request.User, out distanceError))
{
return(await MissionRequestService.ProcessIncorrectTry(request, _missionRepository, _missionRequestRepository));
}
await MissionRequestService.SetStarsAccordingToTries(request, _missionRequestRepository);
request.User.OutpostCoordinate = oupostCoordinate;
var recievedPoints = await RewardsCalculator.UpdateUserAfterMissionCompletion(
request,
_missionRepository);
return(new MissionCompletionResult
{
Points = recievedPoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
});
}
private static async Task <List <MissionIdWithSetId> > CheckActiveMissionDependencies(
MissionRequest missionRequest,
bool success,
IMissionRepository missionRepository)
{
var autoRemovedActiveMissions = new List <MissionIdWithSetId>();
if (success)
{
return(autoRemovedActiveMissions);
}
var user = missionRequest.User;
var declinedMissionId = missionRequest.Mission.Id;
var activeMissionsIds = user.ActiveMissionIds.Select(m => m.MissionId).ToIList();
var activeMissions =
(await
missionRepository.GetMissions(
new QueryOptions <Mission>
{
Filter =
ExpressionHelper.Expr((Mission x) => x.Id).In(activeMissionsIds),
Select = mission => new { mission.Id, mission.DependsOn }
}));
AutoDeclineActiveMissions(
declinedMissionId,
activeMissions,
user,
autoRemovedActiveMissions);
return(autoRemovedActiveMissions);
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{MissionCompletionResult}.</returns>
public async Task <MissionCompletionResult> ProcessRequest(MissionRequest request)
{
var userAnswer = request.Proof.CreatedText.ToLower();
if ((userAnswer.Contains("мам") && !userAnswer.Contains("друг")) ||
(userAnswer.Contains("друг") && !userAnswer.Contains("мам")))
{
request.StarsCount = 1;
}
else if (userAnswer.Contains("мам") && userAnswer.Contains("друг") || userAnswer.Contains("обоим") ||
userAnswer.Contains("двоим"))
{
request.StarsCount = 3;
}
else
{
request.DeclineReason = "Это неправильный выбор.";
await RewardsCalculator.UpdateUserAfterMissionDecline(request, _missionRepository);
return(new MissionCompletionResult
{
MissionCompletionStatus = MissionCompletionStatus.Fail,
Description = request.DeclineReason
});
}
var recievedPoints = await RewardsCalculator.UpdateUserAfterMissionCompletion(request, _missionRepository);
return(new MissionCompletionResult
{
Points = recievedPoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
});
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{MissionCompletionResult}.</returns>
public async Task <MissionCompletionResult> ProcessRequest(MissionRequest request)
{
var baseCoordinates = request.Proof.Coordinates.ToArray();
if (!ValidBaseCoordinates(baseCoordinates, request.User.HomeCoordinate))
{
request.DeclineReason = "Координаты базы ошибочны";
await RewardsCalculator.UpdateUserAfterMissionDecline(request, _missionRepository);
return(new MissionCompletionResult
{
MissionCompletionStatus = MissionCompletionStatus.Fail,
Description = request.DeclineReason
});
}
request.User.BaseNorthCoordinate = baseCoordinates[0];
request.User.BaseEastCoordinate = baseCoordinates[1];
request.User.BaseSouthCoordinate = baseCoordinates[2];
request.User.BaseWestCoordinate = baseCoordinates[3];
request.StarsCount = 3;
var recievedPoints = await RewardsCalculator.UpdateUserAfterMissionCompletion(request, _missionRepository);
return(new MissionCompletionResult
{
Points = recievedPoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
});
}
/// <summary>
/// The add mission request.
/// </summary>
/// <param name="missionRequest">
/// The mission request.
/// </param>
/// <returns>
/// The <see cref="Task" />.
/// </returns>
public async Task <IdResult> AddMissionRequest(MissionRequest missionRequest)
{
missionRequest.Id = Guid.NewGuid().ToString();
await Task.Factory.StartNew(() => _allMissionRequests.Add(missionRequest));
return(new IdResult(missionRequest.Id));
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public async Task <MissionCompletionResult> ProcessRequest(MissionRequest request)
{
if (String.IsNullOrEmpty(request.Proof.CreatedText))
{
request.StarsCount = 3;
var recievedPoints =
await RewardsCalculator.UpdateUserAfterMissionCompletion(request, _missionRepository, _appCountersService);
return(new MissionCompletionResult
{
Points = recievedPoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
});
}
request.DeclineReason = "Увы. В следующий раз постарайся думать своей головой и не совершать глупости";
await RewardsCalculator.UpdateUserAfterMissionDecline(request, _missionRepository, _appCountersService);
return(new MissionCompletionResult
{
MissionCompletionStatus = MissionCompletionStatus.Fail,
Description = request.DeclineReason
});
}
/// <summary>
/// Converts MissionRequestAzure to MissionRequest..
/// </summary>
/// <param name="azureModel">The azure model.</param>
/// <returns>MissionRequest.</returns>
public static MissionRequest FromAzureModel(this MissionRequestAzure azureModel)
{
if (azureModel == null)
{
return(null);
}
var domainModel = new MissionRequest();
azureModel.CopyTo(domainModel);
MissionRequestStatus status;
if (Enum.TryParse(azureModel.Status, out status))
{
domainModel.Status = status;
}
domainModel.StarsCount = (byte?)azureModel.StarsCount;
domainModel.Proof = new MissionProof
{
ImageUrls = azureModel.ProofImageUrls?.SplitStringByDelimiter(),
CreatedText = azureModel.CreatedText,
Coordinates = azureModel.ProofCoordinates?.SplitStringByDelimiter(CommonConstants.Delimiter)?.Select(coord => coord.ConvertToGeoCoordinate()).ToList(),
TimeElapsed = azureModel.TimeElapsed,
NumberOfTries = (ushort?)azureModel.NumberOfTries
};
return(domainModel);
}
private static void CalculatePersonQualities(MissionRequest missionRequest, bool afterSuccess)
{
if (missionRequest.Mission.PersonQualities != null && missionRequest.Mission.PersonQualities.Any())
{
var lightQuality =
missionRequest.Mission.PersonQualities.FirstOrDefault(
q => q.PersonQualityId == GameConstants.PersonQuality.LightQualityId);
if (lightQuality != null)
{
var lightScore = lightQuality.Score * missionRequest.StarsCount
?? (double)0 / GameConstants.PersonQuality.StarsNeededForMissionValue;
if (missionRequest.User.PersonQualitiesWithScores != null)
{
var userLightQuality =
missionRequest.User.PersonQualitiesWithScores.FirstOrDefault(pq => pq.PersonQualityId == GameConstants.PersonQuality.LightQualityId);
if (userLightQuality != null)
{
if (afterSuccess)
{
userLightQuality.Score += lightScore;
if (userLightQuality.Score > GameConstants.PersonQuality.LightScoreMax)
{
userLightQuality.Score = GameConstants.PersonQuality.LightScoreMax;
}
}
else
{
userLightQuality.Score -= lightScore;
if (userLightQuality.Score < GameConstants.PersonQuality.LightScoreMin)
{
userLightQuality.Score = GameConstants.PersonQuality.LightScoreMin;
}
}
}
else if (afterSuccess)
{
missionRequest.User.PersonQualitiesWithScores
.Add(
new PersonQualityIdWithScore
{
PersonQualityId = GameConstants.PersonQuality.LightQualityId,
Score = lightScore
});
}
}
else if (afterSuccess)
{
missionRequest.User.PersonQualitiesWithScores = new List <PersonQualityIdWithScore>
{
new PersonQualityIdWithScore
{
PersonQualityId = GameConstants.PersonQuality.LightQualityId,
Score = lightScore
}
};
}
UpdateRadrugaColor(missionRequest.User, false);
}
}
}
/// <summary>
/// Updates the missionRequest.
/// </summary>
/// <param name="missionRequest">
/// The missionRequest.
/// </param>
/// <returns>
/// Task{OperationResult}.
/// </returns>
public async Task <OperationResult> UpdateMissionRequest(MissionRequest missionRequest)
{
var missionRequestsAzure =
await
_azureManager.GetEntitiesAsync(
new TableQuery <MissionRequestAzure>().Where(GetFilterByPartitionKey(missionRequest.Id)));
var missionRequestAzure = missionRequestsAzure.FirstOrDefault();
if (missionRequestAzure == null)
{
return(new OperationResult(OperationResultStatus.Error, "Can't find missionRequest for update"));
}
var updatedMissionRequest = missionRequest.ToAzureModel();
var oldUrls = missionRequestAzure.ProofImageUrls.SplitStringByDelimiter();
var newUrls = missionRequest.Proof.ImageUrls;
await
_imagesProvider.SaveImagesToProductionBlobOnUpdate(oldUrls, newUrls, BlobContainer.MissionRequestImages);
updatedMissionRequest.ProofImageUrls = newUrls.JoinToString();
updatedMissionRequest.CopyToTableEntity(missionRequestAzure);
return(await _azureManager.UpdateEntityAsync(missionRequestAzure));
}
private static async Task MissionFinished(
MissionRequest missionRequest,
bool success,
IMissionRepository missionRepository,
AppCountersService appCountersService)
{
var user = missionRequest.User;
var mission = missionRequest.Mission;
var changedSetIds = await GetChangedSetIds(missionRequest, success, missionRepository, user, mission);
var lastSetExist = changedSetIds.Contains(GameConstants.MissionSet.LastSetId);
foreach (var changedSetId in changedSetIds)
{
var hasOtherSetMissions = user.ActiveMissionIds.Any(m => m.MissionSetId == changedSetId);
if (!hasOtherSetMissions)
{
user.ActiveMissionSetIds.Remove(changedSetId);
user.CompletedMissionSetIds = user.CompletedMissionSetIds ?? new List <string>();
user.CompletedMissionSetIds.Add(changedSetId);
await CheckForLastSetAndLoadMissions(missionRequest, missionRepository, user, changedSetId, lastSetExist);
}
}
await CheckLastSetCounters(missionRequest, appCountersService);
UpdateThreeStarsAchievement(user, missionRequest.StarsCount);
}
private static void SetStarsAccordingToTime(MissionRequest request)
{
if (!request.Proof.TimeElapsed.HasValue)
{
request.StarsCount = 0;
return;
}
var time = request.Proof.TimeElapsed;
if (time <= request.Mission.SecondsFor3Stars)
{
request.StarsCount = 3;
}
else if (time <= request.Mission.SecondsFor2Stars)
{
request.StarsCount = 2;
}
else if (time <= request.Mission.SecondsFor1Star)
{
request.StarsCount = 1;
}
else
{
request.StarsCount = 0;
}
}
public static async Task SetStarsAccordingToTries(
MissionRequest request,
IMissionRequestRepository missionRequestRepository)
{
Expression <Func <MissionRequest, bool> > filter =
a => a.MissionId == request.MissionId && a.UserId == request.UserId;
var previousRequiests =
await missionRequestRepository.GetMissionRequests(new QueryOptions <MissionRequest> {
Filter = filter
});
var tries = previousRequiests.Count + 1;
if (tries <= request.Mission.TriesFor3Stars)
{
request.StarsCount = 3;
}
else if (tries <= request.Mission.TriesFor2Stars)
{
request.StarsCount = 2;
}
else if (tries <= request.Mission.TriesFor1Star)
{
request.StarsCount = 1;
}
else
{
throw new Exception("Can't pass mission with more tries than allowed");
}
}
private static async Task <IList <string> > GetChangedSetIds(
MissionRequest missionRequest,
bool success,
IMissionRepository missionRepository,
User user,
Mission mission)
{
if (success)
{
user.CompletedMissionIds = user.CompletedMissionIds ?? new List <string>();
user.CompletedMissionIds.Add(mission.Id);
}
else
{
user.FailedMissionIds = user.FailedMissionIds ?? new List <string>();
user.FailedMissionIds.Add(mission.Id);
}
user.ActiveMissionIds.RemoveAll(m => m.MissionId == mission.Id);
var autoRemovedActiveMissions = await CheckActiveMissionDependencies(missionRequest, success, missionRepository);
var changedSetIds = autoRemovedActiveMissions.Select(m => m.MissionSetId).ToIList();
if (!changedSetIds.Contains(mission.MissionSetId))
{
changedSetIds.Add(mission.MissionSetId);
}
return(changedSetIds);
}
private static async Task CheckForLastSetAndLoadMissions(
MissionRequest missionRequest,
IMissionRepository missionRepository,
User user,
string changedSetId,
bool lastSetExist)
{
var finishedSet = user.MissionSetIds.First(s => s.MissionSetId == changedSetId);
if (!lastSetExist)
{
MissionSetIdWithOrder newSet;
var currentOrder = finishedSet.Order + 1;
do
{
newSet = user.MissionSetIds.FirstOrDefault(s => s.Order == currentOrder);
if (newSet == null) //after 3 sets completed before test passed
{
break;
}
currentOrder++;
}while ((user.ActiveMissionSetIds.Contains(newSet.MissionSetId) ||
user.CompletedMissionSetIds.Contains(newSet.MissionSetId)));
if (newSet != null)
{
user.ActiveMissionSetIds.Add(newSet.MissionSetId);
// go to db to load missions from set, not ideal but for now is ok
await LoadMissionsFromNewSet(missionRepository, newSet.MissionSetId, missionRequest.User);
}
}
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{MissionCompletionResult}.</returns>
public async Task <MissionCompletionResult> ProcessRequest(MissionRequest request)
{
var homeCoordinate = request.Proof.Coordinates.First();
request.User.HomeCoordinate = homeCoordinate;
var homePlaceIdResult = await _placeIdService.GetUniquePlaceId(request.User.HomeCoordinate);
if (homePlaceIdResult == null)
{
request.DeclineReason = "Невозможно опеределить идентификатор города. Возможно, ты находишься в пути. Попробуй еще раз позже.";
return(new MissionCompletionResult
{
MissionCompletionStatus = MissionCompletionStatus.IntermediateFail,
Description = request.DeclineReason
});
}
request.User.CityShortName = homePlaceIdResult.CityShortName;
request.User.CountryShortName = homePlaceIdResult.CountryShortName;
request.StarsCount = 3;
var recievedPoints = await RewardsCalculator.UpdateUserAfterMissionCompletion(request, _missionRepository);
await _appCountersService.UserPassedFirstMission();
return(new MissionCompletionResult
{
Points = recievedPoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
});
}
private async Task <MissionCompletionResult> ProcessCommonPlace(MissionRequest request)
{
var commonPlaceAlias = request.Mission.CommonPlaceAlias;
var passedCoordinate = request.Proof.Coordinates.First();
if (request.User.HomeCoordinate.GetDistanceTo(passedCoordinate) < Core.Constants.GameConstants.Mission.CommonPlaceMinDistanceFromHome)
{
var incorrectResult = await ProcessIncorrectTry(request, _missionRepository, _missionRequestRepository);
if (incorrectResult.MissionCompletionStatus == MissionCompletionStatus.IntermediateFail)
{
incorrectResult.Description = "StillHome";
}
return(incorrectResult);
}
var realCommonPlace = await _commonPlacesRepository.GetCommonPlaceByAlias(request.UserId, commonPlaceAlias);
if (realCommonPlace == null)
{
return(await ProcessTemporaryCommonPlace(request, commonPlaceAlias, passedCoordinate));
}
var distance = passedCoordinate.GetDistanceTo(realCommonPlace.Coordinate);
if (distance > request.Mission.AccuracyRadius)
{
var incorrectResult = await ProcessIncorrectTry(request, _missionRepository, _missionRequestRepository);
if (incorrectResult.MissionCompletionStatus == MissionCompletionStatus.IntermediateFail)
{
incorrectResult.Description = distance > request.Mission.AccuracyRadius * 2 ? "Incorrect" : "IsNear";
}
return(incorrectResult);
}
await SetStarsAccordingToTries(request, _missionRequestRepository);
var completePoints =
await
RewardsCalculator.UpdateUserAfterMissionCompletion(request, _missionRepository, _appCountersService);
var finalResult = new MissionCompletionResult
{
Points = completePoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
};
var requestResult = await _missionRequestRepository.AddMissionRequest(request);
return(requestResult.Status != OperationResultStatus.Success
? MissionCompletionResult.FromOperationResult(requestResult)
: finalResult);
}
private async Task <MissionCompletionResult> ProcessAutoApprovedMissions(MissionRequest missionRequest)
{
var oldUserPoints = missionRequest.User.Points;
MissionCompletionResult result;
switch (missionRequest.Mission.ExecutionType)
{
case ExecutionType.RightAnswer:
{
result = await ProcessRightAnswer(missionRequest);
break;
}
case ExecutionType.Path:
{
result = await ProcessGeoCoordinate(missionRequest);
break;
}
case ExecutionType.CommonPlace:
{
result = await ProcessCommonPlace(missionRequest);
break;
}
default:
{
throw new ArgumentOutOfRangeException(nameof(missionRequest), "Incorrect execution type");
}
}
if (result.Status != OperationResultStatus.Success ||
result.MissionCompletionStatus == MissionCompletionStatus.IntermediateFail)
{
return(result);
}
//after any mission completion user should be updated
var userUpdateResult = await _userRepository.UpdateUser(missionRequest.User);
if (userUpdateResult.Status != OperationResultStatus.Error)
{
// new points should always have value
// ReSharper disable once PossibleInvalidOperationException
await _ratingService.UpdateUserRating(missionRequest.User, oldUserPoints, missionRequest.User.Points.Value);
}
return(userUpdateResult.Status == OperationResultStatus.Success
? result
: MissionCompletionResult.FromOperationResult(userUpdateResult));
}
private static async Task CheckLastSetCounters(
MissionRequest missionRequest,
AppCountersService appCountersService)
{
if (appCountersService != null && !missionRequest.User.ActiveMissionIds.Any() &&
!missionRequest.User.ActiveMissionSetIds.Any() &&
!string.IsNullOrEmpty(missionRequest.User.RadrugaColor))
{
await appCountersService.UserHasFinished();
}
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{MissionCompletionResult}.</returns>
public async Task <MissionCompletionResult> ProcessRequest(MissionRequest request)
{
request.StarsCount = 3;
var recievedPoints = await RewardsCalculator.UpdateUserAfterMissionCompletion(request, _missionRepository);
return(new MissionCompletionResult
{
Points = recievedPoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
});
}
/// <summary>
/// The update mission request.
/// </summary>
/// <param name="missionRequest">
/// The mission request.
/// </param>
/// <returns>
/// The <see cref="Task" />.
/// </returns>
public async Task <OperationResult> UpdateMissionRequest(MissionRequest missionRequest)
{
var existingMissionRequest = await GetMissionRequest(missionRequest.Id);
if (existingMissionRequest == null)
{
return(OperationResult.NotFound);
}
missionRequest.CopyTo(existingMissionRequest);
return(new OperationResult(OperationResultStatus.Success));
}
/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{MissionCompletionResult}.</returns>
public async Task <MissionCompletionResult> ProcessRequest(MissionRequest request)
{
var users = await _userRepository.GetUsers(new QueryOptions <User> {
Filter = u => u.Id != request.UserId, Select = u => u.HomeCoordinate
});
var coordinates = users.Select(u => u.HomeCoordinate).Where(coord => coord != null);
var passedCoordinate = request.Proof.Coordinates.First();
GeoCoordinate friendsBaseCoordinate = null;
foreach (var geoCoordinate in coordinates)
{
var distance = passedCoordinate.GetDistanceTo(geoCoordinate);
if (distance <= 100)
{
request.StarsCount = 1;
if (distance <= 50)
{
request.StarsCount = 2;
}
if (distance <= 10)
{
request.StarsCount = 3;
}
friendsBaseCoordinate = geoCoordinate;
break;
}
}
if (friendsBaseCoordinate == null)
{
request.DeclineReason = "Мы не смогли найти ни одного пользователя с таким командным пунктом";
await RewardsCalculator.UpdateUserAfterMissionDecline(request, _missionRepository, _appCountersService);
return(new MissionCompletionResult
{
MissionCompletionStatus = MissionCompletionStatus.Fail,
Description = request.DeclineReason
});
}
var recievedPoints =
await
RewardsCalculator.UpdateUserAfterMissionCompletion(request, _missionRepository, _appCountersService);
return(new MissionCompletionResult
{
Points = recievedPoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
});
}
public async Task <IActionResult> AddMission([FromBody] MissionRequest missionRequest)
{
bool result = await _missionService.AddMission(missionRequest);
if (result)
{
return(Ok(new { message = "Mission was created" }));
}
else
{
return(StatusCode(500, "An error occured"));
}
}
/// <summary>
/// Updates the user ater mission decline.
/// </summary>
/// <param name="missionRequest">The mission request.</param>
/// <param name="missionRepository">The mission repository.</param>
/// <param name="appCountersService">The application counters service.</param>
/// <returns>
/// If not empty returns the set id, so active missions need to be populated
/// </returns>
public static async Task UpdateUserAfterMissionDecline(
MissionRequest missionRequest,
IMissionRepository missionRepository,
AppCountersService appCountersService = null)
{
var pointsDecrease =
(ushort)
(missionRequest.Mission.Difficulty * GameConstants.Experience.PerDifficultyPoint
* GameConstants.Points.ExtraMultiplier);
missionRequest.User.Points = (missionRequest.User.Points ?? 0) - pointsDecrease;
CalculatePersonQualities(missionRequest, false);
await MissionFinished(missionRequest, false, missionRepository, appCountersService);
}
// GET: Admin/MissionRequests/Details/5
/// <summary>
/// Detailses the specified id.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>Task{ActionResult}.</returns>
public async Task <ActionResult> Details(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MissionRequest missionRequest = await _missionRequestService.GetRequest(id);
if (missionRequest == null)
{
return(HttpNotFound());
}
return(View(missionRequest));
}
/// <summary>
/// Add mission and the correspondent agent and country
/// </summary>
/// <param name="mission"></param>
/// <returns></returns>
public async Task <bool> AddMission(MissionRequest missionRequest)
{
Mission mission = _mapper.Map <Mission>(missionRequest);
//if agent already eixst we will not add another one
Agent agent = await _missionRepository.GetAgentByName(mission.Agent.Name);
mission.Agent = agent ?? mission.Agent;
//if country already eixst we will not add another one
Country country = await _missionRepository.GetCountryByName(mission.Country.Name);
mission.Country = country ?? mission.Country;
return(await _missionRepository.AddMission(mission));
}
/// <summary>
/// To the azure model.
/// </summary>
/// <param name="missionRequest">The mission request.</param>
/// <returns>MissionRequestAzure</returns>
public static MissionRequestAzure ToAzureModel(this MissionRequest missionRequest)
{
var azureModel = new MissionRequestAzure();
missionRequest.CopyTo(azureModel);
azureModel.StarsCount = missionRequest.StarsCount;
azureModel.Status = missionRequest.Status.ToString();
//set proofs
azureModel.ProofImageUrls = missionRequest.Proof.ImageUrls?.JoinToString();
azureModel.ProofCoordinates = missionRequest.Proof.Coordinates?.Select(coord => coord.ConvertToAzureCoordinate())
.JoinToString(CommonConstants.Delimiter);
azureModel.CreatedText = missionRequest.Proof.CreatedText;
azureModel.TimeElapsed = missionRequest.Proof.TimeElapsed;
azureModel.NumberOfTries = missionRequest.Proof.NumberOfTries;
return(azureModel);
}
private async Task <RightAnswerMissionCompletionResult> ProcessRightAnswer(MissionRequest request)
{
var userAnswers = request.Proof.CreatedText.Trim().SplitStringByDelimiter();
if (!userAnswers.AnyValues())
{
return(new RightAnswerMissionCompletionResult(OperationResultStatus.Error, "Ответ не может быть пустым"));
}
var rightAnswers = AnswerModelHelper.SplitAnswer(request.Mission.CorrectAnswers);
List <string> userAnswerStatuses;
var invalidAnswersCount = ParseUserAnswers(rightAnswers, userAnswers, request.Mission.ExactAnswer ?? false, out userAnswerStatuses);
var rightAnswersCount = userAnswers.Count - invalidAnswersCount;
if (rightAnswersCount == 0 || rightAnswersCount < request.Mission.AnswersCount)
{
var result = await ProcessIncorrectTry(request, _missionRepository, _missionRequestRepository);
var rightAnswerResult = RightAnswerMissionCompletionResult.FromMissionCompletionResult(result);
request.DeclineReason = userAnswerStatuses.JoinToString();
rightAnswerResult.AnswerStatuses = userAnswerStatuses;
return(rightAnswerResult);
}
await SetStarsAccordingToTries(request, _missionRequestRepository);
var recievedPoints =
await
RewardsCalculator.UpdateUserAfterMissionCompletion(request, _missionRepository, _appCountersService);
var requestResult = await _missionRequestRepository.AddMissionRequest(request);
if (requestResult.Status != OperationResultStatus.Success)
{
return
(RightAnswerMissionCompletionResult.FromMissionCompletionResult(
MissionCompletionResult.FromOperationResult(requestResult)));
}
return(new RightAnswerMissionCompletionResult
{
Points = recievedPoints,
StarsCount = request.StarsCount,
MissionCompletionStatus = MissionCompletionStatus.Success
});
}
/// <summary>
/// Adds the missionRequest.
/// </summary>
/// <param name="missionRequest">
/// The missionRequest.
/// </param>
/// <returns>
/// Task{AddResult}.
/// </returns>
public async Task <IdResult> AddMissionRequest(MissionRequest missionRequest)
{
missionRequest.Id = Guid.NewGuid().ToString("N");
if (missionRequest.Proof.ImageUrls != null)
{
var newUrlsTasks =
missionRequest.Proof.ImageUrls.Select(
async url =>
await _imagesProvider.SaveImageToProductionBlobOnAdd(url, BlobContainer.MissionRequestImages));
var newUrls = await Task.WhenAll(newUrlsTasks);
missionRequest.Proof.ImageUrls = newUrls.ToList();
}
var azureModel = missionRequest.ToAzureModel();
return(await _azureManager.AddEntityAsync(azureModel));
}
