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());
        }
예제 #3
0
        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);
                }
            }
        }
예제 #4
0
        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."));
            }
        }
예제 #6
0
        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);
        }
예제 #7
0
        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);
                }
            }
        }