public override CourseResponse SendItem(AbstractMoodleServiceClient client, Disciplina item)
{
CreateCourseClient createClient = (CreateCourseClient)client;
long?categoryId = item.GetMoodleCursoId(ModalidadeAtual, GetCategoryByNameClient, client.GetUnderlyingHttpClient());
if (!categoryId.HasValue)
{
throw new MoodleDataNotExistsException($"O curso [{item.CursoDescricao}]´nõa está adicionado ao MOODLE.");
}
CourseRequest request = new CourseRequest()
{
CategoryId = categoryId.Value,
Fullname = item.DisciplinaNome,
Shortname = item.ShortName,
Visible = 1
};
Task <CourseResponse> task = createClient.Post(request);
task.Wait();
CourseResponse response = task.Result;
LastUrl = createClient.LastUrl;
return(response);
}
protected override void ProcessWithRegularForeach(IEnumerable <Aluno> data, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
foreach (var item in data)
{
ProcessItem(item, createClient, verifyClient);
}
}
protected override void ProcessWithParallelism(IEnumerable <Professor> data, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
data.AsParallel()
.WithExecutionMode(ParallelExecutionMode.ForceParallelism)
.ForAll((item) =>
{
ProcessItem(item, createClient, verifyClient);
});
}
protected override void ProcessWithParallelism(IEnumerable <Aluno> data, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
data.AsParallel()
.WithExecutionMode(ParallelExecutionMode.ForceParallelism)
.WithMergeOptions(ParallelMergeOptions.FullyBuffered)
.ForAll((item) =>
{
ProcessItem(item, createClient, verifyClient);
});
}
protected override void ProcessItem(AlunoDisciplinaViewModel viewmodel, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
viewmodel.Disciplinas = ConsultaAcademicaService.GetDisciplinasAluno(viewmodel.Aluno.IdAluno);
if (viewmodel.Disciplinas?.Count() == 0)
{
Log($"Aluno {viewmodel.Aluno.AlunoNome} não tem disciplinas");
return;
}
foreach (var disciplina in viewmodel.Disciplinas)
{
ProcessDisciplina(viewmodel.Aluno, disciplina, createClient, verifyClient);
}
}
protected override void ProcessItem(ProfessorDisciplinaViewModel viewmodel, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
if (UseParallelism)
{
Parallel.ForEach(viewmodel.Disciplinas, (disciplina) =>
{
ProcessDisciplina(viewmodel.Professor, disciplina, createClient, verifyClient);
});
}
else
{
foreach (var disciplina in viewmodel.Disciplinas)
{
ProcessDisciplina(viewmodel.Professor, disciplina, createClient, verifyClient);
}
}
}
public override CourseResponse VerifyIfExists(AbstractMoodleServiceClient client, string filter)
{
GetCourseByNameClient verifyClient = (GetCourseByNameClient)client;
GetByNameRequest request = new GetByNameRequest()
{
Name = filter
};
Task <CourseResponse> task = verifyClient.Post(request);
task.Wait();
LastUrl = client.LastUrl;
CourseResponse response = task.Result;
return(response);
}
public override UserResponse VerifyIfExists(AbstractMoodleServiceClient client, string filter)
{
GetUserByUsernameClient verifyClient = (GetUserByUsernameClient)client;
GetByUsernameRequest request = new GetByUsernameRequest()
{
Username = filter.DesformatarCpf()
};
Task <UserResponse> task = verifyClient.Post(request);
task.Wait();
LastUrl = client.LastUrl;
UserResponse response = task.Result;
return(response);
}
public override UserResponse SendItem(AbstractMoodleServiceClient client, Aluno item)
{
CreateUserClient createClient = (CreateUserClient)client;
var nome = item.AlunoNomeSocial ?? item.AlunoNome;
var tuple = nome.SepararNomeSobrenome();
var matricula = item.AlunoMatricula.FormatarMatricula();
if (item.AlunoEmail == null)
{
item.AlunoEmail = "";
}
UserRequest request = new UserRequest()
{
Email = item.AlunoEmail.TratarEmail(matricula),
Username = item.AlunoCpf.DesformatarCpf(),
Firstname = tuple.Item1,
Lastname = tuple.Item2,
Password = matricula
};
request.Preferences.Add("auth_forcepasswordchange", "1");
Task <UserResponse> task = createClient.Post(request);
task.Wait();
UserResponse response = task.Result;
LastUrl = createClient.LastUrl;
if (response != null)
{
response.Fullname = item.AlunoNomeSocial;
response.Email = item.AlunoEmail;
}
return(response);
}
protected void ProcessDisciplina(Professor professor, Disciplina disciplina, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
disciplina.DisciplinaNome = disciplina.GetNomeDisciplina(Configuration, ModalidadeAtual);
disciplina.ShortName = disciplina.GetShortNameDisciplina(Configuration, ModalidadeAtual);
try
{
InternalMoodleData moodleData = VerifyIfExistsOnMoodleAndCreateIfDont(professor, disciplina);
GetEnrolmentsByUserIdResponse response = null;
if (moodleData?.MoodleCategoryId > 0 && moodleData?.MoodleCourseId > 0 && moodleData?.MoodleUserId > 0)
{
response = SendDisciplina(moodleData);
}
ProfessorDisciplinaImportedResult <ProfessorDisciplinaViewModel, GetEnrolmentsByUserIdResponse> importedResult =
new ProfessorDisciplinaImportedResult <ProfessorDisciplinaViewModel, GetEnrolmentsByUserIdResponse>()
{
Date = DateTime.Now,
Url = LastUrl,
Professor = professor,
Disciplina = disciplina,
Result = response
};
Result.ImportedSuccessfully.Enqueue(importedResult);
Log($"Disciplina [{disciplina.DisciplinaNome}] do professor [{professor.ProfessorCpf} | {professor.ProfessorNome}] adicionada.");
}
catch (MoodleDataNotExistsException mex)
{
var reason = new ProfessorDisciplinaNotImportedReason <ProfessorDisciplinaViewModel>()
{
Url = LastUrl,
Professor = professor,
Disciplina = disciplina,
Reason = mex.Message
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
catch (AggregateException agex)
{
var exception = agex.InnerExceptions[0];
var reason = new ProfessorDisciplinaNotImportedReason <ProfessorDisciplinaViewModel>()
{
Url = LastUrl,
Professor = professor,
Disciplina = disciplina,
Exception = exception,
Reason = exception.Message
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
catch (Exception ex)
{
var reason = new ProfessorDisciplinaNotImportedReason <ProfessorDisciplinaViewModel>()
{
Url = LastUrl,
Professor = professor,
Disciplina = disciplina,
Exception = ex,
Reason = ex.Message
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
}
protected override void ProcessItem(Professor item, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
try
{
long?cachedMoodleId = MoodleFromToCache.GetCachedMoodleUser(ModalidadeAtual.IdModalidade, item.ProfessorCpf);
if (cachedMoodleId.HasValue)
{
LastUrl = "cached_value";
var reason = new NotImportedReason <Professor>()
{
Data = item,
Url = LastUrl,
Reason = $"Professor [{item.ProfessorCpf} | {item.ProfessorNome}] já está adicionado ao MOODLE ({LastUrl})."
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
return;
}
UserResponse exists = VerifyIfExists(verifyClient, item.ProfessorCpf);
if (exists?.Id > 0)
{
MoodleFromToCache.AddUser(ModalidadeAtual.IdModalidade, item.ProfessorCpf, exists.Id);
var reason = new NotImportedReason <Professor>()
{
Data = item,
Url = LastUrl,
Reason = $"Professor [{item.ProfessorCpf} | {item.ProfessorNome}] já está adicionado ao MOODLE ({LastUrl})."
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
return;
}
if (item.AtivoProfessor)
{
UserResponse response = SendItem(createClient, item);
ImportedResult <Professor, UserResponse> importedResult = new ImportedResult <Professor, UserResponse>()
{
Date = DateTime.Now,
Data = item,
Url = LastUrl,
Result = response,
Active = true,
};
Result.ImportedSuccessfully.Enqueue(importedResult);
Log($"Professor [{item.ProfessorCpf} | {item.ProfessorNome}] adicionado.");
MoodleFromToCache.AddUser(ModalidadeAtual.IdModalidade, item.ProfessorCpf, response.Id);
}
else
{
SuspendedUserResult suspendedUserResult = this.SuspendItem(item, ModalidadeAtual, createClient.GetUnderlyingHttpClient());
if (!suspendedUserResult.MoodleId.HasValue)
{
throw new MoodleDataNotExistsException($"Tentativa de suspender usuário falhou. O professor [{item.ProfessorCpf} | {item.ProfessorNome}] não está cadastrado no MOODLE");
}
var nome = item.ProfessorNome;
var matricula = item.ProfessorMatricula.FormatarMatricula();
if (item.ProfessorEmail == null)
{
item.ProfessorEmail = "";
}
UserResponse response = new UserResponse()
{
Email = item.ProfessorEmail.TratarEmail(item.ProfessorMatricula),
Id = suspendedUserResult.MoodleId.Value,
Fullname = nome,
Username = item.ProfessorCpf.DesformatarCpf()
};
ImportedResult <Professor, UserResponse> importedResult = new ImportedResult <Professor, UserResponse>()
{
Date = DateTime.Now,
Data = item,
Url = suspendedUserResult.LastUrl,
Result = response,
Active = false
};
Result.ImportedSuccessfully.Enqueue(importedResult);
Log($"Professor [{item.ProfessorCpf} | {item.ProfessorNome}] SUSPENSO.");
MoodleFromToCache.AddUser(ModalidadeAtual.IdModalidade, item.ProfessorCpf, suspendedUserResult.MoodleId.Value);
}
}
catch (MoodleDataNotExistsException mex)
{
var reason = new NotImportedReason <Professor>()
{
Data = item,
Url = LastUrl,
Reason = mex.Message
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
catch (AggregateException agex)
{
var exception = agex.InnerExceptions[0];
var reason = new NotImportedReason <Professor>()
{
Data = item,
Url = LastUrl,
Reason = exception.Message,
Exception = exception
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
catch (Exception ex)
{
var reason = new NotImportedReason <Professor>()
{
Data = item,
Url = LastUrl,
Exception = ex,
Reason = ex.Message
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
}
protected override void ProcessItem(Disciplina item, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
try
{
item.DisciplinaNome = item.GetNomeDisciplina(Configuration, ModalidadeAtual);
item.ShortName = item.GetShortNameDisciplina(Configuration, ModalidadeAtual);
long?cachedMoodleId = MoodleFromToCache.GetCachedMoodleCourse(ModalidadeAtual.IdModalidade, item.DisciplinaNome);
if (cachedMoodleId.HasValue)
{
LastUrl = "cached_value";
var reason = new NotImportedReason <Disciplina>()
{
Data = item,
Url = LastUrl,
Reason = $"Disciplina [{item.DisciplinaNome}] já está adicionada ao MOODLE ({LastUrl})."
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
return;
}
CourseResponse exists = VerifyIfExists(verifyClient, item.DisciplinaNome);
if (exists?.Id > 0)
{
MoodleFromToCache.AddCourse(ModalidadeAtual.IdModalidade, item.DisciplinaNome, exists.Id);
var reason = new NotImportedReason <Disciplina>()
{
Data = item,
Url = LastUrl,
Reason = $"Disciplina [{item.DisciplinaNome}] já está adicionada ao MOODLE ({LastUrl})."
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
return;
}
CourseResponse response = SendItem(createClient, item);
ImportedResult <Disciplina, CourseResponse> importedResult = new ImportedResult <Disciplina, CourseResponse>()
{
Date = DateTime.Now,
Data = item,
Url = LastUrl,
Result = response,
Active = true,
};
Result.ImportedSuccessfully.Enqueue(importedResult);
MoodleFromToCache.AddCourse(ModalidadeAtual.IdModalidade, item.DisciplinaNome, response.Id);
Log($"Disciplina {item.DisciplinaNome} adicionado.");
}
catch (MoodleDataNotExistsException mex)
{
var reason = new NotImportedReason <Disciplina>()
{
Data = item,
Url = LastUrl,
Reason = mex.Message
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
catch (AggregateException agex)
{
var exception = agex.InnerExceptions[0];
var reason = new NotImportedReason <Disciplina>()
{
Data = item,
Url = LastUrl,
Reason = exception.Message,
Exception = exception
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
catch (Exception ex)
{
var reason = new NotImportedReason <Disciplina>()
{
Data = item,
Url = LastUrl,
Exception = ex,
Reason = ex.Message
};
Result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
}
protected abstract void ProcessWithParallelism(IEnumerable <TData> data, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient);
protected abstract void ProcessItem(TData data, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient);
protected override void ProcessWithRegularForeach(IEnumerable <AlunoDisciplinaViewModel> data, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
/*var cpfs = new string[] {
* "054.653.471-63",
* "041.699.381-86",
* "039.320.661-03",
* "039.281.621-01",
* "006.818.041-14",
* "038.654.121-30",
* "057.103.101-31"
* };*/
foreach (var viewmodel in data)
{
/*if(cpfs.Contains(viewmodel.Aluno.AlunoCpf))
* {
* Debugger.Break();
* }
*/
ProcessItem(viewmodel, createClient, verifyClient);
}
}
protected abstract void ProcessWithRegularForeach(IEnumerable <TData> data, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient);
public virtual TResponse SendItem(AbstractMoodleServiceClient client, TData item)
{
throw new NotImplementedException();
}
protected void ProcessDisciplina(Aluno aluno, Disciplina disciplina, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
if (disciplina?.IdDisciplina == 0 || string.IsNullOrEmpty(disciplina?.DisciplinaNome))
{
return;
}
disciplina.DisciplinaNome = disciplina.GetNomeDisciplina(Configuration, ModalidadeAtual);
disciplina.ShortName = disciplina.GetShortNameDisciplina(Configuration, ModalidadeAtual);
try
{
InternalMoodleData moodleData = VerifyIfExistsOnMoodleAndCreateIfDont(aluno, disciplina);
GetEnrolmentsByUserIdResponse response = null;
if (moodleData?.MoodleCategoryId > 0 && moodleData?.MoodleCourseId > 0 && moodleData?.MoodleUserId > 0)
{
response = SendDisciplina(moodleData);
}
AlunoDisciplinaImportedResult <AlunoDisciplinaViewModel, GetEnrolmentsByUserIdResponse> importedResult =
new AlunoDisciplinaImportedResult <AlunoDisciplinaViewModel, GetEnrolmentsByUserIdResponse>()
{
Date = DateTime.Now,
Aluno = aluno,
Disciplina = disciplina,
Url = LastUrl,
Result = response
};
Result.ImportedSuccessfully.Enqueue(importedResult);
Log($"Disciplina {disciplina.DisciplinaNome} do aluno {aluno.AlunoNomeSocial ?? aluno.AlunoNome} adicionada.");
}
catch (MoodleDataNotExistsException mex)
{
var reason = new AlunoDisciplinaNotImportedReason <AlunoDisciplinaViewModel>()
{
Url = LastUrl,
Aluno = aluno,
Disciplina = disciplina,
Reason = mex.Message
};
Result.NotImported.Enqueue(reason);
Log($"Disciplina {disciplina.DisciplinaNome} não adicionada. {reason.Reason}");
}
catch (AggregateException agex)
{
var exception = agex.InnerExceptions[0];
var reason = new AlunoDisciplinaNotImportedReason <AlunoDisciplinaViewModel>()
{
Url = LastUrl,
Aluno = aluno,
Disciplina = disciplina,
Exception = exception,
Reason = exception.Message
};
Result.NotImported.Enqueue(reason);
if (exception is MoodleResponseException moodleEx)
{
Log($"Disciplina {disciplina.DisciplinaNome} não adicionada. {moodleEx.RawMoodleError}");
}
else
{
Log($"Disciplina {disciplina.DisciplinaNome} não adicionada. {reason.Reason}");
}
}
catch (Exception ex)
{
var reason = new AlunoDisciplinaNotImportedReason <AlunoDisciplinaViewModel>()
{
Url = LastUrl,
Aluno = aluno,
Disciplina = disciplina,
Exception = ex,
Reason = ex.Message
};
Result.NotImported.Enqueue(reason);
Log($"Disciplina {disciplina.DisciplinaNome} não adicionada. {reason.Reason}");
}
}
public virtual TResponse VerifyIfExists(AbstractMoodleServiceClient client, string filter)
{
throw new NotImplementedException();
}
protected override void ProcessWithRegularForeach(IEnumerable <ProfessorDisciplinaViewModel> data, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
/*var cpfs = new string[] {
* "638.819.421-49"
* };*/
foreach (var viewmodel in data)
{
/*if (cpfs.Contains(viewmodel.Professor.ProfessorCpf))
* {
* Debugger.Break();
* }*/
ProcessItem(viewmodel, createClient, verifyClient);
}
}
protected override void ProcessWithParallelism(IEnumerable <AlunoDisciplinaViewModel> data, AbstractMoodleServiceClient createClient, AbstractMoodleServiceClient verifyClient)
{
data.AsParallel()
.WithExecutionMode(ParallelExecutionMode.ForceParallelism)
.ForAll((viewmodel) =>
{
ProcessItem(viewmodel, createClient, verifyClient);
});
}
