public IHttpActionResult AddDocument(AddDocumentViewModel model)
{
if (model.Document == null)
{
return(BadRequest("Object is null"));
}
if (model.DocFile == null)
{
return(BadRequest("Provided Doc File is null"));
}
var employee = _employeeService.GetById(model.EmployeeId);
if (employee == null)
{
return(NotFound());
}
// save the document file to the server /Content/docs directory
string filePath = Utility.Utility.SaveToDisk(HttpContext.Current, model.DocFile, "~/Content/docs");
// saving only the image name
model.Document.DocumentPath = filePath;
_documentService.Add(model.Document, model.DocTypeId, model.EmployeeId);
return(Ok());
}
//Create new document
public IActionResult Create(AddDocumentViewModel model)
{
User user = _context.Users.Include(u => u.Projects).ToList(). //Get User from DB
Where(u => u.UserName == HttpContext.User.Identity.Name).FirstOrDefault();
Project project = _context.Projects.Include(u => u.Documents).ToList(). //Get Project from DB
Where(i => i.Id == model.projectId).FirstOrDefault();
Document document = new Document();
Comment comment = new Comment();
if (model.Document != null)
{
byte[] data = null;
using (var reader = new BinaryReader(model.Document.OpenReadStream())) //Open stream
{
data = reader.ReadBytes((int)model.Document.Length);
}
document = new Document {
Project = project, Name = model.Name, ProjectId = project.Id, Subject = data, Format = new FileFormatGetter().GetFileFormat(model)
};
comment = new Comment {
Text = model.Comment, Document = document, DocumentId = document.Id, User = user, Date = DateTime.Now
};
}
_context.Comments.Add(comment); //add new records to tables
_context.Documents.Add(document);
_context.SaveChanges(); //save db
return(RedirectToAction("Index", "Home"));
}
public ActionResult AddInvolvedOrganizations(string projectId)
{
var project = RepositoryContext.Current.GetOne <Project>(p => p._id == projectId);
if (project == null)
{
return(HttpNotFound("проект не найден"));
}
var model = new AddDocumentViewModel();
model.PorjectId = projectId;
model.Documents = new List <string>();
ViewBag.DocumentList =
RepositoryContext.Current.All <TaskTemplate>(t => t.Type == TaskTypes.InvolvedOrganiztion)
.Select(template => template.Title)
.ToList();
if (project.Tasks != null)
{
foreach (var document in project.Tasks.Where(t => t.Type == TaskTypes.InvolvedOrganiztion))
{
model.Documents.Add(document.Title);
}
}
return(View(model));
}
/// <summary>
/// Edit document
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel> EditDocumentAsync(AddDocumentViewModel model)
{
var result = new ResultModel();
if (model == null)
{
result.Errors.Add(new ErrorModel {
Message = "entity == null"
});
result.IsSuccess = false;
return(result);
}
var document = await _documentContext.Documents.FirstOrDefaultAsync(x => x.Id == model.DocumentId);
if (document == null)
{
result.Errors.Add(new ErrorModel {
Message = "document not fount"
});
result.IsSuccess = false;
return(result);
}
document.DocumentCode = model.DocumentCode;
document.Title = model.Title;
document.Description = model.Description;
document.Group = model.Group;
document.DocumentTypeId = model.DocumentTypeId;
_documentContext.Documents.Update(document);
result = await _documentContext.PushAsync();
return(result);
}
public async Task <JsonResult> Create(AddDocumentViewModel model)
{
var result = new ResultModel();
result = await _documentService.AddDocumentAsync(model);
return(Json(result));
}
/// <summary>
/// Add new document
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel> AddDocumentAsync(AddDocumentViewModel model)
{
var result = new ResultModel();
if (model == null || model.Title.IsNull() || model.DocumentCategoryId.Equals(Guid.Empty))
{
result.Errors.Add(new ErrorModel {
Message = "entity is not valid"
});
result.IsSuccess = false;
return(result);
}
var userRequest = await _userManager.GetCurrentUserAsync();
if (!userRequest.IsSuccess)
{
result.Errors.Add(new ErrorModel {
Message = "User not found"
});
result.IsSuccess = false;
return(result);
}
var user = userRequest.Result;
var newDocument = new Document
{
DocumentCategoryId = model.DocumentCategoryId,
DocumentTypeId = model.DocumentTypeId,
DocumentCode = model.DocumentCode,
Title = model.Title,
Description = model.Description,
Group = model.Group,
UserId = user.Id
};
await _documentContext.Documents.AddAsync(newDocument);
result = await _documentContext.PushAsync();
if (result.IsSuccess)
{
result = await AddNewDocumentVersionAsync(new AddNewVersionDocumentViewModel
{
Comments = model.Comments,
DocumentId = newDocument.Id,
File = model.File,
IsMajorVersion = true,
Url = model.Url,
});
}
result.Result = newDocument.Id;
return(result);
}
public Document Add(AddDocumentViewModel addData)
{
var document = new Document {
Alias = addData.Alias,
Title = addData.Title,
Content = "# " + addData.Title
};
return(_documentService.Add(document, addData.ParentId));
}
public void AddDocument_DocumentIsNull_ReturnBadRequestObjcet()
{
AddDocumentViewModel model = new AddDocumentViewModel
{
Document = null
};
var result = _controller.AddDocument(model);
Assert.That(result, Is.TypeOf <BadRequestErrorMessageResult>());
}
public void AddDocument_EmployeeIsNull_ReturnNotFound()
{
AddDocumentViewModel model = new AddDocumentViewModel
{
Document = new hr_system.Models.Document(),
EmployeeId = 89012843
};
var result = _controller.AddDocument(model);
Assert.That(result, Is.TypeOf <NotFoundResult>());
}
public async Task <IActionResult> Create()
{
var documentAddModel = new AddDocumentViewModel();
documentAddModel.ListDocumentTypes = (await _documentTypeService.GetAllDocumentTypeAsync()).Result.ToList().Select(x => new SelectListItem
{
Text = x.Name,
Value = x.Id.ToString()
});
return(View(documentAddModel));
}
public void AddDocument_DocFileIsNull_ReturnBadRequest()
{
AddDocumentViewModel model = new AddDocumentViewModel
{
Document = new hr_system.Models.Document(),
EmployeeId = 89012843,
DocFile = null
};
var result = _controller.AddDocument(model);
Assert.That(result, Is.TypeOf <BadRequestErrorMessageResult>());
}
public ActionResult Add(AddDocumentViewModel model)
{
if (ModelState.IsValid)
{
Document d = new Document(model.Name, DateTime.Now.Date, User.Identity.Name, TagsToString(model.Tags));
documentsRepository.AddDocument(d);
return(RedirectToAction("List"));
}
else
{
ModelState.AddModelError("", "Данные введены некорректно");
return(View());
}
}
public ActionResult AddInvolvedOrganizations(AddDocumentViewModel model)
{
ViewBag.DocumentList =
RepositoryContext.Current.All <TaskTemplate>(t => t.Type == TaskTypes.InvolvedOrganiztion)
.Select(template => template.Title)
.ToList();
if (!ModelState.IsValid)
{
return(View(model));
}
var project = RepositoryContext.Current.GetOne <Project>(p => p._id == model.PorjectId);
IQueryable <TaskTemplate> templates =
RepositoryContext.Current.All <TaskTemplate>(t => model.Documents.Contains(t.Title));
var tasks = new List <ProjectTask>();
foreach (var template in templates)
{
tasks.Add(new ProjectTask
{
_id = ObjectId.GenerateNewId().ToString(),
ProjectId = model.PorjectId,
Body = template.Body,
Title = template.Title,
Type = template.Type,
Step = ProjectWorkflow.State.InvolvedOrganizations,
CreationTime = DateTime.Now
});
}
if (project.Tasks == null)
{
project.Tasks = new List <ProjectTask>();
}
project.Tasks.RemoveAll(p => p.Type == TaskTypes.InvolvedOrganiztion);
project.Tasks.AddRange(tasks);
RepositoryContext.Current.Update(project);
try
{
ProjectStateManager.StateManagerFactory(project, User.Identity.Name,
Roles.GetRolesForUser(User.Identity.Name)).DocumentUpdate();
}
catch (Exception)
{
}
return(RedirectToAction("Project", "BaseProject", new { id = model.PorjectId }));
}
public async Task <JsonResult> Edit(AddDocumentViewModel model)
{
var result = new ResultModel();
if (!ModelState.IsValid)
{
result.IsSuccess = false;
result.Result = model;
return(Json(result));
}
result = await _documentService.EditDocumentAsync(model);
return(Json(result));
}
protected override IList <Category> ResolveCore(AddDocumentViewModel source)
{
if (source.CategoryList != null && source.CategoryList.Count > 0)
{
// transform the category Guid list to a list of category objects
var categoryEntitiyList = source.CategoryList.Select(x => new Category()
{
Id = x
}).ToList();
return(categoryEntitiyList);
}
else
{
return(new List <Category>());
}
}
public ActionResult AddDocumentTask(AddDocumentViewModel model)
{
ViewBag.DocumentList =
RepositoryContext.Current.All <TaskTemplate>(t => t.Step == ProjectWorkflow.State.DocumentSending)
.Select(template => template.Title)
.ToList();
if (!ModelState.IsValid)
{
return(View(model));
}
var project = RepositoryContext.Current.GetOne <Project>(p => p._id == model.PorjectId);
IQueryable <TaskTemplate> templates =
RepositoryContext.Current.All <TaskTemplate>(t => model.Documents.Contains(t.Title));
var tasks = new List <ProjectTask>();
foreach (var template in templates)
{
tasks.Add(new ProjectTask
{
_id = ObjectId.GenerateNewId().ToString(),
ProjectId = model.PorjectId,
Body = template.Body,
Title = template.Title,
Type = template.Type,
Step = template.Step,
CreationTime = DateTime.Now
});
}
if (project.Tasks == null)
{
project.Tasks = new List <ProjectTask>();
}
project.Tasks.RemoveAll(p => p.Step == ProjectWorkflow.State.DocumentSending);
project.Tasks.AddRange(tasks);
RepositoryContext.Current.Update(project);
return(RedirectToAction("Project", "BaseProject", new { id = model.PorjectId }));
}
protected override IList <Keyword> ResolveCore(AddDocumentViewModel source)
{
if (source.KeywordsList != null && source.KeywordsList.Count > 0)
{
// transfrom the list name to a list of objects
return((from s in source.KeywordsList
select s.Trim()
into trimedName
where !string.IsNullOrWhiteSpace(trimedName)
select new Keyword()
{
Name = trimedName
}).ToList());
}
else
{
return(new List <Keyword>());
}
}
public ActionResult Create(AddDocumentViewModel addViewModel, HttpPostedFileBase file = null)
{
if (ModelState.IsValid)
{
var doc = new Document()
{
DocumentUploadDateTime = DateTime.Now,
DocumentDescription = addViewModel.Description,
DocumentContent = new byte[file.ContentLength],
DocumentName = addViewModel.Title
};
file.InputStream.Read(doc.DocumentContent, 0, file.ContentLength);
db.Documents.Add(doc);
db.SaveChanges();
return(RedirectToAction("Admin"));
}
else
{
return(View());
}
}
public AddDocumentPage()
{
_addDocumentViewModel = new AddDocumentViewModel();
InitializeComponent();
BindingContext = _addDocumentViewModel;
}
public AddDocumentView()
{
InitializeComponent();
DataContext = new AddDocumentViewModel();
}
public AddDocumentView(AddDocumentViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
}
