public void Delete(int id)
{
try {
Curriculo curriculo = new Curriculo();
Anexo anexo = new Anexo();
AnexoBO anx = new AnexoBO();
CurriculoBO curriculoBO = new CurriculoBO();
curriculo = curriculoBO.ReadById(id);
SqlConnection conn = new SqlConnection();
SqlCommand comando = new SqlCommand();
comando.CommandType = CommandType.Text;
comando.CommandText = "DELETE FROM curriculo WHERE id=@curriculoId ";
comando.Parameters.AddWithValue("@curriculoId", id);
ConexaoBanco.CRUD(comando);
conn = ConexaoBanco.Conectar();
comando = new SqlCommand();
comando.CommandType = CommandType.Text;
if (curriculo.anexo.id != 0)
{
int anexoId = curriculo.anexo.id;
comando.CommandText = "DELETE from anexo where id=@id ";
comando.Parameters.AddWithValue("@id", anexoId);
ConexaoBanco.CRUD(comando);
}
}
catch {
throw;
}
}
public async Task <Response> Handle(AdicionarAnexo request, CancellationToken cancellationToken)
{
if (request == null)
{
return(new Response(false, "Informe os dados do anexo", request));
}
Ticket ticket = await _repositorioTicket.CarregarObjetoPeloID(request.TicketId);
if (ticket == null)
{
return(new Response(false, "Ticket não encontrado", null));
}
Anexo anexo = new Anexo(request.Descricao, request.URL, ticket);
//ticket.AdicionarAnexo(anexo);
if (anexo.Invalid)
{
return(new Response(false, "Anexo inválido", ticket.Notifications));
}
//_repositorioTicket.Editar(ticket);
_repositorioAnexo.Adicionar(anexo);
var result = new Response(true, "Anexo adicionado com sucesso!", null);
return(await Task.FromResult(result));
}
public async Task SubstituirAnexo(Anexo anexo, IFormFile arquivoNovo)
{
anexo.Atualizar(nome: arquivoNovo.FileName, mime: arquivoNovo.ContentType);
await this.Excluir(anexo.Localizador);
await this.Upload(anexo.Localizador, arquivoNovo);
}
public Exception Incluir_Anexo(Anexo reg, string usuario)
{
Processo_Data obj = new Processo_Data(_connection);
Exception ex = obj.Incluir_Anexo(reg, usuario);
return(ex);
}
public ActionResult Upload(HttpPostedFileBase arq)
{
if (arq != null && arq.ContentLength > 0)
{
var extensoePermitidas = new String[] { ".pdf", ".docx", ".doc" };
var checarExtensao = Path.GetExtension(arq.FileName).ToLower();
if (extensoePermitidas.Contains(checarExtensao))
{
string caminho = Path.Combine(Server.MapPath("~/pdf"), Path.GetFileName(arq.FileName));
arq.SaveAs(caminho);
byte[] toBytes = System.IO.File.ReadAllBytes(caminho);
Anexo a = new Anexo();
a.arquivo = toBytes;
a.nome = arq.FileName;
AnexoBO b = new AnexoBO();
b.Gravar(a);
}
else
{
ViewBag.aviso = "arquivo com extensão inválida!";
}
}
return(View());
}
public Anexo ReadById(int id)
{
SqlCommand comando = new SqlCommand();
comando.CommandType = CommandType.Text;
comando.CommandText = "SELECT * FROM anexo WHERE id=@anexoId ";
comando.Parameters.AddWithValue("@anexoId", id);
SqlDataReader dr = ConexaoBanco.Selecionar(comando);
Anexo anexo = new Anexo();
if (dr.HasRows) //verifica se o dr tem alguma coisa
{
dr.Read();
anexo.nome = (string)dr["nome"];
anexo.arquivo = (Byte[])dr["arquivo"];
anexo.tipoArquivo = (string)dr["tipoArquivo"];
anexo.id = (int)dr["id"];
}
else
{
anexo = null;
}
return(anexo);
}
public async Task <IHttpActionResult> PutAnexo(int id, Anexo anexo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != anexo.idAnexo)
{
return(BadRequest());
}
db.Entry(anexo).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AnexoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public Anexo Download(int id) // responsável por fazer o donwload do anexo
{
byte[] bytes;
string fileName, contentType;
SqlConnection conn = new SqlConnection();
SqlCommand comando = new SqlCommand();
comando.CommandText = "select nome, arquivo, tipoConteudo from anexo where id=@anexoId";
comando.Parameters.AddWithValue("@anexoId", id);
comando.Connection = conn;
conn.Open();
Anexo anexo = new Anexo();
SqlDataReader sdr = comando.ExecuteReader();
if (sdr.HasRows)
{
sdr.Read();
bytes = (byte[])sdr["arquivo"];
contentType = sdr["tipoConteudo"].ToString();
fileName = sdr["nome"].ToString();
}
else
{
anexo = null;
}
conn.Close();
return(anexo);
}
public PainelDetalhesConhecimento(UserControlCentro ucc, bool back)
{
InitializeComponent();
PainelCentro = ucc;
conhe = new Conhecimento();
anexo = new Anexo();
buttonsDetails = new Controls.ButtonsDetails();
gridFundo.Children.Add(buttonsDetails);
buttonsDetails.SaveClick += new EventHandler(Add_Conhecimento);
buttonsDetails.HomeClick += new EventHandler(Home);
buttonsDetails.DeleteClick += new EventHandler(DeleteConhecimento);
treeView = new Controls.TreeView(this);
gridPesquisa.Children.Add(treeView);
propertyGridInfo = new Controls.PropertyGrid(this);
gridPropertyInfo.Children.Add(propertyGridInfo);
propertyGridComboBox.SelectedIndex = 2;
textEditor.TextArea.TextEntering += textEditor_TextArea_TextEntering;
textEditor.TextArea.TextEntered += textEditor_TextArea_TextEntered;
DispatcherTimer foldingUpdateTimer = new DispatcherTimer();
foldingUpdateTimer.Interval = TimeSpan.FromSeconds(2);
foldingUpdateTimer.Tick += foldingUpdateTimer_Tick;
foldingUpdateTimer.Start();
}
private void TFEvoluirTicket_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode.Equals(Keys.F4))
{
afterGrava();
}
else if (e.Control && e.KeyCode.Equals(Keys.V))
{
if (Clipboard.ContainsImage())
{
using (TFAnexosHelpDesk fAnexo = new TFAnexosHelpDesk())
{
fAnexo.st_print = true;
fAnexo.Img_anexo = Clipboard.GetImage();
if (fAnexo.ShowDialog() == DialogResult.OK)
{
Anexo anexo = new Anexo();
anexo.Ds_anexo = fAnexo.pDs_anexo;
System.IO.MemoryStream ms = new System.IO.MemoryStream();
fAnexo.Img_anexo.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
anexo.Imagem = ms.ToArray();
anexo.Tp_ext = string.Empty;
lAnexo.Add(anexo);
llkAnexo.Text = "Anexar Imagem (" + lAnexo.Count.ToString() + ")";
}
}
}
}
}
private void llkAnexo_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
using (OpenFileDialog file = new OpenFileDialog())
{
if (file.ShowDialog() == DialogResult.OK)
{
if (System.IO.File.Exists(file.FileName))
{
Anexo anexo = new Anexo();
anexo.Imagem = System.IO.File.ReadAllBytes(file.FileName);
anexo.Tp_ext = System.IO.Path.GetExtension(file.FileName);
Utils.InputBox ibp = new Utils.InputBox();
ibp.Text = "Descrição Anexo";
string ds = ibp.ShowDialog();
if (string.IsNullOrEmpty(ds))
{
MessageBox.Show("Obrigatório informar Descrição da Anexo!", "Mensagem", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
anexo.Ds_anexo = ds;
lAnexo.Add(anexo);
llkAnexo.Text = "Anexar Imagem (" + lAnexo.Count.ToString() + ")";
}
}
}
}
public async Task InsertAttachDB(string Path, string description)
{
try
{
var _anexo = new Anexo();
string _Image;
Guid id = Guid.NewGuid();
_anexo.AnexoId = Items.Count + 1;
_anexo.UPMId = 1;
_anexo.ID = id.ToString();
_anexo.Tipo = Path;
_anexo.VisitaId = 1;
_anexo.Path = Path;
_anexo.URL = Path;
_anexo.Descripcion = description;
_anexo.LugarTrabajoId = 1;
_anexo.CodNivel = "1";
_anexo.EstadoId = 1;
_anexo.FechaCreacion = DateTime.Now;
_anexo.UsuarioCreacion = "test";
_anexo.UsuarioModificacion = "test";
_anexo.FechaModificacion = DateTime.Now;;
Items.Add(_anexo);
}
catch (Exception ex)
{
RemotePathLabel.Text = ex.Message;
}
finally { IsBusy = false; }
}
public async Task <IActionResult> Edit(int id, [Bind("Legenda,Descricao,Caminho,Adequada,Id,DataInc,DataMod")] Anexo anexo)
{
if (id != anexo.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(anexo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AnexoExists(anexo.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(anexo));
}
public async Task <Response> Handle(ExcluirAnexo request, CancellationToken cancellationToken)
{
if (request == null)
{
return(new Response(false, "Informe o anexo que deseja excluír", request));
}
//Ticket ticket = await _repositorioTicket.CarregarObjetoPeloID(request.TicketId);
//Anexo anexo = ticket.Anexos.FirstOrDefault(a => a.Id == request.IdAnexo);
Anexo anexo = await _repositorioAnexo.CarregarObjetoPeloID(request.IdAnexo);
AddNotifications(new Contract()
.Requires()
//.IsNotNull(ticket,"Ticket","Ticket não encontrado")
.IsNotNull(anexo, "Anexo", "Anexo não encontrado")
);
//ticket.ExcluirAnexo(anexo);
//if (ticket.Invalid)
// return new Response(false, "Ticket inválido", ticket.Notifications);
//_repositorioTicket.Editar(ticket);
_repositorioAnexo.Remover(anexo);
var result = new Response(true, "Anexo excluído com sucesso!", null);
return(await Task.FromResult(result));
}
internal Boolean Excluir(int CodigoAtivo)
{
Anexo a = Buscar(CodigoAtivo, true);
if (a != null)
{
try
{
File.Delete(a.Local);
b.getComandoSQL().Parameters.Clear();
b.getComandoSQL().CommandText = @"delete from anexos_ativos where ati_codigo = @codigo;";
b.getComandoSQL().Parameters.AddWithValue("@codigo", CodigoAtivo);
return(b.ExecutaComando(true) == 1);
}
catch (Exception e)
{
return(false);
}
}
else
{
return(true);
}
}
public ActionResult Download(int id)
{
Anexo anexo = this._app.ObterAnexoPorId(id);
var dados = DownloadArquivo(anexo.Conteudo, anexo.NomeDoArquivo);
return(dados);
}
public async Task <ActionResult <dynamic> > PostAnexo()
{
Logger.Info("linha 117");
var ret = new Anexo();
try
{
var files = Request.Form.Files;
var fileName = "";
if (!Directory.Exists(_path))
{
Logger.Info("diretorio não existe: " + _path);
Directory.CreateDirectory(_path);
}
var extPermitidas = new string[] { "doc", "pdf", "txt", "docx", "csv", "xls" };
foreach (var file in files)
{
var extencao = file.FileName.Split(".")[1];
//if (!extPermitidas.Contains(extencao))
// return BadRequest("Arquivos com extensão" + extencao + " não sao permitidos");
fileName = Guid.NewGuid().ToString("N");
var filePath = Path.Combine(_path, fileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
ret.NomeOriginal = file.FileName;
ret.NomeCriado = fileName;
Logger.Info("diretorio não existe: " + ret.NomeCriado);
var dados = Request.Form["idCancelamento"];
if (!string.IsNullOrEmpty(dados))
{
var cancel = _ctx.Cancelamentos.Find(int.Parse(dados));
ret.Cancelamento = cancel;
_ctx.Anexos.Add(ret);
ret.Id = _ctx.SaveChangesAsync().Id;
}
}
return(Ok(ret));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
//return CreatedAtAction("GetAnexo", new { id = anexo.Id }, anexo);
}
public void Gravar(Curriculo curriculo, Anexo anexo, DateTime dataEnvio)
{
CurriculoDAO curriculoDAO = new CurriculoDAO();
AnexoDAO anexoDAO = new AnexoDAO();
//insere curriculo com anexo
curriculoDAO.InsertCvAnexo(curriculo, anexo, dataEnvio);
}
public void MostarArquivo(Anexo anexo)
{
Response.Clear(); // limpar reponses anteriores
Response.ContentType = anexo.FileType; // extenção do arquivo
Response.AppendHeader("Content-Disposition", "inline; filename =" + anexo.FileName + ""); // nome que vai aparecer para donwload
Response.BufferOutput = true;
Response.AddHeader("Content-Length", anexo.FileByte.Length.ToString());
Response.BinaryWrite(anexo.FileByte); // convertando aquivo
Response.End();
}
public void Execute(IServiceProvider serviceProvider)
{
var context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
ITracingService trace = (ITracingService)serviceProvider.GetService(typeof(ITracingService));
IOrganizationServiceFactory serviceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
IOrganizationService service = serviceFactory.CreateOrganizationService(null);
try
{
switch (Util.Utilitario.ConverterEnum <Domain.Enum.Plugin.MessageName>(context.MessageName))
{
#region Create
case Domain.Enum.Plugin.MessageName.Create:
if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
{
var entidade = (Entity)context.InputParameters["Target"];
Anexo anexo = entidade.Parse <Anexo>(context.OrganizationName, context.IsExecutingOffline);
var ocorrenciaService = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline, service);
OcorrenciaBase ocorrenciaBase = ocorrenciaService.BuscaOcorrenca(anexo.EntidadeRelacionada.Id);
if (ocorrenciaService.IsContractBradesco(ocorrenciaBase) && ocorrenciaBase.ReplicadoBradesco == false && ocorrenciaBase.Id == anexo.EntidadeRelacionada.Id)
{
/*Está condição serve para realizar uma nova tentatica de criação do incidente no HPSM caso
* tenha algum problema de integração durante a execução do create Incidente*/
if (ocorrenciaBase.OsCliente == null)
{
trace.Trace("Inicio integração HPSM - Operação: REGISTRAR INCIDENTE - posCreate");
ocorrenciaBase.TipoOperacao = "REGISTRAR INCIDENTE";
ocorrenciaService.IntegracaoBradesco(ocorrenciaBase);
trace.Trace("Fim integração HPSM - Operação: REGISTRAR INCIDENTE - posCreate");
}
if (anexo.NomeArquivos == null && anexo.Texto != "")
{
trace.Trace("Inicio integração HPSM - Operação: REGISTRAR INFORMACAO COMPLEMENTAR - posCreate");
ocorrenciaBase.TipoOperacao = "REGISTRAR INFORMACAO COMPLEMENTAR";
ocorrenciaService.IntegracaoBradesco(ocorrenciaBase, anexo);
trace.Trace("Fim integração HPSM - Operação: REGISTRAR INFORMACAO COMPLEMENTAR - posCreate");
}
}
}
break;
#endregion
}
}
catch (Exception ex)
{
trace.Trace(String.Format("EXCEPTION PLUGIN {0} {1} [{2}]", context.MessageName.ToLower(), "annotation", DateTime.Now));
trace.Trace(SDKore.Helper.Error.GetMessageError(ex));
throw new InvalidPluginExecutionException(ex.Message);
}
}
public async Task <IHttpActionResult> GetAnexo(int id)
{
Anexo anexo = await db.Anexo.FindAsync(id);
if (anexo == null)
{
return(NotFound());
}
return(Ok(anexo));
}
public async Task <IActionResult> Create([Bind("Legenda,Descricao,Caminho,Adequada,Id,DataInc,DataMod")] Anexo anexo)
{
if (ModelState.IsValid)
{
_context.Add(anexo);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(anexo));
}
public IEnumerable <Anexo> criaAnexos()
{
List <Anexo> listaAnexo = new List <Anexo>();
Anexo anexo1 = new Anexo(@"c:\windows\temp\a.txt");
Anexo anexo2 = new Anexo(@"c:\windows\temp\teste.xls");
listaAnexo.Add(anexo1);
listaAnexo.Add(anexo2);
return(listaAnexo);
}
public AnexoSaida(Anexo anexo)
{
if (anexo == null)
{
return;
}
this.Id = anexo.Id;
this.IdLancamento = anexo.IdLancamento;
this.IdGoogleDrive = anexo.IdGoogleDrive;
this.Descricao = anexo.Descricao;
this.NomeArquivo = anexo.NomeArquivo;
}
public async Task Deletar(Anexo anexo)
{
if (_googleDriveUtil.Invalido)
{
this.AdicionarNotificacoes(_googleDriveUtil.Notificacoes);
return;
}
// Exclui o arquivo do anexo do Google Drive
await _googleDriveUtil.ExcluirPorId(anexo.IdGoogleDrive);
_efContext.Anexos.Remove(anexo);
}
public void InsertCvAnexo(Curriculo curriculo, Anexo anexo, DateTime dataEnvio) // insere um anexo que esta vinculado com um curriculo
{
try
{
int idAnexo = 0;
AnexoBO b = new AnexoBO();
idAnexo = b.Gravar(anexo);
SqlConnection conn = new SqlConnection();
SqlCommand comando = new SqlCommand();
comando.CommandType = CommandType.Text;
//comando.CommandText = "select anexo.id from anexo; Select scope_identity()";
conn = ConexaoBanco.Conectar();
comando.Connection = conn;
//int id = (Int32)comando.ExecuteScalar();
comando.CommandText = "INSERT INTO curriculo (nome,cpf,dataNascimento,uf,cep,cidade,bairro,rua,numero," +
"descricao,telefoneFixo,telefoneCelular,email,siteBlog,skype,remuneracao,genero,estadoCivil_fk, " +
"areaPretendida_fk,anexo_fk, dataEnvio) VALUES (@nome,@cpf,@dataNascimento,@uf,@cep,@cidade,@bairro,@rua,@numero,@descricao,@telefoneFixo," +
"@telefoneCelular,@email,@siteBlog,@skype,@remuneracao,@genero,@estadoCivil_fk,@areaPretendida_fk,@anexo_fk,@dataEnvio)";
comando.Parameters.AddWithValue("@nome", curriculo.nome);
comando.Parameters.AddWithValue("@cpf", curriculo.cpf);
comando.Parameters.AddWithValue("@dataNascimento", curriculo.dataNascimento);
comando.Parameters.AddWithValue("@uf", curriculo.uf);
comando.Parameters.AddWithValue("@cep", curriculo.cep);
comando.Parameters.AddWithValue("@cidade", curriculo.cidade);
comando.Parameters.AddWithValue("@bairro", curriculo.bairro);
comando.Parameters.AddWithValue("@rua", curriculo.rua);
comando.Parameters.AddWithValue("@numero", curriculo.numero);
comando.Parameters.AddWithValue("@descricao", curriculo.descricao);
comando.Parameters.AddWithValue("@telefoneFixo", curriculo.telefoneFixo);
comando.Parameters.AddWithValue("@telefoneCelular", curriculo.telefoneCelular);
comando.Parameters.AddWithValue("@email", curriculo.email);
comando.Parameters.AddWithValue("@siteBlog", curriculo.siteBlog);
comando.Parameters.AddWithValue("@skype", curriculo.skype);
comando.Parameters.AddWithValue("@remuneracao", curriculo.remuneracao); //não pegou a remner~ção verrificar a view
comando.Parameters.AddWithValue("@genero", curriculo.genero);
comando.Parameters.AddWithValue("@estadoCivil_fk", curriculo.estado.id);
comando.Parameters.AddWithValue("@areaPretendida_fk", curriculo.area.id);
comando.Parameters.AddWithValue("@anexo_fk", idAnexo);
comando.Parameters.AddWithValue("@dataEnvio", dataEnvio);
ConexaoBanco.CRUD(comando);
}
catch
{
throw;
}
}
public ActionResult Arquivo(int id)
{
AnexoBO anexoBO = new AnexoBO();
Anexo a = new Anexo();
a = anexoBO.ReadById(id);
if (a != null)
{
return(File(a.arquivo, a.tipoArquivo, a.nome));
}
return(RedirectToAction("ListarCurriculos"));
}
public ActionResult EnviarDadosFinalizacao(OrdemServicoViewModel ordemServicoViewModel)
{
var ordemservicoViewModelOrigem = Session["ordemservicoViewModel"] as OrdemServicoViewModel;
ordemservicoViewModelOrigem.Observacoes = ordemServicoViewModel.Observacoes;
//Implementar seu metodo de geração de identificador de anexo a OS.
ordemServicoViewModel.IdAnexo = 1;
int a = 1;
//--------------------------------------------------------------------
ordemservicoViewModelOrigem.IdAnexo = ordemServicoViewModel.IdAnexo;
var conta = Request.Files.Count;
List <Anexo> anexos = new List <Anexo>();
for (int i = 0; i < Request.Files.Count; i++)
{
var arquivo = Request.Files[i];
if (arquivo.ContentLength != 0)
{
var anexo = new Anexo();
anexo.Id = a++; // Exemplo modificar para um identificador unico do objeto
anexo.IdAnexo = ordemservicoViewModelOrigem.IdAnexo;
//Use este metodo de conversao para binario caso o arquivo seja tipo imagem (jpeg, png, entre outros)
// anexo.Arquivo = Imagem.ConverterHttpImagem(arquivo);
//Exemplo de recebimento de dados de arquivo anexo (Mockup)
anexo.Arquivo = arquivo.FileName;
anexos.Add(anexo);
}
}
ordemservicoViewModelOrigem.Anexos = anexos;
Session["ordemservicoViewModel"] = ordemservicoViewModelOrigem;
return(RedirectToAction("ClienteResponsavel", "OrdemServico"));
}
public async Task <IHttpActionResult> DeleteAnexo(int id)
{
Anexo anexo = await db.Anexo.FindAsync(id);
if (anexo == null)
{
return(NotFound());
}
db.Anexo.Remove(anexo);
await db.SaveChangesAsync();
return(Ok(anexo));
}
public ActionResult Create(SolucaoDesafio SolucaoDesafio, HttpPostedFileBase file)
{
string extensao = Path.GetExtension(file.FileName);
if (file == null)
{
ModelState.AddModelError("ErroFicheiro2", "Tem que Submeter pelo menos um ficheiro");
}
if (file != null)
{
int indexOf = file.ContentType.IndexOf("zip");
if (extensao != ".zip")
{
ModelState.AddModelError("Zip2", "Compacte os ficheiros e envie em formato .Zip");
}
}
if (ModelState.IsValid)
{
var Solucao = new Solucao();
Solucao.DesafioId = SolucaoDesafio.IdDesafio;
Solucao.Descricao = SolucaoDesafio.DescricaoSolucao;
Solucao.SolucaoTitulo = SolucaoDesafio.NomeSolucao;
Solucao.ApplicationUserId = User.Identity.GetUserId();
Solucao.DataCriacao = DateTime.Now;
db.Solucoes.Add(Solucao);
db.SaveChanges();
#pragma warning disable CS0162 // Unreachable code detected
if (file.ContentLength > 0)
{
Anexo anexo = new Anexo();
string filePath = Path.Combine(HttpContext.Server.MapPath("~/Anexos/"),
Path.GetFileName(file.FileName));
file.SaveAs(filePath);
anexo.Caminho = filePath;
anexo.SolucaoId = Solucao.SolucaoId;
anexo.NomeFicheiro = file.FileName;
db.Anexos.Add(anexo);
db.SaveChanges();
return(RedirectToAction("Details", "Desafios", new { id = SolucaoDesafio.IdDesafio }));
}
}
return(View(SolucaoDesafio));
}