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 AzureService()
{
string MyAppServiceURL = "http://mxamarincats.azurewebsites.net";
Client = new MobileServiceClient(MyAppServiceURL);
Table = Client.GetTable <T>();
}
public LoginViewModel(IMobileServiceClient client, IAuthenticationService authService, INavigationService navService)
{
this._authService = authService;
this._navigationService = navService;
this._mobileServiceClient = client;
UpdateCommand = new Command(Update);
}
public async Task ReadAsync_RoundTripsDate_Generic()
{
string tableName = "NotSystemPropertyCreatedAtType";
ResetDatabase(tableName);
var store = new MobileServiceSQLiteStore(TestDbName);
store.DefineTable <NotSystemPropertyCreatedAtType>();
var hijack = new TestHttpHandler();
IMobileServiceClient service = await CreateClient(hijack, store);
IMobileServiceSyncTable <NotSystemPropertyCreatedAtType> table = service.GetSyncTable <NotSystemPropertyCreatedAtType>();
DateTime theDate = new DateTime(2014, 3, 10, 0, 0, 0, DateTimeKind.Utc);
var inserted = new NotSystemPropertyCreatedAtType()
{
__CreatedAt = theDate
};
await table.InsertAsync(inserted);
Assert.AreEqual(inserted.__CreatedAt.ToUniversalTime(), theDate);
NotSystemPropertyCreatedAtType rehydrated = await table.LookupAsync(inserted.Id);
Assert.AreEqual(rehydrated.__CreatedAt.ToUniversalTime(), theDate);
}
private async Task <bool> Login(IMobileServiceClient client)
{
var authentication = ServiceLocator.Instance.Resolve <IAuthentication>();
if (authentication == null)
{
throw new InvalidOperationException("Make sure the ServiceLocator has an instance of IAuthentication");
}
var accountType = GetProviderType();
try
{
var user = await authentication.LoginAsync(client, accountType);
if (user != null)
{
return(true);
}
}
catch (System.Exception e)
{
Logger.Instance.Report(e);
}
return(false);
}
public async Task ReadAsync_RoundTripsBytes()
{
const string tableName = "bytes_test_table";
ResetDatabase(tableName);
var store = new MobileServiceSQLiteStore(TestDbName);
store.DefineTable(tableName, new JObject {
{ "id", String.Empty },
{ "data", new byte[0] }
});
var hijack = new TestHttpHandler();
IMobileServiceClient service = await CreateClient(hijack, store);
IMobileServiceSyncTable table = service.GetSyncTable(tableName);
byte[] theData = { 0, 128, 255 };
JObject inserted = await table.InsertAsync(new JObject { { "data", theData } });
Assert.AreEquivalent(theData, inserted["data"].Value <byte[]>());
JObject rehydrated = await table.LookupAsync(inserted["id"].Value <string>());
Assert.AreEquivalent(theData, rehydrated["data"].Value <byte[]>());
}
public async Task InsertAsync_Throws_IfItemAlreadyExistsInLocalStore()
{
ResetDatabase(TestTable);
var store = new MobileServiceSQLiteStore(TestDbName);
store.DefineTable(TestTable, new JObject()
{
{ "id", String.Empty },
{ "String", String.Empty }
});
var hijack = new TestHttpHandler();
IMobileServiceClient service = await CreateClient(hijack, store);
string pullResult = "[{\"id\":\"abc\",\"String\":\"Wow\"}]";
hijack.AddResponseContent(pullResult);
hijack.AddResponseContent("[]");
IMobileServiceSyncTable table = service.GetSyncTable(TestTable);
await table.PullAsync(null, null);
var ex = await AssertEx.Throws <MobileServiceLocalStoreException>(() => table.InsertAsync(new JObject()
{
{ "id", "abc" }
}));
Assert.AreEqual(ex.Message, "An insert operation on the item is already in the queue.");
}
private async Task <bool> Login(IMobileServiceClient client)
{
var authentication = DependencyService.Get <IAuthenticator>();
if (authentication == null)
{
throw new InvalidOperationException("Make sure the ServiceLocator has an instance of IAuthenticator.");
}
var accountType = ProviderType;
var parameters = App.LoginParameters;
try
{
var user = await authentication.LoginAsync(client, accountType, parameters);
if (user != null)
{
return(true);
}
}
catch (System.Exception e)
{
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="MobileServiceAuthentication"/> class.
/// </summary>
/// <param name="client">
/// The <see cref="MobileServiceClient"/> associated with this
/// MobileServiceLogin instance.
/// </param>
/// <param name="providerName">
/// The <see cref="MobileServiceAuthenticationProvider"/> used to authenticate.
/// </param>
/// <param name="parameters">
/// Provider specific extra parameters that are sent as query string parameters to login endpoint.
/// </param>
public MobileServiceAuthentication(IMobileServiceClient client, string providerName, IDictionary<string, string> parameters)
{
Debug.Assert(client != null, "client should not be null.");
if (providerName == null)
{
throw new ArgumentNullException("providerName");
}
this.Client = client;
this.Parameters = parameters;
this.ProviderName = providerName;
string path = MobileServiceUrlBuilder.CombinePaths(LoginAsyncUriFragment, this.ProviderName);
string loginAsyncDoneUriFragment = MobileServiceAuthentication.LoginAsyncDoneUriFragment;
if (!string.IsNullOrEmpty(this.Client.LoginUriPrefix))
{
path = MobileServiceUrlBuilder.CombinePaths(this.Client.LoginUriPrefix, this.ProviderName);
loginAsyncDoneUriFragment = MobileServiceUrlBuilder.CombinePaths(this.Client.LoginUriPrefix, "done");
}
string queryString = MobileServiceUrlBuilder.GetQueryString(parameters, useTableAPIRules: false);
string pathAndQuery = MobileServiceUrlBuilder.CombinePathAndQuery(path, queryString);
this.StartUri = new Uri(this.Client.MobileAppUri, pathAndQuery);
this.EndUri = new Uri(this.Client.MobileAppUri, loginAsyncDoneUriFragment);
if (this.Client.AlternateLoginHost != null)
{
this.StartUri = new Uri(this.Client.AlternateLoginHost, pathAndQuery);
this.EndUri = new Uri(this.Client.AlternateLoginHost, loginAsyncDoneUriFragment);
}
}
public AzureService()
{
string MyAppServiceURL = "http://demodeveloperxamarin.azurewebsites.net";
Client = new MobileServiceClient(MyAppServiceURL);
Table = Client.GetTable <Contacts>();
}
/// <summary>
/// Initializes a new instance of the <see cref="MobileServiceAuthentication"/> class.
/// </summary>
/// <param name="client">
/// The <see cref="MobileServiceClient"/> associated with this
/// MobileServiceLogin instance.
/// </param>
/// <param name="providerName">
/// The <see cref="MobileServiceAuthenticationProvider"/> used to authenticate.
/// </param>
/// <param name="parameters">
/// Provider specific extra parameters that are sent as query string parameters to login endpoint.
/// </param>
public MobileServiceAuthentication(IMobileServiceClient client, string providerName, IDictionary <string, string> parameters)
{
Debug.Assert(client != null, "client should not be null.");
if (providerName == null)
{
throw new ArgumentNullException("providerName");
}
this.Client = client;
this.Parameters = parameters;
this.ProviderName = providerName;
string path = MobileServiceUrlBuilder.CombinePaths(LoginAsyncUriFragment, this.ProviderName);
string loginAsyncDoneUriFragment = MobileServiceAuthentication.LoginAsyncDoneUriFragment;
if (!string.IsNullOrEmpty(this.Client.LoginUriPrefix))
{
path = MobileServiceUrlBuilder.CombinePaths(this.Client.LoginUriPrefix, this.ProviderName);
loginAsyncDoneUriFragment = MobileServiceUrlBuilder.CombinePaths(this.Client.LoginUriPrefix, "done");
}
string queryString = MobileServiceUrlBuilder.GetQueryString(parameters, useTableAPIRules: false);
string pathAndQuery = MobileServiceUrlBuilder.CombinePathAndQuery(path, queryString);
this.StartUri = new Uri(this.Client.MobileAppUri, pathAndQuery);
this.EndUri = new Uri(this.Client.MobileAppUri, loginAsyncDoneUriFragment);
if (this.Client.AlternateLoginHost != null)
{
this.StartUri = new Uri(this.Client.AlternateLoginHost, pathAndQuery);
this.EndUri = new Uri(this.Client.AlternateLoginHost, loginAsyncDoneUriFragment);
}
}
public async Task <bool> LoginAsync(IMobileServiceClient client, MobileServiceAuthenticationProvider provider)
{
var success = false;
try
{
var user = await client.LoginAsync(Xamarin.Forms.Forms.Context, provider);
if (user != null)
{
Settings.AuthToken = user.MobileServiceAuthenticationToken;
var employee = await client.InvokeApiAsync <Employee>("UserInfo", System.Net.Http.HttpMethod.Get, null);
Settings.FirstName = employee.FirstName;
Settings.LastName = employee.LastName;
Settings.PhotoUrl = employee.PhotoUrl;
Settings.UserId = employee.Id;
Xamarin.Forms.Application.Current.MainPage = new RootPage();
return(true);
}
return(false);
}
catch (Exception ex)
{
Console.WriteLine($"Error logging in: {ex.Message}");
}
return(success);
}
public AzureServices()
{
string MyAppServiceURL = "http://pedro1teste.azurewebsites.net";
Client = new MobileServiceClient(MyAppServiceURL);
Table = Client.GetTable <Model.Luminosidade>();
}
public async Task InitializeAsync()
{
this.MobileService =
new MobileServiceClient(MobileUrl, new LoggingHandler());
// string filename = "local.db";
// string documentsPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
// string libraryPath = Path.Combine(documentsPath, "..", "Library");
// var path = Path.Combine(libraryPath, filename);
// var path = Path.Combine(documentsPath, filename);
// if (!File.Exists(path))
// {
// File.Create(path).Dispose();
// }
//var store = new MobileServiceSQLiteStore(path);
var store = new MobileServiceSQLiteStore("local.db");
store.DefineTable <Job>();
jobTable = MobileService.GetSyncTable <Job>();
await MobileService.SyncContext.InitializeAsync(store, StoreTrackingOptions.NotifyLocalAndServerOperations);
// jobTable = MobileService.GetSyncTable<Job>();
}
public AzureService()
{
string MyAppServiceURL = "http://catsappdiplomado.azurewebsites.net";
Client = new MobileServiceClient(MyAppServiceURL);
Table = Client.GetTable <T>();
}
public static void Client(
[MobileTable(MobileAppUriSetting = "MyUri", ApiKeySetting = "MyKey")] IMobileServiceClient client,
TraceWriter trace)
{
Assert.NotNull(client);
trace.Warning("Client");
}
public AzureRepository()
{
string MyAppServiceURL = "https://calculadorafreelancer01.azurewebsites.net";
Client = new MobileServiceClient(MyAppServiceURL);
Table = Client.GetTable <TEntity>();
}
public AzureService()
{
MobileService = AuthInfo.Instance.GetMobileServiceClient();
//MobileService = new MobileServiceClient(
// AuthInfo.APPLICATION_URL, AuthInfo.APPLICATION_KEY);
}
public async Task ReadAsync_RoundTripsBytes_Generic()
{
const string tableName = "BytesType";
ResetDatabase(tableName);
var store = new MobileServiceSQLiteStore(TestDbName);
store.DefineTable <BytesType>();
var hijack = new TestHttpHandler();
IMobileServiceClient service = await CreateClient(hijack, store);
IMobileServiceSyncTable <BytesType> table = service.GetSyncTable <BytesType>();
byte[] theData = { 0, 128, 255 };
BytesType inserted = new BytesType {
Data = theData
};
await table.InsertAsync(inserted);
Assert.AreEquivalent(inserted.Data, theData);
BytesType rehydrated = await table.LookupAsync(inserted.Id);
Assert.AreEquivalent(rehydrated.Data, theData);
}
public override async Task <MobileServiceUser> LoginAsync(IMobileServiceClient client, MobileServiceAuthenticationProvider provider, IDictionary <string, string> parameters = null)
{
try
{
var window = UIKit.UIApplication.SharedApplication.KeyWindow;
var root = window.RootViewController;
if (root == null)
{
return(null);
}
var current = root;
while (current.PresentedViewController != null)
{
current = current.PresentedViewController;
}
return(await client.LoginAsync(current, provider, parameters));
}
catch (Exception e)
{
e.Data["method"] = "LoginAsync";
}
return(null);
}
public async Task ReadAsync_RoundTripsDate()
{
string tableName = "itemWithDate";
ResetDatabase(tableName);
var store = new MobileServiceSQLiteStore(TestDbName);
store.DefineTable(tableName, new JObject()
{
{ "id", String.Empty },
{ "date", DateTime.Now }
});
var hijack = new TestHttpHandler();
IMobileServiceClient service = await CreateClient(hijack, store);
IMobileServiceSyncTable table = service.GetSyncTable(tableName);
DateTime theDate = new DateTime(2014, 3, 10, 0, 0, 0, DateTimeKind.Utc);
JObject inserted = await table.InsertAsync(new JObject()
{
{ "date", theDate }
});
Assert.AreEqual(inserted["date"].Value <DateTime>(), theDate);
JObject rehydrated = await table.LookupAsync(inserted["id"].Value <string>());
Assert.AreEqual(rehydrated["date"].Value <DateTime>(), theDate);
}
public AzureService()
{
string MyAppServiceURL = "http://meodemoxamarin.azurewebsites.net/";
Client = new MobileServiceClient(MyAppServiceURL);
table = Client.GetTable <T>();
}
internal MobileServiceFileSyncContext(IMobileServiceClient client, IFileMetadataStore metadataStore, IFileOperationQueue operationsQueue,
IFileSyncTriggerFactory syncTriggerFactory, IFileSyncHandler syncHandler, IMobileServiceFilesClient filesClient)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
if (metadataStore == null)
{
throw new ArgumentNullException("metadataStore");
}
if (operationsQueue == null)
{
throw new ArgumentNullException("operationsQueue");
}
if (syncTriggerFactory == null)
{
throw new ArgumentNullException("syncTriggerFactory");
}
if (syncHandler == null)
{
throw new ArgumentNullException("syncHandler");
}
this.metadataStore = metadataStore;
this.syncHandler = syncHandler;
this.operationsQueue = operationsQueue;
this.mobileServiceFilesClient = filesClient ?? new MobileServiceFilesClient(client, new AzureBlobStorageProvider(client));
this.eventManager = client.EventManager;
this.triggers = syncTriggerFactory.CreateTriggers(this);
}
public async Task SystemPropertiesArePreserved_OnlyWhenReturnedFromServer()
{
ResetDatabase(TestTable);
var hijack = new TestHttpHandler();
var store = new MobileServiceSQLiteStore(TestDbName);
store.DefineTable <ToDoWithSystemPropertiesType>();
IMobileServiceClient service = await CreateClient(hijack, store);
IMobileServiceSyncTable <ToDoWithSystemPropertiesType> table = service.GetSyncTable <ToDoWithSystemPropertiesType>();
// first insert an item
var updatedItem = new ToDoWithSystemPropertiesType()
{
Id = "b",
String = "Hey",
Version = "abc",
CreatedAt = new DateTime(2013, 1, 1, 1, 1, 1, DateTimeKind.Utc),
UpdatedAt = new DateTime(2013, 1, 1, 1, 1, 2, DateTimeKind.Utc)
};
await table.UpdateAsync(updatedItem);
var lookedupItem = await table.LookupAsync("b");
Assert.Equal("Hey", lookedupItem.String);
Assert.Equal("abc", lookedupItem.Version);
// we ignored the sys properties on the local object
Assert.Equal(lookedupItem.CreatedAt, new DateTime(0, DateTimeKind.Utc));
Assert.Equal(lookedupItem.UpdatedAt, new DateTime(0, DateTimeKind.Utc));
Assert.Equal(1L, service.SyncContext.PendingOperations); // operation pending
hijack.OnSendingRequest = async req =>
{
string content = await req.Content.ReadAsStringAsync();
Assert.Equal(@"{""id"":""b"",""String"":""Hey""}", content); // the system properties are not sent to server
return(req);
};
string updateResult = "{\"id\":\"b\",\"String\":\"Wow\",\"version\":\"def\",\"createdAt\":\"2014-01-29T23:01:33.444Z\", \"updatedAt\":\"2014-01-30T23:01:33.444Z\"}";
hijack.Responses.Add(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(updateResult)
}); // push
await service.SyncContext.PushAsync();
Assert.Equal(0L, service.SyncContext.PendingOperations); // operation removed
lookedupItem = await table.LookupAsync("b");
Assert.Equal("Wow", lookedupItem.String);
Assert.Equal("def", lookedupItem.Version);
// we preserved the system properties returned from server on update
Assert.Equal(lookedupItem.CreatedAt.ToUniversalTime(), new DateTime(2014, 01, 29, 23, 1, 33, 444, DateTimeKind.Utc));
Assert.Equal(lookedupItem.UpdatedAt.ToUniversalTime(), new DateTime(2014, 01, 30, 23, 1, 33, 444, DateTimeKind.Utc));
}
private TodoItemManager()
{
this.client = new MobileServiceClient(Constants.ApplicationURL);
var store = new MobileServiceSQLiteStore("localstore.db");
store.DefineTable<TodoItem>();
this.client.SyncContext.InitializeAsync(store);
this.todoTable = client.GetSyncTable<TodoItem>();
}
public AuthenticationService(IMobileServiceClient mobileService, Application application)
{
this.mobileService = mobileService;
application.RegisterActivityLifecycleCallbacks(lifecycleHandler);
lifecycleHandler.ActivityResumed += (s, e) => currentActivity = e.Activity;
}
public AptkAmaDataService(IAptkAmaPluginConfiguration configuration, IMobileServiceClient client)
{
Configuration = configuration;
Client = client;
// Init tables
Initialize();
}
/// <summary>
/// Returns true when the authentication token for the current user is expired.
/// </summary>
/// <param name="client">The current MobileServiceClient instance</param>
/// <param name="credential">PasswordCredential to check.</param>
/// <returns>true when the token is expired; otherwise false.</returns>
public static bool IsTokenExpired(this IMobileServiceClient client, PasswordCredential credential)
{
// Get the stored password.
credential.RetrievePassword();
// Check for expired token.
return(CheckToken(credential.Password));
}
public static void Initialize(string appServiceUrl = AppServiceUrl)
{
if (!string.IsNullOrEmpty(appServiceUrl))
{
MobileServiceClient = new MobileServiceClient(appServiceUrl);
IsInitialized = true;
}
}
public WritePostViewModel(IMobileServiceClient client, IUserService userService, ITimelineService timelineService)
{
this.client = client;
this.userService = userService;
this.timelineService = timelineService;
this.CreateCommands();
}
public IMobileServiceClient GetMobileServicesClinet()
{
if (_client == null)
{
_client = new MobileServiceClient(Helpers.Constants.ClientAddress);
}
return(_client);
}
public AzureExpenseService(IMobileServiceClient client)
{
_client = client;
_expenseTable = _client.GetTable <Expense>();
_reportTable = _client.GetTable <Report>();
_expenseReceiptTable = _client.GetTable <ExpenseReceipt>();
_categoryTable = _client.GetTable <Category>();
}
/// <summary>
/// Initialize Android plugin
/// </summary>
public static void Init(IAptkAmaPluginConfiguration configuration)
{
#if __ANDROID__ || __IOS__
CurrentPlatform.Init();
#endif
_configuration = configuration;
_client = CreateMobileServiceClient();
}
public AzureClient()
{
_client =
new
MobileServiceClient("http://EderadoXamarinTest.azurewebsites.net");
_table = _client.GetTable <Nota>();
}
/// <summary>
/// Initializes a new instance of the <see cref="SqLiteRepository{TEntity, TIdentifier}"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <exception cref="System.ArgumentNullException">context</exception>
public SqLiteRepository(IMobileServiceClient context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
this.DbContext = context;
}
//private IMobileServiceTable<TodoItem> todoTable = App.MobileService.GetTable<TodoItem>();
public MainPageViewModel()
{
_mobileService = new MobileServiceClient(
"https://isvacceleratoreumar.azurewebsites.net",
"https://default-web-eastus744386286bdd4ad5816e8100d15de451.azurewebsites.net",
"");
_todoTable = _mobileService.GetSyncTable<TodoItem>();
}
static MobileService()
{
#if LOCAL_SERVICE
Client = new MobileServiceClient("http://localhost:59988/", new LegacyUserIdHandler(), new AuthFailureHandler());
Client.AlternateLoginHost = new Uri(MobileServiceUrl);
#else
Client = new MobileServiceClient(MobileServiceUrl, new LegacyUserIdHandler(), new AuthFailureHandler());
#endif
}
public FileSyncTriggerFactory(IMobileServiceClient mobileServiceClient, bool autoUpdateParentRecords)
{
if (mobileServiceClient == null) {
throw new ArgumentNullException("mobileServiceClient");
}
this.mobileServiceClient = mobileServiceClient;
this.autoUpdateRecords = autoUpdateParentRecords;
}
public Task<MobileServiceUser> LoginAsync(IMobileServiceClient client, MobileServiceAuthenticationProvider provider, IDictionary<string, string> parameters = null)
{
try
{
return client.LoginAsync(Forms.Context, provider, parameters);
}
catch { }
return null;
}
public async Task InitializeAsync()
{
this.MobileService =
new MobileServiceClient(MobileUrl, new LoggingHandler());
var store = new MobileServiceSQLiteStore("local.db");
store.DefineTable<Job>();
await MobileService.SyncContext.InitializeAsync(store, StoreTrackingOptions.NotifyLocalAndServerOperations);
jobTable = MobileService.GetSyncTable<Job>();
}
private async Task<StorageToken> GetStorageToken(IMobileServiceClient client, MobileServiceFile file, StoragePermissions permissions)
{
var tokenRequest = new StorageTokenRequest();
tokenRequest.Permissions = permissions;
tokenRequest.TargetFile = file;
string route = string.Format("/tables/{0}/{1}/StorageToken", file.TableName, file.ParentId);
return await this.client.InvokeApiAsync<StorageTokenRequest, StorageToken>(route, tokenRequest);
}
IMobileServiceClient CreateClient()
{
client = new MobileServiceClient(DefaultMobileServiceUrl, new AuthHandler())
{
SerializerSettings = new MobileServiceJsonSerializerSettings()
{
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore,
CamelCasePropertyNames = true
}
};
return client;
}
public MainViewModel(NavigationService navigationService, IMobileServiceClient mobileServiceClient) : base(navigationService)
{
if (mobileServiceClient == null) throw new ArgumentNullException(nameof(mobileServiceClient));
this._mobileServiceClient = mobileServiceClient;
DigitalClock = new BasicDigitalClock();
var dispatcherTimer = new DispatcherTimer();
dispatcherTimer.Tick += dispatcherTimer_Tick;
dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, 100);
dispatcherTimer.Start();
}
/// <summary>
/// Initializes a new instance of the <see cref="MobileServiceAuthentication"/> class.
/// </summary>
/// <param name="client">
/// The <see cref="MobileServiceClient"/> associated with this
/// MobileServiceLogin instance.
/// </param>
/// <param name="provider">
/// The <see cref="MobileServiceAuthenticationProvider"/> used to authenticate.
/// </param>
public MobileServiceAuthentication(IMobileServiceClient client, MobileServiceAuthenticationProvider provider)
{
Debug.Assert(client != null, "client should not be null.");
this.Client = client;
this.Provider = provider;
string providerName = this.Provider.ToString().ToLower();
this.StartUri = new Uri(this.Client.ApplicationUri, MobileServiceAuthentication.LoginAsyncUriFragment + "/" + providerName);
this.EndUri = new Uri(this.Client.ApplicationUri, MobileServiceAuthentication.LoginAsyncDoneUriFragment);
}
private async Task<HttpResponseMessage> ResendRequest(IMobileServiceClient client, HttpRequestMessage request, CancellationToken cancellationToken)
{
// Clone the request
var clonedRequest = await CloneRequest(request);
// Set the authentication header
clonedRequest.Headers.Remove("X-ZUMO-AUTH");
clonedRequest.Headers.Add("X-ZUMO-AUTH", client.CurrentUser.MobileServiceAuthenticationToken);
// Resend the request
return await base.SendAsync(clonedRequest, cancellationToken);
}
public async Task InitializeAsync()
{
this.MobileService =
new MobileServiceClient(MobileUrl, new LoggingHandler());
var store = new MobileServiceSQLiteStore("local.db");
store.DefineTable<Job>();
await MobileService.SyncContext.InitializeAsync(store, StoreTrackingOptions.NotifyLocalAndServerOperations);
jobTable = MobileService.GetSyncTable<Job>();
// This sample doesn't do any authentication. To add it, see
// https://azure.microsoft.com/en-us/documentation/articles/app-service-mobile-xamarin-forms-get-started-users/
}
public async Task InitializeAsync()
{
this.MobileService = AppService.CreateMobileServiceClient(
MobileAppURL,
"");
// 3. initialize local store
var store = new MobileServiceSQLiteStore("local-db-" + MobileAppName);
store.DefineTable<Job>();
await MobileService.SyncContext.InitializeAsync(store);
jobTable = MobileService.GetSyncTable<Job>();
}
public async Task InitializeAsync()
{
this.MobileService = AppService.CreateMobileServiceClient(
"https://fetechnician-code.azurewebsites.net/",
"OtFsjAFDBBMENsPCBQFJmItwjvAfaX77");
// 3. initialize local store
var store = new MobileServiceSQLiteStore("local-db-fabrikam80");
store.DefineTable<Job>();
await MobileService.SyncContext.InitializeAsync(store);
jobTable = MobileService.GetSyncTable<Job>();
}
public Task<MobileServiceUser> LoginAsync(IMobileServiceClient client, MobileServiceAuthenticationProvider provider, IDictionary<string, string> parameters = null)
{
try
{
return client.LoginAsync(GetController(), provider, parameters);
}
catch (Exception e)
{
e.Data["method"] = "LoginAsync";
}
return null;
}
/// <summary>
/// Initializes a new instance of the <see cref="MobileServiceAuthentication"/> class.
/// </summary>
/// <param name="client">
/// The <see cref="MobileServiceClient"/> associated with this
/// MobileServiceLogin instance.
/// </param>
/// <param name="providerName">
/// The <see cref="MobileServiceAuthenticationProvider"/> used to authenticate.
/// </param>
public MobileServiceAuthentication(IMobileServiceClient client, string providerName)
{
Debug.Assert(client != null, "client should not be null.");
if (providerName == null)
{
throw new ArgumentNullException("providerName");
}
this.Client = client;
this.ProviderName = providerName;
this.StartUri = new Uri(this.Client.ApplicationUri, MobileServiceAuthentication.LoginAsyncUriFragment + "/" + this.ProviderName);
this.EndUri = new Uri(this.Client.ApplicationUri, MobileServiceAuthentication.LoginAsyncDoneUriFragment);
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
public MainViewModel(IMobileServiceClient client, NetworkInformationDelegate networkDelegate)
{
this.client = client;
this.networkDelegate = networkDelegate;
this.todoTable = client.GetTable<TodoItem2>();
this.RefreshCommand = new RelayCommand(this.RefreshTodoItems);
this.SaveCommand = new RelayCommand(this.Save);
this.CompletedCommand = new RelayCommand<TodoItem2>(x => this.Complete(x));
this.RemoveCommand = new RelayCommand<TodoItem2>(x => this.Remove(x));
this.Items = new ObservableCollection<TodoItem2>();
//this.RefreshTodoItems();
}
internal Push(IMobileServiceClient client)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
MobileServiceClient internalClient = client as MobileServiceClient;
if (internalClient == null)
{
throw new ArgumentException("Client must be a MobileServiceClient object");
}
this.PushHttpClient = new PushHttpClient(internalClient);
this.Client = client;
}
public CustomFileSyncTrigger(IFileSyncContext fileSyncContext, IMobileServiceClient mobileServiceClient, bool autoUpdateParentRecords)
{
if (fileSyncContext == null) {
throw new ArgumentNullException("fileSyncContext");
}
if (mobileServiceClient == null) {
throw new ArgumentNullException("mobileServiceClient");
}
this.fileSyncContext = fileSyncContext;
this.mobileServiceClient = mobileServiceClient;
this.dataChangeNotificationSubscription = mobileServiceClient.EventManager.Subscribe<StoreOperationCompletedEvent>(OnStoreOperationCompleted);
if (autoUpdateParentRecords) {
this.fileChangeNotificationSubscription = mobileServiceClient.EventManager.Subscribe<FileOperationCompletedEvent>(OnFileOperationCompleted);
}
}
public async Task<MobileServiceUser> LoginAsync(IMobileServiceClient client,
MobileServiceAuthenticationProvider provider)
{
var coreWindow = Windows.ApplicationModel.Core.CoreApplication.MainView;
// Dispatcher needed to run on UI Thread
var dispatcher = coreWindow.CoreWindow.Dispatcher;
MobileServiceUser user = null;
try
{
if (dispatcher.HasThreadAccess) //is running on UI thread
{
user = await client.LoginAsync(provider);
}
else
{
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
{
user = await client.LoginAsync(provider);
});
}
if (user != null)
{
Settings.Current.AuthToken = user?.MobileServiceAuthenticationToken ?? string.Empty;
Settings.Current.AzureMobileUserId = user?.UserId ?? string.Empty;
}
}
catch (Exception e)
{
if (!e.Message.Contains("cancelled"))
{
e.Data["method"] = "LoginAsync";
Logger.Instance.Report(e);
}
}
return user;
}
//returns info for the authenticated user
public static async Task<UserProfile> GetUserProfileAsync(IMobileServiceClient client)
{
var userprof =
await client.InvokeApiAsync<UserProfile>(
"UserInfo",
System.Net.Http.HttpMethod.Get,
null);
Settings.Current.UserFirstName = userprof?.FirstName ?? string.Empty;
Settings.Current.UserLastName = userprof?.LastName ?? string.Empty;
Settings.Current.UserProfileUrl = userprof?.ProfilePictureUri ?? string.Empty;
Settings.Current.UserUID = userprof?.UserId ?? string.Empty;
if (string.IsNullOrWhiteSpace(userprof?.ProfilePictureUri))
{
Settings.Current.UserProfileUrl = "http://appstudio.windows.com/Content/img/temp/icon-user.png";
}
return userprof;
}
// Return username of currently logged in user
public async Task<string> GetUsername(IMobileServiceClient client)
{
//Get user name
var url = "https://demofieldengineernxevufbcegvsy.azurewebsites.net/.auth/me";
HttpClient httpclient = new HttpClient();
httpclient.DefaultRequestHeaders.Add("X-ZUMO-AUTH", client.CurrentUser.MobileServiceAuthenticationToken);
HttpResponseMessage response = await httpclient.GetAsync (url);
string content = await response.Content.ReadAsStringAsync();
// get rid of {,},[,]
content = content.Replace("{","").Replace("}","").Replace("[","").Replace("]","").Replace("\"","");
// split with , and :
String [] splitContent = content.Split(new Char[] { ',', ':'},
StringSplitOptions.RemoveEmptyEntries).ToArray();
// find "name" key
int nameIndex = Array.IndexOf(splitContent, "name");
// get "name" value
return splitContent[(nameIndex+2)];
}
public async Task<MobileServiceUser> LoginAsync(IMobileServiceClient client,
MobileServiceAuthenticationProvider provider)
{
try
{
Settings.Current.LoginAttempts++;
var user = await client.LoginAsync(CrossCurrentActivity.Current.Activity, provider);
Settings.Current.AuthToken = user?.MobileServiceAuthenticationToken ?? string.Empty;
Settings.Current.AzureMobileUserId = user?.UserId ?? string.Empty;
return user;
}
catch (Exception e)
{
if (!e.Message.Contains("cancelled"))
{
e.Data["method"] = "LoginAsync";
Logger.Instance.Report(e);
}
}
return null;
}
public AddUserDeviceViewModel(
ILoggedInUserService loggedInUserService,
IMobileServiceClient mobileServiceClient)
{
loggedInUserService.CheckIfNull("loggedInUserService");
this.DeviceSelections = new ObservableCollection<string>();
this.AddCommand = new MvxCommand(this.AddExecute, this.CanAdd);
// setup key actions
this.keyActions = new Dictionary<string, Action>
{
{ UserDeviceSelections.Garmin, () => this.ShowViewModel<GarminViewModel>() },
{ UserDeviceSelections.Fitbit, () => this.ShowViewModel<FitbitViewModel>() },
};
this.DeviceSelections = new ObservableCollection<string> {
UserDeviceSelections.Garmin,
UserDeviceSelections.Fitbit
};
}
public async Task<MobileServiceUser> LoginAsync(IMobileServiceClient client,
MobileServiceAuthenticationProvider provider)
{
try
{
var window = UIKit.UIApplication.SharedApplication.KeyWindow;
var root = window.RootViewController;
if (root != null)
{
var current = root;
while (current.PresentedViewController != null)
{
current = current.PresentedViewController;
}
Settings.Current.LoginAttempts++;
var user = await client.LoginAsync(current, provider);
Settings.Current.AuthToken = user?.MobileServiceAuthenticationToken ?? string.Empty;
Settings.Current.AzureMobileUserId = user?.UserId ?? string.Empty;
return user;
}
}
catch (Exception e)
{
if (!e.Message.Contains("cancelled"))
{
e.Data["method"] = "LoginAsync";
Logger.Instance.Report(e);
}
}
return null;
}
public NotificationsService(IMobileServiceClient mobileService)
{
this.mobileService = mobileService;
}
