public UsersController( ITwitterService twitterService, ITwitterUserService twitterUserService, IFavouriteUserService favouriteUserService, UserManager <User> userManager, IJsonProvider jsonProvider, IMappingProvider mapper ) { this.twitterService = twitterService ?? throw new ArgumentNullException(nameof(twitterService)); this.twitterUserService = twitterUserService ?? throw new ArgumentNullException(nameof(twitterUserService)); this.favouriteUserService = favouriteUserService ?? throw new ArgumentNullException(nameof(favouriteUserService)); this.userManager = userManager ?? throw new ArgumentNullException(nameof(userManager)); this.jsonProvider = jsonProvider ?? throw new ArgumentNullException(nameof(jsonProvider)); this.mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); }
public ConnectionViewViewModel(INavigationService navigation, ITwitterService twitterService) { this.navigation = navigation; this.twitterService = twitterService; Messenger.Default.Register <GenericMessage <String> >(this, ExternalErrors); ManageAppPropertiesLoad(); }
private static void RunSearch(ITwitterService service, string searchTerm, IBus bus, IDocumentSession documentSession, IList <string> excludedTerms) { var options = new TweetSharp.SearchOptions { Q = searchTerm, Lang = "en", Resulttype = TwitterSearchResultType.Mixed }; var results = service.Search(options); foreach (var result in results.Statuses) { var tweet = new Status { Id = Guid.NewGuid(), TwitterId = result.Id, User = result.User.ScreenName, UserId = result.User.Id, Content = result.Text, Created = result.CreatedDate, SearchTerm = searchTerm }; if (result.InReplyToStatusId.HasValue || documentSession.Query <Status>().Any(s => s.TwitterId == tweet.TwitterId) || excludedTerms.Any(t => result.Text.IndexOf(t, StringComparison.InvariantCultureIgnoreCase) > 0)) { return; } documentSession.Store(tweet); documentSession.SaveChanges(); bus.Send(tweet); } }
public AccountController( UserManager <User> userManager, SignInManager <User> signInManager, IEmailSender emailSender, ILogger <AccountController> logger, ITwitterService twitterService, IUserService userService, ITwitterAccountService twitterAccountService, ITweetService tweetService) { Guard.WhenArgument(userManager, "userManager").IsNull().Throw(); _userManager = userManager; Guard.WhenArgument(signInManager, "signInManager").IsNull().Throw(); _signInManager = signInManager; Guard.WhenArgument(emailSender, "emailSender").IsNull().Throw(); _emailSender = emailSender; Guard.WhenArgument(logger, "logger").IsNull().Throw(); _logger = logger; Guard.WhenArgument(twitterService, "twitterService").IsNull().Throw(); this.twitterService = twitterService; Guard.WhenArgument(userService, "userService").IsNull().Throw(); this.userService = userService; Guard.WhenArgument(twitterAccountService, "twitterAccountService").IsNull().Throw(); this.twitterAccountService = twitterAccountService; Guard.WhenArgument(tweetService, "tweetService").IsNull().Throw(); this.tweetService = tweetService; }
public Workflow(ILogger logger, ITwitterService twitterService, IFootballAPIClient footballAPI, IDatabaseOperations database, ITweetBuilder tweetBuilder, IInterestCalculator interestCalculator) { _logger = logger; _twitterService = twitterService; _footballAPI = footballAPI; _database = database; _tweetBuilder = tweetBuilder; _interestCalculator = interestCalculator; _getMatchScoreFromAPIStep = new GetMatchScoreFromAPI(_logger, _footballAPI); _getLastMatchCheckTimeStep = new GetLastMatchCheckTimeFromDatabase(_logger, _database); _buildMatchTweetStep = new BuildMatchTweet(_logger, _tweetBuilder); _getMatchesFromAPIStep = new GetMatchesFromAPI(_logger, _footballAPI); _getMatchesToSearchFromDatabaseStep = new GetMatchesToSearchFromDatabase(_logger, _database); _getMatchStatsFromAPIStep = new GetMatchStatsFromAPI(_logger, _footballAPI); _persistMatchesToDatabaseStep = new PersistMatchesToDatabase(_logger, _database); _processMatchStatsStep = new ProcessMatchStats(_logger, _interestCalculator); _sendMatchTweetStep = new SendMatchTweet(_logger, _twitterService); _updateMatchTwitterStatusStep = new UpdateMatchTwitterStatus(_logger, _database); }
public void Load(bool Old = false) { if (service == null) { service = ServiceDispatcher.GetDefaultService(); } if (Resource == null || service == null || requestsInProgress >= 1 || _rateResetTime > DateTime.Now) { if (LoadFinished != null) { LoadFinished(this, new EventArgs()); } return; } requestsInProgress++; if (Old) { LoadOld(lastId); } else { LoadNew(); } }
public PuzzlesController(IPuzzleService puzzleService, IAuthenticationService authenticationService, IAccountService accountService, ITwitterService twitterService) { _puzzleService = puzzleService; _authenticationService = authenticationService; _accountService = accountService; _twitterService = twitterService; }
public TwittootFacade(ITwitterService twitterService, IMastodonService mastodonService, ISyncAccountsRepository syncAccountsRepository, ProcessAccountSyncFactory processAccountSyncFactory) { _twitterService = twitterService; _mastodonService = mastodonService; _syncAccountsRepository = syncAccountsRepository; _processAccountSyncFactory = processAccountSyncFactory; }
public Connection() { ts = new TwitterService(); InitializeComponent(); this.Btn = ConnectionBtn; this.ConnectionBtn.Clicked += ConnectionBtn_Clicked; }
public TwitterViewModel(ITwitterService twitterService) { _twitterService = twitterService; _currentImageFromTweet = _defaultCurrentImageFromTweet; _currentTwitterId = "RealTimeWWII"; UpdateTweets("RealTimeWWII"); }
public HomeController(IUserService userService, ITwitterService twitterService, ITweetService tweetService) { this.userService = userService ?? throw new ArgumentNullException(nameof(userService)); this.twitterService = twitterService ?? throw new ArgumentNullException(nameof(twitterService)); this.tweetService = tweetService ?? throw new ArgumentNullException(nameof(tweetService)); }
public EmailService(IDataProvider dataProvider, IConfigService configService, IErrorLogService errorLogService, IFacebookService facebookService, ITwitterService twitterService) : base(dataProvider) { _configService = configService; _errorLogService = errorLogService; _facebookService = facebookService; _twitterService = twitterService; }
public LoginService(IFacebookService facebookService, ITwitterService twitterService, IAuthenticationManager authentication, UserManager <User> userManager) { UserManager = userManager; Authentication = authentication; TwitterService = twitterService; FacebookService = facebookService; }
public TweetsViewViewModel(ITwitterService twitterService) { Messenger.Default.Register <GenericMessage <int> >(this, PageLoaded); Messenger.Default.Register <GenericMessage <List <SearchListItem> > >(this, RequestedTweets); this.twitterService = twitterService; this.tweets = new ObservableCollection <Tweet>(); }
public TweetViewModel(ITwitterService twitterService = null) { _twitterService = twitterService ?? Locator.Current.GetService <ITwitterService>(); UpdateTweetCommand = ReactiveCommand.CreateFromObservable <long, ITweet>(x => _twitterService.UpdateTweet(x)); UpdateTweetCommand.Subscribe(ConfigureData); FavoriteCommand = ReactiveCommand.CreateFromTask(async() => { if (Tweet.Favorited) { await Tweet.UnFavoriteAsync(); } else { await Tweet.FavoriteAsync(); } Observable.Start(() => Tweet.Id).InvokeCommand(UpdateTweetCommand); return(Unit.Default); }); this.WhenAnyValue(x => x.Tweet).Where(x => x != null) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(ConfigureData); }
public MainPage() { this.twitterService = new TwitterService(); InitializeComponent(); this.TwitterConnect.Clicked += TwitterConnect_Clicked; this.LoadTweets(this.StacklayoutTweets); }
public MainPage() { InitializeComponent(); this.form.IsVisible = false; this.tweets.IsVisible = true; this.twitterService = new TwitterServiceImpl(); }
public ServiceHandler(ISettings settings, ITwitterService twitterService, ITweetMatcher tweetMatcher, ISandboxService sandboxService) { this.settings = settings; this.twitterService = twitterService; this.tweetMatcher = tweetMatcher; this.sandboxService = sandboxService; }
public ProcessAccountSynchronisation(SyncAccount syncAccount, ITwitterService twitterService, IMastodonService mastodonService, ISyncAccountsRepository syncAccountsRepository) { this._syncAccount = syncAccount; _twitterService = twitterService; _mastodonService = mastodonService; _syncAccountsRepository = syncAccountsRepository; }
public void Init() { var tweets = new ObservableCollection <Tweet>() { new Tweet { created_at = "1/1/2012", entities = new TwitterUserEntities { media = new List <TwitterUserMedia>() { new TwitterUserMedia { media_url = "http://www.google.com/google.jpg" }, }, }, text = "Tweet from RealTimeWWII", user = new TwitterUser { screen_name = "RealTimeWWII", name = "Real Tweets From WWII", profile_image_url = "http://www.twitter.com/twitter.jpg" }, } }; _mock = MockRepository.GenerateMock <ITwitterService>(); _mock.Stub(s => s.GetNextTwentyTweetsFromUserId("RealTimeWWII")).Return(tweets); _tvm = new TwitterViewModel(_mock); }
public TwitterBindingConfigProvider(INameResolver nameResolver, ILoggerFactory loggerFactory, ITwitterService twitterService) { this._nameResolver = nameResolver; this._loggerFactory = loggerFactory; this._twitterService = twitterService; }
public TwitterTestViewModel(ITwitterService service = null) { _service = service ?? Resolver.Resolve <ITwitterService>(); this.WhenActivated(registerDisposable => { var canLogoutOrGetProfile = _service.CurrentAccount.AsObservable().Select(account => null != account); var canAuthorize = _service .ServiceReadySub .AsObservable() .Select(authenticator => null != authenticator) .CombineLatest(canLogoutOrGetProfile, (arg1, arg2) => arg1 && !arg2); LogInCommand = ReactiveCommand.CreateAsyncObservable(canAuthorize, args => Observable.Start(() => _service.Authorize())); LogOutCommand = ReactiveCommand.CreateAsyncObservable(canLogoutOrGetProfile, args => Observable.Start(async() => await _service.Logout())); GetProfileCommand = ReactiveCommand.CreateAsyncObservable(canLogoutOrGetProfile, args => Observable.Start(() => { IsLoaderShowing = true; _service .GetUserData() .ObserveOnUI() .Catch(ex => { IsLoaderShowing = false; Error = ex.Message; }).SubscribeOnce(data => { UserData = data; IsLoaderShowing = false; }); })); }); }
public MainPage() { InitializeComponent(); this.btnConnexion.Clicked += BtnConnexion_Clicked; this.errorLabel.IsVisible = false; this.twitterService = new TwitterServiceImpl(); }
private static void Main(string[] args) { ServiceProvider serviceProvider = new ServiceCollection() .AddLogging(options => { options.AddConsole().SetMinimumLevel(LogLevel.Debug); }) .AddHttpClient() .AddSingleton <ITwitterClient, TwitterClient>() .AddSingleton <ITwitterService, TwitterService>() .AddSingleton <IHttpUtils, HttpUtils>() .BuildServiceProvider(); ILogger <Program> logger = serviceProvider.GetService <ILoggerFactory>() .CreateLogger <Program>(); logger.LogDebug("Starting application..."); //Do the work ITwitterService httpUtils = serviceProvider.GetService <ITwitterService>(); var result = httpUtils.GetTweets("fiho").GetAwaiter().GetResult(); foreach (var tweet in result) { Console.WriteLine(tweet.ToString()); Console.WriteLine("================================================================================================================="); } logger.LogDebug("The end..."); Console.ReadLine(); }
public JobOpportunityController( IJobOpportunityService jobOpportunityService, ITwitterService twitterService) { _jobOpportunityService = jobOpportunityService; _twitterService = twitterService; }
public TweetDetailViewModel(ITwitterService twitterService = null) { _twitterService = twitterService ?? Locator.Current.GetService <ITwitterService>(); FavoriteCommand = ReactiveCommand.CreateFromTask(async() => { if (Tweet.Favorited) { await Tweet.UnFavoriteAsync(); } else { await Tweet.FavoriteAsync(); } Favorited = Tweet.Favorited; FavoriteCount = Tweet.Favorited ? FavoriteCount = Tweet.FavoriteCount + 1 : FavoriteCount = Tweet.FavoriteCount; return(Unit.Default); }); this.WhenAnyValue(x => x.Tweet).Where(x => x != null) .ObserveOn(RxApp.MainThreadScheduler) .Subscribe(tweet => { Favorited = tweet.Favorited; FavoriteCount = tweet.FavoriteCount; }); }
public void Init() { var tweets = new ObservableCollection<Tweet>() { new Tweet { created_at = "1/1/2012", entities = new TwitterUserEntities { media = new List<TwitterUserMedia>() { new TwitterUserMedia { media_url = "http://www.google.com/google.jpg" }, }, }, text = "Tweet from RealTimeWWII", user = new TwitterUser { screen_name = "RealTimeWWII", name = "Real Tweets From WWII", profile_image_url = "http://www.twitter.com/twitter.jpg" }, } }; _mock = MockRepository.GenerateMock<ITwitterService>(); _mock.Stub(s => s.GetNextTwentyTweetsFromUserId("RealTimeWWII")).Return(tweets); _tvm = new TwitterViewModel(_mock); }
public TwitterStreamBackGroudService(ITwitterApiService twitterApiService, ITwitterService twitterService, ILogger logger) { _twitterApiService = twitterApiService; _twitterApiService.OnTweet += OnTweet; _twitterService = twitterService; _logger = logger; }
private void CreateButton_Click(object sender, System.Windows.RoutedEventArgs e) { ITwitterService srv = ServiceDispatcher.GetService(DataTransfer.CurrentAccount); TwitterListMode mode; if (PublicBtn.IsChecked == true) { mode = TwitterListMode.Public; } else { mode = TwitterListMode.Private; } Dispatcher.BeginInvoke(() => pBar.IsVisible = true); srv.CreateList(new CreateListOptions { ListOwner = DataTransfer.CurrentAccount.ScreenName, Name = ListName.Text, Description = ListDescp.Text, Mode = mode }, (list, response) => { if (response.StatusCode == HttpStatusCode.OK) { Dispatcher.BeginInvoke(() => { MessageBox.Show(Localization.Resources.ListCreated); NavigationService.GoBack(); }); } else { Dispatcher.BeginInvoke(() => MessageBox.Show(Localization.Resources.ErrorCreatingList)); } Dispatcher.BeginInvoke(() => pBar.IsVisible = false); }); }
public WidgetsTwitterController(ITwitterService twitterService, ICacheManager cacheManager) { if (twitterService == null) throw new ArgumentNullException("twitterService"); if (cacheManager == null) throw new ArgumentNullException("cacheManager"); _twitterService = twitterService; _cacheManager = cacheManager; }
public ToggleRetweetCommand( ISettings settings, ITwitterService twitterService, IMessageBoxService messageBoxService) { Settings = settings; TwitterService = twitterService; MessageBoxService = messageBoxService; }
public TweetLoader(TwitterResource resource, bool cached) : this() { Resource = resource; service = ServiceDispatcher.GetService(resource.User); conversationService = new ConversationService(resource.User); Cached = cached; }
public TwitterFeedController(ITwitterService twitterService, IAuthorizationManager <MvcAuthorizer> authorizationManager, IOptions <TwitterConfig> twitterConfig) { _authorizationManager = authorizationManager; _twitterService = twitterService; _twitterConfig = twitterConfig.Value; }
public ITwitterService GetTwitterService() { if (TwitterService == null) { TwitterService = new TwitterService(GetTokenService()); } return(TwitterService); }
public void SetUp() { _repository = MockRepository.GenerateStub<IRepository>(); _twitterService = MockRepository.GenerateStub<ITwitterService>(); _blogPostCommentService = new BlogPostCommentService(_repository, _twitterService); GivenBody = "body"; GivenUserSubscriberd = true; GivenUser = new User { DisplayName = "user" }; }
public HomeController(ITwitterService twitterService, IBlogService blogService) { this.twitterService = twitterService; this.blogService = blogService; organization = OrganizationRepository.GetDefaultOrganization(readOnly: true); Mapper.CreateMap<Organization, OrganizationDetailsModel>(); Mapper.CreateMap<OrganizationSetting, OrganizationSettingModel>(); Mapper.CreateMap<CauseTemplate, CauseTemplateDetailsModel>(); }
/// <summary> /// Initializes a new instance of the EventDetailViewModel class. /// </summary> /// <param name="navSrv">Navigation Service</param> /// <param name="twitterSrv">Twitter Service</param> /// <param name="myEventSrv">MyEvents Service</param> public EventDetailViewModel(INavigationService navSrv, ITwitterService twitterSrv, IMyEventsClient myEventSrv) { _navService = navSrv; _twitterService = twitterSrv; _myEventsService = myEventSrv; TwitterBtnContent = _loader.GetString("LogInTwitter"); InitializeCommands(); _myEventsService.SetAccessToken(UserCredentials.Current.CurrentUser.MyEventsToken); }
public FishController(IFishService fishService, ITwitterService twitterService, IFishPageViewModelFactory fishPageViewModelFactory, IFishEditPageViewModelFactory fishEditPageViewModelFactory, IFishRepository fishRepository, ISpeciesRepository speciesRepository, IPhotosRepository photosRepository, ILogger logger) { this.fishService = fishService; this.twitterService = twitterService; this.fishPageViewModelFactory = fishPageViewModelFactory; this.fishEditPageViewModelFactory = fishEditPageViewModelFactory; this.fishRepository = fishRepository; this.speciesRepository = speciesRepository; this.photosRepository = photosRepository; this.logger = logger; }
public HomeViewModel ( IRepository repository, ITimeService timeService, ITwitterService twitterService) { _repository = repository; _timeService = timeService; _twitterService = twitterService; CurrentSessions = new List<HomeCurrentSessionViewModel> (); Tweets = new List<TweetCellViewModel> (); }
void ListManager_Loaded(object sender, RoutedEventArgs e) { if (!NavigationContext.QueryString.TryGetValue("user", out _userName)) { NavigationService.GoBack(); return; } _srv = ServiceDispatcher.GetService(DataTransfer.CurrentAccount); LoadListsIn(); LoadUserLists(); }
public AuthenticationController(ICommandExecutor commandExecutor, IMicrosoftService microsoftService, IFacebookService facebookService, IGoogleService googleService, ITwitterService twitterService) : base(commandExecutor) { Guard.NotNull(commandExecutor, nameof(commandExecutor)); Guard.NotNull(microsoftService, nameof(microsoftService)); Guard.NotNull(facebookService, nameof(facebookService)); Guard.NotNull(googleService, nameof(googleService)); Guard.NotNull(twitterService, nameof(twitterService)); this._microsoftService = microsoftService; this._facebookService = facebookService; this._googleService = googleService; this._twitterService = twitterService; }
public TwitterAggregator(ITwitterService twitterService, IConfigProvider queryProvider) { if (twitterService == null) { throw new ArgumentNullException("twitterService"); } if (queryProvider == null) { throw new ArgumentNullException("queryProvider"); } this.twitterService = twitterService; this.queryProvider = queryProvider; }
public HomeController(IRepository repository, ICurrentUserService currentUser, ITwitterService twitterService) : base(repository, currentUser) { _twitterService = twitterService; }
public TweetsController(ITwitterService twitterService) { _twitterService = twitterService; Mapper.AddProfile<TweetsMappingProfile>(); }
public JobOpportunityController( ILocationService locationService, IJobOpportunityService jobOpportunityService, ITwitterService twitterService) { _locationService = locationService; _jobOpportunityService = jobOpportunityService; _twitterService = twitterService; }
public HomeController(IUnitOfWork unit, ITwitterService twitterService, IUserService userService) { _unit = unit; _twitterService = twitterService; _userService = userService; }
private void GetService() { if (User == null) _service = ServiceDispatcher.GetDefaultService(); else _service = ServiceDispatcher.GetService(User); }
public BlogPostCommentService(IRepository repository, ITwitterService twitterService) { _twitterService = twitterService; _repository = repository; }
public JobOpportunityController( IJobOpportunityService jobOpportunityService, ITwitterService twitterService, IJobOpportunityLikeService jobOpportunityLikeService) { _jobOpportunityService = jobOpportunityService; _twitterService = twitterService; _jobOpportunityLikeService = jobOpportunityLikeService; }
public ApiController(IMicroAggroService aggroService, ITwitterService twitterService, ITwitterBot twitterBot) { this.aggroService = aggroService; this.twitterService = twitterService; this.twitterBot = twitterBot; }
/// <summary> /// Eventhandler for Login /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Login_Click(object sender, RoutedEventArgs e) { try { NetworkCredential cred = new NetworkCredential(this.Username.Text, this.Password.Password); this._twitterService = new TwitterService(cred); this.Login.Visibility = Visibility.Hidden; this.ReloadTweets(); this.TweetsList.Visibility = Visibility.Visible; this.Writer.Visibility = Visibility.Visible; } catch (AuthenticationException) { this.HandleAuthenticationException(); } }
public void SetUp() { _sut = new TwitterService(); _jobOpportunityService = Substitute.For<IJobOpportunityService>(); _jobOpportunityController = new JobOpportunityController(_jobOpportunityService, _sut); }
public BibleTweetRetrievalService(ITwitterService TwitterService, INHibernateSessionProvider SessionProvider) { _TwitterService = TwitterService; _SessionProvider = SessionProvider; }
public DataController(ITwitterService twitterService) { _twitterService = twitterService; }
public TwitterFeedService(ITwitterService twitterService) { _twitterService = twitterService; }
public void Load(bool Old = false) { if (service == null) service = ServiceDispatcher.GetDefaultService(); if (Resource == null || service == null || requestsInProgress >= 2 || _rateResetTime > DateTime.Now) { if (LoadFinished != null) LoadFinished(this, new EventArgs()); return; } requestsInProgress++; if (Old) LoadOld(lastId); else LoadNew(); }
public HomeViewModel () : base () { _twitterService = IocContainer.GetContainer ().Resolve<ITwitterService> (); _twitterHelper = IocContainer.GetContainer ().Resolve<ITwitterHelper> (); _facebookService = IocContainer.GetContainer ().Resolve<IFacebookService> (); _facebookHelper = IocContainer.GetContainer ().Resolve<IFacebookHelper> (); _logger.Track(Analytics.HOME_PAGE_VIEWED.ToString()); }
public TwitterServiceTests() { _sut = new TwitterService(); }