private ModuleDraft DeleteNonExisting(ModuleDraft module, List <ContractContent> contents)
{
foreach (var subject in module.Subjects)
{
var requestIds = from content in contents
where !string.IsNullOrEmpty(content.Id)
select ObjectId.Parse(content.Id);
subject.Contents = subject.Contents.Where(
x => requestIds.Contains(x.Id)
).ToList();
}
return(module);
}
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);
}
private async Task <bool> UpdateCurrentModule(ObjectId userId, ModuleDraft draft, CancellationToken token)
{
var module = await _db.ModuleCollection.AsQueryable()
.Where(mod => mod.Id == draft.ModuleId)
.FirstOrDefaultAsync();
if (module == null)
{
return(false);
}
string config = _configuration[$"EcommerceIntegration:Active"];
if (!draft.EcommerceId.HasValue && draft.CreateInEcommerce && config == "True")
{
var response = await CreateEcommerceProduct(module);
string content = await response.Content.ReadAsStringAsync();
if (response.StatusCode == HttpStatusCode.Created)
{
var parsed = JObject.Parse(content);
module.EcommerceId = (long)parsed["product"]["id"];
}
else
{
var error = ErrorLog.Create(
ErrorLogTypeEnum.EcommerceIntegration,
"create-module", content
).Data;
await _db.ErrorLogCollection.InsertOneAsync(
error, cancellationToken : token
);
}
}
var serializedModuleOldValues = JsonConvert.SerializeObject(new List <Module>
{
module
});
module.Title = draft.Title;
module.Excerpt = draft.Excerpt;
module.ImageUrl = draft.ImageUrl;
module.Published = draft.Published;
module.InstructorId = draft.InstructorId;
module.ExtraInstructorIds = draft.ExtraInstructorIds;
module.Instructor = draft.Instructor;
module.InstructorMiniBio = draft.InstructorMiniBio;
module.InstructorImageUrl = draft.InstructorImageUrl;
module.Duration = draft.Duration;
module.VideoUrl = draft.VideoUrl;
module.VideoDuration = draft.VideoDuration;
module.CertificateUrl = draft.CertificateUrl;
module.StoreUrl = draft.StoreUrl;
module.EcommerceUrl = draft.EcommerceUrl;
module.Tags = draft.Tags;
module.TutorsIds = draft.TutorsIds;
module.Subjects = draft.Subjects;
module.Requirements = draft.Requirements;
module.SupportMaterials = draft.SupportMaterials;
module.EcommerceId = draft.EcommerceId;
module.ModuleGradeType = draft.ModuleGradeType;
var listEcomerce = new List <EcommerceModule>();
if (draft.EcommerceProducts != null && draft.EcommerceProducts.Count > 0)
{
for (int i = 0; i < draft.EcommerceProducts.Count; i++)
{
var currentDraftProduct = draft.EcommerceProducts[i];
listEcomerce.Add(new EcommerceModule()
{
EcommerceId = currentDraftProduct.EcommerceId,
UsersAmount = currentDraftProduct.UsersAmount,
DisableEcommerce = currentDraftProduct.DisableEcommerce,
Price = currentDraftProduct.Price,
DisableFreeTrial = currentDraftProduct.DisableFreeTrial,
LinkEcommerce = currentDraftProduct.LinkEcommerce,
LinkProduct = currentDraftProduct.LinkProduct,
Subject = currentDraftProduct.Subject,
Hours = currentDraftProduct.Hours
});
}
}
module.EcommerceProducts = listEcomerce;
await _db.ModuleCollection.ReplaceOneAsync(t =>
t.Id == module.Id, module,
cancellationToken : token
);
var newDraftList = new List <Module>
{
module
};
var auditLog = AuditLog.Create(userId, module.Id, module.GetType().ToString(),
JsonConvert.SerializeObject(newDraftList), EntityAction.Update, serializedModuleOldValues);
await _db.AuditLogCollection.InsertOneAsync(auditLog);
return(true);
}
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 <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));
}
public async Task <Result> Handle(Contract request, CancellationToken cancellationToken)
{
if (request.UserRole != "Admin" && request.UserRole != "Author")
{
return(Result.Fail("Acesso Negado"));
}
var userId = ObjectId.Parse(request.UserId);
var draftId = ObjectId.Parse(request.ModuleId);
var module = await _db.ModuleDraftCollection.AsQueryable()
.Where(x => (
x.DeletedAt == null || x.DeletedAt == DateTimeOffset.MinValue
) && !x.DraftPublished && (
x.Id == draftId || x.ModuleId == draftId
)
)
.FirstOrDefaultAsync();
if (module == null)
{
return(Result.Fail("Rascunho de Módulo não encontrado"));
}
if (module.CreatedBy != userId)
{
return(Result.Fail("Você não tem permissão de excluir o módulo selecionado."));
}
if (request.UserRole == "Student")
{
if (!ModuleDraft.IsInstructor(module, userId).Data)
{
return(Result.Fail("Acesso Negado"));
}
}
module.DeletedBy = ObjectId.Parse(request.UserId);
module.DeletedAt = DateTimeOffset.Now;
await _db.ModuleDraftCollection.ReplaceOneAsync(t =>
t.Id == module.Id, module,
cancellationToken : cancellationToken
);
var oldDraftList = new List <ModuleDraft>
{
module
};
var changeLog = AuditLog.Create(userId, draftId, module.GetType().ToString(),
"", EntityAction.Delete, JsonConvert.SerializeObject(oldDraftList));
await _db.AuditLogCollection.InsertOneAsync(changeLog);
var questionDrafts = await _db.QuestionDraftCollection.AsQueryable()
.Where(d => d.ModuleId == module.ModuleId && !d.DraftPublished)
.ToListAsync();
if (questionDrafts.Count > 0)
{
var update = Builders <QuestionDraft> .Update
.Set(d => d.DeletedAt, DateTimeOffset.Now)
.Set(d => d.DeletedBy, ObjectId.Parse(request.UserId));
var ids = questionDrafts.Select(x => x.Id).ToArray();
await _db.QuestionDraftCollection.UpdateManyAsync(x =>
ids.Contains(x.Id), update,
cancellationToken : cancellationToken
);
}
return(Result.Ok());
}