public override void SetFile(string fileName)
{
var file = FileFactory.GetFile(fileName);
if (file == null)
{
throw new TFUnknownFileTypeException("No se reconoce el tipo del fichero");
}
var dbFile = new DbFile
{
Path = fileName, Hash = Utils.CalculateHash(fileName), Content = File.ReadAllBytes(fileName)
};
_repository.InsertFile(dbFile);
file.Id = dbFile.Id;
using (var ms = new MemoryStream(dbFile.Content))
{
file.Read(ms);
}
if (file.Strings.Count(x => x.Visible) > 0)
{
Files.Add(file);
}
else
{
_repository.DeleteFile(file.Id);
}
}
public void SetUp()
{
_autoMocker = new();
_userId = Guid.NewGuid();
_items = new Dictionary <object, object>();
_items.Add("UserId", _userId);
_dbFileMapper = _autoMocker.CreateInstance <DbFileMapper>();
_autoMocker
.Setup <IHttpContextAccessor, IDictionary <object, object> >(x => x.HttpContext.Items)
.Returns(_items);
_fileRequest = new AddFileRequest
{
Content = "RGlnaXRhbCBPZmA5Y2U=",
Extension = ".txt",
Name = "DigitalOfficeTestFile"
};
_dbFile = new DbFile
{
Id = Guid.NewGuid(),
Content = "RGlnaXRhbCBPZmA5Y2U=",
Extension = ".txt",
Name = "DigitalOfficeTestFile"
};
}
public async Task <IActionResult> UploadCert(IFormFile file)
{
var fileStream = file.OpenReadStream();
var hash = SaveFileToFs(fileStream);
var certBytes = new byte[fileStream.Length];
fileStream.Position = 0;
fileStream.Read(certBytes, 0, (int)fileStream.Length);
var cert = new X509Certificate2(certBytes);
var dbFile = await _db.Files.FirstOrDefaultAsync(x => x.Md5Hash == hash);
if (dbFile == null)
{
dbFile = new DbFile()
{
CreateDate = DateTime.UtcNow,
Md5Hash = hash,
Type = EFileType.Cert
};
_db.Files.Add(dbFile);
await _db.SaveChangesAsync();
}
return(Ok(new CertUploadResult()
{
Id = dbFile.Id,
Hash = hash,
Issuer = cert.Issuer,
NotAfter = cert.NotAfter,
NotBefore = cert.NotBefore,
}));
}
public Task <bool> SaveFile(DbFile file)
{
var insert = DbSet.InsertOneAsync(file);
return(null);
//AddCommand(() => DbSet.InsertOneAsync(obj));
}
public async Task <IActionResult> UploadBinary(IFormFile file)
{
var fileStream = file.OpenReadStream();
var hash = SaveFileToFs(fileStream);
var dbFile = await _db.Files.FirstOrDefaultAsync(x => x.Md5Hash == hash);
if (dbFile == null)
{
dbFile = new DbFile()
{
CreateDate = DateTime.UtcNow,
Md5Hash = hash,
Type = EFileType.Binary
};
_db.Files.Add(dbFile);
await _db.SaveChangesAsync();
}
return(Ok(new UploadResult()
{
Id = dbFile.Id,
Hash = hash
}));
}
protected void OnBtnCheckInVirusTotalClicked(object sender, EventArgs e)
{
if (treeFiles.SelectedItem == null)
{
return;
}
DbFile file = Workers.GetDBFile(((DbFile)treeFiles.SelectedItem).Sha256);
outIter = (DbFile)treeFiles.SelectedItem;
if (file == null)
{
MessageBox.Show("Cannot get file from database", MessageBoxType.Error);
return;
}
treeFiles.Enabled = false;
btnToggleCrack.Enabled = false;
btnScanWithClamd.Enabled = false;
btnCheckInVirusTotal.Enabled = false;
prgProgressFiles1.Visible = true;
lblProgressFiles1.Visible = true;
Workers.Failed += VirusTotalFailed;
Workers.ScanFinished += VirusTotalFinished;
Workers.UpdateProgress += UpdateVirusProgress;
lblProgressFiles1.Text = "Scanning file with VirusTotal.";
prgProgressFiles1.Indeterminate = true;
thdScanFile = new Thread(() => Workers.VirusTotalFileFromRepo(file));
thdScanFile.Start();
}
public void CRUD_One_Attachment_And_Fetch_Runs_Successfully()
{
var connectionManager = new ConnectionManager(DbFile.GetConnectionString("testdb.db"));
var repository = new AttachmentRepository(connectionManager);
var entry = new Attachment
{
FileName = "filename.pdf",
Description = "New Attachment",
Extension = "pdf"
};
repository.InsertOne(entry);
var insertedEntity = repository.GetOne(1);
Assert.IsNotNull(entry);
insertedEntity.Description = "Modified Attachment";
repository.UpdateOne(insertedEntity);
var updatedEntity = repository.GetOne(1);
Assert.That(updatedEntity.Description, Is.EqualTo("Modified Attachment"));
repository.DeleteOne(updatedEntity);
var deletedEntity = repository.GetOne(insertedEntity.Id);
Assert.IsNull(deletedEntity);
}
public void SetUp()
{
_autoMocker = new();
_userId = Guid.NewGuid();
_items = new Dictionary <object, object>();
_items.Add("UserId", _userId);
IHttpContextAccessor httpContextAccessor = new HttpContextAccessor();
var dbOptionsFileService = new DbContextOptionsBuilder <FileServiceDbContext>()
.UseInMemoryDatabase("FileServiceTestDatabase")
.Options;
_dbContext = new FileServiceDbContext(dbOptionsFileService);
_repository = new FileRepository(_dbContext, _autoMocker.GetMock <IHttpContextAccessor>().Object);
_autoMocker
.Setup <IHttpContextAccessor, IDictionary <object, object> >(x => x.HttpContext.Items)
.Returns(_items);
_dbFile = new DbFile
{
Id = Guid.NewGuid(),
Content = "RGlnaXRhbCBPZmA5Y2U=",
Extension = ".txt",
Name = "DigitalOfficeTestFile"
};
}
public static DbFile UploadSingleFile(FileInfo fi, Crypto.EncryptionMode encryptionMode)
{
DbFile dbf = null;
try
{
dbf = new DbFile();
dbf.Id = fi.FullName;
dbf.DateLastWriteTime = fi.LastWriteTimeUtc;
dbf.Name = fi.Name;
dbf.Tag = null;
dbf.Category = null;
dbf.EncryptionMode = encryptionMode;
dbf.Size = fi.Length;
dbf.Checksum = Checksum.Calculate(fi);
if (UploadProcess(dbf) == false)
{
Logger.Warn(LOGNAME, "File has not been uploaded");
}
else
{
Logger.Info(LOGNAME, "Link: " + dbf.DownloadLink);
}
}
catch (Exception ex)
{
Logger.Error(LOGNAME, ex.Message, ex);
}
return(dbf);
}
private async Task <SQLiteAsyncConnection> GetConnectionAsync()
{
if (Connection == null)
{
var dbPassword = GetDBPassword();
var connString = new SQLiteConnectionString(DbFile.FullName, true, key: GetDBPassword());
Connection = new SQLiteAsyncConnection(connString);
try
{
await Connection.CreateTableAsync <OTPGenerator>();
}
catch (SQLiteException e) when(e.Result == SQLite3.Result.NonDBFile)
{
//Encryption password does not match anymore. Most likely due to roaming.
//Notify user and delete database file. Hope they had backup.
await Connection.CloseAsync();
Connection = null;
DbFile.Delete();
ErrorOccurred?.Invoke(this, new ErrorEventArgs(e));
return(null);
}
await MigrateOldDb(Connection);
}
return(Connection);
}
public void SetupTest()
{
var databaseOperations =
new DatabaseOperationsRepository(DbFile.GetConnectionString("testdb.db"));
databaseOperations.CreateAndInitialize(DbFile.GetPath("testdb.db"), TxtFile.ReadText("RebuildDatabase.txt"));
}
public void CRUD_One_DiaryEntry_And_Fetch_Runs_Successfully()
{
var connectionManager = new ConnectionManager(DbFile.GetConnectionString("testdb.db"));
var repository = new DiaryEntryRepository(connectionManager);
var dateCreated = DateTime.Parse("2017/03/12 13:12:21");
var entry = new DiaryEntry
{
Title = "New DiaryEntry",
DateCreated = dateCreated.Ticks
};
repository.InsertOne(entry);
var insertedEntity = repository.GetOne(1);
Assert.IsNotNull(entry);
Assert.That(entry.Title, Is.EqualTo("New DiaryEntry"));
Assert.That(new DateTime(entry.DateCreated), Is.EqualTo(dateCreated));
insertedEntity.Title = "Modified DiaryEntry";
repository.UpdateOne(insertedEntity);
var updatedEntity = repository.GetOne(1);
Assert.That(updatedEntity.Title, Is.EqualTo("Modified DiaryEntry"));
repository.DeleteOne(updatedEntity);
var deletedEntity = repository.GetOne(insertedEntity.Id);
Assert.IsNull(deletedEntity);
}
void VirusTotalFinished(DbFile file)
{
Application.Invoke(delegate
{
treeFiles.Sensitive = true;
btnToggleCrack.Sensitive = true;
btnScanWithClamd.Sensitive = true;
btnCheckInVirusTotal.Sensitive = true;
Workers.Failed -= VirusTotalFailed;
Workers.ScanFinished -= VirusTotalFinished;
Workers.UpdateProgress -= UpdateVirusProgress;
prgProgressFiles1.Text = "";
prgProgressFiles1.Visible = false;
if (thdPulseProgress != null)
{
thdPulseProgress.Abort();
thdPulseProgress = null;
}
if (thdScanFile != null)
{
thdScanFile = null;
}
if (!(bool)fileView.GetValue(outIter, 3) && file.HasVirus.HasValue && file.HasVirus.Value)
{
infectedFiles++;
}
fileView.Remove(ref outIter);
AddFile(file);
lblFileStatus.Text = $"{fileView.IterNChildren()} files ({infectedFiles} infected)";
});
}
public void CRUD_One_Snippet_And_Fetch_Runs_Successfully()
{
var connectionManager = new ConnectionManager(DbFile.GetConnectionString("testdb.db"));
var repository = new SnippetRepository(connectionManager);
var entry = new Snippet
{
Title = "New Hyperlink",
Content = "Here is some content for you.",
SyntaxHighlightId = 1
};
repository.InsertOne(entry);
var insertedEntity = repository.GetOne(1);
Assert.IsNotNull(entry);
insertedEntity.Title = "Modified Snippet";
repository.UpdateOne(insertedEntity);
var updatedEntity = repository.GetOne(1);
Assert.That(updatedEntity.Title, Is.EqualTo("Modified Snippet"));
repository.DeleteOne(updatedEntity);
var deletedEntity = repository.GetOne(insertedEntity.Id);
Assert.IsNull(deletedEntity);
}
public async Task InsertTest()
{
var ctx = new DbContext(_cs);
var item = new DbFile()
{
Id = _fileId,
Name = "filetest.txt",
AuthorId = _creatorId,
Created = new DateTime(2019, 1, 1, 22, 23, 00),
MessageId = _messageId
};
DbFile message;
try
{
message = await ctx.Files.Create(item);
Assert.AreEqual(item.Id, message.Id);
}
catch (MySqlException ex)
{
Debug.WriteLine(ex);
await ctx.Files.Delete(_fileId);
message = await ctx.Files.Create(item);
Assert.AreEqual(item.Id, message.Id);
}
}
void AddFile(DbFile file)
{
Application.Invoke(delegate
{
if (thdPulseProgress != null)
{
thdPulseProgress.Abort();
thdPulseProgress = null;
}
string color;
if (file.HasVirus.HasValue)
{
color = file.HasVirus.Value ? "red" : "green";
}
else
{
color = "yellow";
}
if (file.HasVirus.HasValue && file.HasVirus.Value)
{
infectedFiles++;
}
fileView.AppendValues(file.Sha256, file.Length, file.Crack, file.HasVirus ?? false,
file.ClamTime?.ToString() ?? "Never",
file.VirusTotalTime?.ToString() ?? "Never",
file.Virus, color, "black", !file.HasVirus.HasValue);
});
}
private static void ModeUpload(string filepath, Crypto.EncryptionMode encryptionMode, string savepath)
{
try
{
DbFile dbf = FileUploader.UploadSingleFile(new FileInfo(filepath), encryptionMode);
string nzblPath = filepath + Utilities.EXT_NZBL;
if (string.IsNullOrEmpty(savepath) == false)
{
if (Directory.Exists(savepath))
{
nzblPath = Path.Combine(savepath, new FileInfo(filepath).Name + Utilities.EXT_NZBL);
}
else
{
nzblPath = savepath;
}
}
if (dbf != null)
{
File.WriteAllBytes(nzblPath, Utilities.HexToBytes(dbf.DownloadLink));
}
}
catch (Exception ex)
{
Logger.Error(LOGNAME, ex.Message, ex);
}
}
public static void SaveCompiledCustomAssembly(byte[] buffer)
{
RemoveExistingCompiledAssemblyFromDb();
var path = "/" + KompilerEntryPoint.CompiledAssemblyName + ".dll";
using (var ctx = new DbFileContext())
{
var root = ctx.DbFiles.Include(x => x.Children).First(x => x.IsDirectory && x.ParentId == null && x.Name == null && x.VirtualPath.Equals("/", StringComparison.InvariantCultureIgnoreCase));
var file = new DbFile
{
ParentId = root.Id,
IsDirectory = false,
Name = KompilerEntryPoint.CompiledAssemblyName,
Extension = ".dll",
IsBinary = true,
VirtualPath = path,
Bytes = buffer
};
ctx.DbFiles.Add(file);
ctx.SaveChanges();
}
}
public void CRUD_One_Hyperlink_And_Fetch_Runs_Successfully()
{
var connectionManager = new ConnectionManager(DbFile.GetConnectionString("testdb.db"));
var repository = new HyperlinkRepository(connectionManager);
var entry = new Hyperlink
{
Title = "New Hyperlink",
Url = "http://www.msn.com"
};
repository.InsertOne(entry);
var insertedEntity = repository.GetOne(1);
Assert.IsNotNull(entry);
insertedEntity.Title = "Modified Hyperlink";
repository.UpdateOne(insertedEntity);
var updatedEntity = repository.GetOne(1);
Assert.That(updatedEntity.Title, Is.EqualTo("Modified Hyperlink"));
repository.DeleteOne(updatedEntity);
var deletedEntity = repository.GetOne(insertedEntity.Id);
Assert.IsNull(deletedEntity);
}
void VirusTotalFinished(DbFile file)
{
Application.Instance.Invoke(delegate
{
treeFiles.Enabled = true;
btnToggleCrack.Enabled = true;
btnScanWithClamd.Enabled = true;
btnCheckInVirusTotal.Enabled = true;
Workers.Failed -= VirusTotalFailed;
Workers.ScanFinished -= VirusTotalFinished;
Workers.UpdateProgress -= UpdateVirusProgress;
lblProgressFiles1.Text = "";
prgProgressFiles1.Visible = false;
if (thdScanFile != null)
{
thdScanFile = null;
}
if ((!outIter.HasVirus.HasValue || outIter.HasVirus.HasValue && !outIter.HasVirus.Value) &&
file.HasVirus.HasValue && file.HasVirus.Value)
{
infectedFiles++;
}
lstFiles.Remove(outIter);
AddFile(file);
lblFileStatus.Text = $"{lstFiles.Count} files ({infectedFiles} infected)";
});
}
public void AddUserFile(User user, UserFile file)
{
using (var db = GetConnect(_mf.ConnectionString))
{
SHA256 sha = new SHA256Managed();
file.Hash = Convert.ToBase64String(sha.ComputeHash(file.Bin));
var newUserFile = new DbUserfile
{
Userid = user.Id,
Hash = file.Hash,
Filename = file.Filename,
Contenttype = file.ContentType,
};
if (db.Files.Any(o => o.Hash == file.Hash))
{
db.Userfiles.Add(newUserFile);
db.SaveChanges();
}
else
{
DbFile newFile = new DbFile
{
Hash = file.Hash,
Bin = file.Bin,
};
db.Files.Add(newFile);
db.Userfiles.Add(newUserFile);
db.SaveChanges();
}
}
}
private DbFile GetFileFromReader(IDataReader reader)
{
var file = new DbFile
{
FileId = reader.GetInt32("FileId"),
BlobProvider = reader.GetSafeString("BlobProvider"),
BlobProviderData = reader.GetSafeString("BlobProviderData"),
ContentType = reader.GetSafeString("ContentType"),
FileNameWithoutExtension = reader.GetSafeString("FileNameWithoutExtension"),
Extension = reader.GetSafeString("Extension"),
Size = reader.GetSafeInt64("Size"),
CreationDate = reader.GetSafeDateTime("CreationDate") ?? DateTime.MinValue,
IsDeleted = reader.GetSafeBooleanFromBoolean("IsDeleted"),
Staging = reader.GetSafeBooleanFromBoolean("Staging"),
StagingPropertyTypeId = reader.GetSafeInt32("StagingPropertyTypeId"),
StagingVersionId = reader.GetSafeInt32("StagingVersionId"),
Stream = reader.GetSafeByteArray("Stream"),
Checksum = reader.GetSafeString("Checksum"),
RowGuid = reader.GetGuid(reader.GetOrdinal("RowGuid")),
Timestamp = reader.GetSafeLongFromBytes("Timestamp")
};
file.ExternalStream = GetExternalData(file);
return(file);
}
private static void ScanFiles(DirectoryInfo di, SettingFolder sf)
{
try
{
FileInfo[] files = di.GetFiles();
foreach (FileInfo fi in files)
{
if (fi.Length < Settings.Settings.Current.FileMinSize)
{
continue;
}
string fileId = fi.FullName;
if (string.IsNullOrEmpty(fileId))
{
continue;
}
DbFile dbf = Db.FileGet(fileId);
if (dbf == null) //file not in db
{
string name = GetFileName(fi, sf);
if (CheckFilters(name) == false)
{
continue;
}
dbf = new DbFile();
dbf.Id = fileId;
dbf.DateLastWriteTime = fi.LastWriteTimeUtc;
dbf.Name = name;
dbf.Tag = sf.Tag;
dbf.Category = sf.Category;
dbf.Lang = sf.Lang;
dbf.EncryptionMode = sf.EncryptionMode;
dbf.Checksum = null;
dbf.Size = fi.Length;
Db.FileSave(dbf, DbFile.State.QUEUED);
Logger.Info(LOGNAME, "Added: " + dbf.Name);
}
else if (dbf.DateLastWriteTime < fi.LastWriteTimeUtc)
{
dbf.DateLastWriteTime = fi.LastWriteTimeUtc;
dbf.Checksum = null;
dbf.Size = fi.Length;
dbf.DownloadLink = null;
Db.FileSave(dbf, DbFile.State.QUEUED);
Logger.Info(LOGNAME, "Updated: " + dbf.Name);
}
}
}
catch (System.UnauthorizedAccessException ex)
{
//nothing to do
System.Diagnostics.Debug.WriteLine(ex.Message);
}
catch (Exception ex)
{
Logger.Error(LOGNAME, ex.Message, ex);
}
}
public ActionResult UploadToDb(IEnumerable <HttpPostedFileBase> file)
{
string message = string.Empty;
if (file.Count() > 0)
{
//保證資料一致性，將所有資料 Add 完以後，再呼叫 db.SaveChanges() 方法
//若有上傳失敗的檔案則不會叫到此方法
try
{
int i = 0;
foreach (var F in file)
{
message += $"<h3>檔案{i}：</h3>";
if (F == null)
{
message += "沒有選到檔案。";
}
else
{
if (F.ContentLength > 0)
{
string FileName = Path.GetFileName(F.FileName);
int FileLength = F.ContentLength;
byte[] buffer = new byte[FileLength];
//讀取 Stream，寫入 Buffer
F.InputStream.Read(buffer, 0, FileLength);
DbFile dbFile = new DbFile()
{
Name = FileName,
MimeType = F.ContentType,
Size = FileLength,
Content = buffer
};
DbFile NewRow = db.DbFiles.Add(dbFile);
message += $" 檔案ID：{NewRow.Id}<br /> 檔案名稱：{FileName}<br /> 上傳檔案類型(MIME)：{F.ContentType}<br /> 檔案大小：{FileLength} Byte<br /> 上傳成功！<hr />";
}
else
{
message += "請勿上傳空白檔案。";
}
}
i += 1;
}
db.SaveChanges();
}
catch (Exception ex)
{
message = $"檔案上傳失敗，錯誤訊息：<br />{ex.Message}";
}
}
else
{
message = "你好像很不會上傳檔案喔？";
}
TempData["Message"] = message;
return(View("UploadFile"));
}
private void viewBtn_Click(object sender, EventArgs e)
{
ClearDisplay();
// open database and read records back - the database is transactional
Env env = new Env(EnvCreateFlags.None);
try {
DbBTree btree;
Env.OpenFlags envFlags =
Env.OpenFlags.Create |
Env.OpenFlags.InitLock |
Env.OpenFlags.InitLog |
Env.OpenFlags.InitMPool |
Env.OpenFlags.InitTxn |
Env.OpenFlags.Recover;
env.Open(homeDir, envFlags, 0);
Db db = env.CreateDatabase(DbCreateFlags.None);
Txn txn = env.TxnBegin(null, Txn.BeginFlags.None);
DbFile tmpDb =
db.Open(txn, Path.Combine(homeDir, myDb), null, DbType.Unknown, Db.OpenFlags.None, 0);
txn.Commit(Txn.CommitMode.None);
if (tmpDb.DbType == DbType.BTree)
{
btree = (DbBTree)tmpDb;
}
else
{
throw new ApplicationException("Unexpected database type.");
}
List <Customer> custList = new List <Customer>();
// DbBTreeCursor implements IDisposable - will be closed through "using"
using (DbBTreeCursor cursor = btree.OpenCursor(null, DbFileCursor.CreateFlags.None)) {
Customer cust = null;
while (GetNextRecord(cursor, ref cust))
{
custList.Add(cust);
}
}
db.Close();
DataGridViewColumn nameCol = new DataGridViewTextBoxColumn();
nameCol.Name = "NameCol";
nameCol.HeaderText = "Name";
nameCol.DataPropertyName = "Name";
dataGridView.Columns.Add(nameCol);
dataGridView.DataSource = custList;
tabControl.SelectTab("dataPage");
}
catch (Exception ex) {
errBox.Text = ex.ToString();
tabControl.SelectTab("errorPage");
}
finally {
env.Close();
}
}
public FileData Map(DbFile dbFile)
{
if (dbFile == null)
{
return(null);
}
return(new FileData(dbFile.Id, dbFile.Content, dbFile.Extension, dbFile.Name));
}
public ActionResult DeleteStudent(int id)
{
DbFile db = new DbFile();
Student student = db.student.Find(id);
db.student.Remove(student);
db.SaveChanges();
return(RedirectToAction("StudentDetail"));
}
void Zf_SaveProgress(object sender, SaveProgressEventArgs e)
{
if (e.CurrentEntry != null &&
e.CurrentEntry.FileName != _zipCurrentEntryName)
{
_zipCurrentEntryName = e.CurrentEntry.FileName;
_filePosition++;
SetProgress2?.Invoke(this, new ProgressEventArgs
{
Value = _filePosition
});
if (!_filesByMachine.TryGetValue(e.CurrentEntry.FileName, out FileByMachine fileByMachine))
{
if (!_filesByMachine.TryGetValue(e.CurrentEntry.FileName.Replace('/', '\\'), out fileByMachine))
{
throw new ArgumentException(Localization.CannotFindZipEntryInDictionary);
}
}
DbFile currentFile = fileByMachine.File;
SetMessage3?.Invoke(this, new MessageEventArgs
{
Message = string.Format(Localization.Compressing, e.CurrentEntry.FileName)
});
SetProgress3Bounds?.Invoke(this, new ProgressBoundsEventArgs
{
Minimum = 0,
Maximum = currentFile.Size
});
}
SetProgress3?.Invoke(this, new ProgressEventArgs
{
Value = e.BytesTransferred
});
switch (e.EventType)
{
case ZipProgressEventType.Error_Saving:
#if DEBUG
throw new Exception();
#endif
break;
case ZipProgressEventType.Saving_Completed:
_machinePosition++;
CompressNextMachine();
break;
}
}
void AddFile(DbFile file) => Application.Instance.Invoke(delegate
{
if (file.HasVirus.HasValue &&
file.HasVirus.Value)
{
infectedFiles++;
}
lstFiles.Add(file);
});
public Database(string fileName)
{
if (!Directory.Exists("data"))
Directory.CreateDirectory("data");
fileName = "data/" + fileName;
db = new Db(DbCreateFlags.None);
db.CacheSize = new CacheSize(0, 10240, 0);
dbFile = db.Open(null, fileName, null, DbType.BTree, Db.OpenFlags.Create | Db.OpenFlags.ThreadSafe, 0);
}
public Guid Upload(string fileName, byte[] fileData)
{
var file = new DbFile()
{
Name = fileName,
FileData = fileData
};
filesRepository.Insert(file);
return(file.Id);
}
public static void WriteToDisk(DbFile dbFile, bool force)
{
Trace.TraceInformation("[DbToLocal]:Copiando arquivo: '{0}'", dbFile.VirtualPath);
var localpath = GetLocalPath(dbFile);
if (File.Exists(localpath))
{
var fi = new FileInfo(localpath);
if (fi.LastWriteTimeUtc > dbFile.LastWriteUtc && !force)
return;
Trace.TraceWarning("[DbToLocal]:Arquivo será excluído: {0}/{1}", fi.FullName, fi.LastAccessTimeUtc);
try
{
File.Delete(localpath);
}
catch (Exception ex)
{
Trace.TraceInformation(ex.Message);
}
}
var dir = Path.GetDirectoryName(localpath);
if (!Directory.Exists(dir))
Directory.CreateDirectory(dir);
try
{
if (dbFile.IsBinary && dbFile.Bytes.Length > 0)
File.WriteAllBytes(localpath, dbFile.Bytes);
else File.WriteAllText(localpath, dbFile.Texto);
}
catch (Exception ex)
{
Trace.TraceInformation(ex.Message);
}
}
public static void RemoveFromDisk(DbFile dbFile)
{
var localpath = GetLocalPath(dbFile);
if (File.Exists(localpath))
{
Trace.TraceWarning("[DbToLocal]:Arquivo será excluído: {0}", localpath);
try
{
File.Delete(localpath);
}
catch (Exception ex)
{
Trace.TraceInformation(ex.Message);
}
}
else if (Directory.Exists(localpath))
{
RecursiveDelete(new DirectoryInfo(localpath), true, ".Config");
}
}
static string GetLocalPath(DbFile dbFile)
{
string localpath = DirInfo.FullName + dbFile.VirtualPath.Replace("/", "\\");
return localpath;
}
