public void TestUserDeleteWithOneDocumentFromDatabase()
{
User user3 = new User
{
UserName = "******",
Password = "******",
Name = "name3",
LastName = "lastname3",
Email = "email3",
Administrator = true
};
Document document = new Document
{
Id = Guid.NewGuid(),
Title = "title",
Creator = user3,
CreationDate = DateTime.Now,
LastModification = DateTime.Now,
StyleClass = null
};
UserRepository.Add(user3);
DocumentRepository.Add(document);
bool existsAfterAddedDocument = DocumentRepository.Exists(document.Id);
UserRepository.Delete(user3.Email);
bool existsAfterDeletedUser = DocumentRepository.Exists(document.Id);
Assert.IsTrue(existsAfterAddedDocument);
Assert.IsFalse(existsAfterDeletedUser);
}
public int AddDocuments(List <Document> documents, int refrenceId, DocumentType refrenceType)
{
foreach (var document in documents)
{
document.RefrenceId = refrenceId;
document.RefrenceType = (int)refrenceType;
documentRepository.Add(document);
}
documentRepository.SaveChanges();
return(1);
}
public DocumentDm Add(DocumentDm documentDm)
{
var document = documentRepository.Add(new Document
{
DocumentId = documentDm.DocumentId,
DocumentName = documentDm.DocumentName,
DocumentPath = documentDm.DocumentPath,
DocumentVersion = documentDm.DocumentVersion,
DocumentOwnerId = documentDm.DocumentOwnerId,
CreatedOn = documentDm.CreatedOn,
ModifiedOn = documentDm.ModifiedOn
});
if (document == null)
{
return(null);
}
return(new DocumentDm
{
DocumentId = document.DocumentId,
DocumentName = document.DocumentName,
DocumentPath = document.DocumentPath,
DocumentVersion = document.DocumentVersion,
DocumentOwnerId = document.DocumentOwnerId,
CreatedOn = document.CreatedOn,
ModifiedOn = document.ModifiedOn
});
}
public ActionResult Upload(string name, HttpPostedFileBase upload)
{
if (!string.IsNullOrEmpty(name) &&
upload != null &&
int.TryParse(Membership.GetUser().ProviderUserKey.ToString(), out int userId))
{
string userDir = Server.MapPath($"~/Files/{userId}/");
if (!Directory.Exists(userDir))
{
Directory.CreateDirectory(userDir);
}
string fileName;
using (SHA1 sha = new SHA1CryptoServiceProvider())
fileName = BitConverter.ToString(sha.ComputeHash(Encoding.Unicode.GetBytes(name + DateTime.UtcNow.ToString())))
.Replace("-", string.Empty);
string filePath = userDir + fileName + Path.GetExtension(upload.FileName);
upload.SaveAs(filePath);
repository.Add(userId, name, filePath);
return(RedirectToAction("Index"));
}
return(View());
}
public VmGenericServiceResult Insert(VmDocumentItem vmItem)
{
VmGenericServiceResult result = new VmGenericServiceResult();
try
{
Com.BudgetMetal.DBEntities.Document entity = new Com.BudgetMetal.DBEntities.Document();
Copy <VmDocumentItem, Com.BudgetMetal.DBEntities.Document>(vmItem, entity);
entity.Company_Id = (int)vmItem.Company_Id;
entity.DocumentStatus_Id = (int)vmItem.DocumentStatus_Id;
entity.DocumentType_Id = (int)vmItem.DocumentType_Id;
if (entity.CreatedBy.IsNullOrEmpty())
{
entity.CreatedBy = entity.UpdatedBy = "System";
}
documentRepo.Add(entity);
documentRepo.Commit();
result.IsSuccess = true;
}
catch (Exception e)
{
result.IsSuccess = false;
result.Error = e;
}
return(result);
}
public async Task ProcessQueueMessage(
[QueueTrigger("task-savewebpage")] SavePageTask task,
[Blob("savedPages/{Id}_{datetime:yyyy-mm-dd}", FileAccess.Write)] Stream outputBlob,
string Id, DateTime datetime,
ILogger logger)
{
string targetHost = task.TaskOptions.Url;
switch (task.TaskOptions.HowToSave)
{
case SaveOption.ToPdf:
//TODO:
throw new NotImplementedException();
case SaveOption.ToHtml:
await SaveToHtml(outputBlob, targetHost);
break;
}
var log = new SavePageTriggeredTask
{
Id = task.Id,
TaskType = TaskType.SavePage,
TriggeredOn = DateTime.UtcNow,
BlobPath = $"savedPages/{Id}_{datetime:yyyy-mm-dd}"
};
await repository.Add(log);
}
public async Task <ActionResult <Document> > PostDocument(int companyId, DocumentInput document)
{
// Get user email id from claim.
UserInfo authoUserInfo = await UserInformation();
var documentDto = _mapper.Map <Document>(document);
if (_dataRepository.IsValidUser(authoUserInfo.Email, companyId))
{
try
{
documentDto.CompanyId = companyId;
documentDto.Author = authoUserInfo.Email;
_dataRepository.Add(documentDto);
}
catch (DbUpdateException)
{
if (_dataRepository.FindById(documentDto.Id) != null) //DocumentExists
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetDocument", new { id = documentDto.Id }, documentDto));
}
else
{
return(Unauthorized("Insufficient Privileges."));
}
}
public DocumentsModule()
{
this.RequiresAuthentication();
this.RequiresAnyClaim(new[] { "Users", "Admins" });
Get["/"] = param => { return(View["Views/Documents/Index.html"]); };
Get["/UserDocs/{id}"] = param => { return(GetUserDocs((Guid)param.id)); };
Get["/Add"] = param => { return(View["Views/Documents/Form.html"]); };
Post["/Add"] = param =>
{
string title = (string)param.Request.Form.Title;
string description = (string)param.Request.Form.Description;
Guid userId = (Guid)param.Request.Form.UserId;
using (IDocumentRepository ctx = Program.NinjectKernel.Get <IDocumentRepository>())
{
ctx.Add(new Document()
{
Title = title, Description = description
});
return(View["Views/Documents/Index.html"]);
}
};
}
public ActionResult Document(long id, int year, EditMode?mode, long?creatorID)
{
Document currentDocument = null;
long currentUserID = User.Identity.GetUserId <long>();
if (!creatorID.HasValue)//если обычный пользователь, то его id и есть id создателя
{
creatorID = currentUserID;
}
if (_documentRepository.IsDocumentAllowUser(mode, id, currentUserID))
{
currentDocument = _documentRepository.GetByYear(id, creatorID.Value, year);
if (currentDocument == null)
{
var documentType = _documentTypeRepository.GetById(id);
if (documentType != null)
{
var creator = _userRepository.GetById(creatorID.Value);
currentDocument = new Document
{
DocumentType = documentType,
DateCreated = DateTime.Now,
DateChanged = DateTime.Now,
Creator = creator
};
_documentRepository.Add(currentDocument);
}
else
{
return(HttpNotFound());
}
}
var documentConstructor = new DocumentConstructor
{
DocumentID = currentDocument.DocumentID,
MaxPoint = currentDocument.DocumentType.MaxPoint,
Name = currentDocument.DocumentType.Name,
Mode = mode,
CreatorID = creatorID.Value
};
return(View(documentConstructor));
}
return(HttpNotFound());
}
/// <summary>
/// Adds a document to the repository
/// </summary>
/// <param name="attachment"></param>
public void Add(AttachmentRequest attachment)
{
//valid attachment type.
if (ValidateAttachment(attachment, "application/pdf"))
{
_documentRepo.Add();
}
}
private async Task <bool> UploadDatabase(DocumentViewModel documentViewModel)
{
if (!ModelState.IsValid)
{
return(false);
}
await _documentRepository.Add(_mapper.Map <Document>(documentViewModel));
return(true);
}
public async Task <IActionResult> Upload(string englishDesc, string frenchDesc, IFormFile file)
{
var documentUpload = await documentRepository.GetDocuments();
// var doc = await
// i//f (poster == null)
// return NotFound();
if (file == null)
{
return(BadRequest("Null Document File"));
}
if (file.Length == 0)
{
return(BadRequest("Empty Document File"));
}
if (file.Length > documentSettings.MaxBytes)
{
return(BadRequest("Maximum file size exceeded"));
}
if (!documentSettings.IsSupported(file.FileName))
{
return(BadRequest("File type is invalid"));
}
var uploadsFolderPath = Path.Combine(host.WebRootPath, "documentUploads");
if (!Directory.Exists(uploadsFolderPath))
{
Directory.CreateDirectory(uploadsFolderPath);
}
var fileName = Guid.NewGuid().ToString() + Path.GetExtension(file.FileName);
var filePath = Path.Combine(uploadsFolderPath, fileName);
using (var stream = new FileStream(filePath, FileMode.Create))
{
await file.CopyToAsync(stream);
}
var document = new Document {
DocumentFileName = fileName, EnglishDesc = englishDesc, FrenchDesc = frenchDesc
};
// context.Documents.Add(document);
// context.Documents.Add(document);
documentRepository.Add(document);
await unitOfWork.CompleteAsync();
return(Ok(mapper.Map <Document, DocumentResource>(document)));
}
public ActionResult <ApiResponse <StudentProfileDto> > UpdateProfileDocuments(int id, StudentProfileDto profileDto)
{
var response = new ApiResponse <StudentProfileDto>();
StudentUpdateDto updateDto = _mapper.Map <StudentUpdateDto>(profileDto);
try
{
var stu = _studentRepository.Find(st => st.Id == id);
updateDto.Activated = stu.Activated;
updateDto.Active = stu.Active;
if (stu != null)
{
foreach (DocumentDto item in profileDto.Documents)
{
var doc = _documentRepository.Find(p => p.Id == item.Id);
if (doc == null)
{
//insert
Document document = _documentRepository.Add(_mapper.Map <Document>(item));
//response.Result = _mapper.Map<UserDto>(user);
}
else
{
//update
_mapper.Map(item, doc);
_documentRepository.Update(doc, item.Id);
}
}
var usr = _userRepository.Find(us => us.Id == updateDto.UserId);
_mapper.Map(profileDto.User, usr);
_userRepository.Update(usr, updateDto.UserId);
_mapper.Map(updateDto, stu);
_studentRepository.Update(stu, id);
response.Message = "Los cambios se guardaron correctamente";
response.Result = _mapper.Map <StudentProfileDto>(_studentRepository.Find(u => u.Id == id));
}
else
{
response.Success = false;
response.Message = "El estudiante no existe, favor de verificar";
}
}
catch (Exception ex)
{
response.Result = null;
response.Success = false;
response.Message = "Internal server error";
_logger.LogError($"Something went wrong: { ex.ToString() }");
return(StatusCode(500, response));
}
return(Ok(response));
}
public IActionResult Post(Document document)
{
if (_documentRepository.GetBy(x => x.Initials == document.Initials) != null)
{
return(Conflict());
}
_documentRepository.Add(document);
_documentRepository.Commit();
return(Created($"api/document/{document.Id}", document));
}
public async Task <ValueWrapper <bool> > Handle(CreateDocumentCommand request, CancellationToken cancellationToken)
{
var document = _documentFactory.Create(request.Filename, request.Bytes);
if (!document.IsSuccessful)
{
return(new ValueWrapper <bool>(false));
}
await _repository.Add(document.Value, cancellationToken);
return(new ValueWrapper <bool>(true));
}
public Guid Create(DocumentCreateParameters parameters)
{
var directoryPath = Path.GetDirectoryName(parameters.FileName);
var documentLevel = CreateDirectory(directoryPath, out var parentNode);
var existingDocument = _repository.Get(new DocumentSpecification
{
ParentNode = parentNode,
FileName = Path.GetFileName(parameters.FileName)
});
if (existingDocument != null)
{
throw new Exception($"File '{parameters.FileName}' already exists.");
}
var document = _factory.CreateFileDocument(parameters.FileName, documentLevel, parentNode,
parameters.DocumentSummary, parameters.DocumentData);
_repository.Add(document);
return(document.Id);
}
internal DocumentRequest PersistSourceFileInfoInDatabase(DocumentRequest request)
{
if (!request.IsSuccessed)
{
return(request);
}
if (request.Document == null || request.Document?.User == null)
{
request.IsSuccessed = false;
return(request);
}
_documentRepository.Add(request);
return(request);
}
public async Task Add(Document document)
{
try
{
documentRepository.Add(document);
await documentStore.Upload(document.Key.ToString(), document.Bytes);
}
catch
{
if (document.Id != 0)
{
documentRepository.Delete(document.Id);
}
throw;
}
}
public int SaveDocument(DocumentModel model)
{
if (model.FromScreen == "companyScreen")
{
model.IsCompanyAccessOnly = true;
}
else
{
model.IsCompanyAccessOnly = false;
}
model.CreatedDate = DateTime.Now;
var documentEntity = Mapper.DynamicMap <tblDocument>(model);
_documentRepository.Add(documentEntity);
return(_documentRepository.SaveChanges());
}
public ICommandResult Execute(AddDocumentCommand command)
{
try
{
var document = new Document();
AddDocument(command, document);
_documentRepository.Add(document);
_unitOfWork.Commit();
return(new SuccessResult(DocumentCommandMessage.DocumentAddedSuccsfully));
}
catch (Exception exception)
{
_logger.Error(exception.Message);
return(new FailureResult(DocumentCommandMessage.AddingDocumentFaild));
}
}
public async Task <IActionResult> Create(DocumentCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.Files != null && model.Files.Count > 0)
{
foreach (var file in model.Files)
{
//必须将图像上传到wwwroot中的images文件夹
//而要获取wwwroot文件夹的路径，我们需要注入 ASP.NET Core提供的HostingEnvironment服务
//通过HostingEnvironment服务去获取wwwroot文件夹的路径
string uploadsFolder = Path.Combine(_hostingEnvironment.WebRootPath, "files");
//为了确保文件名是唯一的，我们在文件名后附加一个新的GUID值和一个下划线
uniqueFileName = Guid.NewGuid().ToString() + "_" + file.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
//因为使用了非托管资源，所以需要手动进行释放
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
//使用IFormFile接口提供的CopyTo()方法将文件复制到wwwroot/images文件夹
file.CopyTo(fileStream);
}
var aa = await _userManager.GetUserAsync(HttpContext.User);
Document newDocument = new Document
{
ProjectID = model.ProjectID,
UploadDate = DateTime.Now,
FileSize = ((double)file.Length / 1048576).ToString("F1") + "MB",
Uploader = aa.UserName,
FilePath = uniqueFileName,
FileName = file.FileName
};
_documentRepository.Add(newDocument);
}
}
return(RedirectToAction("Details", new { id = model.ProjectID }));
}
return(View());
}
public async Task RequestAsync(Document document)
{
InterdepartRequest interdepartRequest;
if (Verification(document))
{
interdepartRequest = new InterdepartRequest(document.Id,
(int)InterdepartStatusType.Confirmed);
}
else
{
interdepartRequest = new InterdepartRequest(document.Id,
(int)InterdepartStatusType.Denied);
}
_documentRepository.Add(interdepartRequest);
await _documentRepository.SaveAllAsync();
}
public string Create(Document document)
{
unitOfWorkIsolatedFactory.With(
unitOfWork =>
{
retailSaleRepository.Enlist(unitOfWork);
document.Id = retailSaleRepository.GetNewId();
retailSaleRepository.Add(document);
unitOfWork.Complete();
retailSaleRepository.Delist();
}
);
return(string.Empty);
}
public static async Task ProcessQueueMessage([QueueTrigger("task-webping")] CloudQueueMessage message, ILogger logger)
{
var task = message.AsString.Deserialize <WebPingTask>();
string targetHost = task.TaskOptions.Url;
Ping pingSender = new Ping();
PingReply reply = pingSender.Send(targetHost, TIMEOUT);
var log = new WebPingTriggeredTask
{
Id = task.Id,
TaskType = TaskType.WebPing,
TriggeredOn = DateTime.UtcNow,
TaskResult = reply.Status == IPStatus.Success ? WebPingTaskResult.Ok : WebPingTaskResult.Error
};
repository = await DocumentRepository <WebPingTriggeredTask> .CreateAsync();
await repository.Add(log);
}
public ActionResult Upload(DocumentViewModel upload)
{
if (upload != null)
{
if (string.IsNullOrEmpty(upload.Name) == false && upload.Name.Length >= DocumentValidation.NameLength)
{
ModelState.AddModelError("Name", "Name is required");
return(View("Add", upload));
}
// Сохранение файла на диск
var ext = upload.Name.Contains(".") == false?
System.IO.Path.GetExtension(upload.Files[0].FileName) :
string.Empty;
var dirPath = Server.MapPath(userDirPath);
var saveTo = dirPath + upload.Name + ext;
var saveToRelative = userDirPath + upload.Name + ext;
var dirExist = System.IO.Directory.Exists(dirPath);
if (dirExist == false)
{
System.IO.Directory.CreateDirectory(dirPath);
}
upload.Files[0].SaveAs(saveTo);
// Сохранение файла в db
var document = new Document
{
Name = upload.Name + ext,
User = _userRepository.GetByLogin(User.Identity.Name),
Date = DateTime.Now.ToShortDateString(),
Link = saveToRelative
};
_documentRepository.Add(document);
_unitOfWork.SaveChanges();
}
return(RedirectToAction("Index"));
}
/// <summary>
/// The Save
/// </summary>
/// <param name="entity">The entity<see cref="Document"/></param>
/// <returns>The <see cref="ServiceResult"/></returns>
public ServiceResult Save(Document entity)
{
try
{
if (entity.Identifier == 0)
{
_repository.Add(entity);
}
else
{
_repository.Update(entity);
}
return(new ServiceResult(true));
}
catch (Exception ex)
{
return(new ServiceResult(false)
{
Error = ex.ToString()
});
}
}
public async Task <Document> UploadAsync(Stream stream, string fileName, long fileSize, string contentType)
{
var id = _idGenerator.NewId();
var blobName = $"{id}{Path.GetExtension(fileName)}";
await _blobStorageService.UploadFileAsync(blobName, stream);
int maxOrder = await this.GetMaxOrderAsync();
var newDocument = new Document
{
Id = id,
BlobName = blobName,
ContentType = contentType,
FileSize = fileSize,
Name = fileName,
Order = maxOrder + 1
};
_documentRepository.Add(newDocument);
await _documentRepository.SaveChangesAsync();
return(newDocument);
}
public async Task CreateDocument(Document document)
{
try
{
StatusEntity statusEntity = _statusRepository
.GetAll()
.AsNoTracking()
.FirstOrDefault(s => s.Name == "Approved");
document.Status = Mapper.Map <StatusEntity, Status>(statusEntity);
DocumentEntity documentEntity = Mapper.Map <Document, DocumentEntity>(document);
documentEntity.UsersWithApprove = documentEntity.Reviewers;
_documentRepository.Add(documentEntity);
await _documentRepository.CommitAsync();
}
catch (Exception e)
{
throw new DocManagerException("Error during document creation.", e.Message, e);
}
}
/// <summary>
/// Add / Update Document
/// </summary>
public Document AddUpdateDocument(Document documentRequest)
{
Document dbVersion = documentRepository.Find(documentRequest.DocumentId);
if (documentRepository.IsDocumentCodeExist(documentRequest))
{
throw new CaresException(Resources.BusinessPartner.Document.DocumentCodeDuplicationError);
}
if (dbVersion != null)
{
UpdateDocumentProperties(documentRequest, dbVersion);
documentRepository.Update(dbVersion);
}
else
{
dbVersion = new Document();
SetDocumentProperties(documentRequest, dbVersion);
documentRepository.Add(dbVersion);
}
documentRepository.SaveChanges();
// To Load the proprties
return(documentRepository.GetDocumentWithDetail(dbVersion.DocumentId));
}
public IHttpActionResult Upload()
{
int ProjectId = 0, AssignedToId = 0, UploadeById = 0, DocumentTypeId = 0;
string DocumentTitle = string.Empty, DocumentDescription = string.Empty;
DateTime EffectiveDate = DateTime.Now;
byte[] fileData = null;
var result = new HttpResponseMessage();
var httpContext = HttpContext.Current;
var httpRequest = httpContext.Request;
try
{
if (!string.IsNullOrEmpty(httpRequest.Form["ProjectId"]))
{
ProjectId = Convert.ToInt32(httpRequest.Form["ProjectId"]);
}
if (!string.IsNullOrEmpty(httpRequest.Form["AssignedToId"]))
{
AssignedToId = Convert.ToInt32(httpRequest.Form["AssignedToId"]);
}
if (!string.IsNullOrEmpty(httpRequest.Form["DocumentType"]))
{
DocumentTypeId = Convert.ToInt32(httpRequest.Form["DocumentTypeId"]);
}
if (!string.IsNullOrEmpty(httpRequest.Form["DocumentTitle"]))
{
DocumentTitle = httpRequest.Form["DocumentTitle"];
}
if (!string.IsNullOrEmpty(httpRequest.Form["UploadeById"]))
{
UploadeById = Convert.ToInt32(httpRequest.Form["UploadeById"]);
}
if (!string.IsNullOrEmpty(httpRequest.Form["DocumentDescription"]))
{
DocumentDescription = httpRequest.Form["DocumentDescription"];
}
var postedFile = httpRequest.Files[0];
string FileName = postedFile.FileName;
string contentType = postedFile.ContentType;
using (var binaryReader = new BinaryReader(postedFile.InputStream))
{
fileData = binaryReader.ReadBytes(postedFile.ContentLength);
var document = new Documents()
{
ProjectId = ProjectId,
DocumentTitle = DocumentTitle,
DocumentTypeId = DocumentTypeId,
AssignedToId = AssignedToId,
UploadedBy = UploadeById,
FileNameUrl = FileName,
CreatedOn = DateTime.Now,
DocumentBytes = fileData,
DocumentDescription = DocumentDescription
};
var docId = _documentService.Add(document);
if (docId > 0)
{
return(Ok("Uploaded successfully"));
}
else
{
return(Ok("Uploading failed"));
}
}
}
catch (Exception ex)
{
throw ex;
}
}