//AJOUT D'UNE PROPOSITION
public async Task AddStatement(string observationId, ObservationCreationModel newStatement, string userId)
{
var existingObservation = await this.GetUserObservationbyId(observationId);
if (existingObservation == null)
{
throw new BusinessException("Ce relevé n'existe pas");
}
var statement = new ObservationStatement();
statement.Id = Guid.NewGuid().ToString("N");
statement.UserId = userId;
statement.Date = DateTime.UtcNow;
if (!string.IsNullOrEmpty(newStatement.Genus))
{
var s = (await this.SpeciesManager
.GetSpeciesByGenusAsync(newStatement.Genus))
.FirstOrDefault();
statement.CommonGenus = s?.CommonGenus;
statement.Genus = s?.Genus;
}
if (!string.IsNullOrEmpty(newStatement.Species))
{
Species species = await this.SpeciesManager
.GetSpeciesByNameAsync(newStatement.Species);
statement.CommonSpeciesName = species?.CommonSpeciesName;
statement.SpeciesName = species.SpeciesName;
statement.TelaBotanicaTaxon = species?.TelaBotanicaTaxon;
statement.Expertise = await this.CalculateUserSpeciesExpertise(userId, newStatement.Species);
}
if (existingObservation.ObservationStatements.Any(s => s.SpeciesName == statement.SpeciesName && s.Genus == statement.Genus))
{
throw new BusinessException("Une proposition identique existe déjà");
}
statement.TotalScore = statement.CalculateReliabilityStatement();
statement.Order = existingObservation.ObservationStatements.Count() + 1;
statement.TotalScore = statement.CalculateReliabilityStatement();
existingObservation.ObservationStatements.Add(statement);
await this.DataContext.Observations.FindOneAndReplaceAsync(o => o.Id == existingObservation.Id, existingObservation);
await this.CalculateKnowledegePoints(observationId, statement.Id, null);
await this.CheckObservationIsIdentify(existingObservation.Id);
User user = await this.UsersManager.SelectAsync(userId);
var validator = await MissionValidatorFactory.GetValidator(this.ServiceProvider, user);
if (validator != null)
{
await validator?.UpdateMissionProgression(existingObservation, statement, ActionType.CreateStatement);
}
}
public static decimal CalculateReliabilityStatement(this ObservationStatement statement)
{
var score = statement.Expertise;
if (statement.ObservationStatementConfirmations != null && statement.ObservationStatementConfirmations.Any())
{
score = score + statement.ObservationStatementConfirmations.Sum(x => x.Expertise);
}
return(score);
}
public static decimal CalculateSpeciesReliabilityStatement(this ObservationStatement statement)
{
var score = !string.IsNullOrEmpty(statement.SpeciesName) ? statement.Expertise : 0;
if (statement.ObservationStatementConfirmations != null && statement.ObservationStatementConfirmations.Any())
{
score = score + statement.ObservationStatementConfirmations.Where(x => !x.IsOnlyGenus).Sum(x => x.Expertise);
}
return(score);
}
public async Task <Observation> EditObservationAsync(ObservationStatement editObservation, string currentUserId)
{
var existingObservation = await this.GetUserObservationbyId(editObservation.Id);
if (existingObservation == null)
{
throw new BusinessException("Ce relevé n'existe pas");
}
return(existingObservation);
}
public async Task <Observation> EditObservationStatementAsync(ObservationStatement editStatement, string observationId)
{
var existingObservation = await this.GetUserObservationbyId(observationId);
var existingStatement = existingObservation.ObservationStatements.Find(s => s.Id == editStatement.Id);
var os = existingObservation.ObservationStatements;
if (existingStatement == null)
{
throw new BusinessException("Ce relevé n'existe pas");
}
if (existingObservation.ObservationStatements.Count() > 1)
{
if (editStatement.SpeciesName != null)
{
if (os.Any(x => x.SpeciesName == editStatement.SpeciesName))
{
throw new BusinessException("Un relevé avec cette espèce existe déja vous pouvez le confirmer");
}
}
else if (editStatement.SpeciesName == null && editStatement.Genus != null)
{
if (os.Any(x => x.Genus == editStatement.Genus))
{
throw new BusinessException("Un relevé avec ce genre existe déja, préciser l'espèce");
}
}
}
try
{
existingStatement.CommonGenus = editStatement.CommonGenus;
existingStatement.Genus = editStatement.Genus;
existingStatement.SpeciesName = editStatement.SpeciesName;
existingStatement.Confident = editStatement.Confident;
if (!string.IsNullOrEmpty(existingStatement.SpeciesName))
{
Species species = await this.SpeciesManager
.GetSpeciesByNameAsync(existingStatement.SpeciesName);
existingStatement.CommonSpeciesName = species?.CommonSpeciesName;
}
await this.DataContext.Observations.FindOneAndReplaceAsync(o => o.Id == existingObservation.Id, existingObservation);
}
catch
{
throw;
}
return(existingObservation);
}
public async Task CheckObservationIsIdentify(string observationId)
{
var existingObservation = await this.GetUserObservationbyId(observationId);
if (existingObservation == null)
{
throw new BusinessException("Ce relevé n'existe pas");
}
var minScore = int.Parse(this.Configuration["Reliability:MinimunScore"]);
var minPercent = int.Parse(this.Configuration["Reliability:MinimunPercent"]);
var totalSpeciesStatementsScore = existingObservation.ObservationStatements.Sum(x => x.TotalScoreSpecies);
ObservationStatement identifyStatement = null;
if (totalSpeciesStatementsScore != 0)
{
foreach (var s in existingObservation.ObservationStatements)
{
if (s.TotalScore >= minScore)
{
var percent = s.TotalScoreSpecies * 100 / totalSpeciesStatementsScore;
if (percent >= minPercent)
{
//statement identify
identifyStatement = s;
break;
}
}
}
}
if (identifyStatement != null)
{
existingObservation.IsIdentified = true;
existingObservation.StatementValidatedId = identifyStatement.Id;
await this.DataContext.Observations.FindOneAndReplaceAsync(o => o.Id == existingObservation.Id, existingObservation);
if (!existingObservation.OSMStatus.HasValue)
{
var user = await this.UsersManager.SelectAsync(existingObservation.UserId);
if (user != null)
{
BackgroundJob.Enqueue(() => this.SendMailForObservationToSendToOsm(user.Email, user.Name));
}
}
}
}
public async Task <bool> UpdateMissionProgression([FromBody] ObservationCreationModel identification, string observationId)
{
User user = await this.UsersManager.SelectAsync(this.User.Identity.Name);
Mission mission = await this.MissionsManager.GetMissionById(user.MissionProgress.MissionId);
ObservationStatement os = new ObservationStatement
{
Genus = identification.Genus,
SpeciesName = identification.Species
};
var result = false;
var validator = await MissionValidatorFactory.GetValidator(this.ServiceProvider, user);
if (validator != null)
{
result = await((IdentifyMissionValidator)validator).UpdateIdentifyMissionProgression(observationId, mission, os, user.OsmId);
}
return(result);
}
public static ObservationStatementModel ToObservationStatementModel(this ObservationStatement observationStatement, User[] users)
{
return(new ObservationStatementModel
{
Id = observationStatement.Id,
UserId = observationStatement.UserId,
Date = observationStatement.Date,
CommonSpeciesName = observationStatement.CommonSpeciesName,
SpeciesName = observationStatement.SpeciesName,
CommonGenus = observationStatement.CommonGenus,
Genus = observationStatement.Genus,
TelaBotanicaTaxon = observationStatement.TelaBotanicaTaxon,
Expertise = observationStatement.Expertise,
Validate = observationStatement.Validate,
Order = observationStatement.Order,
Confident = (int?)observationStatement.Confident,
TotalScore = observationStatement.TotalScore,
TotalScoreSpecies = observationStatement.TotalScoreSpecies,
ObservationStatementConfirmations = observationStatement.ObservationStatementConfirmations?.Select(sc => sc.ToObservationStatementConfirmationModel()).ToArray() ?? null,
UserName = users?.FirstOrDefault(u => u.OsmId == observationStatement.UserId)?.Name
});
}
public abstract Task <bool> UpdateMissionProgression(Observation observation, ObservationStatement statement, ActionType?type);
public async Task <Observation> CreateObservationAsync(string speciesName, string genus, string userid, Entities.Enums.Confident confident, double latitude, double longitude, string[] pictures, int?treeSize)
{
Observation newObservation = new Observation();
try
{
newObservation.Id = Guid.NewGuid().ToString("N");
newObservation.Pictures = new List <string>();
newObservation.Date = DateTime.UtcNow;
var statement = new ObservationStatement();
statement.Id = Guid.NewGuid().ToString("N");
User user = await this.UsersManager.SelectAsync(userid);
newObservation.UserId = user.OsmId;
statement.UserId = user.OsmId;
newObservation.AuthorName = user?.Name;
newObservation.ObservationStatements = new List <ObservationStatement>();
newObservation.Coordinates = new GeoJsonPoint <GeoJson2DGeographicCoordinates>(new GeoJson2DGeographicCoordinates(longitude, latitude));
newObservation.TreeSize = (TreeSize?)treeSize;
if (!string.IsNullOrEmpty(genus))
{
var s = (await this.SpeciesManager
.GetSpeciesByGenusAsync(genus))
.FirstOrDefault();
statement.CommonGenus = s?.CommonGenus;
statement.Genus = s?.Genus;
if (string.IsNullOrEmpty(speciesName))
{
statement.Expertise = await this.CalculateUserGenusExpertise(user.OsmId, statement.Genus);
}
}
if (!string.IsNullOrEmpty(speciesName))
{
Species species = await this.SpeciesManager
.GetSpeciesByNameAsync(speciesName);
statement.CommonSpeciesName = species?.CommonSpeciesName;
statement.SpeciesName = species.SpeciesName;
statement.TelaBotanicaTaxon = species?.TelaBotanicaTaxon;
statement.Expertise = await this.CalculateUserSpeciesExpertise(user.OsmId, speciesName);
}
statement.Date = DateTime.UtcNow;
statement.TotalScore = statement.CalculateReliabilityStatement();
statement.TotalScoreSpecies = statement.CalculateSpeciesReliabilityStatement();
statement.Order = 1;
statement.Confident = confident;
newObservation.ObservationStatements.Add(statement);
if (pictures != null)
{
foreach (string picture in pictures?.Where(p => !string.IsNullOrEmpty(p)))
{
newObservation.Pictures.Add(await this.FileManager.SaveDataUrlAsFileAsync("observations", picture));
}
}
await this.DataContext.Observations.InsertOneAsync(newObservation);
await this.AddExplorationPointsForNewObservation(newObservation);
var validator = await MissionValidatorFactory.GetValidator(this.ServiceProvider, user);
if (validator != null)
{
await validator?.UpdateMissionProgression(newObservation, statement, ActionType.CreateObservation);
}
}
catch (Exception e)
{
throw;
}
return(newObservation);
}
public override async Task <bool> UpdateMissionProgression(Observation observation, ObservationStatement statement, ActionType?type)
{
bool conditionsCompleted = true;
//Si la mission à une restriction géographique on vérifie que nous somme dedans
if (!this.ValidateRestrictedArea(observation))
{
return(false);
}
//si ce n'est pas une action de création de proposition ou de confirmation ça ne concerne pas ce type de mission
if (!type.HasValue || (type.Value != ActionType.CreateStatement && type.Value != ActionType.ConfirmStatement))
{
return(false);
}
//Si on demande une observation avec photos mais qu'il y en a pas on ignore
if (this.Mission.ObservationWithPics && (observation.Pictures == null || !observation.Pictures.Any()))
{
return(false);
}
//Si on ne demande pas les observation fiable, et que l'observation modifié n'est pas déjà fiable.
if (!this.Mission.UnreliableObservation && observation.StatementValidatedId == null)
{
return(false);
}
Console.WriteLine(User.MissionProgress.History);
var missionProgressHistory = User.MissionProgress.History?.ToList() ?? new List <MissionProgressionHistory>();
var observationsFromHistory = await this.ObservationsManager.GetObservationsByIds(missionProgressHistory.Select(x => x.ObservationId).ToArray());
//Question Est-ce que si le relevé est certains, on vérifie qu'il valide bien la bonne données
if (this.Mission.Restriction != null)
{
var value = this.Mission.Restriction.Value?.ToLowerInvariant().RemoveDiacritics().Trim();
if (!string.IsNullOrEmpty(value))
{
switch (this.Mission.Restriction.Type)
{
case RestrictionType.ExactSpecies:
if (statement.CommonSpeciesName?.ToLowerInvariant().RemoveDiacritics().Trim() != value && statement.SpeciesName?.ToLowerInvariant().RemoveDiacritics().Trim() != value)
{
return(false);
}
break;
case RestrictionType.ExactGender:
if (statement.CommonGenus?.ToLowerInvariant().RemoveDiacritics().Trim() != value && statement.Genus?.ToLowerInvariant().RemoveDiacritics().Trim() != value)
{
return(false);
}
break;
}
}
}
missionProgressHistory.Add(new MissionProgressionHistory
{
ObservationId = observation.Id,
Date = DateTime.UtcNow,
StatementId = statement?.Id,
Type = type.Value
});
if (this.Mission.EndingCondition.GetType() == typeof(NumberOfActions))
{
NumberOfActions endCondition = (NumberOfActions)this.Mission.EndingCondition;
if (missionProgressHistory.Count() < endCondition.Number)
{
conditionsCompleted = false;
}
}
if (this.Mission.EndingCondition.GetType() == typeof(TimeLimit))
{
TimeLimit timeLimit = (TimeLimit)this.Mission.EndingCondition;
conditionsCompleted = this.IsTimerEnd(timeLimit.Minutes, User.MissionProgress.StartDate);
}
if (conditionsCompleted)
{
await this.UsersManager.EndCurrentMission(userId : this.User.OsmId, missionProgressHistory.ToArray());
}
else
{
await this.UpdateProgression(missionProgressHistory.ToArray());
}
return(false);
}
public override async Task <bool> UpdateMissionProgression(Observation observation, ObservationStatement statement, ActionType?type)
{
bool conditionsCompleted = true;
//Si la mission à une restriction géographique on vérifie que nous somme dedans
if (!this.ValidateRestrictedArea(observation))
{
return(false);
}
//si ce n'est pas une action de création de proposition ou d'observation ça ne concerne pas ce type de mission
if (!type.HasValue || (type.Value != ActionType.CreateStatement && type.Value != ActionType.CreateObservation))
{
return(false);
}
var missionProgressHistory = User.MissionProgress.History?.ToList() ?? new List <MissionProgressionHistory>();
var observationsFromHistory = await this.ObservationsManager.GetObservationsByIds(missionProgressHistory.Select(x => x.ObservationId).ToArray());
//Si on arrive la alors nous avons forcement un statement...
if (missionProgressHistory.Any(h => h.ObservationId == observation.Id))
{
return(false);
}
switch (this.Mission.Type)
{
case NewObservationMissionType.DifferentGenders:
if (observationsFromHistory.Any(x => x.ObservationStatements.Any(s => s.UserId == User.OsmId && s.CommonGenus.ToLowerInvariant().RemoveDiacritics() == statement.CommonGenus.ToLowerInvariant().RemoveDiacritics())))
{
return(false);
}
break;
case NewObservationMissionType.DifferentSpecies:
if (observationsFromHistory.Any(x => x.ObservationStatements.Any(s => s.UserId == User.OsmId && s.CommonSpeciesName.ToLowerInvariant().RemoveDiacritics() == statement.CommonSpeciesName.ToLowerInvariant().RemoveDiacritics())))
{
return(false);
}
break;
case NewObservationMissionType.ExactSpecies:
if (statement.CommonSpeciesName.ToLowerInvariant().RemoveDiacritics() != this.Mission.Value.ToLowerInvariant().RemoveDiacritics() || statement.SpeciesName.ToLowerInvariant().RemoveDiacritics() != this.Mission.Value.ToLowerInvariant().RemoveDiacritics())
{
return(false);
}
break;
case NewObservationMissionType.ExactGender:
if (!(statement.CommonGenus.RemoveDiacritics().ToLowerInvariant() == this.Mission.Value.RemoveDiacritics().ToLowerInvariant() || statement.Genus.RemoveDiacritics().ToLowerInvariant() == this.Mission.Value.RemoveDiacritics().ToLowerInvariant()))
{
return(false);
}
break;
}
missionProgressHistory.Add(new MissionProgressionHistory
{
ObservationId = observation.Id,
Date = DateTime.UtcNow,
StatementId = statement?.Id,
Type = type.Value
});
if (this.Mission.EndingCondition.GetType() == typeof(NumberOfActions))
{
NumberOfActions endCondition = (NumberOfActions)this.Mission.EndingCondition;
if (missionProgressHistory.Count() < endCondition.Number)
{
conditionsCompleted = false;
}
}
if (this.Mission.EndingCondition.GetType() == typeof(TimeLimit))
{
TimeLimit timeLimit = (TimeLimit)this.Mission.EndingCondition;
conditionsCompleted = this.IsTimerEnd(timeLimit.Minutes, User.MissionProgress.StartDate);
}
if (conditionsCompleted)
{
await this.UsersManager.EndCurrentMission(userId : this.User.OsmId, missionProgressHistory.ToArray());
}
else
{
await this.UpdateProgression(missionProgressHistory.ToArray());
}
return(true);
}
public async Task <bool> UpdateIdentifyMissionProgression(string observationId, Mission mission, ObservationStatement identification, string osmId)
{
bool isMissionCompleted = false;
bool isIdentified = true;
Observation observation = await this.ObservationsManager.GetObservationbyId(observationId);
ObservationStatement observationStatement = observation.ObservationStatements.FirstOrDefault(x => x.Id == observation.StatementValidatedId);
if (mission.GetType() == typeof(NewObservationMission) || mission.GetType() == typeof(VerificationMission))
{
return(false);
}
IdentificationMission identifyMission = (IdentificationMission)mission;
if (identifyMission.Restriction == null || string.IsNullOrEmpty(identifyMission.Restriction.Value))
{
if (!(observationStatement.Genus == identification.Genus && observationStatement.SpeciesName == identification.SpeciesName))
{
isIdentified = false;
}
}
else
{
var value = identifyMission.Restriction.Value.ToLowerInvariant().RemoveDiacritics().Trim();
if (identifyMission.Restriction.Type == RestrictionType.ExactGender)
{
if (value != identification.Genus?.ToLowerInvariant().RemoveDiacritics().Trim() && value != identification.CommonGenus?.ToLowerInvariant().RemoveDiacritics().Trim())
{
isIdentified = false;
}
}
else if (identifyMission.Restriction.Type == RestrictionType.ExactSpecies)
{
if (value != identification.SpeciesName?.ToLowerInvariant().RemoveDiacritics().Trim() && value != identification.CommonSpeciesName?.ToLowerInvariant().RemoveDiacritics().Trim())
{
isIdentified = false;
}
}
}
User user = await this.UsersManager.SelectAsync(osmId);
var missionProgressHistory = user.MissionProgress.History?.ToList() ?? new List <MissionProgressionHistory>();
missionProgressHistory.Add(new MissionProgressionHistory
{
ObservationId = observation.Id,
Date = DateTime.UtcNow,
StatementId = observationStatement?.Id,
Type = ActionType.Recognition,
Gender = identification.Genus,
Species = identification.SpeciesName,
SuccessRecognition = isIdentified
});
user.MissionProgress.Progression += isIdentified ? 1 : 0;
if (identifyMission.EndingCondition.GetType() == typeof(NumberOfActions))
{
NumberOfActions numberOfActions = (NumberOfActions)identifyMission.EndingCondition;
if (user.MissionProgress.Progression == numberOfActions.Number)
{
isMissionCompleted = true;
}
}
if (identifyMission.EndingCondition.GetType() == typeof(TimeLimit))
{
TimeLimit timeLimit = (TimeLimit)identifyMission.EndingCondition;
if (this.IsTimerEnd(timeLimit.Minutes, user.MissionProgress.StartDate))
{
isMissionCompleted = true;
}
}
if (isMissionCompleted)
{
await this.UsersManager.EndCurrentMission(osmId, missionProgressHistory.ToArray());
}
else
{
await this.UpdateProgression(missionProgressHistory.ToArray(), true, isIdentified);
}
return(isIdentified);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
public override async Task <bool> UpdateMissionProgression(Observation observation, ObservationStatement statement, ActionType?type)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
return(false);
}
