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> /// 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); }
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()); }
/// <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> /// 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 NoteHeader CloneForLink() { NoteHeader nh = new NoteHeader() { Id = Id, NoteSubject = NoteSubject, LastEdited = LastEdited, ThreadLastEdited = ThreadLastEdited, CreateDate = CreateDate, AuthorID = AuthorID, AuthorName = AuthorName, LinkGuid = LinkGuid }; return(nh); }
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 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 <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 <List <NoteHeader> > GetSeqHeader1(NotesDbContext db, Sequencer myseqfile, NoteHeader bnh) { return(await db.NoteHeader .Where(x => x.NoteFileId == myseqfile.NoteFileId && x.ArchiveId == 0 && x.LastEdited >= myseqfile.LastTime && x.NoteOrdinal > bnh.NoteOrdinal && x.ResponseOrdinal == 0) .OrderBy(x => x.NoteOrdinal) .ToListAsync()); }
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()); }
public static async Task <List <NoteHeader> > GetSearchResponseList(NotesDbContext db, Search start, int myRespOrdinal, NoteHeader bnh, SearchOption so) { // First try responses if (so == SearchOption.Tag) { return(await db.NoteHeader .Include("Tags") .Where(x => x.NoteFileId == start.NoteFileId && x.ArchiveId == start.ArchiveId && x.NoteOrdinal == bnh.NoteOrdinal && x.ResponseOrdinal > myRespOrdinal) .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 && x.ResponseOrdinal > myRespOrdinal) .ToListAsync()); } return(await db.NoteHeader .Where(x => x.NoteFileId == start.NoteFileId && x.ArchiveId == start.ArchiveId && x.NoteOrdinal == bnh.NoteOrdinal && x.ResponseOrdinal > myRespOrdinal) .ToListAsync()); }
public static async Task <NoteHeader> GetEditedNoteHeader(NotesDbContext db, NoteHeader edited) { return(await db.NoteHeader .Where(p => p.NoteFileId == edited.NoteFileId && p.ArchiveId == edited.ArchiveId && p.NoteOrdinal == edited.NoteOrdinal) .FirstOrDefaultAsync()); }
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); }