private ENSessionUploadContext UploadNote_DetermineDestination(ENSessionUploadContext context)
{
// Begin prepping a resulting note ref.
context.NoteRef = new ENNoteRef();
// If this app uses an app notebook and that notebook is linked, then no matter what the caller says,
// we're going to need to use the explicit notebook destination to comply with shared notebook auth.
if (AppNotebookIsLinked)
{
// Do we have a cached linked notebook record to use as a destination?
LinkedNotebook linkedNotebook = (LinkedNotebook)Preferences.ObjectForKey(ENSessionPreferencesLinkedAppNotebook);
if (linkedNotebook != null)
{
context.NoteStore = NoteStoreForLinkedNotebook(linkedNotebook);
context.NoteRef.Type = ENNoteRef.ENNoteRefType.TypeShared;
context.NoteRef.LinkedNotebook = ENLinkedNotebookRef.LinkedNotebookRefFromLinkedNotebook(linkedNotebook);
// Because we are using a linked app notebook, and authenticating to it with the shared auth model,
// we must provide a notebook guid in the note or face an error.
SharedNotebook sharedNotebook = (SharedNotebook)Preferences.ObjectForKey(ENSessionPreferencesSharedAppNotebook);
context.Note.NotebookGuid = sharedNotebook.NotebookGuid;
}
else
{
// We don't have a linked notebook record to use. We need to go find one.
context = UploadNote_FindLinkedAppNotebook(context);
return context;
}
}
if (context.NoteStore == null)
{
if (context.RefToReplace != null)
{
context.NoteStore = NoteStoreForNoteRef(context.RefToReplace);
context.NoteRef.Type = context.RefToReplace.Type;
context.NoteRef.LinkedNotebook = context.RefToReplace.LinkedNotebook;
}
else if (context.Notebook != null && context.Notebook.IsBusinessNotebook)
{
context.NoteStore = BusinessNoteStore;
context.NoteRef.Type = ENNoteRef.ENNoteRefType.TypeBusiness;
}
else if (context.Notebook != null && context.Notebook.IsLinked)
{
context.NoteStore = NoteStoreForLinkedNotebook(context.Notebook.LinkedNotebook);
context.NoteRef.Type = ENNoteRef.ENNoteRefType.TypeShared;
context.NoteRef.LinkedNotebook = ENLinkedNotebookRef.LinkedNotebookRefFromLinkedNotebook(context.Notebook.LinkedNotebook);
}
else
{
// This is the normal case. Either the app has not specified a destination notebook, or the
// notebook is personal.
context.NoteStore = PrimaryNoteStore;
context.NoteRef.Type = ENNoteRef.ENNoteRefType.TypePersonal;
}
}
if (context.RefToReplace != null)
{
context = UploadNote_Update(context);
}
else
{
context = UploadNote_Create(context);
}
return context;
}
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 ENSessionUploadContext UploadNote_Create(ENSessionUploadContext context)
{
// Clear create and update dates. The service will set these to sensible defaults for a new note.
context.Note.Created = 0;
context.Note.Updated = 0;
// Write in the notebook guid if we're providing one.
if (context.Note.NotebookGuid == null && context.Notebook != null)
{
context.Note.NotebookGuid = context.Notebook.Guid;
}
try
{
Note resultNote = context.NoteStore.CreateNote(context.Note);
context.NoteRef.Guid = resultNote.Guid;
//context = UploadNote_Complete(context)
}
catch (Exception ex)
{
context.NoteRef = null;
ENSDKLogger.ENSDKLogError(string.Format("Failed to createNote for uploadNote: {0}", ex.Message));
throw new Evernote.EDAM.Error.EDAMNotFoundException();
}
return context;
}
private ENSessionUploadContext UploadNote_FindSharedAppNotebook(ENSessionUploadContext context)
{
LinkedNotebook linkedNotebook = (LinkedNotebook)Preferences.ObjectForKey(ENSessionPreferencesLinkedAppNotebook);
ENNoteStoreClient linkedNoteStore = NoteStoreForLinkedNotebook(linkedNotebook);
try
{
SharedNotebook sharedNotebook = linkedNoteStore.GetSharedNotebookByAuth();
if (sharedNotebook != null)
{
// Persist the shared notebook record.
Preferences.SetObject(sharedNotebook, ENSessionPreferencesSharedAppNotebook);
// Go back and redetermine the destination.
context = UploadNote_DetermineDestination(context);
}
else
{
// Uh-oh; there's no destination to use. We have to fail the request.
ENSDKLogger.ENSDKLogError("getSharedNotebookByAuth for uploadNote returned empty sharedNotebook; turning into NotFound.");
throw new Evernote.EDAM.Error.EDAMNotFoundException();
}
}
catch (Exception ex)
{
// Uh-oh; there's no destination to use. We have to fail the request.
ENSDKLogger.ENSDKLogError(string.Format("Failed to getSharedNotebookByAuth for uploadNote; turning into NotFound: {0}", ex.Message));
throw new Evernote.EDAM.Error.EDAMNotFoundException();
}
return context;
}
private ENSessionUploadContext UploadNote_FindLinkedAppNotebook(ENSessionUploadContext context)
{
try
{
// We know the app notebook is linked. List linked notebooks; we expect to find a single result.
List<LinkedNotebook> linkedNotebooks = PrimaryNoteStore.ListLinkedNotebooks();
if (linkedNotebooks.Count < 1)
{
// Uh-oh; there's no destination to use. We have to fail the request.
string errorMessage = "Cannot find linked app notebook. Perhaps user deleted it?";
ENSDKLogger.ENSDKLogError(errorMessage);
throw new Exception(errorMessage);
}
if (linkedNotebooks.Count > 1)
{
ENSDKLogger.ENSDKLogInfo(string.Format("Expected to find single linked notebook, found {0}", linkedNotebooks.Count));
}
// Take this notebook, and cache it.
LinkedNotebook linkedNotebook = linkedNotebooks[0];
if (linkedNotebook.ShareKey == null)
{
// The notebook is a public notebook so it's read only. Fail the request with error.
throw new ENPermissionDeniedException();
}
Preferences.SetObject(linkedNotebook, ENSessionPreferencesLinkedAppNotebook);
// Go find the shared notebook that corresponds to this.
context = UploadNote_FindSharedAppNotebook(context);
return context;
}
catch (Exception ex)
{
// Uh-oh; there's no destination to use. We have to fail the request.
ENSDKLogger.ENSDKLogError(string.Format("Failed to listLinkedNotebooks for uploadNote; turning into NotFound: {0}", ex.Message));
throw new Evernote.EDAM.Error.EDAMNotFoundException();
}
}
private ENSessionUploadContext UploadNote_Update(ENSessionUploadContext context)
{
// If we're replacing a note, fixup the update date.
context.Note.Updated = DateTime.Now.ToEdamTimestamp();
context.Note.Guid = context.RefToReplace.Guid;
context.Note.Active = true;
try
{
Note resultNote = context.NoteStore.UpdateNote(context.Note);
context.NoteRef = context.RefToReplace; // The result by definition has the same ref.
//context = UploadNote_Complete(context)
}
catch (Evernote.EDAM.Error.EDAMNotFoundException ex)
{
if (ex.Message.Contains("Note.guid"))
{
// We tried to replace a note that isn't there anymore. Now we look at the replacement policy.
if (context.Policy == UploadPolicy.ReplaceOrCreate)
{
// Can't update it, just create it anew.
context.Note.Guid = null;
context.Policy = UploadPolicy.Create;
context.RefToReplace = null;
// Go back to determining the destination before creating. We'll take into account a supplied
// notebook at this point, which may actually be in a different place than the note we were
// trying to replace. We don't have enough information otherwise to reliably place a new note
// in the same notebook as the original one, so defaulting to a default notebook in a given
// note store is less predictable than defaulting to the default overall. In practice, this
// works out the same most of the time. (For app notebook apps, it'll end up in the app notebook
// anyway of course.)
context = UploadNote_DetermineDestination(context);
return context;
}
}
ENSDKLogger.ENSDKLogError(string.Format("Failed to updateNote for uploadNote: {0}", ex.Message));
throw new Exception(ex.Message, ex.InnerException);
}
catch (Exception ex)
{
ENSDKLogger.ENSDKLogError(string.Format("Failed to updateNote for uploadNote: {0}", ex.Message));
throw new Exception(ex.Message, ex.InnerException);
}
//context = UploadNote_Complete(context)
return context;
}
