public ActionResult CGCDocumentEdit(int id = 0)
{
DocumentEditViewModel viewModel = new DocumentEditViewModel();
CropGermplasmCommitteeDocument document = null;
try
{
if (id > 0)
{
document = _cgcRepository.GetDocument(id);
viewModel.CommitteeID = document.Committee.ID;
viewModel.CommitteeName = document.Committee.Name;
viewModel.Title = document.Title;
viewModel.CategoryCode = document.CategoryCode;
viewModel.CategoryTitle = document.CategoryTitle;
viewModel.Year = document.DocumentYear;
viewModel.ID = document.ID;
viewModel.URL = document.URL;
}
}
catch (Exception ex)
{
Log.Error(ex, ex.Message);
string actionName = this.ControllerContext.RouteData.Values["action"].ToString();
string controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
string errorText = "<label>Controller:</label>" + controllerName;
errorText = errorText + "<br><label>Action:</label>" + actionName;
errorText = errorText + "<br><label>Details:</label>" + ex.TargetSite + ex.Message;
Session["ERROR_TEXT"] = errorText;
return(RedirectToAction("InternalServerError", "Error"));
}
return(View("~/Views/Admin/CGC/Edit.cshtml", viewModel));
}
public ActionResult Create(DocumentEditViewModel model)
{
if (ModelState.IsValid)
{
model.document.version = 1;
model.document.createUser = WebSecurity.CurrentUserId;
model.document.statusID = 1;
model.document.EDT = 1;
model.document.companyID = (int)db.Users.Find(WebSecurity.CurrentUserId).companyID;
Helper.updateObjectFields(model.document);
if (model.selectedRules != null)
{
foreach (int ruleId in model.selectedRules)
{
model.document.Rules.Add(db.Rules.Find(ruleId));
}
}
db.Documents.Add(model.document);
db.SaveChanges();
return(RedirectToAction("Edit", new { id = model.document.ID }));
}
ViewBag.allRules = Helper.GetRulesSelect(db);
return(View(model));
}
public async Task <ActionResult> Edit(Document document)
{
if (DoesCodeAlreadyExist(document))
{
ModelState.AddModelError("CatalogCode", DocumentStrings.CodeAlreadyExists);
}
if (ModelState.IsValid)
{
foreach (var t in document.Translations)
{
db.UpdateTranslation(t);
}
db.Update(document);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
var model = new DocumentEditViewModel(document);
await model.PopulateDropDownLists(db.Set <Author>(), db.Set <Collection>());
return(View(model));
}
// GET: BackOffice/Documents/Create
public async Task <ActionResult> Create(int?collectionId, int?authorId)
{
var doc = new Document();
doc.Translations.Add(new DocumentTranslation
{
LanguageCode = LanguageDefinitions.DefaultLanguage
});
// Check for a collection.
if (collectionId != null && db.Set <Collection>().Any(c => c.Id == collectionId))
{
doc.CatalogCode = CodeGenerator.SuggestDocumentCode(collectionId.Value);
doc.CollectionId = collectionId.Value;
}
// Check for an author.
if (authorId != null && db.Set <Author>().Any(a => a.Id == authorId))
{
doc.AuthorId = authorId.Value;
}
var model = new DocumentEditViewModel(doc);
await model.PopulateDropDownLists(db.Set <Author>(), db.Set <Collection>());
return(View(model));
}
public ActionResult Create(long id)
{
var folder = folderRepository.Load(id);
var model = new DocumentEditViewModel {
Folder = folder
};
return(View(model));
}
public ActionResult Create()
{
DocumentEditViewModel model = new DocumentEditViewModel();
model.document.documentTypeID = (
from d in db.DocumentTypes
where d.name == "Manual"
select d.ID
).FirstOrDefault();
ViewBag.allRules = Helper.GetRulesSelect(db);
return(View(model));
}
public ActionResult Edit(int id = 0)
{
DocumentEditViewModel model = new DocumentEditViewModel();
model.document = db.Documents.Include(d => d.Rules).Include(d => d.Status)
.Include(d => d.Document1).Include(d => d.Document2).FirstOrDefault(d => d.ID == id);
ViewBag.allRules = Helper.GetRulesSelect(db);
model.selectedRules = (from r in model.document.Rules
select r.ID).ToArray();
return(View(model));
}
/// <summary>
///
/// </summary>
/// <param name="viewModel"></param>
/// <returns></returns>
public async Task EditByViewModelAsync(DocumentEditViewModel viewModel)
{
if (viewModel == null)
{
throw new ArgumentNullException(nameof(viewModel));
}
var documet = await FindByIdAsync(viewModel.Id);
_mapper.Map(viewModel, documet);
await _unitOfWork.SaveAllChangesAsync(auditUserId : _httpContextManager.CurrentUserId());
}
public ActionResult Edit(DocumentEditViewModel model, string submitVal)
{
if (ModelState.IsValid)
{
Helper.updateObjectFields(model.document);
model.document.Rules.Clear();
model.document.updateDate = DateTime.Now;
model.document.companyID = (int)db.Users.Find(WebSecurity.CurrentUserId).companyID;
if (submitVal == "nueva version")
{
HistDocument d = new HistDocument(model.document);
d.changeReason = model.changeReason;
db.HistDocuments.Add(d);
db.SaveChanges();
model.document.version++;
}
db.Entry(model.document).State = EntityState.Modified;
db.SaveChanges();
Document document = db.Documents.Include(d => d.Rules)
.FirstOrDefault(d => d.ID == model.document.ID);
document.Rules.Clear();
db.Entry(document).State = EntityState.Modified;
db.SaveChanges();
if (model.selectedRules != null)
{
foreach (int ruleId in model.selectedRules)
{
document.Rules.Add(db.Rules.Find(ruleId));
}
}
db.Entry(document).State = EntityState.Modified;
db.SaveChanges();
if (submitVal == "Capitulo")
{
return(RedirectToAction("CreateChild", new { id = model.document.ID }));
}
else
{
return(RedirectToAction("Index"));
}
}
ViewBag.allRules = Helper.GetRulesSelect(db);
return(View(model));
}
public async Task <IActionResult> DocumentEdit(DocumentEditViewModel model)
{
var items = model.Items.ToDictionary(it => it.IdDocumentTemplateItem, it => it.Value);
var user = await userManager.GetUserAsync(HttpContext.User);
unitOfWork.LogsService.Add(user.Id, $"Editare document: {model.IdDocument}");
await unitOfWork.DocumentsService.EditDocument(model.IdDocument, user.Id, items);
await unitOfWork.Commit();
TempData[Notifications.DOCUMENT_EDIT] = "Documentul a fost editat cu success.";
return(RedirectToAction(nameof(DocumentDetails), new { id = model.IdDocument }));
}
public ActionResult Edit(int id = 0)
{
DocumentEditViewModel model = new DocumentEditViewModel();
int?companyID = db.Users.Find(WebSecurity.CurrentUserId).companyID;
model.document = db.Documents.Where(dep => dep.companyID == companyID).Include(d => d.Rules)
.Include(d => d.Status).Include(d => d.Document1)
.Include(d => d.Document2).FirstOrDefault(d => d.ID == id);
ViewBag.allRules = Helper.GetRulesSelect(db);
model.selectedRules = (from r in model.document.Rules
select r.ID).ToArray();
return(View(model));
}
public ActionResult Edit(Guid documentID)
{
ScansRepository scansRepository = new ScansRepository();
ScanBrowser scans = ScanBrowserFactory.Create();
DocumentEditViewModel viewModel = new DocumentEditViewModel()
{
AllowDocumentDisplay = true,
Details = _repository.GetDocumentDetails(documentID),
Categories = _dictRepository.GetCategories().ToList(),
Senders = _dictRepository.GetSenders().ToList(),
Types2 = _dictRepository.GetTypes2().ToList(),
ScanSelectorModel = new ScanSelectorViewModel()
{
AvailableScans = scansRepository.GetAvailableScans().ToList(),
AllScansCount = scans.GetScansCount(true),
KnownScansCount = scans.GetScansCount(false)
}
};
#region Check if user can display this document
if (viewModel.Details.Document == null)
{
viewModel.AllowDocumentDisplay = false;
viewModel.DenyMessage = "Dokument nie istnieje.";
}
else if (!AppContext.GetCIDs().Contains(viewModel.Details.Document.ClientID))
{
viewModel.AllowDocumentDisplay = false;
viewModel.DenyMessage = "Nie masz uprawnieñ do tego dokumentu.";
}
else
{
if (viewModel.Details.Document.ClientID != AppContext.GetCID())
{
AppContext.ChangeClient(viewModel.Details.Document.ClientID);
}
}
#endregion
if (viewModel.Details.InfoTypeOne != null && viewModel.Details.InfoTypeOne.CategoryID.HasValue)
{
viewModel.Types = _dictRepository.GetTypes(viewModel.Details.InfoTypeOne.CategoryID.Value).ToList();
}
return(View(viewModel));
}
public ActionResult Edit(DocumentEditViewModel documents)
{
if (ModelState.IsValid)
{
Documents doc = db.Documents.Single(d => d.DocId == documents.Doc.DocId);
doc.PublishDate = documents.Doc.PublishDate;
doc.EventId = documents.SelectedEventValue;
doc.Status = documents.SelectedStatusValue;
doc.Type = documents.SelectedTypeValue;
doc.GroupId = documents.SelectedGroupValue;
doc.Title = documents.Doc.Title;
doc.isPublic = documents.Doc.isPublic;
db.SaveChanges();
return(RedirectToAction("ListAll"));
}
return(View(documents));
}
public virtual async Task <ActionResult> Edit(DocumentEditViewModel viewModel)
{
if (viewModel == null)
{
return(View(MVC.Error.Views.BadRequest));
}
if (ModelState.IsValid == false)
{
return(View(MVC.Document.Views.Edit, viewModel));
}
await _documentService.EditByViewModelAsync(viewModel);
this.AddToastMessage("Success", "", ToastType.Success);
return(RedirectToAction(MVC.Document.List()));
}
//
// GET: /Document/Edit/5
public ActionResult Edit(int id)
{
bool isInGroup = false;
Documents documents = db.Documents.Single(d => d.DocId == id);
if (documents == null)
{
return(HttpNotFound());
}
//make shure that current user belongs to group of user who created event
var roles = (SimpleRoleProvider)Roles.Provider;
List <string> getRolesOfCurrentUser = roles.GetRolesForUser(User.Identity.Name).ToList();
int GrpId = documents.GroupId ?? 0;
foreach (var s in getRolesOfCurrentUser)
{
if (HlpView.GetParamValueByPk(GrpId) == s)
{
isInGroup = true;
break;
}
}
if (!isInGroup)
{
ViewBag.NotAllowed = "Du kannst das Dokument nicht ändern, da es von einer anderen Gruppe erstellt wurde.";
return(View("ListAll"));
}
var viewModel = new DocumentEditViewModel
{
Doc = documents,
Events = HlpView.EventsForDocs,
SelectedEventValue = documents.EventId,
Status = HlpView.Status,
SelectedStatusValue = documents.Status,
Type = HlpView.DocType,
SelectedTypeValue = documents.Type,
Group = HlpView.Group,
SelectedGroupValue = documents.GroupId
};
return(View(viewModel));
}
// GET: BackOffice/Documents/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Document document = await db.GetByIdAsync(id);
if (document == null)
{
return(HttpNotFound());
}
document.Translations = document.Translations.ToList();
var model = new DocumentEditViewModel(document);
await model.PopulateDropDownLists(db.Set <Author>(), db.Set <Collection>());
return(View(model));
}
public ActionResult Create(DocumentEditViewModel model)
{
var document = new Document
{
Name = model.Name,
Description = model.Description,
ParentFolder = model.Folder
};
var version = new DocumentVersion
{
Document = document,
File = new File {
Name = model.File.FileName,
Content = model.File.InputStream.ToByteArray()
}
};
document.Versions.Add(version);
documentRepository.Save(document);
return(RedirectToAction("Index", "Folder", new { id = document.ParentFolder.Id }));
}
public ActionResult CGCDocumentEdit(DocumentEditViewModel viewModel)
{
string uploadDir = "~/documents/cgc/";
string path = String.Empty;
CropGermplasmCommitteeDocument document = new CropGermplasmCommitteeDocument();
ResultContainer resultContainer = new ResultContainer();
try
{
document.ID = viewModel.ID;
document.Committee.ID = viewModel.CommitteeID;
document.Title = viewModel.Title;
document.DocumentYear = viewModel.Year;
document.CategoryCode = viewModel.CategoryCode;
document.URL = viewModel.URL;
if (viewModel.DocumentUpload != null && viewModel.DocumentUpload.ContentLength > 0)
{
if (document.CategoryTitle == "CVS")
{
uploadDir = uploadDir + "cvs";
}
else
{
if (document.CategoryTitle == "MIN")
{
uploadDir = uploadDir + "committee";
}
}
//NEEDED?
//path = Path.Combine(Server.MapPath(uploadDir), Path.GetFileName(viewModel.DocumentUpload.FileName));
var documentPath = Path.Combine(Server.MapPath(uploadDir), viewModel.DocumentUpload.FileName);
var documentUrl = Path.Combine(uploadDir, viewModel.DocumentUpload.FileName);
viewModel.DocumentUpload.SaveAs(documentPath);
var urlBuilder =
new System.UriBuilder(Request.Url.AbsoluteUri)
{
Path = Url.Content(documentUrl),
Query = null,
};
Uri uri = urlBuilder.Uri;
document.URL = urlBuilder.ToString();
}
if (viewModel.ID > 0)
{
resultContainer = _cgcRepository.UpdateDocument(document);
}
else
{
resultContainer = _cgcRepository.InsertDocument(document);
}
return(RedirectToAction("CGCDocumentView", "Admin", new { id = resultContainer.EntityID }));
}
catch (Exception ex)
{
Log.Error(ex, ex.Message);
string actionName = this.ControllerContext.RouteData.Values["action"].ToString();
string controllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
string errorText = "<label>Controller:</label>" + controllerName;
errorText = errorText + "<br><label>Action:</label>" + actionName;
errorText = errorText + "<br><label>Details:</label>" + ex.TargetSite + ex.Message;
Session["ERROR_TEXT"] = errorText;
return(RedirectToAction("InternalServerError", "Error"));
}
}
public async Task <IActionResult> Edit(int id, /*[Bind("DocumentId,Name,Data")]*/ DocumentEditViewModel documentEditViewModel)
{
if (id != documentEditViewModel.DocumentId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var prevFile = await _context.DocumentFiles
.SingleOrDefaultAsync(m => m.DocumentFileId == documentEditViewModel.DocumentId);
var newFile = new DocumentFile();
newFile.Name = documentEditViewModel.Name;
newFile.ModifiedTime = DateTime.Now;
using (var memoryStream = new MemoryStream())
{
await documentEditViewModel.Data.CopyToAsync(memoryStream);
newFile.Data = memoryStream.ToArray();
}
var document = await _context.Documents
.SingleOrDefaultAsync(m => m.DocumentId == id);
document.File = newFile;
newFile.OwnerDocumentId = document.DocumentId;
_context.Add(newFile);
try
{
_context.Update(document);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DocumentExists(document.DocumentId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(documentEditViewModel));
}
