//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task UpdateAsync(string canteenId, bool force) { // Wait for the old update to finish first: if (updateTask is null || updateTask.IsCompleted) { updateTask = Task.Run(async() => { // Get current language: Language lang = CanteensDbContext.GetActiveLanguage(); if (lang is null) { Logger.Error("Failed to download dishes. No language available."); return; } Logger.Debug($"Dish language: {lang.Name}"); if (!force && CacheDbContext.IsCacheEntryValid(BuildCanteenDishUrl(canteenId, lang))) { Logger.Info("No need to fetch dishes. Cache is still valid."); return; } IEnumerable <Dish> dishes = await DownloadDishesAsync(canteenId, lang); if (!(dishes is null)) { using (CanteensDbContext ctx = new CanteensDbContext()) { ctx.RemoveRange(ctx.Dishes.Where(d => string.Equals(d.CanteenId, canteenId))); ctx.AddRange(dishes); } CacheDbContext.UpdateCacheEntry(BuildCanteenDishUrl(canteenId, lang), DateTime.Now.Add(MAX_TIME_IN_CACHE)); } }); } await updateTask.ConfAwaitFalse(); }
//--------------------------------------------------------Attributes:-----------------------------------------------------------------\\ #region --Attributes-- #endregion //--------------------------------------------------------Constructor:----------------------------------------------------------------\\ #region --Constructors-- #endregion //--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- #endregion //--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public override void Add() { using (CacheDbContext ctx = new CacheDbContext()) { ctx.Add(this); } }
public override void Update() { using (CacheDbContext ctx = new CacheDbContext()) { ctx.Update(this); } }
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\ #region --Constructors-- #endregion //--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- #endregion //--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task DeleteTumOnlineTokenAndIdAsync(ConfirmDialogContext ctx) { if (ctx.MODEL.Confirmed) { // Delete token: Storage.Classes.Settings.SetSetting(SettingsConsts.TUM_ID, ""); Vault.DeleteAllVaults(); // Delete DB: using (TumOnlineDbContext dbCtx = new TumOnlineDbContext()) { await dbCtx.Database.EnsureDeletedAsync(); await dbCtx.Database.EnsureCreatedAsync(); } // Remove all the cached stuff: using (CacheDbContext dbCtx = new CacheDbContext()) { await dbCtx.Database.EnsureDeletedAsync(); await dbCtx.Database.EnsureCreatedAsync(); } } }
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\ #region --Constructors-- #endregion //--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- #endregion //--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task <List <NewsSource> > UpdateNewsSourcesAsync(bool force) { // Wait for the old update to finish first: if (updateTask is null || updateTask.IsCompleted) { updateTask = Task.Run(async() => { List <NewsSource> newsSources; if (!force && CacheDbContext.IsCacheEntryValid(NEWS_SOURCES_URI.ToString())) { Logger.Info("No need to fetch news sources. Cache is still valid."); using (NewsDbContext ctx = new NewsDbContext()) { newsSources = ctx.NewsSources.ToList(); } } else { newsSources = await DownloadNewsSourcesAsync(); if (!(newsSources is null)) { using (NewsDbContext ctx = new NewsDbContext()) { ctx.RemoveRange(ctx.NewsSources); ctx.AddRange(newsSources); } CacheDbContext.UpdateCacheEntry(NEWS_SOURCES_URI.ToString(), DateTime.Now.Add(MAX_TIME_IN_CACHE)); return(newsSources); } } return(new List <NewsSource>()); }); } return(await updateTask.ConfAwaitFalse()); }
/// <summary> /// gets peers and stores them in db /// you are responsible for determining whether result is a group or user /// </summary> /// <param name="peerIds"></param> /// <param name="lookupInDb"></param> /// <returns></returns> public static async Task <List <object> > GetAndCacheNewPeers(IEnumerable <long> peerIds, bool lookupInDb = false) { var ids = peerIds.ToList(); var userIds = ids.Where(x => x > 0).ToList(); var users = new ReadOnlyCollection <User>(new List <User>()); if (userIds.Any()) { users = await VkObjects.Api.Users.GetAsync(userIds, ProfileFields.Photo50); } var groupIds = ids.Where(x => x < 0).Select(x => (-x).ToString()).ToList(); var groups = new ReadOnlyCollection <Group>(new List <Group>()); if (groupIds.Any()) { //groups.get requires all params groups = await VkObjects.Api.Groups.GetByIdAsync( groupIds, "", GroupsFields.IsVerified); } using (var db = new CacheDbContext()) { foreach (var user in users) { if (lookupInDb) { if (await db.VkPeers.FindAsync(user.Id) == null) { await AddUserToDb(user); } } else { await AddUserToDb(user); } } foreach (var group in groups) { if (lookupInDb) { if (await db.VkPeers.FindAsync(group.Id) == null) { await AddGroupToDb(group); } } else { await AddGroupToDb(group); } } } var collection = new List <object>(users); collection.AddRange(groups); return(collection); }
/// <summary> /// Initializes the singleton application object. This is the first line of authored code /// executed, and as such is the logical equivalent of main() or WinMain(). /// </summary> public App() { this.InitializeComponent(); this.Suspending += OnSuspending; using (var db = new CacheDbContext()) { db.Database.Migrate(); } }
public static void InitializeApi() { Api = new VkApi(); using (var db = new CacheDbContext()) { Api.Authorize(new ApiAuthParams { AccessToken = db.SessionInfo.First().AccessToken }); } }
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\ #region --Constructors-- #endregion //--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- #endregion //--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task <User> UpdateUserAsync(TumOnlineCredentials credentials, string obfuscatedId, bool force) { // Wait for the old update to finish first: if (!(updateTask is null) && !updateTask.IsCompleted) { try { return(await updateTask.ConfAwaitFalse()); } catch (Exception e) { InvokeOnRequestError(new RequestErrorEventArgs(e)); Logger.Error("Awaiting for user task failed with:", e); return(null); } } updateTask = Task.Run(async() => { if (!force && CacheDbContext.IsCacheEntryValid(TumOnlineService.PERSON_DETAILS.NAME)) { Logger.Info("No need to fetch user. Cache is still valid."); using (TumOnlineDbContext ctx = new TumOnlineDbContext()) { return(ctx.Users.Include(ctx.GetIncludePaths(typeof(User))).FirstOrDefault()); } } User user = null; try { user = await DownloadUserAsync(credentials, obfuscatedId, force); } catch (Exception e) { InvokeOnRequestError(new RequestErrorEventArgs(e)); Logger.Error("Failed to request user with:", e); } if (!(user is null)) { using (TumOnlineDbContext ctx = new TumOnlineDbContext()) { foreach (User userOld in ctx.Users.Where(u => u.Id == user.Id).Include(ctx.GetIncludePaths(typeof(User)))) { if (userOld.Groups.Count() > 0) { ctx.RemoveRange(userOld.Groups); userOld.Groups.Clear(); } ctx.Remove(userOld); } ctx.Add(user); } CacheDbContext.UpdateCacheEntry(TumOnlineService.PERSON_DETAILS.NAME, DateTime.Now.Add(TumOnlineService.PERSON_DETAILS.VALIDITY)); }
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\ #region --Constructors-- #endregion //--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- #endregion //--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task <IEnumerable <CalendarEvent> > UpdateAsync(TumOnlineCredentials credentials, bool force) { // Wait for the old update to finish first: if (!(updateTask is null) && !updateTask.IsCompleted) { try { return(await updateTask.ConfAwaitFalse()); } catch (Exception e) { InvokeOnRequestError(new RequestErrorEventArgs(e)); Logger.Error("Awaiting for calendar task failed with:", e); return(new List <CalendarEvent>()); } } updateTask = Task.Run(async() => { if (!force && CacheDbContext.IsCacheEntryValid(TumOnlineService.CALENDAR.NAME)) { Logger.Info("No need to fetch calendar events. Cache is still valid."); return(LoadCalendarEventsFromDb()); } IEnumerable <CalendarEvent> events = null; try { events = await DownloadCalendarEventsAsync(credentials, force); } catch (Exception e) { InvokeOnRequestError(new RequestErrorEventArgs(e)); Logger.Error("Failed to request calendar events with:", e); } if (!(events is null)) { using (TumOnlineDbContext ctx = new TumOnlineDbContext()) { ctx.RemoveRange(ctx.CalendarEvents); ctx.AddRange(events); } CacheDbContext.UpdateCacheEntry(TumOnlineService.CALENDAR.NAME, DateTime.Now.Add(TumOnlineService.CALENDAR.VALIDITY)); // Update the Windows calendar: if (!Settings.GetSettingBoolean(SettingsConsts.DISABLE_WINDOWS_CALENDAR_INTEGRATION)) { await UpdateWindowsCalendarAsync(events); } else { Logger.Debug("Not updating the Windows calendar. Setting disabled."); } }
public async Task <IEnumerable <Label> > UpdateLabelsAsync(bool force) { // Wait for the old update to finish first: if (!(updateLabelsTask is null) && !updateLabelsTask.IsCompleted) { return(await updateLabelsTask.ConfAwaitFalse()); } updateLabelsTask = Task.Run(async() => { IEnumerable <Label> labels = null; if (!force && CacheDbContext.IsCacheEntryValid(LABELS_URI.ToString())) { Logger.Info("No need to fetch labels. Cache is still valid."); using (CanteensDbContext ctx = new CanteensDbContext()) { labels = ctx.Labels.Include(ctx.GetIncludePaths(typeof(Label))).ToList(); } if (LABEL_CACHE.Count <= 0) { UpdateLabelCache(labels); } } labels = await DownloadLabelsAsync(); if (!(labels is null)) { using (CanteensDbContext ctx = new CanteensDbContext()) { ctx.RemoveRange(ctx.Labels); ctx.RemoveRange(ctx.LabelTranslations); ctx.AddRange(labels); } CacheDbContext.UpdateCacheEntry(LABELS_URI.ToString(), DateTime.Now.Add(MAX_TIME_IN_CACHE)); UpdateLabelCache(labels); return(labels); } Logger.Info("Failed to retrieve labels. Returning from DB."); using (CanteensDbContext ctx = new CanteensDbContext()) { labels = ctx.Labels.Include(ctx.GetIncludePaths(typeof(Label))).ToList(); } if (LABEL_CACHE.Count <= 0) { UpdateLabelCache(labels); } return(labels); }); return(await updateLabelsTask.ConfAwaitFalse()); }
private static async Task AddUserToDb(User user) { using (var db = new CacheDbContext()) { await db.VkPeers.AddAsync(new VkPeer { Avatar = user.Photo50 == null ? null : await ImageUtils.UriToByte(user.Photo50), PeerId = user.Id, ReadableName = user.FirstName + " " + user.LastName, VkMessages = new List <VkMessage>() }); await db.SaveChangesAsync(); } }
private static async Task AddGroupToDb(Group group) { using (var db = new CacheDbContext()) { await db.VkPeers.AddAsync(new VkPeer { Avatar = group.Photo50 == null ? null : await ImageUtils.UriToByte(group.Photo50), PeerId = -group.Id, ReadableName = group.Name, VkMessages = new List <VkMessage>() }); await db.SaveChangesAsync(); } }
private async Task <string> RequestStringAsync(Uri uri, bool checkCached) { Logger.Debug($"[{nameof(TumOnlineRequest)}] Request: {uri}"); if (checkCached && (SERVICE.VALIDITY != TumOnlineService.VALIDITY_NONE)) { string result = CacheDbContext.GetCacheLine(uri.ToString()); if (!string.IsNullOrEmpty(result)) { Logger.Debug($"Loaded cached request for: '{uri}'"); return(result); } Logger.Debug($"No cached request found for: '{uri}'"); } if (!NetworkHelper.Instance.ConnectionInformation.IsInternetAvailable) { Logger.Warn("Unable to request string - no internet."); return(null); } try { HttpClient client = new HttpClient(); client.DefaultRequestHeaders.TryAppendWithoutValidation("User-Agent", GetUserAgent()); HttpResponseMessage response = await client.GetAsync(uri); IHttpContent content = response.Content; IBuffer buffer = await content.ReadAsBufferAsync(); using (DataReader dataReader = DataReader.FromBuffer(buffer)) { string result = dataReader.ReadString(buffer.Length); if (SERVICE.VALIDITY != TumOnlineService.VALIDITY_NONE) { CacheDbContext.UpdateCacheLine(uri.ToString(), DateTime.Now.Add(SERVICE.VALIDITY), result); } Logger.Debug($"[{nameof(TumOnlineRequest)}] Response: {result}"); return(result); } } catch (Exception e) { Logger.Error("Failed to request string from: " + uri, e); } return(null); }
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\ #region --Constructors-- #endregion //--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- #endregion //--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task <IEnumerable <TuitionFee> > UpdateAsync(TumOnlineCredentials credentials, bool force) { // Wait for the old update to finish first: if (!(updateTask is null) && !updateTask.IsCompleted) { try { return(await updateTask.ConfAwaitFalse()); } catch (Exception e) { InvokeOnRequestError(new RequestErrorEventArgs(e)); Logger.Error("Awaiting for tuition fees task failed with:", e); return(new List <TuitionFee>()); } } updateTask = Task.Run(async() => { if (!force && CacheDbContext.IsCacheEntryValid(TumOnlineService.TUITION_FEE_STATUS.NAME)) { Logger.Info("No need to fetch tuition fees. Cache is still valid."); using (TumOnlineDbContext ctx = new TumOnlineDbContext()) { return(ctx.TuitionFees.Include(ctx.GetIncludePaths(typeof(TuitionFee))).ToList()); } } IEnumerable <TuitionFee> fees = null; try { fees = await DownloadFeesAsync(credentials, force); } catch (Exception e) { InvokeOnRequestError(new RequestErrorEventArgs(e)); Logger.Error("Failed to request tuition fees with:", e); } if (!(fees is null)) { using (TumOnlineDbContext ctx = new TumOnlineDbContext()) { ctx.RemoveRange(ctx.TuitionFees); ctx.AddRange(fees); } CacheDbContext.UpdateCacheEntry(TumOnlineService.GRADES.NAME, DateTime.Now.Add(TumOnlineService.GRADES.VALIDITY)); }
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task <IEnumerable <Canteen> > UpdateCanteensAsync(bool force) { // Wait for the old update to finish first: if (!(updateCanteensTask is null) && !updateCanteensTask.IsCompleted) { return(await updateCanteensTask.ConfAwaitFalse()); } updateCanteensTask = Task.Run(async() => { // Get current language: Language lang = CanteensDbContext.GetActiveLanguage(); if (lang is null) { Logger.Error("Failed to download canteens. No language available."); return(new List <Canteen>()); } Logger.Debug($"Canteen language: {lang.Name}"); if (!force && CacheDbContext.IsCacheEntryValid(CANTEENS_URI_POSTDIX + '_' + lang.BaseUrl)) { Logger.Info("No need to fetch canteens. Cache is still valid."); using (CanteensDbContext ctx = new CanteensDbContext()) { return(ctx.Canteens.Include(ctx.GetIncludePaths(typeof(Canteen))).ToList()); } } IEnumerable <Canteen> canteens = await DownloadCanteensAsync(lang); if (!(canteens is null)) { using (CanteensDbContext ctx = new CanteensDbContext()) { ctx.RemoveRange(ctx.Canteens); ctx.AddRange(canteens); } CacheDbContext.UpdateCacheEntry(CANTEENS_URI_POSTDIX + '_' + lang.BaseUrl, DateTime.Now.Add(MAX_TIME_IN_CACHE)); return(canteens); } Logger.Info("Failed to retrieve canteens. Returning from DB."); using (CanteensDbContext ctx = new CanteensDbContext()) { return(ctx.Canteens.Include(ctx.GetIncludePaths(typeof(Canteen))).ToList()); } }); return(await updateCanteensTask.ConfAwaitFalse()); }
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\ #region --Constructors-- #endregion //--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- #endregion //--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task <Identity> UpdateAsync(TumOnlineCredentials credentials, bool force) { // Wait for the old update to finish first: if (!(updateTask is null) && !updateTask.IsCompleted) { try { return(await updateTask.ConfAwaitFalse()); } catch (Exception e) { InvokeOnRequestError(new RequestErrorEventArgs(e)); Logger.Error("Awaiting for identity task failed with:", e); return(null); } } updateTask = Task.Run(async() => { if (!force && CacheDbContext.IsCacheEntryValid(TumOnlineService.ID.NAME)) { Logger.Info("No need to fetch identity. Cache is still valid."); using (TumOnlineDbContext ctx = new TumOnlineDbContext()) { return(ctx.Identities.Include(ctx.GetIncludePaths(typeof(Identity))).FirstOrDefault()); } } Identity identity = null; try { identity = await DownloadIdentityAsync(credentials, force); } catch (Exception e) { InvokeOnRequestError(new RequestErrorEventArgs(e)); Logger.Error("Failed to request identity with:", e); } if (!(identity is null)) { using (TumOnlineDbContext ctx = new TumOnlineDbContext()) { ctx.RemoveRange(ctx.Identities); ctx.Add(identity); } CacheDbContext.UpdateCacheEntry(TumOnlineService.ID.NAME, DateTime.Now.Add(TumOnlineService.ID.VALIDITY)); }
public void ParseTokenFromUrl(string url) { if (url.Contains("access_token=")) { var accessToken = url.Split("access_token=")[1].Split("&")[0]; using (var db = new CacheDbContext()) { db.SessionInfo.Add(new SessionInfo { AccessToken = accessToken }); db.SaveChanges(); } VkObjects.InitializeApi(); (Window.Current.Content as Frame)?.Navigate(typeof(MainPage)); } }
private void LoginWebView_OnLoaded(object sender, RoutedEventArgs e) { using (var db = new CacheDbContext()) { if (db.SessionInfo.Any()) { var sessionInfo = db.SessionInfo.First(); if (!string.IsNullOrWhiteSpace(sessionInfo.AccessToken)) { AuthWithKnownToken(sessionInfo); return; } } } LoginWebView.Navigate(new Uri( $"https://oauth.vk.com/authorize?client_id={VkConstants.AppId}&display=page&scope={VkConstants.AppScope}&redirect_uri=https://oauth.vk.com/blank.html&response_type=token&v=5.103&state=success" )); }
public async Task <IEnumerable <Language> > UpdateLanguagesAsync(bool force) { // Wait for the old update to finish first: if (!(updateLanguagesTask is null) && !updateLanguagesTask.IsCompleted) { return(await updateLanguagesTask.ConfAwaitFalse()); } updateLanguagesTask = Task.Run(async() => { if (!force && CacheDbContext.IsCacheEntryValid(LANGUAGES_URI.ToString())) { Logger.Info("No need to fetch canteen languages. Cache is still valid."); using (CanteensDbContext ctx = new CanteensDbContext()) { return(ctx.Languages.Include(ctx.GetIncludePaths(typeof(Language))).ToList()); } } IEnumerable <Language> languages = await DownloadLanguagesAsync(); if (!(languages is null)) { // Keep currently selected language or select english per default: List <Language> langList = languages.ToList(); MigrateActiveLanguage(langList); using (CanteensDbContext ctx = new CanteensDbContext()) { ctx.RemoveRange(ctx.Languages); ctx.AddRange(langList); } CacheDbContext.UpdateCacheEntry(LANGUAGES_URI.ToString(), DateTime.Now.Add(MAX_TIME_IN_CACHE)); return((IEnumerable <Language>)langList); } Logger.Info("Failed to retrieve canteen languages. Returning from DB."); using (CanteensDbContext ctx = new CanteensDbContext()) { return(ctx.Languages.Include(ctx.GetIncludePaths(typeof(Language))).ToList()); } }); return(await updateLanguagesTask.ConfAwaitFalse()); }
private void LoginWebView_OnNavigationStarting(WebView sender, WebViewNavigationStartingEventArgs args) { var authUri = args.Uri.ToString(); if (authUri.Contains("access_token=")) { var accessToken = authUri.Split("access_token=")[1].Split("&")[0]; Console.WriteLine($"Token is: {accessToken}"); using (var db = new CacheDbContext()) { db.SessionInfo.Add(new SessionInfo { AccessToken = accessToken }); db.SaveChanges(); } VkObjects.InitializeApi(); Frame.Navigate(typeof(MainPage)); } }
//--------------------------------------------------------Constructor:----------------------------------------------------------------\\ #region --Constructors-- #endregion //--------------------------------------------------------Set-, Get- Methods:---------------------------------------------------------\\ #region --Set-, Get- Methods-- #endregion //--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- public async Task <IEnumerable <StudyRoomGroup> > UpdateAsync(bool force) { // Wait for the old update to finish first: if (!(updateTask is null) && !updateTask.IsCompleted) { return(await updateTask.ConfAwaitFalse()); } updateTask = Task.Run(async() => { if (!force && CacheDbContext.IsCacheEntryValid(STUDY_ROOMS_URI.ToString())) { Logger.Info("No need to fetch study rooms. Cache is still valid."); using (StudyRoomDbContext ctx = new StudyRoomDbContext()) { return(ctx.StudyRoomGroups.Include(ctx.GetIncludePaths(typeof(StudyRoomGroup))).ToList()); } } IEnumerable <StudyRoomGroup> groups = null; try { groups = await DownloadRoomsAsync(force); } catch (Exception e) { InvokeOnRequestError(new RequestErrorEventArgs(e)); Logger.Error("Failed to request study rooms with:", e); } if (!(groups is null)) { using (StudyRoomDbContext ctx = new StudyRoomDbContext()) { ctx.RemoveRange(ctx.StudyRoomGroups); ctx.RemoveRange(ctx.StudyRooms); ctx.RemoveRange(ctx.StudyRoomAttributes); ctx.AddRange(groups); } CacheDbContext.UpdateCacheEntry(STUDY_ROOMS_URI.ToString(), DateTime.Now.Add(MAX_TIME_IN_CACHE)); }
public void CreateResultFileTest() { SqliteConnection connection = new SqliteConnection("Data Source=cache.db"); connection.Open(); DbContextOptionsBuilder <CacheDbContext> optionsBuilder = new DbContextOptionsBuilder <CacheDbContext>() .UseSqlite(connection); CacheDbContext context = new CacheDbContext(optionsBuilder.Options); context.Database.EnsureCreated(); CacheRepository repository = new CacheRepository(context); Guid resultFileId = Guid.NewGuid(); byte[] fileBytes = new byte[1]; fileBytes[0] = 1; BinaryFile resultFile = new BinaryFile { FileId = resultFileId, CreateDateUtc = DateTime.Now, FileName = "test.pdf", FileSize = fileBytes.Length, Content = new BinaryFileContent { FileBytes = fileBytes } }; repository.CreateFile(resultFile); Assert.NotNull(repository.GetFile(resultFileId)); }
//--------------------------------------------------------Misc Methods:---------------------------------------------------------------\\ #region --Misc Methods (Public)-- /// <summary> /// Gets called on App start and performs update task e.g. migrate the DB to a new format. /// </summary> #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously public static async Task OnAppStartAsync() #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously { PackageVersion versionLastStart = GetLastStartedVersion(); // Check if version != 0.0.0.0 => first ever start of the app: if (!(versionLastStart.Major == 0 && versionLastStart.Major == versionLastStart.Minor && versionLastStart.Minor == versionLastStart.Revision && versionLastStart.Revision == versionLastStart.Build) || Settings.GetSettingBoolean(SettingsConsts.INITIALLY_STARTED)) { if (!Compare(versionLastStart, GetPackageVersion())) { // Total refactoring in version 2.0.0.0: if (versionLastStart.Major < 2) { Logger.Info("Started updating to version 2.0.0.0."); Settings.SetSetting(SettingsConsts.INITIALLY_STARTED, false); Logger.Info("Finished updating to version 2.0.0.0."); } // DB layout for dishes changed in 2.1.0.0: if (versionLastStart.Major <= 2 && versionLastStart.Minor < 1) { Logger.Info("Started updating to version 2.1.0.0."); Logger.Info("Resetting canteens DB..."); try { StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync("canteens.db"); if (!(file is null)) { await file.DeleteAsync(); } } catch (Exception e) { Logger.Error("Failed to remove old canteens DB with:", e); } Logger.Info("Updating canteens and dishes..."); await CanteenManager.INSTANCE.UpdateCanteensAsync(true); Settings.SetSetting(SettingsConsts.INITIALLY_STARTED, false); Logger.Info("Finished updating to version 2.1.0.0."); } // DB layout for dishes changed in 2.2.0.0: if (versionLastStart.Major <= 2 && versionLastStart.Minor < 2) { Logger.Info("Started updating to version 2.2.0.0."); Logger.Info("Resetting canteens DB..."); try { StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync("canteens.db"); if (!(file is null)) { await file.DeleteAsync(); } } catch (Exception e) { Logger.Error("Failed to remove old canteens DB with:", e); } Logger.Info("Updating canteens and dishes..."); await CanteenManager.INSTANCE.UpdateCanteensAsync(true); Settings.SetSetting(SettingsConsts.INITIALLY_STARTED, false); Logger.Info("Finished updating to version 2.2.0.0."); } // DB layout for TUMonline changed in 2.3.0.0: if (versionLastStart.Major <= 2 && versionLastStart.Minor < 3) { Logger.Info("Started updating to version 2.3.0.0."); using (TumOnlineDbContext ctx = new TumOnlineDbContext()) { await ctx.RecreateDbAsync(); } CacheDbContext.ClearCache(); Logger.Info("Finished updating to version 2.2.0.0."); } // New tables for the canteen DB in 2.4.0.0: if (versionLastStart.Major <= 2 && versionLastStart.Minor < 4) { Logger.Info("Started updating to version 2.4.0.0."); using (CanteensDbContext ctx = new CanteensDbContext()) { await ctx.RecreateDbAsync(); } CacheDbContext.ClearCache(); Logger.Info("Finished updating to version 2.4.0.0."); } } } SetVersion(GetPackageVersion()); }
private async void OnNewMessageReceived(Message message) { // var forwardedMessages = message.ForwardedMessages?.ToArray() ?? new Message[] { }; var attachments = message.Attachments?.ToArray() ?? new Attachment[] { }; // var replyMessage = message.ReplyMessage; // var actionObject = message.Action; using (var db = new CacheDbContext()) { if (message.FromId == null || message.PeerId == null) { return; } string readableName; var foundPeerByFromId = await db.VkPeers.FindAsync(message.FromId); if (foundPeerByFromId != null) { readableName = foundPeerByFromId.ReadableName; } else { var peer = (await VkUtils.GetAndCacheNewPeers(new[] { (long)message.FromId })).First(); readableName = message.FromId > 0 ? ((User)peer).FirstName + " " + ((User)peer).LastName : ((Group)peer).Name; foundPeerByFromId = await db.VkPeers.FindAsync(message.FromId); } var foundPeerByPeerId = await db.VkPeers.FindAsync(message.PeerId); var indexToUpdate = 0; ChatsListItemData itemToUpdate = null; for (var i = 0; i < _viewModel.ChatsList.Count; i++) { var item = _viewModel.ChatsList[i]; if (item.PeerId != message.PeerId) { continue; } indexToUpdate = i; itemToUpdate = item; (await db.VkPeers.FindAsync(item.PeerId)).LastMessage = message.Text; break; } _viewModel.ChatsList.RemoveAt(indexToUpdate); _viewModel.ChatsList.Insert(0, new ChatsListItemData { Avatar = itemToUpdate?.Avatar, Message = message.Text, Name = itemToUpdate?.Name, PeerId = message.PeerId ?? 0, IsThisUser = itemToUpdate?.IsThisUser ?? false }); await db.VkMessages.AddAsync(new VkMessage { ConversationMessageId = message.ConversationMessageId ?? 0, Text = message.Text, FromId = message.FromId ?? 0, PeerId = message.PeerId ?? 0, VkPeer = foundPeerByPeerId, ReceiveTime = DateTime.Now }); await db.SaveChangesAsync(); _viewModel.MessageDict[(long)message.PeerId].Add(new ChatsListItemData { Name = readableName, Message = message.Text, IsThisUser = message.FromId == db.SessionInfo.First().UserId }); foreach (var attachment in attachments) { if (attachment.Type == typeof(Photo)) { await ViewAttachmentInWindow(attachment); } } } }
private async void MainPage_OnLoaded(object sender, RoutedEventArgs e) { var isInternetConnected = NetworkInformation.GetInternetConnectionProfile() != null; var networkStatusCallback = new NetworkStatusChangedEventHandler(OnNetworkStatusChanged); _viewModel.ChatsList = new ObservableCollection <ChatsListItemData>(); ChatsListView.ItemsSource = _viewModel.ChatsList; _viewModel.InboxesList = new ObservableCollection <ChatsListItemData>(); InboxesListView.ItemsSource = _viewModel.InboxesList; using (var db = new CacheDbContext()) { foreach (var vkPeer in db.VkPeers) { // last is unsupported in ef //var lastMessageText = db.VkMessages.Where(x => x.PeerId == vkPeer.PeerId) // .OrderByDescending(x => x.ConversationMessageId).FirstOrDefault()?.Text; //if (string.IsNullOrEmpty(vkPeer.LastMessage)) continue; _viewModel.ChatsList.Add(new ChatsListItemData { Avatar = await ImageUtils.ConvertToImageSource(vkPeer.Avatar), Message = vkPeer.LastMessage, Name = vkPeer.ReadableName, PeerId = vkPeer.PeerId, IsThisUser = false }); } foreach (var inbox in db.Inboxes) { _viewModel.InboxesList.Add(new ChatsListItemData { Name = inbox.ReadableName, Avatar = await ImageUtils.ConvertToImageSource(inbox.Avatar) }); } } _viewModel.MessageDict = new Dictionary <long, ObservableCollection <ChatsListItemData> >(); foreach (var item in _viewModel.ChatsList) { _viewModel.MessageDict.Add(item.PeerId, new ObservableCollection <ChatsListItemData>()); } using (var db = new CacheDbContext()) { foreach (var vkMessage in db.VkMessages) { if (!_viewModel.MessageDict.ContainsKey(vkMessage.PeerId)) { _viewModel.MessageDict.Add(vkMessage.PeerId, new ObservableCollection <ChatsListItemData>()); } //FromId - because one peer can have several senders var vkPeer = await db.VkPeers.FindAsync(vkMessage.FromId); _viewModel.MessageDict[vkMessage.PeerId].Add(new ChatsListItemData { Avatar = await ImageUtils.ConvertToImageSource(vkPeer.Avatar), Message = vkMessage.Text, Name = vkPeer.ReadableName, PeerId = vkMessage.PeerId, IsThisUser = vkMessage.FromId == db.SessionInfo.First().UserId }); } } if (isInternetConnected) { _viewModel.InboxesList = await VkDataToClassesUtils.GetInboxesAsItemData(); _viewModel.ChatsList = await VkDataToClassesUtils.GetChatsListAsItemData(); ChatsListView.ItemsSource = _viewModel.ChatsList; InboxesListView.ItemsSource = _viewModel.InboxesList; InboxesProgressRing.IsActive = false; InboxesProgressRing.Visibility = Visibility.Collapsed; ChatsListProgressBar.IsEnabled = false; ChatsListProgressBar.Visibility = Visibility.Collapsed; } if (!isInternetConnected) { return; } var vkLongPoll = new VKLongPoll { NewMessageReceived = OnNewMessageReceived }; await vkLongPoll.FetchHistory(); }
public static async Task <ObservableCollection <ChatsListItemData> > GetChatsListAsItemData(ulong?offset = null) { var chats = await VkObjects.Api.Messages.GetConversationsAsync(new GetConversationsParams { Count = 20, Offset = offset }); var chatsListDatas = new ObservableCollection <ChatsListItemData>(); foreach (var chat in chats.Items) { var peerName = ""; Uri peerImageUri = null; if (chat.Conversation.Peer.Type == ConversationPeerType.User) { var user = (await VkObjects.Api.Users.GetAsync(new[] { chat.Conversation.Peer.Id }, ProfileFields.Photo50 | ProfileFields.FirstName | ProfileFields.LastName))[0]; peerName = user.FirstName + ' ' + user.LastName; peerImageUri = user.Photo50; } else if (chat.Conversation.Peer.Type == ConversationPeerType.Chat) { var chatSettings = chat.Conversation.ChatSettings; peerName = chatSettings.Title; peerImageUri = chatSettings.Photo?.Photo50; } else if (chat.Conversation.Peer.Type == ConversationPeerType.Group) { //method requires all params bug in library var group = (await VkObjects.Api.Groups.GetByIdAsync( new[] { (-chat.Conversation.Peer.Id).ToString() }, "", GroupsFields.IsVerified))[0]; peerName = group.Name; peerImageUri = group.Photo50; } var peerImage = await ImageUtils.UriToByte(peerImageUri); using (var db = new CacheDbContext()) { if (await db.VkPeers.FindAsync(chat.Conversation.Peer.Id) == null) { await db.VkPeers.AddAsync(new VkPeer { PeerId = chat.Conversation.Peer.Id, ReadableName = peerName, Avatar = peerImage, VkMessages = new List <VkMessage>() }); await db.SaveChangesAsync(); } } var chatsListItemData = new ChatsListItemData { PeerId = chat.Conversation.Peer.Id, IsThisUser = false, Message = chat.LastMessage.Text, Name = peerName, Avatar = await ImageUtils.ConvertToImageSource(peerImage) }; chatsListDatas.Add(chatsListItemData); } return(chatsListDatas); }
public static async Task <ObservableCollection <ChatsListItemData> > GetInboxesAsItemData() { var thisUser = await VkObjects.Api.Users.GetAsync(new long[] { }, ProfileFields.Photo50 | ProfileFields.FirstName | ProfileFields.LastName); //this user is first, groups will go after //extract to another method using (var db = new CacheDbContext()) { db.SessionInfo.First().UserId = thisUser.First().Id; db.SessionInfo.First().ReadableName = thisUser.First().FirstName + " " + thisUser.First().LastName; await db.SaveChangesAsync(); } var groupsNavigationViewData = new List <ChatsListItemData> { await thisUser.Select(async sthisUser => { var avatar = await ImageUtils.ConvertToImageSource(await ImageUtils.UriToByte(sthisUser.Photo50)); return(new ChatsListItemData { Name = sthisUser.FirstName + " " + sthisUser.LastName, Avatar = avatar }); }).First(), }; var groupsVkCollection = await VkObjects.Api.Groups.GetAsync(new GroupsGetParams { Filter = GroupsFilters.Moderator, Extended = true, Count = 1000 }); foreach (var vkGroup in groupsVkCollection) { var avatar = await ImageUtils.ConvertToImageSource(await ImageUtils.UriToByte(vkGroup.Photo50)); var groupItem = new ChatsListItemData { Name = vkGroup.Name, Avatar = avatar }; groupsNavigationViewData.Add(groupItem); } using (var db = new CacheDbContext()) { foreach (var vkGroup in groupsVkCollection) { //todo update, not add if (db.Inboxes.Find(vkGroup.Id) == null) { await db.Inboxes.AddAsync(new VkInbox { //todo double download to single Avatar = await ImageUtils.UriToByte(vkGroup.Photo50), Id = vkGroup.Id, Type = InboxType.Group, ReadableName = vkGroup.Name }); } } if (db.Inboxes.Find(thisUser.First().Id) == null) { await db.Inboxes.AddAsync(new VkInbox { Avatar = await ImageUtils.UriToByte(thisUser.First().Photo50), Id = thisUser.First().Id, Type = InboxType.User, ReadableName = thisUser.First().FirstName + " " + thisUser.First().LastName }); } await db.SaveChangesAsync(); } return(new ObservableCollection <ChatsListItemData>(groupsNavigationViewData)); }
public CacheRepository(CacheDbContext dbContext) { this.context = dbContext; }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IApplicationLifetime life, CacheDbContext cacheDbContext, GetPdfOnlineDbContext getPdfOnlineDbContext) { loggerFactory.AddConsole(Configuration.GetSection("Logging")); loggerFactory.AddDebug(); var locOptions = app.ApplicationServices.GetService <IOptions <RequestLocalizationOptions> >(); app.UseRequestLocalization(locOptions.Value); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseWebpackDevMiddleware(new WebpackDevMiddlewareOptions { HotModuleReplacement = true }); } else { app.UseExceptionHandler("/Home/Error"); } app.UseCors("AllowSpecificOrigin"); app.UseDefaultFiles(); app.UseStaticFiles(); app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{culture?}/{controller=Home}/{action=Index}/{id?}"); routes.MapSpaFallbackRoute( name: "spa-fallback", defaults: new { controller = "Home", action = "Index" }); }); cacheDbContext.Database.EnsureCreated(); getPdfOnlineDbContext.Database.Migrate(); // Enable middleware to serve generated Swagger as a JSON endpoint. app.UseSwagger(c => { c.RouteTemplate = "api/{documentName}/swagger.json"; }); // Enable middleware to serve swagger-ui (HTML, JS, CSS etc.), specifying the Swagger JSON endpoint. /*app.UseSwaggerUI(c => * { * c.SwaggerEndpoint("/api/v1/swagger.json", "GetPDF.online REST API v1"); * c.RoutePrefix = "swagger"; * });*/ life.ApplicationStarted.Register(() => { var cacheRepository = app.ApplicationServices.GetService <ICacheRepository>(); var options = this.Configuration.Get <UserSettingsOptions>(); this.CreateAndOpenHosts(options.Host.TcpPort, options.LibreOffice.UseCustomUnoPath, options.LibreOffice.CustomUnoPath, options.Data.ConnectionString); Task task = DeleteExpiredDataScheduler.Start(cacheRepository); task.Wait(); }); }