public static async Task <bool> TestLinkAccess(NotesDbContext NotesDbContext, NoteFile noteFile, string secret) { try { List <LinkedFile> linkedFiles; if (string.IsNullOrEmpty(secret)) { linkedFiles = await NotesDbContext.LinkedFile .Where(p => p.RemoteFileName == noteFile.NoteFileName && p.AcceptFrom) .ToListAsync(); } else { linkedFiles = await NotesDbContext.LinkedFile .Where(p => p.RemoteFileName == noteFile.NoteFileName && p.AcceptFrom && p.Secret == secret) .ToListAsync(); } if (linkedFiles == null || linkedFiles.Count < 1) { return(false); } return(true); } catch { return(false); } }
public static async Task <List <NoteHeader> > GetSeqHeader2(NotesDbContext db, Sequencer myseqfile) { return(await db.NoteHeader .Where(x => x.NoteFileId == myseqfile.NoteFileId && x.ArchiveId == 0 && x.LastEdited >= myseqfile.LastTime && x.ResponseOrdinal == 0) .OrderBy(x => x.NoteOrdinal) .ToListAsync()); }
public static void ArchiveNoteFile(NotesDbContext _db, NoteFile noteFile) { noteFile.NumberArchives++; _db.Update(noteFile); List <NoteHeader> nhl = _db.NoteHeader.Where(p => p.NoteFileId == noteFile.Id && p.ArchiveId == 0).ToList(); foreach (NoteHeader nh in nhl) { nh.ArchiveId = noteFile.NumberArchives; _db.Update(nh); } List <NoteAccess> nal = _db.NoteAccess.Where(p => p.NoteFileId == noteFile.Id && p.ArchiveId == 0).ToList(); foreach (NoteAccess na in nal) { na.ArchiveId = noteFile.NumberArchives; } _db.NoteAccess.AddRange(nal); List <Tags> ntl = _db.Tags.Where(p => p.NoteFileId == noteFile.Id && p.ArchiveId == 0).ToList(); foreach (Tags nt in ntl) { nt.ArchiveId = noteFile.NumberArchives; _db.Update(nt); } _db.SaveChanges(); }
/// <summary> /// Get Users Specific Access Entry /// </summary> /// <param name="db">NotesDbContext</param> /// <param name="userId">ID of logged in user</param> /// <param name="fileId">NoteFileID</param> /// <returns>NoteAcess Object</returns> public static async Task <NoteAccess> GetOneAccess(NotesDbContext db, string userId, int fileId, int arcId) { NoteAccess na = await db.NoteAccess .Where(p => p.UserID == userId && p.NoteFileId == fileId && p.ArchiveId == arcId).FirstOrDefaultAsync(); return(na); }
/// <summary> /// Create a NoteFile /// </summary> /// <param name="db">NotesDbContext</param> /// <param name="userManager">UserManager</param> /// <param name="userId">UserID of creator</param> /// <param name="name">NoteFile name</param> /// <param name="title">NoteFile title</param> /// <returns></returns> public static async Task <bool> CreateNoteFile(NotesDbContext db, UserManager <IdentityUser> userManager, string userId, string name, string title) { var query = db.NoteFile.Where(p => p.NoteFileName == name); if (!query.Any()) { NoteFile noteFile = new NoteFile() { NoteFileName = name, NoteFileTitle = title, Id = 0, OwnerId = userId, LastEdited = DateTime.Now.ToUniversalTime() }; db.NoteFile.Add(noteFile); await db.SaveChangesAsync(); NoteFile nf = await db.NoteFile .Where(p => p.NoteFileName == noteFile.NoteFileName) .FirstOrDefaultAsync(); await AccessManager.CreateBaseEntries(db, userManager, userId, nf.Id); return(true); } return(false); }
/// <summary> /// Get all the BaseNoteHeaders for a file /// </summary> /// <param name="db">NotesDbContext</param> /// <param name="nfid">fileid</param> /// <returns></returns> public static async Task <List <NoteHeader> > GetBaseNoteHeadersForFile(NotesDbContext db, int nfid, int arcId) { return(await db.NoteHeader .Where(p => p.NoteFileId == nfid && p.ArchiveId == arcId && p.ResponseOrdinal == 0) .OrderBy(p => p.NoteOrdinal) .ToListAsync()); }
public static async Task <string> DeleteLinked(NotesDbContext db, NoteHeader nh) { // Check for linked notefile(s) List <LinkedFile> links = await db.LinkedFile.Where(p => p.HomeFileId == nh.NoteFileId).ToListAsync(); if (links == null || links.Count < 1) { } else { foreach (var link in links) { if (link.SendTo) { LinkQueue q = new LinkQueue { Activity = LinkAction.Delete, LinkGuid = nh.LinkGuid, LinkedFileId = nh.NoteFileId, BaseUri = link.RemoteBaseUri, Secret = link.Secret }; db.LinkQueue.Add(q); await db.SaveChangesAsync(); } } } return("Ok"); }
public static async Task <NoteFile> GetFileByIdWithOwner(NotesDbContext db, int id) { return(await db.NoteFile .Include(a => a.Owner) .Where(p => p.Id == id) .FirstOrDefaultAsync()); }
public static async Task <List <Sequencer> > GetSeqListForUser(NotesDbContext db, string userid) { return(await db.Sequencer .Where(x => x.UserId == userid) .OrderBy(x => x.Ordinal) .ToListAsync()); }
/// <summary> /// Given a NoteContent Object and Response number get the response NoteID /// </summary> /// <param name="db"></param> /// <param name="nc"></param> /// <param name="resp"></param> /// <returns></returns> public static async Task <long?> FindResponseId(NotesDbContext db, NoteHeader nc, int resp) { NoteHeader content = await db.NoteHeader .Where(p => p.NoteFileId == nc.NoteFileId && p.ArchiveId == nc.ArchiveId && p.NoteOrdinal == nc.NoteOrdinal && p.ResponseOrdinal == resp) .FirstOrDefaultAsync(); return(content?.Id); }
// ReSharper disable once UnusedMember.Global public static async Task <long> GetNumberOfBaseNotes(NotesDbContext db, int fileid, int arcId) { List <NoteHeader> notes = await db.NoteHeader .Where(p => p.Id == fileid && p.ArchiveId == arcId && p.ResponseOrdinal == 0) .ToListAsync(); return(notes.Count); }
public static async Task <NoteHeader> GetNoteById(NotesDbContext db, long noteid) { return(await db.NoteHeader .Include("NoteContent") .Include("Tags") .Where(p => p.Id == noteid) .FirstOrDefaultAsync()); }
public static async Task <NoteHeader> GetMarkedNote(NotesDbContext db, Mark mark) { return(await db.NoteHeader .Include(m => m.NoteContent) .Include(m => m.Tags) .Where(p => p.NoteFileId == mark.NoteFileId && p.ArchiveId == mark.ArchiveId && p.NoteOrdinal == mark.NoteOrdinal && p.ResponseOrdinal == mark.ResponseOrdinal) .FirstAsync()); }
public static async Task <List <NoteHeader> > GetBaseNoteAndResponses(NotesDbContext db, int nfid, int arcId, int noteord) { return(await db.NoteHeader .Include("NoteContent") .Include("Tags") .Where(p => p.NoteFileId == nfid && p.ArchiveId == arcId && p.NoteOrdinal == noteord) .ToListAsync()); }
/// <summary> /// Delete a NoteFile /// </summary> /// <param name="db">NotesDbContext</param> /// <param name="id">NoteFileID</param> /// <returns></returns> public static async Task <bool> DeleteNoteFile(NotesDbContext db, int id) { // Things to delete: // 1) X Entries in NoteContent // 2) X Entries in BaseNoteHeader // 3) X Entries in Sequencer // 4) X Entries in NoteAccesses // 5) X Entries in Marks // 6) X Entries in SearchView // 7) 1 Entry in NoteFile // The above (1 - 6) now done by Cascade Delete of NoteFile //List<NoteContent> nc = await _db.NoteContent // .Where(p => p.NoteFileID == id) // .ToListAsync(); //List<BaseNoteHeader> bnh = await GetBaseNoteHeadersForFile(_db, id); //List<Sequencer> seq = await _db.Sequencer //.Where(p => p.NoteFileID == id) //.ToListAsync(); //List<NoteAccess> na = await AccessManager.GetAccessListForFile(_db, id); //List<Mark> marks = await _db.Mark // .Where(p => p.NoteFileID == id) // .ToListAsync(); //List<SearchView> sv = await _db.SearchView // .Where(p => p.NoteFileID == id) // .ToListAsync(); //_db.NoteContent.RemoveRange(nc); //_db.BaseNoteHeader.RemoveRange(bnh); //_db.Sequencer.RemoveRange(seq); //_db.NoteAccess.RemoveRange(na); //_db.Mark.RemoveRange(marks); //_db.SearchView.RemoveRange(sv); NoteFile noteFile = await db.NoteFile .Where(p => p.Id == id) .FirstAsync(); for (int arcId = 0; arcId <= noteFile.NumberArchives; arcId++) { List <NoteAccess> na = await AccessManager.GetAccessListForFile(db, id, arcId); db.NoteAccess.RemoveRange(na); } List <Subscription> subs = await db.Subscription .Where(p => p.NoteFileId == id) .ToListAsync(); db.Subscription.RemoveRange(subs); db.NoteFile.Remove(noteFile); await db.SaveChangesAsync(); return(true); }
public static async Task <List <NoteHeader> > GetOrderedListOfResponses(NotesDbContext db, int nfid, NoteHeader bnh) { return(await db.NoteHeader .Include(m => m.NoteContent) .Include(m => m.Tags) .Where(p => p.NoteFileId == nfid && p.ArchiveId == bnh.ArchiveId && p.NoteOrdinal == bnh.NoteOrdinal && p.ResponseOrdinal > 0) .OrderBy(p => p.ResponseOrdinal) .ToListAsync()); }
public static async Task <NoteFile> GetFileByIdWithHeaders(NotesDbContext db, int id, int arcId) { NoteFile nf = await db.NoteFile .Where(p => p.Id == id) .FirstOrDefaultAsync(); //nf.NoteHeaders = await db.NoteHeader.Where(p => p.NoteFileId == id && p.ArchiveId == arcId).ToListAsync(); return(nf); }
public static async Task <NoteHeader> GetBaseNoteHeader(NotesDbContext db, long id) { NoteHeader nh = await db.NoteHeader .Where(p => p.Id == id) .FirstOrDefaultAsync(); return(await db.NoteHeader .Where(p => p.Id == nh.BaseNoteId) .FirstOrDefaultAsync()); }
public static async Task <NoteHeader> GetNoteByIdWithFile(NotesDbContext db, long noteid) { return(await db.NoteHeader .Include("NoteContent") .Include("NoteFile") .Include("Tags") .Where(p => p.Id == noteid) .OrderBy((x => x.NoteOrdinal)) .FirstOrDefaultAsync()); }
/// <summary> /// Delete a Note /// </summary> /// <param name="db">NotesDbContext</param> /// <param name="nc">NoteContent</param> /// <returns></returns> public static async Task <bool> DeleteNote(NotesDbContext db, NoteHeader nc) { if (nc.ResponseOrdinal == 0) // base note { return(await DeleteBaseNote(db, nc)); } else // Response { return(await DeleteResponse(db, nc)); } }
/// <summary> /// Get next available BaseNoteOrdinal /// </summary> /// <param name="db">NotesDbContext</param> /// <param name="noteFileId">NoteFileID</param> /// <returns></returns> public static async Task <int> NextBaseNoteOrdinal(NotesDbContext db, int noteFileId, int arcId) { IOrderedQueryable <NoteHeader> bnhq = GetBaseNoteHeaderByIdRev(db, noteFileId, arcId); if (bnhq == null || !bnhq.Any()) { return(1); } NoteHeader bnh = await bnhq.FirstAsync(); return(bnh.NoteOrdinal + 1); }
//TODO //public static async Task<bool> SendNotesAsync(ForwardViewModel fv, NotesDbContext db, IEmailSender emailSender, // string email, string name, string Url) //{ // await emailSender.SendEmailAsync(fv.ToEmail, fv.NoteSubject, // await MakeNoteForEmail(fv, db, email, name, Url)); // return true; //} private static async Task <string> MakeNoteForEmail(ForwardViewModel fv, NotesDbContext db, string email, string name, string ProductionUrl) { NoteHeader nc = await GetNoteByIdWithFile(db, fv.NoteID); if (!fv.hasstring || !fv.wholestring) { return("Forwarded by Notes 2021 - User: "******" / " + name + "<p>File: " + nc.NoteFile.NoteFileName + " - File Title: " + nc.NoteFile.NoteFileTitle + "</p><hr/>" + "<p>Author: " + nc.AuthorName + " - Director Message: " + nc.NoteContent.DirectorMessage + "</p><p>" + "<p>Subject: " + nc.NoteSubject + "</p>" + nc.LastEdited.ToShortDateString() + " " + nc.LastEdited.ToShortTimeString() + " UTC" + "</p>" + nc.NoteContent.NoteBody + "<hr/>" + "<a href=\"" + ProductionUrl + "NoteDisplay/Display/" + fv.NoteID + "\" >Link to note</a>"); } else { List <NoteHeader> bnhl = await GetBaseNoteHeadersForNote(db, nc.NoteFileId, nc.ArchiveId, nc.NoteOrdinal); NoteHeader bnh = bnhl[0]; fv.NoteSubject = bnh.NoteSubject; List <NoteHeader> notes = await GetBaseNoteAndResponses(db, nc.NoteFileId, nc.ArchiveId, nc.NoteOrdinal); StringBuilder sb = new StringBuilder(); sb.Append("Forwarded by Notes 2020 - User: "******" / " + name + "<p>\nFile: " + nc.NoteFile.NoteFileName + " - File Title: " + nc.NoteFile.NoteFileTitle + "</p>" + "<hr/>"); for (int i = 0; i < notes.Count; i++) { if (i == 0) { sb.Append("<p>Base Note - " + (notes.Count - 1) + " Response(s)</p>"); } else { sb.Append("<hr/><p>Response - " + notes[i].ResponseOrdinal + " of " + (notes.Count - 1) + "</p>"); } sb.Append("<p>Author: " + notes[i].AuthorName + " - Director Message: " + notes[i].NoteContent.DirectorMessage + "</p>"); sb.Append("<p>Subject: " + notes[i].NoteSubject + "</p>"); sb.Append("<p>" + notes[i].LastEdited.ToShortDateString() + " " + notes[i].LastEdited.ToShortTimeString() + " UTC" + " </p>"); sb.Append(notes[i].NoteContent.NoteBody); sb.Append("<hr/>"); sb.Append("<a href=\""); sb.Append(ProductionUrl + "NoteDisplay/Display/" + notes[i].Id + "\" >Link to note</a>"); } return(sb.ToString()); } }
/// <summary> /// All access checks call this /// </summary> /// <param name="db">NotesDbContext</param> /// <param name="userId">ID of logged in user</param> /// <param name="fileId">NoteFileID</param> /// <returns>NoteAcess Object</returns> public static async Task <NoteAccess> GetAccess(NotesDbContext db, string userId, int fileId, int arcId) { // Next we check for this user specifically NoteAccess na = await db.NoteAccess .Where(p => p.UserID == userId && p.NoteFileId == fileId && p.ArchiveId == arcId).FirstOrDefaultAsync(); if (na != null) { return(na); } // If specific user not in list use "Other" return(await db.NoteAccess .Where(p => p.UserID == "Other" && p.NoteFileId == fileId && p.ArchiveId == arcId).FirstOrDefaultAsync()); }
/// <summary> /// Create standard starting entires for a access controls for a new file. /// "Other" -- no access /// creating user (Admin) -- Full Access /// [email protected] if it exists -- no access /// </summary> /// <param name="db"></param> /// <param name="userManager"></param> /// <param name="userId"></param> /// <param name="fileId"></param> /// <returns></returns> public static async Task <bool> CreateBaseEntries(NotesDbContext db, UserManager <IdentityUser> userManager, string userId, int fileId) { if (true) { bool flag1 = await Create(db, "Other", fileId, false, false, false, false, false, false, false); if (!flag1) { return(false); } } if (true) { bool flag1 = await Create(db, userId, fileId, true, true, true, true, true, true, true); if (!flag1) { return(false); } } try { var user = await userManager.FindByNameAsync("*****@*****.**"); if (user == null) { return(true); } string readonlyId = user.Id; { bool flag1 = await Create(db, readonlyId, fileId, false, false, false, false, false, false, false); if (!flag1) { return(false); } } } catch { // ignored } return(true); }
/// <summary> /// Delete a Response Note /// </summary> /// <param name="db">NotesDbContext</param> /// <param name="nc">NoteContent</param> /// <returns></returns> // Steps involved: // 1. Delete single NoteContent row where NoteFileID, NoteOrdinal, and ResponseOrdinal match input // 2. Decrement all NoteContent.ResponseOrdinal where NoteFileID, and NoteOrdinal match input and NoteContent.ResponseOrdinal > nc.ResponseOrdinal // 3. Decrement single row (Responses field)in BaseNoteHeader where NoteFileID, NoteOrdinal match input private static async Task <bool> DeleteResponse(NotesDbContext db, NoteHeader nc) { int fileId = nc.NoteFileId; int arcId = nc.ArchiveId; int noteOrd = nc.NoteOrdinal; int respOrd = nc.ResponseOrdinal; try { List <NoteHeader> deleteCont = await db.NoteHeader .Where(p => p.NoteFileId == fileId && p.ArchiveId == arcId && p.NoteOrdinal == noteOrd && p.ResponseOrdinal == nc.ResponseOrdinal) .ToListAsync(); if (deleteCont.Count != 1) { return(false); } await DeleteLinked(db, deleteCont.First()); db.NoteHeader.Remove(deleteCont.First()); List <NoteHeader> upCont = await db.NoteHeader .Where(p => p.NoteFileId == fileId && p.ArchiveId == arcId && p.NoteOrdinal == noteOrd && p.ResponseOrdinal > respOrd) .ToListAsync(); foreach (var cont in upCont) { cont.ResponseOrdinal--; db.Entry(cont).State = EntityState.Modified; } NoteHeader bnh = await GetBaseNoteHeader(db, fileId, arcId, noteOrd); bnh.ResponseCount--; db.Entry(bnh).State = EntityState.Modified; await db.SaveChangesAsync(); return(true); } catch { // ignored } return(false); }
public static async Task <NoteHeader> CreateResponse(NotesDbContext db, UserManager <IdentityUser> userManager, NoteHeader nh, string body, string tags, string dMessage, bool send, bool linked) { NoteHeader mine = await GetBaseNoteHeader(db, nh.BaseNoteId); db.Entry(mine).State = EntityState.Unchanged; await db.SaveChangesAsync(); mine.ThreadLastEdited = DateTime.Now.ToUniversalTime(); mine.ResponseCount++; db.Entry(mine).State = EntityState.Modified; await db.SaveChangesAsync(); nh.ResponseOrdinal = mine.ResponseCount; nh.NoteOrdinal = mine.NoteOrdinal; return(await CreateNote(db, userManager, nh, body, tags, dMessage, send, linked)); }
public static async Task <bool> Audit(NotesDbContext db, string eventType, string userName, string userId, string Event /*, TelemetryClient telemetry*/) { Audit na = new Audit(); var usr = await db.Users.SingleAsync(p => p.UserName == userName); na.UserID = usr.Id; na.UserName = userName; na.EventType = eventType; na.Event = Event; na.EventTime = System.DateTime.Now.ToUniversalTime(); //telemetry.TrackEvent("Audit - " + userName + " - " + eventType + " - " + Event); db.Audit.Add(na); return((await db.SaveChangesAsync()) == 1); }
private static async Task <bool> Create(NotesDbContext db, string userId, int noteFileId, bool read, bool respond, bool write, bool setTag, bool deleteEdit, bool director, bool editAccess) { NoteAccess na = new NoteAccess() { UserID = userId, NoteFileId = noteFileId, ReadAccess = read, Respond = respond, Write = write, SetTag = setTag, DeleteEdit = deleteEdit, ViewAccess = director, EditAccess = editAccess }; db.NoteAccess.Add(na); return((await db.SaveChangesAsync()) == 1); }
public static async Task <NoteContent> GetNoteContent(NotesDbContext db, int nfid, int ArcId, int noteord, int respOrd) { var header = await db.NoteHeader .Where(p => p.NoteFileId == nfid && p.ArchiveId == ArcId && p.NoteOrdinal == noteord && p.ResponseOrdinal == respOrd) .FirstAsync(); if (header == null) { return(null); } var content = await db.NoteContent .OfType <NoteContent>() .Where(p => p.NoteHeaderId == header.Id) .FirstAsync(); content.NoteHeader = null; return(content); }
public static async Task <List <NoteHeader> > GetSearchHeaders(NotesDbContext db, Search start, NoteHeader bnh, SearchOption so) { if (so == SearchOption.Tag) { return(await db.NoteHeader .Include("Tags") .Where(x => x.NoteFileId == start.NoteFileId && x.ArchiveId == start.ArchiveId && x.NoteOrdinal > bnh.NoteOrdinal) .ToListAsync()); } if (so == SearchOption.Content || so == SearchOption.DirMess) { return(await db.NoteHeader .Include("NoteContent") .Where(x => x.NoteFileId == start.NoteFileId && x.ArchiveId == start.ArchiveId && x.NoteOrdinal > bnh.NoteOrdinal) .ToListAsync()); } return(await db.NoteHeader .Where(x => x.NoteFileId == start.NoteFileId && x.ArchiveId == start.ArchiveId && x.NoteOrdinal > bnh.NoteOrdinal) .ToListAsync()); }