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);
}
