private async Task <ModuleDraft> CreateModuleDraft(
Contract request, Module originalModule, CancellationToken token
)
{
var moduleId = ObjectId.Parse(request.ModuleId);
var module = ModuleDraft.Create(
moduleId, originalModule.Title, originalModule.Excerpt, originalModule.ImageUrl, originalModule.Published,
originalModule.InstructorId, originalModule.Instructor, originalModule.InstructorMiniBio, originalModule.InstructorImageUrl,
originalModule.Duration, originalModule.VideoDuration, originalModule.VideoUrl,
originalModule.CertificateUrl, originalModule.StoreUrl, originalModule.EcommerceUrl, false,
originalModule.Tags, originalModule.TutorsIds
).Data;
module.Subjects = originalModule.Subjects;
module.Requirements = originalModule.Requirements;
module.SupportMaterials = originalModule.SupportMaterials;
await _db.ModuleDraftCollection.InsertOneAsync(
module, cancellationToken : token
);
var dbModulesQuestionsQuery = _db.QuestionCollection
.AsQueryable()
.Where(q => q.ModuleId == moduleId);
var dbModuleQuestions = await(
(IAsyncCursorSource <Question>)dbModulesQuestionsQuery
).ToListAsync();
if (dbModuleQuestions.Count > 0)
{
var draftQuestions = dbModuleQuestions.Select(q =>
QuestionDraft.Create(
q.Id, module.Id,
q.Text, q.Level, q.Duration,
q.Concepts, q.Answers,
q.ModuleId, q.SubjectId
).Data
);
await _db.QuestionDraftCollection.InsertManyAsync(
draftQuestions, cancellationToken : token
);
}
return(module);
}
public async Task <Result <ModuleDraft> > Handle(Contract request, CancellationToken cancellationToken)
{
try
{
if (request.UserRole != "Admin" && request.UserRole != "Author")
{
return(Result.Fail <ModuleDraft>("Acesso Negado"));
}
var tags = new List <Tag>();
foreach (var tagStr in request.Tags)
{
var tag = Tag.Create(tagStr);
tags.Add(tag.Data);
}
var tutorsIds = request.TutorsIds != null?
request.TutorsIds.Select(x => ObjectId.Parse(x)).ToList() :
new List <ObjectId>();
var instructorId = String.IsNullOrEmpty(request.InstructorId) ?
ObjectId.Empty : ObjectId.Parse(request.InstructorId);
Module dbModule = null;
Module dbModuleClone = null;
List <Question> dbModuleQuestions = new List <Question>();
if (!String.IsNullOrEmpty(request.ModuleId))
{
dbModule = await GetModule(request.ModuleId);
}
dbModuleClone = Module.Create(
request.Title,
dbModule.Excerpt,
dbModule.Instructor,
dbModule.ImageUrl,
new List <ObjectId>(),
instructorId,
new List <SupportMaterial>(),
new List <Requirement>(),
tags,
false,
null,
new List <Subject>(),
dbModule.CertificateUrl,
tutorsIds,
dbModule.ExtraInstructorIds,
dbModule.StoreUrl,
dbModule.EcommerceUrl,
dbModule.ModuleGradeType,
dbModule.ValidFor
).Data;
await _db.ModuleCollection.InsertOneAsync(
dbModuleClone, cancellationToken : cancellationToken
);
dbModuleQuestions = await GetModuleQuestions(request.ModuleId);
var draft = ModuleDraft.Create(
dbModuleClone.Id, dbModuleClone.Title, dbModuleClone.Excerpt, dbModuleClone.ImageUrl, dbModuleClone.Published,
instructorId, dbModuleClone.Instructor, dbModuleClone.InstructorMiniBio, dbModuleClone.InstructorImageUrl,
null, null, null, dbModuleClone.CertificateUrl, dbModuleClone.StoreUrl, dbModuleClone.EcommerceUrl, request.CreateInEcommerce ?? false,
tags, tutorsIds
).Data;
draft.Subjects = dbModule.Subjects;
draft.Requirements = dbModule.Requirements;
draft.SupportMaterials = dbModule.SupportMaterials;
await _db.ModuleDraftCollection.InsertOneAsync(
draft, cancellationToken : cancellationToken
);
if (dbModuleQuestions.Count > 0)
{
var draftQuestions = dbModuleQuestions.Select(q =>
QuestionDraft.Create(
ObjectId.GenerateNewId(), draft.Id,
q.Text, q.Level, q.Duration,
q.Concepts, q.Answers,
dbModuleClone.Id, q.SubjectId
).Data
);
await _db.QuestionDraftCollection.InsertManyAsync(
draftQuestions, cancellationToken : cancellationToken
);
}
return(Result.Ok(draft));
}
catch (Exception ex)
{
return(Result.Fail <ModuleDraft>(ex.Message));
}
}
private async Task<ModuleDraft> CreateModuleDraft(ObjectId userId, Contract request, Module originalModule,
Duration duration, Duration videoDuration, CancellationToken token
) {
var tags = new List<Tag>();
foreach (var tagStr in request.Tags)
{
var tag = Tag.Create(tagStr);
tags.Add(tag.Data);
}
var tutorsIds = request.TutorsIds != null ?
request.TutorsIds.Select(x => ObjectId.Parse(x)).ToList() :
new List<ObjectId>();
var instructorId = String.IsNullOrEmpty(request.InstructorId) ?
ObjectId.Empty : ObjectId.Parse(request.InstructorId);
var extraInstructorIds = request.ExtraInstructorIds != null ?
request.ExtraInstructorIds.Select(x => ObjectId.Parse(x)).ToList() :
new List<ObjectId>();
var moduleId = ObjectId.Parse(request.Id);
var module = ModuleDraft.Create(
moduleId, request.Title, request.Excerpt, request.ImageUrl, request.Published,
instructorId, request.Instructor, request.InstructorMiniBio, request.InstructorImageUrl,
duration, videoDuration, request.VideoUrl, request.CertificateUrl, request.StoreUrl, request.EcommerceUrl,
request.CreateInEcommerce.HasValue ? request.CreateInEcommerce.Value : false,
tags, tutorsIds, extraInstructorIds, request.ModuleGradeType
).Data;
module.Subjects = originalModule.Subjects;
module.Requirements = originalModule.Requirements;
module.SupportMaterials = originalModule.SupportMaterials;
await _db.ModuleDraftCollection.InsertOneAsync(
module, cancellationToken: token
);
var creationLog = AuditLog.Create(userId, moduleId, module.GetType().ToString(),
JsonConvert.SerializeObject(module), EntityAction.Add);
await _db.AuditLogCollection.InsertOneAsync(creationLog);
var dbModuleQuestions = await _db.QuestionCollection.AsQueryable()
.Where(q => q.ModuleId == moduleId)
.ToListAsync();
if (dbModuleQuestions.Count > 0)
{
var draftQuestions = dbModuleQuestions.Select(q =>
QuestionDraft.Create(
q.Id, module.Id,
q.Text, q.Level, q.Duration,
q.Concepts, q.Answers,
q.ModuleId, q.SubjectId
).Data
);
await _db.QuestionDraftCollection.InsertManyAsync(
draftQuestions, cancellationToken: token
);
}
return module;
}
public async Task <Result <ModuleDraft> > Handle(Contract request, CancellationToken cancellationToken)
{
if (request.UserRole != "Admin" && request.UserRole != "Author")
{
return(Result.Fail <ModuleDraft>("Acesso Negado"));
}
var userId = ObjectId.Parse(request.UserId);
var tags = new List <Tag>();
foreach (var tagStr in request.Tags)
{
var tag = Tag.Create(tagStr);
tags.Add(tag.Data);
}
var tutorsIds = request.TutorsIds != null?
request.TutorsIds.Select(x => ObjectId.Parse(x)).ToList() :
new List <ObjectId>();
var instructorId = String.IsNullOrEmpty(request.InstructorId) ?
ObjectId.Empty : ObjectId.Parse(request.InstructorId);
var extraInstructorIds = request.ExtraInstructorIds != null?
request.ExtraInstructorIds.Select(x => ObjectId.Parse(x)).ToList() :
new List <ObjectId>();
Module dbModule = null;
List <Question> dbModuleQuestions = new List <Question>();
if (!String.IsNullOrEmpty(request.ModuleId))
{
dbModule = await GetModule(request.ModuleId);
}
if (dbModule == null)
{
dbModule = Module.Create(
request.Title,
request.Excerpt,
request.Instructor,
request.ImageUrl,
new List <ObjectId>(),
instructorId,
new List <SupportMaterial>(),
new List <Requirement>(),
tags,
request.Published ?? false,
null,
new List <Subject>(),
request.CertificateUrl,
tutorsIds,
extraInstructorIds,
request.StoreUrl,
request.EcommerceUrl,
request.ModuleGradeType,
request.ValidFor
).Data;
await _db.ModuleCollection.InsertOneAsync(
dbModule, cancellationToken : cancellationToken
);
}
else
{
dbModuleQuestions = await GetModuleQuestions(request.ModuleId);
}
var draft = ModuleDraft.Create(
dbModule.Id, request.Title, request.Excerpt, request.ImageUrl, request.Published ?? false,
instructorId, request.Instructor, request.InstructorMiniBio, request.InstructorImageUrl,
null, null, null, request.CertificateUrl, request.StoreUrl, request.EcommerceUrl, request.CreateInEcommerce ?? false,
tags, tutorsIds, extraInstructorIds, request.ModuleGradeType
).Data;
var newDraftList = new List <ModuleDraft>
{
draft
};
await _db.ModuleDraftCollection.InsertOneAsync(
draft, cancellationToken : cancellationToken
);
var creationLog = AuditLog.Create(userId, draft.Id, draft.GetType().ToString(),
JsonConvert.SerializeObject(newDraftList), EntityAction.Add);
await _db.AuditLogCollection.InsertOneAsync(creationLog);
if (dbModuleQuestions.Count > 0)
{
var draftQuestions = dbModuleQuestions.Select(q =>
QuestionDraft.Create(
q.Id, draft.Id,
q.Text, q.Level, q.Duration,
q.Concepts, q.Answers,
q.ModuleId, q.SubjectId
).Data
);
await _db.QuestionDraftCollection.InsertManyAsync(
draftQuestions, cancellationToken : cancellationToken
);
}
return(Result.Ok(draft));
}
public async Task <Result> Handle(Contract request, CancellationToken cancellationToken)
{
if (request.UserRole == "Secretary")
{
return(Result.Fail("Acesso Negado"));
}
var moduleId = ObjectId.Parse(request.ModuleId);
var module = await _db.ModuleDraftCollection.AsQueryable()
.Where(x => (
x.DeletedAt == null || x.DeletedAt == DateTimeOffset.MinValue
) && !x.DraftPublished && (
x.Id == moduleId || x.ModuleId == moduleId
)
)
.FirstOrDefaultAsync(cancellationToken: cancellationToken);
if (module == null)
{
var originalModule = await GetModule(request.ModuleId);
if (originalModule == null)
{
return(Result.Fail("Módulo não existe"));
}
module = await CreateModuleDraft(
request, originalModule, cancellationToken
);
}
var subjectConceptDictionary = new Dictionary <string, List <string> >();
foreach (var subject in module.Subjects)
{
var subjectConcepts = subject.Concepts.Select(x => x.Name).ToList();
subjectConceptDictionary.Add(subject.Id.ToString(), subjectConcepts);
}
var questions = new List <QuestionDraft>();
request.File = request.File.Substring(request.File.IndexOf(",", StringComparison.Ordinal) + 1);
Byte[] bytes = Convert.FromBase64String(request.File);
using (Stream stream = new MemoryStream(bytes))
{
using (var xlPackage = new ExcelPackage(stream))
{
var baseWorksheet = xlPackage.Workbook.Worksheets[0];
var currentLine = 2;
while (baseWorksheet.Cells[currentLine, 1].Value != null)
{
/*
* IDExterno Assunto
* ID Nível
* Descrição Questão
* Tempo médio de Resposta em minutos
* Resposta 1
* Valor Resposta 1
* Conceitos certos Resposta 1
* Resposta 2
* Valor Resposta 2
* Conceitos certos Resposta 2
* Resposta 3
* Valor Resposta 3
* Conceitos certos Resposta 3
* Resposta 4
* Valor Resposta 4
* Conceitos certos Resposta 4
* Resposta 5
* Valor Resposta 5
* Conceitos certos Resposta 5
*/
var subjectId = baseWorksheet.Cells[currentLine, 1].Value.ToString();
if (!subjectConceptDictionary.ContainsKey(subjectId))
{
return(Result.Fail <bool>("Assunto não encontrado"));
}
var subjectConcepts =
subjectConceptDictionary[subjectId];
var quest = new AddOrModifyQuestionCommand.Contract();
if (!int.TryParse(baseWorksheet.Cells[currentLine, 2].Value.ToString(), out int level))
{
var availableLevels = Level.GetLevels().Data.Select(x => x.Id.ToString())
.Aggregate((x, y) => x + "," + y);
return(Result.Fail <bool>(
$"Não foi possível definir o nível de dificuldade da pergunta da linha {currentLine}. Valores possíveis são ({availableLevels})"));
}
quest.Level = level;
quest.Text = baseWorksheet.Cells[currentLine, 3].Value?.ToString();
if (quest.Text == null || quest.Text.Length < 10)
{
return(Result.Fail <bool>(
$"Texto da pergunta da linha {currentLine} não pode ser menor que 10 caracteres"));
}
var durationStr = baseWorksheet.Cells[currentLine, 4].Value?.ToString();
if (durationStr != null && int.TryParse(durationStr, out int duration))
{
quest.Duration = duration;
}
if (baseWorksheet.Cells[currentLine, 5].Value != null)
{
var answer1 =
this.getAnswerFromWorksheet(baseWorksheet, currentLine, 5, "Resposta 1");
if (answer1.IsFailure)
{
return(Result.Fail <bool>(answer1.Error));
}
quest.Answers.Add(answer1.Data);
}
if (baseWorksheet.Cells[currentLine, 8].Value != null)
{
var answer2 =
this.getAnswerFromWorksheet(baseWorksheet, currentLine, 8, "Resposta 2");
if (answer2.IsFailure)
{
return(Result.Fail <bool>(answer2.Error));
}
quest.Answers.Add(answer2.Data);
}
if (baseWorksheet.Cells[currentLine, 11].Value != null)
{
var answer3 =
this.getAnswerFromWorksheet(baseWorksheet, currentLine, 11, "Resposta 3");
if (answer3.IsFailure)
{
return(Result.Fail <bool>(answer3.Error));
}
quest.Answers.Add(answer3.Data);
}
if (baseWorksheet.Cells[currentLine, 14].Value != null)
{
var answer4 =
this.getAnswerFromWorksheet(baseWorksheet, currentLine, 14, "Resposta 4");
if (answer4.IsFailure)
{
return(Result.Fail <bool>(answer4.Error));
}
quest.Answers.Add(answer4.Data);
}
if (baseWorksheet.Cells[currentLine, 17].Value != null)
{
var answer5 =
this.getAnswerFromWorksheet(baseWorksheet, currentLine, 17, "Resposta 5");
if (answer5.IsFailure)
{
return(Result.Fail <bool>(answer5.Error));
}
quest.Answers.Add(answer5.Data);
}
var concepts = quest.Answers.SelectMany(x => x.Concepts).Select(x => x.Concept).Distinct().ToList();
quest.Concepts = concepts.ToArray();
var notContainedConcepts = concepts.Where(x => !subjectConcepts.Contains(x)).ToList();
if (notContainedConcepts.Any())
{
return(Result.Fail <bool>($"Os conceitos ({notContainedConcepts.Aggregate((x, y) => x + "," + y)}) das repostas da linha {currentLine} não estão contidos no assunto"));
}
// Colocando os conceitos errados da pergunta
foreach (var answer in quest.Answers)
{
var answerConcepts = answer.Concepts.Select(x => x.Concept);
var notPresentConcepts = concepts.Where(x => !answerConcepts.Contains(x)).Select(
x => new AddOrModifyQuestionCommand.ContractAnswerConcept()
{
Concept = x.Trim(),
IsRight = false
});
answer.Concepts.AddRange(notPresentConcepts);
}
var answers = quest.Answers.Select(x => new Answer(x.Description, x.Points,
x.Concepts.Select(y => new AnswerConcept(y.Concept, y.IsRight)).ToList())).ToList();
var newObject = QuestionDraft.Create(
module.Id, quest.Text, quest.Level,
quest.Duration, quest.Concepts, answers,
ObjectId.Parse(request.ModuleId), ObjectId.Parse(subjectId)
);
if (newObject.IsFailure)
{
return(Result.Fail <bool>($"Erro na linha {currentLine}: {newObject.Error}"));
}
questions.Add(newObject.Data);
currentLine++;
}
}
}
if (!request.AddQuestions)
{
var baseQuestionDraftCollection = await _db.QuestionDraftCollection
.AsQueryable()
.Where(x =>
x.DraftId == module.Id
)
.ToListAsync();
await _db.QuestionDraftCollection.DeleteManyAsync(x =>
x.DraftId == module.Id,
cancellationToken : cancellationToken
);
var deleteLog = AuditLog.Create(ObjectId.Parse(request.UserId), moduleId, baseQuestionDraftCollection.GetType().ToString(),
JsonConvert.SerializeObject(baseQuestionDraftCollection), EntityAction.Delete);
await _db.AuditLogCollection.InsertOneAsync(deleteLog);
}
await _db.QuestionDraftCollection.InsertManyAsync(
questions, cancellationToken : cancellationToken
);
var creationLog = AuditLog.Create(ObjectId.Parse(request.UserId), moduleId, questions[0].GetType().ToString(),
JsonConvert.SerializeObject(questions), EntityAction.Add);
await _db.AuditLogCollection.InsertOneAsync(creationLog);
return(Result.Ok());
}
public async Task <Result <Contract> > Handle(Contract request, CancellationToken cancellationToken)
{
if (request.UserRole == "Secretary" || request.UserRole == "Recruiter")
{
return(Result.Fail <Contract>("Acesso Negado"));
}
var mId = ObjectId.Parse(request.ModuleId);
var userId = ObjectId.Parse(request.UserId);
var module = await _db.ModuleDraftCollection.AsQueryable()
.Where(x => (
x.DeletedAt == null || x.DeletedAt == DateTimeOffset.MinValue
) && !x.DraftPublished && (
x.Id == mId || x.ModuleId == mId
)
)
.FirstOrDefaultAsync(cancellationToken: cancellationToken);
if (module == null)
{
return(Result.Fail <Contract>("Módulo não Encontrado"));
}
if (request.UserRole == "Student")
{
if (!ModuleDraft.IsInstructor(module, userId).Data)
{
return(Result.Fail <Contract>("Acesso Negado"));
}
}
var subject = module.Subjects.FirstOrDefault(x =>
x.Id == ObjectId.Parse(request.SubjectId)
);
if (subject == null)
{
return(Result.Fail <Contract>("Assunto não Encontrado"));
}
var answers = request.Answers.Select(x =>
new Answer(
x.Description, x.Points,
x.Concepts.Select(y => new AnswerConcept(y.Concept, y.IsRight)).ToList()
)
).ToList();
Result <QuestionDraft> newObject;
if (!String.IsNullOrEmpty(request.QuestionId))
{
var questionId = ObjectId.Parse(request.QuestionId);
newObject = QuestionDraft.Create(
questionId, module.Id, request.Text, request.Level, request.Duration,
request.Concepts, answers, module.ModuleId, ObjectId.Parse(request.SubjectId)
);
}
else
{
newObject = QuestionDraft.Create(
module.Id, request.Text, request.Level, request.Duration,
request.Concepts, answers, module.ModuleId, ObjectId.Parse(request.SubjectId)
);
}
if (newObject.IsFailure)
{
return(Result.Fail <Contract>(newObject.Error));
}
var newQuestion = newObject.Data;
var newQuestionList = new List <QuestionDraft>
{
newQuestion
};
if (string.IsNullOrEmpty(request.Id))
{
await _db.QuestionDraftCollection.InsertOneAsync(
newQuestion,
cancellationToken : cancellationToken
);
request.Id = newQuestion.Id.ToString();
var creationLog = AuditLog.Create(userId, mId, newQuestionList[0].GetType().ToString(),
JsonConvert.SerializeObject(newQuestionList), EntityAction.Add);
await _db.AuditLogCollection.InsertOneAsync(creationLog);
}
else
{
var question = await _db.QuestionDraftCollection
.AsQueryable()
.Where(x => x.Id == ObjectId.Parse(request.Id))
.FirstOrDefaultAsync(cancellationToken: cancellationToken);
if (question == null)
{
return(Result.Fail <Contract>("Questão não Encontrada"));
}
var oldQuestionList = new List <QuestionDraft>
{
question
};
var oldValues = JsonConvert.SerializeObject(oldQuestionList);
question.ModuleId = newQuestion.ModuleId;
question.SubjectId = newQuestion.SubjectId;
question.Concepts = newQuestion.Concepts;
question.Answers = newQuestion.Answers;
question.Duration = newQuestion.Duration;
question.Level = newQuestion.Level;
question.Text = newQuestion.Text;
question.UpdatedAt = DateTimeOffset.UtcNow;
await _db.QuestionDraftCollection.ReplaceOneAsync(t =>
t.Id == question.Id, question,
cancellationToken : cancellationToken
);
var changeLog = AuditLog.Create(userId, mId, newQuestionList[0].GetType().ToString(),
JsonConvert.SerializeObject(newQuestionList), EntityAction.Update, oldValues);
await _db.AuditLogCollection.InsertOneAsync(changeLog);
}
return(Result.Ok(request));
}
