Beispiel #1
0
        public HttpResponseMessage UploadFile(int fileTypeId)
        {
            List <FileBase> data = null;

            for (int i = 0; i < HttpContext.Current.Request.Files.Count; i++)
            {
                string userId = UserService.GetCurrentUserId();

                HttpPostedFile file = HttpContext.Current.Request.Files[i];
                if (file.ContentLength > 0)
                {
                    if (data == null)
                    {
                        data = new List <FileBase>();
                    }
                    var path   = _fileService.UploadToCloud(file);
                    var fileId = _fileService.Add(path, fileTypeId);

                    data.Add(new FileBase {
                        FileId = fileId, Path = "https://sabio-training.s3-us-west-2.amazonaws.com/C11/" + path, FileTypeId = fileTypeId
                    });
                }
            }

            ItemsResponse <FileBase> response = new ItemsResponse <FileBase>();

            response.Items = data;

            return(Request.CreateResponse(response));
        }
Beispiel #2
0
        public IResult Add(CarImage carImage, IFormFile file)
        {
            IResult result = BusinessRules.Run(
                CheckIfImageLimitExceded(carImage.CarID)
                );

            if (result != null)
            {
                return(result);
            }

            carImage.ImagePath = _fileService.Add(uploadPath, file).Data;
            carImage.Date      = DateTime.Now;
            _carImageDal.Add(carImage);
            return(new SuccessResult(Messages.CarImageAdded));
        }
Beispiel #3
0
        public async Task <IActionResult> Upload(FileUploadVM model)
        {
            if (ModelState.IsValid)
            {
                string filePath = null;
                string fileName = null;
                if (model.CsvFile != null)
                {
                    string uploadsFolder = Path.Combine(_hostingEnvironment.WebRootPath, "data");
                    fileName = model.CsvFile.FileName;
                    filePath = Path.Combine(uploadsFolder, model.CsvFile.FileName);
                    using (Stream fileStream = new FileStream(filePath, FileMode.Create))
                    {
                        await model.CsvFile.CopyToAsync(fileStream);
                    }
                }

                CSVFile csvFile = new CSVFile
                {
                    FilePath = filePath,
                    FileName = fileName
                };
                _fileService.Add(csvFile);
                return(RedirectToAction("details", new { Id = csvFile.Id }));
            }
            return(View());
        }
Beispiel #4
0
        public ActionResult <ItemResponse <int> > Add(List <FileAddRequest> modelList)
        {
            ObjectResult result = null;

            int userId = _authService.GetCurrentUserId();

            try
            {
                List <int>          id       = _service.Add(modelList, userId);
                ItemsResponse <int> response = new ItemsResponse <int>()
                {
                    Items = id
                };

                result = StatusCode(201, response);
            }
            catch (Exception ex)
            {
                Logger.LogError(ex.ToString());
                ErrorResponse response = new ErrorResponse(ex.Message);

                result = StatusCode(500, response);
            }

            return(result);
        }
Beispiel #5
0
        public async Task <IHttpActionResult> Post()
        {
            IHttpActionResult res = BadRequest();

            if (!Request.Content.IsMimeMultipartContent())
            {
                return(res);
            }
            var serviceRes = await _fileService.Add(new FileAddRequest()
            {
                RequestOwner = User,
                File         = Request.Content
            });

            if (serviceRes.Access == ResponseAccess.Granted)
            {
                res = Ok(serviceRes.Model);
            }

            if (serviceRes.Access == ResponseAccess.Deny)
            {
                res = Unauthorized(serviceRes.Message);
            }

            return(res);
        }
        public async Task <FileResponse> Add(FileAddRequest request)
        {
            var res = await _fileService.Add(request);

            if (res.Access == ResponseAccess.Granted)
            {
                _observers.ForEach(x => x.FileAdded(res, request));
                await _unitOfWork.SaveChangesAsync();
            }

            return(res);
        }
Beispiel #7
0
        private static void files()
        {
            file = new FileManager(new EfFileDal());
            file.Add(new File {
                Path = "c:\\abc.txt"
            });
            var lst = file.GetAll();

            foreach (var item in lst)
            {
                Console.WriteLine(item.Path);
            }
        }
Beispiel #8
0
 public ActionResult <ItemResponse <int> > Add(FileAddRequest model)
 {
     try
     {
         int id = _fileService.Add(model, _authService.GetCurrentUserId());
         ItemResponse <int> resp = new ItemResponse <int>();
         resp.Item = id;
         return(Created201(resp));
     }
     catch (Exception ex)
     {
         Logger.LogError(ex.ToString());
         return(StatusCode(500, new ErrorResponse(ex.Message)));
     }
 }
