public override ParallelSendResult <Professor, UserResponse> SendAll()
{
Result = new ParallelSendResult <Professor, UserResponse>();
System.GC.Collect();
IEnumerable <Professor> data = GetData("");
if (data == null)
{
return(Result);
}
var factory = new HttpClientFactory();
using (var httpClient = factory.CreateMoodleHttpClient())
{
CreateUserClient createClient = new CreateUserClient();
GetUserByUsernameClient verifyClient = new GetUserByUsernameClient();
// Sharing the same HttpClient instance to improve performance
verifyClient.AddHttpClient(httpClient);
createClient.AddHttpClient(httpClient);
foreach (var modalidade in Modalidades)
{
ModalidadeAtual = modalidade;
this.AddMoodleBaseUrl(modalidade.MoodleUrl)
.AddMoodleToken(modalidade.MoodleToken)
.AddMoodleGetInfoServiceToken(modalidade.MoodleGetInfoServiceToken)
.AddMoodleServiceUrl(modalidade.MoodleServiceUrl);
BuildMoodleClient(createClient, MoodleTokenType.OfficialMoodleApiFunctions);
BuildMoodleClient(verifyClient, MoodleTokenType.LocalMoodleExternalApiGetInfoToken);
var professores = data.Where
(
x =>
(
x.Disciplinas
.Where(d => d.IdModalidade == modalidade.IdModalidade)
.Count() > 0
)
)
.ToArray();
if (UseParallelism)
{
ProcessWithParallelism(professores, createClient, verifyClient);
}
else
{
ProcessWithRegularForeach(professores, createClient, verifyClient);
}
}
}
return(Result);
}
public override ParallelSendResult <AlunoDisciplinaViewModel, GetEnrolmentsByUserIdResponse> SendAll()
{
Result = new ParallelSendResult <AlunoDisciplinaViewModel, GetEnrolmentsByUserIdResponse>();
IEnumerable <AlunoDisciplinaViewModel> data = GetData("");
if (data == null)
{
return(Result);
}
var factory = new HttpClientFactory();
HttpClient = factory.CreateMoodleHttpClient();
CreateCourseClient = new CreateCourseClient();
CreateCategoryClient = new CreateCategoryClient();
CreateUserClient = new CreateUserClient();
GetCategoryByNameClient = new GetCategoryByNameClient();
GetCourseByNameClient = new GetCourseByNameClient();
GetUserByUsernameClient = new GetUserByUsernameClient();
EnrolmentClient = new EnrolmentClient();
GetEnrolementsrByUserIdClient = new GetEnrolementsrByUserIdClient();
CreateCourseClient.AddHttpClient(HttpClient);
CreateCategoryClient.AddHttpClient(HttpClient);
CreateUserClient.AddHttpClient(HttpClient);
GetCategoryByNameClient.AddHttpClient(HttpClient);
GetCourseByNameClient.AddHttpClient(HttpClient);
GetUserByUsernameClient.AddHttpClient(HttpClient);
EnrolmentClient.AddHttpClient(HttpClient);
GetEnrolementsrByUserIdClient.AddHttpClient(HttpClient);
foreach (var modalidade in Modalidades)
{
ModalidadeAtual = modalidade;
this.AddMoodleBaseUrl(modalidade.MoodleUrl)
.AddMoodleToken(modalidade.MoodleToken)
.AddMoodleGetInfoServiceToken(modalidade.MoodleGetInfoServiceToken)
.AddMoodleServiceUrl(modalidade.MoodleServiceUrl);
this.AddMoodleCategoryParent(modalidade.MoodleCategoryParent)
.AddMoodleDescriptionFormat(modalidade.MoodleDescriptionFormat);
var alunos = data.Where(x => x.Aluno.IdModalidade == modalidade.IdModalidade).ToArray();
if (UseParallelism)
{
ProcessWithParallelism(alunos, null, null);
}
else
{
ProcessWithRegularForeach(alunos, null, null);
}
}
return(Result);
}
public ParallelSendResult <Aluno, UserResponse> ImportarAlunos(IEnumerable <Aluno> alunos)
{
AlunoProxy alunoProxy = new AlunoProxy(ConsultaAcademicaService)
{
UseParallelism = UseParallelism,
CanLog = CanLog
};
ParallelSendResult <Aluno, UserResponse> result = alunoProxy.AddAlunos(alunos)
.AddModalidades(Modalidades)
.AddSemestreAtual(Configuration.SemestreAtual)
.SendAll();
return(result);
}
public ParallelSendResult <Professor, UserResponse> ImportarProfessores(IEnumerable <Professor> professores)
{
ProfessorProxy professorProxy = new ProfessorProxy(ConsultaAcademicaService)
{
UseParallelism = UseParallelism,
CanLog = CanLog
};
ParallelSendResult <Professor, UserResponse> result = professorProxy.AddProfessores(professores)
.AddModalidades(Modalidades)
.AddSemestreAtual(Configuration.SemestreAtual)
.SendAll();
return(result);
}
public ParallelSendResult <Disciplina, CourseResponse> ImportarDisciplinas()
{
DisciplinaProxy disciplinaProxy = new DisciplinaProxy(ConsultaAcademicaService)
{
UseParallelism = UseParallelism,
CanLog = CanLog
};
ParallelSendResult <Disciplina, CourseResponse> result = disciplinaProxy
.AddConfiguration(Configuration)
.AddModalidades(Modalidades)
.AddSemestreAtual(Configuration.SemestreAtual)
.SendAll();
return(result);
}
public void SaveAlumnLogs(ParallelSendResult <Aluno, UserResponse> result)
{
var logs = new List <LogImportacao>();
while (!result.ImportedSuccessfully.IsEmpty)
{
ImportedResult <Aluno, UserResponse> item = null;
bool success = result.ImportedSuccessfully.TryDequeue(out item);
if (!success)
{
continue;
}
var log = LogImportacao.Parse <Aluno, UserResponse>(item, TipoImportacao.Aluno);
if (log.Suspenso)
{
log.Mensagem = $"Suspensão do aluno [{item.Data.AlunoCpf}][{item.Data.AlunoNomeSocial}]. Situação acadêmica: [{item.Data.SituacaoAcademicaNome}]";
}
else
{
log.Mensagem = $"Criação de usuário para o aluno [{item.Data.AlunoCpf}][{item.Data.AlunoNomeSocial}]";
}
log.Sincronia = Sincronia;
logs.Add(log);
}
while (!result.NotImported.IsEmpty)
{
NotImportedReason <Aluno> item = null;
bool success = result.NotImported.TryDequeue(out item);
if (!success)
{
continue;
}
var log = LogImportacao.Parse <Aluno>(item, TipoImportacao.Aluno);
log.Sincronia = Sincronia;
logs.Add(log);
}
Repository.Save(logs);
}
public void SaveProfessorLogs(ParallelSendResult <Professor, UserResponse> result)
{
var logs = new List <LogImportacao>();
while (!result.ImportedSuccessfully.IsEmpty)
{
ImportedResult <Professor, UserResponse> item = null;
bool success = result.ImportedSuccessfully.TryDequeue(out item);
if (!success)
{
continue;
}
var log = LogImportacao.Parse <Professor, UserResponse>(item, TipoImportacao.Professor);
log.Sincronia = Sincronia;
if (log.Suspenso)
{
log.Mensagem = $"Suspensão do professor [{item.Data.ProfessorCpf}][{item.Data.ProfessorNome}].";
}
else
{
log.Mensagem = $"Criação de usuário para o professor [{item.Data.ProfessorCpf}][{item.Data.ProfessorNome}]";
}
logs.Add(log);
}
while (!result.NotImported.IsEmpty)
{
NotImportedReason <Professor> item = null;
bool success = result.NotImported.TryDequeue(out item);
if (!success)
{
continue;
}
var log = LogImportacao.Parse <Professor>(item, TipoImportacao.Professor);
log.Sincronia = Sincronia;
logs.Add(log);
}
Repository.Save(logs);
}
public Resultados Sincronizar()
{
SincroniaProxy sincroniaProxy = new SincroniaProxy(SincroniaService, ConsultaAcademicaService);
IEnumerable <Aluno> alunos = sincroniaProxy.GetData();
if (alunos?.Count() == 0)
{
return(null);
}
AlunoProxy alunoProxy = new AlunoProxy(ConsultaAcademicaService)
{
UseParallelism = UseParallelism,
CanLog = CanLog
};
ParallelSendResult <Aluno, UserResponse> alunoResult =
alunoProxy.AddAlunos(alunos)
.AddModalidades(Modalidades)
.AddSemestreAtual(Configuration.SemestreAtual)
.SendAll();
AlunoDisciplinaProxy alunoDisciplinaProxy = new AlunoDisciplinaProxy(ConsultaAcademicaService)
{
UseParallelism = UseParallelism,
CanLog = CanLog
};
ParallelSendResult <AlunoDisciplinaViewModel, GetEnrolmentsByUserIdResponse> disciplinaResult =
alunoDisciplinaProxy.AddAlunos(alunos)
.AddConfiguration(Configuration)
.AddModalidades(Modalidades)
.AddSemestreAtual(Configuration.SemestreAtual)
.SendAll();
SincroniaService.ResetarAlunosEAD();
return(new Resultados()
{
AlunosResult = alunoResult,
DisciplinasAlunoResult = disciplinaResult
});
}
public void SaveDisciplinesResult(ParallelSendResult <Disciplina, CourseResponse> result)
{
var logs = new List <LogImportacao>();
while (!result.ImportedSuccessfully.IsEmpty)
{
ImportedResult <Disciplina, CourseResponse> item = null;
bool success = result.ImportedSuccessfully.TryDequeue(out item);
if (!success)
{
continue;
}
var log = LogImportacao.Parse <Disciplina, CourseResponse>(item, TipoImportacao.Disciplina);
log.Mensagem = $"Criação da disciplina [{item.Data.DisciplinaNome}] no curso [{item.Data.CursoDescricao}]";
log.Sincronia = Sincronia;
logs.Add(log);
}
while (!result.NotImported.IsEmpty)
{
NotImportedReason <Disciplina> item = null;
bool success = result.NotImported.TryDequeue(out item);
if (!success)
{
continue;
}
var log = LogImportacao.Parse <Disciplina>(item, TipoImportacao.Disciplina);
log.Sincronia = Sincronia;
logs.Add(log);
}
Repository.Save(logs);
}
public void SaveProfessorDisciplinesLogs(ParallelSendResult <ProfessorDisciplinaViewModel, GetEnrolmentsByUserIdResponse> result)
{
var logs = new List <LogImportacao>();
while (!result.ImportedSuccessfully.IsEmpty)
{
ImportedResult <ProfessorDisciplinaViewModel, GetEnrolmentsByUserIdResponse> item = null;
bool success = result.ImportedSuccessfully.TryDequeue(out item);
if (!success)
{
continue;
}
var log = (item as ProfessorDisciplinaImportedResult <ProfessorDisciplinaViewModel, GetEnrolmentsByUserIdResponse>).Parse();
log.Sincronia = Sincronia;
logs.Add(log);
}
while (!result.NotImported.IsEmpty)
{
NotImportedReason <ProfessorDisciplinaViewModel> item = null;
bool success = result.NotImported.TryDequeue(out item);
if (!success)
{
continue;
}
var log = (item as ProfessorDisciplinaNotImportedReason <ProfessorDisciplinaViewModel>).Parse();
log.Sincronia = Sincronia;
logs.Add(log);
}
Repository.Save(logs);
}
public ParallelSendResult <ProfessorDisciplinaViewModel, GetEnrolmentsByUserIdResponse> ImportarProfessorDisciplinas(IEnumerable <Professor> professores)
{
ProfessorDisciplinaProxy professorProxy = new ProfessorDisciplinaProxy(ConsultaAcademicaService)
{
UseParallelism = UseParallelism,
CanLog = CanLog
};
ParallelSendResult <ProfessorDisciplinaViewModel, GetEnrolmentsByUserIdResponse> result =
professorProxy.AddProfessores(professores)
.AddConfiguration(Configuration)
.AddModalidades(Modalidades)
.AddSemestreAtual(Configuration.SemestreAtual)
.SendAll();
return(result);
}
public ParallelSendResult <AlunoDisciplinaViewModel, GetEnrolmentsByUserIdResponse> ImportarAlunoDisciplinas(IEnumerable <Aluno> alunos)
{
AlunoDisciplinaProxy alunoProxy = new AlunoDisciplinaProxy(ConsultaAcademicaService)
{
UseParallelism = false,
CanLog = CanLog
};
ParallelSendResult <AlunoDisciplinaViewModel, GetEnrolmentsByUserIdResponse> result =
alunoProxy.AddAlunos(alunos)
.AddConfiguration(Configuration)
.AddModalidades(Modalidades)
.AddSemestreAtual(Configuration.SemestreAtual)
.SendAll();
return(result);
}
