Beispiel #1
0
        // We only unfollow if nobody is subscribed anymore
        public async Task UnfollowUser(long userId, string discordName)
        {
            var RelevantUser = await UserAsync.GetUserFromId(userId);

            // For some reason, User has an unfollow method but UserAsync doesn't
            User.UnFollowUser(RelevantUser);
        }
Beispiel #2
0
        public async Task AddFriendsToList()
        {
            //var userId = "rkgk_mochi_112";
            foreach (var targetName in new[] { "zombie_haruna", "zombie_you" })
            {
                var me = await UserAsync.GetAuthenticatedUser(cred);

                var listName    = $"home-{targetName}";
                var twitterList = TwitterList.CreateList(listName, PrivacyMode.Private, "Just for test of my application.");

                var target = await UserAsync.GetUserFromScreenName(targetName);

                if (targetName.Contains("haruna"))
                {
                    var users = await UserAsync.GetFriendIds(target, maxFriendsToRetrieve : 100);

                    foreach (var userId in users)
                    {
                        var result = twitterList.AddMember(userId);
                        Debug.WriteLine(result);
                    }
                }
                else
                {
                    continue;
                }
            }
        }
Beispiel #3
0
        public async Task <ITweet> GetLatestTweetFromTimeline(string name)
        {
            var user = await UserAsync.GetUserFromScreenName(name);

            var timeline = Timeline.GetUserTimeline(user.Id);

            return(timeline.FirstOrDefault());
        }
        public async Task <ActionResult> Index()
        {
            Auth.SetUserCredentials("CONSUMER_KEY", "CONSUMER_SECRET", "ACCESS_TOKEN", "ACCESS_TOKEN_SECRET");
            var user = await UserAsync.GetAuthenticatedUser();

            ViewBag.User = user.Name;

            return(View());
        }
Beispiel #5
0
        public static void Main(string[] args)
        {
            Auth.SetUserCredentials("CONSUMER_KEY", "CONSUMER_SECRET", "ACCESS_TOKEN", "ACCESS_TOKEN_SECRET");

            var user = UserAsync.GetAuthenticatedUser().Result;

            System.Console.WriteLine(user);
            System.Console.ReadKey();
        }
        public async Task <IEnumerable <Entities.User> > GetFriendsAsync(string userId)
        {
            var users = await Auth.ExecuteOperationWithCredentials(
                this.credentials, () => UserAsync.GetFriends(long.Parse(userId)));

            var mapper = new UserMapper();

            return(users.Select(user => mapper.Map(user, new Entities.User())));
        }
        public virtual async Task <Entities.User> GetAsync(string userId)
        {
            var user = await Auth.ExecuteOperationWithCredentials(
                this.credentials, () => UserAsync.GetUserFromId(long.Parse(userId)));

            var mapper = new UserMapper();

            return(mapper.Map(user, new Entities.User()));
        }
        public async Task <IActionResult> GetUser(string screenName)
        {
            var user = await Auth.ExecuteOperationWithCredentials(creds, () =>
            {
                return(UserAsync.GetUserFromScreenName(screenName));
            });

            return(Ok(user));
        }
        private async Task <IEnumerable <ITweet> > GetPostsByUserTimeline(
            IUser author,
            int maximumResults)
        {
            Tweetinvi.Models.IUser user = await _executer
                                          .Execute(() => UserAsync.GetUserFromId(author.Id));

            return(await _executer
                   .Execute(() => user.GetUserTimelineAsync(maximumResults)));
        }
Beispiel #10
0
        protected override async void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);

            // Set our view from the "main" layout resource
            SetContentView(Resource.Layout.Main);

            // Get our button from the layout resource,
            // and attach an event to it
            Button button = FindViewById <Button>(Resource.Id.MyButton);

            Auth.SetUserCredentials("CONSUMER_KEY", "CONSUMER_SECRET", "ACCESS_TOKEN", "ACCESS_TOKEN_SECRET");

            var user = await UserAsync.GetAuthenticatedUser();

            button.Click += delegate { button.Text = string.Format("{0} clicked {1} times!", user, count++); };
        }
        public override async Task <GetTwitterUserResponse> GetTwitterUser(GetTwitterUserRequest request, ServerCallContext context)
        {
            GetTwitterUserResponse response = new GetTwitterUserResponse();

            response.User = new TwitterUser {
                Language = request.Language, VoiceName = request.VoiceName
            };

            IUser user = request.UserCase switch
            {
                GetTwitterUserRequest.UserOneofCase.Id => await UserAsync.GetUserFromId(request.Id),
                GetTwitterUserRequest.UserOneofCase.Handle => await UserAsync.GetUserFromScreenName(request.Handle),
                _ => null,
            };

            response.User.Id              = user.Id;
            response.User.Handle          = user.ScreenName;
            response.User.Name            = user.Name;
            response.User.ProfileImageUrl = user.ProfileImageUrlFullSize;

            return(response);
        }
 public Task <IUser> GetUserAsync(string name)
 => GetUserFromTwitter(() => UserAsync.GetUserFromScreenName(name));