Beispiel #9
0
        public async Task <JsonResult> AddFile(IEnumerable <IFormFile> file, int Id)
        {
            string error = "";

            try
            {
                foreach (var item in file)
                {
                    string filename = item.FileName;
                    int    index    = filename.LastIndexOf("\\");
                    filename = filename.Substring(index + 1, filename.Length - index - 1);

                    var folder   = CreateOrUpdateFolder(Id, fileHelper.FilePath);
                    var filePath = Path.Combine(folder, "FTS", filename);
                    if (UserIdentityInfo.Roles.Contains(Roles.Customer))
                    {
                        filePath = Path.Combine(folder, "MUSTERI", filename);
                    }
                    using (var stream = new FileStream(filePath, FileMode.Create))
                    {
                        await item.CopyToAsync(stream);
                    }
                    Entities.Concrete.File fileBox = new Entities.Concrete.File();
                    fileBox.DataSheetId = Id;
                    fileBox.FileName    = filename;
                    fileBox.FilePath    = filePath;
                    fileBox.ContentType = item.ContentType;
                    fileBox.Uploader    = "MUSTERI";
                    fileBox.CreateDate  = DateTime.Now;
                    fileBox.CreateUser  = Convert.ToInt32(UserIdentityInfo.Id);
                    _fileService.Add(fileBox);

                    if (UserIdentityInfo.Roles.Contains(Roles.FTSUser))
                    {
                        var datasheet = _dataSheetService.GetById(Id);
                        datasheet.FTSUserId = Convert.ToInt32(UserIdentityInfo.Id);
                        _dataSheetService.Update(datasheet);
                    }
                }
            }
            catch (Exception ex)
            {
                error = ex.Message;
            }

            return(Json(error));
        }
Beispiel #10
0
        public async Task <IResultModel> Upload([FromForm] Application.FileService.ViewModels.FileUploadModel model, IFormFile formFile)
        {
            var config = _configProvider.Get <PathConfig>();
            var module = _moduleCollection.FirstOrDefault(m => m.Code.EqualsIgnoreCase(model.ModuleCode));

            if (module == null)
            {
                return(ResultModel.Success("指定模块不存在"));
            }

            //使用模块编码,防止大小写问题
            model.ModuleCode = module.Code;

            var uploadModel = new FileUploadModel
            {
                Request  = Request,
                FormFile = formFile,
                RootPath = config.UploadPath,
                Module   = "Admin",
                Group    = Path.Combine("OSS", model.AccessMode == FileAccessMode.Open ? "Open" : "Private"),
                SubPath  = Path.Combine(model.ModuleCode.ToLower(), model.Group.ToLower())
            };

            var result = await _fileUploadHelper.Upload(uploadModel);

            if (!result.Successful)
            {
                return(result);
            }

            //文件本地物理路径
            model.PhysicalPath = Path.Combine(config.UploadPath, result.Data.FullPath);

            //文件的OSS相对路径
            result.Data.Path = Path.Combine(result.Data.Path.Split(Path.DirectorySeparatorChar).Skip(3).ToArray());

            return(await _service.Add(model, result.Data));
        }
Beispiel #11
0
        public async Task <string> Add(DataImage base64Image)
        {
            if (base64Image.RawData.Length > _configuration.MaxSizeByte)
            {
                throw new ClientException("too-big-image");
            }
            else if (base64Image == null)
            {
                throw new ClientException("inc-photo-type", base64Image.ToString());
            }
            string       Id = null;
            MemoryStream ms = new MemoryStream();

            try
            {
                new ImageProcessor.ImageFactory()
                .Load(base64Image.RawData)
                .Constrain(_configuration.MaxSize)
                .Format(_configuration.Format)
                .Save(ms);
                Id = await _fileService.Add(Convert.ToBase64String(ms.ToArray()));

                await _imageGR.CreateAsync(new Image { FileId = Id, Type = _configuration.Format.MimeType });
            }
            catch (Exception)
            {
                if (Id != null)
                {
                    await _fileService.Remove(Id);
                }
                throw new ClientException("image-load-err");
            }
            finally
            {
                ms.Close();
            }
            return(Id);
        }
