Example #1
0
        public static string GenerateReport(List <VeteranMapping> veteranMapping)
        {
            // Set the file name and get the output directory
            var fileName    = "Report-" + DateTime.Now.ToString("yyyy-MM-dd--hh-mm-ss") + ".xlsx";
            var outputDir   = HttpContext.Current.Server.MapPath(ConfigurationSettingsModule.GetItem("Temp"));
            var virtualPath = ConfigurationSettingsModule.GetItem("Temp");

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

            // Create the file using the FileInfo object
            var file = new FileInfo(outputDir + fileName);


            // Create the package and make sure you wrap it in a using statement
            using (var package = new ExcelPackage(file))
            {
                // add a new worksheet to the empty workbook
                ExcelWorksheet worksheet = package.Workbook.Worksheets.Add("Sheet1 - " + DateTime.Now.ToShortDateString());

                AddFormating(worksheet);
                AddHeader(worksheet);
                AddData(worksheet, veteranMapping);


                // save our new workbook and we are done!
                package.Save();
            }


            return(virtualPath + fileName);
        }
Example #2
0
        public async Task <IHttpActionResult> Post()
        {
            if (!Request.Content.IsMimeMultipartContent())
            {
                return(BadRequest());
            }

            string root     = HttpContext.Current.Server.MapPath("~/Content/Files/");
            var    provider = new MultipartMemoryStreamProvider();
            await Request.Content.ReadAsMultipartAsync(provider);

            var imageUrl = GenerateAbsolutePath(HttpContext.Current.Request.ApplicationPath + ConfigurationSettingsModule.GetItem("PathImages"));

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

            Dictionary <string, string> errors = new Dictionary <string, string>();

            List <ImageReference> imageFilesVeterans = _imageService.SaveImages(provider, root, ref errors);

            var imageVeterans = imageFilesVeterans.Select(file => new ImageReference
            {
                ImageOriginal  = imageUrl + @"/" + file.ImageOriginal,
                ThumbnailImage = imageUrl + @"/" + file.ThumbnailImage
            }).ToList();

            return(Ok(new
            {
                Images = imageVeterans,
                Errors = errors
            }));
        }
Example #3
0
        public async Task <IHttpActionResult> PostUploadExcellFiles()
        {
            if (!Request.Content.IsMimeMultipartContent())
            {
                return(BadRequest());
            }

            var    provider = new MultipartMemoryStreamProvider();
            string path     = null;

            Tuple <byte[], HttpContent> fileArrayAndFileHttpContent = await GetFileArrayAndFileHttpContentFromProvider(provider);

            var filename = GetFilename(fileArrayAndFileHttpContent.Item2);

            filename += Guid.NewGuid() + ".xlsx";

            path = Path.Combine(HttpContext.Current.Server.MapPath("~" + ConfigurationSettingsModule.GetItem("Temp")), filename);

            if (!Directory.Exists(HttpContext.Current.Server.MapPath("~" + ConfigurationSettingsModule.GetItem("Temp"))))
            {
                Directory.CreateDirectory(
                    HttpContext.Current.Server.MapPath("~" + ConfigurationSettingsModule.GetItem("Temp")));
            }

            using (FileStream fs = new FileStream(path, FileMode.Create))
            {
                fs.Write(fileArrayAndFileHttpContent.Item1, 0, fileArrayAndFileHttpContent.Item1.Length);
            }

            try
            {
                ExcellParser excellParser    = new ExcellParser(path);
                var          veteranMappings = excellParser.GetVeterans();

                foreach (var veteranMapping in veteranMappings)
                {
                    var veteranBindingModel = Mapper.Map <VeteranMapping, VeteranBindingModel>(veteranMapping);

                    var listParsedUrls = UrlParser.Parse(veteranMapping.UrlImages);
                    veteranBindingModel.Images = UrlParser.DownloadFromUrls(listParsedUrls);

                    var veteran = Mapper.Map <VeteranBindingModel, Veteran>(veteranBindingModel);
                    veteran.User = _userService.GetById(User.Identity.GetUserId());

                    var googleMapsService = new GoogleMapsService(string.Empty);
                    var latLng            = googleMapsService.GetLatLng(veteran.BirthPlace);
                    veteran.Latitude  = latLng.Latitude;
                    veteran.Longitude = latLng.Longitude;

                    _veteranService.Add(veteran);
                }
            }
            catch (Exception exception)
            {
                var resp = new HttpResponseMessage(HttpStatusCode.InternalServerError)
                {
                    Content      = new StringContent("Problems with parsing the file"),
                    ReasonPhrase = "File Not Parsed"
                };

                _logger.Error(exception);

                throw new HttpResponseException(resp);
            }
            finally
            {
                if (File.Exists(path))
                {
                    File.Delete(path);
                }
            }

            return(Ok());
        }