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"); }
/// <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); }
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)); }
/// <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); }
/// <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 <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); }
/// <summary> /// Delete a Base Note /// </summary> /// <param name="db">NotesDbContext</param> /// <param name="nc">NoteContent</param> /// <returns></returns> // Steps involved: // 1. Delete all NoteContent rows where NoteFileID, NoteOrdinal match input // 2. Delete single row in BaseNoteHeader where NoteFileID, NoteOrdinal match input // 3. Decrement all BaseNoteHeader.NoteOrdinal where NoteFileID match input and // BaseNoteHeader.NoteOrdinal > nc.NoteOrdinal // 4. Decrement all NoteContent.NoteOrdinal where NoteFileID match input and NoteContent.NoteOrdinal > nc.NoteOrdinal private static async Task <bool> DeleteBaseNote(NotesDbContext db, NoteHeader nc) { int fileId = nc.NoteFileId; int arcId = nc.ArchiveId; int noteOrd = nc.NoteOrdinal; try { List <NoteHeader> deleteCont = await GetNoteContentList(db, fileId, arcId, noteOrd); foreach (var nh in deleteCont) { await DeleteLinked(db, nh); } db.NoteHeader.RemoveRange(deleteCont); List <NoteHeader> upBase = await db.NoteHeader .Where(p => p.NoteFileId == fileId && p.ArchiveId == arcId && p.NoteOrdinal > noteOrd) .ToListAsync(); foreach (var cont in upBase) { cont.NoteOrdinal--; db.Entry(cont).State = EntityState.Modified; } await db.SaveChangesAsync(); return(true); } catch { // ignored } return(false); }
public static async Task <NoteHeader> EditNote(NotesDbContext db, UserManager <IdentityUser> userManager, NoteHeader nh, NoteContent nc, string tags) { NoteHeader eHeader = await GetBaseNoteHeader(db, nh.Id); eHeader.LastEdited = nh.LastEdited; eHeader.ThreadLastEdited = nh.ThreadLastEdited; eHeader.NoteSubject = nh.NoteSubject; db.Entry(eHeader).State = EntityState.Modified; NoteContent eContent = await GetNoteContent(db, nh.NoteFileId, nh.ArchiveId, nh.NoteOrdinal, nh.ResponseOrdinal); eContent.NoteBody = nc.NoteBody; eContent.DirectorMessage = nc.DirectorMessage; db.Entry(eContent).State = EntityState.Modified; List <Tags> oTags = await GetNoteTags(db, nh.NoteFileId, nh.ArchiveId, nh.NoteOrdinal, nh.ResponseOrdinal, 0); db.Tags.RemoveRange(oTags); db.UpdateRange(oTags); db.Update(eHeader); db.Update(eContent); await db.SaveChangesAsync(); // deal with tags if (tags != null && tags.Length > 1) { var theTags = Tags.StringToList(tags, eHeader.Id, eHeader.NoteFileId, eHeader.ArchiveId); if (theTags.Count > 0) { await db.Tags.AddRangeAsync(theTags); await db.SaveChangesAsync(); } } // Check for linked notefile(s) List <LinkedFile> links = await db.LinkedFile.Where(p => p.HomeFileId == eHeader.NoteFileId && p.SendTo).ToListAsync(); if (links == null || links.Count < 1) { } else { foreach (var link in links) { if (link.SendTo) { LinkQueue q = new LinkQueue { Activity = LinkAction.Edit, LinkGuid = eHeader.LinkGuid, LinkedFileId = eHeader.NoteFileId, BaseUri = link.RemoteBaseUri, Secret = link.Secret }; db.LinkQueue.Add(q); await db.SaveChangesAsync(); } } } return(eHeader); }
public static async Task <NoteHeader> CreateNote(NotesDbContext db, UserManager <IdentityUser> userManager, NoteHeader nh, string body, string tags, string dMessage, bool send, bool linked) { if (nh.ResponseOrdinal == 0) // base note { nh.NoteOrdinal = await NextBaseNoteOrdinal(db, nh.NoteFileId, nh.ArchiveId); } if (!linked) { nh.LinkGuid = Guid.NewGuid().ToString(); } if (!send) // indicates an import operation / adjust time to UCT / assume original was CST = UCT-06, so add 6 hours { int offset = 6; if (nh.LastEdited.IsDaylightSavingTime()) { offset--; } Random rand = new Random(); int ms = rand.Next(999); nh.LastEdited = nh.LastEdited.AddHours(offset).AddMilliseconds(ms); nh.CreateDate = nh.LastEdited; nh.ThreadLastEdited = nh.CreateDate; } NoteFile nf = await db.NoteFile .Where(p => p.Id == nh.NoteFileId) .FirstOrDefaultAsync(); nf.LastEdited = nh.CreateDate; db.Entry(nf).State = EntityState.Modified; db.NoteHeader.Add(nh); await db.SaveChangesAsync(); NoteHeader newHeader = nh; if (newHeader.ResponseOrdinal == 0) { newHeader.BaseNoteId = newHeader.Id; db.Entry(newHeader).State = EntityState.Modified; await db.SaveChangesAsync(); } else { NoteHeader baseNote = await db.NoteHeader .Where(p => p.NoteFileId == newHeader.NoteFileId && p.ArchiveId == newHeader.ArchiveId && p.NoteOrdinal == newHeader.NoteOrdinal && p.ResponseOrdinal == 0) .FirstOrDefaultAsync(); newHeader.BaseNoteId = baseNote.Id; db.Entry(newHeader).State = EntityState.Modified; await db.SaveChangesAsync(); } NoteContent newContent = new NoteContent() { NoteHeaderId = newHeader.Id, NoteBody = body, DirectorMessage = dMessage }; db.NoteContent.Add(newContent); await db.SaveChangesAsync(); // deal with tags if (tags != null && tags.Length > 1) { var theTags = Tags.StringToList(tags, newHeader.Id, newHeader.NoteFileId, newHeader.ArchiveId); if (theTags.Count > 0) { await db.Tags.AddRangeAsync(theTags); await db.SaveChangesAsync(); } } // Check for linked notefile(s) List <LinkedFile> links = await db.LinkedFile.Where(p => p.HomeFileId == newHeader.NoteFileId && p.SendTo).ToListAsync(); if (linked || links == null || links.Count < 1) { } else { foreach (var link in links) { if (link.SendTo) { LinkQueue q = new LinkQueue { Activity = newHeader.ResponseOrdinal == 0 ? LinkAction.CreateBase : LinkAction.CreateResponse, LinkGuid = newHeader.LinkGuid, LinkedFileId = newHeader.NoteFileId, BaseUri = link.RemoteBaseUri, Secret = link.Secret }; db.LinkQueue.Add(q); await db.SaveChangesAsync(); } } } return(newHeader); }