public async Task <IActionResult> OnPostClear(Guid id)
{
ResourceAbstract resourceToClear = await _databaseContext.ResourceAbstracts
.FirstOrDefaultAsync(_ => _.ID == id);
resourceToClear.NumberOfReports = 0;
await _databaseContext.SaveChangesAsync();
return(RedirectToPage("AdminPanel"));
}
public async Task <StatusCode <ShareEveryoneOut> > ShareForEveryone(Guid resourceId, string username, string password, DateTime?expirationDateTime, int?downloadLimit)
{
string userId = (await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
ResourceAbstract resourceAbstract = await _databaseContext.ResourceAbstracts.FirstOrDefaultAsync(_ => _.ID == resourceId && _.OwnerID == userId);
if (resourceAbstract == null)
{
return(new StatusCode <ShareEveryoneOut>(StatusCodes.Status404NotFound, StatusMessages.FILE_NOT_FOUND));
}
ShareEveryone shareEveryone = await _databaseContext.ShareEveryones.FirstOrDefaultAsync(_ => _.ResourceID == resourceId && _.OwnerID == userId);
if (shareEveryone == null)
{
shareEveryone = new ShareEveryone
{
CreatedDateTime = DateTime.Now,
DownloadLimit = downloadLimit,
ExpirationDateTime = expirationDateTime,
ResourceID = resourceId,
OwnerID = userId,
Password = password,
Token = GenerateToken()
};
await _databaseContext.ShareEveryones.AddAsync(shareEveryone);
resourceAbstract.IsShared = true;
resourceAbstract.IsSharedForEveryone = true;
}
else
{
shareEveryone.DownloadLimit = downloadLimit;
shareEveryone.ExpirationDateTime = expirationDateTime;
shareEveryone.Password = password;
shareEveryone.LastModifiedDateTime = DateTime.Now;
}
if (shareEveryone.ExpirationDateTime.HasValue)
{
shareEveryone.ExpirationDateTime = shareEveryone.ExpirationDateTime.Value.AddHours(1);
}
await _databaseContext.SaveChangesAsync();
ShareEveryoneOut result = _mapper.Map <ShareEveryoneOut>(shareEveryone);
return(new StatusCode <ShareEveryoneOut>(StatusCodes.Status200OK, result));
}
public async Task <bool> ReportResource(Guid resourceId)
{
ResourceAbstract resource = await _databaseContext.ResourceAbstracts
.FirstOrDefaultAsync(_ => _.IsShared && _.ID == resourceId);
if (resource == null)
{
return(false);
}
++resource.NumberOfReports;
await _databaseContext.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> OnPostDelete(Guid id)
{
List <ShareAbstract> sharesToDelete = await _databaseContext.ShareAbstracts
.Where(_ => _.ResourceID == id)
.ToListAsync();
_databaseContext.ShareAbstracts
.RemoveRange(sharesToDelete);
ResourceAbstract resourceToDelete = await _databaseContext.ResourceAbstracts
.FirstOrDefaultAsync(_ => _.ID == id);
_databaseContext.ResourceAbstracts
.Remove(resourceToDelete);
await _databaseContext.SaveChangesAsync();
return(RedirectToPage("AdminPanel"));
}
public async Task <bool> CancelSharingForEveryone(Guid resourceId, string username)
{
string userId = (await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
ResourceAbstract fileAbstract = await _databaseContext.ResourceAbstracts.FirstOrDefaultAsync(_ => _.ID == resourceId && _.OwnerID == userId);
ShareEveryone shareEveryone = await _databaseContext.ShareEveryones.FirstOrDefaultAsync(_ => _.ResourceID == resourceId && _.OwnerID == userId);
if (fileAbstract == null || shareEveryone == null)
{
return(false);
}
_databaseContext.ShareEveryones.Remove(shareEveryone);
fileAbstract.IsSharedForEveryone = false;
fileAbstract.IsShared = fileAbstract.IsSharedForUsers;
await _databaseContext.SaveChangesAsync();
return(!fileAbstract.IsSharedForEveryone &&
!(await _databaseContext.ShareEveryones.AnyAsync(_ => _.ResourceID == resourceId && _.OwnerID == userId)));
}
public async Task <StatusCode <FileOut> > PatchByIdAndFilePatchAndUser(Guid id, JsonPatchDocument <FilePatch> jsonPatchDocument, string username)
{
string userId = (await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
ResourceAbstract fileAbstract = await _databaseContext.ResourceAbstracts.FirstOrDefaultAsync(_ => _.ID == id && _.OwnerID == userId);
if (fileAbstract == null)
{
return(new StatusCode <FileOut>(StatusCodes.Status404NotFound, StatusMessages.FILE_NOT_FOUND));
}
JsonPatchDocument <ResourceAbstract> fileAbstractPatch = _mapper.Map <JsonPatchDocument <ResourceAbstract> >(jsonPatchDocument);
fileAbstractPatch.ApplyTo(fileAbstract);
fileAbstract.LastModifiedDateTime = DateTime.Now;
await _databaseContext.SaveChangesAsync();
FileOut result = _mapper.Map <FileOut>(await _databaseContext.ResourceAbstracts.FirstOrDefaultAsync(_ => _.ID == id));
return(new StatusCode <FileOut>(StatusCodes.Status200OK, result));
}
public async Task <StatusCode <ShareForUserOut> > ShareForUser(ShareForUserIn shareForUserIn, string ownerUsername)
{
if (shareForUserIn.Username == ownerUsername)
{
return(new StatusCode <ShareForUserOut>(StatusCodes.Status404NotFound, $"You cannot share your own file with yourself"));
}
if (!await _databaseContext.Users.AnyAsync(_ => _.UserName == shareForUserIn.Username))
{
return(new StatusCode <ShareForUserOut>(StatusCodes.Status404NotFound, $"User {shareForUserIn.Username} not found"));
}
string ownerId = (await _databaseContext.Users
.FirstOrDefaultAsync(_ => _.UserName == ownerUsername))?
.Id;
ResourceAbstract resourceAbstract = await _databaseContext.ResourceAbstracts
.Include(_ => _.ShareForUsers)
.FirstOrDefaultAsync(_ => _.ID == shareForUserIn.ResourceId && _.OwnerID == ownerId);
if (resourceAbstract == null)
{
return(new StatusCode <ShareForUserOut>(StatusCodes.Status404NotFound, $"Resource {shareForUserIn.ResourceId} not found"));
}
string userId = (await _databaseContext.Users
.FirstOrDefaultAsync(_ => _.UserName == shareForUserIn.Username))?
.Id;
ShareForUser shareForUser = await _databaseContext.ShareForUsers
.FirstOrDefaultAsync(_ => _.OwnerID == ownerId && _.ResourceID == shareForUserIn.ResourceId && _.SharedForUserID == userId);
if (shareForUser == null)
{
shareForUser = new ShareForUser
{
CreatedDateTime = DateTime.Now,
ExpirationDateTime = shareForUserIn.ExpirationDateTime,
OwnerID = ownerId,
ResourceID = shareForUserIn.ResourceId,
SharedForUserID = userId
};
resourceAbstract.IsShared = true;
resourceAbstract.IsSharedForUsers = true;
resourceAbstract.ShareForUsers.Add(shareForUser);
}
else
{
shareForUser.LastModifiedDateTime = DateTime.Now;
shareForUser.ExpirationDateTime = shareForUserIn.ExpirationDateTime;
}
if (shareForUser.ExpirationDateTime.HasValue)
{
shareForUser.ExpirationDateTime = shareForUser.ExpirationDateTime.Value.AddHours(1);
}
await _databaseContext.SaveChangesAsync();
ShareForUserOut result = _mapper.Map <ShareForUserOut>(shareForUser);
return(new StatusCode <ShareForUserOut>(StatusCodes.Status200OK, result));
}
public async Task <StatusCode <DirectoryOut> > DeleteByIdAndUser(Guid id, string username)
{
ApplicationUser user = await _databaseContext.Users.FirstOrDefaultAsync(_ => _.UserName == username);
string userId = user?.Id;
ResourceAbstract fileAbstractToDelete = await _databaseContext.ResourceAbstracts
.FirstOrDefaultAsync(_ => _.ID == id && _.OwnerID == userId);
if (fileAbstractToDelete == null)
{
return(new StatusCode <DirectoryOut>(StatusCodes.Status404NotFound, StatusMessages.FILE_NOT_FOUND));
}
List <ShareAbstract> shares = await _databaseContext.ShareAbstracts
.Where(_ => _.ResourceID == fileAbstractToDelete.ID)
.ToListAsync();
_databaseContext.ShareAbstracts.RemoveRange(shares);
Guid?parentDirectoryId = fileAbstractToDelete.ParentDirectoryID;
if (fileAbstractToDelete is File)
{
File fileToDelete = fileAbstractToDelete as File;
System.IO.File.Delete(fileToDelete.Path);
if (System.IO.File.Exists(fileToDelete.Path))
{
return(new StatusCode <DirectoryOut>(StatusCodes.Status400BadRequest, StatusMessages.CANNOT_DELETE_FILE));
}
user.UsedDiskSpace -= fileToDelete.FileSizeBytes;
_databaseContext.Files.Remove(fileToDelete);
await _databaseContext.SaveChangesAsync();
}
else if (fileAbstractToDelete is Directory)
{
Directory directoryToDelete = await _databaseContext.Directories
.Include(_ => _.Files)
.FirstOrDefaultAsync(_ => _.ID == fileAbstractToDelete.ID && _.OwnerID == userId);
foreach (ResourceAbstract fileAbstract in directoryToDelete.Files.ToList())
{
await DeleteByIdAndUser(fileAbstract.ID, username);
}
_databaseContext.Directories.Remove(directoryToDelete);
await _databaseContext.SaveChangesAsync();
}
DirectoryOut parentDirectoryOutResult = null;
if (parentDirectoryId != null)
{
Directory directoryToReturn = await _databaseContext.Directories
.Include(_ => _.Files)
.Include(_ => _.ParentDirectory)
.FirstOrDefaultAsync(_ => _.ID == parentDirectoryId && _.OwnerID == userId);
parentDirectoryOutResult = _mapper.Map <DirectoryOut>(directoryToReturn);
}
else
{
List <ResourceAbstract> files = await _databaseContext.ResourceAbstracts
.Include(_ => _.ParentDirectory)
.Where(_ => _.ParentDirectoryID == null && _.OwnerID == userId)
.ToListAsync();
parentDirectoryOutResult = new DirectoryOut
{
ID = null,
Files = _mapper.Map <List <FileOut> >(files),
ResourceType = ResourceType.DIRECTORY,
Name = "root",
ParentDirectoryID = null,
ParentDirectoryName = null
};
}
return(new StatusCode <DirectoryOut>(StatusCodes.Status200OK, StatusMessages.FILE_DELETED, parentDirectoryOutResult));
}
public async Task <StatusCode <FileOut> > GetByIdAndUser(Guid id, string username)
{
string userId = (await _databaseContext.Users
.FirstOrDefaultAsync(_ => _.UserName == username))?.Id;
ResourceAbstract fileAbstract = await _databaseContext.ResourceAbstracts
.Include(_ => _.ParentDirectory)
.Include(_ => _.ShareEveryone)
.Include(_ => _.ShareForUsers)
.FirstOrDefaultAsync(_ => _.ID == id && (_.ResourceType == ResourceType.FILE || _.ResourceType == ResourceType.DIRECTORY));
if (fileAbstract == null)
{
return(new StatusCode <FileOut>(StatusCodes.Status404NotFound, $"File {id} not found"));
}
if (fileAbstract.OwnerID == userId)
{
FileOut result = _mapper.Map <FileOut>(fileAbstract);
if (fileAbstract is File)
{
result.FileSizeBytes = (fileAbstract as File).FileSizeBytes;
}
return(new StatusCode <FileOut>(StatusCodes.Status200OK, result));
}
if (fileAbstract.IsShared)
{
if (fileAbstract.IsSharedForEveryone)
{
ShareEveryone share = fileAbstract.ShareEveryone;
if (share != null)
{
if ((share.ExpirationDateTime == null ||
(share.ExpirationDateTime != null && share.ExpirationDateTime >= DateTime.Now)) &&
(share.DownloadLimit == null ||
(share.DownloadLimit != null && share.DownloadLimit > 0)))
{
FileOut result = _mapper.Map <FileOut>(fileAbstract);
if (fileAbstract is File)
{
result.FileSizeBytes = (fileAbstract as File).FileSizeBytes;
}
return(new StatusCode <FileOut>(StatusCodes.Status200OK, result));
}
}
}
else if (fileAbstract.IsSharedForUsers)
{
ShareForUser share = fileAbstract.ShareForUsers.FirstOrDefault(_ => _.SharedForUserID == userId && _.ResourceID == id);
if (share != null)
{
if (share.ExpirationDateTime == null ||
(share.ExpirationDateTime != null && share.ExpirationDateTime >= DateTime.Now))
{
FileOut result = _mapper.Map <FileOut>(fileAbstract);
if (fileAbstract is File)
{
result.FileSizeBytes = (fileAbstract as File).FileSizeBytes;
}
return(new StatusCode <FileOut>(StatusCodes.Status200OK, result));
}
}
}
}
return(new StatusCode <FileOut>(StatusCodes.Status404NotFound, $"File {id} not found"));
}
