// this method removes desired files and folders
public bool RemoveFilesAndFolders(string userId, string[] foldersId, string[] filesId)
{
bool success = true;
foreach (var id in foldersId)
{
Folder folder = _database.GetRepository <Folder>().Get(id);
if (folder == null)
{
throw new StatusCodeException($"The folder with ID = {id} doesn't exists.", StatusCodes.Status404NotFound);
}
FolderVM vm = new FolderVM {
IsShared = folder.IsShared, OwnerId = folder.OwnerId
};
if (CheckEditAccess(vm, userId))
{
try
{
Directory.Delete(folder.Path, true);
Folder deletedFolder = _database.GetRepository <Folder>().Get(id);
RemoveChildrenFolders(deletedFolder);
_database.GetRepository <Folder>().Delete(id);
_database.Save();
}
catch
{
success = false;
}
}
}
foreach (var id in filesId)
{
DAL.Entities.File file = _database.GetRepository <DAL.Entities.File>().Get(id);
if (file == null)
{
throw new StatusCodeException($"The file with ID = {id} doesn't exists.", StatusCodes.Status404NotFound);
}
FileVM vm = new FileVM {
IsShared = file.IsShared, OwnerId = _database.GetRepository <Folder>().Get(file.FolderId).OwnerId
};
if (CheckEditAccess(vm, userId))
{
try
{
System.IO.File.Delete(file.Path);
_database.GetRepository <DAL.Entities.File>().Delete(id);
_database.Save();
}
catch
{
success = false;
}
}
}
return(success);
}
public void GetFileById_ReturnsFileVMWithCorrectContentType(string extension, string expected)
{
// arrange
File fileFromDB = new File
{
Id = "23",
Path = "C:\\User\\MyFolder\\file" + extension,
FolderId = "1",
IsShared = false
};
Folder folderFromDB = new Folder
{
Id = "1",
Path = "C:\\User\\MyFolder",
OwnerId = "User",
ParentFolderId = null,
IsShared = false
};
var mock = new Mock <IUnitOfWork>();
mock.Setup(a => a.GetRepository <File>().Get("23")).Returns(fileFromDB);
mock.Setup(a => a.GetRepository <Folder>().Get("1")).Returns(folderFromDB);
FileSystemService service = new FileSystemService(mock.Object, _mapper);
// act
FileVM fileVM = service.GetFileById("23");
string result = fileVM.ContentType;
// assert
Assert.AreEqual(expected, result);
}
public void renameFile(FileVM file)
{
var fi = new FileInfo(file.fullName);
var renameFile = Path.Combine(fi.Directory.FullName, file.renameFile);
MoveFile(file.fullName, renameFile);
}
public static string SaveFile(FileVM file)
{
try
{
string FileName = string.Empty,
ServerPath = "/Files/Images/";
//if (file.FileBase64.StartsWith("data:image/jpeg;base64,"))
// file.FileBase64 = file.FileBase64.Replace("data:image/jpeg;base64,", string.Empty);
//else if (file.FileBase64.StartsWith("data:image/png;base64,"))
// file.FileBase64 = file.FileBase64.Replace("data:image/png;base64,", string.Empty);
//else if (file.FileBase64.StartsWith("data:image/jpg;base64,"))
// file.FileBase64 = file.FileBase64.Replace("data:image/jpg;base64,", string.Empty);
if (string.IsNullOrEmpty(file.Extension))
{
file.Extension = ".jpg";
}
else if (!file.Extension.StartsWith("."))
{
file.Extension = "." + file.Extension;
}
FileName = "Tageer-Photo-" + Guid.NewGuid().ToString() + file.Extension;
System.IO.File.WriteAllBytes(HttpContext.Current.Server.MapPath(ServerPath) + FileName, Convert.FromBase64String(file.FileBase64));
return(ServerPath + FileName);
}
catch (Exception ex)
{
return(null);
}
}
// this method recursively compresses a folder structure
private void CompressFolder(Folder folder, string userId, ZipOutputStream zipStream, int folderOffset)
{
List <Folder> childFolders = _database.GetRepository <Folder>().Find(f => f.ParentFolderId == folder.Id).ToList();
List <DAL.Entities.File> childFiles = _database.GetRepository <DAL.Entities.File>().Find(f => f.FolderId == folder.Id).ToList();
foreach (var childFile in childFiles)
{
FileVM file = new FileVM {
IsShared = childFile.IsShared, OwnerId = _database.GetRepository <Folder>().Get(childFile.FolderId).OwnerId
};
if (CheckAccessToView(file, userId))
{
CompressFile(childFile, zipStream, folderOffset);
}
}
foreach (var childFolder in childFolders)
{
FolderVM vm = new FolderVM {
IsShared = childFolder.IsShared, OwnerId = childFolder.OwnerId
};
if (CheckAccessToView(vm, userId))
{
CompressFolder(childFolder, userId, zipStream, folderOffset);
}
}
}
/*
* Constructor allows mapping ViewModel on DataTransferObject
* to avoid repetition of code
*/
public FileDTO(FileVM vModel)
{
Id = vModel.Id;
DisplayName = vModel.DisplayName;
FileType = vModel.DisplayName;
FileName = vModel.FileName;
UploadTime = vModel.UploadTime;
HikeId = vModel.HikeId;
}
// GET: File
public ActionResult Index(int Page = 1)
{
FileVM fileVM = new FileVM();
fileVM.Paging = new ForPaging(Page);
fileVM.FileList = fileservice.GetFileList(fileVM.Paging);
return(View(fileVM));
}
public App()
{
MainVM = new MainVM();
MainPageVM = new MainPageVM();
AddingBuyerPageVM = new AddingBuyerPageVM();
AddingEquipmentPageVM = new AddingEquipmentPageVM();
BackButtonVM = new BackButtonVM();
BuyersResultPageVM = new BuyersResultPageVM();
EquipmentsResultPageVM = new EquipmentsResultPageVM();
FileVM = new FileVM();
SaveNotificationWindowVM = new SaveNotificationWindowVM();
}
// this action returns a single file to download
public IActionResult Download(string fileId)
{
FileVM file = _fileSystemService.GetFileById(fileId);
if (_fileSystemService.CheckAccessToView(file, User.FindFirstValue(ClaimTypes.NameIdentifier)))
{
return(PhysicalFile(file.Path, file.ContentType, file.Name));
}
else
{
throw new StatusCodeException($"You don't have access to file with ID = {fileId}.", StatusCodes.Status403Forbidden);
}
}
// this method checks the current user for editing access to the needed file
public bool CheckEditAccess(FileVM file, string currentId)
{
if (file == null)
{
throw new StatusCodeException("Unable to check access to the file.", StatusCodes.Status500InternalServerError);
}
if (file.OwnerId == currentId)
{
return(true);
}
return(false);
}
public List <FileVM> addFiles(DirectoryInfo di)
{
var filesVM = new List <FileVM>();
foreach (var f in di.GetFiles())
{
var ext = f.Extension.Replace(".", "");
var fileVM = new FileVM {
name = f.Name, fullName = f.FullName, dateCreated = f.CreationTime, Icon = $"/img/FileManager/FileIcons/{ext}.png"
};
filesVM.Add(fileVM);
}
return(filesVM);
}
// this action returns a single file to display
public IActionResult DisplayFile(string fileId)
{
FileVM file = _fileSystemService.GetFileById(fileId);
if (_fileSystemService.CheckAccessToView(file, User.FindFirstValue(ClaimTypes.NameIdentifier)))
{
Response.Headers.Add("Content-Disposition", "inline; filename=" + file.Name);
return(PhysicalFile(file.Path, file.ContentType));
}
else
{
throw new StatusCodeException($"You don't have access to file with ID = {fileId}.", StatusCodes.Status403Forbidden);
}
}
internal async void Upload_WithValidData_MustResultAsSpected()
{
var driveID = "driveID";
var fileID = "fileID";
var httpPath = $"drives/{driveID}/items/{driveID}!{fileID}/content";
var fileDTO = new DTOs.File { id = "fileID", name = "fileName", parentReference = new DTOs.DirectoryParent { path = "/parentFolder", id = "parentID" } };
var fileVM = new FileVM { ID = "fileID" };
var client = ClientBuilder.Create().With(httpPath, fileDTO).Build();
var service = new OneDriveService(client);
var value = await service.Upload($"{driveID}!{fileID}", new byte[] { });
Assert.NotNull(value);
Assert.Equal(fileVM.ID, value.ID);
}
public void CheckEditAccess_Returns500StatusCodeIfFileIsNull()
{
// arrange
string currUserId = "4321";
FileVM file = null;
var mock = new Mock <IUnitOfWork>();
FileSystemService service = new FileSystemService(mock.Object, _mapper);
int expected = 500;
// act
StatusCodeException ex = Assert.Throws <StatusCodeException>(() => service.CheckEditAccess(file, currUserId));
// assert
Assert.AreEqual(expected, ex.Data["Status code"]);
}
public void CheckAccessToView_ReturnsTrueIfFileIsShared()
{
// arrange
FileVM file = new FileVM {
IsShared = true, OwnerId = "1234"
};
var mock = new Mock <IUnitOfWork>();
FileSystemService service = new FileSystemService(mock.Object, _mapper);
string currUserId = "4321";
// act
bool result = service.CheckAccessToView(file, currUserId);
// assert
Assert.IsTrue(result);
}
public void CheckEditAccess_ReturnsFalseIfYouAreNotFileOwner()
{
// arrange
string currUserId = "4321";
FileVM file = new FileVM {
IsShared = true, OwnerId = "1234"
};
var mock = new Mock <IUnitOfWork>();
FileSystemService service = new FileSystemService(mock.Object, _mapper);
// act
bool result = service.CheckEditAccess(file, currUserId);
// assert
Assert.IsFalse(result);
}
// this method checks access to view the needed file by current user
public bool CheckAccessToView(FileVM file, string currentId)
{
if (file == null)
{
throw new StatusCodeException("Unable to check access to the file.", StatusCodes.Status500InternalServerError);
}
if (file.IsShared)
{
return(true);
}
else
{
return(CheckEditAccess(file, currentId));
}
}
internal async void Download_WithValidData_MustResultAsSpected()
{
var fileID = "driveID!fileID";
var expected = new FileVM {
ID = "fileID"
};
var client = ClientBuilder.Create().With("", expected).Build();
var service = new OneDriveService(client);
var valueStream = await service.Download(fileID);
var value = await System.Text.Json.JsonSerializer.DeserializeAsync <FileVM>(valueStream);
Assert.NotNull(value);
Assert.Equal(expected.ID, value.ID);
}
public void CheckAccessToView_ReturnsTrueIfFilerIsNonSharedButYouAreOwner()
{
// arrange
string currUserId = "4321";
FileVM file = new FileVM {
IsShared = false, OwnerId = currUserId
};
var mock = new Mock <IUnitOfWork>();
FileSystemService service = new FileSystemService(mock.Object, _mapper);
// act
bool result = service.CheckAccessToView(file, currUserId);
// assert
Assert.IsTrue(result);
}
// this method creates an archive and returns it for download
public MemoryStream CreateArchive(string currFolderId, string userId, string[] foldersId, string[] filesId)
{
Folder parentFolder = _database.GetRepository <Folder>().Get(currFolderId);
if (parentFolder == null)
{
throw new StatusCodeException($"Invalid current folder ID ({currFolderId}). Unable to create archive.",
StatusCodes.Status500InternalServerError);
}
ZipStrings.UseUnicode = true;
MemoryStream outputMemStream = new MemoryStream();
using (var zipStream = new ZipOutputStream(outputMemStream))
{
zipStream.SetLevel(0);
int folderOffset = parentFolder.Path.Length + (parentFolder.Path.EndsWith("\\") ? 0 : 1);
foreach (var id in filesId)
{
DAL.Entities.File file = _database.GetRepository <DAL.Entities.File>().Get(id);
FileVM vm = new FileVM {
IsShared = file.IsShared, OwnerId = _database.GetRepository <Folder>().Get(file.FolderId).OwnerId
};
if (CheckAccessToView(vm, userId))
{
CompressFile(file, zipStream, folderOffset);
}
}
foreach (var id in foldersId)
{
Folder folder = _database.GetRepository <Folder>().Get(id);
FolderVM vm = new FolderVM {
IsShared = folder.IsShared, OwnerId = folder.OwnerId
};
if (CheckAccessToView(vm, userId))
{
CompressFolder(folder, userId, zipStream, folderOffset);
}
}
zipStream.IsStreamOwner = false;
}
outputMemStream.Position = 0;
return(outputMemStream);
}
private async void PathNavigate(object parameter)
{
string path = parameter as string;
if (path == "Recovery")
{
RecVM ??= new RecoveryBoxViewModel();
MainContainerContent = RecVM;
await RecVM.LazyLoad();
}
else
{
FileVM ??= new FileListViewModel();
MainContainerContent = FileVM;
await FileVM.NavigateByPath("/" + path, true);
}
OnPropertyChanged(nameof(MainContainerContent));
}
public void GetFileById_ReturnsTheSameFileVM()
{
// arrange
File fileFromDB = new File
{
Id = "23",
Path = "C:\\User\\MyFolder\\file.txt",
FolderId = "1",
IsShared = false
};
Folder folderFromDB = new Folder
{
Id = "1",
Path = "C:\\User\\MyFolder",
OwnerId = "User",
ParentFolderId = null,
IsShared = false
};
var mock = new Mock <IUnitOfWork>();
mock.Setup(a => a.GetRepository <File>().Get("23")).Returns(fileFromDB);
mock.Setup(a => a.GetRepository <Folder>().Get("1")).Returns(folderFromDB);
FileSystemService service = new FileSystemService(mock.Object, _mapper);
FileVM expected = new FileVM
{
Id = "23",
Path = "C:\\User\\MyFolder\\file.txt",
OwnerId = "User",
Name = "file.txt",
ContentType = "text/plain",
FolderId = "1",
IsShared = false
};
// act
FileVM result = service.GetFileById("23");
// assert
Assert.AreEqual(expected, result);
}
// this method returns file by id
public FileVM GetFileById(string id)
{
FileVM file = _mapper.Map <DAL.Entities.File, FileVM>(_database.GetRepository <DAL.Entities.File>().Get(id));
if (file == null)
{
throw new StatusCodeException($"The file with ID = {id} doesn't exists.", StatusCodes.Status404NotFound);
}
file.OwnerId = _database.GetRepository <Folder>().Get(file.FolderId).OwnerId;
file.Name = ElementHelperClass.DefineFileName(file.Path);
var provider = new FileExtensionContentTypeProvider();
string contentType;
if (!provider.TryGetContentType(file.Name, out contentType))
{
contentType = "application/octet-stream";
}
file.ContentType = contentType;
return(file);
}
// this method returns all folders and files that are contained in the needed folder
public ICollection <ElementVM> GetElementsFromFolder(FolderVM folderVM, string userId)
{
if (folderVM == null)
{
throw new StatusCodeException("The needed folder doesn't exists.", StatusCodes.Status404NotFound);
}
DirectoryInfo dir = new DirectoryInfo(folderVM.Path);
FileInfo[] files;
DirectoryInfo[] dirs;
files = dir.GetFiles();
dirs = dir.GetDirectories();
List <ElementVM> models = new List <ElementVM>();
List <Folder> childFolders = _database.GetRepository <Folder>().Find(f => f.ParentFolderId == folderVM.Id).ToList();
List <DAL.Entities.File> childFiles = _database.GetRepository <DAL.Entities.File>().Find(f => f.FolderId == folderVM.Id).ToList();
foreach (var elem in dirs)
{
Folder folder = childFolders.Find(f => f.Path == elem.FullName);
if (folder != null)
{
if (CheckAccessToView(new FolderVM {
OwnerId = folder.OwnerId, IsShared = folder.IsShared
}, userId))
{
ElementVM model = new ElementVM
{
Id = folder.Id,
IsFolder = true,
Type = ElementVM.FileType.Folder,
ElemName = elem.Name,
LastModified = elem.LastWriteTime.ToShortDateString(),
Size = null,
IsShared = folder.IsShared
};
models.Add(model);
}
}
}
foreach (var elem in files)
{
DAL.Entities.File file = childFiles.Find(f => f.Path == elem.FullName);
if (file != null)
{
FileVM vm = new FileVM {
IsShared = file.IsShared, OwnerId = _database.GetRepository <Folder>().Get(file.FolderId).OwnerId
};
if (CheckAccessToView(vm, userId))
{
// for a more convenient display of file size, call the conversion function
Tuple <double, ElementVM.Unit> size = new Tuple <double, ElementVM.Unit>(elem.Length, ElementVM.Unit.B);
size = ElementHelperClass.Recount(size);
ElementVM.FileType type = ElementHelperClass.DefineFileType(elem.Extension);
ElementVM model = new ElementVM
{
Id = childFiles.Find(f => f.Path == elem.FullName).Id,
IsFolder = false,
Type = type,
ElemName = elem.Name,
LastModified = elem.LastWriteTime.ToShortDateString(),
Size = size,
IsShared = file.IsShared
};
models.Add(model);
}
}
}
return(models);
}
// this method changes access to view for the selected folders and files and returns folder id
public string ChangeAccess(string currFolderId, string userId, string[] foldersId, string[] filesId, bool openAccess)
{
Folder parent = _database.GetRepository <Folder>().Get(currFolderId);
if (parent == null)
{
throw new StatusCodeException($"The folder with ID = {currFolderId} doesn't exists.", StatusCodes.Status404NotFound);
}
FolderVM parentVM = new FolderVM {
IsShared = parent.IsShared, OwnerId = parent.OwnerId
};
if (CheckEditAccess(parentVM, userId))
{
string idForLink;
if (foldersId.Length == 1 && filesId.Length == 0)
{
idForLink = foldersId[0];
}
else
{
idForLink = currFolderId;
}
foreach (string id in filesId)
{
DAL.Entities.File file = _database.GetRepository <DAL.Entities.File>().Get(id);
if (file == null)
{
throw new StatusCodeException($"The file with ID = {id} doesn't exists.", StatusCodes.Status404NotFound);
}
FileVM vm = new FileVM {
IsShared = file.IsShared, OwnerId = _database.GetRepository <Folder>().Get(file.FolderId).OwnerId
};
if (CheckEditAccess(vm, userId))
{
file.IsShared = openAccess;
_database.GetRepository <DAL.Entities.File>().Update(file);
}
}
foreach (string id in foldersId)
{
Folder folder = _database.GetRepository <Folder>().Get(id);
if (folder == null)
{
throw new StatusCodeException($"The folder with ID = {id} doesn't exists.", StatusCodes.Status404NotFound);
}
FolderVM vm = new FolderVM {
IsShared = folder.IsShared, OwnerId = folder.OwnerId
};
if (CheckEditAccess(vm, userId))
{
folder.IsShared = openAccess;
_database.GetRepository <Folder>().Update(folder);
ChangeChildrenAccess(folder, openAccess);
}
}
_database.Save();
return(idForLink);
}
else
{
throw new StatusCodeException($"You don't have access to folder with ID = {currFolderId}.", StatusCodes.Status403Forbidden);
}
}
//[Route("[action]")]
//public async Task<ActionResult<FileVM>> PostImage(FileVM UploadedImage)
public async Task <IActionResult> PostImage(FileVM UploadedImage)
{
byte[] bytes = Convert.FromBase64String(UploadedImage.FileAsBase64);
var credentials = new BasicAWSCredentials("AKIAYFOXPUFXRIBLXF4O", "kt30oEKBt35RZRxXD6rLRd2uxITL0aYX24qFXnox");
var config = new AmazonS3Config
{
RegionEndpoint = Amazon.RegionEndpoint.USEast1
};
var image = new Image();
using (var client = new AmazonS3Client(credentials, config))
{
using (var newMemoryStream = new MemoryStream(bytes))
{
//file.CopyTo(newMemoryStream);
var uploadRequest = new TransferUtilityUploadRequest
{
InputStream = newMemoryStream,
Key = UploadedImage.FileName,
BucketName = "quickquoteitem",
CannedACL = S3CannedACL.PublicRead
};
var fileTransferUtility = new TransferUtility(client);
try
{
await fileTransferUtility.UploadAsync(uploadRequest);
}
catch (Exception err)
{
throw err;
}
}
}
AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient(credentials, Amazon.RegionEndpoint.USEast1);
DetectLabelsRequest detectlabelsRequest = new DetectLabelsRequest()
{
Image = new Image()
{
S3Object = new S3Object()
{
Name = UploadedImage.FileName,
Bucket = "quickquoteitem"
},
},
MaxLabels = 10,
MinConfidence = 75F
};
try
{
var Labels = new List <LabelVM>();
DetectLabelsResponse detectLabelsResponse =
await rekognitionClient.DetectLabelsAsync(detectlabelsRequest);
//Console.WriteLine("Detected labels for " + photo);
foreach (Label label in detectLabelsResponse.Labels)
{
var item = new LabelVM();
item.LabelName = label.Name;
item.LabelConfidence = label.Confidence.ToString();
Labels.Add(item);
}
return(Ok(Labels));
//Console.WriteLine("{0}: {1}", label.Name, label.Confidence);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
//return CreatedAtAction("GetQuote", new { id = quote.QuoteID }, quote);
return(Ok());
}
public FileItemControl()
{
this.InitializeComponent();
vm = DataContext as FileVM;
}
public IHttpActionResult PostFile(FileVM file)
{
return(Json(FileService.SaveFile(file)));
}
