Example #1
0
        public async Task <ResGetServiceRecord> GetServiceRecord(ReqGetServiceRecord req)
        {
            var escapedGt     = req.Gamertag.ToSlug();
            var needsQueueing = await CacheMetaHelpers.NeedsQueueing(_dbClient, $"sr-{escapedGt}");

            if (needsQueueing)
            {
                await _dbClient.SetCacheMeta($"sr-{escapedGt}", "in_progress");

                TaskExt.FireAndForget(() => _sqsClient.SendMessageAsync(new QueueEvent
                {
                    Type    = QueueEventTypes.CacheServiceRecord,
                    Payload = new ServiceRecordPayload {
                        Gamertag = req.Gamertag
                    },
                }));

                throw new BaeException("queued_for_caching");
            }

            // TODO(0xdeafcafe): Clean this shit up 🤮
            var sr = await _dbClient.GetServiceRecord(escapedGt);

            var p1 = Mapper.Map <ServiceRecordResponse>(sr);
            var p2 = Mapper.Map <ResGetServiceRecord>(p1);

            p2.CacheInfo = new CacheInfo(sr.CreatedAt);

            return(p2);
        }
Example #2
0
        public async Task <(ServiceRecordResponse serviceRecord, ICacheInfo cacheInfo)> GetServiceRecord(Identity identity)
        {
            var path      = $"players/{identity.Gamertag}/h4/servicerecord";
            var key       = $"halo-4/service-record/{identity.XUIDStr}.json";
            var expire    = TimeSpan.FromMinutes(10);
            var cacheInfo = await fetchCacheInfo(key);

            if (cacheInfo != null && cacheInfo.IsFresh())
            {
                return(await fetchContent <ServiceRecordResponse>(key), cacheInfo);
            }

            var response = await requestWaypointData <External.ServiceRecordResponse>(path, null, key);

            if (response == null && cacheInfo != null)
            {
                return(await fetchContent <ServiceRecordResponse>(key), cacheInfo);
            }

            // Transpile and enrich content
            var finalCacheInfo = new CacheInfo(DateTime.UtcNow, expire);
            var final          = _transpiler.ServiceRecord(response);

            final = await _enricher.ServiceRecord(final, response);

            TaskExt.FireAndForget(() => cacheContent(key, final, finalCacheInfo));

            return(final, finalCacheInfo);
        }
Example #3
0
        public async Task <(RecentMatchesResponse recentMatches, ICacheInfo cacheInfo)> GetRecentMatches(Identity identity, GameMode gameMode, uint startAt, uint count)
        {
            var newCount    = count + 1;
            var gameModeStr = gameMode.ToString("d");
            var query       = new Dictionary <string, string>
            {
                { "gamemodeid", gameModeStr },
                { "startat", startAt.ToString() },
                { "count", newCount.ToString() },
            };
            var path      = $"players/{identity.Gamertag}/h4/matches";
            var key       = $"halo-4/recent-matches/{identity.XUIDStr}-{gameModeStr}-{startAt}-{newCount}.json";
            var expire    = TimeSpan.FromMinutes(10);
            var cacheInfo = await fetchCacheInfo(key);

            if (cacheInfo != null && cacheInfo.IsFresh())
            {
                return(await fetchContent <RecentMatchesResponse>(key), cacheInfo);
            }

            var response = await requestWaypointData <External.RecentMatchesResponse>(path, query, key);

            if (response == null && cacheInfo != null)
            {
                return(await fetchContent <RecentMatchesResponse>(key), cacheInfo);
            }

            // Transpile and enrich content
            var final = _transpiler.RecentMatches(response, newCount);
            // final = await enricher.RecentMatches(final, response); // Nothing to enrich here I think

            var finalCacheInfo = new CacheInfo(DateTime.UtcNow, expire);

            TaskExt.FireAndForget(() => cacheContent(key, final, finalCacheInfo));

            return(final, finalCacheInfo);
        }