/// <summary> /// Loads filepath of last version of specified document. /// </summary> /// <param name="documentId"></param> /// <returns></returns> public string GetLastDocumentVersionFilePath(int documentId) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { return(context.tDocumentVersions.Where(u => u.DocumentId == documentId).OrderByDescending(u => u.HierarchyId).First().FilePath); } }
/// <summary> /// Returns true if user has write access right for document. /// </summary> /// <param name="userId"></param> /// <param name="documentId"></param> /// <returns></returns> public bool CheckIfUserHasWriteAccess(int userId, int documentId) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { tUser user = context.tUsers.Find(userId); if (user.AuthorizationRoleId == (int)AuthorizationRoleCodes.Administrator) { return(true); } tUserDocument ud = context.tUserDocuments.Where(u => u.UserId == userId && u.DocumentId == documentId).SingleOrDefault(); if (ud == null) { return(false); } if (ud.DocumentAccessRightId == (int)DocumentAccessRightCodes.Owner) { return(true); } if (ud.DocumentAccessRightId == (int)DocumentAccessRightCodes.Modify) { return(true); } return(false); } }
/// <summary> /// Opens document for writing for current user if document is not locked and no one currently reads it. /// </summary> /// <param name="documentId">The document id.</param> /// <param name="loggedUserId">The logged user id.</param> /// <returns></returns> public bool TryOpenDocumentForWriting(int documentId, int loggedUserId) { using (TransactionScope scope = new TransactionScope()) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { tDocument document = context.tDocuments.Find(documentId); if (document.IsLocked) { scope.Complete(); return(false); } int readers = context.tUserDocuments.Where(u => u.DocumentId == documentId && u.IsReading).Count(); if (readers > 0) { scope.Complete(); return(false); } tUserDocument ud = context.tUserDocuments.Where(u => u.DocumentId == documentId && u.UserId == loggedUserId).Single(); ud.IsWriting = true; document.IsLocked = true; context.SaveChanges(); scope.Complete(); return(true); } } }
/// <summary> /// Loads all coments for document version /// </summary> /// <param name="versionId">The document version id</param> /// <returns></returns> public List <CommentDTO> LoadDocumentComments(int versionId) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { IQueryable <tComment> comments = context.tComments.Where(u => u.tDocumentVersion.Id == versionId).OrderByDescending(u => u.CreatedAt); return(Mapper.Map <List <CommentDTO> >(comments.ToList())); } }
/// <summary> /// Loads list of keywords for specified document. /// </summary> /// <param name="documentId">The document id</param> /// <returns></returns> public IEnumerable <string> LoadDocumentKeywords(int documentId) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { return(context.tKeywords.Where(u => u.tDocuments.Select(x => x.Id).Contains(documentId)) .Select(u => u.Name).ToList()); } }
/// <summary> /// Loads documents that are matched by criteria from filter. /// </summary> /// <param name="userDto">The user dto.</param> /// <returns></returns> public IEnumerable <DocumentDTO> LoadUserDocuments(DocumentFilterDTO filter) { Expression <Func <tDocument, bool> > restriction = x => x.IsValid; if (filter.LoggedUser.AuthorizationRole == AuthorizationRoleCodes.Operator) { restriction = ExpressionUtils.AndOperation(restriction, u => u.tUserDocuments.Select(x => x.UserId).Contains(filter.LoggedUser.Id)); } if (!String.IsNullOrEmpty(filter.Title)) { restriction = ExpressionUtils.AndOperation(restriction, u => u.Title.Contains(filter.Title)); } if (!String.IsNullOrEmpty(filter.Keywords)) { string[] keywords = filter.Keywords.Split(' ', ','); Expression <Func <tDocument, bool> > wordRestriciton = x => false; // false || kw1 || kw2 foreach (string word in keywords) { wordRestriciton = ExpressionUtils.OrOperation(wordRestriciton, x => x.tKeywords.Select(k => k.Name).Contains(word)); } restriction = ExpressionUtils.AndOperation(restriction, wordRestriciton); } if (!String.IsNullOrEmpty(filter.Extension)) { restriction = ExpressionUtils.AndOperation(restriction, u => u.Extension.Contains(filter.Extension)); } if (filter.DateFrom.HasValue) { DateTime date1 = filter.DateFrom.Value.Date; restriction = ExpressionUtils.AndOperation(restriction, u => u.CreatedAt >= date1); } if (filter.DateTo.HasValue) { DateTime date2 = filter.DateTo.Value.AddDays(1).Date; restriction = ExpressionUtils.AndOperation(restriction, u => u.CreatedAt <= date2); } if (filter.OnlyActive) { restriction = ExpressionUtils.AndOperation(restriction, u => !u.IsArchived); } if (filter.OnlyArchived) { restriction = ExpressionUtils.AndOperation(restriction, u => u.IsArchived); } if (!String.IsNullOrEmpty(filter.UserName)) { restriction = ExpressionUtils.AndOperation(restriction, u => u.tUserDocuments.Select(x => x.tUser.UserName).Contains(filter.UserName)); } using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { return(Mapper.Map <IEnumerable <DocumentDTO> >(context.tDocuments.Where(restriction).OrderBy(u => u.CreatedAt))); } }
/// <summary> /// Adds new document to system. /// </summary> /// <param name="documentDto">The document</param> /// <param name="ownerId">The owner id = logged user id.</param> /// <returns></returns> public DocumentDTO SaveNewDocument(DocumentDTO documentDto, int ownerId) { if (documentDto == null) { throw new ArgumentNullException("documentDto"); } documentDto.CreatedAt = DateTime.Now; documentDto.IsArchived = false; documentDto.IsLocked = false; documentDto.IsValid = true; tDocument result = Mapper.Map <tDocument>(documentDto); result.Version = 1; result.Guid = Guid.NewGuid(); result.Extension = result.Extension.TrimStart('.'); result.tKeywords = Mapper.Map <List <tKeyword> >(documentDto.Keywords.ToList()); foreach (DocumentShareDTO share in documentDto.DocumentShares) { tUserDocument ud = new tUserDocument(); ud.IsReading = false; ud.IsWriting = false; ud.UserId = share.UserId; ud.DocumentId = documentDto.Id; ud.DocumentAccessRightId = (int)share.AccessRight; result.tUserDocuments.Add(ud); } tUserDocument owner = new tUserDocument() { IsReading = false, IsWriting = false, DocumentAccessRightId = (int)DocumentAccessRightCodes.Owner, UserId = ownerId }; using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { result = context.tDocuments.Add(result); context.SaveChanges(); owner.DocumentId = result.Id; result.tUserDocuments.Add(owner); context.SaveChanges(); } AddAdministratorsToDocument(result.Id, ownerId); documentDto.Id = result.Id; return(documentDto); }
/// <summary> /// Check if user is currently reading from last version of document. /// </summary> /// <param name="userId">The user id.</param> /// <param name="documentId">The document id.</param> /// <returns></returns> public bool IsUserReadingFromDocument(int userId, int documentId) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { tUserDocument ud = context.tUserDocuments.Where(u => u.UserId == userId && u.DocumentId == documentId).SingleOrDefault(); if (ud == null) { throw new AuthorizationException(); } return(ud.IsReading); } }
/// <summary> /// Toggles value of archived flag for specified document. /// </summary> /// <param name="documentDto">The document dto.</param> /// <returns>The modified document dto.</returns> public DocumentDTO ToggleArchivedFlag(DocumentDTO documentDto) { documentDto.IsArchived = !documentDto.IsArchived; using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { tDocument document = context.tDocuments.Find(documentDto.Id); Mapper.Map(documentDto, document); document.Version++; context.SaveChanges(); return(documentDto); } }
/// <summary> /// Loads all versions for specified document except the last one. /// </summary> /// <param name="documentId">The document id.</param> /// <returns>List of <see cref="DocumentVErsionDTO"/></returns> public IEnumerable <DocumentVersionDTO> LoadDocumentVersions(int documentId) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { IQueryable <tDocumentVersion> versions = context.tDocumentVersions.Where(u => u.DocumentId == documentId && u.tDocument.IsValid).OrderByDescending(u => u.CreatedAt); if (versions == null || versions.Count() < 2) { return(null); } versions = versions.Skip(1); return(Mapper.Map <IEnumerable <DocumentVersionDTO> >(versions)); } }
/// <summary> /// Loads list of document shares for specified user. Document owner is not loaded. Administrators are not loaded. /// </summary> /// <param name="documentId">The document id.</param> /// <returns>List of <see cref="DocumentShareDTO"/></returns> public IEnumerable <DocumentShareDTO> LoadDocumentsShare(int documentId) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { return(context.tUserDocuments.Where(u => u.DocumentId == documentId && u.DocumentAccessRightId != (int)DocumentAccessRightCodes.Owner && u.tUser.AuthorizationRoleId != (int)AuthorizationRoleCodes.Administrator) .Select(u => new DocumentShareDTO() { AccessRight = (DocumentAccessRightCodes)u.DocumentAccessRightId, UserName = u.tUser.UserName, UserId = u.UserId }).ToList()); } }
/// <summary> /// Saves the new comment. /// </summary> /// <param name="commentDto">The comment dto.</param> /// <returns></returns> public CommentDTO SaveNewComment(CommentDTO commentDto) { commentDto.CreatedAt = DateTime.Now; tComment comment = Mapper.Map <tComment>(commentDto); using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { context.tComments.Add(comment); context.SaveChanges(); } return(commentDto); }
/// <summary> /// Loads list of users for auto suggest sharing control. Only valid operators will be loaded. /// If document is new, the owner of the document will not be loaded, that is current user. /// If document is not new all users that already can access document will not be loaded. /// </summary> /// <param name="documentId">The document Id.</param> /// <returns></returns> public IEnumerable <UserDTO> LoadUsersForShareAutosuggest(DocumentDTO documentDTo, int loggedUserId) { Expression <Func <tUser, bool> > restriction = u => u.IsValid && u.AuthorizationRoleId == (int)AuthorizationRoleCodes.Operator; if (documentDTo != null) { restriction = ExpressionUtils.AndOperation(restriction, u => !u.tUserDocuments.Any(x => x.DocumentId == documentDTo.Id && x.UserId == u.Id)); } else { restriction = ExpressionUtils.AndOperation(restriction, u => u.Id != loggedUserId); } using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { return(Mapper.Map <IEnumerable <UserDTO> >(context.tUsers.Where(restriction))); } }
/// <summary> /// Adds new document version to document, which takes next hierarchy id. /// </summary> /// <param name="document">The document id.</param> /// <returns>Returns the filepath of the new document version.</returns> public string AddNewDocumentVersion(DocumentDTO document) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { tDocumentVersion lastVersion = context.tDocumentVersions.Where(u => u.DocumentId == document.Id).OrderByDescending(u => u.HierarchyId).FirstOrDefault(); tDocumentVersion documentVersion = new tDocumentVersion(); documentVersion.Guid = Guid.NewGuid(); documentVersion.CreatedAt = DateTime.Now; documentVersion.HierarchyId = (lastVersion == null) ? 1 : lastVersion.HierarchyId + 1; documentVersion.DocumentId = document.Id; documentVersion.Version = 1; documentVersion.FilePath = documentVersion.Guid + document.Extension; context.tDocumentVersions.Add(documentVersion); context.SaveChanges(); return(documentVersion.FilePath); } }
/// <summary> /// Updates document title, keywords and sharing with users. /// </summary> /// <param name="documentDto">The document dto.</param> /// <param name="loggedUserId">The logged user id.</param> public void UpdateDocumentData(DocumentDTO documentDto, long loggedUserId) { if (documentDto == null) { throw new ArgumentNullException("documentDto"); } // operators, not owner, not logged user Expression <Func <tUserDocument, bool> > oldShareRestrictions = x => x.DocumentId == documentDto.Id && x.DocumentAccessRightId != (int)DocumentAccessRightCodes.Owner && x.UserId != loggedUserId && x.tUser.AuthorizationRoleId == (int)AuthorizationRoleCodes.Operator; using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { tDocument document = context.tDocuments.Find(documentDto.Id); document.tKeywords.Clear(); document.tKeywords = Mapper.Map <List <tKeyword> >(documentDto.Keywords.ToList()); document.LastModifiedAt = DateTime.Now; document.Version++; document.Title = documentDto.Title; IEnumerable <tUserDocument> oldShared = context.tUserDocuments.Where(oldShareRestrictions); foreach (tUserDocument ud in oldShared) { context.tUserDocuments.Remove(ud); } foreach (DocumentShareDTO share in documentDto.DocumentShares) { tUserDocument ud = new tUserDocument(); ud.IsReading = false; ud.IsWriting = false; ud.UserId = share.UserId; ud.DocumentId = documentDto.Id; ud.DocumentAccessRightId = (int)share.AccessRight; document.tUserDocuments.Add(ud); } context.SaveChanges(); } }
/// <summary> /// Gives modify access right to all administrators of system except owner, to the document. /// </summary> /// <param name="documentId">The document id</param> private void AddAdministratorsToDocument(int documentId, int ownerId) { using (DMSDataBaseEntities context = new DMSDataBaseEntities()) { IEnumerable <tUser> users = context.tUsers.Where(u => u.AuthorizationRoleId == (int)AuthorizationRoleCodes.Administrator && u.Id != ownerId); foreach (tUser user in users) { tUserDocument ud = new tUserDocument() { DocumentId = documentId, IsReading = false, IsWriting = false, DocumentAccessRightId = (int)DocumentAccessRightCodes.Modify, UserId = user.Id }; context.tUserDocuments.Add(ud); } context.SaveChanges(); } }
protected void BeginTransaction() { _context = new DMSDataBaseEntities(); }