public override async Task <FilesReply> AddFolders(AddFoldersRequest request, ServerCallContext context)
{
var reply = new FilesReply();
var user = await _userService.GetUser(context.GetHttpContext());
if (user == null)
{
reply.Error = Error.NeedLogin;
return(reply);
}
if (!user.HasWritePermission())
{
reply.Error = Error.NoPermission;
return(reply);
}
File parent = null;
if (!string.IsNullOrWhiteSpace(request.ParentId))
{
if (!Guid.TryParse(request.ParentId, out var parentId))
{
reply.Error = Error.NoSuchEntity;
return(reply);
}
parent = await _service.All()
.FirstOrDefaultAsync(f => f.Id == parentId && f.Type == (int)FileType.Folder);
if (parent == null)
{
reply.Error = Error.NoSuchEntity;
return(reply);
}
}
var now = DateTime.Now;
var files = new List <File>();
var autoFix = request.AutoFix;
var existedFiles = autoFix ? new HashSet <string>() : null;
foreach (var f in request.Folders)
{
if (!AddFileFromNewFolderItem(existedFiles, files, f, parent, now, autoFix))
{
reply.Error = Error.InvalidArguments;
return(reply);
}
}
await _service.AddRange(files);
await ClearFolderVersionsCache();
reply.Files.AddRange(files.Select(Converter));
return(reply);
}
public override async Task <FilesReply> GetFiles(GetFilesRequest request, ServerCallContext context)
{
var reply = new FilesReply();
var items = _service.All().Where(f => f.Type == (int)FileType.Normal);
if (!string.IsNullOrWhiteSpace(request.ParentId))
{
if (!Guid.TryParse(request.ParentId, out var folderId))
{
reply.Error = Error.NoSuchEntity;
return(reply);
}
var folder = await _service.All().Where(k => k.Id == folderId && k.Type == (int)FileType.Folder)
.FirstOrDefaultAsync();
if (folder == null)
{
reply.Error = Error.NoSuchEntity;
return(reply);
}
var pathPrefix = folder.Path + PathSep;
items = items.Where(f => f.Path.StartsWith(pathPrefix));
}
var readPrivate = (await _userService.GetUser(context.GetHttpContext())).HasReadPrivatePermission();
if (!readPrivate)
{
items = items.Where(i => i.Private == (ulong)PrivateType.Public);
}
int?total = null;
if (request.Skip > 0)
{
total = await items.CountAsync();
items = items.Skip(request.Skip);
}
if (request.Take > 0)
{
items = items.Take(request.Take);
}
reply.Files.AddRange(await items
.Select(Selector)
.ToArrayAsync());
if (total.HasValue)
{
reply.Total = total.Value;
}
return(reply);
}
private async Task <FilesReply> GetFoldersInternal()
{
var reply = new FilesReply();
reply.Files.AddRange(await _service.All()
.Where(f => f.Type == (int)FileType.Folder)
.Select(Selector)
.ToArrayAsync());
return(reply);
}
public override async Task <FilesReply> GetFolders(Empty request, ServerCallContext context)
{
var version = await _cache.GetStringAsync(FoldersVersionCacheKey);
if (string.IsNullOrWhiteSpace(version) || !await _contentService.Existed(version))
{
var reply = await UpdateFolderVersionsCache();
return(reply);
}
else
{
var reply = new FilesReply {
Version = version
};
return(reply);
}
}
public override async Task <FilesReply> Query(QueryRequest request, ServerCallContext context)
{
var reply = new FilesReply();
var query = request.Query;
var parentPaths = default(FileParentId[]);
if (!string.IsNullOrWhiteSpace(query.Parent))
{
var indexedParentPath = query.Parent !;
parentPaths = await _service.All()
.Where(n => n.Type == (int)FileType.Folder && n.Path == indexedParentPath).Select(
n => new FileParentId {
Path = n.Path + PathSep
}
).ToArrayAsync();
if (!parentPaths.Any())
{
return(null);
}
}
Expression <Func <File, bool> > queryFunc;
try
{
queryFunc = _queryCompiler.Compile(parentPaths, query);
}
catch
{
reply.Error = Error.InvalidArguments;
return(reply);
}
var items = _service.All().Where(queryFunc);
items = await FilterPrivate(items, context);
var filter = request.Filter;
if (!string.IsNullOrWhiteSpace(filter))
{
filter = filter !.Trim();
items = items.Where(n =>
n.Path !.Contains(filter, StringComparison.CurrentCultureIgnoreCase));
}
var randomOrder = query.OrderBy == "Random";
int?total = null;
if (randomOrder)
{
total = await items.CountAsync();
var skip = total.Value - request.Take + 1;
if (skip > 0)
{
skip = new Random().Next() % skip;
items = items.Skip(skip);
}
if (request.Take > 0)
{
items = items.Take(request.Take);
}
}
else
{
if (!string.IsNullOrWhiteSpace(query.OrderBy))
{
Expression <Func <File, object> > orderBy = default;
switch (query.OrderBy)
{
case nameof(File.Name):
orderBy = node => node.Name !;
break;
case nameof(File.Created):
orderBy = node => node.Created;
break;
case nameof(File.Modified):
orderBy = node => node.Modified;
break;
case nameof(File.Published):
orderBy = node => node.Published;
break;
}
if (orderBy == null)
{
reply.Error = Error.InvalidArguments;
return(reply);
}
items = query.OrderByDesc ? items.OrderByDescending(orderBy) : items.OrderBy(orderBy);
}
if (request.Skip > 0 || request.Take > 0)
{
total = await items.CountAsync();
}
if (request.Skip > 0)
{
items = items.Skip(request.Skip);
}
if (request.Take > 0)
{
items = items.Take(request.Take);
}
}
var files = await items
.Select(Selector)
.ToArrayAsync();
reply.Files.AddRange(files);
if (total.HasValue)
{
reply.Total = total.Value;
}
return(reply);
}
