public async Task <DtoResult> UpdateFeatureStateAsync(ShellFeatureState featureState, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
if (featureState == null)
{
throw new ArgumentNullException(nameof(featureState));
}
var model = await ShellFeatureStates.SingleOrDefaultAsync(c => c.Id == featureState.Id);
model.EnableState = featureState.EnableState;
model.InstallState = featureState.InstallState;
Context.Update(model);
try
{
await SaveChanges(cancellationToken);
}
catch (DbUpdateConcurrencyException)
{
return(DtoResult.Failed(new DtoError
{
Code = "ConcurrencyFailure",
Description = "并发故障"
}));
}
return(DtoResult.Success);
}
public async Task <DtoResult <DtoCurso> > Cadastrar(DtoCurso dtoCurso)
{
DtoResult <DtoCurso> dtoResult = new DtoResult <DtoCurso>();
if (dtoCurso.DataInicio < DateTime.Now)
{
dtoResult.Message = "Data início menor que a data atual.";
return(dtoResult);
}
try
{
bool verificaPeriodo = VerificaCursoPorPeriodo(dtoCurso.DataInicio, dtoCurso.DataTermino);
if (verificaPeriodo)
{
Categoria categoria = await GetCategoria(dtoCurso);
if (categoria == null)
{
dtoResult.Message = "Categora não existe.";
return(dtoResult);
}
Curso curso = new Curso(dtoCurso.Descricao, dtoCurso.DataInicio, dtoCurso.DataTermino, dtoCurso.QuantidadeAlunosPorTurma, categoria.Codigo);
_cursoRepository.Add(curso);
dtoResult.Result = new DtoCurso
{
CodCategoria = categoria.Codigo,
Id = curso.Id,
DataInicio = curso.DataInicio,
DataTermino = curso.DataTermino,
Descricao = curso.Descricao,
QuantidadeAlunosPorTurma = curso.QuantidadeAlunosPorTurma
};
dtoResult.Message = "Curso cadastrado com sucesso.";
return(dtoResult);
}
else
{
dtoResult.Message = "Existe(m) curso(s) planejados(s) dentro do período informado.";
}
return(dtoResult);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <DtoResult <DtoCurso> > DeleteCurso(long idCurso)
{
DtoResult <DtoCurso> dtoResultCurso = new DtoResult <DtoCurso>();
var curso = await _cursoRepository.GetEntityById(idCurso);
if (curso != null)
{
await _cursoRepository.Delete(curso);
dtoResultCurso.Message = "Curso deletado com sucesso.";
}
else
{
dtoResultCurso.Message = "Curso não existe.";
}
return(dtoResultCurso);
}
private async Task <DtoResult> ValidateTencentVodInternal(TVod article)
{
var errors = new List <DtoError>();
foreach (var v in TencentVodValidators)
{
var result = await v.ValidateAsync(this, article);
if (!result.Succeeded)
{
errors.AddRange(result.Errors);
}
}
if (errors.Count > 0)
{
//Logger.LogWarning(0, "Role {roleId} validation failed: {errors}.", await GetRoleIdAsync(role), string.Join(";", errors.Select(e => e.Code)));
return(DtoResult.Failed(errors.ToArray()));
}
return(DtoResult.Success);
}
public virtual async Task <DtoResult> DeleteAsync(TencentVod vod, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
if (vod == null)
{
throw new ArgumentNullException(nameof(vod));
}
Context.Remove(vod);
try
{
await SaveChanges(cancellationToken);
}
catch (DbUpdateConcurrencyException)
{
return(DtoResult.Failed(ErrorDescriber.ConcurrencyFailure()));
}
return(DtoResult.Success);
}
public virtual async Task <DtoResult> ValidateAsync(TencentVodManager <TTencentVod> manager, TTencentVod article)
{
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
if (article == null)
{
throw new ArgumentNullException(nameof(article));
}
var errors = new List <DtoError>();
await ValidateTitle(manager, article, errors);
//if (manager.Options.User.RequireUniqueEmail)
//{
// await ValidateEmail(manager, user, errors);
//}
return(errors.Count > 0 ? DtoResult.Failed(errors.ToArray()) : DtoResult.Success);
}
public async Task <DtoResult <DtoCurso> > UpdateCurso(DtoCurso dtoCurso)
{
DtoResult <DtoCurso> dtoResultCurso = new DtoResult <DtoCurso>();
try
{
var curso = _cursoRepository.GetEntityById(dtoCurso.Id).Result;
if (curso != null)
{
bool verificaPeriodo = VerificaCursoPorPeriodo(dtoCurso.DataInicio, dtoCurso.DataTermino, curso.Id, true);
if (verificaPeriodo)
{
var categoria = _categoriaRespostory.GetEntityById(dtoCurso.CodCategoria).Result;
if (categoria == null)
{
dtoResultCurso.Message = "Categoria não existe.";
return(dtoResultCurso);
}
curso.IdCategoria = categoria.Codigo;
curso.DataInicio = dtoCurso.DataInicio;
curso.DataTermino = dtoCurso.DataTermino;
curso.Descricao = dtoCurso.Descricao;
curso.QuantidadeAlunosPorTurma = dtoCurso.QuantidadeAlunosPorTurma;
var update = _cursoRepository.Update(curso).Result;
dtoResultCurso.Message = "Curso alterado com sucesso.";
return(dtoResultCurso);
}
}
}
catch (Exception ex)
{
dtoResultCurso.Message = "Houve um erro ao editar o curso.";
return(dtoResultCurso);
}
return(dtoResultCurso);
}
public virtual async Task <DtoResult> UpdateAsync(TencentVod article, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
if (article == null)
{
throw new ArgumentNullException(nameof(article));
}
Context.Attach(article);
//article.ConcurrencyStamp = Guid.NewGuid().ToString();
Context.Update(article);
try
{
await SaveChanges(cancellationToken);
}
catch (DbUpdateConcurrencyException)
{
return(DtoResult.Failed(ErrorDescriber.ConcurrencyFailure()));
}
return(DtoResult.Success);
}