Beispiel #12
0
        public async Task <HttpResponseMessage> UploadFile()
        {
            if (!Request.Content.IsMimeMultipartContent())
            {
                Request.CreateResponse(HttpStatusCode.UnsupportedMediaType);
            }

            var provider = GetMultipartMemoryStreamProvider();

            var tt = await Request.Content.ReadAsMultipartAsync(provider).ContinueWith(p =>
            {
                var result = p.Result;
                // var myParameter = result.FormData.GetValues("myParameter").FirstOrDefault();
                var file = _fileService.Create();
                foreach (var stream in result.Contents.Where((content, idx) => result.IsStream(idx)))
                {
                    string fileName = GetFileInfo.GetDeserializedFileName(stream);
                    var contentType = GetFileInfo.GetContentType(stream);

                    if (_fileService.IsValidType(fileName) && _fileService.IsValidContent(contentType.MediaType))
                    {
                        file.FileBinary = stream.ReadAsByteArrayAsync().Result;
                        file.Size       = stream.Headers.ContentLength;
                        file.IsDeleted  = false;
                        file.Extention  = contentType.MediaType;
                        file.Guid       = Guid.NewGuid();
                        file.Name       = fileName;
                        file.UploadDate = DateTime.UtcNow;
                        //  var file = new this.GetFormData<string >(stream.Headers.ContentDisposition.FileName);
                        //  var contentTest =  stream.ReadAsByteArrayAsync();
                        // ... and so on, as per your original code.
                        _fileService.Add(file);
                        _unitOfWork.SaveChanges();
                    }
                }
                return(file);
            });



            /*var result = await Request.Content.ReadAsMultipartAsync(provider);
             *
             *
             * // On upload, files are given a generic name like "BodyPart_26d6abe1-3ae1-416a-9429-b35f15e6e5d5"
             * // so this is how you can get the original file name
             *
             * var originalFileName = GetDeserializedFileName(result.FileData.First());
             *
             * // uploadedFileInfo object will give you some additional stuff like file length,
             * // creation time, directory name, a few filesystem methods etc..
             *
             * var uploadedFileInfo = new FileInfo(result.FileData.First().LocalFileName);
             *
             * // Remove this line as well as GetFormData method if you're not
             * // sending any form data with your upload request
             *
             * var fileUploadObj = GetFormData<UploadDataModel>(result);
             *
             * // Through the request response you can return an object to the Angular controller
             * // You will be able to access this in the .success callback through its data attribute
             * // If you want to send something to the .error callback, use the HttpStatusCode.BadRequest instead
             *
             * var returnData = "ReturnTest";
             *
             *
             */
            return(this.Request.CreateResponse(HttpStatusCode.OK, new { id = tt.Id }));
        }
 public File AddFile(File file)
 {
     return(_serviceFile.Add(file));
 }
