예제 #1
0
        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;
            }
        }
예제 #2
0
        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));
        }
예제 #3
0
        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);
        }
예제 #4
0
        public Exception Incluir_Anexo(Anexo reg, string usuario)
        {
            Processo_Data obj = new Processo_Data(_connection);
            Exception     ex  = obj.Incluir_Anexo(reg, usuario);

            return(ex);
        }
예제 #5
0
        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());
        }
예제 #6
0
        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);
        }
예제 #7
0
        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));
        }
예제 #8
0
        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();
        }
예제 #10
0
 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() + ")";
                 }
             }
         }
     }
 }
예제 #11
0
 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() + ")";
             }
         }
     }
 }
예제 #12
0
 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; }
 }
예제 #13
0
        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));
        }
예제 #14
0
        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));
        }
예제 #15
0
        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);
            }
        }
예제 #16
0
        public ActionResult Download(int id)
        {
            Anexo anexo = this._app.ObterAnexoPorId(id);
            var   dados = DownloadArquivo(anexo.Conteudo, anexo.NomeDoArquivo);

            return(dados);
        }
예제 #17
0
        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);
        }
예제 #18
0
        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);
        }
예제 #19
0
 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();
 }
예제 #20
0
        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);
            }
        }
예제 #21
0
        public async Task <IHttpActionResult> GetAnexo(int id)
        {
            Anexo anexo = await db.Anexo.FindAsync(id);

            if (anexo == null)
            {
                return(NotFound());
            }

            return(Ok(anexo));
        }
예제 #22
0
        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));
        }
예제 #23
0
        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);
        }
예제 #24
0
        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;
        }
예제 #25
0
        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);
        }
예제 #26
0
        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;
            }
        }
예제 #27
0
        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"));
        }
예제 #28
0
        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"));
        }
예제 #29
0
        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));
        }
예제 #30
0
        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));
        }