public async Task <User> GetOrCreateUserAsync(string name)
{
var dbUser = await _context.Users.FirstOrDefaultAsync(p => p.Name == name);
if (dbUser == null)
{
dbUser = new User {
Name = name
};
_context.Users.Add(dbUser);
await _context.SaveChangesAsync();
}
return(dbUser);
}
public async Task <IFileResponse> DeleteDocumentAsync(int documentId)
{
try
{
var file = await _appDbContext.Files.FirstOrDefaultAsync(k => k.Id == documentId);
if (file == null)
{
return(new FileResponse(ClientMessageConstant.FileNotFound, HttpStatusCode.NotFound));
}
var fileDb = await _fileDbContext.FileDB.FirstOrDefaultAsync(k => k.Id == file.IdGuid);
if (fileDb == null)
{
return(new FileResponse(ClientMessageConstant.FileNotFound, HttpStatusCode.NotFound));
}
_fileDbContext.FileDB.Remove(fileDb);
await _fileDbContext.SaveChangesAsync();
_appDbContext.Files.Remove(file);
await _appDbContext.SaveChangesAsync();
return(new FileResponse(true, "Success", HttpStatusCode.Accepted));
}
catch (Exception e)
{
return(new FileResponse(e));
}
}
public async Task <IActionResult> Post([FromRoute] string connectionId, [FromBody] FileViewModel model)
{
var fileId = Guid.NewGuid();
var filename = Path.Combine(_configuration.GetValue <string>("RootDirectory"),
Path.GetRandomFileName()).Replace("\\", "/");
_dbContext.Files.Add(new FileMetadata
{
Id = fileId,
RawName = model.Filename,
Filename = filename,
Size = model.Size,
CreatedAt = DateTime.Now,
ContentType = model.ContentType,
State = FileState.Uploading,
Hash = model.Hash,
FilledSize = 0
});
await _dbContext.SaveChangesAsync(HttpContext.RequestAborted);
_mergingQueue.QueueWorkItem(new Services.FileInfo
{
FileId = fileId,
Size = model.Size,
Filename = filename
});
_memoryCache.Set(fileId, connectionId);
return(Created($"/files/{fileId}", new { Id = fileId }));
}
public async static void SaveFileToDatabase(File fileModel)
{
using (var context = new FileDbContext())
{
context.Files.Add(fileModel);
await context.SaveChangesAsync();
}
}
public async static void SaveStatusToDatabase(Status status)
{
using (var context = new FileDbContext())
{
context.Statuses.Add(status);
await context.SaveChangesAsync();
}
}
public async Task <List <Data> > CreateData(List <Data> data)
{
await _context.Data.AddRangeAsync(data);
await _context.SaveChangesAsync();
return(data);
}
/// <summary>
/// 创建文件
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <bool> AddFileAsync(AddFileDto dto)
{
await fileDbContext.Files.AddAsync(new Models.File
{
Id = GuidEx.NewGuid(),
DirectoryId = long.Parse(dto.DirectoryId),
UserId = userId,
OriginFileName = dto.FileName,
UploadFilePath = dto.Link,
Size = dto.Size,
ModifyDatetime = DateTimeOffset.Now,
CreateTime = DateTimeOffset.Now,
IsDeleted = false
});
int rows = await fileDbContext.SaveChangesAsync();
return(rows > 0);
}
private async Task UploadIntoFileDbAsync(Guid id, IFormFile formFile)
{
var fileDb = new FileDB()
{
Id = id,
Bytes = formFile.OpenReadStream().ToBytes()
};
await _fileDbContext.FileDB.AddAsync(fileDb);
await _fileDbContext.SaveChangesAsync();
}
/// <summary>
/// 创建文件夹
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task AddDirectoryAsync(AddDirectoryDto dto)
{
var id = GuidEx.NewGuid();
if (!long.TryParse(dto.PId, out long pid))
{
pid = 0;
}
string path = null;
var parent = await fileDbContext.FileDirectories.FirstOrDefaultAsync(e => e.UserId == userId && e.Id == pid);
if (parent == null)
{
//pid = 0
path = $"0|{id}";
}
else
{
path = $"{parent.Path}|{id}";
}
FileDirectory fileDirectory = new FileDirectory
{
Id = id,
CreateTime = DateTimeOffset.Now,
Name = dto.Name,
PId = pid,
Path = path,
UserId = userId,
IsDeleted = false,
ModifyDatetime = DateTimeOffset.Now
};
await fileDbContext.FileDirectories.AddAsync(fileDirectory);
await fileDbContext.SaveChangesAsync();
}
public async Task <FileReference> InsertFileReferenceAsync(FileReference fileReference)
{
using (var db = new FileDbContext())
{
if (await db.FileReferences.AnyAsync(p => p.AuthorId == fileReference.Author.Id && p.Name == fileReference.Name))
{
throw new FileReferenceAlreadyExistsException();
}
db.FileReferences.Add(fileReference);
db.Entry(fileReference.Author).State = EntityState.Unchanged;
var saved = await db.SaveChangesAsync();
}
return(fileReference);
}
public async Task <IActionResult> UploadProfileImage(string userId, ByteArrayPart request)
{
var profileImageInDb = await _context.ProfileImageFiles.Where(x => x.UserId == userId).FirstOrDefaultAsync();
if (profileImageInDb != null)
{
return(BadRequest("User already has a profile picture"));
}
var guidId = Guid.NewGuid();
var uploadImage = new ProfileImageFile()
{
Id = guidId.ToString(),
UserId = userId,
ProfileImageBytes = request.Value,
FileName = request.FileName,
ContentType = request.ContentType
};
_context.ProfileImageFiles.Add(uploadImage);
await _context.SaveChangesAsync();
return(Ok());
}
/// <summary>
/// 创建文件共享
/// </summary>
/// <returns></returns>
public async Task <FileShared> CreateSharedFileAsync(CreateSharedDto dto)
{
long fileId = long.Parse(dto.FileId);
//先判断文件存不存在
var exist = await fileDbContext.Files.AnyAsync(e => e.Id == fileId && e.UserId == userId);
if (exist)
{
var sharedId = GuidEx.NewGuid();
string code = string.Empty;
if (dto.HadCode)
{
code = (new Random()).Next(1000, 9999).ToString();
}
if (dto.Days <= 0)
{
dto.Days = 3650;
}
fileDbContext.FileShareds.Add(new FileShared
{
Id = sharedId,
Code = code,
EndDateTime = DateTimeOffset.Now.AddDays(dto.Days),
FileId = fileId
});
int row = await fileDbContext.SaveChangesAsync();
return(await GetFileSharedAsync(new GetFileSharedDto { Code = code, SharedId = sharedId }));
}
return(null);
}
public async Task <IdentityResult> SaveFileAsync()
{
try
{
await _fileContext.SaveChangesAsync();
return(IdentityResult.Success);
}
catch (Exception e)
{
return(IdentityResult.Failed(new IdentityError()
{
Code = "Error", Description = e.Message
}));
}
}
public async Task <User> GetOrCreateUserAsync(string name)
{
using (var db = new FileDbContext())
{
var dbUser = await db.Users.FirstOrDefaultAsync(p => p.Name == name);
if (dbUser == null)
{
dbUser = new User {
Name = name
};
db.Users.Add(dbUser);
await db.SaveChangesAsync();
}
return(dbUser);
}
}
private async Task SaveFile(CriteriaClaimRequestView model, UserInfo userInfo)
{
foreach (var formFile in model.AttachmentFile)
{
if (formFile == null)
{
continue;
}
var data = new File()
{
IdGuid = Guid.NewGuid(),
CorrelationId = model.CorrelationId,
SizeMb = GetFileSize(formFile.Length),
Name = formFile.FileName,
ProviderName = "SqlProvider",
Created = DateTime.UtcNow,
MimeType = formFile.ContentType,
Modified = DateTime.UtcNow,
CreatedBy = userInfo.Email,
ModifiedBy = userInfo.Email
};
await _appDbContext.Files.AddAsync(data);
await _appDbContext.SaveChangesAsync();
var fileDb = new FileDB()
{
Id = data.IdGuid,
Bytes = StreamToBytes(formFile.OpenReadStream())
};
await _fileDbContext.FileDB.AddAsync(fileDb);
await _fileDbContext.SaveChangesAsync();
}
}