Beispiel #14
0
        public async Task <IHttpActionResult> Upload(Guid refId, string screenCode)
        {
            #region Condition

            /// Checks whether the parameters are null.
            if (refId == null || screenCode == null)
            {
                return(BadRequest(Messages.FUE0002));
            }

            /// Controls whether the screen code is in the <see cref="ScreenCodes"/> class.
            if (!typeof(ScreenCodes).GetFields().Any(x => x.Name == screenCode))
            {
                return(BadRequest(Messages.GNW0002));
            }

            /// Checks the media type for the file-s to be uploaded.
            if (!Request.Content.IsMimeMultipartContent())
            {
                return(Content(HttpStatusCode.UnsupportedMediaType, Messages.FUW0001));
            }
            #endregion

            /// `localPath` and `useCloud` is get from Web.Config.
            string localPath = HostingEnvironment.MapPath(ConfigurationManager.AppSettings["fileServiceLocalPath"]);
            bool   useCloud  = Convert.ToBoolean(ConfigurationManager.AppSettings["useCloud"]);

            var provider = new MultipartFormDataStreamProvider(localPath);

            try
            {
                /// Loads the files into the local storage.
                await Request.Content.ReadAsMultipartAsync(provider);

                /// Check is exist valid file.
                if (provider.FileData.Count == 0)
                {
                    return(BadRequest(Messages.FUE0001));
                }

                IList <FileDto> modelList = new List <FileDto>();

                foreach (MultipartFileData file in provider.FileData)
                {
                    string originalName = file.Headers.ContentDisposition.FileName;
                    if (originalName.StartsWith("\"") && originalName.EndsWith("\""))
                    {
                        originalName = originalName.Trim('"');
                    }
                    if (originalName.Contains(@"/") || originalName.Contains(@"\"))
                    {
                        originalName = Path.GetFileName(originalName);
                    }

                    FileDto fileDto = new FileDto
                    {
                        RefId        = refId,
                        ScreenCode   = screenCode,
                        OriginalName = Path.GetFileNameWithoutExtension(originalName),
                        StorageName  = Path.GetFileName(file.LocalFileName),
                        Extension    = Path.GetExtension(originalName).ToLower(),
                        Size         = new FileInfo(file.LocalFileName).Length
                    };

                    modelList.Add(fileDto);
                }

                if (useCloud)
                {
                    await fileService.SendCloud(modelList, localPath);
                }

                await fileService.Add(modelList, IdentityClaimsValues.UserId <Guid>());

                return(Ok(Messages.Ok));
            }
            catch (Exception exMessage)
            {
                return(Content(HttpStatusCode.InternalServerError, exMessage));
            }
        }
Beispiel #15
0
        public async Task <HttpResponseMessage> Import()
        {
            if (!Request.Content.IsMimeMultipartContent())
            {
                return(Request.CreateErrorResponse(HttpStatusCode.UnsupportedMediaType, "Định dạng không được server hỗ trợ"));
            }

            var root = HttpContext.Current.Server.MapPath("~/UploadedFiles/FilePdf");

            if (!Directory.Exists(root))
            {
                Directory.CreateDirectory(root);
            }

            var provider = new MultipartFormDataStreamProvider(root);
            var result   = await Request.Content.ReadAsMultipartAsync(provider);

            //Byte[] test = File.ReadAllBytes(provider.FileData[0].LocalFileName);

            bool status = Boolean.Parse(result.FormData["status"].ToString().Trim('"'));

            var      dt          = result.FormData["timeStarted"].ToString().Trim('"');
            DateTime timeStarted = Convert.ToDateTime(dt);

            string folder = result.FormData["folders"].ToString().Trim('"');

            string cateId = result.FormData["categoryId"].ToString().Trim('"');

            string createdBy = result.FormData["createdBy"].ToString().Trim('"');

            var folderRoot = HttpContext.Current.Server.MapPath("~/UploadedFiles/FilePdf/" + folder + "-" + cateId);

            if (!Directory.Exists(folderRoot))
            {
                Directory.CreateDirectory(folderRoot);
            }

            foreach (MultipartFileData fileData in result.FileData)
            {
                if (fileData.Headers.ContentType.MediaType != "application/pdf" || string.IsNullOrEmpty(fileData.Headers.ContentDisposition.FileName))
                {
                    System.IO.File.Delete(fileData.LocalFileName);
                    return(Request.CreateResponse(HttpStatusCode.NotAcceptable, "Yêu cầu không đúng định dạng"));
                }
                string fileName = fileData.Headers.ContentDisposition.FileName;
                if (fileName.StartsWith("\"") && fileName.EndsWith("\""))
                {
                    fileName = fileName.Trim('"');
                }
                if (fileName.Contains(@"/") || fileName.Contains(@"\"))
                {
                    fileName = Path.GetFileName(fileName);
                }
                var fullPath = Path.Combine(folderRoot, fileName);

                if (System.IO.File.Exists(fullPath))
                {
                    System.IO.File.Delete(fileData.LocalFileName);
                    return(Request.CreateResponse(HttpStatusCode.NotAcceptable, "Tên file đã có trong hệ thống."));
                }
                else
                {
                    await Task.Run(() =>
                                   _fileService.Add(new Model.Models.File
                    {
                        Name          = fileName,
                        Alias         = StringHelper.ToUnsignString(fileName),
                        NewCategoryID = int.Parse(cateId),
                        CreatedDate   = DateTime.Now,
                        CreatedBy     = createdBy,
                        Status        = status,
                        TimeStarted   = timeStarted,
                        Path          = CommonConstants.FileUpload + folder + "-" + cateId + "/" + fileName
                    })
                                   ).ContinueWith((finishedTask) =>
                    {
                        _fileService.Save();
                    });

                    await Task.Run(() =>
                                   System.IO.File.Copy(fileData.LocalFileName, fullPath, false)
                                   ).ContinueWith((finishedTask) =>
                    {
                        System.IO.File.Delete(fileData.LocalFileName);
                    });

                    //System.IO.File.Copy(fileData.LocalFileName, fullPath, false);
                    //System.IO.File.Delete(fileData.LocalFileName);

                    //_fileService.Add(new Model.Models.File
                    //{
                    //    Name = fileName,
                    //    Alias = StringHelper.ToUnsignString(fileName),
                    //    NewCategoryID = int.Parse(cateId),
                    //    CreatedDate = DateTime.Now,
                    //    Status = status,
                    //    TimeStarted = timeStarted,
                    //    Path = CommonConstants.FileUpload + folder + "-" + cateId + "/" + fileName
                    //});
                    //_fileService.Save();

                    //MimeMapping.GetMimeMapping(filename)
                }
            }
            return(Request.CreateResponse(HttpStatusCode.OK, "Upload thành công."));
        }