// ---------------------------------------------------------------------------------------------
public ModuleDTO GetDTOWithQuestions(edumodule module, int userId)
{
ModuleDTO moduleDTO = ModuleMapper.GetDTO(module);
List <TestQuestionDTO> questionDtosOfModule = QuestionDtosForModule(module);
List <TestCodeDTO> codeDtosOfModule = CodeDtosForModule(module);
// Wersja dla NAUCZYCIELA (do edycji modułów)
// .........................................................................
// brak id użytkownika - pytania będą zawierać indeks prawidłowej odpowiedzi
// - ta wersja potrzebna jest do edycji modułów
if (userId < 0)
{
moduleDTO.test_questions_DTO = questionDtosOfModule;
moduleDTO.test_codes_DTO = codeDtosOfModule;
return(moduleDTO);
}
// Wersja dla STUDENTA
// .........................................................................
// Jest id uzytkownika -
// - pytania będą zawierały indeks ostatniej odpowiedzi udzielonej przez użytkownika
// - kody będą zawierały kody utworzone przez użytkownika
// (zamiana indeksów prawidłowych odpowiedzi na ostatnie odpowiedzi podane przez użytkownika
// i prawidłowych wyników kodu na kody utworzone przez użytkownika).
moduleDTO.test_questions_DTO = SetStudentAnswers(userId, questionDtosOfModule);
moduleDTO.test_codes_DTO = SetStudentCodes(userId, codeDtosOfModule);
// moduł gotowy do wysłania studentowi
return(moduleDTO);
}
public async Task <IReadOnlyList <PackageCarrier> > Load(PackagesLock packagesLock)
{
var mapper = new ModuleMapper(_framework, _modulesDirectory, Runtime.Windows, Environment.Is64BitProcess ? Architecture.x64 : Architecture.x86);
var packageStack = mapper.BuildMap(packagesLock);
var loadedPackages = new ConcurrentBag <PackageCarrier>();
while (packageStack.Any())
{
var dependencyLayer = packageStack.Pop();
await TaskCombinators.ThrottledAsync(dependencyLayer, (context, token) =>
{
return(Task.Run(() =>
{
foreach (var module in LoadModule(context))
{
loadedPackages.Add(module);
}
}));
}, CancellationToken.None);
}
Packages = Packages.AddRange(loadedPackages);
return(loadedPackages.ToList());
}
// ---------------------------------------------------------------------------------------------
public string FillMetaModules()
{
string[] stopnie = { "medium", "hard" };
List <edumodule> modules;
ModuleDTO[] children;
for (int i = 0; i < 2; i++)
{
// pobranie wszystkich modułów na danym stopniu trudności
modules = _moduleRepository.All().Where(m => m.difficulty == stopnie[i]).ToList();
// wypełnienie modułu nadrzędnego treścią jego dzieci
foreach (var module in modules)
{
children = module.edumodule1
.ToList()
.Select(child => ModuleMapper.GetDTO(child))
.ToArray();
FillMetaModule(children, module);
}
}
return("Automatycznie wypełniono meta moduły zawartością ich dzieci");
}
public async Task Load(IEnumerable <PackageIdentity> primaryPackages, PackagesLock packagesLock)
{
var mapper = new ModuleMapper(_project.Framework, _project.ModulesDirectory, _project.Runtime, _project.Architecture);
var map = mapper.BuildMap(packagesLock);
var dependencyPaths = new Dictionary <AssemblyName, AssemblyInfo>(new AssemblyNameComparer());
_dependencyAssemblies = dependencyPaths;
while (map.TryPop(out var dependencyLayer))
{
foreach (var context in dependencyLayer.Where(x => !x.IsMazeModule))
{
foreach (var file in Directory.GetFiles(context.LibraryDirectory, "*.dll"))
{
dependencyPaths.Add(AssemblyName.GetAssemblyName(file), new AssemblyInfo(file));
}
}
await TaskCombinators.ThrottledAsync(dependencyLayer.Where(x => x.IsMazeModule), (context, token) => Task.Run(() =>
{
foreach (var file in Directory.GetFiles(context.LibraryDirectory, "*.dll"))
{
var assembly = _assemblyLoadContext.LoadFromAssemblyPath(file);
var typeDiscoveryService = new TypeDiscoveryService(assembly, context.Package);
typeDiscoveryService.DiscoverTypes(ModuleTypeMap);
}
}), CancellationToken.None);
}
}
// PRIVATE
// =============================================================================================
private ModuleDTO GetDTOWitResults(ICollection <user_question> userQuestions, List <test_question> passedQuests, ICollection <user_code> userCodes, List <test_code> passedCodes, edumodule mod)
{
ModuleDTO dto = ModuleMapper.GetDTO(mod);
IEnumerable <test_question> moduleQuests;
IEnumerable <test_code> moduleCodes;
moduleQuests = QuestionsForModule(mod);
// this module has no questions
if (moduleQuests.Count() == 0)
{
dto.solvedQuestions = true;
}
// the user has not answered this module's questions yet
else if (userQuestions.FirstOrDefault(q => moduleQuests.Contains(q.test_question)) == null)
{
dto.solvedQuestions = false;
}
// check the latest user's results with this module question test
else
{
dto.solvedQuestions = moduleQuests.FirstOrDefault(q => !passedQuests.Contains(q)) == null;
}
// codeTasks for the module
moduleCodes = CodesForModule(mod);
// this module has no code test
if (moduleCodes.Count() == 0)
{
dto.solvedCodes = true;
}
// the user has not taken this module's code test yet
else if (userCodes.FirstOrDefault(c => moduleCodes.Contains(c.test_code)) == null)
{
dto.solvedCodes = false;
}
// check the latest user's results with this module code test
else
{
dto.solvedCodes = moduleCodes.FirstOrDefault(c => !passedCodes.Contains(c)) == null;
}
return(dto);
}
public List <Modules> AllModuleList()
{
try
{
ModuleMapper objModuleMapper = new ModuleMapper();
SqlParameter[] parameters =
{
new SqlParameter("@Type", "B")
};
IDataReader reader = base.GetReader("SP_Manage_Modules", parameters);
using (reader)
{
return(objModuleMapper.Map(reader));
}
}
catch (Exception ex)
{
return(null);
}
}
// ---------------------------------------------------------------------------------------------
// TODO zrzobić porządek z tymi metodami do ModuleResult!
private ModuleResultDTO GetModuleResultDTO(edumodule module, user user)
{
var userQuestions = user.user_question;
var passedQuests = userQuestions
.Where(uq => uq.last_result == true)
.Select(uq => uq.test_question)
.ToList();
var userCodes = user.user_code;
var passedCodes = userCodes
.Where(uc => uc.last_result == true)
.Select(uc => uc.test_code)
.ToList();
var dto = GetDTOWitResults(
userQuestions,
passedQuests,
userCodes,
passedCodes, module);
return(ModuleMapper.GetModuleResultDTO(module, dto.solvedCodes, dto.solvedQuestions, false));
}
// this resolver gets the file path from a known, named module
public override bool TryGetModule(ModuleRequest moduleRequest, out Module result)
{
var modulePath = ModuleMapper.GetPath(moduleRequest.CmdArgument);
if (modulePath is null)
{
result = null;
return(false);
}
var resolvedPath = Path.Join(Directory.GetCurrentDirectory(), modulePath);
if (!File.Exists(resolvedPath))
{
result = null;
return(false);
}
var code = File.ReadAllText(resolvedPath);
// by setting module name to full path, relative paths are available if/when the resolved file imports more files
result = new Module(resolvedPath, code);
return(true);
}
// ---------------------------------------------------------------------------------------------
public ModuleDTO UpsertModule(ModuleDTO moduleReceived)
{
var id = moduleReceived.id;
edumodule module;
List <test_question> oldQuestions = null;
List <test_code> oldCodes = null;
// MODUŁ
// ...............................................................
// utworzenie nowego modułu lub pobranie istniejącego
if (id == 0)
{
module = new edumodule();
ModuleMapper.CopyValues(moduleReceived, module);
_moduleRepository.Add(module);
}
else
{
module = _moduleRepository.Get(id);
_moduleRepository.SetNewValues(moduleReceived, module);
oldQuestions = module.test_question.ToList();
oldCodes = module.test_code.ToList();
}
// PYTANIA
// ...............................................................
// usunięcie pytań, których nie ma w tablicy z nowymi pytaniami
var newQuestions = moduleReceived.test_questions_DTO;
foreach (var oldQ in oldQuestions)
{
if (newQuestions == null)
{
_questionService.DeleteQuestion(oldQ.id);
}
else if (!newQuestions.Exists(newQ => newQ.id == oldQ.id))
{
_questionService.DeleteQuestion(oldQ.id);
}
}
// zapisanie nowych i odświeżenie starych pytań przypisanych do modułu
if (moduleReceived.test_questions_DTO != null && moduleReceived.difficulty == "easy")
{
foreach (var new_question in moduleReceived.test_questions_DTO)
{
_questionService.UpsertQuestion(new_question);
}
}
// CODE TASKS
// ...............................................................
// usunięcie zadań z kodu, których nie ma w tablicy z nowymi zadaniami
var newCodes = moduleReceived.test_codes_DTO;
foreach (var oldC in oldCodes)
{
if (newCodes == null)
{
_codeService.DeleteCode(oldC.id);
}
else if (!newCodes.Exists(newC => newC.id == oldC.id))
{
_codeService.DeleteCode(oldC.id);
}
}
// zapisanie nowych i odświeżenie starych pytań przypisanych do modułu
if (moduleReceived.test_codes_DTO != null && moduleReceived.difficulty == "easy")
{
foreach (var new_code in moduleReceived.test_codes_DTO)
{
_codeService.UpsertCode(new_code);
}
}
// RETURN
// ...............................................................
return(GetDTOWithQuestions(module, -1));
}
