public ENNoteRef UploadNote(ENNote note, ENNotebook notebook)
{
return UploadNote(note, UploadPolicy.Create, notebook, null);
}
public ENNoteRef UploadNote(ENNote note, ENSession.UploadPolicy policy, ENNotebook notebook, ENNoteRef noteToReplace)
{
if (note == null)
{
ENSDKLogger.ENSDKLogError("Must specify note");
throw new ENInvalidDataException();
}
if (policy == UploadPolicy.Replace && noteToReplace == null || policy == UploadPolicy.ReplaceOrCreate && noteToReplace == null)
{
ENSDKLogger.ENSDKLogError("Must specify existing ID when requesting a replacement policy");
throw new ENInvalidDataException();
}
if (policy == UploadPolicy.Create && noteToReplace != null)
{
ENSDKLogger.ENSDKLogError("Can't use create policy when specifying an existing note ref. Ignoring.");
noteToReplace = null;
}
if (notebook != null && !notebook.AllowsWriting)
{
var errorMessage = "A specified notebook must not be readonly";
ENSDKLogger.ENSDKLogError(errorMessage);
throw new ArgumentException(errorMessage);
}
if (!IsAuthenticated)
{
throw new ENAuthExpiredException();
}
// Run size validation on any resources included with the note. This is done at upload time because
// the sizes are a function of the user's service level, which can change.
if (!note.ValidateForLimits())
{
ENSDKLogger.ENSDKLogError("Note failed limits validation. Cannot upload.");
throw new ENLimitReachedException();
}
ENSessionUploadContext context = new ENSessionUploadContext();
if (noteToReplace != null)
{
context.Note = note.EDAMNoteToReplaceServiceNoteGUID(noteToReplace.Guid);
}
else
{
context.Note = note.EDAMNote();
}
context.RefToReplace = noteToReplace;
context.Notebook = notebook;
context.Policy = policy;
context = UploadNote_DetermineDestination(context);
return context.NoteRef;
}
private ENSessionListNotebooksContext ListNotebooks_ProcessBusinessNotebooks(ENSessionListNotebooksContext context)
{
// Postprocess our notebook sets for business notebooks. For every linked notebook in the personal
// account, check for a corresponding business shared notebook (by shareKey). If we find it, also
// grab its corresponding notebook object from the business notebook list.
List<LinkedNotebook> linkedPersonalNotebooksCopy = new List<LinkedNotebook>(context.LinkedPersonalNotebooks);
foreach (LinkedNotebook linkedNotebook in linkedPersonalNotebooksCopy)
{
SharedNotebook sharedNotebook = null;
context.SharedBusinessNotebooks.TryGetValue(linkedNotebook.ShareKey, out sharedNotebook);
if (sharedNotebook != null)
{
// This linked notebook corresponds to a business notebook.
Notebook businessNotebook = context.BusinessNotebooks[sharedNotebook.NotebookGuid];
ENNotebook result = new ENNotebook(businessNotebook, sharedNotebook, linkedNotebook);
context.ResultNotebooks.Add(result);
context.LinkedPersonalNotebooks.Remove(linkedNotebook);
}
}
// Any remaining linked notebooks are personal shared notebooks. No shared notebooks?
// Then go directly to results preparation.
if (context.LinkedPersonalNotebooks.Count == 0)
{
context = ListNotebooks_PrepareResults(context);
}
else
{
context = ListNotebooks_FetchSharedNotebooks(context);
}
return context;
}
private ENSessionListNotebooksContext ListNotebooks_ProcessSharedNotebooks(ENSessionListNotebooksContext context)
{
// Process the results
foreach (LinkedNotebook linkedNotebook in context.LinkedPersonalNotebooks)
{
object sharedNotebook = context.SharedNotebooks[linkedNotebook.Guid];
ENNotebook result = null;
if (sharedNotebook.GetType() == typeof(SharedNotebook))
{
// Shared notebook with individuals
result = new ENNotebook((SharedNotebook)sharedNotebook, linkedNotebook);
}
else
{
// Public notebook
result = new ENNotebook((Notebook)sharedNotebook, linkedNotebook);
}
context.ResultNotebooks.Add(result);
}
context = ListNotebooks_PrepareResults(context);
return context;
}
private ENSessionListNotebooksContext ListNotebooks_ListNotebooks(ENSessionListNotebooksContext context)
{
List<Notebook> notebooks = PrimaryNoteStore.ListNotebooks();
if (notebooks.Count > 0)
{
// Populate the result list with personal notebooks.
foreach (Notebook book in notebooks)
{
ENNotebook result = new ENNotebook(book);
context.ResultNotebooks.Add(result);
}
// Now get any shared notebook records for the personal account.
context = ListNotebooks_ListSharedNotebooks(context);
}
else
{
// This must be a single notebook auth token, so try getting linked notebooks.
context = ListNotebooks_ListLinkedNotebooks(context);
}
return context;
}
internal object NoteStoreForNotebook(ENNotebook notebook)
{
if (notebook.IsBusinessNotebook)
{
return BusinessNoteStore;
}
else if (notebook.IsLinked)
{
return NoteStoreForLinkedNotebook(notebook.LinkedNotebook);
}
else
{
return PrimaryNoteStore;
}
}
public ENCollection FindNotes(string noteSearchString, ENNotebook notebook, SearchScope scope, SortOrder order, int maxResults)
{
List<ENSessionFindNotesResult> results = ENSession.SharedSession.FindNotes(ENNoteSearch.NoteSearch(noteSearchString), notebook, scope, order, maxResults);
ENCollection comResults = new ENCollection();
foreach (ENSessionFindNotesResult result in results)
{
object tempvar = result;
comResults.Add(ref tempvar);
}
//foreach (var result in results)
//{
// var tempVar = result;
// comResults.Add(ref tempVar);
//}
////foreach (var result in results)
////{
//// object null_object = null;
//// object null_object2 = null;
//// object null_object3 = null;
//// object temp_object = result;
//// comResults.Add(ref temp_object, ref null_object, ref null_object2, ref null_object3);
////}
return comResults;
}
public List<ENSessionFindNotesResult> FindNotes(ENNoteSearch noteSearch, ENNotebook notebook, SearchScope scope, SortOrder order, int maxResults)
{
if (!IsAuthenticated)
{
throw new ENAuthExpiredException();
}
// App notebook scope is internally just an "all" search, because we don't a priori know where the app
// notebook is. There's some room for a fast path in this flow if we have a saved linked record to a
// linked app notebook, but that case is likely rare enough to prevent complexifying this code for.
if (scope.HasFlag(SearchScope.AppNotebook))
{
scope = SearchScope.All;
}
// Validate the scope and sort arguments.
if (notebook != null && scope != SearchScope.None)
{
ENSDKLogger.ENSDKLogError("No search scope necessary if notebook provided.");
scope = SearchScope.None;
}
else if (notebook == null && scope == SearchScope.None)
{
ENSDKLogger.ENSDKLogError("Search scope or notebook must be specified. Defaulting to personal scope.");
scope = SearchScope.DefaultScope;
}
bool requiresLocalMerge = false;
if (scope != SearchScope.None)
{
// Check for multiple scopes. Because linked scope can subsume multiple linked notebooks, that *always* triggers
// the multiple scopes. If not, then both personal and business must be set together.
if ((scope.HasFlag(SearchScope.Personal) && scope.HasFlag(SearchScope.Business)) || scope.HasFlag(SearchScope.PersonalLinked))
{
// If we're asked for multiple scopes, relevance is not longer supportable (since we
// don't know how to combine relevance on the client), so default to updated date,
// which is probably the closest proxy to relevance.
if (order.HasFlag(SortOrder.Relevance))
{
ENSDKLogger.ENSDKLogError("Cannot sort by relevance across multiple search scopes. Using update date.");
order = (EvernoteSDK.ENSession.SortOrder)EN_FLAG_CLEAR(order, SortOrder.Relevance);
order = (EvernoteSDK.ENSession.SortOrder)EN_FLAG_SET(order, SortOrder.RecentlyUpdated);
}
requiresLocalMerge = true;
}
}
NotesMetadataResultSpec resultSpec = new NotesMetadataResultSpec();
resultSpec.IncludeNotebookGuid = true;
resultSpec.IncludeTitle = true;
resultSpec.IncludeCreated = true;
resultSpec.IncludeUpdated = true;
resultSpec.IncludeUpdateSequenceNum = true;
NoteFilter noteFilter = new NoteFilter();
noteFilter.Words = noteSearch.SearchString;
if (order.HasFlag(SortOrder.Title))
{
noteFilter.Order = (System.Int32)NoteSortOrder.TITLE;
}
else if (order.HasFlag(SortOrder.RecentlyCreated))
{
noteFilter.Order = (System.Int32)NoteSortOrder.CREATED;
}
else if (order.HasFlag(SortOrder.RecentlyUpdated))
{
noteFilter.Order = (System.Int32)NoteSortOrder.UPDATED;
}
else if (order.HasFlag(SortOrder.Relevance))
{
noteFilter.Order = (System.Int32)NoteSortOrder.RELEVANCE;
}
// "Normal" sort is ascending for titles, and descending for dates and relevance.
bool sortAscending = order.HasFlag(SortOrder.Title) ? true : false;
if (order.HasFlag(SortOrder.Reverse))
{
sortAscending = !sortAscending;
}
noteFilter.Ascending = sortAscending;
if (notebook != null)
{
noteFilter.NotebookGuid = notebook.Guid;
}
// Set up context
ENSessionFindNotesContext context = new ENSessionFindNotesContext();
context.scopeNotebook = notebook;
context.scope = scope;
context.order = order;
context.noteFilter = noteFilter;
context.resultSpec = resultSpec;
context.maxResults = maxResults;
context.findMetadataResults = new List<NoteMetadata>();
context.requiresLocalMerge = requiresLocalMerge;
context.sortAscending = sortAscending;
// If we have a scope notebook, we already know what notebook the results will appear in.
// If we don't have a scope notebook, then we need to query for all the notebooks to determine
// where to search.
if (context.scopeNotebook == null)
{
context = FindNotes_ListNotebooks(context);
return context.results;
}
context = FindNotes_FindInPersonalScope(context);
return context.results;
}
public ENCollection FindNotesForCOM(ENNoteSearch noteSearch, ENNotebook notebook, SearchScope scope, SortOrder order, int maxResults)
{
System.Windows.Forms.MessageBox.Show("Finding...", "Debug", System.Windows.Forms.MessageBoxButtons.OK);
List<ENSessionFindNotesResult> results = ENSession.SharedSession.FindNotes(noteSearch, notebook, scope, order, maxResults);
System.Windows.Forms.MessageBox.Show(results.Count.ToString(),"Debug",System.Windows.Forms.MessageBoxButtons.OK);
ENCollection comResults = new ENCollection();
foreach (ENSessionFindNotesResult result in results)
{
object tempvar = result;
comResults.Add(ref tempvar);
}
return comResults;
}