public static LogImportacao Parse <TData>(NotImportedReason <TData> item, TipoImportacao tipoImportacao)
{
var log = new LogImportacao()
{
DataImportacao = item.Date,
TipoImportacao = tipoImportacao,
DadosImportados = JsonConvert.SerializeObject(item.Data),
DadosRetornados = "",
Url = item.Url,
Sucesso = false,
Mensagem = item.Reason,
Excecao = item.Exception != null?JsonConvert.SerializeObject(item.Exception) : ""
};
return(log);
}
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 void SaveCoursesLogs(SendResult <Curso, CategoryResponse> result)
{
var logs = new List <LogImportacao>();
while (result.ImportedSuccessfully.Count > 0)
{
ImportedResult <Curso, CategoryResponse> item = result.ImportedSuccessfully.Dequeue();
var log = LogImportacao.Parse <Curso, CategoryResponse>(item, TipoImportacao.Curso);
log.Mensagem = $"Criação do curso [{item.Data.CursoDescricao}]";
log.Sincronia = Sincronia;
logs.Add(log);
}
while (result.NotImported.Count > 0)
{
NotImportedReason <Curso> item = result.NotImported.Dequeue();
var log = LogImportacao.Parse <Curso>(item, TipoImportacao.Curso);
log.Sincronia = Sincronia;
logs.Add(log);
}
Repository.Save(logs);
}
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 override SendResult <Curso, CategoryResponse> SendAll()
{
SendResult <Curso, CategoryResponse> result = new SendResult <Curso, CategoryResponse>();
IEnumerable <Curso> data = GetData("");
if (data == null)
{
return(result);
}
foreach (var modalidade in Modalidades)
{
var cursos = data.Where(x => x.IdModalidade == modalidade.IdModalidade).ToArray();
this.AddMoodleBaseUrl(modalidade.MoodleUrl)
.AddMoodleToken(modalidade.MoodleToken)
.AddMoodleGetInfoServiceToken(modalidade.MoodleGetInfoServiceToken)
.AddMoodleServiceUrl(modalidade.MoodleServiceUrl);
this.AddMoodleCategoryParent(modalidade.MoodleCategoryParent)
.AddMoodleDescriptionFormat(modalidade.MoodleDescriptionFormat);
foreach (var item in cursos)
{
try
{
long?cachedMoodleId = MoodleFromToCache.GetCachedMoodleCategory(modalidade.IdModalidade, item.CursoDescricao);
if (cachedMoodleId.HasValue)
{
LastUrl = "cached_value";
var reason = new NotImportedReason <Curso>()
{
Data = item,
Url = LastUrl,
Reason = $"Curso [{item.CursoDescricao}] já está adicionado ao MOODLE ({LastUrl})."
};
result.NotImported.Enqueue(reason);
Log(reason.Reason);
continue;
}
CategoryResponse exists = VerifyIfExists(item.CursoDescricao);
if (exists?.Id > 0)
{
MoodleFromToCache.AddCategory(modalidade.IdModalidade, item.CursoDescricao, exists.Id);
var reason = new NotImportedReason <Curso>()
{
Data = item,
Url = LastUrl,
Reason = $"Curso [{item.CursoDescricao}] já está adicionado ao MOODLE ({LastUrl})."
};
result.NotImported.Enqueue(reason);
Log(reason.Reason);
continue;
}
CategoryResponse response = SendItem(item);
ImportedResult <Curso, CategoryResponse> importedResult = new ImportedResult <Curso, CategoryResponse>()
{
Date = DateTime.Now,
Data = item,
Url = LastUrl,
Result = response
};
result.ImportedSuccessfully.Enqueue(importedResult);
Log($"Curso [{item.CursoDescricao}] adicionado");
}
catch (Exception ex)
{
var reason = new NotImportedReason <Curso>()
{
Data = item,
Url = LastUrl,
Exception = ex
};
result.NotImported.Enqueue(reason);
Log(reason.Reason);
}
}
}
return(result);
}
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);
}
}
