public async Task <ApiWhitelabelPrivateUserModel> GetPersonalModelAsync(ApiPriority priority)
{
var cacheTimeMinutes = 10;
#if DEBUG
cacheTimeMinutes = 1;
#endif
var cachedUserPrivateModel = BlobCache.LocalMachine.GetAndFetchLatest(PersonalModelKey, () => GetPersonalModelRemoteAsync(priority), null, DateTimeOffset.Now.AddMinutes(cacheTimeMinutes));
var userPrivateModel = await cachedUserPrivateModel.FirstOrDefaultAsync();
if (userPrivateModel == null)
{
userPrivateModel = await cachedUserPrivateModel.LastOrDefaultAsync();
}
if (userPrivateModel != null)
{
if (Settings.UserRoles.Any(r => userPrivateModel.Roles.All(p => p != r)))
{
ViewDispatcher.ChangePresentation(new LanguageChangedPresentationHint());
}
Settings.UserRoles = userPrivateModel.Roles;
}
return(userPrivateModel);
}
public async Task <ApiRoomModel> GetRoomAsync(ApiPriority priority, Guid roomId)
{
var cachedRoom = await GetAllRoomsAsync(priority);
var roomModel = cachedRoom.FirstOrDefault(r => r.Id == roomId);
return(roomModel);
}
private async Task <ApiWhitelabelPrivateUserModel> GetRemoteSelfPrivateAsync(ApiPriority priority)
{
var userApi = _userApiService.GetApi(priority);
var apiResponse = await userApi.GetPersonalModel();
return(apiResponse?.Data);
}
public async Task <List <ApiCentralPrivateChatMessageModel> > GetUnreadAsync(ApiPriority priority)
{
var cachedUnreadMessages = BlobCache.LocalMachine.GetOrFetchObject("unreadmessages", () => GetUnreadMessagesRemoteAsync(priority), DateTimeOffset.Now.AddSeconds(1));
var unreadMessages = await cachedUnreadMessages.FirstOrDefaultAsync();
return(unreadMessages);
}
public async Task <List <ApiWhitelabelEventModel> > GetUpcomingAsync(ApiPriority priority, int number)
{
var cachedEventModels = BlobCache.LocalMachine.GetOrFetchObject($"upcomingEvents-{number}", () => GetUpcomingRemoteAsync(priority, number), DateTimeOffset.Now.AddMinutes(5));
var eventModels = await cachedEventModels.FirstOrDefaultAsync();
return(eventModels);
}
public async Task <List <ApiWhitelabelEventModel> > GetAllAsync(ApiPriority priority, Guid?categoryId = null, bool futureOnly = false)
{
var cachedEventModels = BlobCache.LocalMachine.GetOrFetchObject(GetKey(categoryId), () => GetAllRemoteAsync(priority, categoryId), DateTimeOffset.Now.AddSeconds(30));
var eventModels = await cachedEventModels.FirstOrDefaultAsync();
return(eventModels);
}
public async Task <ApiWhitelabelPrivateUserModel> GetSelfPrivateAsync(ApiPriority priority)
{
var cachedUserPrivateModel = BlobCache.LocalMachine.GetOrFetchObject("personalmodel", () => GetRemoteSelfPrivateAsync(priority), DateTimeOffset.Now.AddHours(1));
var userPrivateModel = await cachedUserPrivateModel.FirstOrDefaultAsync();
return(userPrivateModel);
}
public async Task <ApiWhitelabelEventModel> GetAsync(ApiPriority priority, Guid eventId)
{
var cachedEventModel = BlobCache.LocalMachine.GetOrFetchObject($"event-{eventId}", () => GetEventRemoteAsync(priority, eventId), DateTimeOffset.Now.AddMinutes(5));
var eventModel = await cachedEventModel.FirstOrDefaultAsync();
return(eventModel);
}
public async Task <ApiWhitelabelCompanyModel> GetAsync(ApiPriority priority, Guid id)
{
var cachedCompany = BlobCache.LocalMachine.GetOrFetchObject($"company-{id}", () => GetRemoteAsync(priority, id), DateTimeOffset.Now.AddHours(1));
var companyModel = await cachedCompany.FirstOrDefaultAsync();
return(companyModel);
}
public async Task <PlatformCustomMenuModel> GetPlatformCustomMenuAsync(ApiPriority priority)
{
var cachedCustomMenu = BlobCache.LocalMachine.GetOrFetchObject(PlatformMenuKey, () => GetPlatformCustomMenuRemoteAsync(priority), DateTimeOffset.Now.AddHours(1));
var customMenuModel = await cachedCustomMenu.FirstOrDefaultAsync();
return(customMenuModel);
}
public async Task <NotificationResponseModel> GetAllAsync(ApiPriority priority)
{
var cachedNotifications = BlobCache.LocalMachine.GetOrFetchObject("notifications", () => GetAllRemoteAsync(priority), DateTimeOffset.Now.AddSeconds(10));
var notificationModels = await cachedNotifications.FirstOrDefaultAsync();
return(notificationModels);
}
public async Task <List <ApiWhitelabelCompanyModel> > GetMyCompaniesAsync(ApiPriority priority)
{
var cachedCompanies = BlobCache.LocalMachine.GetOrFetchObject("mycompanies", () => GetMyCompaniesRemoteAsync(priority), DateTimeOffset.Now.AddHours(1));
var companyModels = await cachedCompanies.FirstOrDefaultAsync();
return(companyModels);
}
public async Task <List <ApiWhitelabelGroupModel> > GetAllAsync(ApiPriority priority)
{
var cachedGroup = BlobCache.LocalMachine.GetOrFetchObject("groups", () => GetAllRemoteAsync(priority), DateTimeOffset.Now.AddHours(1));
var groupModel = await cachedGroup.FirstOrDefaultAsync();
return(groupModel);
}
public async Task <List <ApiRoomModel> > GetAllRoomsAsync(ApiPriority priority)
{
var cachedRooms = BlobCache.LocalMachine.GetOrFetchObject(RoomsKey, () => GetAllRoomsRemoteAsync(priority), DateTimeOffset.Now.AddHours(1));
var roomModels = await cachedRooms.FirstOrDefaultAsync();
return(roomModels);
}
public async Task <FeedResponseModel> GetPostAsync(ApiPriority priority, Guid postId)
{
var cachedFeedPost = BlobCache.LocalMachine.GetOrFetchObject($"post-{postId}",
() => GetPostRemoteAsync(priority, postId), DateTimeOffset.Now);
var feedPost = await cachedFeedPost.FirstOrDefaultAsync();
return(feedPost);
}
public async Task <ApiWhitelabelPublicUserModel> GetUserAsync(Guid userId, ApiPriority priority)
{
// 1 hour cache
var cachedUserModel = BlobCache.LocalMachine.GetOrFetchObject($"user_{userId}", () => GetRemoteUserAsync(userId, priority), DateTimeOffset.Now.AddHours(1));
var userModel = await cachedUserModel.FirstOrDefaultAsync();
return(userModel);
}
public async Task <ApiCentralPublicPlatformModel> GetPublicPlatformAsync(ApiPriority priority)
{
var cachedPlatform = BlobCache.LocalMachine.GetAndFetchLatest(PlatformKey, () => GetRemotePlatformAsync(priority), null, DateTimeOffset.Now.AddHours(1));
var platform = await cachedPlatform.FirstOrDefaultAsync();
if (platform == null)
{
platform = await cachedPlatform.LastOrDefaultAsync();
}
return(platform);
}
public async Task <bool> SetHasReadAsync(ApiPriority priority, Guid conversationId)
{
if (!CrossConnectivity.Current.IsConnected)
{
return(false);
}
var api = _chatApiService.GetApi(priority);
var response = await api.MarkAsRead(conversationId);
return(response.Success);
}
private async Task <List <ApiWhitelabelCompanyModel> > GetAllRemoteAsync(ApiPriority priority)
{
if (!CrossConnectivity.Current.IsConnected)
{
return(null);
}
var companyApi = _companyApiService.GetApi(priority);
var apiResponse = await companyApi.GetAll();
return(apiResponse?.Data);
}
private async Task <List <ApiWhitelabelEventModel> > GetUpcomingRemoteAsync(ApiPriority priority, int number)
{
if (!CrossConnectivity.Current.IsConnected)
{
return(null);
}
var api = _eventApiService.GetApi(priority);
var eventModels = await api.GetUpcomming(number);
return(eventModels.Data);
}
private async Task <List <RoomReservationModel> > GetRemoteReservationsAsync(ApiPriority priority, Guid roomId, DateTime?date = null)
{
if (!CrossConnectivity.Current.IsConnected)
{
return(null);
}
var api = _bookingApiService.GetApi(priority);
var reservations = await api.CheckReservations(roomId, date?.Year ?? DateTime.Now.Year, date?.DayOfYear ?? DateTime.Now.DayOfYear);
return(reservations.Data);
}
private async Task <ApiWhitelabelEventModel> GetEventRemoteAsync(ApiPriority priority, Guid eventId)
{
if (!CrossConnectivity.Current.IsConnected)
{
return(null);
}
var api = _eventApiService.GetApi(priority);
var eventModel = await api.GetEvent(eventId);
return(eventModel.Data);
}
private async Task <List <ApiRoomModel> > GetAllRoomsRemoteAsync(ApiPriority priority)
{
if (!CrossConnectivity.Current.IsConnected)
{
return(null);
}
var api = _bookingApiService.GetApi(priority);
var response = await api.GetRooms();
return(response.Data);
}
private async Task <ApiWhitelabelGroupModel> GetRemoteAsync(ApiPriority priority, Guid id)
{
if (!CrossConnectivity.Current.IsConnected)
{
return(null);
}
var api = _groupApiService.GetApi(priority);
var apiResponse = await api.Get(id);
return(apiResponse?.Data);
}
private async Task <NotificationResponseModel> GetAllRemoteAsync(ApiPriority priority)
{
if (!CrossConnectivity.Current.IsConnected)
{
return(null);
}
var api = _notificationApiService.GetApi(priority);
var notificationModels = await api.GetAll();
return(new NotificationResponseModel
{
Notifications = notificationModels.Data,
RelatedItems = notificationModels.AdditionalData
});
}
public async Task <List <RoomReservationModel> > GetReservationsAsync(ApiPriority priority, Guid roomId, bool remote = false, DateTime?date = null)
{
var cacheKey = $"reservations-{roomId}{date?.Year}{date?.DayOfYear}";
// Clear cache when remote = true
if (remote)
{
await BlobCache.LocalMachine.Invalidate(cacheKey);
}
// 10 minute cache
var cachedReservations = BlobCache.LocalMachine.GetOrFetchObject(cacheKey, () => GetRemoteReservationsAsync(priority, roomId, date), DateTimeOffset.Now.AddMinutes(10));
var reservations = await cachedReservations.FirstOrDefaultAsync();
return(reservations);
}
private async Task <ApiCentralPublicPlatformModel> GetRemotePlatformAsync(ApiPriority priority)
{
if (!CrossConnectivity.Current.IsConnected)
{
return(null);
}
var api = _apiService.GetApi(priority);
var apiResponse = await api.Get();
if (apiResponse?.Data != null && apiResponse.Success)
{
Settings.AmPmNotation = apiResponse.Data.ShowAmPmNotation;
Settings.ShowExternalUrlWarning = apiResponse.Data.MemberSettings?.ShowExternalLinkWarning ?? false;
Settings.TimeFormat = apiResponse.Data.TimeString;
Settings.DateFormat = apiResponse.Data.DateString;
Settings.AccessControlEnabled = apiResponse.Data.AccessControlEnabled;
Settings.NotificationHubPath = apiResponse.Data.NotificationHub;
Settings.NotificationConnectionString = apiResponse.Data.NotificationListenSharedConnectionString;
Settings.AmPmNotation = apiResponse.Data.ShowAmPmNotation;
Settings.SenderId = apiResponse.Data.GoogleSenderId;
// Always set default language
var defaultLanguage = apiResponse.Data?.Languages?.FirstOrDefault(l => l.IsDefault);
if (defaultLanguage != null)
{
Settings.DefaultLanguage = defaultLanguage;
// Set the selected language too
Settings.SelectedLanguage = Settings.SelectedLanguageId == Guid.Empty ? defaultLanguage : apiResponse.Data.Languages.FirstOrDefault(l => l.Id == Settings.SelectedLanguageId);
}
Settings.BlobUrl = apiResponse.Data.CdnBasePath;
Settings.CompanyHeaderUrl = apiResponse.Data.Images?.CompanyCardHeader?.Medium;
Settings.EventHeaderUrl = apiResponse.Data.Images?.EventHeader?.Medium;
Settings.GroupsHeaderUrl = apiResponse.Data.Images?.GroupsHeader?.Medium;
}
return(apiResponse?.Data);
}
public TApi GetApi(ApiPriority priority)
{
switch (priority)
{
case ApiPriority.Explicit:
return(Explicit);
case ApiPriority.Speculative:
return(Speculative);
case ApiPriority.Background:
return(Background);
case ApiPriority.UserInitiated:
return(UserInitiated);
default:
throw new ArgumentOutOfRangeException(nameof(priority), priority, null);
}
}
public async Task <FeedResponseModel> GetGroupFeedAsync(ApiPriority priority, Guid groupId, DateTime?olderThen)
{
FeedResponseModel responseModel;
if (olderThen == null)
{
// First load
var cachedResponseModel = BlobCache.LocalMachine.GetOrFetchObject($"groupfeed-{groupId}",
() => GetGroupFeedRemoteAsync(priority, groupId, null), DateTimeOffset.Now.AddMinutes(5));
responseModel = await cachedResponseModel.FirstOrDefaultAsync();
}
else
{
// Load more
responseModel = await GetGroupFeedRemoteAsync(priority, groupId, olderThen);
}
return(responseModel);
}
public async Task <FeedResponseModel> GetHomeFeedAsync(ApiPriority priority, DateTime?olderThen)
{
FeedResponseModel feedResponseModel;
if (olderThen == null)
{
// First load
var cachedFeedResponse = BlobCache.LocalMachine.GetOrFetchObject("homefeed",
() => GetHomeFeedRemoteAsync(priority), DateTimeOffset.Now.AddMinutes(1));
feedResponseModel = await cachedFeedResponse.FirstOrDefaultAsync();
}
else
{
// Load more, always from web
feedResponseModel = await GetHomeFeedRemoteAsync(priority, olderThen);
}
return(feedResponseModel);
}
