public async static Task UploadAsync(this IMobileServiceClient client, MobileServiceFile file, IMobileServiceFileDataSource dataSource)
{
MobileServiceFileMetadata metadata = MobileServiceFileMetadata.FromFile(file);
IMobileServiceFilesClient filesClient = GetFilesClient(client);
await filesClient.UploadFileAsync(metadata, dataSource);
}
public async static Task DeleteFileAsync <T>(this IMobileServiceTable <T> table, MobileServiceFile file)
{
MobileServiceFileMetadata metadata = MobileServiceFileMetadata.FromFile(file);
IMobileServiceFilesClient client = GetFilesClient(table.MobileServiceClient);
await client.DeleteFileAsync(metadata);
}
public async Task <PathMobileServiceFileDataSource> GetFileDataSource(MobileServiceFileMetadata metadata)
{
var filePath = await FileHelper.GetLocalFilePathAsync(metadata.ParentDataItemType, metadata.ParentDataItemId,
metadata.FileName);
return(new PathMobileServiceFileDataSource(filePath));
}
public void ChangedFileMetadataIsUpdated()
{
MobileServiceFileMetadata metadata = this.testMetadata.FirstOrDefault(f => string.Compare(f.FileId, "updated-123") == 0);
MobileServiceFile file = this.testFiles.FirstOrDefault(f => string.Compare(f.Id, "updated-123") == 0);
Assert.Equal(file.ContentMD5, metadata.ContentMD5);
Assert.Equal(file.LastModified, metadata.LastModified);
}
private bool IsMetadataValid(MobileServiceFileMetadata metadata)
{
return(inputFile.Id == metadata.Id &&
string.Compare(inputFile.Name, metadata.FileName) == 0 &&
string.Compare(inputFile.ParentId, metadata.ParentDataItemId) == 0 &&
string.Compare(inputFile.TableName, metadata.ParentDataItemType) == 0 &&
string.Compare(inputFile.ContentMD5, metadata.ContentMD5) == 0 &&
inputFile.Length == metadata.Length);
}
private void initializeInput()
{
this.testFiles = new List <MobileServiceFile>
{
new MobileServiceFile
{
Id = "new-123",
Name = "newfile",
ContentMD5 = "0",
LastModified = DateTimeOffset.Now,
ParentId = this.testRecordId,
TableName = this.testTableName
},
new MobileServiceFile
{
Id = "existing-123",
Name = "existing-file",
ContentMD5 = "0",
LastModified = DateTimeOffset.Now,
ParentId = this.testRecordId,
TableName = this.testTableName
},
new MobileServiceFile
{
Id = "updated-123",
Name = "updated-file",
ContentMD5 = "1",
LastModified = DateTimeOffset.Now,
ParentId = this.testRecordId,
TableName = this.testTableName
},
new MobileServiceFile
{
Id = "deleted-123",
Name = "deleted-file",
ContentMD5 = "2",
LastModified = DateTimeOffset.Now,
ParentId = this.testRecordId,
TableName = this.testTableName
},
};
this.testMetadata = new List <MobileServiceFileMetadata>(testFiles.Skip(1).Select(f =>
{
var metadata = MobileServiceFileMetadata.FromFile(f);
if (string.Compare(metadata.ContentMD5, "1") == 0)
{
metadata.ContentMD5 = "0";
metadata.LastModified = DateTimeOffset.Now.AddMinutes(-5);
}
return(metadata);
}));
this.testFiles = new List <MobileServiceFile>(testFiles.Where(f => string.Compare(f.ContentMD5, "2") != 0));
}
public async static Task UploadFileAsync <T>(this IMobileServiceSyncTable <T> table, MobileServiceFile file, string filePath)
{
IMobileServiceFileDataSource dataSource = new PathMobileServiceFileDataSource(filePath);
MobileServiceFileMetadata metadata = MobileServiceFileMetadata.FromFile(file);
IFileSyncContext context = table.MobileServiceClient.GetFileSyncContext();
await context.MobileServiceFilesClient.UploadFileAsync(metadata, dataSource);
}
internal static MobileServiceFile FromMetadata(MobileServiceFileMetadata metadata)
{
var file = new MobileServiceFile(metadata.FileId, metadata.ParentDataItemType, metadata.ParentDataItemId);
file.ContentMD5 = metadata.ContentMD5;
file.LastModified = metadata.LastModified;
file.Length = metadata.Length;
file.Metadata = metadata.ToDictionary();
return(file);
}
public Task <IMobileServiceFileDataSource> GetDataSource(MobileServiceFileMetadata metadata)
{
#if PORTABLE || WINDOWS_PHONE
throw new ArgumentException("This functionality is not implemented in this version of this assembly. You should reference the NuGet package from your main application project in order to reference the platform-specific implementation.");
#else
var source = new PathMobileServiceFileDataSource(GetFileFullPath(metadata.ParentDataItemId, metadata.FileName)) as IMobileServiceFileDataSource;
return(Task.FromResult(source));
#endif
}
protected async override Task ExecuteOperation(IFileMetadataStore metadataStore, IFileSyncContext context)
{
MobileServiceFileMetadata metadata = await metadataStore.GetFileMetadataAsync(FileId);
if (metadata != null)
{
var dataSource = await context.SyncHandler.GetDataSource(metadata);
await context.MobileServiceFilesClient.UploadFileAsync(metadata, dataSource);
}
}
protected async override Task ExecuteOperation(IFileMetadataStore metadataStore, IFileSyncContext context)
{
MobileServiceFileMetadata metadata = await metadataStore.GetFileMetadataAsync(FileId);
if (metadata != null)
{
await metadataStore.DeleteAsync(metadata);
await context.MobileServiceFilesClient.DeleteFileAsync(metadata);
}
}
public async Task PullFilesAsync(string tableName, string itemId)
{
IEnumerable <MobileServiceFile> files = await this.mobileServiceFilesClient.GetFilesAsync(tableName, itemId);
foreach (var file in files)
{
FileSynchronizationAction syncAction = FileSynchronizationAction.Update;
MobileServiceFileMetadata metadata = await this.metadataStore.GetFileMetadataAsync(file.Id);
if (metadata == null)
{
syncAction = FileSynchronizationAction.Create;
metadata = MobileServiceFileMetadata.FromFile(file);
metadata.ContentMD5 = null;
metadata.LastModified = null;
}
if (string.Compare(metadata.ContentMD5, file.ContentMD5, StringComparison.Ordinal) != 0 ||
(metadata.LastModified == null || metadata.LastModified.Value.ToUniversalTime() != file.LastModified.Value.ToUniversalTime()))
{
metadata.LastModified = file.LastModified;
metadata.ContentMD5 = file.ContentMD5;
await this.metadataStore.CreateOrUpdateAsync(metadata);
await this.syncHandler.ProcessFileSynchronizationAction(file, syncAction);
NotifyFileOperationCompletion(file, syncAction.ToFileOperationKind(), FileOperationSource.ServerPull);
}
}
var fileMetadata = await this.metadataStore.GetMetadataAsync(tableName, itemId);
var deletedItemsMetadata = fileMetadata.Where(m => !files.Any(f => string.Compare(f.Id, m.FileId) == 0));
foreach (var metadata in deletedItemsMetadata)
{
IMobileServiceFileOperation pendingOperation = await this.operationsQueue.GetOperationByFileIdAsync(metadata.FileId);
// TODO: Need to call into the sync handler for conflict resolution here...
if (pendingOperation == null || pendingOperation is DeleteMobileServiceFileOperation)
{
await metadataStore.DeleteAsync(metadata);
await this.syncHandler.ProcessFileSynchronizationAction(MobileServiceFile.FromMetadata(metadata), FileSynchronizationAction.Delete);
NotifyFileOperationCompletion(MobileServiceFile.FromMetadata(metadata), FileOperationKind.Delete, FileOperationSource.ServerPull);
}
}
}
public async static Task DeleteFileAsync <T>(this IMobileServiceSyncTable <T> table, MobileServiceFile file)
{
IFileSyncContext context = table.MobileServiceClient.GetFileSyncContext();
await context.DeleteFileAsync(file);
MobileServiceFileMetadata metadata = await context.MetadataStore.GetFileMetadataAsync(file.Id);
metadata.PendingDeletion = true;
await context.MetadataStore.CreateOrUpdateAsync(metadata);
}
public async Task DeleteFileAsync(MobileServiceFileMetadata metadata)
{
string route = string.Format("/tables/{0}/{1}/MobileServiceFiles/{2}/", metadata.ParentDataItemType, metadata.ParentDataItemId, metadata.FileName);
var parameters = new Dictionary <string, string>();
if (metadata.FileStoreUri != null)
{
parameters.Add("x-zumo-filestoreuri", metadata.FileStoreUri);
}
await this.client.InvokeApiAsync(route, HttpMethod.Delete, parameters);
}
public Task <IMobileServiceFileDataSource> GetDataSource(MobileServiceFileMetadata metadata)
{
var filePath = _fileHelper.GetLocalFilePath(metadata.ParentDataItemId, metadata.FileName);
IMobileServiceFileDataSource result = null;
if (filePath != null)
{
result = _fileHelper.GetMobileServiceDataSource(filePath);
}
return(Task.FromResult(result));
}
public async Task UploadFileAsync(MobileServiceFileMetadata metadata, IMobileServiceFileDataSource dataSource, StorageToken storageToken)
{
CloudBlockBlob blob = GetBlobReference(storageToken, metadata.FileName);
using (var stream = await dataSource.GetStream())
{
await blob.UploadFromStreamAsync(stream);
metadata.LastModified = blob.Properties.LastModified;
metadata.FileStoreUri = blob.Uri.LocalPath;
stream.Position = 0;
metadata.ContentMD5 = GetMD5Hash(stream);
}
}
public async Task UploadFileAsync(MobileServiceFileMetadata metadata, IMobileServiceFileDataSource dataSource)
{
if (metadata == null)
{
throw new ArgumentNullException("metadata");
}
if (dataSource == null)
{
throw new ArgumentNullException("dataSource");
}
StorageToken token = await GetStorageToken(this.client, MobileServiceFile.FromMetadata(metadata), StoragePermissions.Write);
await this.storageProvider.UploadFileAsync(metadata, dataSource, token);
}
public async static Task AddFileAsync <T>(this IMobileServiceTable <T> table, MobileServiceFile file, Stream fileStream)
{
if (file == null)
{
throw new ArgumentNullException("file");
}
if (fileStream == null)
{
throw new ArgumentNullException("fileStream");
}
IMobileServiceFileDataSource dataSource = new StreamMobileServiceFileDataSource(fileStream);
IMobileServiceFilesClient client = GetFilesClient(table.MobileServiceClient);
await client.UploadFileAsync(MobileServiceFileMetadata.FromFile(file), dataSource);
}
public async Task AddFileAsync(MobileServiceFile file)
{
var metadata = new MobileServiceFileMetadata
{
FileId = file.Id,
FileName = file.Name,
Length = file.Length,
Location = FileLocation.Local,
ContentMD5 = file.ContentMD5,
ParentDataItemType = file.TableName,
ParentDataItemId = file.ParentId
};
await metadataStore.CreateOrUpdateAsync(metadata);
var operation = new CreateMobileServiceFileOperation(Guid.NewGuid().ToString(), file.Id);
await QueueOperationAsync(operation);
NotifyFileOperationCompletion(file, FileOperationKind.Create, FileOperationSource.Local);
}
public PullFilesScenario()
{
initializeInput();
FilesClientMock.Setup(m => m.GetFilesAsync(It.Is <string>(s => string.Compare(this.testTableName, s) == 0),
It.Is <string>(s => string.Compare(this.testRecordId, s) == 0)))
.Returns(() => Task.FromResult <IEnumerable <MobileServiceFile> >(testFiles));
FileMetadataStoreMock.Setup(m => m.GetFileMetadataAsync(It.IsAny <string>()))
.Returns <string>(id => Task.FromResult(testMetadata.FirstOrDefault(m => string.Compare(m.FileId, id) == 0)));
FileMetadataStoreMock.Setup(m => m.GetMetadataAsync(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>((table, id) => Task.FromResult <IEnumerable <MobileServiceFileMetadata> >(testMetadata.ToList()));
FileMetadataStoreMock.Setup(m => m.CreateOrUpdateAsync(It.IsAny <MobileServiceFileMetadata>()))
.Callback <MobileServiceFileMetadata>(m =>
{
if (!testMetadata.Any(tm => string.Compare(tm.FileId, m.FileId) == 0))
{
testMetadata.Add(m);
}
})
.Returns(Task.FromResult(0));
FileMetadataStoreMock.Setup(m => m.DeleteAsync(It.IsAny <MobileServiceFileMetadata>()))
.Callback <MobileServiceFileMetadata>(m =>
{
MobileServiceFileMetadata metadata = testMetadata.FirstOrDefault(tm => string.Compare(tm.FileId, m.FileId) == 0);
if (metadata != null)
{
testMetadata.Remove(metadata);
}
})
.Returns(Task.FromResult(0));
SyncContext.PullFilesAsync("testtable", "id").Wait();
}
public async Task <IMobileServiceFileDataSource> GetFileDataSource(MobileServiceFileMetadata metadata)
{
var path = await GetLocalFilePathAsync(metadata.ParentDataItemId, metadata.FileName);
return(new PathMobileServiceFileDataSource(path));
}
public async Task <IMobileServiceFileDataSource> GetDataSource(MobileServiceFileMetadata metadata)
{
string filePath = await FileHelper.GetLocalFilePathAsync(metadata.ParentDataItemId);
return(new PathMobileServiceFileDataSource(filePath));
}
public Task <IMobileServiceFileDataSource> GetDataSource(MobileServiceFileMetadata metadata) => fileProvider.GetFileDataSource(metadata);
private async Task <StorageToken> GetStorageToken(IMobileServiceClient client, MobileServiceFileMetadata metadata, StoragePermissions permissions)
{
return(await GetStorageToken(client, MobileServiceFile.FromMetadata(metadata), permissions));
}
public Task <IMobileServiceFileDataSource> GetDataSource(MobileServiceFileMetadata metadata)
{
IMobileServiceFileDataSource source = fileSyncHelper.GetMobileServiceDataSource(fileHelper.GetLocalFilePath(metadata.ParentDataItemId, metadata.FileName));
return(Task.FromResult(source));
}
public Task <IMobileServiceFileDataSource> GetDataSource(MobileServiceFileMetadata metadata)
{
IPlatform platform = DependencyService.Get <IPlatform>();
return(platform.GetFileDataSource(metadata));
}
