/// <inheritdoc cref="ITrainingRoomService.StartTrainingSessionAsync(StartTrainingSessionRequest)"/>
public async Task <StartTrainingSessionResponse> StartTrainingSessionAsync(StartTrainingSessionRequest startTrainingSessionRequest)
{
TrainingRoom trainingRoom;
Expression <Func <TrainingRoom, bool> > predicate = tr => tr.Id.Equals(startTrainingSessionRequest.TrainingRoomId);
if ((trainingRoom = await _trainingRoomRepository.FindSingleOrDefaultAsync(predicate)) == default)
{
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "Training room does not exist."));
}
if (!await _userRepository.ExistsAsync(usr => usr.Id.Equals(startTrainingSessionRequest.UserId)))
{
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "User does not exist."));
}
if (!trainingRoom.IsUserAuthorized(startTrainingSessionRequest.UserId))
{
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "User is not authorized"));
}
if (!trainingRoom.StartTrainingSession(startTrainingSessionRequest.UserId, out TrainingSession trainingSession))
{
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "Failed to start a training session."));
}
await _trainingRoomRepository.UpdateAsync(trainingRoom);
TrainingSessionDto trainingSessionDto = EntityToDtoConverter.Convert <TrainingSessionDto, TrainingSession>(trainingSession);
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, trainingSessionDto, "Successfully started a training session.", true));
}
/// <inheritdoc cref="ITrainingRoomService.StartTrainingSessionAsync(StartTrainingSessionRequest)"/>
public async Task <StartTrainingSessionResponse> StartTrainingSessionAsync(StartTrainingSessionRequest startTrainingSessionRequest)
{
Expression <Func <TrainingRoom, bool> > predicate = tr => tr.Id.Equals(startTrainingSessionRequest.TrainingRoomId);
if (!await _trainingRoomRepository.ExistsAsync(predicate))
{
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "Training room does not exist."));
}
if (!await _userRepository.ExistsAsync(usr => usr.Id.Equals(startTrainingSessionRequest.UserId)))
{
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "User does not exist."));
}
TrainingRoom trainingRoom = await _trainingRoomRepository.FindSingleByExpressionAsync(predicate);
if (!trainingRoom.IsUserAuthorized(startTrainingSessionRequest.UserId))
{
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "User is not authorized"));
}
if (!trainingRoom.StartTrainingSession(startTrainingSessionRequest.UserId, out TrainingSession trainingSession))
{
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "Failed to start a training session."));
}
await _trainingRoomRepository.UpdateAsync(trainingRoom);
_trainingSessionOrganismsDictionary.TryAdd(trainingSession.Id, new ConcurrentQueue <Organism>(trainingRoom.Species.SelectMany(sp => sp.LastGenerationOrganisms)));
TrainingSessionDto trainingSessionDto = EntityToDtoConverter.Convert <TrainingSessionDto, TrainingSession>(trainingSession);
return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, trainingSessionDto, "Successfully started a training session.", true));
}
public bool InkPen(Pen pen, Ink ink)
{
Entities.Pen penEntity = DtoToEntityConverter.Convert(pen);
Entities.Ink inkEntity = DtoToEntityConverter.Convert(ink);
penEntity.InkUp(inkEntity);
pen = EntityToDtoConverter.Convert(penEntity);
return(Storage.UpdatePen(pen));
}
public async Task <SignUpResultDto> SignUpAsync(string name, string credentialTypeCode, string identifier, string secret)
{
if (string.IsNullOrEmpty(secret))
{
return(new SignUpResultDto(success: false, error: SignUpResultError.SecretIsNullOrEmpty));
}
if (await _applicationUserRepository.ExistsAsync(anyUser => anyUser.UserName.Equals(name, StringComparison.OrdinalIgnoreCase)))
{
return(new SignUpResultDto(success: false, error: SignUpResultError.UserNameAlreadyExists));
}
if (!await _credentialTypeRepository.ExistsAsync(ct => string.Equals(ct.Code, credentialTypeCode, StringComparison.OrdinalIgnoreCase)))
{
return(new SignUpResultDto(success: false, error: SignUpResultError.CredentialTypeNotFound));
}
ApplicationUser user = new ApplicationUser
{
UserName = name,
UserDetail = new UserDetail {
ProfilePictureData = "test"
}
};
await _applicationUserRepository.CreateAsync(user);
CredentialType credentialType = await _credentialTypeRepository.FindSingleByExpressionAsync(ct => string.Equals(ct.Code, credentialTypeCode, StringComparison.OrdinalIgnoreCase));
byte[] salt = _saltGenerator.GenerateSalt();
Credential credential = new Credential
{
UserId = user.Id,
CredentialTypeId = credentialType.Id,
Identifier = identifier,
Secret = _hasher.Hash(secret, salt),
Extra = Convert.ToBase64String(salt)
};
await _credentialRepository.CreateAsync(credential);
user = await _applicationUserRepository.FindSingleByExpressionAsync(actualUser => actualUser.UserName.Equals(name)); //
ApplicationUserDto applicationUserDto = EntityToDtoConverter.Convert <ApplicationUserDto, ApplicationUser>(user);
return(new SignUpResultDto(user: applicationUserDto, success: true));
}
public async Task <CollectionDto> GetCollectionByIdAsync(int collectionId)
{
Collection actualCollection = await _collectionRepository.FindSingleByExpressionAsync(collection => collection.Id.Equals(collectionId));
return(EntityToDtoConverter.Convert <CollectionDto, Collection>(actualCollection));
}
/// <inheritdoc cref="ITrainingRoomService.GetOrganismsAsync(GetOrganismsRequest)"/>
public async Task <GetOrganismsResponse> GetOrganismsAsync(GetOrganismsRequest getOrganismsRequest)
{
string message = "Successfully fetched all requested organisms.";
TrainingSession trainingSession;
if (getOrganismsRequest.TrainingSessionId.Equals(Guid.Empty))
{
return(new GetOrganismsResponse(getOrganismsRequest.Id, new List <OrganismDto>(), "Training room id cannot be an empty guid."));
}
if (getOrganismsRequest.Amount < 1)
{
return(new GetOrganismsResponse(getOrganismsRequest.Id, new List <OrganismDto>(), "Amount cannot be smaller than 1."));
}
if ((trainingSession = await _trainingSessionRepository.FindSingleOrDefaultAsync(ts => ts.Id.Equals(getOrganismsRequest.TrainingSessionId))) == default)
{
return(new GetOrganismsResponse(getOrganismsRequest.Id, new List <OrganismDto>(), "Training session does not exist."));
}
// if the list is empty then get new ones from the training room
if (trainingSession.LeasedOrganisms.Count(o => !o.Organism.Evaluated) == 0)
{
if (trainingSession.TrainingRoom.Generation == 0)
{
TrainingRoomSettings trainingRoomSettings = trainingSession.TrainingRoom.TrainingRoomSettings;
for (int i = 0; i < trainingRoomSettings.OrganismCount; i++)
{
Organism organism = new Organism(trainingSession.TrainingRoom.Generation, trainingRoomSettings)
{
Leased = true
};
trainingSession.TrainingRoom.AddOrganism(organism);
trainingSession.LeasedOrganisms.Add(new LeasedOrganism(organism));
}
trainingSession.TrainingRoom.IncreaseNodeIdTo(trainingRoomSettings.InputCount + trainingRoomSettings.OutputCount);
message = $"First generation; generated {trainingSession.TrainingRoom.TrainingRoomSettings.OrganismCount} organisms.";
}
else
{
trainingSession.LeasedOrganisms.AddRange(GetNewLeasedOrganisms(getOrganismsRequest.Amount));
message = "Start of new generation.";
}
}
else if (trainingSession.LeasedOrganisms.Count(o => !o.Organism.Evaluated) < getOrganismsRequest.Amount)
{
int take = getOrganismsRequest.Amount - trainingSession.LeasedOrganisms.Count(o => !o.Organism.Evaluated);
List <LeasedOrganism> newLeasedOrganisms = GetNewLeasedOrganisms(take);
trainingSession.LeasedOrganisms.AddRange(newLeasedOrganisms);
}
if (trainingSession.LeasedOrganisms.Count(o => !o.Organism.Evaluated) < getOrganismsRequest.Amount)
{
message = "The requested amount of organisms are not all available. The training room is probably close to a new generation or is waiting on other training sessions to complete.";
}
await _trainingSessionRepository.UpdateAsync(trainingSession);
List <OrganismDto> organismDtos = trainingSession.LeasedOrganisms
.Where(lo => !lo.Organism.Evaluated)
.Take(getOrganismsRequest.Amount)
.Select(lo =>
{
OrganismDto organismDto = EntityToDtoConverter.Convert <OrganismDto, Organism>(lo.Organism);
// Because the input and output nodes are set using a Many To Many relation the nodes are converted separately.
organismDto.InputNodes = lo.Organism.Inputs.Select(input => EntityToDtoConverter.Convert <NodeDto, InputNode>(input.InputNode)).ToList();
organismDto.OutputNodes = lo.Organism.Outputs.Select(input => EntityToDtoConverter.Convert <NodeDto, OutputNode>(input.OutputNode)).ToList();
return(organismDto);
}).ToList();
return(new GetOrganismsResponse(getOrganismsRequest.Id, organismDtos, message, organismDtos.Any()));
List <LeasedOrganism> GetNewLeasedOrganisms(int take)
{
return(trainingSession.TrainingRoom.Species.SelectMany(sp => sp.Organisms).Where(lo => !lo.Leased)
.Take(take).Select(o =>
{
o.Leased = true;
return new LeasedOrganism(o);
}).ToList());
}
}
public async Task <MemeDto> GetMemeAsync(string memeId)
{
Meme actualMeme = await _memeRepository.FindSingleByExpressionAsync(meme => meme.Id.Equals(memeId));
return(EntityToDtoConverter.Convert <MemeDto, Meme>(actualMeme));
}
