Exemple #1
0
 public void HandleTableProcessorBegin(object sender, TableProcessorBeginEventArgs args)
 {
     Detail = new UploadDetail()
     {
         TableName = args.TableName, ClassName = args.ClassName, Begin = DateTime.Now, UploadHeader = Header
     };
     Context.UploadDetails.Add(Detail);
     Context.SaveChanges();
 }
Exemple #2
0
        public void TestCreateAndPopulate()
        {
            UploadContext context = new UploadContext();

            UploadHeader header = new UploadHeader();

            header.Begin = DateTime.Now;

            context.UploadHeaders.Add(header);

            DateTime       dt      = DateTime.Now;
            int            minutes = 0;
            IList <String> tables  = new List <String>()
            {
                "IN_GUEST", "IN_TRN", "IN_MSG", "IN_RES"
            };

            foreach (String table in tables.OrderBy(s => s))
            {
                minutes++;
                UploadDetail dtl = new UploadDetail()
                {
                    TableName = table, Begin = dt.AddMinutes(minutes++), End = dt.AddMinutes(minutes++), UploadHeader = header
                };
                context.UploadDetails.Add(dtl);
            }
            context.SaveChanges();
            TestContext.WriteLine("Done - {0}", minutes);
        }
        public ActionResult Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                using (UploadContext db = new UploadContext())
                {
                    User existUser = db.Users.FirstOrDefault(u => u.Login == model.UserName);
                    if (existUser != null)
                    {
                        ModelState.AddModelError("", "This login already exist. Enter another login");
                        return(View());
                    }

                    Role role = db.Roles.FirstOrDefault(r => r.Name == "User");

                    if (role != null)
                    {
                        var user = new User {
                            Login = model.UserName, Password = model.Password, Role = role, RoleId = role.Id
                        };
                        db.Users.Add(user);
                        db.SaveChanges();

                        return(RedirectToAction("Login", "Account"));
                    }
                }
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
 public SqlTableProcessorEventHandler(String connectionName)
 {
     Context      = new UploadContext(connectionName);
     Header       = new UploadHeader();
     Header.Begin = DateTime.Now;
     Context.UploadHeaders.Add(Header);
     Context.SaveChanges();
 }
Exemple #5
0
        public async Task <IActionResult> Post(UploadItem model, IFormFile fileToUpload)
        {
            if (fileToUpload != null)
            {
                // limit size to 100MB
                if (fileToUpload.Length > 104857600)
                {
                    return(BadRequest("File is to large. Allowed size < 100MB"));
                }

                var privateFileName = Hash.GetSecureToken(_rndProvider);
                var safeFileName    = WebUtility.HtmlEncode(Path.GetFileName(fileToUpload.FileName));
                var fileExtension   = Path.GetExtension(safeFileName);

                if (!string.IsNullOrEmpty(fileExtension))
                {
                    privateFileName += fileExtension;
                }

                var basePath = Path.Combine("wwwroot", "Uploads");
                var filePath = Path.Combine(basePath, privateFileName);

                using (var memStream = new MemoryStream())
                {
                    await fileToUpload.CopyToAsync(memStream);

                    var    byteData        = _protector.EncryptStream(memStream);
                    Stream encryptedStream = new MemoryStream(byteData);

                    using (var fileStream = new FileStream(filePath, FileMode.Create))
                    {
                        await encryptedStream.CopyToAsync(fileStream);
                    }
                }

                model.Token = $"https://{Request.Host}/upload/" + privateFileName;
                _context.UploadItems.Add(new UploadItem {
                    Token       = privateFileName, OriginalName = safeFileName,
                    CreatedDate = DateTime.Now, ExpiredBy = DateTime.Now + TimeSpan.FromMinutes(5)
                });
                _context.SaveChanges();
            }

            return(View("~/Views/Upload/Index.cshtml", model));
        }
