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 TwitterViewModel(ITwitterService twitterService)
{
_twitterService = twitterService;
_currentImageFromTweet = _defaultCurrentImageFromTweet;
_currentTwitterId = "RealTimeWWII";
UpdateTweets("RealTimeWWII");
}
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 ServiceHandler(ISettings settings, ITwitterService twitterService, ITweetMatcher tweetMatcher, ISandboxService sandboxService)
{
this.settings = settings;
this.twitterService = twitterService;
this.tweetMatcher = tweetMatcher;
this.sandboxService = sandboxService;
}
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();
}
