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