public async Task <ActionResult> ShowFile(Guid id, bool download = false)
{
try
{
List <FilesModel> files = await new FilesFetcherHandler(_logger, _dbContext).GetFileList(id);
FilesModel file = files[0];
byte[] bytes = Convert.FromBase64String(file.Content);
FileContentResult result = new FileContentResult(bytes, file.ContentType)
{
FileContents = bytes,
EnableRangeProcessing = true,
};
if (download)
{
result.FileDownloadName = file.FileName;
}
return(result);
}
catch (Exception e)
{
_logger.LogError(e, e.Message, e);
Console.WriteLine(e);
throw;
}
}
public JsonResult Save(FilesModel model)
{
if (!CheckPoint.Instance.GrantEditImplementationGuide(model.Id))
{
throw new AuthorizationException("You do not have access to edit this implementation guide's files.");
}
foreach (FileModel fileModel in model.Files)
{
if (fileModel.IsRemoved)
{
RemoveFile(fileModel);
}
else if (fileModel.FileId != null)
{
UpdateFile(fileModel);
}
else
{
AddFile(model.Id, fileModel);
}
this.tdb.SaveChanges();
}
return(Json(new { }));
}
public ActionResult Index()
{
DirectoryInfo d = new DirectoryInfo(Server.MapPath("~/Files/Template"));
FileInfo[] Files = d.GetFiles("*");
List <FilesModel> filesList = new List <FilesModel>();
foreach (var a in Files)
{
var path = Path.Combine(Server.MapPath("~/Files/Template"), a.Name);
if (System.IO.File.Exists(path))
{
var f = new FilesModel()
{
Name = Path.GetFileNameWithoutExtension(path),
FileName = a.Name,
Extension = a.Extension
};
filesList.Add(f);
}
}
return(View(filesList));
}
//this ctor is used when creating new item of known type
public FileNode(FilesModel model, string name, EFileType type)
{
_model = model;
_type = type;
_SetName(name);
_id = _model.AddGetId(this);
}
/// <summary>
/// Method to upload files
/// </summary>
/// <param name="files"></param>
/// <returns></returns>
public async Task <ResponseModel> UploadFiles(List <IFormFile> files)
{
try
{
foreach (var f in files)
{
using (var memoryStream = new MemoryStream())
{
await f.CopyToAsync(memoryStream);
FilesModel file = new FilesModel
{
Content = Convert.ToBase64String(memoryStream.ToArray()),
FileName = f.FileName,
ContentType = f.ContentType,
};
await _dbContext.Files.AddAsync(file);
await _dbContext.SaveChangesAsync();
}
return(new ResponseModel(true));
}
return(new ResponseModel(false)
{
Message = "Couldn't upload"
});
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public bool AddDE(FilesModel model)
{
if (DataContext.DigitalEvidences.Any(x => x.WID == model.WID))
{
var file = DataContext.DigitalEvidences.Where(x => x.WID == model.WID).FirstOrDefault();
file.FileData = model.FileData;
file.FileDataEnc = model.FileDataEnc;
file.FileName = model.FileName;
file.FileExtension = model.FileExtension;
}
else
{
var record = new DigitalEvidence()
{
WID = model.WID,
FileData = model.FileData,
FileDataEnc = model.FileDataEnc,
FileName = model.FileName,
FileExtension = model.FileExtension,
FileHashedValue = model.FileHashedValue
};
DataContext.DigitalEvidences.Add(record);
}
return(DataContext.SaveChanges() > 0);
}
public async Task CanInsertInDatabase_Ok()
{
try
{
Setup();
var sevenItems = new byte[] { 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 };
var bytes = new byte[64493];
var base64String = Convert.ToBase64String(sevenItems);
var file = new FilesModel()
{
Content = base64String,
FileName = "test",
ContentType = "application/json"
};
await _dbContext.Files.AddAsync(file);
await _dbContext.SaveChangesAsync();
Assert.Pass();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
/// <summary>
/// 儲存圖片
/// </summary>
/// <param name="model"></param>
public void SaveFiles(FilesModel model)
{
if (model.ID > 0)
{
List <FILEBASE> filterRemove = new List <FILEBASE>();
if (model.UploadIdentify == FileUploadType.NOTSET)
{
filterRemove = this.DB.FILEBASE
.Where(o => !model.OldFileIds.Contains(o.ID) &&
o.MAP_ID == model.ID &&
o.MAP_SITE == model.ActionName &&
o.FILE_TP == "F"
).ToList();
}
else
{
filterRemove = this.DB.FILEBASE
.Where(o => !model.OldFileIds.Contains(o.ID) &&
o.MAP_ID == model.ID &&
o.MAP_SITE == model.ActionName &&
o.FILE_TP == "F" &&
o.IDENTIFY_KEY == (int)model.UploadIdentify
).ToList();
}
if (filterRemove.Count > 0)
{
foreach (var f in filterRemove)
{
File.Delete(string.Concat(rootPath, f.FILE_PATH));
}
//刪除舊檔
this.DB.FILEBASE.RemoveRange(filterRemove);
this.DB.SaveChanges();
}
}
//存檔多筆
foreach (var f in model.MemberDataMultiple)
{
int sq = model.MemberDataMultiple.IndexOf(f) + 1;
FILEBASE file = new FILEBASE()
{
FILE_RANDOM_NM = f.FileName,
MAP_SITE = model.ActionName,
SQ = sq,
BUD_DT = DateTime.UtcNow.AddHours(8),
BUD_ID = UserProvider.Instance.User.ID,
MAP_ID = model.ID,
FILE_REL_NM = f.RealFileName,
FILE_TP = "F",
FILE_PATH = f.FilePath,
URL_PATH = f.FileUrl,
IDENTIFY_KEY = model.UploadIdentify == FileUploadType.NOTSET ? default(int?) : (int)model.UploadIdentify,
};
this.DB.FILEBASE.Add(file);
this.DB.SaveChanges();
f.ID = file.ID;
}
}
public static FilesModel LoadCsvHeaderAndFillLoaderModel(HttpPostedFileBase file)
{
var filesModel = new FilesModel();
var stream = file.InputStream;
var reader = new StreamReader(stream);
var headerLine = reader.ReadLine();
if (headerLine == null)
{
return(null);
}
var headers = headerLine.Split(',', ';');
filesModel.Header = "";
foreach (var column in headers)
{
filesModel.Header = String.Concat(filesModel.Header, "\n", column);
}
filesModel.Header = filesModel.Header.Trim();
filesModel.FileName = file.FileName;
return(filesModel);
}
/// <summary>
/// 上傳檔案
/// </summary>
/// <param name="vm"></param>
/// <param name="myFile"></param>
public void UploadFile(FilesModel vm, List <HttpPostedFileBase> files, int identityId, string siteName)
{
string serverMapPath = @"/Content/Upload/Manage/Files/" + siteName + "/" + identityId + @"/";
if (files != null && files.Count > 0)
{
for (int i = 0; i < files.Count; i++)
{
string strFileName = Guid.NewGuid().ToString() + Path.GetExtension(files[i].FileName);
string strFilePath = HttpContext.Current.Server.MapPath(serverMapPath + strFileName);
string realFileName = files[i].FileName;
string[] dirAry = new string[] { "Content", "Upload", "Manage", "Files", siteName, identityId.ToString() };
PublicMethodRepository.CreateDir(dirAry);
files[i].SaveAs(strFilePath);
#region data binding to model
vm.MemberDataMultiple.Add(new FileViewModel()
{
RealFileName = realFileName,
FilePath = strFilePath.Replace(rootPath, ""),
FileName = strFileName,
FileUrl = serverMapPath.Substring(1, serverMapPath.Length - 1) + strFileName,
});
#endregion data binding to model
}
}
}
//currently not used
//this ctor is used when creating new item of known type
//public FileNode(FilesModel model, string name, EFileType type, string linkTarget = null)
//{
// _model = model;
// _type = type;
// _name = name;
// _id = _model.AddGetId(this);
// _CtorMisc(linkTarget);
//}
//this ctor is used when creating new item, importing items from files etc.
//name is filename with extension.
//sourcePath is used when need to get file text to detect type.
//template used when creating new item, to detect item type.
public FileNode(FilesModel model, string name, string sourcePath, bool isFolder, string linkTarget = null, string template = null)
{
//detect file type
EFileType type;
if (isFolder)
{
type = EFileType.Folder;
}
else if (template == "Script.cs")
{
type = EFileType.Script;
}
else if (template == "Class.cs" || template == "Partial.cs")
{
type = EFileType.Class;
}
else
{
type = DetectFileType(sourcePath);
}
_model = model;
_type = type;
_name = name;
_id = _model.AddGetId(this);
_CtorMisc(linkTarget);
}
public IActionResult DeleteFile([FromBody] DeleteModel deleteModel)
{
try
{
string path = Path.Combine(_webHostEnvironment.WebRootPath, "UploadedFiles/" + deleteModel.FileName);
System.IO.File.SetAttributes(path, FileAttributes.Normal);
System.IO.File.Delete(path);
var model = new FilesModel
{
SystemFileNames = GetLocalFiles()
};
return(Json(model));
}
catch (Exception e)
{
var model = new FilesModel
{
SystemFileNames = GetLocalFiles(),
Message = $"Error occured whilst attempting to delete file!\nError details: {e.Message}"
};
return(Json(model));
}
}
public void ZUnloadOnFormClosed()
{
if(_model == null) return;
_model.Save.AllNowIfNeed();
var oldModel = _model;
Program.Model = _model = null;
oldModel.Dispose();
}
public Model(Stream stream, string m3uPath, LogEacFormat log) : base(m3uPath)
{
base._data = Data = new M3uFormat(this, stream, m3uPath);
foreach (var track in log.Tracks.Items)
{
FilesModel.Add(track.Match.Name);
}
}
//protected override void OnGotFocus(EventArgs e) { _c.Focus(); }
/// <summary>
/// Loads existing or new workspace.
/// If fails, shows a task dialog with several choices - retry, load another, create new, cancel. If then fails, ends process.
/// Sets Model and Text properties of the main form. Updates recent files.
/// By default runs startup script.
/// </summary>
/// <param name="wsDir">
/// Workspace's directory. The directory should contain file "files.xml" and subdirectory "files".
/// If null, loads the last used workspace (its path is in settings).
/// If the setting does not exist, uses AFolders.ThisAppDocuments + @"Main".
/// If the file does not exist, copies from AFolders.ThisApp + @"Default\Workspace".
/// </param>
public FilesModel ZLoadWorkspace(string wsDir = null)
{
wsDir ??= Program.Settings.workspace;
if(wsDir.NE()) wsDir = AFolders.ThisAppDocuments + "Main";
var xmlFile = wsDir + @"\files.xml";
var oldModel = _model;
FilesModel m = null;
_isNewWorkspace = false;
g1:
try {
//SHOULDDO: if editor runs as admin, the workspace directory should be write-protected from non-admin processes.
if(_isNewWorkspace = !AFile.ExistsAsFile(xmlFile)) {
AFile.Copy(AFolders.ThisAppBS + @"Default\Workspace", wsDir);
}
_model?.UnloadingWorkspace(); //saves all, closes documents, sets current file = null
m = new FilesModel(_c, xmlFile);
_c.Model = m;
}
catch(Exception ex) {
m?.Dispose();
m = null;
//AOutput.Write($"Failed to load '{wsDir}'. {ex.Message}");
switch(ADialog.ShowError("Failed to load workspace", wsDir,
"1 Retry|2 Load another|3 Create new|0 Cancel",
owner: this, expandedText: ex.ToString())) {
case 1: goto g1;
case 2: m = ZLoadAnotherWorkspace(); break;
case 3: m = ZLoadNewWorkspace(); break;
}
if(m != null) return m;
if(_model != null) return _model;
Environment.Exit(1);
}
oldModel?.Dispose();
Program.Model = _model = m;
//CONSIDER: unexpand path
if(wsDir != Program.Settings.workspace) {
if(Program.Settings.workspace != null) {
var ar = Program.Settings.recentWS ?? Array.Empty<string>();
int i = Array.IndexOf(ar, wsDir); if(i >= 0) ar = ar.RemoveAt(i);
Program.Settings.recentWS = ar.InsertAt(0, Program.Settings.workspace);
}
Program.Settings.workspace = wsDir;
}
Program.MainForm.ZSetTitle();
if(Program.Loaded >= EProgramState.LoadedWorkspace) {
ZOpenDocuments();
ZModel.RunStartupScripts();
}
return _model;
}
public async Task <IActionResult> UploadFile(IFormFile file)
{
var model = new FilesModel {
SystemFileNames = GetLocalFiles()
};
if (file != null && file.Length > 0)
{
string fileExtension = Path.GetExtension(file.FileName);
if (!file.ContentType.Equals("image/png") && !file.ContentType.Equals("image/jpeg"))
{
model.Message = "Please upload a valid file format!";
return(Json(model));
}
if (file.Length > _fileSizeLimit)
{
model.Message = "File should be less than 4MB in size!";
return(Json(model));
}
// extract only the filename and add a unique GUID
var fileName = Guid.NewGuid() + Path.GetFileName(file.FileName);
fileName = fileName.Replace("-", "_");
string path = Path.Combine(_webHostEnvironment.WebRootPath, "UploadedFiles/" + fileName);
if (model.SystemFileNames.Any(x => x.Substring(36) == file.FileName))
{
model.Message = "File already exists on server!";
return(Json(model));
}
else
{
try
{
using (var fileStream = new FileStream(path, FileMode.Create))
{
await file.CopyToAsync(fileStream);
}
model.SystemFileNames = GetLocalFiles();
return(Json(model));
}
catch (Exception e)
{
model.Message = $"Error occured whilst attempting to upload file!\nError details: {e.Message}";
return(Json(model));
}
}
}
else
{
model.Message = "Please select a file to upload!";
return(Json(model));
}
}
//this ctor is used when reading files.xml
FileNode(XmlReader x, FileNode parent, FilesModel model)
{
_model = model;
if (parent == null) //the root node
{
if (x.Name != "files")
{
throw new ArgumentException("XML root element name must be 'files'");
}
x["max-i"].ToInt(out uint u);
_model.MaxId = u;
}
else
{
_type = x.Name switch
{
"d" => EFileType.Folder,
"s" => EFileType.Script,
"c" => EFileType.Class,
"n" => EFileType.NotCodeFile,
_ => throw new ArgumentException("XML element name must be 'd', 's', 'c' or 'n'"),
};
uint id = 0, testScriptId = 0; string linkTarget = null, icon = null;
while (x.MoveToNextAttribute())
{
var v = x.Value;
switch (x.Name)
{
case "n": _name = v; break;
case "i": v.ToInt(out id); break;
case "f": _flags = (_Flags)v.ToInt(); break;
case "path": linkTarget = v; break;
case "icon": icon = v; break;
case "run": v.ToInt(out testScriptId); break;
}
}
if (_name.NE())
{
throw new ArgumentException("no 'n' attribute in XML");
}
_id = _model.AddGetId(this, id);
_CtorMisc(linkTarget);
if (icon != null && linkTarget == null)
{
_iconOrLinkTarget = icon;
}
if (testScriptId != 0)
{
_testScriptId = testScriptId;
}
}
}
public IActionResult GetFiles()
{
var model = new FilesModel
{
SystemFileNames = GetLocalFiles()
};
return(Json(model));
}
public override void CalcHashes(Hashes hashFlags, Validations validationFlags)
{
if (base.Data.Issues.HasFatal)
{
return;
}
if ((validationFlags & Validations.Exists) != 0)
{
Data.MissingCount = 0;
if (Data.Files.Items.Count != 1 || Data.Files.Items[0].Name != Data.IgnoredName)
{
for (int ix = 0; ix < Data.Files.Items.Count; ++ix)
{
FileItem item = Data.Files.Items[ix];
var name = item.Name;
if (Data.AllowNonFile && (name.StartsWith("http:") || name.StartsWith("https:")))
{
IssueModel.Add($"Ignoring URL '{name}'.", Severity.Trivia);
}
else
{
try
{
if (!System.IO.Path.IsPathRooted(name))
{
name = Data.Files.RootDir + System.IO.Path.DirectorySeparatorChar + name;
}
else if (Data.ForbidRooted)
{
IssueModel.Add($"File is rooted: '{item.Name}'.");
}
}
catch (ArgumentException ex)
{
IssueModel.Add($"Malformed file name '{name}': {ex.Message}");
FilesModel.SetIsFound(ix, false);
++Data.MissingCount;
continue;
}
// Exists doesn't seem to throw any exceptions, so no try/catch.
bool isFound = File.Exists(name);
FilesModel.SetIsFound(ix, isFound);
if (!isFound)
{
IssueModel.Add($"File '{item.Name}' not found.", Severity.Advisory);
++Data.MissingCount;
}
}
}
}
}
base.CalcHashes(hashFlags, validationFlags);
}
//this ctor is used when copying or importing a workspace.
//Deep-copies fields from f, except _model, _name, _id (generates new) and _testScriptId.
FileNode(FilesModel model, FileNode f, string name)
{
_model = model;
_name = name;
_type = f._type;
_state = f._state;
_flags = f._flags;
_iconOrLinkTarget = f._iconOrLinkTarget;
_id = _model.AddGetId(this);
}
public static XCompiled OfWorkspace(FilesModel m)
{
var cc = m.CompilerContext;
if (cc == null)
{
m.CompilerContext = cc = new XCompiled(m);
}
return(cc as XCompiled);
}
public static XCompiled OfCollection(FilesModel coll)
{
var cc = coll.CompilerContext;
if (cc == null)
{
coll.CompilerContext = cc = new XCompiled(coll);
}
return(cc as XCompiled);
}
public IActionResult Index(string partName)
{
var model = new FilesModel();
if (string.IsNullOrEmpty(partName))
{
model.ErrorMesage = "No part selected";
}
return(View(model));
}
public void Dispose()
{
_model = null;
App.Timer1s -= _Program_Timer1s;
//must be all saved or unchanged
Debug.Assert(_workspaceAfterS == 0);
Debug.Assert(_stateAfterS == 0);
Debug.Assert(_textAfterS == 0);
}
private void DownloadFile()
{
if (files.Name != String.Empty)
{
var model = _file.Load();
var files = new FilesModel();
files.Name = model.Name;
files.Progress = model.Progress;
ConvertList.Add(files);
}
}
//this ctor is used when importing items from files etc.
//name is filename with extension.
//sourcePath is used to get file text to detect type when !isFolder.
public FileNode(FilesModel model, string name, string sourcePath, bool isFolder, string linkTarget = null)
{
_model = model;
_type = isFolder ? EFileType.Folder : _DetectFileType(sourcePath);
_SetName(name);
_id = _model.AddGetId(this);
if (!linkTarget.NE() && !isFolder)
{
_linkTarget = linkTarget;
}
}
//this ctor is used when copying or importing a workspace.
//Deep-copies fields from f, except _model, _name, _id (generates new) and _testScriptId.
FileNode(FilesModel model, FileNode f, string name)
{
_model = model;
_SetName(name);
_type = f._type;
_state = f._state;
_flags = f._flags;
_linkTarget = f._linkTarget;
_icon = f.CustomIconName;
_id = _model.AddGetId(this);
}
public void Dispose()
{
_model = null;
Program.Timer1s -= _Program_Timer1s;
Program.MainForm.VisibleChanged -= _MainForm_VisibleChanged;
//must be all saved or unchanged
Debug.Assert(_workspaceAfterS == 0);
Debug.Assert(_stateAfterS == 0);
Debug.Assert(_textAfterS == 0);
}
public bool AddDE(FilesModel model)
{
if (DataContext.DigitalEvidences.Any(x => x.WID == model.WID))
{
var file = DataContext.DigitalEvidences.Where(x => x.WID == model.WID).FirstOrDefault();
file.FileData = model.FileData;
file.FileDataEnc = model.FileDataEnc;
file.FileName = model.FileName;
file.FileExtension = model.FileExtension;
}
return(DataContext.SaveChanges() > 0);
}
public IList <ValidationFailure> Validate(IFormFileCollection files)
{
FilesModelValidator validator = new FilesModelValidator();
FilesModel filesModel = new FilesModel();
foreach (var file in files)
{
filesModel.Files.Add(file);
}
ValidationResult result = validator.Validate(filesModel);
return(result.Errors);
}
