public async Task <ActionResult> Patch([FromBody] AtualizaNovaRevisaoViewModel atualizaRevisao)
{
var revisor = ObterUsuario();
if (revisor.TipoUsuario == TipoUsuario.Assinante)
{
return(BadRequest(new { message = "Usuário inválido." }));
}
var revisao = new Revisao {
Id = atualizaRevisao.RevisaoId,
AssinanteId = atualizaRevisao.AssinanteId,
StatusRevisao = StatusRevisao.EmRevisao,
RevisorId = revisor.Id
};
var response = await _revisaoRepository.AtualizarRevisorAsync(revisao);
if (response.HasError)
{
_logger.LogError("Lista", response.ErrorMessages);
return(BadRequest(response.ErrorMessages));
}
return(Ok());
}
public async Task <IActionResult> Delete(string nomeArquivo, [FromBody] DeletaRevisaoViewModel revisaoVm)
{
try
{
var usuario = ObterUsuario();
var revisao = new Revisao
{
Id = revisaoVm.Id,
AssinanteId = usuario.Id,
StatusRevisao = revisaoVm.StatusRevisao,
ArquivoRef = revisaoVm.ArquivoRef,
Arquivo = new Arquivo
{
TipoArquivo = revisaoVm.Arquivo.TipoArquivo,
Nome = revisaoVm.Arquivo.Nome,
Url = revisaoVm.Arquivo.Url
}
};
Usuario usrArquivo;
if (revisao.Arquivo.TipoArquivo == TipoArquivo.Correcao)
{
usrArquivo = new Usuario {
Id = revisao.RevisorId
};
}
else
{
usrArquivo = new Usuario {
Id = revisao.AssinanteId
};
}
await _uploadFile.DeleteFileAsync(usrArquivo, nomeArquivo);
if (!String.IsNullOrEmpty(revisao.ArquivoRef))
{
await _uploadFile.DeleteFileAsync(new Usuario { Id = revisao.RevisorId }, revisao.ArquivoRef);
}
var resp = await _revisaoRepository.DeletarAsync(revisao);
if (resp.HasError)
{
return(BadRequest(resp.ErrorMessages));
}
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest(e.Message));
}
return(Ok());
}
public async Task <Response <Revisao> > AtualizarRevisorAsync(Revisao revisao)
{
var resp = new Response <Revisao>();
using (var client = this._context.GetClientInstance())
{
try
{
var request = new UpdateItemRequest
{
TableName = _context.TableName,
Key = new Dictionary <string, AttributeValue>
{
{ "tipo", new AttributeValue {
S = $"revisao"
} },
{ "id", new AttributeValue {
N = revisao.Id.ToString()
} }
},
ExpressionAttributeNames = new Dictionary <string, string>
{
{ "#usrId", "assinante-id" },
{ "#status", "status" },
{ "#revId", "revisor-id" }
},
ExpressionAttributeValues = new Dictionary <string, AttributeValue>
{
{ ":usrId", new AttributeValue {
N = revisao.AssinanteId.ToString()
} },
{ ":status", new AttributeValue {
S = revisao.StatusRevisao.ToString()
} },
{ ":revId", new AttributeValue {
N = revisao.RevisorId.ToString()
} }
},
UpdateExpression = "SET #usrId = :usrId, #status = :status, #revId = :revId"
};
var updResp = await client.UpdateItemAsync(request);
resp.Return = revisao;
return(resp);
}
catch (Exception e)
{
resp.Return = revisao;
resp.ErrorMessages.Add(e.Message);
_logger.LogError(e.Message);
return(resp);
}
}
}
public async Task <Response <Revisao> > DeletarAsync(Revisao revisao)
{
var resp = new Response <Revisao>();
using (var client = this._context.GetClientInstance())
{
DeleteItemRequest request = new DeleteItemRequest
{
TableName = _context.TableName,
Key = new Dictionary <string, AttributeValue>
{
{ "id", new AttributeValue {
N = revisao.Id.ToString()
} },
{ "tipo", new AttributeValue {
S = "revisao"
} }
},
ConditionExpression = "#status = :status OR #tpArq = :tpArq",
ExpressionAttributeNames = new Dictionary <string, string>
{
{ "#status", "status" },
{ "#tpArq", "tp-arquivo" },
},
ExpressionAttributeValues = new Dictionary <string, AttributeValue>
{
{ ":status", new AttributeValue {
S = revisao.StatusRevisao.ToString()
} },
{ ":tpArq", new AttributeValue {
S = TipoArquivo.Correcao.ToString()
} }
}
};
try
{
DeleteItemResponse response = await client.DeleteItemAsync(request);
if (response.HttpStatusCode != HttpStatusCode.OK)
{
resp.ErrorMessages.Add("Falha ao deletar revisão.");
_logger.LogError("Falha ao deletar revisão.");
}
}
catch (Exception e)
{
resp.ErrorMessages.Add(e.Message);
_logger.LogError(e.Message);
}
return(resp);
}
}
private async Task <IActionResult> UploadFile(IFormCollection form)
{
long size = form.Files.Sum(f => f.Length);
string comentario = form["comentario"];
string tipoArquivo = form["tipoArquivo"];
string arquivoRef = form["arquivoRef"];
int revisaoIdRef = 0;
int.TryParse(form["revisaoIdRef"], out revisaoIdRef);
int revisaoId = 0;
int.TryParse(form["revisaoId"], out revisaoId);
int assinanteId = 0;
int.TryParse(form["assinanteId"], out assinanteId);
if (size > 0)
{
var formFile = form.Files[0];
var urlLocation = "";
if (formFile.Length > 0 && !String.IsNullOrEmpty(formFile.FileName))
{
try
{
using (var mmStream = new MemoryStream())
{
var ext = Path.GetExtension(formFile.FileName);
if (ext.IndexOf(".docx") > -1 ||
ext.IndexOf(".doc") > -1 ||
ext.IndexOf(".odt") > -1 ||
ext.IndexOf(".txt") > -1)
{
await formFile.CopyToAsync(mmStream);
mmStream.Seek(0, SeekOrigin.Begin);
var usuario = ObterUsuario();
urlLocation = await _uploadFile.UploadFileAsync(usuario, mmStream, formFile.FileName);
if (!String.IsNullOrEmpty(urlLocation))
{
var revisao = new Revisao
{
Id = revisaoId,
AssinanteId = assinanteId,
AssinanteEmail = usuario.Email,
ArquivoRef = arquivoRef,
Arquivo = new Arquivo
{
Nome = formFile.FileName,
Url = urlLocation,
DataAtualizacao = DateTime.Now
},
Comentario = comentario
};
if (usuario.TipoUsuario == TipoUsuario.Revisor)
{
revisao.RevisorId = usuario.Id;
revisao.RevisaoIdRef = revisaoIdRef;
revisao.Arquivo.TipoArquivo = TipoArquivo.Correcao;
revisao.StatusRevisao = StatusRevisao.Revisado;
}
else
{
revisao.Arquivo.TipoArquivo = TipoArquivo.Revisao;
revisao.StatusRevisao = StatusRevisao.NovaRevisao;
revisao.AssinanteId = usuario.Id;
}
var response = await _revisaoRepository.SalvarAsync(revisao);
if (response.HasError)
{
_logger.LogError("Upload", response.ErrorMessages);
return(BadRequest(response.ErrorMessages));
}
}
else
{
_logger.LogError("Upload", "Falha no Upload.");
return(BadRequest(new { message = "Falha no Upload." }));
}
}
else
{
_logger.LogError("Upload", "Formato do arquivo inválido.");
return(BadRequest(new { message = "Formato do arquivo inválido." }));
}
}
}
catch (Exception e)
{
var msgErro = "Falha ao processar arquivo.";
_logger.LogError(e.Message, msgErro);
return(StatusCode(500, new { message = msgErro }));
}
}
return(Created(urlLocation, new { message = "Created" }));
}
else
{
return(BadRequest("Arquivo inválido."));
}
}
private List <Revisao> ExtractFileFrom(List <Dictionary <string, AttributeValue> > dictionary)
{
List <Revisao> list = new List <Revisao>();
Revisao revisao = null;
foreach (var item in dictionary)
{
revisao = new Revisao();
foreach (KeyValuePair <string, AttributeValue> kvp in item)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;
if (attributeName == "id")
{
revisao.Id = int.Parse(value.N);
}
else if (attributeName == "nome")
{
revisao.Arquivo.Nome = value.S;
}
else if (attributeName == "url")
{
revisao.Arquivo.Url = value.S;
}
else if (attributeName == "comentario")
{
revisao.Comentario = value.S;
}
else if (attributeName == "assinante-id")
{
int id = 0;
int.TryParse(value.N, out id);
revisao.AssinanteId = id;
}
else if (attributeName == "assinante-email")
{
revisao.AssinanteEmail = value.S;
}
else if (attributeName == "revisor-id")
{
int id = 0;
int.TryParse(value.N, out id);
revisao.RevisorId = id;
}
else if (attributeName == "revisor-id-ref")
{
int id = 0;
int.TryParse(value.N, out id);
revisao.RevisaoIdRef = id;
}
else if (attributeName == "status")
{
Object st = null;
Enum.TryParse(typeof(StatusRevisao), value.S, true, out st);
revisao.StatusRevisao = (StatusRevisao)st;
}
else if (attributeName == "tp-arquivo")
{
Object st = null;
Enum.TryParse(typeof(TipoArquivo), value.S, true, out st);
revisao.Arquivo.TipoArquivo = (TipoArquivo)st;
}
else if (attributeName == "dt-prevista")
{
DateTime dtPrev;
DateTime.TryParseExact(value.S,
"dd/MM/yyyy hh:mm:ss",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out dtPrev);
revisao.DataPrevista = dtPrev;
}
else if (attributeName == "dt-atualizacao")
{
DateTime dtAtual;
DateTime.TryParseExact(value.S,
"dd/MM/yyyy hh:mm:ss",
CultureInfo.InvariantCulture,
DateTimeStyles.None,
out dtAtual);
revisao.Arquivo.DataAtualizacao = dtAtual;
}
else if (attributeName == "arq-ref")
{
revisao.ArquivoRef = value.S;
}
}
list.Add(revisao);
}
return(list);
}
public async Task <Response <Revisao> > SalvarAsync(Revisao revisao)
{
var resp = new Response <Revisao>();
if (revisao.Arquivo == null)
{
resp.ErrorMessages.Add("Arquivo obrigatório.");
return(resp);
}
using (var client = this._context.GetClientInstance())
{
try
{
StringBuilder updateExpr = new StringBuilder("SET ");
var exprAttrValues = new Dictionary <string, AttributeValue>();
var exprAttrNames = new Dictionary <string, string>();
if (revisao.Id < 1)
{
revisao.Id = (Int32)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
}
revisao.DataPrevista = DateTime.Now.AddDays(4);
exprAttrValues.Add(":dtPrev", new AttributeValue {
S = revisao.DataPrevista.ToString("dd/MM/yyyy hh:mm:ss")
});
updateExpr.Append(" #dtPrev = :dtPrev,");
exprAttrNames.Add("#dtPrev", "dt-prevista");
exprAttrValues.Add(":assinanteId", new AttributeValue {
N = revisao.AssinanteId.ToString()
});
updateExpr.Append(" #assinanteId = :assinanteId,");
exprAttrNames.Add("#assinanteId", "assinante-id");
exprAttrValues.Add(":assinanteEmail", new AttributeValue {
S = revisao.AssinanteEmail
});
updateExpr.Append(" #assinanteEmail = :assinanteEmail,");
exprAttrNames.Add("#assinanteEmail", "assinante-email");
exprAttrValues.Add(":revId", new AttributeValue {
N = revisao.RevisorId.ToString()
});
updateExpr.Append(" #revId = :revId,");
exprAttrNames.Add("#revId", "revisor-id");
exprAttrValues.Add(":status", new AttributeValue {
S = revisao.StatusRevisao.ToString()
});
updateExpr.Append(" #status = :status,");
exprAttrNames.Add("#status", "status");
if (revisao.RevisaoIdRef.HasValue)
{
exprAttrValues.Add(":revIdRef", new AttributeValue {
N = revisao.RevisaoIdRef.Value.ToString()
});
updateExpr.Append(" #revIdRef = :revIdRef,");
exprAttrNames.Add("#revIdRef", "revisao-id-ref");
}
if (!String.IsNullOrEmpty(revisao.ArquivoRef))
{
exprAttrValues.Add(":arqRef", new AttributeValue {
S = revisao.ArquivoRef
});
updateExpr.Append(" #arqRef = :arqRef,");
exprAttrNames.Add("#arqRef", "arq-ref");
}
revisao.Arquivo.DataAtualizacao = DateTime.Now;
exprAttrValues.Add(":dtAt", new AttributeValue {
S = revisao.Arquivo.DataAtualizacao.ToString("dd/MM/yyyy hh:mm:ss")
});
updateExpr.Append(" #dtAt = :dtAt,");
exprAttrNames.Add("#dtAt", "dt-atualizacao");
if (!String.IsNullOrEmpty(revisao.Arquivo.Nome))
{
exprAttrValues.Add(":nome", new AttributeValue {
S = revisao.Arquivo.Nome
});
updateExpr.Append(" #nome = :nome,");
exprAttrNames.Add("#nome", "nome");
}
if (!String.IsNullOrEmpty(revisao.Arquivo.Url))
{
exprAttrValues.Add(":url", new AttributeValue {
S = revisao.Arquivo.Url
});
updateExpr.Append(" #url = :url,");
exprAttrNames.Add("#url", "url");
}
exprAttrValues.Add(":tpArq", new AttributeValue {
S = revisao.Arquivo.TipoArquivo.ToString()
});
updateExpr.Append(" #tpArq = :tpArq,");
exprAttrNames.Add("#tpArq", "tp-arquivo");
if (!String.IsNullOrEmpty(revisao.Comentario))
{
exprAttrValues.Add(":comentario", new AttributeValue {
S = revisao.Comentario
});
updateExpr.Append(" #comentario = :comentario,");
exprAttrNames.Add("#comentario", "comentario");
}
var request = new UpdateItemRequest
{
TableName = _context.TableName,
Key = new Dictionary <string, AttributeValue>
{
{ "tipo", new AttributeValue {
S = $"revisao"
} },
{ "id", new AttributeValue {
N = revisao.Id.ToString()
} }
},
ExpressionAttributeNames = exprAttrNames,
ExpressionAttributeValues = exprAttrValues,
UpdateExpression = updateExpr.ToString().Substring(0, updateExpr.ToString().Length - 1)
};
var updResp = await client.UpdateItemAsync(request);
if (updResp.HttpStatusCode == HttpStatusCode.OK && revisao.RevisaoIdRef.HasValue)
{
var updateRequest = new UpdateItemRequest
{
TableName = _context.TableName,
Key = new Dictionary <string, AttributeValue>
{
{ "tipo", new AttributeValue {
S = "revisao"
} },
{ "id", new AttributeValue {
N = revisao.RevisaoIdRef.ToString()
} }
},
ExpressionAttributeNames = new Dictionary <string, string>
{
{ "#status", "status" },
{ "#dtAt", "dt-atualizacao" }
},
ExpressionAttributeValues = new Dictionary <string, AttributeValue>
{
{ ":status", new AttributeValue {
S = "Revisado"
} },
{ ":dtAt", new AttributeValue {
S = DateTime.Now.ToString("dd/MM/yyyy hh:mm:ss")
} }
},
UpdateExpression = "SET #status = :status, #dtAt = :dtAt"
};
try
{
var updateReferencia = await client.UpdateItemAsync(updateRequest);
}
catch (Exception e)
{
_logger.LogError(e.Message);
resp.ErrorMessages.Add("Falha ao atualizar a referência da revisão.");
resp.ErrorMessages.Add(e.Message);
}
}
resp.Return = revisao;
return(resp);
}
catch (Exception e)
{
resp.Return = revisao;
resp.ErrorMessages.Add("Falha ao salvar a revisão.");
resp.ErrorMessages.Add(e.Message);
_logger.LogError(e.Message);
return(resp);
}
}
}