public virtual ActionResult LoadFiles(int id, ProviderType type)
{
var toRet = new List<ImageJson>();
//to recover files state in case of error
var filesFromCache = _ObjectStore.Get<PictureDataContainer>(PictureData.GetKey(type));
if (filesFromCache == null)
{
var provider = GetProvider(type, id);
if (provider == null)
return Json(toRet, "text/html");
filesFromCache = new PictureDataContainer(provider);
}
var urlHelper = new UrlHelper(ControllerContext.RequestContext);
var folder = PictureData.GetFolder(type);
foreach (var file in filesFromCache.Files)
{
var url = ControllerHelpers.GetUserImagePath(file.FileName, true, folder);
var deleteUrl = urlHelper.Action(MVC.UploadImage.DeleteImage(file.FileName));
toRet.Add(new ImageJson
{
name = file.FileName,
delete_url = deleteUrl,
thumbnail_url = url,
url = url,
is_default = file.IsDefault ? "true" : null,
is_logo = file.IsLogo ? "true" : null
});
}
return Json(toRet, "text/html");
}
internal override SqlExpression VisitBinaryOperator(SqlBinary bo)
{
//
// Special case to allow DateTime CLR type to be passed as a paramater where
// a SQL type TIME is expected. We do this only for the equality/inequality
// comparisons.
//
switch(bo.NodeType)
{
case SqlNodeType.EQ:
case SqlNodeType.EQ2V:
case SqlNodeType.NE:
case SqlNodeType.NE2V:
{
SqlDbType leftSqlDbType = ((SqlType)(bo.Left.SqlType)).SqlDbType;
SqlDbType rightSqlDbType = ((SqlType)(bo.Right.SqlType)).SqlDbType;
if(leftSqlDbType == rightSqlDbType)
break;
bool isLeftColRef = bo.Left is SqlColumnRef;
bool isRightColRef = bo.Right is SqlColumnRef;
if(isLeftColRef == isRightColRef)
break;
if(isLeftColRef && leftSqlDbType == SqlDbType.Time && bo.Right.ClrType == typeof(DateTime))
this.timeProviderType = bo.Left.SqlType;
else if(isRightColRef && rightSqlDbType == SqlDbType.Time && bo.Left.ClrType == typeof(DateTime))
this.timeProviderType = bo.Left.SqlType;
break;
}
}
base.VisitBinaryOperator(bo);
return bo;
}
internal CryptoServiceProviderHash(
String provider,
ProviderType providerType,
AlgorithmId algorithm)
: base(provider, providerType, algorithm)
{
}
internal SqlBinary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression left, SqlExpression right, MethodInfo method)
: base(nt, clrType, sqlType, right.SourceExpression) {
switch (nt) {
case SqlNodeType.Add:
case SqlNodeType.Sub:
case SqlNodeType.Mul:
case SqlNodeType.Div:
case SqlNodeType.Mod:
case SqlNodeType.BitAnd:
case SqlNodeType.BitOr:
case SqlNodeType.BitXor:
case SqlNodeType.And:
case SqlNodeType.Or:
case SqlNodeType.GE:
case SqlNodeType.GT:
case SqlNodeType.LE:
case SqlNodeType.LT:
case SqlNodeType.EQ:
case SqlNodeType.NE:
case SqlNodeType.EQ2V:
case SqlNodeType.NE2V:
case SqlNodeType.Concat:
case SqlNodeType.Coalesce:
break;
default:
throw Error.UnexpectedNode(nt);
}
this.Left = left;
this.Right = right;
this.method = method;
}
public CryptoServiceProviderHmac(
String provider,
ProviderType providerType,
AlgorithmId algorithm)
: base(provider, providerType, algorithm)
{
}
internal static extern int LogonUser(
string lpszUsername,
string lpszDomain,
string lpszPassword,
LogonType dwLogonType,
ProviderType dwLogonProvider,
out IntPtr phToken);
public void RegisterProvider(ProviderType providerType, string clientID, string clientSecret, string scope = null, NameValueCollection additionalParameters = null)
{
Provider provider = null;
switch (providerType)
{
case ProviderType.Google:
provider = new GoogleProvider(clientID, clientSecret, scope, additionalParameters);
break;
case ProviderType.Live:
provider = new LiveProvider(clientID, clientSecret, scope, additionalParameters);
break;
case ProviderType.Facebook:
provider = new FacebookProvider(clientID, clientSecret, scope, additionalParameters);
break;
case ProviderType.LinkedIn:
provider = new LinkedInProvider(clientID, clientSecret, scope, additionalParameters);
break;
}
if (provider == null)
{
throw new ArgumentException("Invalid provider type");
}
providers[providerType] = provider;
}
internal SqlUnary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression expr, MethodInfo method, Expression sourceExpression)
: base(nt, clrType, sqlType, sourceExpression) {
switch (nt) {
case SqlNodeType.Not:
case SqlNodeType.Not2V:
case SqlNodeType.Negate:
case SqlNodeType.BitNot:
case SqlNodeType.IsNull:
case SqlNodeType.IsNotNull:
case SqlNodeType.Count:
case SqlNodeType.LongCount:
case SqlNodeType.Max:
case SqlNodeType.Min:
case SqlNodeType.Sum:
case SqlNodeType.Avg:
case SqlNodeType.Stddev:
case SqlNodeType.Convert:
case SqlNodeType.ValueOf:
case SqlNodeType.Treat:
case SqlNodeType.OuterJoinedValue:
case SqlNodeType.ClrLength:
break;
default:
throw Error.UnexpectedNode(nt);
}
this.Operand = expr;
this.method = method;
}
internal SqlTable(MetaTable table, MetaType rowType, ProviderType sqlRowType, Expression sourceExpression)
: base(SqlNodeType.Table, sourceExpression) {
this.table = table;
this.rowType = rowType;
this.sqlRowType = sqlRowType;
this.columns = new List<SqlColumn>();
}
/// <summary>
/// initialization casting for InitializeDataAccess()
/// </summary>
/// <param name="type"></param>
/// <param name="ConnectionString"></param>
/// <param name="Query"></param>
private void castProvider(ProviderType type, string ConnectionString, string Query = null)
{
switch (type)
{
case ProviderType.Oledb:
conn = new OleDbConnection(ConnectionString);
cmd = new OleDbCommand(Query, (OleDbConnection)conn);
da = new OleDbDataAdapter();
break;
case ProviderType.Odbc:
conn = new OdbcConnection(ConnectionString);
cmd = new OdbcCommand(Query, (OdbcConnection)conn);
da = new OdbcDataAdapter();
break;
case ProviderType.SqlClient:
conn = new SqlConnection(ConnectionString);
cmd = new SqlCommand(Query, (SqlConnection)conn);
da = new SqlDataAdapter();
break;
//case ProviderType.OracleClient:
// conn = new OracleConnection(ConnectionString);
// cmd = new OracleCommand(Query,(OracleConnection)conn);
// break;
}
}
public static BaseProvider GetProvider(ProviderType type)
{
switch (type)
{
case ProviderType.Hulu:
return new HuluProvider();
case ProviderType.Instagram:
return new InstagramProvider();
case ProviderType.Polleverywhere:
return new PolleverywhereProvider();
case ProviderType.Polldaddy:
return new PolldaddyProvider();
case ProviderType.Scribd:
return new ScribdProvider();
case ProviderType.Slideshare:
return new SlideshareProvider();
case ProviderType.Smugmug:
return new SmugmugProvider();
case ProviderType.Soundcloud:
return new SoundcloudProvider();
case ProviderType.Spotify:
return new SpotifyProvider();
case ProviderType.Vimeo:
return new VimeoProvider();
case ProviderType.Youtube:
return new YoutubeProvider();
default:
throw new UnknownProviderException();
}
}
private bool BothTypesAreStrings(ProviderType oldSqlType, ProviderType newSqlType)
{
bool result = oldSqlType.IsSameTypeFamily(sql.TypeProvider.From(typeof(string)))
&& newSqlType.IsSameTypeFamily(sql.TypeProvider.From(typeof(string)));
return result;
}
internal SqlGrouping(Type clrType, ProviderType sqlType, SqlExpression key, SqlExpression group, Expression sourceExpression)
: base(SqlNodeType.Grouping, clrType, sqlType, sourceExpression) {
if (key == null) throw Error.ArgumentNull("key");
if (group == null) throw Error.ArgumentNull("group");
this.key = key;
this.group = group;
}
internal SqlRowNumber(Type clrType, ProviderType sqlType, List<SqlOrderExpression> orderByList, Expression sourceExpression)
: base(SqlNodeType.RowNumber, clrType, sqlType, sourceExpression) {
if (orderByList == null) {
throw Error.ArgumentNull("orderByList");
}
this.orderBy = orderByList;
}
public Mapping(ProviderType providerType, int subscriberId, string name, string description, string domain)
{
ProviderId = providerType;
SubscriberId = subscriberId;
Name = name;
Description = description;
Domain = domain;
}
public DbConnector(ProviderType _eProviderType, string _strConnectionString) {
_providerType = _eProviderType;
_connectionString = _strConnectionString;
_connected = false;
_connector = null;
Open();
}
internal SqlParameter(Type clrType, ProviderType sqlType, string name, Expression sourceExpression)
: base(SqlNodeType.Parameter, clrType, sqlType, sourceExpression) {
if (name == null)
throw Error.ArgumentNull("name");
if (typeof(Type).IsAssignableFrom(clrType))
throw Error.ArgumentWrongValue("clrType");
this.name = name;
this.direction = System.Data.ParameterDirection.Input;
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="AbstractCryptoServiceProviderHash"/> class.
/// </summary>
///
/// <param name="provider">
/// The name of the Capi provider.
/// </param>
///
/// <param name="providerType">
/// Type of the provider.
/// </param>
///
/// <param name="algorithm">
/// The hash algorithm.
/// </param>
internal AbstractCryptoServiceProviderHash(
String provider,
ProviderType providerType,
AlgorithmId algorithm)
{
this._algorithmId = algorithm;
this._provider = provider;
this._providerType = providerType;
}
public CryptoServiceProviderHmac(
byte[] key,
String provider,
ProviderType providerType,
AlgorithmId algorithm)
: this(provider, providerType, algorithm)
{
_key = key;
}
public List<Provider> GetProvidersByType(ProviderType providerType, int takeMax)
{
using (var connection = DbContextFactory.CreateConnection())
{
return connection
.Query<Provider>("Provider_GetLatestByType", new { ProviderType = providerType.ToString(), Max = takeMax }, commandType: CommandType.StoredProcedure)
.ToList();
}
}
internal Provider GetProvider(ProviderType providerType)
{
var provider = providers[providerType];
if (provider == null)
{
throw new ArgumentException("Invalid provider type");
}
return provider;
}
/// <summary>
/// Creates an instance of Schema
/// </summary>
/// <param name="dataProvider">The provider of the schema</param>
/// <param name="connectString">The connection string for the provider</param>
public Schema( ProviderType dataProvider, string connectString )
{
m_con = SchemaFactory.GetConnection( dataProvider, connectString );
m_adap = SchemaFactory.CreateDataAdapter( dataProvider );
m_com = SchemaFactory.CreateCommand( ProviderType.SqlServer );
m_com.Connection = m_con;
m_provider = dataProvider;
m_dataset = new DataSet( m_con.Database );
m_name = m_con.Database;
}
internal SqlLike(Type clrType, ProviderType sqlType, SqlExpression expr, SqlExpression pattern, SqlExpression escape, Expression source)
: base(SqlNodeType.Like, clrType, sqlType, source) {
if (expr == null)
throw Error.ArgumentNull("expr");
if (pattern == null)
throw Error.ArgumentNull("pattern");
this.Expression = expr;
this.Pattern = pattern;
this.Escape = escape;
}
internal static void GetConnectionInfo(string databaseName, out string connectionString, out ProviderType providerType)
{
if (!s_ConnStrMaps.ContainsKey(databaseName))
{
throw new ApplicationException("Can't find the info of database '" + databaseName + "'. It hasn't been configurated.");
}
ConnStrSetting conn = s_ConnStrMaps[databaseName];
connectionString = conn.ConnectionString;
providerType = conn.ProviderType;
}
internal SqlMethodCall(Type clrType, ProviderType sqlType, MethodInfo method, SqlExpression obj, IEnumerable<SqlExpression> args, Expression sourceExpression)
: base(SqlNodeType.MethodCall, clrType, sqlType, sourceExpression) {
if (method == null)
throw Error.ArgumentNull("method");
this.method = method;
this.Object = obj;
this.arguments = new List<SqlExpression>();
if (args != null)
this.arguments.AddRange(args);
}
public ISocialNetworkNotifier GetNotifier(ProviderType identityType)
{
switch (identityType)
{
case ProviderType.Facebook:
return new FacebookNotifier(_settings);
}
return null;
}
internal SqlDiscriminatedType(ProviderType sqlType, SqlExpression discriminator, MetaType targetType, Expression sourceExpression)
: base(SqlNodeType.DiscriminatedType,
typeof(Type),
sourceExpression) {
if (discriminator == null)
throw Error.ArgumentNull("discriminator");
this.discriminator = discriminator;
this.targetType = targetType;
this.sqlType = sqlType;
}
public static ProviderKey For(this ProviderConfiguration section, ProviderType providerEnumKey)
{
var provider = section.Providers[providerEnumKey];
if (provider == null)
{
throw new KeyNotFoundException(string.Format("There is no configuration for {0}", providerEnumKey));
}
return provider;
}
private bool OldWillFitInNew(ProviderType oldSqlType, ProviderType newSqlType)
{
bool result = newSqlType.IsLargeType // we can fit into a large type
|| !newSqlType.HasSizeOrIsLarge // if the type is not large, and doesn't have a size specified, assume OK
|| (!oldSqlType.IsLargeType // else, if the old type isn't large
&& oldSqlType.HasSizeOrIsLarge // and both old ..
&& newSqlType.HasSizeOrIsLarge // .. and new sizes are specified
&& newSqlType.Size >= oldSqlType.Size); // and if the new size is larger or equal to the old, then OK
return result;
}
internal SqlLink(object id, MetaType rowType, Type clrType, ProviderType sqlType, SqlExpression expression, MetaDataMember member, IEnumerable<SqlExpression> keyExpressions, SqlExpression expansion, Expression sourceExpression)
: base(SqlNodeType.Link, clrType, sqlType, sourceExpression) {
this.id = id;
this.rowType = rowType;
this.expansion = expansion;
this.expression = expression;
this.member = member;
this.keyExpressions = new List<SqlExpression>();
if (keyExpressions != null)
this.keyExpressions.AddRange(keyExpressions);
}
/// <summary>
/// Obtains the available providers by type for scope.
/// </summary>
/// <param name="scopeId">Scope used to make the request.</param>
/// <param name="providerType">Provider type.</param>
/// <returns>List of providers</returns>
public virtual async Task <IList <Provider> > GetProviders(string scopeId, ProviderType providerType)
{
if (scopeId == null)
{
throw new ArgumentNullException(nameof(scopeId));
}
var cacheKey = BuildProvidersCacheKey(scopeId, providerType);
var request = new GetProvidersRequest
{
ScopeId = scopeId,
ProviderType = providerType,
};
var paymentProviders = await CacheProvider.GetOrAddAsync(cacheKey, () => OvertureClient.SendAsync(request)).ConfigureAwait(false);
return(paymentProviders.Providers);
}
/// <summary>
/// Remove any unsafe characters based on the ProviderType. To prevent any form of malicious injection
/// </summary>
/// <param name="str"></param>
/// <param name="providerType"></param>
/// <returns>A safe string</returns>
public static string ToSafeString(this String str, ProviderType providerType)
{
if (!string.IsNullOrEmpty(str))
{
switch (providerType)
{
case ProviderType.QueryString:
return(Regex.Replace(str, "[^A-Za-z0-9_-]", "")); // only allow alpha-numeric and _ -
case ProviderType.Referrer:
return(Regex.Replace(str, "[^A-Za-z0-9._-]", "")); // only allow alpha-numeric and . _ -
default:
break;
}
}
return(str);
}
public async Task Get_ValidRequest_RendersExpectedOutput(ProviderType providerType)
{
// Arrange
var providerId = await TestData.CreateProvider(
providerType : providerType,
marketingInformation : "Current overview");
await User.AsHelpdesk();
// Act
var response = await HttpClient.GetAsync($"/providers/info?providerId={providerId}");
// Assert
response.EnsureSuccessStatusCode();
var doc = await response.GetDocument();
Assert.Equal("Current overview", doc.GetElementById("MarketingInformation").As <IHtmlTextAreaElement>().InnerHtml);
}
private void CheckProvider()
{
ProviderType type = ProviderType.SQLServer2005 | ProviderType.SQLServer2012;
string providerName = this.ProviderName;
if (providerName == DefaultProviderName)
{
this.Type = type;
return;
}
DbDriver driver = GlobalConfig.GetDriver(ProviderType.None, providerName);
if (driver != null)
{
this.Type = driver.Type;
return;
}
throw new ArgumentNullException("DbDriver", string.Format("[{0}]--没有找到对应的数据驱动", providerName));
}
public SessionStateConfig()
: base()
{
typeName = "MySqlSessionStateStoreProvider";
sectionName = "sessionState";
Configuration machineConfig = ConfigurationManager.OpenMachineConfiguration();
MembershipSection section = (MembershipSection)machineConfig.SectionGroups["system.web"].Sections["membership"];
foreach (ProviderSettings p in section.Providers)
{
if (p.Type.Contains("MySql"))
{
ProviderType = p.Type;
}
}
ProviderType = ProviderType.Replace("MySql.Web.Security.MySQLMembershipProvider",
"MySql.Web.SessionState.MySqlSessionStateStore");
}
internal SqlColumn(Type clrType, ProviderType sqlType, string name, MetaDataMember member, SqlExpression expr, Expression sourceExpression)
: base(SqlNodeType.Column, clrType, sourceExpression)
{
if (typeof(Type).IsAssignableFrom(clrType))
{
throw Error.ArgumentWrongValue("clrType");
}
this.Name = name;
this.member = member;
this.Expression = expr;
this.Ordinal = -1;
if (sqlType == null)
{
throw Error.ArgumentNull("sqlType");
}
this.sqlType = sqlType;
//[JA] - removed so we can support spatial types
//System.Diagnostics.Debug.Assert(sqlType.CanBeColumn);
}
public static SqlBase NewDB(ProviderType providerType, String connectionString)
{
SqlBase sb = null;
switch (providerType)
{
case ProviderType.MsSql: sb = new MsSql(connectionString); break;
case ProviderType.OleDb: sb = new OleDb(connectionString); break;
case ProviderType.Odbc: sb = new Odbc(connectionString); break;
case ProviderType.Oracle: sb = new Oracle(connectionString); break;
case ProviderType.MySql: sb = new MySql(connectionString); break;
}
sb.DSS = MyDss;
return(sb);
}
/// <summary>
/// Get connection string, depending on providerType (and will call the good get connectionstring method)
/// </summary>
public static string GetConnectionString(ProviderType providerType, string dbName)
{
Console.WriteLine($"Get connection for provider {providerType} and database name {dbName}");
switch (providerType)
{
case ProviderType.Sql:
return(Setup.GetSqlDatabaseConnectionString(dbName));
case ProviderType.MySql:
return(Setup.GetMySqlDatabaseConnectionString(dbName));
case ProviderType.Sqlite:
return(GetSqliteDatabaseConnectionString(dbName));
}
// default
return(GetSqliteDatabaseConnectionString(dbName));
}
private string GetFactoryName(ProviderType providerType)
{
string factoryName = "System.Data.SqlClient.SqlClientFactory";
switch (providerType)
{
case ProviderType.DB2:
factoryName = "IBM.Data.DB2.DB2Factory";
break;
case ProviderType.Oracle:
factoryName = "Oracle.DataAccess.Client.OracleClientFactory";
break;
case ProviderType.MySql:
factoryName = "MySql.Data.MySqlClient.MySqlClientFactory";
break;
case ProviderType.SQLite:
factoryName = "Devart.Data.SQLite.SQLiteProviderFactory";
break;
case ProviderType.OleDb:
factoryName = "System.Data.OleDb.OleDbFactory";
break;
case ProviderType.Odbc:
factoryName = "System.Data.Odbc.OdbcFactory";
break;
case ProviderType.SqlServer:
factoryName = "System.Data.SqlClient.SqlClientFactory";
break;
case ProviderType.MsOracle:
factoryName = "System.Data.OracleClient.OracleClientFactory";
break;
default: break;
}
return(factoryName);
}
internal override SqlExpression VisitBinaryOperator(SqlBinary bo)
{
//
// Special case to allow DateTime CLR type to be passed as a paramater where
// a SQL type TIME is expected. We do this only for the equality/inequality
// comparisons.
//
switch (bo.NodeType)
{
case SqlNodeType.EQ:
case SqlNodeType.EQ2V:
case SqlNodeType.NE:
case SqlNodeType.NE2V:
{
SqlDbType leftSqlDbType = ((SqlType)(bo.Left.SqlType)).SqlDbType;
SqlDbType rightSqlDbType = ((SqlType)(bo.Right.SqlType)).SqlDbType;
if (leftSqlDbType == rightSqlDbType)
{
break;
}
bool isLeftColRef = bo.Left is SqlColumnRef;
bool isRightColRef = bo.Right is SqlColumnRef;
if (isLeftColRef == isRightColRef)
{
break;
}
if (isLeftColRef && leftSqlDbType == SqlDbType.Time && bo.Right.ClrType == typeof(DateTime))
{
this.timeProviderType = bo.Left.SqlType;
}
else if (isRightColRef && rightSqlDbType == SqlDbType.Time && bo.Left.ClrType == typeof(DateTime))
{
this.timeProviderType = bo.Left.SqlType;
}
break;
}
}
base.VisitBinaryOperator(bo);
return(bo);
}
public string GetLink(ProviderType providerType, string redirectUrl, string state)
{
switch (providerType)
{
case ProviderType.Facebook:
return(GetLink(providerType, redirectUrl, state, _popIdentityConfig.FacebookAppID));
case ProviderType.Google:
return(GetLink(providerType, redirectUrl, state, _popIdentityConfig.GoogleClientID));
case ProviderType.Microsoft:
return(GetLink(providerType, redirectUrl, state, _popIdentityConfig.MicrosoftApplicationID));
case ProviderType.OAuth2:
throw new ArgumentException("OAuth2 links have to be specified manually.");
default:
throw new ArgumentException($"No link generator has been defined for {nameof(ProviderType)} \"{providerType}.\"");
}
}
public static Gost_28147_89_SymmetricAlgorithm CreateFromSessionKey(ProviderType providerType, byte[] sessionKey)
{
if (sessionKey == null)
{
throw ExceptionUtility.ArgumentNull(nameof(sessionKey));
}
if (sessionKey.Length != 32)
{
throw ExceptionUtility.Argument(nameof(sessionKey), Resources.InvalidHashSize, 32);
}
var providerHandle = CryptoApiHelper.GetProviderHandle(providerType);
var randomNumberGenerator = CryptoApiHelper.GetRandomNumberGenerator(providerType);
using (var keyHandle = CryptoApiHelper.ImportBulkSessionKey(providerType, providerHandle, sessionKey, randomNumberGenerator))
{
return(new Gost_28147_89_SymmetricAlgorithm(providerType, providerHandle, keyHandle));
}
}
public static bool HasProvider(ProviderType provider)
{
var fileName = string.Empty;
switch (provider)
{
case ProviderType.SQLServer:
fileName = Path.Combine(Application.StartupPath, @"SqlProviders\SQLServerProvider.dll");
break;
case ProviderType.SQLite:
fileName = Path.Combine(Application.StartupPath, @"SqlProviders\SqLiteProvider.dll");
break;
default:
break;
}
return(File.Exists(fileName));
}
public IUserManager Create(ProviderType type, string connectionString = null)
{
IProvider provider;
switch (type)
{
case ProviderType.Database:
provider = new DatabaseProvider(new DbContextOptionsBuilder <DatabaseProvider>().UseSqlServer(connectionString).Options);
break;
case ProviderType.InMemory:
provider = new InMemoryProvider();
break;
default:
throw new ArgumentException("no such provider type supported");
}
return(new UserManager(provider));
}
internal override ProviderType GetBestLargeType(ProviderType type)
{
SqlType sqlType = (SqlType)type;
switch (sqlType.SqlDbType)
{
case SqlDbType.NChar:
case SqlDbType.NVarChar:
return(SqlTypeSystem.Create(SqlDbType.NText));
case SqlDbType.Char:
case SqlDbType.VarChar:
return(SqlTypeSystem.Create(SqlDbType.Text));
case SqlDbType.Binary:
case SqlDbType.VarBinary:
return(SqlTypeSystem.Create(SqlDbType.Image));
}
return(type);
}
public static SafeProvHandleImpl GetProviderHandle(ProviderType providerType)
{
if (!_providerHandles.ContainsKey(providerType))
{
lock (ProviderHandleSync)
{
if (!_providerHandles.ContainsKey(providerType))
{
var providerParams = new CspParameters(providerType.ToInt());
var providerHandle = AcquireProvider(providerParams);
Thread.MemoryBarrier();
_providerHandles.Add(providerType, providerHandle);
}
}
}
return(_providerHandles[providerType]);
}
public static SafeKeyHandleImpl GenerateDhEphemeralKey(ProviderType providerType, SafeProvHandleImpl providerHandle, int algId, string digestParamSet, string publicKeyParamSet)
{
var keyHandle = SafeKeyHandleImpl.InvalidHandle;
var dwFlags = MapCspKeyFlags(CspProviderFlags.NoFlags) | Constants.CRYPT_PREGEN;
if (!CryptoApi.CryptGenKey(providerHandle, (uint)algId, dwFlags, ref keyHandle))
{
throw CreateWin32Error();
}
if (!providerType.IsVipNet())
{
SetKeyParameterString(keyHandle, Constants.KP_HASHOID, digestParamSet);
}
SetKeyParameterString(keyHandle, Constants.KP_DHOID, publicKeyParamSet);
SetKeyParameter(keyHandle, Constants.KP_X, null);
return(keyHandle);
}
public static RNGCryptoServiceProvider GetRandomNumberGenerator(ProviderType providerType)
{
if (!_randomNumberGenerators.ContainsKey(providerType))
{
lock (RandomNumberGeneratorSync)
{
if (!_randomNumberGenerators.ContainsKey(providerType))
{
var providerParams = new CspParameters(providerType.ToInt());
var randomNumberGenerator = new RNGCryptoServiceProvider(providerParams);
Thread.MemoryBarrier();
_randomNumberGenerators.Add(providerType, randomNumberGenerator);
}
}
}
return(_randomNumberGenerators[providerType]);
}
/// <summary>
/// Drop a database, depending the Provider type
/// </summary>
public static void DropDatabase(ProviderType providerType, string dbName)
{
switch (providerType)
{
case ProviderType.Sql:
DropSqlDatabase(dbName);
break;
case ProviderType.MySql:
DropMySqlDatabase(dbName);
break;
case ProviderType.Sqlite:
DropSqliteDatabase(dbName);
break;
}
// default
DropSqlDatabase(dbName);
}
public async Task FillAsync(ProviderType providerType, Func <IDbConnection> getConnection, string connectionName)
{
try
{
if (Analyzers.ContainsKey(providerType))
{
_providerType = providerType;
_getConnection = getConnection;
_aliasManager.ConnectionName = connectionName;
await RefreshAsync();
}
IsSchemaSupported = Analyzers.ContainsKey(providerType);
SchemaInspected?.Invoke(this, new EventArgs());
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
/// <summary>
/// Create a database, depending the Provider type
/// </summary>
public static void CreateDatabase(ProviderType providerType, string dbName, bool recreateDb = true)
{
switch (providerType)
{
case ProviderType.Sql:
CreateSqlServerDatabase(dbName, recreateDb);
break;
case ProviderType.SqlAzure:
CreateSqlServerDatabase(dbName, recreateDb);
break;
case ProviderType.MySql:
CreateMySqlDatabase(dbName, recreateDb);
break;
}
// default
CreateSqlServerDatabase(dbName, recreateDb);
}
public async Task <int> AddAsync(string accountId, string name, string code, ProviderType provider, string connectionString)
{
if (await _repository.ExistsCodeAsync(code))
{
throw new BusiException("编码已存在");
}
var model = new TDatabase
{
Id = IdentityHelper.Guid32,
AccountId = accountId,
Name = name,
Code = code,
Provider = (byte)provider,
ConnectionString = connectionString,
CreateTime = Clock.Now,
Status = (byte)CommonStatus.Normal
};
return(await _repository.InsertAsync(model));
}
protected virtual ProviderArguments GetProviderArguments()
{
string targetName = Arguments.Contains("name")
? Arguments["name"]
: (
Arguments.Contains($"{ProviderType.ToLowerInvariant()}Name")
? Arguments[$"{ProviderType.ToLowerInvariant()}Name"]
: (
GetTypeNameArgument(ProviderType.ToLowerInvariant(), $"Please enter the name of the {ProviderType.ToLowerInvariant()}")
??
GetArgument(ProviderType.ToLowerInvariant(), $"Please enter the name of the {ProviderType.ToLowerInvariant()}")
)
);
return(new ProviderArguments()
{
ProviderType = ProviderType,
ProviderContextTarget = targetName,
});
}
internal static bool hasPrecision(ProviderType providerType)
{
switch (providerType)
{
case ProviderType.BigInt: // BigInt
case ProviderType.Integer: // integer
case ProviderType.SmallInt: // smallint
case ProviderType.TinyInt: // tinyint
case ProviderType.Double: // float8
case ProviderType.Real: // real
case ProviderType.DateTime: // date
case ProviderType.IngresDate: // ingresdate
case ProviderType.Interval: // interval
case ProviderType.IntervalYearToMonth: // interval YM
case ProviderType.IntervalDayToSecond: // interval DS
case ProviderType.Decimal: // decimal
return(true);
}
return(false);
}
public override CoreProvider CreateProvider(ProviderType providerType, string dbName)
{
var cs = HelperDatabase.GetConnectionString(providerType, dbName);
switch (providerType)
{
case ProviderType.MySql:
return(new MySqlSyncProvider(cs));
case ProviderType.MariaDB:
return(new MariaDBSyncProvider(cs));
case ProviderType.Sqlite:
return(new SqliteSyncProvider(cs));
case ProviderType.Sql:
default:
return(new SqlSyncChangeTrackingProvider(cs));
}
}
public static IExportProvider GetProvider(
ProviderType type,
Route route,
AirportManager airports)
{
switch (type)
{
case ProviderType.Pmdg:
return(new PmdgProvider(route, airports));
case ProviderType.Fsx:
return(new FsxProvider(route, airports));
case ProviderType.Fs9:
return(new Fs9Provider(route, airports));
default:
throw new ArgumentException();
}
}
public T CreateOrchestrator <T>(ProviderType providerType, string dbName, bool useChangeTracking = false) where T : IOrchestrator
{
// Get connection string
var cs = HelperDatabase.GetConnectionString(providerType, dbName);
IOrchestrator orchestrator = null;
if (typeof(T) == typeof(RemoteOrchestrator))
{
orchestrator = new RemoteOrchestrator();
}
else if (typeof(T) == typeof(LocalOrchestrator))
{
orchestrator = new LocalOrchestrator();
}
else if (typeof(T) == typeof(WebServerOrchestrator))
{
orchestrator = new WebServerOrchestrator();
}
if (orchestrator == null)
{
throw new Exception("Orchestrator does not exists");
}
switch (providerType)
{
case ProviderType.Sql:
orchestrator.Provider = useChangeTracking ? new SqlSyncChangeTrackingProvider(cs) : new SqlSyncProvider(cs);
break;
case ProviderType.MySql:
orchestrator.Provider = new MySqlSyncProvider(cs);
break;
case ProviderType.Sqlite:
orchestrator.Provider = new SqliteSyncProvider(cs);
break;
}
return((T)orchestrator);
}
public static BaseProvider GetProvider(ProviderType type)
{
switch (type)
{
case ProviderType.Hulu:
return(new HuluProvider());
case ProviderType.Instagram:
return(new InstagramProvider());
case ProviderType.Polleverywhere:
return(new PolleverywhereProvider());
case ProviderType.Polldaddy:
return(new PolldaddyProvider());
case ProviderType.Scribd:
return(new ScribdProvider());
case ProviderType.Slideshare:
return(new SlideshareProvider());
case ProviderType.Smugmug:
return(new SmugmugProvider());
case ProviderType.Soundcloud:
return(new SoundcloudProvider());
case ProviderType.Spotify:
return(new SpotifyProvider());
case ProviderType.Vimeo:
return(new VimeoProvider());
case ProviderType.Youtube:
return(new YoutubeProvider());
default:
throw new UnknownProviderException();
}
}
private bool TrySearchCache(ProviderType providerType, string query, out SearchResponse searchResponse)
{
searchResponse = default;
if (!_memoryCache.TryGetValue(providerType, out ICollection <SearchResponse> searchResponses))
{
return(false);
}
foreach (var response in searchResponses)
{
if (response.Query.IsFuzzyMatch(query))
{
searchResponse = response;
return(true);
}
var sum = response.Tracks.Sum(info => {
if (info.Url.IsFuzzyMatch(query))
{
return(1);
}
if (info.Title.IsFuzzyMatch(query))
{
return(1);
}
return($"{info.Author} {info.Title}".IsFuzzyMatch(query) ? 1 : 0);
});
if (sum / response.Tracks.Count <= 85)
{
continue;
}
searchResponse = response;
return(true);
}
return(false);
}
internal DialogResult AddNewProvider(ProviderType type, bool showInitialDialog)
{
DialogResult res = DialogResult.Cancel;
CallButler.Manager.Plugin.CallButlerManagementProviderPlugin providerPlugin = null;
/*if (showInitialDialog)
* {
* InitialProviderDialog dlg = new InitialProviderDialog();
* if (dlg.ShowDialog(this) == DialogResult.OK)
* {
* type = dlg.ProviderType;
* }
* }*/
/*switch (type)
* {
* case ProviderType.CallButler:
* // Get our default CallButler provider plugin
* providerPlugin = (CallButler.Manager.Plugin.CallButlerManagementProviderPlugin)PluginManager.GetPluginFromID(new Guid(Properties.Settings.Default.PreferredVoIPProviderPluginID));
* break;*/
//case ProviderType.Other:
providerPlugin = (CallButler.Manager.Plugin.CallButlerManagementProviderPlugin)PluginManager.GetPluginFromID(new Guid(Properties.Settings.Default.DefaultVoIPProviderPluginID));
//break;
//}
if (providerPlugin != null)
{
CallButler.Manager.Plugin.ProviderData providerData = providerPlugin.AddNewProvider();
if (providerData != null)
{
CallButlerDataset.ProvidersRow provider = CreateProviderRow(providerData, providerPlugin.ServicePluginID.ToString());
callButlerDataset.Providers.AddProvidersRow(provider);
SaveProviderRow(provider);
res = DialogResult.OK;
}
}
return(res);
}
