internal static async Task SetValueAsync(string name, string value) { var conn = StreetFooRuntime.GetSystemDatabase(); // load an existing value... var setting = await conn.Table <SettingItem>().Where(v => v.Name == name).FirstOrDefaultAsync(); if (setting != null) { // change and update... setting.Value = value; await conn.UpdateAsync(setting); } else { setting = new SettingItem() { Name = name, Value = value }; // save... await conn.InsertAsync(setting); } }
// updates the local cache of the reports... public static async Task UpdateCacheFromServerAsync() { IEnumerable <ReportItem> reports = await GetSpooledReportsAsync(); if (reports == null) { // create a service proxy to call up to the server... var proxy = TinyIoCContainer.Current.Resolve <IGetReportsByUserServiceProxy>(); var result = await proxy.GetReportsByUserAsync(); // did it actually work? result.AssertNoErrors(); // set... reports = result.Reports; } // update... var conn = StreetFooRuntime.GetUserDatabase(); foreach (var report in reports) { // load the existing one, deleting it if we find it... var existing = await conn.Table <ReportItem>().Where(v => v.NativeId == report.NativeId).FirstOrDefaultAsync(); if (existing != null) { await conn.DeleteAsync(existing); } // create... await conn.InsertAsync(report); } }
public async Task <bool> RestorePersistentLogonAsync() { var token = await SettingItem.GetValueAsync(LogonTokenKey); if (!(string.IsNullOrEmpty(token))) { var username = await SettingItem.GetValueAsync(LastUsernameKey); if (!(string.IsNullOrEmpty(username))) { // logon... await StreetFooRuntime.LogonAsync(username, token); return(true); } else { return(false); } } else { return(false); } }
private static async Task SetValueAsyncInternal(string name, string value, SQLiteAsyncConnection conn) { // if we don't have a connection, assume the system one... if (conn == null) { conn = StreetFooRuntime.GetSystemDatabase(); } // load an existing value... var setting = await conn.Table <SettingItem>().Where(v => v.Name == name).FirstOrDefaultAsync(); if (setting != null) { // change and update... setting.Value = value; await conn.UpdateAsync(setting); } else { setting = new SettingItem() { Name = name, Value = value }; // save... await conn.InsertAsync(setting); } }
internal static async Task <ReportItem> CreateReportItemAsync(string title, string description, IMappablePoint point, IStorageFile image) { var item = new ReportItem() { Title = title, Description = description, NativeId = Guid.NewGuid().ToString(), Status = ReportItemStatus.New }; item.SetLocation(point); // save... var conn = StreetFooRuntime.GetUserDatabase(); await conn.InsertAsync(item); // stage the image... if (image != null) { // new path... var manager = new ReportImageCacheManager(); var folder = await manager.GetCacheFolderAsync(); // create... await image.CopyAsync(folder, item.NativeId + ".jpg"); } // return... return(item); }
//private static async Task EnsureSearchSuggestionsPopulated() //{ // // get all the items that we currently have... // var conn = StreetFooRuntime.GetUserDatabase(); // var suggestions = await conn.Table<SearchSuggestionItem>().ToListAsync(); // // do we have anything? // if (!(suggestions.Any())) // { // // get all the items... // var reports = await GetAllFromCacheAsync(); // // go through and dig out the words... // List<string> words = new List<string>(); // var regex = new Regex(@"\b\w+\b", RegexOptions.Singleline | RegexOptions.IgnoreCase); // foreach (var report in reports) // { // foreach (Match match in regex.Matches(report.Title)) // { // var word = match.Value; // if (word.Length > 2) // { // word = word.Substring(0, 1).ToUpper() + word.Substring(1).ToLower(); // if (!(words.Contains(word))) // words.Add(word); // } // } // } // // create suggestions from that... // foreach (var word in words) // { // var suggestion = new SearchSuggestionItem() // { // Suggestion = word // }; // await conn.InsertAsync(suggestion); // } // } //} public static async Task <Dictionary <string, List <ReportItem> > > GetSearchSuggestionsAsync(string queryText) { // get everything and sort by the title... var conn = StreetFooRuntime.GetUserDatabase(); var reports = await conn.QueryAsync <ReportItem>("select * from ReportItem where title like ? order by title", new object[] { queryText + "%" }); // walk and build a distinct list of matches... var results = new Dictionary <string, List <ReportItem> >(StringComparer.CurrentCultureIgnoreCase); foreach (var report in reports) { // if we don't have a result with that title... if (!(results.ContainsKey(report.Title))) { results[report.Title] = new List <ReportItem>(); } // add... results[report.Title].Add(report); } // return... return(results); }
public static async Task <ReportItem> GetByIdAsync(int id) { var conn = StreetFooRuntime.GetUserDatabase(); var query = conn.Table <ReportItem>().Where(v => v.Id == id); // return... return((await query.ToListAsync()).FirstOrDefault()); }
internal static async Task <IEnumerable <ReportItem> > SearchCacheAsync(string queryText) { // run a regex to extract out the words... var words = new List <string>(); var regex = new Regex(@"\b\w+\b", RegexOptions.Singleline | RegexOptions.IgnoreCase); foreach (Match match in regex.Matches(queryText)) { var word = match.Value.ToLower(); if (!(words.Contains(word))) { words.Add(word); } } // do we have anything to find? if (words.Count > 0) { // build up some sql... var sql = new StringBuilder(); var parameters = new List <object>(); sql.Append("select * from reportitem where "); bool first = true; foreach (var word in words) { if (first) { first = false; } else { sql.Append(" and "); } // add... sql.Append("title like ?"); parameters.Add("%" + word + "%"); } // run... var conn = StreetFooRuntime.GetUserDatabase(); return(await conn.QueryAsync <ReportItem>(sql.ToString(), parameters.ToArray())); } else { // return the lot... return(await GetAllFromCacheAsync()); } }
private async void DoLogon(CommandExecutionContext context) { // validate... ErrorBucket errors = new ErrorBucket(); Validate(errors); // ok? if (!(errors.HasErrors)) { // get a handler... var proxy = TinyIoCContainer.Current.Resolve <ILogonServiceProxy>(); // call... using (this.EnterBusy()) { var result = await proxy.LogonAsync(this.Username, this.Password); if (!(result.HasErrors)) { // logon... pass through the username as each user gets their own database... await StreetFooRuntime.LogonAsync(this.Username, result.Token); // while we're here - store a setting containing the logon name of the user... await SettingItem.SetValueAsync(LastUsernameKey, this.Username); // remember the user? if (this.RememberMe) { await SettingItem.SetValueAsync(LogonTokenKey, result.Token); } // show the reports page... this.Host.ShowView(typeof(IReportsPageViewModel)); } else { errors.CopyFrom(result); } } } // errors? if (errors.HasErrors) { await this.Host.ShowAlertAsync(errors); } }
internal static async Task <string> GetValueAsync(string name) { var conn = StreetFooRuntime.GetSystemDatabase(); // load any existing value... var setting = (await conn.Table <SettingItem>().Where(v => v.Name == name).ToListAsync()).FirstOrDefault(); if (setting != null) { return(setting.Value); } else { return(null); } }
// runs the operation... public async Task RunAsync(IBackgroundTaskInstance instance) { // configure the logging system to use a streaming target... try { LogManagerFactory.DefaultConfiguration.AddTarget(LogLevel.Trace, LogLevel.Fatal, new FileStreamingTarget()); } catch { // no-op... waiting for a change in MetroLog to see if the config // has already been done... } // logging is a bit tricky as we have to gather all of the messages // and flush them out... var logTasks = new List <Task <LogWriteOperation[]> >(); // do some logging... var asyncLogger = (ILoggerAsync)this.Logger; logTasks.Add(asyncLogger.InfoAsync("Started background task '{0}' (#{1})...", instance.Task.Name, instance.Task.TaskId)); // run... try { // start the app... await StreetFooRuntime.Start("Tasks"); // defer... await DoRunAsync(instance); } catch (Exception ex) { logTasks.Add(asyncLogger.FatalAsync(string.Format("Background task '{0}' (#{1}) failed.", instance.Task.Name, instance.Task.TaskId), ex)); } // finish... logTasks.Add(asyncLogger.InfoAsync("Finished background task '{0}' (#{1}).", instance.Task.Name, instance.Task.TaskId)); // wait... await Task.WhenAll(logTasks); }
internal async Task UpdateAsync(IStorageFile newImage) { // set the flag... this.Status = ReportItemStatus.Updated; // do we have a new image? if (newImage != null) { // set the flag... this.ImageChanged = true; // copy... await this.StageImageAsync(newImage); } // update the database... var conn = StreetFooRuntime.GetUserDatabase(); await conn.UpdateAsync(this); }
// sends the update to the server... internal async Task PushServerUpdateAsync() { this.Logger.Info("Pushing update for #{0} ({1})...", this.Id, this.Status); // what happened? if (this.Status == ReportItemStatus.Unchanged) { // no-op... } else if (this.Status == ReportItemStatus.New) { // insert... var service = new CreateReportServiceProxy(); var result = await service.CreateReportAsync(this.Title, this.Description, this.Longitude, this.Latitude); // patch back the native ID, if it worked... if (!(result.HasErrors)) { this.NativeId = result.NativeId; } else { this.Logger.Warn("Failed to insert report: " + result.GetErrorsAsString()); } } else { throw new NotSupportedException(string.Format("Cannot handle '{0}'.", this.Status)); } // push the image update... await PushServerImageUpdateAsync(); // reset our flag... this.Status = ReportItemStatus.Unchanged; // set... var conn = StreetFooRuntime.GetUserDatabase(); await conn.UpdateAsync(this); }
// indicates whether the cache is empty... internal static async Task <bool> IsCacheEmpty() { var conn = StreetFooRuntime.GetUserDatabase(); return((await conn.Table <ReportItem>().FirstOrDefaultAsync()) == null); }
private static async Task <IEnumerable <ReportItem> > GetLocallyChangedReportsAsync() { var conn = StreetFooRuntime.GetUserDatabase(); return(await conn.Table <ReportItem>().Where(v => v.Status != ReportItemStatus.Unchanged || v.ImageChanged).ToListAsync()); }
// reads the local cache and populates a collection... internal static async Task <IEnumerable <ReportItem> > GetAllFromCacheAsync() { var conn = StreetFooRuntime.GetUserDatabase(); return(await conn.Table <ReportItem>().ToListAsync()); }
public static async Task <string> GetValueAsyncForUser(string name) { return(await GetValueAsyncInternal(name, StreetFooRuntime.GetUserDatabase())); }
public static async Task SetValueAsyncForUser(string name, string value) { await SetValueAsyncInternal(name, value, StreetFooRuntime.GetUserDatabase()); }