public OAuthAuthorizeService(IDbConnectionFactory factory, OAuthHandler oauthHandler, IAuthenticator auth)
: base()
{
this.connFactory = factory;
this.authenticator = auth;
this.oauthHandler = oauthHandler;
}
public NetflixHandler(string userToken, string userSecret, string userID)
{
this.Config = new NetflixConfig()
{
UserToken = (userToken ?? ""),
UserSecret = (userSecret ?? ""),
UserID = (userID ?? "")
};
var oauthConfig = new OAuthConfig()
{
OAuthConsumerKey = NetflixConfig.CONSUMER_KEY,
OAuthConsumerSecret = NetflixConfig.CONSUMER_SECRET,
OAuthToken = this.Config.UserToken,
OAuthTokenSecret = this.Config.UserSecret,
RequestTokenUri = new Uri(NetflixConfig.REQUEST_TOKEN_URL),
AccessTokenUri = new Uri(NetflixConfig.ACCESS_TOKEN_URL)
};
this.oauthHandler = new OAuthHandler(oauthConfig);
this.Users = new NetflixUserHandler(this);
this.Catalog = new NetflixCatalogHandler(this);
}
public void CreateFacebookEvent()
{
var e = new Event()
{
Description = "desc test",
Name = "name test",
StartDateTime = DateTime.UtcNow.AddDays(5),
EndDateTime = DateTime.UtcNow.AddDays(6),
Venue = new Venue()
{
StreetLine1 = "Univerisity St. 10",
StreetLine2 = string.Empty,
City = "Seattle",
State = "Washington",
Country = Country.US,
Lat = 1.123f,
Lon = 12.123f
}
};
Mock <IRepository> mockRepo = new Mock <IRepository>();
var oauth = new OAuthHandler();
oauth.Token = "";
//var fbAcct = new FacebookAccount(mockRepo.Object, oauth);
//fbAcct.CreateFacebookEvent(actv);
}
public SettingsViewModel(EventBus eventBus, OAuthHandler oAuthHandler)
{
this.eventBus = eventBus;
this.oAuthHandler = oAuthHandler;
DisplayName = "Settings";
AllMonitors = new ObservableCollection <string>();
}
/// <summary>
/// Register a unique schema for <c>OAuth</c> redirect handler. The caller needs to ensure that the schema is unique.
/// If the schema is already registered the function will return an error. The handler
/// will be called once the authorization procedure has been completed.
/// The caller should register two schema callbacks. The first will be for
/// authorization redirect and the second schema will in case the user cancels
/// the authentication.
/// </summary>
/// <param name="schema">A unique string that will match the redirect uri schema</param>
/// <param name="callback">MLDispatch <c>OAuth</c> callback function</param>
/// <returns>
/// MLResult.Result will be <c>MLResult.Code.Ok</c> if the new schema has been registered correctly.
/// MLResult.Result will be <c>MLResult.Code.PrivilegeDenied</c> if SecureBrowserWindow privilege is denied.
/// MLResult.Result will be <c>MLResult.Code.UnspecifiedFailure</c> if the operation failed with an unspecified error.
/// MLResult.Result will be <c>MLResult.Code.SchemaAlreadyRegistered</c> if the schema already is registered.
/// MLResult.Result will be <c>MLResult.Code.Dispatch*</c> if a dispatch specific error occurred.
/// </returns>
public static MLResult OAuthRegisterSchema(string schema, ref OAuthHandler callback)
{
try
{
NativeBindings.OAuthCallbacksNative newSchema = NativeBindings.OAuthCallbacksNative.Create();
newSchema.OnReplyComplete = OAuthOnReplyNative;
int newID = uniqueID + 1;
MLResult.Code resultCode = NativeBindings.MLDispatchOAuthRegisterSchemaEx(schema, ref newSchema, new IntPtr(newID));
if (MLResult.IsOK(resultCode))
{
OAuthPair newEntry = new OAuthPair(schema, callback);
oAuthCallbacks.Add(newID, newEntry);
uniqueID = newID;
}
return(MLResult.Create(resultCode));
}
catch (System.DllNotFoundException)
{
MLPluginLog.Error(DllNotFoundExceptionError);
return(MLResult.Create(MLResult.Code.UnspecifiedFailure, DllNotFoundExceptionError));
}
catch (System.EntryPointNotFoundException)
{
MLPluginLog.Error("MLDispatch API symbols not found");
return(MLResult.Create(MLResult.Code.UnspecifiedFailure, "MLDispatch API symbols not found"));
}
}
static async Task Main()
{
// listen for cancel events
RegisterCancels();
// listen for unhandled exceptions in the application
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
// set up logging
EnsureLogs();
Logger.LogInfo("Application is starting");
// load the configuration file into memory
await ReadConfiguration();
// validate the configuration; throws if an error is found
ValidateConfiguration();
// authenticate user
var oAuthHandler = new OAuthHandler(
Config.ClientId.Trim(),
Config.ClientToken.Trim(),
Config.RedirectUri.Trim()
);
Logger.LogInfo("Begin authentication...");
// get the access token for a user
var token = await oAuthHandler.AuthorizeOAuth();
if (token != null)
{
Logger.LogInfo("Twitch authentication finished successfully");
}
else
{
Logger.LogError("Error while authenticating with Twitch. The application will now exit.");
Environment.Exit(1);
return;
}
// start communicating with Twitch
using var twitchHandler = new TwitchHandler(
token,
Config.ClientId.Trim(),
Config.ClientToken.Trim(),
Config.OutputFile.Trim(),
Config.OutputFormat.Trim()
);
await twitchHandler.Init();
// wait for an exit event to continue
try
{
await ExitToken.Token;
}
catch { }
}
public DatabaseBackend(IDbConnectionFactory conn_factory, DbStorageFactory storage_factory, IAuthenticator auth,
OAuthHandler handler) : base(conn_factory)
{
oauthHandler = handler;
storageFactory = storage_factory;
// TODO move this into (Encrypted)DbStorageFactory implementation
CreateSchema(conn_factory);
}
private void WireupGenericTestClasses(Funq.Container container)
{
container.Register <IAuthenticator> (c => {
var factory = c.Resolve <IDbConnectionFactory> ();
var dbauth = new DbAuthenticator(factory);
//var dbauth = new DbTestAuthenticator ();
var test_user = new DBUser {
Username = RainyTestServer.TEST_USER,
IsActivated = true,
IsVerified = true
};
test_user.CreateCryptoFields(RainyTestServer.TEST_PASS);
// insert a dummy testuser
using (var db = factory.OpenDbConnection()) {
db.InsertParam <DBUser> (test_user);
}
return(dbauth);
});
container.Register <IAdminAuthenticator> (c => {
var admin_auth = new DummyAdminAuthenticator(ADMIN_TEST_PASS);
return((IAdminAuthenticator)admin_auth);
});
RegisterStorageFactory(container, false);
container.Register <IDataBackend> (c => {
var conn_factory = c.Resolve <IDbConnectionFactory> ();
var storage_factory = c.Resolve <DbStorageFactory> ();
var auth = c.Resolve <IAuthenticator> ();
var handler = c.Resolve <OAuthHandler> ();
return(new DatabaseBackend(conn_factory, storage_factory, auth, handler));
});
container.Register <OAuthHandler> (c => {
var auth = c.Resolve <IAuthenticator> ();
var factory = c.Resolve <IDbConnectionFactory> ();
// ITokenRepository<AccessToken> access_tokens = new SimpleTokenRepository<AccessToken> ();
// ITokenRepository<RequestToken> request_tokens = new SimpleTokenRepository<RequestToken> ();
ITokenRepository <AccessToken> access_tokens = new DbAccessTokenRepository <AccessToken> (factory);
ITokenRepository <RequestToken> request_tokens = new DbRequestTokenRepository <RequestToken> (factory);
ITokenStore token_store = new RainyTokenStore(access_tokens, request_tokens);
OAuthHandler handler = new OAuthHandler(auth, access_tokens, request_tokens, token_store);
return(handler);
});
var connFactory = container.Resolve <IDbConnectionFactory> ();
DatabaseBackend.CreateSchema(connFactory, true);
// HACK so the user is inserted when a fixture SetUp is run
container.Resolve <IAuthenticator> ();
}
private static Resources Authenticate()
{
string ODataEntityPath = ConnectionSettings.Default.UriString + "data";
Uri oDataUri = new Uri(ODataEntityPath, UriKind.Absolute);
var context = new Resources(oDataUri);
context.SendingRequest2 += new EventHandler <SendingRequest2EventArgs>(delegate(object sender, SendingRequest2EventArgs e)
{
var authenticationHeader = OAuthHandler.GetAuthenticationHeader(useWebAppAuthentication: true);
e.RequestMessage.SetHeader(OAuthHandler.OAuthHeader, authenticationHeader);
});
return(context);
}
// Use this for initialization
void Start()
{
//OAuth
StartCoroutine(OAuthHandler.GetAccessToken(userID =>
{
//string timerInfo = timerResult;
//Populate the Timer
//UnityEngine.Debug.Log(timerInfo);
}));
LoadTimer();
}
public FileSystemBackend(string data_path, IDbConnectionFactory factory, IAuthenticator auth, OAuthHandler handler, bool reset = false)
{
oauthHandler = handler;
// TODO move this into the oauth stuff
//DbConfig.CreateSchema ();
this.notesBasePath = Path.Combine(data_path, "notes");
if (!Directory.Exists(notesBasePath))
{
Directory.CreateDirectory(notesBasePath);
}
}
public void SetUp()
{
_tokenServiceMock.Setup(x => x.GetTokenAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult <Token>(
new Token()
{
AccessToken = "accessToken"
}));
_sut = new OAuthHandler(_tokenServiceMock.Object)
{
InnerHandler = new TestHandler()
{
InnerHandler = new HttpClientHandler()
}
};
}
public void OAuthSerializationTest()
{
string ckey = "this";
string csec = "is";
string akey = "a";
string asec = "test";
OAuthHandler oauth = new OAuthHandler( ckey, csec, akey, asec );
oauth.SaveAs( @"serialized.txt" );
OAuthHandler loaded = OAuthHandler.LoadFrom( @"serialized.txt" );
Assert.AreEqual( ckey, loaded.ConsumerKey );
Assert.AreEqual( csec, loaded.ConsumerSecret );
Assert.AreEqual( akey, loaded.AccessKey );
Assert.AreEqual( asec, loaded.AccessSecret );
}
private async Task <bool> EnableOauth2IdentityProvider(
AuthenticationProviderResponse authProvider,
HttpContext context)
{
var option = ExtractOAuthOptions(authProvider, _dataProtectionProvider);
if (option == null)
{
return(false);
}
var handler = new OAuthHandler <OAuthOptions>(new HttpClient());
await handler.InitializeAsync(option, context, _logger, UrlEncoder.Default);
return(await handler.HandleRequestAsync());
}
public void HomeTimeLineTest()
{
XmlDocument doc = new XmlDocument();
doc.Load( @"D:\Documents\Visual Studio 2010\F#\TwitterClient\oauthtoken.xml" );
XmlNode root = doc.SelectSingleNode( "/OAuthTokens" );
string ckey = root["ConsumerKey"].InnerText;
string csec = root["ConsumerSecret"].InnerText;
string akey = root["AccessKey"].InnerText;
string asec = root["AccessSecret"].InnerText;
OAuthHandler oauth = new OAuthHandler( ckey, csec, akey, asec );
Api api = new Api( oauth );
XmlNodeList result = api.HomeTimeLine();
}
public ActionResult About()
{
FacebookWebAuthorizer fwa = new FacebookWebAuthorizer(new PraLoupFacebookApplication(), HttpContext);
fwa.Permissions = new string[] { "publish_stream" };
fwa.ReturnUrlPath = HttpContext.Request.Url.ToString();
if (fwa.Authorize())
{
var oAuth = new OAuthHandler();
//Get the access token and secret.
oAuth.Token = FacebookWebContext.Current.AccessToken;
Friends f = new Friends(oAuth);
FriendsLists fl = new FriendsLists(oAuth);
}
return(View());
}
private string GetDeepLinkString()
{
Resources context = Authenticate();
string sessionUrl = "/api/services/DeepLinkServices/DeepLinkSevice/getDeepLink";
string GetUserSessionOperationPath = string.Format("{0}{1}", ConnectionSettings.Default.UriString.TrimEnd('/'), sessionUrl);
var request = WebRequest.Create(GetUserSessionOperationPath);
request.Headers[OAuthHandler.OAuthHeader] = OAuthHandler.GetAuthenticationHeader();
request.Method = "POST";
var requestContract = new
{
company = "usmf",
menuItem = "PurchTableListPage",
dataSource = "PurchTable",
field = "PurchId",
value = ImputOrderNumber
};
var requestContractString = JsonConvert.SerializeObject(requestContract);
using (var stream = request.GetRequestStream())
{
using (var writer = new StreamWriter(stream))
{
writer.Write(requestContractString);
}
}
using (var response = (HttpWebResponse)request.GetResponse())
{
using (Stream responseStream = response.GetResponseStream())
{
using (StreamReader streamReader = new StreamReader(responseStream))
{
return(streamReader.ReadToEnd().ToString());
}
}
}
}
public override void Init(params object[] param)
{
Debug.Log("TwitterConnector Initialization.");
DebugUtils.Assert(param[0] is string);
DebugUtils.Assert(param[1] is string);
oauth_handler_ = new OAuthHandler(param[0] as string, param[1] as string);
string oauth_token = EncryptedPlayerPrefs.GetString("oauth_token");
string oauth_token_secret = EncryptedPlayerPrefs.GetString("oauth_token_secret");
if (!string.IsNullOrEmpty(oauth_token) && !string.IsNullOrEmpty(oauth_token_secret))
{
oauth_handler_.AddParameter("oauth_token", oauth_token);
oauth_handler_.AddParameter("oauth_token_secret", oauth_token_secret);
my_info_.id = EncryptedPlayerPrefs.GetString("user_id");
my_info_.name = EncryptedPlayerPrefs.GetString("screen_name");
Debug.Log("Already logged in.");
OnEventNotify(SNResultCode.kLoggedIn);
}
}
public OAuthAccessTokenService(IDbConnectionFactory factory, OAuthHandler oauthHandler) : base()
{
this.oauthHandler = oauthHandler;
this.connFactory = connFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="OAuthPair" /> struct.
/// </summary>
/// /// <param name="schema">Schema to pair with a Callback.</param>
/// <param name="callback">Callback to pair with a Schema.</param>
public OAuthPair(string schema, OAuthHandler callback)
{
this.Schema = schema;
this.Callback = callback;
}
// This is the "Composition Root" in the IoC pattern that wires all
// our objects/implementations up, based on a given configuration.
// config sanity checks SHOULD NOT go here
private static void ComposeObjectGraph(Funq.Container container)
{
var config = Config.Global;
container.Register <SqliteConfig> (c => new SqliteConfig {
File = Path.Combine(config.DataPath, "rainy.db")
});
container.Register <PostgreConfig> (c => {
dynamic txt_conf = config.Postgre;
var psql_conf = new PostgreConfig();
if (!string.IsNullOrEmpty(txt_conf.Username))
{
psql_conf.Username = txt_conf.Username;
}
if (!string.IsNullOrEmpty(txt_conf.Password))
{
psql_conf.Password = txt_conf.Password;
}
if (!string.IsNullOrEmpty(txt_conf.Database))
{
psql_conf.Database = txt_conf.Database;
}
if (!string.IsNullOrEmpty(txt_conf.Host))
{
psql_conf.Host = txt_conf.Host;
}
if (txt_conf.Port > 0)
{
psql_conf.Port = (uint)txt_conf.Port;
}
return(psql_conf);
});
if (config.Backend == "xml")
{
// use username/password pairs from the config file
container.Register <IAuthenticator> (c => {
return(new ConfigFileAuthenticator(config.User));
});
// we store notes in XML files in the DataPath
container.Register <IDataBackend> (c => {
var auth = c.Resolve <IAuthenticator> ();
var factory = c.Resolve <IDbConnectionFactory> ();
var oauth_handler = c.Resolve <OAuthHandler> ();
return(new FileSystemBackend(config.DataPath, factory, auth, oauth_handler, false));
});
}
else
{
// database based backends
switch ((string)config.Backend)
{
case "sqlite":
container.Register <IDbConnectionFactory> (c => {
var conf = container.Resolve <SqliteConfig> ();
var connection_string = conf.ConnectionString;
var factory = new OrmLiteConnectionFactory(connection_string, SqliteDialect.Provider);
if (!File.Exists(conf.File))
{
DatabaseBackend.CreateSchema(factory);
}
return((IDbConnectionFactory)factory);
});
break;
case "postgre":
container.Register <IDbConnectionFactory> (c => {
var connection_string = container.Resolve <PostgreConfig> ().ConnectionString;
var factory = new OrmLiteConnectionFactory(connection_string, PostgreSqlDialect.Provider);
DatabaseBackend.CreateSchema(factory);
return(factory);
});
break;
}
container.Register <IAuthenticator> (c => {
var factory = c.Resolve <IDbConnectionFactory> ();
// var sfactory = new OrmLiteConnectionFactory ();
var dbauth = new DbAuthenticator(factory);
//var dbauth = new ConfigFileAuthenticator (Config.Global.Users);
// we have to make sure users from the config file exist with the configured password
// in the db
// TODO delete old users? or restrict to webinterface?
if (dbauth is ConfigFileAuthenticator)
{
foreach (dynamic user in Config.Global.Users)
{
string username = user.Username;
string password = user.Password;
using (var db = factory.OpenDbConnection()) {
var db_user = db.FirstOrDefault <DBUser> (u => u.Username == username);
if (db_user != null)
{
var need_update = db_user.UpdatePassword(password);
if (need_update)
{
db.UpdateOnly(new DBUser {
PasswordHash = db_user.PasswordHash
}, u => new { u.PasswordHash }, (DBUser p) => p.Username == username);
}
}
else
{
// create the user in the db
var new_user = new DBUser();
new_user.Username = username;
new_user.CreateCryptoFields(password);
new_user.UpdatePassword(password);
db.Insert <DBUser> (new_user);
}
}
}
}
return(dbauth);
});
//
container.Register <IAdminAuthenticator> (c => {
var auth = new ConfigFileAdminAuthenticator();
return(auth);
});
container.Register <OAuthHandler> (c => {
var auth = c.Resolve <IAuthenticator> ();
var factory = c.Resolve <IDbConnectionFactory> ();
// ITokenRepository<AccessToken> access_tokens = new SimpleTokenRepository<AccessToken> ();
// ITokenRepository<RequestToken> request_tokens = new SimpleTokenRepository<RequestToken> ();
ITokenRepository <AccessToken> access_tokens = new DbAccessTokenRepository <AccessToken> (factory);
ITokenRepository <RequestToken> request_tokens = new DbRequestTokenRepository <RequestToken> (factory);
ITokenStore token_store = new RainyTokenStore(access_tokens, request_tokens);
OAuthHandler handler = new OAuthHandler(auth, access_tokens, request_tokens, token_store);
return(handler);
});
container.Register <DbStorageFactory> (c => {
var conn_factory = c.Resolve <IDbConnectionFactory> ();
bool use_encryption = (bool)Config.Global.UseNoteEncryption;
var storage_factory = new DbStorageFactory(conn_factory, use_encryption, use_history: true);
return(storage_factory);
});
container.Register <IDataBackend> (c => {
var conn_factory = c.Resolve <IDbConnectionFactory> ();
var storage_factory = c.Resolve <DbStorageFactory> ();
var handler = c.Resolve <OAuthHandler> ();
var auth = c.Resolve <IAuthenticator> ();
return(new DatabaseBackend(conn_factory, storage_factory, auth, handler));
});
/* container.Register<OAuthHandler> (c => {
* var factory = c.Resolve<IDbConnectionFactory> ();
* var access_token_repo = new DbAccessTokenRepository<AccessToken> (factory);
* var request_token_repo = new SimpleTokenRepository<RequestToken> ();
* var auth = c.Resolve<IAuthenticator> ();
* var token_store = new Rainy.OAuth.SimpleStore.SimpleTokenStore (access_token_repo, request_token_repo);
*
* var handler = new OAuthHandler (auth, token_store);
* return handler;
* });
*/
if (config.Development == true)
{
AddDummyUserIfRequired(container);
}
}
}
private static async Task HandleCreatingTicket <TOAuthUser>(OAuthCreatingTicketContext context)
where TOAuthUser : class, IOAuthUser
=> await OAuthHandler <TOAuthUser, User, UserLogin, UserMetadata> .HandleCreatingTicket(context, GetClaims);
public OAuthStartupDialogViewModel(OAuthHandler oAuthHandler)
{
DisplayName = "RatTracker";
this.oAuthHandler = oAuthHandler;
}
public OAuthRequestTokenService(OAuthHandler oauthHandler) : base()
{
this.oauthHandler = oauthHandler;
}
public ApiService(OAuthHandler oauthHandler) : base()
{
this.oauthHandler = oauthHandler;
}
