コード例 #1
0
        private async void GetUserProfile(AskForGitHubUserProfile message)
        {
            Cache.TryGetValue("USER_PROFILE", out var cacheResponse);

            if (
                cacheResponse == null ||
                cacheResponse?.Retrieved.Add(ValidDuration) < DateTimeOffset.Now
                )
            {
                using (var scope = ServiceScopeFactory.CreateScope())
                {
                    var service = scope.ServiceProvider.GetServices <IStrykerService>()
                                  .Where(s => s.GetType() == typeof(GitHubService))
                                  .FirstOrDefault();

                    var result = await service?.Get($"users/{message.Profile}");

                    var resultObject = JsonConvert.DeserializeObject <GitHubUser>((string)result.Data);

                    Cache.AddOrSet(
                        "USER_PROFILE",
                        new CacheEntry
                    {
                        Retrieved = DateTimeOffset.Now,
                        Data      = resultObject
                    }
                        );

                    Sender.Tell(resultObject);
                }
            }
            else
            {
                Sender.Tell(cacheResponse.Data as GitHubUser);
            }
        }
コード例 #2
0
        private async void GetUserProfile(AskForTwitchUserProfile message)
        {
            Cache.TryGetValue("USER_PROFILE", out var cacheResponse);

            if (
                cacheResponse == null ||
                cacheResponse?.Retrieved.Add(ValidDuration) < DateTimeOffset.Now
                )
            {
                using (var scope = ServiceScopeFactory.CreateScope())
                {
                    try
                    {
                        var service = scope.ServiceProvider.GetServices <IStrykerService>()
                                      .Where(s => s.GetType() == typeof(TwitchService))
                                      .FirstOrDefault() as TwitchService;

                        service.SetHttpClientHeaders(AccessToken.AccessToken, ClientId);

                        // Get the user information
                        var userResult = await service?.Get($"helix/users?login={message.Profile}");

                        // Result is in the form { "data": [ { ... }, { ... } ] }
                        var userResultObject = JsonConvert.DeserializeObject <JObject>((string)userResult.Data);
                        var userDataString   = userResultObject.SelectToken("data").ToString();

                        // We want the first user
                        var userResultDataList = JsonConvert.DeserializeObject <List <TwitchUser> >(userDataString);
                        var user = userResultDataList.First();

                        // Get the follower information, now that we know the UserId
                        var followerResult = await service?.Get($"helix/users/follows?to_id={user.Id}");

                        var followers = JsonConvert.DeserializeObject <FollowsTo>((string)followerResult.Data);

                        var resultObject = new StrykerTwitchUser {
                            User = user, Followers = followers
                        };

                        Cache.AddOrSet(
                            "USER_PROFILE",
                            new CacheEntry
                        {
                            Retrieved = DateTimeOffset.Now,
                            Data      = resultObject
                        }
                            );

                        Sender.Tell(resultObject);
                    }
                    catch (Exception ex)
                    {
                        Sender.Tell(ex);
                    }
                }
            }
            else
            {
                Sender.Tell(cacheResponse.Data as StrykerTwitchUser);
            }
        }
コード例 #3
0
        private async void GetTimeEntries(AskForTimeEntries message)
        {
            using (var scope = ServiceScopeFactory.CreateScope())
            {
                // First check if we have the required information in cache
                Cache.TryGetValue("USER_PROFILE", out var userCache);
                Cache.TryGetValue("PROJECTS", out var projectCache);

                var service = scope.ServiceProvider.GetServices <IStrykerService>()
                              .Where(s => s.GetType() == typeof(ClockifyService))
                              .FirstOrDefault();
                var now = DateTimeOffset.Now;

                // If we're missing the user we need to get that before continuing
                if (userCache == null)
                {
                    var userResult = await service?.Get("v1/user");

                    var userResultObject = userResult.Data != null
                        ? JsonConvert.DeserializeObject <ClockifyUser>((string)userResult.Data)
                        : null;

                    var userCacheEntry = new CacheEntry
                    {
                        Retrieved = now,
                        Data      = userResultObject
                    };

                    userCache = userCacheEntry;
                    Cache.AddOrSet(
                        "USER_PROFILE",
                        userCacheEntry
                        );
                }

                // Now that we have the user and workspace ids, we can get the tags
                // and time entries
                var userData       = userCache.Data as ClockifyUser;
                var projectRequest = projectCache == null || projectCache.Retrieved.Add(ValidDuration) < DateTimeOffset.Now
                    ? service?.Get($"v1/workspaces/{userData.Workspace}/projects")
                    : null;

                var start = now.Subtract(TimeSpan.FromDays(7)).ToString("O");
                var end   = now.ToString("O");

                // The clockify API doesn't like the offset, so we need to replace with Z
                start = Regex.Replace(start, @"-..:..", "Z");
                end   = Regex.Replace(end, @"-..:..", "Z");
                var timeEntryRequest = service?.Get($"v1/workspaces/{userData.Workspace}/user/{userData.Id}/time-entries?start={start}&end={end}");

                Task.WaitAll(new Task[] { projectRequest, timeEntryRequest });
                var projects = projectRequest != null
                    ? JsonConvert.DeserializeObject <List <Project> >((string)projectRequest.Result.Data)
                    : projectCache.Data as List <Project>;

                var timeEntries = JsonConvert.DeserializeObject <List <TimeEntry> >((string)timeEntryRequest.Result.Data);

                // Now that we have tags and time entries, we can build our response
                // We need to return a set of projects with their associated times in seconds
                Dictionary <string, int> timeTrackingResults = new Dictionary <string, int>();
                foreach (var entry in timeEntries)
                {
                    var projectName = projects
                                      .Where(p => p.Id == entry.ProjectId)
                                      .Select(p => p.Name)
                                      .FirstOrDefault();

                    if (entry.TimeInterval.Duration != null)
                    {
                        var entryDuration = entry.TimeInterval?.Duration;
                        var hourMatch     = Regex.Match(entryDuration, @"[0-9]+H");
                        var minuteMatch   = Regex.Match(entryDuration, @"[0-9]+M");
                        var secondsMatch  = Regex.Match(entryDuration, @"[0-9]+S");

                        int.TryParse(hourMatch.Value.TrimEnd('H'), out var hours);
                        int.TryParse(minuteMatch.Value.TrimEnd('M'), out var minutes);
                        int.TryParse(secondsMatch.Value.TrimEnd('S'), out var seconds);

                        var secondsDuration = seconds + (minutes * 60) + (hours * 60 * 60);

                        if (timeTrackingResults.TryGetValue(projectName, out var existingProjectDuration))
                        {
                            var newProjectDuration = existingProjectDuration + secondsDuration;
                            timeTrackingResults.AddOrSet(projectName, newProjectDuration);
                        }
                        else
                        {
                            timeTrackingResults.Add(projectName, secondsDuration);
                        }
                    }
                }

                Sender.Tell(timeTrackingResults);
            }
        }