//--------------------------------------------------------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();
});
}