Beispiel #13
0
        public async Task AlertUnsubscribedUser(long userId, string discordName)
        {
            var RelevantUser = await UserAsync.GetUserFromId(userId);

            await TweetAsync.PublishTweet($"@{RelevantUser.ScreenName}: {discordName} has requested that Switch screenshots from you are no longer PMed to them.");
        }
Beispiel #14
0
        public async Task <string> GetUsername(long userId)
        {
            var RelevantUser = await UserAsync.GetUserFromId(userId);

            return(RelevantUser.ScreenName);
        }
Beispiel #15
0
        public async Task SetUserConnected()
        {
            var user = await UserAsync.GetLoggedUser();

            UserLogged = AutoMapper.Mapper.Map <Models.TwitterUser> (user);
        }
        protected async Task <TrainSet> ScheduleProcessTwitter(TrainSet data)
        {
            var collection = await _twitterCollectionsStore.Get(data.SourceId);

            if (collection == null)
            {
                data.SetFailed("Can not find source data");
                return(data);
            }

            var sources = await _twitterSourcesStore.GetBy(x => x.CollectionId == collection.Id);

            if (sources == null || !sources.Any())
            {
                data.SetFailed("Can not find any twitter sources");
                return(data);
            }

            var user = await _userStore.FindByIdAsync(collection.UserId);

            if (user == null)
            {
                data.SetFailed("Can not find user data");
                return(data);
            }

            var userTwitter = await _userSocialsStore.GetTwitter(user.Id);

            if (userTwitter == null)
            {
                data.SetFailed("No twitter access token");
                return(data);
            }

            try
            {
                OAuthTwitter(userTwitter);
            }
            catch
            {
                data.SetFailed("Error with twitter connections");
                return(data);
            }

            // upload twitter data

            int min = data.MinCount;

            min = Math.Max(1, min);

            int max = data.MaxCount;

            max = Math.Max(100, max);
            max = Math.Min(10000, max);

            if (min > max)
            {
                var t = min;
                max = min;
                min = t;
            }

            int perSource = (int)Math.Ceiling((double)max / sources.Count);
            var entity    = new TrainSetModel {
            };

            var rawData = new StringBuilder();
            int total   = 0;

            var regex = new Regex("http[s]?://[A-Za-z0-9._-]*");

            foreach (var screen in sources)
            {
                long?lastId      = null;
                int  count       = 0;
                var  twetterUser = await UserAsync.GetUserFromId(screen.TwitterId);

                while (perSource > count)
                {
                    var @params = new UserTimelineParameters
                    {
                        MaximumNumberOfTweetsToRetrieve = 50,
                    };

                    if (lastId.HasValue)
                    {
                        @params.SinceId = lastId.Value;
                    }

                    var tweets = await TimelineAsync.GetUserTimeline(twetterUser, @params);

                    if (tweets == null || !tweets.Any())
                    {
                        break;
                    }

                    count += tweets.Count();
                    foreach (var t in tweets)
                    {
                        rawData.Append(regex.Replace(t.FullText, string.Empty));
                    }
                }

                total += count;
            }

            if (total < min)
            {
                data.SetFailed($"Not enough data avaliable. Avaliable : {total}. Minimum: {min}");
                return(data);
            }

            WordBag wb = WordBag.CreateToWords(rawData.ToString(), data.InputWordsCount + 1);

            _vReader.UploadBinary();

            List <Tuple <string[], string[]> > stringList = new List <Tuple <string[], string[]> >();
            List <Tuple <double[], double[]> > doubleList = new List <Tuple <double[], double[]> >();

            foreach (var s in wb.Read())
            {
                var vectorList = new List <double[]>();
                var wordList   = new List <string>();

                foreach (var ss in s)
                {
                    var word = _vReader.Vocab.GetRepresentationOrNullFor(ss);
                    if (word == null)
                    {
                        break;
                    }

                    vectorList.Add(ss.Select(x => (double)x).ToArray());
                    wordList.Add(ss);
                }

                if (vectorList.Count < s.Length)
                {
                    continue;
                }

                var tmpVector = new List <double>();
                foreach (var i in vectorList.Take(data.InputWordsCount))
                {
                    tmpVector.AddRange(i);
                }

                doubleList.Add(new Tuple <double[], double[]>(tmpVector.ToArray(), vectorList.Last().ToArray()));
                stringList.Add(new Tuple <string[], string[]>(wordList.Take(wordList.Count - 1).ToArray(), new string[1] {
                    wordList.Last()
                }));
            }

            entity.Data         = doubleList.ToArray();
            entity.StringSource = stringList.ToArray();

            string dataString = JsonConvert.SerializeObject(entity);

            await _storageBlobClient.SetContainer(CONTAINER_NAME, true);

            var storageKey = await _storageBlobClient.WriteText(dataString);

            if (string.IsNullOrWhiteSpace(storageKey))
            {
                data.SetFailed("Can not upload train set to storage");
                return(data);
            }

            data.StorageKey = storageKey;
            data.SetReady();

            data.ExamplesCount = entity.Data.Count();

            return(data);
        }
        public async Task OnGet([FromQuery(Name = "id")] string twitterId, [FromQuery] bool DoIt = false)
        {
            if (string.IsNullOrEmpty(twitterId))
            {
                Redirect("/Error");
            }

            var sw = new Stopwatch();

            var(consumerKey, consumerSecret, accessToken, accessTokenSecret) = await GetTwitterAuthKeys();

            ExceptionHandler.SwallowWebExceptions = false;

            Auth.SetUserCredentials(consumerKey, consumerSecret, accessToken, accessTokenSecret);

            LoggedInTwitterId = (await UserAsync.GetAuthenticatedUser()).ScreenName;
            TwitterId         = twitterId;
            ListName          = $"private_{twitterId}";

            // Ensure that we can get some information

            sw.Start();
            var usersFriends = await Tweetinvi.UserAsync.GetFriendIds(twitterId, 5000);

            sw.Stop();
            ListMemberCount = usersFriends.Count() + 1;
            _logger.LogInformation($"TweetInvi command ({sw.ElapsedMilliseconds}ms) UserAsync.GetFriendIds() for {{{twitterId}}} found {ListMemberCount} friends");
            var membersToAdd = usersFriends.Select(f => new UserIdentifier(f));
            var list         = await TwitterListAsync.GetExistingList(ListNameSlug, LoggedInTwitterId);

            if (list == null)
            {
                list = await TwitterListAsync.CreateList(
                    ListName,
                    PrivacyMode.Private,
                    $"The list of accounts that @{twitterId} follows as of {DateTime.UtcNow.ToLongDateString()}. Should have {membersToAdd.Count()} members.");

                _logger.LogInformation($"Created list {{{ListName}}}.");
            }
            else
            {
                TwitterListUpdateParameters updateParameter = new TwitterListUpdateParameters()
                {
                    // Name = ListName,
                    // PrivacyMode = PrivacyMode.Private,
                    Description = $"The list of accounts that @{twitterId} follows as of {DateTime.UtcNow.ToLongDateString()}. Should have {membersToAdd.Count()} members."
                };
                sw.Restart();
                var existingMembers = await list.GetMembersAsync(5000);

                sw.Stop();
                _logger.LogInformation($"TweetInvi command ({sw.ElapsedMilliseconds}ms) list.GetMembersAsync() for {{{list.Slug}}} found {existingMembers.Count()} members");
                membersToAdd = membersToAdd.Where(m => !existingMembers.Any(existing => m.Id == existing.Id));
                if (DoIt || !_env.IsDevelopment())
                {
                    var success = await list.UpdateAsync(updateParameter);

                    if (success)
                    {
                        _logger.LogInformation($"Updated description of {{{ListName}}}.");
                    }
                    else
                    {
                        _logger.LogError($"Updating description of {{{ListName}}} failed.");
                    }
                }
            }

            NoOfMembersToAdd = membersToAdd.Count();

            // Need to limit to 5000 accounts
            if (DoIt || !_env.IsDevelopment())
            {
                await list.AddMemberAsync(await UserAsync.GetUserFromScreenName(twitterId));

                sw.Restart();
                var result = await list.AddMultipleMembersAsync(membersToAdd);

                sw.Stop();
                ResponseString = result.ToString();
                if (result == MultiRequestsResult.Success)
                {
                    _logger.LogInformation($"TweetInvi command ({sw.ElapsedMilliseconds}ms) list.AddMultipleMembersAsync() for {{{list.Slug}}} adding {membersToAdd.Count()} members finished with result: {result}");
                }
                else
                {
                    _logger.LogError($"TweetInvi command ({sw.ElapsedMilliseconds}ms) list.AddMultipleMembersAsync() for {{{list.Slug}}} adding {membersToAdd.Count()} members finished with result: {result}");
                }
            }
            else
            {
                _logger.LogWarning($"DEV MODE: AddMultipleMembersToList: Didn't add {membersToAdd.Count()} to list {{{ListName}}}.");
                ResponseString = "Nothing added in Development Mode";
            }

            sw.Restart();
            NoOfActualMembers = (await list.GetMembersAsync(5000)).Count();
            sw.Stop();
            _logger.LogInformation($"TweetInvi command ({sw.ElapsedMilliseconds}ms) list.GetMembersAsync() for {{{list.Slug}}} found {NoOfActualMembers} members");

            var rateLimits = await RateLimitAsync.GetCurrentCredentialsRateLimits();
        }
 public Task <IUser> GetUserAsync(long userId)
 => GetUserFromTwitter(() => UserAsync.GetUserFromId(userId));
 public Task <IUser> GetIdentityAsync()
 => GetUserFromTwitter(async() => (Tweetinvi.Models.IUser) await UserAsync.GetAuthenticatedUser());