Exemple #6
0
 private void ProcessFiles(List <Upload> uploads)
 {
     foreach (Upload u in uploads)
     {
         u.ProcessedTimestamp = DateTime.Now;
         _logger.LogInformation("File Id: " + u.Id + " Name: " + u.FileName + " processed at " + DateTime.Now.ToString("dddd, MMMM dd, yyyy HH:mm:ss.fffK"));
     }
     _context.SaveChanges();
 }
        private void ProcessFiles(List <Upload> uploads)
        {
            foreach (Upload u in uploads)
            {
                // Base64 decode file
                byte[] base64Data    = System.Convert.FromBase64String(u.FileContent);
                string base64Decoded = System.Text.ASCIIEncoding.UTF8.GetString(base64Data);

                try
                {
                    // Deserialize and process JSON file, persisting entities to database
                    if (u.FileType.ToLower() == "patients")
                    {
                        List <Patient> patients = JsonSerializer.Deserialize <List <Patient> >(base64Decoded);
                        foreach (Patient p in patients)
                        {
                            p.ModifiedDate = DateTime.Now;
                            _patientContext.Patients.Add(p);
                        }
                        _patientContext.SaveChanges();
                    }

                    if (u.FileType.ToLower() == "organizations")
                    {
                        List <Organization> organizations = JsonSerializer.Deserialize <List <Organization> >(base64Decoded);
                        foreach (Organization o in organizations)
                        {
                            o.ModifiedDate = DateTime.Now;
                            _organizationContext.Organizations.Add(o);
                        }
                        _organizationContext.SaveChanges();
                    }

                    if (u.FileType.ToLower() == "claims")
                    {
                        List <Claim> claims = JsonSerializer.Deserialize <List <Claim> >(base64Decoded);
                        foreach (Claim c in claims)
                        {
                            c.ModifiedDate = DateTime.Now;
                            _claimContext.Claims.Add(c);
                        }
                        _claimContext.SaveChanges();
                    }
                }

                catch (Exception ex)
                {
                    _logger.LogInformation("Exception Type: " + ex.GetType());
                }

                // Update file processing status in the system
                u.ProcessedTimestamp = DateTime.Now;
                _logger.LogInformation("File Id: " + u.Id + " Name: " + u.FileType + " processed at " + DateTime.Now.ToString("dddd, MMMM dd, yyyy HH:mm:ss.fffK"));
            }
            _uploadContext.SaveChanges();
        }
        public ActionResult Create([Bind(Include = "ProdutoId,Nome,Quantidade")] Produto produto, HttpPostedFileBase file)
        {
            if (ModelState.IsValid)
            {
                db.Produtos.Add(produto);


                if (file != null && file.ContentLength > 0)
                {
                    try
                    {
                        string path = Path.Combine(Server.MapPath("~/Public"),
                                                   Path.GetFileName(file.FileName));
                        file.SaveAs(path);

                        produto.Imagem = "Public/" + file.FileName;

                        ViewBag.Message = "File uploaded successfully";
                    }
                    catch (Exception ex)
                    {
                        ViewBag.Message = "ERROR:" + ex.Message.ToString();
                    }
                }
                else
                {
                    ViewBag.Message = "You have not specified a file.";
                }

                db.SaveChanges();

                return(RedirectToAction("Index"));
            }

            return(View(produto));
        }
Exemple #9
0
 public IActionResult Create(Upload upload)
 {
     upload.UploadTimestamp    = DateTime.Now;
     upload.ProcessedTimestamp = null;
     if (ModelState.IsValid)
     {
         _context.Uploads.Add(upload);
         _context.SaveChanges();
         return(CreatedAtRoute("GetUpload", new { id = upload.Id }, upload));
     }
     else
     {
         return(BadRequest(ModelState));
     }
 }
Exemple #10
0
        public IActionResult Index(IFormFile files)
        {
            if (files != null)
            {
                if (files.Length > 0)
                {
                    //Getting FileName
                    var fileName = Path.GetFileName(files.FileName);
                    //Getting file Extension
                    var fileExtension = Path.GetExtension(fileName);
                    // concatenating  FileName + FileExtension
                    var newFileName = String.Concat(Convert.ToString(Guid.NewGuid()), fileExtension);

                    // Combines two strings into a path.
                    var filepath = new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "UploadAudioFiles")).Root + $@"\{newFileName}";

                    var objfiles = new Files()
                    {
                        DocumentId = 0,
                        Name       = newFileName,
                        FileType   = fileExtension,
                        FilePath   = "~/UploadAudioFiles/" + newFileName,
                        CreatedOn  = DateTime.Now
                    };

                    using (var target = new MemoryStream())
                    {
                        files.CopyTo(target);
                        objfiles.DataFiles = target.ToArray();
                    }

                    _context.Files.Add(objfiles);
                    _context.SaveChanges();

                    using (FileStream fs = System.IO.File.Create(filepath))
                    {
                        files.CopyTo(fs);
                        fs.Flush();
                    }
                }
            }
            return(RedirectToAction("Index"));
        }
        public IActionResult Create(Upload upload)
        {
            upload.UploadTimestamp    = DateTime.Now;
            upload.ProcessedTimestamp = null;
            // Trim the header from the Base 64 encoded content
            int    position       = upload.FileContent.IndexOf("base64,");
            string trimmedContent = upload.FileContent.Remove(0, position + 7);

            upload.FileContent = trimmedContent;
            if (ModelState.IsValid)
            {
                _context.Uploads.Add(upload);
                _context.SaveChanges();
                return(CreatedAtRoute("GetUpload", new { id = upload.Id }, upload));
            }
            else
            {
                return(BadRequest(ModelState));
            }
        }
        private void Cleanup(object state)
        {
            foreach (var item in _secretContext.SecretItems)
            {
                if (item.ExpiredBy < DateTime.Now)
                {
                    _secretContext.SecretItems.Remove(item);
                    _secretContext.SaveChanges();
                }
            }

            foreach (var upload in _uploadContext.UploadItems)
            {
                if (upload.ExpiredBy < DateTime.Now)
                {
                    var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "Uploads", upload.Token);
                    _uploadContext.UploadItems.Remove(upload);
                    _uploadContext.SaveChanges();
                    FileOperator.DeleteUploadedFile(path);
                }
            }

            // Clean-up leftover uploads that have no records in the DB
            var allUploadedFiles = Directory.GetFiles(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "Uploads"));

            foreach (var uploadedFile in allUploadedFiles)
            {
                if (Path.GetFileName(uploadedFile) == ".placeholder.txt")
                {
                    continue;
                }

                if (!_uploadContext.UploadItems.Any(b => b.Token == Path.GetFileName(uploadedFile)))
                {
                    FileOperator.DeleteUploadedFile(uploadedFile);
                }
            }
        }
Exemple #13
0
 public void Commit()
 {
     _context.SaveChanges();
 }