public async Task <ActionResult <UserFiles> > PostUserFile(UserFiles userFile)
{
_context.UserFiles.Add(userFile);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUserFiles", new { id = userFile.Id }, userFile));
}
public async Task <IActionResult> PutUserFile(int id, UserFiles userFile)
{
if (id != userFile.Id)
{
return(BadRequest());
}
_context.Entry(userFile).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserFileExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult Edit(UserFileVM model)
{
if (model.UserFile == null)
{
model.UserFile = new UserFile();
}
model.UploadFile = UserFiles.GetUploadFile(Request.Files[0]);
if (!FluentValidate(model))
{
return(RedirectBack());
}
UserFile userFile = null;
var courseTCs = model.CourseTCs;
var groupIds = model.GroupIds;
if (model.IsNew)
{
userFile = model.UserFile;
userFile.UserID = User.UserID;
userFile.SysFileName = model.UploadFile.Name;
var courses = GetCourses(model.CourseTCs);
var groups = GetGroups(model.GroupIds);
userFile.CourseFiles.AddRange(courses);
userFile.GroupFiles.AddRange(groups);
FileService.InsertAndSubmit(userFile);
}
else
{
var userFileId = model.UserFile.UserFileID;
userFile = FileService.GetByPK(userFileId);
if (userFile.UserID != User.UserID)
{
throw new NotOwnerException("File");
}
userFile.Update(model.UserFile, x => x.Name, x => x.Description);
if (!model.UploadFile.IsEmpty)
{
userFile.SysFileName = model.UploadFile.Name;
}
FileService.SubmitChanges();
ChangeCourses(userFileId, courseTCs);
ChangeGroups(userFileId, groupIds);
}
if (!model.UploadFile.IsEmpty)
{
UserFiles.DeleteFile(userFile.UserFileID);
var hpf = Request.Files[0];
hpf.SaveAs(UserFiles.GetUserFileSys(userFile.UserFileID,
model.UploadFile.Name));
}
return(RedirectToAction(() => List(1)));
}
public List <CourseFileVM> GetFiles(List <Tuple <string, string> > courseTrainerTCs)
{
CourseFileService.LoadWith(c => c.Load(x => x.UserFile).And <UserFile>(x => x.User));
var keys = courseTrainerTCs.Select(x => x.Item1 + "|" + x.Item2).ToList();
var files = CourseFileService.GetAll(x => keys.Contains(
x.Course_TC + "|" + x.UserFile.User.Employee_TC)).ToList()
.Select(x => new CourseFileVM(x.UserFile.Name, UserFiles.GetUserFileUrl(x.UserFile), x.Course_TC, x.UserFile.User.FullName, x.UserFile.User.Employee_TC));
var specFiles = GetSpecFiles(courseTrainerTCs.Select(x => x.Item1).ToList());
return(files.Concat(specFiles).ToList());
}
public async Task <string> NewUserFile(string userID, string md5Str, string fileName)
{
if (string.IsNullOrEmpty(userID) || string.IsNullOrEmpty(md5Str) || string.IsNullOrEmpty(fileName))
{
return(JsonConvert.SerializeObject(new RequestResult()
{
Flag = -1, Message = "参数错误"
}));
}
try
{
Files file = await _files.Find(Builders <Files> .Filter.Eq(q => q.MD5, md5Str)).FirstOrDefaultAsync();
//如果不存在相同MD5的文件，则新建文件
if (file == null)
{
file = new Files()
{
Id = new ObjectId(),
MD5 = md5Str,
Position = 0,
State = 0
};
_files.InsertOne(file);
}
UserFiles userFile = new UserFiles()
{
Id = new ObjectId(),
FileID = file.Id,
MD5 = md5Str,
FileName = fileName,
UserID = userID,
UploadTime = DateTime.Now
};
_userFiles.InsertOne(userFile);
return(JsonConvert.SerializeObject(new RequestResult()
{
Flag = 1, Message = "新建文件成功", Data = userFile.Id.ToString()
}));
}
catch (Exception)
{
return(JsonConvert.SerializeObject(new RequestResult()
{
Flag = -2, Message = "新建文件失败"
}));
}
}
public ActionResult UploadToDb(UserProfileViewModel model)
{
var userId = User.Identity.GetUserId();
bool userExists = db.Users.Any(x => x.Id == userId);
if (!userExists)
{
HttpNotFound();
}
if (model.UploadData.Files != null && model.UploadData.Files.Count > 0 && model.UploadData.Files[0] != null)
{
foreach (var file in model.UploadData.Files)
{
var fileName = Path.GetFileName(file.FileName);
bool fileExists = db.UserFileses.Any(x => x.FileName == fileName);
if (!fileExists && fileName.ToLower().EndsWith(".png") || fileName.ToLower().EndsWith(".jpg") || fileName.ToLower().EndsWith(".gif"))
{
var fileType = file.ContentType;
var fileContent = new byte[file.InputStream.Length];
file.InputStream.Read(fileContent, 0, fileContent.Length);
var userFileDb = db.UserFileses.FirstOrDefault(x => x.UserId == userId);
if (userFileDb != null)
{
userFileDb.FileName = fileName;
userFileDb.FileType = fileType;
userFileDb.UserFile = fileContent;
db.Entry(userFileDb).State = EntityState.Modified;
}
else
{
UserFiles uf = new UserFiles
{
Id = Guid.NewGuid().ToString(),
FileName = fileName,
FileType = fileType,
UserFile = fileContent,
UserId = userId
};
db.UserFileses.Add(uf);
}
db.SaveChanges();
}
else
{
ModelState.AddModelError("", "File exists or file format is not correct");
}
}
}
return(RedirectToAction("CustomChangePassword", "Manage"));
}
public ActionResult Delete(int fileID)
{
var file = FileService.GetByPK(fileID);
if (file.CourseFiles.Count > 0 || file.GroupFiles.Count > 0)
{
return(RedirectBack());
}
if (file.UserID != User.UserID)
{
throw new NotOwnerException("File");
}
FileService.DeleteAndSubmit(file);
UserFiles.DeleteFile(file.UserFileID);
return(RedirectBack());
}
public IActionResult UploadToDb(UploadDataViewModel model)
{
bool userExists = _context.Users.Where(x => x.UserName == model.UserName).Any();
if (!userExists)
{
User us = new User {
Id = Guid.NewGuid().ToString(), UserName = model.UserName
};
_context.Users.Add(us);
_context.SaveChanges();
}
if (model.Files != null && model.Files.Count > 0 && model.Files[0] != null)
{
foreach (var file in model.Files)
{
var fileName = Path.GetFileName(file.FileName);
bool fileExists = _context.UserFiles.Where(x => x.FileName == fileName).Any();
if (!fileExists)
{
var fileType = file.ContentType;
Stream stream = file.OpenReadStream();
BinaryReader reader = new BinaryReader(stream);
var fileContent = reader.ReadBytes((int)file.Length);
var userId = _context.Users.Where(x => x.UserName == model.UserName).Select(x => x.Id).FirstOrDefault();
UserFiles uf = new UserFiles
{
Id = Guid.NewGuid().ToString(),
FileName = fileName,
FileType = fileType,
UserFile = fileContent,
UserId = userId
};
_context.UserFiles.Add(uf);
_context.SaveChanges();
ModelState.AddModelError("", "File Uploaded.");
}
else
{
ModelState.AddModelError("", "File exists.");
}
}
}
return(RedirectToAction("UploadToDatabase"));
}
public async Task <IActionResult> Upload(UploadModel uploadModel)
{
var filePath = Path.Combine(environment.ContentRootPath, "uploads", uploadModel.File.FileName);
using (var fs = new FileStream(filePath, FileMode.Create))
{
await uploadModel.File.CopyToAsync(fs);
}
//byte[] bs = await System.IO.File.ReadAllBytesAsync(filePath);
//var ms = new MemoryStream(bs);
//await minioClient.PutObjectAsync(minioBucketName, uploadModel.File.FileName, ms, ms.Length, "application/octet-stream", null, null);
string extension = Path.GetExtension(filePath);
var userFile = new UserFiles
{
FileName = uploadModel.File.FileName,
Url = $"{minioURL}/{minioBucketName}",
InternalName = Guid.NewGuid() + extension,
};
await minioClient.PutObjectAsync(minioBucketName, userFile.InternalName, filePath, uploadModel.File.ContentType);
System.IO.File.Delete(filePath);
using (ApplicationDbContext context = new ApplicationDbContext())
{
context.UserFiles.Add(userFile);
context.SaveChanges();
}
TempData["message"] = "Archivo subido";
return(RedirectToAction("Index"));
}
public ActionResult Competition(CompetitionVM model)
{
model.UploadFile = UserFiles.GetUploadFile(Request.Files[0]);
if (FluentValidate(model))
{
var competition =
model.Competition
= CompetitionService.GetByPK(model.Competition.CompetitionID);
if (competition.UserCompetitions.All(uc => uc.UserID != User.UserID))
{
competition.UserCompetitions.Add(
new UserCompetition {
UserID = User.UserID
});
}
CompetitionService.SubmitChanges();
MailService.SendCompetitionRequest(model);
}
return(RedirectBack());
}
public async Task <IEnumerable <EventViewModel> > GetEventsWithCommentsAndPhotos(IQueryable <Event> query)
{
query = query.Include(e => e.User);
var result = await query.ToArrayAsync();
var eventsIds = result.Select(e => e.EventId);
var comments = await Comments.Where(c => c.EntityType == CommentEntityTypes.Event && eventsIds.Contains(c.EntityId))
.ToListAsync();
var photos = await Photos.Where(p => p.EntityType == PhotoEntityTypes.Event && eventsIds.Contains(p.EntityId))
.ToListAsync();
var photosMap = photos.ToDictionary(p => p.UserFileId);
var files = await UserFiles.Where(f => photosMap.Keys.Contains(f.UserFileId)).ToListAsync();
var photoViewModelMap = files
.Select(f => new { EntityId = photosMap[f.UserFileId].EntityId, ViewModel = new PhotoViewModel
{
Url = "/Uploads/" + f.FilePath,
UserId = f.UserId,
Likes = Enumerable.Empty <SimpleUserProfileViewModel>(),
LikesCount = 0,
AlbumId = 0
} })
.GroupBy(p => p.EntityId)
.ToDictionary(g => g.Key, g => g.Select(p => p.ViewModel).ToArray());
var commentViewModelMap = comments
.Select(c => Tuple.Create(c.EntityId, new CommentViewModel(c, null, null)))
.GroupBy(c => c.Item1)
.ToDictionary(g => g.Key, g => g.Select(t => t.Item2).ToArray());;
return(result.Select(e =>
{
return new EventViewModel(e, null,
commentViewModelMap.ContainsKey(e.EventId) ? commentViewModelMap[e.EventId] : null,
photoViewModelMap.ContainsKey(e.EventId) ? photoViewModelMap[e.EventId] : null,
null);
}));
}
public async Task <string> GetFileInfo(string id)
{
if (string.IsNullOrEmpty(id))
{
return(JsonConvert.SerializeObject(new RequestResult()
{
Flag = -1, Message = "参数错误"
}));
}
try
{
ObjectId _id = new ObjectId(id);
UserFiles userFile = await _userFiles.Find(Builders <UserFiles> .Filter.Eq(q => q.Id, _id)).FirstOrDefaultAsync();
Files file = await _files.Find(Builders <Files> .Filter.Eq(q => q.Id, userFile.FileID)).FirstOrDefaultAsync();
UserFileInfo userFileInfo = new UserFileInfo()
{
FileName = userFile.FileName,
MD5 = file.MD5,
Position = file.Position,
State = file.State
};
return(JsonConvert.SerializeObject(new RequestResult()
{
Flag = 1, Message = "新建文件成功", Data = userFileInfo
}));
}
catch (Exception)
{
return(JsonConvert.SerializeObject(new RequestResult()
{
Flag = -2, Message = "查询文件失败"
}));
}
}
public ActionResult AddLectureFile(decimal lectureId)
{
var file = Request.Files[0];
var errors = UserFiles.Validate(file, LectureFiles.size, LectureFiles.ext);
if (errors.Any())
{
return(Json(errors.JoinWith(Environment.NewLine)));
}
CheckLecturePermission(lectureId);
LectureFileService.EnableTracking();
var lectureFile = LectureFileService.FirstOrDefault(x => x.Lecture_ID == lectureId);
if (lectureFile == null)
{
lectureFile = new LectureFile();
lectureFile.Lecture_ID = lectureId;
LectureFileService.InsertAndSubmit(lectureFile);
}
file.SaveAs(LectureFiles.GetFile(lectureFile.Id).Path);
return(Json("ok"));
}
public static string UserFileLink(this HtmlHelper helper, UserFile userFile)
{
return(HtmlControls.Anchor(
UserFiles.GetUserFileUrl(userFile), userFile.Name).ToString());
}
protected override void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
if (Packages != null)
{
if (Packages.Count > 0)
{
foreach (SelectablePackage package in Packages)
{
package.Dispose();
}
}
Packages.Clear();
Packages = null;
}
if (Dependencies != null)
{
Dependency.ClearLogics(Dependencies);
Dependencies = null;
}
// TODO: dispose managed state (managed objects)
if (ParentCategory != null)
{
ParentCategory = null;
}
if (Parent != null)
{
Parent = null;
}
if (TopParent != null)
{
TopParent = null;
}
if (UserFiles != null)
{
foreach (UserFile file in UserFiles)
{
file.FilesSaved.Clear();
}
UserFiles.Clear();
UserFiles = null;
}
if (Medias != null)
{
foreach (Media media in Medias)
{
media.SelectablePackageParent = null;
}
Medias.Clear();
Medias = null;
}
if (UIComponent != null)
{
UIComponent.Package = null;
UIComponent = null;
}
if (ParentUIComponent != null)
{
ParentUIComponent.Package = null;
ParentUIComponent = null;
}
if (TopParentUIComponent != null)
{
TopParentUIComponent.Package = null;
TopParentUIComponent = null;
}
if (RelhaxWPFComboBoxList != null)
{
for (int i = 0; i < RelhaxWPFComboBoxList.Count(); i++)
{
if (RelhaxWPFComboBoxList[i] != null)
{
RelhaxWPFComboBoxList[i] = null;
}
}
RelhaxWPFComboBoxList = null;
}
if (ChildBorder != null)
{
ChildBorder = null;
}
if (ChildStackPanel != null)
{
ChildStackPanel = null;
}
if (ParentBorder != null)
{
ParentBorder = null;
}
if (ParentStackPanel != null)
{
ParentStackPanel = null;
}
if (ContentControl != null)
{
ContentControl = null;
}
if (ScrollViewer != null)
{
ScrollViewer = null;
}
if (TreeViewItem != null)
{
TreeViewItem = null;
}
if (TreeView != null)
{
TreeView = null;
}
if (TabIndex != null)
{
TabIndex = null;
}
}
// TODO: free unmanaged resources (unmanaged objects) and override finalizer
// TODO: set large fields to null
disposedValue = true;
}
base.Dispose(disposing);
}
