public async Task <string> Upload(string targetPath, string targetFileName, Stream stream, CancellationToken?ct = null)
{
LiveOperationResult res;
if (ct != null)
{
res = await _liveConnectClient.UploadAsync("me/skydrive/" + targetPath, targetFileName, stream, OverwriteOption.Overwrite, ct.Value, null);
}
else
{
res = await _liveConnectClient.UploadAsync("me/skydrive/" + targetPath, targetFileName, stream, OverwriteOption.Overwrite);
}
return(res.Result["id"].ToString());
}
public async Task BackupLocalDatabase()
{
string toUploadDatabaseName = "toUploadDatabase.sdf";
//release all resources from DB
App.AppViewModel.DisposeCurrentDB();
// Obtain the virtual store for the application.
IsolatedStorageFile iso = IsolatedStorageFile.GetUserStoreForApplication();
iso.CopyFile(AppResources.DatabaseName + ".sdf", toUploadDatabaseName, true);
App.AppViewModel.ConnectDB();
LiveConnectClient liveClient = new LiveConnectClient(oneDriveAuthClient.Session);
try
{
using (Stream uploadStream = iso.OpenFile(toUploadDatabaseName, FileMode.Open))
{
if (uploadStream != null)
{
LiveOperationResult uploadResult = await liveClient.UploadAsync(oneDriveFolderId, databaseBackupname + ".sdf", uploadStream, OverwriteOption.Overwrite);
MessageBox.Show("Upload successful.");
}
}
iso.DeleteFile(toUploadDatabaseName);
await getFileFromBackupFolderAsync();
}
catch (LiveConnectException ex)
{
App.AppViewModel.SendExceptionReport(ex);
}
}
private void btnUploadDirectory_Click(object sender, RoutedEventArgs e)
{
//Show folder picker...
var dialog = new System.Windows.Forms.FolderBrowserDialog();
dialog.ShowDialog();
//END Show folder picker...
//Get a recusive list of all files...
if (dialog.SelectedPath == "")
{
System.Windows.MessageBox.Show("No folder selected.");
return;
}
string[] files = Directory.GetFiles(dialog.SelectedPath, "*.*", SearchOption.AllDirectories);
foreach (string file in files)
{
txtRaw.Text += file + "\r\n";
LiveConnectClient client = new LiveConnectClient(Properties.session);
client.UploadCompleted += this.ConnectClient_UploadCompleted;
var stream = default(Stream);
stream = File.OpenRead(file);
client.UploadAsync(Properties.UltiDriveFolderID + "/files", file, stream, stream);
stream.Close();
//System.Windows.MessageBox.Show(file);
}
//END Get a recursive list of all files...
}
void client_GetCompleted(object sender, LiveOperationCompletedEventArgs e)
{
try
{
if (e.Result.ContainsKey("available"))
{
Int64 available = Convert.ToInt64(e.Result["available"]);
byte[] data = RecordManager.GetRecordByteArray(MainPageViewModel.Instance.CurrentlyUploading);
if (available >= data.Length)
{
MemoryStream stream = new MemoryStream(data);
client = new LiveConnectClient(App.MicrosoftAccountSession);
client.UploadCompleted += MicrosoftAccountClient_UploadCompleted;
client.UploadProgressChanged += MicrosoftAccountClient_UploadProgressChanged;
client.UploadAsync("me/skydrive", MainPageViewModel.Instance.CurrentlyUploading,
stream, OverwriteOption.Overwrite);
grdUpload.Visibility = System.Windows.Visibility.Visible;
ApplicationBar.IsVisible = false;
}
else
{
MessageBox.Show("Looks like you don't have enough space on your SkyDrive. Go to http://skydrive.com and either purchase more space or clean up the existing storage.", "Upload",
MessageBoxButton.OK);
}
}
}
catch
{
FailureAlert();
}
}
/// <summary>
/// uplaods a picture to sky drive.
/// </summary>
/// <param name="e"></param>
private void UploadPicture(PhotoResult e)
{
LiveConnectClient uploadClient = new LiveConnectClient(App.Session);
uploadClient.UploadCompleted
+= new EventHandler <LiveOperationCompletedEventArgs>(ISFile_UploadCompleted);
if (e.OriginalFileName == null)
{
return;
}
// file name is the current datetime stapm
string ext = e.OriginalFileName.Substring(e.OriginalFileName.LastIndexOf('.'));
DateTime dt = DateTime.Now;
string fileName = String.Format("{0:d_MM_yyy_HH_mm_ss}", dt);
fileName = fileName + ext;
string progMsgUpPic = SkyPhoto.Resources.Resources.progMsgUpPic;
ShowProgressBar(progMsgUpPic);
try
{
uploadClient.UploadAsync(App.CurrentAlbum.ID, fileName, e.ChosenPhoto, OverwriteOption.Overwrite);
}
catch (Exception)
{
string upFaild = SkyPhoto.Resources.Resources.upFaild;
MessageBox.Show(upFaild);
HideProgressBar();
}
}
public void uploadFile(string filename, System.IO.Stream file, string skydrivePath = "folder.559920a76be10760.559920A76BE10760!162")
{
LiveConnectClient client = new LiveConnectClient(App.Session);
client.UploadAsync(skydrivePath, filename, file, OverwriteOption.Overwrite);
client.UploadCompleted += new EventHandler <LiveOperationCompletedEventArgs>(UploadCompleted);
}
private void CreateFolder3_Completed(object sender, LiveOperationCompletedEventArgs e)
{
if (e.Error == null)
{
infoTextBlock.Text = txtnote.Resources.StringLibrary.shareInfo_3;
Dictionary <string, object> folder = (Dictionary <string, object>)e.Result;
skyDriveFolderID_merge = folder["id"].ToString(); //grab the folder ID
//merge文件夹建立后，自动上传merge的空文件
byte[] b2 = System.Text.Encoding.UTF8.GetBytes("");
MemoryStream file = new MemoryStream(b2);
client.UploadAsync(skyDriveFolderID_merge, "txtNote_Merge.txt", file, OverwriteOption.Overwrite);
}
else
{
MessageBox.Show(e.Error.Message);
}
}
private void SaveButtonClick(object sender, EventArgs e)
{
TextBox textBox = new TextBox()
{
Margin = new Thickness(0, 14, 0, -2)
};
CustomMessageBox box = new CustomMessageBox()
{
Caption = "Save to SkyDrive",
Message = "Enter file name",
LeftButtonContent = "ok",
RightButtonContent = "cancel",
Content = textBox
};
box.Dismissed += async(s, boxEventArgs) =>
{
switch (boxEventArgs.Result)
{
case CustomMessageBoxResult.LeftButton:
if (!string.IsNullOrWhiteSpace(textBox.Text))
{
using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication())
{
try
{
using (var fileStream = store.OpenFile("sound.wav", FileMode.Open, FileAccess.Read, FileShare.Read))
{
string filename = textBox.Text + ".wav";
LiveOperationResult res = await client.UploadAsync("me/skydrive",
filename,
fileStream,
OverwriteOption.Overwrite);
MessageBoxResult result =
MessageBox.Show("File " + filename + " uploaded",
"SkyDrive Sign-in", MessageBoxButton.OK);
}
}
catch (Exception ex)
{
}
}
}
break;
default:
break;
}
};
box.Show();
/**/
}
public void UploadFile()
{
if (skyDriveFolderID != string.Empty) //the folder must exist, it should have already been created
{
this.client.UploadCompleted
+= new EventHandler <LiveOperationCompletedEventArgs>(ISFile_UploadCompleted);
_progressIndicator.IsVisible = true;
_progressIndicator.Text = "Przesyłanie kopii zapasowej...";
// tblDate.Text = "";
try
{
int count = 0;
var fotoToSync = App.ViewModel.GetAllFotoToSync();
foreach (Foto ft in fotoToSync)
{
count += 1;
_progressIndicator.Text = "Przesyłanie pliku " + count + " z " + fotoToSync.Count;
object[] state = new object[1];
state[0] = ft.FotoId;
using (IsolatedStorageFile myIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication())
{
using (IsolatedStorageFileStream stream = myIsolatedStorage.OpenFile(ft.FotoPath, System.IO.FileMode.Create))
{
stream.Write(ft.FotoImage, 0, ft.FotoImage.Length);
}
readStream = myIsolatedStorage.OpenFile(ft.FotoPath, FileMode.Open);
client.UploadAsync(skyDriveFolderID, ft.FotoPath, true, readStream, ft.FotoId);
}
}
if (!fotoToSync.Any())
{
tblInfo.Text = "Brak plików do przesłania.";
}
}
catch
{
_progressIndicator.IsVisible = false;
MessageBox.Show("Błąd dostępu IsolatedStorage. Proszę zamknąć aplikację i otworzyć ją ponownie, a następnie spróbuj ponownie stworzenie kopii zapasowyej!", "Backup Failed", MessageBoxButton.OK);
tblInfo.Text = "Błąd. Zamknij aplikację i uruchom ponownie.";
//tblDate.Text = "";
}
finally
{
_progressIndicator.IsVisible = false;
}
}
}
public void SaveFile()
{
byte[] myBytes = AES.Encrypt(this.SerializeToXML(), _password);
MemoryStream ms = new MemoryStream(myBytes);
var clientFolder = new LiveConnectClient(App.Session);
clientFolder.UploadCompleted += (object sender, LiveOperationCompletedEventArgs e) =>
{
if (e.Error != null)
{
MessageBox.Show(e.Error.Message, "Upload Failed", MessageBoxButton.OK);
}
string name = e.Result["name"].ToString();
string id = e.Result["id"].ToString();
if (App.MyWalletFile == null)
{
App.MyWalletFile = new WalletFileWM {
FileId = id, FileName = name
};
App.MyWallet = this;
}
ms.Dispose();
};
if (App.MyWalletFile == null)
{
clientFolder.UploadAsync("me/skydrive", FileName, ms, OverwriteOption.Rename);
}
else
{
clientFolder.UploadAsync(App.MyWalletFile.FileId, FileName, ms, OverwriteOption.Overwrite);
}
if (OnSaveCompleted != null)
{
OnSaveCompleted(this, null);
}
}
void task_Completed(object sender, PhotoResult e)
{
if (e.ChosenPhoto == null)
{
return;
}
LiveConnectClient uploadClient = new LiveConnectClient(App.Session);
uploadClient.UploadCompleted += new EventHandler <LiveOperationCompletedEventArgs>(uploadClient_UploadCompleted);
uploadClient.UploadAsync(SelectedAlbum.ID, "Image" + DateTime.Now.Millisecond + ".jpg", e.ChosenPhoto);
}
public async void UploadFile(string fileName)
{
try
{
var stream = _memoryService.ReadFile(fileName);
await _client.UploadAsync(_folderId, fileName, stream, OverwriteOption.Overwrite);
OnUploadCompleted(fileName, true);
}
catch (Exception)
{
OnUploadCompleted(fileName, false);
}
}
public bool Upload(string currentFolderID, string remoteFileName, Stream fileStream, OverwriteOption overwriteOption, Action <SkyDriveResult <bool> > callback)
{
lock (_syncRoot)
{
if (!IsWorking && Logged)
{
IsWorking = true;
_uploadCallback = callback;
LiveClient.UploadAsync(currentFolderID, remoteFileName, fileStream, overwriteOption);
return(true);
}
}
return(false);
}
public virtual async Task UploadPasswords()
{
if (!IsConnected)
{
await Login();
}
if (!IsConnected)
{
return;
}
IsolatedStorageFile isoStore = IsolatedStorageFile.GetUserStoreForApplication();
if (isoStore.FileExists("accounts.dat"))
{
using (IsolatedStorageFileStream isoStream = new IsolatedStorageFileStream("accounts.dat", FileMode.Open, isoStore))
{
var res = await _connectClient.UploadAsync(_pkFolderId, "passwords.txt", isoStream, OverwriteOption.Overwrite);
_filePasswordsId = res.Result["id"] as string;
}
}
}
internal async void RunTaskAsync(LiveConnectClient client, Action <bool> callback)
{
bool succeeded = true;
using (var stream = await File.OpenStreamForReadAsync())
{
try
{
const int backgroundTheshold = 1024 * 1024 * 100;
if (stream.Length >= backgroundTheshold)
{
const string rootPath = "/shell/transfers";
var tempFilePath = string.Format("{0}/{1}/{2}", rootPath, FolderId, FileName);
using (var storage = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!storage.DirectoryExists(rootPath))
{
storage.CreateDirectory(rootPath);
}
if (storage.FileExists(tempFilePath))
{
storage.DeleteFile(tempFilePath);
}
using (var file = storage.CreateFile(tempFilePath))
{
var position = stream.Position;
await stream.CopyToAsync(file);
stream.Position = position;
}
}
client.BackgroundTransferPreferences = BackgroundTransferPreferences.None;
await client.BackgroundUploadAsync(FolderId, new Uri(tempFilePath, UriKind.Relative), OverwriteOption.Overwrite);
}
else
{
await client.UploadAsync(FolderId, FileName, stream, OverwriteOption.Overwrite);
}
}
catch (Exception)
{
succeeded = false;
}
}
if (callback != null)
{
callback(succeeded);
}
}
void Folder_Upload()
{
if (sky_base_folder_id != null)
{
if (wait_async == false)
{
wait_async = true;
list_files_isolated = My_Isolated_Storage.GetFileNames("GPX\\*.gpx");
progress_multiple = true;
Progress_Init();
int loop_count = 0;
client.UploadCompleted += new EventHandler <LiveOperationCompletedEventArgs>(Folder_Upload_Completed);
foreach (string content in list_files_isolated)
{
int scan_loop = 0;
bool scan_file_exist = false;
while (scan_loop + 1 <= list_files_skydrive.Count())
{
if (content == list_files_skydrive.ElementAt(scan_loop).Name.ToString())
{
scan_file_exist = true;
//MessageBox.Show("Deja existant : " + content);
}
scan_loop += 1;
}
if (scan_file_exist == false)
{
progress_list.Add(0);
IsolatedStorageFileStream fileStream = My_Isolated_Storage.OpenFile("GPX\\" + content, FileMode.Open, FileAccess.Read);
StreamReader reader = new StreamReader(fileStream);
client.UploadAsync(sky_base_folder_id, content + ".txt", fileStream, OverwriteOption.DoNotOverwrite, loop_count);
loop_count = loop_count + 1;
}
}
if (loop_count == 0)
{
wait_async = false;
client.UploadCompleted -= Folder_Upload_Completed;
SystemTray.ProgressIndicator.IsVisible = false;
//MessageBox.Show("Tous les fichiers ont été envoyés.");
}
}
}
else
{
MessageBox.Show("Erreur upload: sky_base_folder_id = null");
}
}
public async Task <bool> SaveToSkyDrive(SkyDriveSaveArgs args)
{
bool uploadSuccess = false;
try
{
var loginResult = await _authClient.LoginAsync(LiveConfig.Scopes);
if (loginResult.Status == LiveConnectSessionStatus.Connected)
{
LiveConnectClient client = new LiveConnectClient(loginResult.Session);
var foldersResult = await client.GetAsync("me/skydrive/files?filter=folders");
var folders = foldersResult.Result["data"] as List <object>;
if (folders != null)
{
var folderQuery = (from f in folders
where f is IDictionary <string, object>
select(IDictionary <string, object>) f);
_whatIEatFolderId = folderQuery.Where(it => it["name"].ToString().ToLowerInvariant().Equals("what i eat")).Select(it => it["id"].ToString()).FirstOrDefault();
}
if (string.IsNullOrWhiteSpace(_whatIEatFolderId))
{
Dictionary <string, object> folderData = new Dictionary <string, object>();
folderData.Add("name", "What I Eat");
var folderCreateResult = await client.PostAsync("me/skydrive", folderData);
_whatIEatFolderId = folderCreateResult.Result["id"].ToString();
}
if (!string.IsNullOrWhiteSpace(_whatIEatFolderId))
{
using (var ms = new MemoryStream(args.Encoding.GetBytes(args.Content)))
{
var uploadResult = await client.UploadAsync(_whatIEatFolderId, args.Filename, ms, OverwriteOption.Overwrite);
uploadSuccess = true;
}
}
}
}
catch (Exception ex)
{
//TODO: Log Exception
_log.LogException(ex, "SkyDrive Upload Error");
}
return(uploadSuccess);
}
public static async Task <string> upload(string filename)
{
string res = "";
//diagLog("Uploading " + file);
try
{
string[] requiredScope = { "wl.offline_access", "wl.skydrive_update" };
LiveAuthClient auth = new LiveAuthClient(Secrets.ClientID);
await auth.InitializeAsync(requiredScope);
if (auth.Session == null)
{
await auth.LoginAsync(requiredScope);
}
LiveConnectClient liveClient = new LiveConnectClient(auth.Session);
string folderid = await GetSkyDriveFolderID(FOLDER, liveClient);
if (folderid == null)
{
folderid = await createSkyDriveFolder(FOLDER, liveClient);
res = "Created folder: " + FOLDER + "\n"; // , "ID:", folderid);
}
var store = IsolatedStorageFile.GetUserStoreForApplication();
if (store.FileExists(filename))
{
var file = store.OpenFile(filename, System.IO.FileMode.Open, System.IO.FileAccess.Read);
LiveOperationResult operationResult = await liveClient.UploadAsync(folderid, filename, file, OverwriteOption.Overwrite);
dynamic result = operationResult.Result;
res += "Uploaded :" + result.name; //, "ID:", result.id);
}
else
{
throw new Exception("file does not exist");
}
}
catch (Exception exception)
{
res = "Error uploading file: " + exception.Message;
}
return(res);
}
private void PerformDeviceToCloudSync(LiveConnectSession session, string syncFilename, Action <BookmarkserviceImportCompletedEventArgs> completedAction, BookmarkserviceImportCompletedEventArgs completedEventArgs)
{
//get device bookmarks
List <Bookmark> deviceBookmarks = RetrieveDeviceBookmarks();
//upload
string syncFileContents = GenerateNetscapBookmarkFile(syncFilename, deviceBookmarks);
LiveConnectClient uploadClient = new LiveConnectClient(session);
uploadClient.UploadCompleted += delegate(object uploadSender, LiveOperationCompletedEventArgs e)
{
#warning update the internal file name if non existant
completedEventArgs.StatusCode = ImportStatusCode.Success;
completedAction(completedEventArgs);
};
Stream uploadStream = new MemoryStream(Encoding.UTF8.GetBytes(syncFileContents));
uploadClient.UploadAsync("me/skydrive", syncFilename, true, uploadStream, null);
}
private void UploadItems(ListItem item)
{
_uploadCounter++;
var newFile = new MemoryStream();
var writer = new StreamWriter(newFile);
foreach (var listItem in item.Items)
{
if (listItem.Deleted)
{
continue;
}
writer.WriteLine("{0}{1}", listItem.Mark ? "-" : "", listItem.Name);
}
writer.Flush();
newFile.Flush();
newFile.Seek(0, SeekOrigin.Begin);
//writer.Close();
_client.UploadAsync(App.Current.SkyDriveFolders.FolderID, item.Name + ".txt", true, newFile, item);
}
public async static Task <string> UploadAsync(string folderId, string fileName, Stream data)
{
string fileId = null;
try
{
LiveOperationResult operationResult = await _client.UploadAsync(folderId, fileName, data, OverwriteOption.Overwrite);
foreach (var item in operationResult.Result)
{
if (item.Key == "id")
{
fileId = item.Value as string;
break;
}
}
}
catch (Exception) { }
return(fileId);
}
public static async Task <string> UploadFileAsync(string sourceFileName, string destinationFileName, CancellationToken ct, IProgress <LiveOperationProgress> progress)
{
if (_session == null)
{
throw new InvalidOperationException("Session is null");
}
string uploadFileName = _specialRegEx.Replace(destinationFileName, "-");
LiveConnectClient client = new LiveConnectClient(_session);
using (var fileStream = await StorageHelper.OpenFileForReadAsync(sourceFileName))
{
var folderId = await GetOrCreateFolderAsync("Voice Memos", ct);
var operationResult = await client.UploadAsync(folderId, uploadFileName, fileStream, OverwriteOption.Overwrite, ct, progress);
dynamic result = operationResult.Result;
return(result.id);
}
}
private void BeginUpload(string localFilePath)
{
try
{
using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication())
{
_currentUlFileStream = isf.OpenFile(localFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
Log("Starts UploadAsync");
StartTaskAndContinueWith(
() => _liveClient.UploadAsync(_uploadsFolderId, Path.GetFileName(localFilePath), _currentUlFileStream, OverwriteOption.Overwrite),
t => OnLiveClientUploadCompleted(t, localFilePath));
}
}
catch (Exception e)
{
Geowigo.Utils.DebugUtils.DumpException(e, "BeginUpload failed for " + localFilePath, true);
// Forces a post-process of the upload to discard this file and try another one.
PostProcessUpload(localFilePath);
}
}
private static async Task updateSourceAsync(WebFileStream stream)
{
var skyProfile = stream.Profile as SkyDriveProfile;
var skyModel = stream.EntryModel as SkyDriveItemModel;
await skyProfile.checkLoginAsync();
CancellationTokenSource cts = new CancellationTokenSource();
var progressHandler = new Progress <LiveOperationProgress>(
(progress) => { });
LiveConnectClient liveClient = new LiveConnectClient(skyProfile.Session);
LiveOperationResult result;
stream.Seek(0, SeekOrigin.Begin);
var uid = (skyModel.Parent as SkyDriveItemModel).UniqueId;
result = await liveClient.UploadAsync(uid,
skyModel.Name, stream, OverwriteOption.Overwrite, cts.Token, progressHandler);
skyModel.init(skyProfile, skyModel.FullPath, result.Result);
}
public static void UploadFile()
{
if (skyDriveFolderID != string.Empty) //the folder must exist, it should have already been created
{
client.UploadCompleted
+= new EventHandler <LiveOperationCompletedEventArgs>(ISFile_UploadCompleted);
try
{
var fotoToSync = App.ViewModel.GetAllFotoToSync();
foreach (Foto ft in fotoToSync)
{
object[] state = new object[1];
state[0] = ft.FotoId;
using (IsolatedStorageFile myIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication())
{
using (IsolatedStorageFileStream stream = myIsolatedStorage.OpenFile(ft.FotoPath, System.IO.FileMode.Create))
{
stream.Write(ft.FotoImage, 0, ft.FotoImage.Length);
}
readStream = myIsolatedStorage.OpenFile(ft.FotoPath, FileMode.Open);
client.UploadAsync(skyDriveFolderID, ft.FotoPath, true, readStream, ft.FotoId);
}
}
}
catch
{
MessageBox.Show("Błąd dostępu IsolatedStorage. Proszę zamknąć aplikację i otworzyć ją ponownie, a następnie spróbuj ponownie stworzenie kopii zapasowyej!", "Backup Failed", MessageBoxButton.OK);
}
}
}
public async void uploadFilesToFolder(string folderId)
{
if (_session == null)
{
return;
}
try
{
var client = new LiveConnectClient(_session);
SystemTray.ProgressIndicator = new ProgressIndicator();
SystemTray.ProgressIndicator.Text = "Uploading...";
SystemTray.ProgressIndicator.IsIndeterminate = true;
SystemTray.ProgressIndicator.IsVisible = true;
var isf = IsolatedStorageFile.GetUserStoreForApplication();
foreach (string filePath in App.filesToSave)
{
string[] segments = filePath.Split('\\');
var fileName = segments[segments.Length - 1];
IsolatedStorageFileStream fileStream = new IsolatedStorageFileStream(filePath, FileMode.OpenOrCreate, isf);
//FileStream fileStream = new FileStream(filePath, FileMode.Open);
await client.UploadAsync(folderId, fileName, fileStream, OverwriteOption.Overwrite);
fileStream.Dispose();
}
SystemTray.ProgressIndicator.IsVisible = false;
MessageBox.Show("Finsihed uploading: " + App.filesToSave.Count + " files");
}
catch (Exception) { }
}
private void btnUploadFile_Click(object sender, RoutedEventArgs e)
{
Microsoft.Win32.OpenFileDialog picker = new Microsoft.Win32.OpenFileDialog();
picker.Filter = "All Files (*.*)|*.*";
picker.ShowDialog();
string filePath = picker.FileName;
if (filePath != "")
{
LiveConnectClient liveClient = new LiveConnectClient(Properties.session);
liveClient.UploadCompleted += this.ConnectClient_UploadCompleted;
var stream = default(Stream);
stream = File.OpenRead(filePath);
liveClient.UploadAsync("folder.6f717ff8a3b1a691.6F717FF8A3B1A691!192/files", filePath, stream, stream);
}
else
{
System.Windows.Forms.MessageBox.Show("You didn't select a file.");
}
}
private async void romList_SelectionChanged_1(object sender, SelectionChangedEventArgs e)
{
ROMDBEntry entry = this.romList.SelectedItem as ROMDBEntry;
if (entry == null)
{
return;
}
if (this.uploading)
{
MessageBox.Show(AppResources.BackupWaitForUpload, AppResources.ErrorCaption, MessageBoxButton.OK);
this.romList.SelectedItem = null;
return;
}
var indicator = new ProgressIndicator()
{
IsIndeterminate = true,
IsVisible = true,
Text = String.Format(AppResources.BackupUploadProgressText, entry.DisplayName)
};
SystemTray.SetProgressIndicator(this, indicator);
this.uploading = true;
try
{
LiveConnectClient client = new LiveConnectClient(this.session);
String folderID = await this.CreateExportFolder(client);
IsolatedStorageFile iso = IsolatedStorageFile.GetUserStoreForApplication();
bool errors = false;
foreach (var savestate in entry.Savestates)
{
String path = FileHandler.ROM_DIRECTORY + "/" + FileHandler.SAVE_DIRECTORY + "/" + savestate.FileName;
try
{
using (IsolatedStorageFileStream fs = iso.OpenFile(path, System.IO.FileMode.Open))
{
await client.UploadAsync(folderID, savestate.FileName, fs, OverwriteOption.Overwrite);
}
}
catch (FileNotFoundException)
{
errors = true;
}
catch (LiveConnectException ex)
{
MessageBox.Show(String.Format(AppResources.BackupErrorUpload, ex.Message), AppResources.ErrorCaption, MessageBoxButton.OK);
errors = true;
}
}
String sramName = entry.FileName.Substring(0, entry.FileName.Length - 3) + "srm";
String sramPath = FileHandler.ROM_DIRECTORY + "/" + FileHandler.SAVE_DIRECTORY + "/" + sramName;
try
{
if (iso.FileExists(sramPath))
{
using (IsolatedStorageFileStream fs = iso.OpenFile(sramPath, FileMode.Open))
{
await client.UploadAsync(folderID, sramName, fs, OverwriteOption.Overwrite);
}
}
}
catch (Exception)
{
errors = true;
}
if (errors)
{
MessageBox.Show(AppResources.BackupUploadUnsuccessful, AppResources.ErrorCaption, MessageBoxButton.OK);
}
else
{
MessageBox.Show(AppResources.BackupUploadSuccessful);
}
}
catch (NullReferenceException)
{
MessageBox.Show(AppResources.CreateBackupFolderError, AppResources.ErrorCaption, MessageBoxButton.OK);
}
catch (LiveConnectException)
{
MessageBox.Show(AppResources.SkyDriveInternetLost, AppResources.ErrorCaption, MessageBoxButton.OK);
}
finally
{
SystemTray.GetProgressIndicator(this).IsVisible = false;
this.uploading = false;
}
}
private void exportToSkyDrive(String opmlExportFileName, IsolatedStorageFileStream sourceStream)
{
liveConnect.UploadCompleted += new EventHandler <LiveOperationCompletedEventArgs>(opmlLiveOperation_UploadCompleted);
liveConnect.UploadAsync("me/skydrive", opmlExportFileName, sourceStream, OverwriteOption.Overwrite);
}
private async void SendFileToSkyDrive(LiveConnectClient client, String folder, ArticleContent content)
{
if (folder != null)
{
Dispatcher.BeginInvoke(() => AppUtils.ToastPromptShow("阅FM", "正在准备文件"));
var store = IsolatedStorageFile.GetUserStoreForApplication();
string filePath = "tmp.html";
if (store.FileExists(filePath))
{
store.DeleteFile(filePath);
}
var tmpfile = store.OpenFile(filePath,
FileMode.OpenOrCreate, FileAccess.Write);
if (tmpfile != null)
{
try
{
using (StreamWriter sw =
new StreamWriter(tmpfile))
{
string css;
string fileName = "css.txt";
StreamResourceInfo resourceInfo = Application.GetResourceStream(new Uri(fileName, UriKind.Relative));
using (StreamReader reader = new StreamReader(resourceInfo.Stream))
{
css = reader.ReadToEnd();
}
String html = "";
html += "<!DOCTYPE html><html><head><meta charset=\"UTF-8\"><style>" + css + "</style></head>";
html += "<body><div class=\"page\"><div class=\"article\">";
html += "<a target=\"_blank\" href=" + content.source + " class=\"source\">来源</a>";
html += "<h1 class=\"title\">" + content.title + "</h1><div class=\"body\">";
html += content.body;
html += "</div></div></div></body></html>";
sw.Write(html);
sw.Flush();
}
}
catch (IsolatedStorageException ex)
{
Dispatcher.BeginInvoke(() => AppUtils.ToastPromptShow("阅FM", "上传失败,准备文件时发生错误"));
is_upload_started = false;
return;
}
}
tmpfile.Close();
Dispatcher.BeginInvoke(() => AppUtils.ToastPromptShow("阅FM", "开始上传.."));
await client.UploadAsync(folder, content.title + ".html", store.OpenFile(filePath,
FileMode.Open, FileAccess.Read), OverwriteOption.Overwrite);
Dispatcher.BeginInvoke(() => AppUtils.ToastPromptShow("阅FM", "上传成功!")); is_upload_started = false;
}
else
{
Dispatcher.BeginInvoke(() => AppUtils.ToastPromptShow("阅FM", "上传失败,找不到目标文件夹"));
is_upload_started = false;
}
}
private async void Export_Click(object sender, EventArgs e)
{
if (fileList.CheckedItems.Count == 0)
{
MessageBox.Show(AppResources.ExportNoSelection);
return;
}
//can only export 1 file if use cloudsix
if (backupMedium == "cloudsix" && fileList.CheckedItems.Count > 1 && ZipCheckBox.IsChecked.Value == false)
{
MessageBox.Show(AppResources.CloudSixOneFileLimitText);
return;
}
if (this.uploading)
{
MessageBox.Show(AppResources.BackupWaitForUpload, AppResources.ErrorCaption, MessageBoxButton.OK);
return;
}
//zip file if users choose to do so
if (ZipCheckBox.IsChecked.Value)
{
using (ZipFile zip = new ZipFile())
{
using (var iso = IsolatedStorageFile.GetUserStoreForApplication())
{
foreach (ExportFileItem file in fileList.CheckedItems)
{
IsolatedStorageFileStream fs = iso.OpenFile(file.Path, System.IO.FileMode.Open);
zip.AddEntry(file.Name, fs);
}
MemoryStream stream = new MemoryStream();
zip.Save(stream);
if (backupMedium == "cloudsix")
{
var saver = new CloudSixSaver(currentEntry.DisplayName + ".zip", stream);
await saver.Launch();
}
else if (backupMedium == "onedrive")
{
var indicator = SystemTray.GetProgressIndicator(this);
indicator.IsIndeterminate = true;
this.uploading = true;
bool errors = false;
try
{
LiveConnectClient client = new LiveConnectClient(this.session);
String folderID = await CreateExportFolder(client);
indicator.Text = String.Format(AppResources.UploadProgressText, currentEntry.DisplayName + ".zip");
stream.Seek(0, SeekOrigin.Begin);
await client.UploadAsync(folderID, currentEntry.DisplayName + ".zip", stream, OverwriteOption.Overwrite);
}
catch (Exception ex)
{
MessageBox.Show(String.Format(AppResources.BackupErrorUpload, ex.Message), AppResources.ErrorCaption, MessageBoxButton.OK);
errors = true;
}
this.uploading = false;
if (errors)
{
MessageBox.Show(AppResources.BackupUploadUnsuccessful, AppResources.ErrorCaption, MessageBoxButton.OK);
}
else
{
MessageBox.Show(AppResources.BackupUploadSuccessful);
}
#if GBC
indicator.Text = AppResources.ApplicationTitle2;
#else
indicator.Text = AppResources.ApplicationTitle;
#endif
indicator.IsIndeterminate = false;
} //end of if (backupMedium == "onedrive")
stream.Close();
}
}
}
else //does not use zip function
{
using (var iso = IsolatedStorageFile.GetUserStoreForApplication())
{
if (backupMedium == "cloudsix")
{
ExportFileItem file = this.fileList.CheckedItems[0] as ExportFileItem;
using (IsolatedStorageFileStream fs = iso.OpenFile(file.Path, System.IO.FileMode.Open))
{
var saver = new CloudSixSaver(file.Name, fs);
await saver.Launch();
}
}
else if (backupMedium == "onedrive")
{
var indicator = SystemTray.GetProgressIndicator(this);
indicator.IsIndeterminate = true;
this.uploading = true;
bool errors = false;
try
{
LiveConnectClient client = new LiveConnectClient(this.session);
String folderID = await CreateExportFolder(client);
foreach (ExportFileItem file in this.fileList.CheckedItems)
{
indicator.Text = String.Format(AppResources.UploadProgressText, file.Name);
using (IsolatedStorageFileStream fs = iso.OpenFile(file.Path, System.IO.FileMode.Open))
{
await client.UploadAsync(folderID, file.Name, fs, OverwriteOption.Overwrite);
}
}
}
catch (Exception ex)
{
MessageBox.Show(String.Format(AppResources.BackupErrorUpload, ex.Message), AppResources.ErrorCaption, MessageBoxButton.OK);
errors = true;
}
this.uploading = false;
if (errors)
{
MessageBox.Show(AppResources.BackupUploadUnsuccessful, AppResources.ErrorCaption, MessageBoxButton.OK);
}
else
{
MessageBox.Show(AppResources.BackupUploadSuccessful);
}
#if GBC
indicator.Text = AppResources.ApplicationTitle2;
#else
indicator.Text = AppResources.ApplicationTitle;
#endif
indicator.IsIndeterminate = false;
}
} //IsolatedStorage
} //using zip upload or not
}
private async void BackupFilesAndUpload(string _backupFileName)
{
if (_backupFileName == null)
{
throw new ArgumentNullException("_backupFileName");
}
//
//
string filename = _backupFileName;
//byte[] b = new byte[0x16] {0x50,0x4b,0x05,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
var b = new byte[0x16];
b[0] = 0x50;
b[1] = 0x4b;
b[2] = 0x05;
b[4] = 0x06;
using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication()) {
using (IsolatedStorageFileStream f = store.OpenFile(filename, FileMode.Create)) {
f.Write(b, 0, b.Length);
}
}
using (var store = IsolatedStorageFile.GetUserStoreForApplication()) {
using (var file = new IsolatedStorageFileStream(filename, FileMode.Create, store))
{
var zz = new ZipOutputStream(file);
foreach (string f in store.GetFileNames())
{
if (f.Equals(filename))
{
continue;
}
var ze = new ZipEntry(f);
zz.PutNextEntry(ze);
using (IsolatedStorageFileStream ss = store.OpenFile(f, FileMode.Open))
{
var bytes = new byte[100];
int x = ss.Read(bytes, 0, 100);
while (x > 0)
{
zz.Write(bytes, 0, x);
bytes = new byte[100];
x = ss.Read(bytes, 0, 100);
}
}
}
zz.Finish();
}
try
{
pbProgress.Value = 0;
bBackup.IsEnabled = false;
bRestore.IsEnabled = false;
var progressHandler = new Progress <LiveOperationProgress>(
(e) =>
{
pbProgress.Value = e.ProgressPercentage;
pbProgress.Visibility = Visibility.Visible;
lblLastBackup.Text =
string.Format(
StringResources
.BackupAndRestorePage_Messages_Progress,
e.BytesTransferred, e.TotalBytes);
});
_ctsUpload = new CancellationTokenSource();
_client = new LiveConnectClient(App.LiveSession);
using (
var file = new IsolatedStorageFileStream(filename, FileMode.Open,
FileAccess.Read, FileShare.Read,
IsolatedStorageFile.GetUserStoreForApplication()))
{
await
_client.UploadAsync("me/skydrive", filename, file,
OverwriteOption.Overwrite, _ctsUpload.Token,
progressHandler);
}
pbProgress.Visibility = Visibility.Collapsed;
}
catch (TaskCanceledException)
{
App.ToastMe("Upload Cancelled");
}
catch (LiveConnectException ee)
{
lblLastBackup.Text = string.Format("Error uploading File:{0}",
ee.Message);
}
finally
{
bBackup.IsEnabled = true;
bRestore.IsEnabled = true;
lblLastBackup.Text = DateTime.Now.ToString("MM/dd/yyyy");
}
}
}
public static bool UploadFile(string guid, string filePath)
{
validateSession();
try
{
LiveConnectClient client = new LiveConnectClient(Properties.session);
client.UploadCompleted += UltiDrive.SkyDrive.Utilities.ConnectClient_UploadCompleted;
var stream = default(Stream);
stream = File.OpenRead(filePath);
string directoryName = Path.GetDirectoryName(filePath) + "\\";
client.UploadAsync(Properties.UltiDriveFolderID + "/files", directoryName + guid, stream, stream);
//System.Windows.MessageBox.Show(stream.ToString());
//stream.Close();
return true;
}
catch (Exception e)
{
Console.WriteLine("SkyDriveApi.UploadFile() failed. --> " + e.ToString());
return false;
}
}