public Storage(StorageType type) : base()
{
localFolder = ApplicationData.Current.LocalFolder;
path = type == StorageType.SECURE ? MPIN_STORAGE : USER_STORAGE;
this.Data = string.Empty;
}
/// <summary>
/// Gets total number of images in a presentation from a 3rd party storage
/// </summary>
/// <param name="storageType"></param>
/// <param name="storageName">Name of the storage</param>
/// <param name="folderName">In case of Amazon S3 storage the folder's path starts with Amazon S3 Bucket name.</param>
/// <returns>Total number of images</returns>
public int GetImageCount(StorageType storageType, string storageName, string folderName)
{
//build URI to get image count
StringBuilder strURI = new StringBuilder(Product.BaseProductUri + "/slides/" + FileName
+ "/images" + (string.IsNullOrEmpty(folderName) ? "" : "?folder=" + folderName));
switch (storageType)
{
case StorageType.AmazonS3:
strURI.Append("&storage=" + storageName);
break;
}
string signedURI = Utils.Sign(strURI.ToString());
Stream responseStream = Utils.ProcessCommand(signedURI, "GET");
StreamReader reader = new StreamReader(responseStream);
string strJSON = reader.ReadToEnd();
//Parse the json string to JObject
JObject parsedJSON = JObject.Parse(strJSON);
//Deserializes the JSON to a object.
ImagesResponse imagesResponse = JsonConvert.DeserializeObject<ImagesResponse>(parsedJSON.ToString());
return imagesResponse.Images.List.Count;
}
internal int SetBytes(long fieldOffset, byte[] buffer, int bufferOffset, int length)
{
int dstOffset = (int) fieldOffset;
if (this.IsNull || (StorageType.ByteArray != this._type))
{
if (dstOffset != 0)
{
throw ADP.ArgumentOutOfRange("fieldOffset");
}
this._object = new byte[length];
this._type = StorageType.ByteArray;
this._isNull = false;
this.BytesLength = length;
}
else
{
if (dstOffset > this.BytesLength)
{
throw ADP.ArgumentOutOfRange("fieldOffset");
}
if ((dstOffset + length) > this.BytesLength)
{
int num2 = ((byte[]) this._object).Length;
if ((dstOffset + length) > num2)
{
byte[] dst = new byte[Math.Max((int) (dstOffset + length), (int) (2 * num2))];
Buffer.BlockCopy((byte[]) this._object, 0, dst, 0, (int) this.BytesLength);
this._object = dst;
}
this.BytesLength = dstOffset + length;
}
}
Buffer.BlockCopy(buffer, bufferOffset, (byte[]) this._object, dstOffset, length);
return length;
}
internal DataExpression(DataTable table, string expression, Type type)
{
this.dependency = DataTable.zeroColumns;
ExpressionParser parser = new ExpressionParser(table);
parser.LoadExpression(expression);
this.originalExpression = expression;
this.expr = null;
if (expression != null)
{
this._storageType = DataStorage.GetStorageType(type);
if (this._storageType == StorageType.BigInteger)
{
throw ExprException.UnsupportedDataType(type);
}
this._dataType = type;
this.expr = parser.Parse();
this.parsed = true;
if ((this.expr != null) && (table != null))
{
this.Bind(table);
}
else
{
this.bound = false;
}
}
}
internal static bool IsSigned(StorageType type) {
return(type == StorageType.Int16 ||
type == StorageType.Int32 ||
type == StorageType.Int64 ||
type == StorageType.SByte ||
IsFloat(type));
}
public Storage LoadStorage(Player player, StorageType type)
{
string SQL = "SELECT * FROM `inventory` WHERE "
+ "`playerid` = ?pid AND `storagetype` = ?type";
MySqlCommand cmd = new MySqlCommand(SQL, InventoryDAOConnection);
cmd.Parameters.AddWithValue("?pid", player.Id);
cmd.Parameters.AddWithValue("?type", type.ToString());
MySqlDataReader LoadStorageReader = cmd.ExecuteReader();
var storage = new Storage { StorageType = StorageType.Inventory };
if (LoadStorageReader.HasRows)
{
while (LoadStorageReader.Read())
{
if (LoadStorageReader.GetInt32(2) != 20000000)
{
StorageItem item = new StorageItem()
{
ItemId = LoadStorageReader.GetInt32(2),
Amount = LoadStorageReader.GetInt32(3),
Color = LoadStorageReader.GetInt32(4),
};
storage.Items.Add(LoadStorageReader.GetInt32(5), item);
}
else
{
storage.Money = LoadStorageReader.GetInt32(3);
}
}
}
LoadStorageReader.Close();
return storage;
}
public async Task<AccountConfiguration> CreateOrUpdateAccount(StorageType type)
{
var newAccount = await _storageService.CreateAccount(type);
if (newAccount == null) return null;
var existingAccount = _configService.Accounts.SingleOrDefault(_ => _.Type == newAccount.Type && _.Id == newAccount.Id);
if (existingAccount == null) // New Account
{
// ensure account's name is unique
var i = 1;
var name = newAccount.Name;
while (
_configService.Accounts.Any(
_ => _.Type == newAccount.Type && _.Name.Equals(newAccount.Name, StringComparison.InvariantCultureIgnoreCase)))
{
i++;
newAccount.Name = string.Format("{0} ({1})", name, i);
}
_configService.Accounts.Add(newAccount);
return newAccount;
}
MessageService.ShowInfo("This account already exists.\r\nUpdating account data only.");
//existingAccount.Name = newAccount.Name;
existingAccount.Secret = newAccount.Secret;
return existingAccount;
}
public ClientStorageMoveSlotPacket(long sourceSlot, long destSlot, StorageType storageType)
: this()
{
SourceSlot = sourceSlot;
DestSlot = destSlot;
StorageType = storageType;
}
internal InventoryPage(InventoryType type, StorageType storage, byte size, Item bag = null)
{
_type = type;
_storage = storage;
Size = size;
Bag = bag;
}
internal DataExpression(DataTable table, string expression, Type type)
{
ExpressionParser parser = new ExpressionParser(table);
parser.LoadExpression(expression);
_originalExpression = expression;
_expr = null;
if (expression != null)
{
_storageType = DataStorage.GetStorageType(type);
if (_storageType == StorageType.BigInteger)
{
throw ExprException.UnsupportedDataType(type);
}
_dataType = type;
_expr = parser.Parse();
_parsed = true;
if (_expr != null && table != null)
{
Bind(table);
}
else
{
_bound = false;
}
}
}
public StorageTypeInfo (StorageType storage_type, string name, string description)
{
Type = storage_type;
Name = name;
Description = description;
}
public bool AddItem(Player player, StorageType type, KeyValuePair<int, StorageItem> KeyVP)
{
string SQL = "INSERT INTO `inventory` "
+ "(`accountname`, `playerid`, `itemid`, `amount`, `color`, `slot`, `storagetype`) "
+ "VALUES(?accountname, ?pid, ?itemid, ?count, ?color, ?slot, ?type);";
MySqlCommand cmd = new MySqlCommand(SQL, InventoryDAOConnection);
cmd.Parameters.AddWithValue("?accountname", player.AccountName);
cmd.Parameters.AddWithValue("?pid", player.pid);
cmd.Parameters.AddWithValue("?itemid", KeyVP.Value.ItemId);
cmd.Parameters.AddWithValue("?count", KeyVP.Value.Count);
cmd.Parameters.AddWithValue("?color", KeyVP.Value.Color);
cmd.Parameters.AddWithValue("?slot", KeyVP.Key);
cmd.Parameters.AddWithValue("?type", type.ToString());
try
{
cmd.ExecuteNonQuery();
return true;
}
catch (Exception e)
{
Log.ErrorException("DAO: ADD ITEM ERROR!", e);
}
return false;
}
private SqlBuffer(SqlBuffer value)
{
this._isNull = value._isNull;
this._type = value._type;
this._value = value._value;
this._object = value._object;
}
internal static bool IsFloat(StorageType type)
{
if ((type != StorageType.Single) && (type != StorageType.Double))
{
return (type == StorageType.Decimal);
}
return true;
}
internal static bool IsIntegerSql(StorageType type)
{
if (((((type != StorageType.Int16) && (type != StorageType.Int32)) && ((type != StorageType.Int64) && (type != StorageType.UInt16))) && (((type != StorageType.UInt32) && (type != StorageType.UInt64)) && ((type != StorageType.SByte) && (type != StorageType.Byte)))) && (((type != StorageType.SqlInt64) && (type != StorageType.SqlInt32)) && (type != StorageType.SqlInt16)))
{
return (type == StorageType.SqlByte);
}
return true;
}
internal static bool IsNumericSql(StorageType type)
{
if (!IsFloatSql(type))
{
return IsIntegerSql(type);
}
return true;
}
/// <summary>
/// Creates a storage of specified type using metadata information of enumeration value.
/// </summary>
/// <param name="st">Type of storage to create.</param>
/// <param name="storageStr">Connection string or file path for data storage.</param>
/// <returns>Newly created storage.</returns>
public static AbstractResultStorage CreateStorage(StorageType st, string storageStr)
{
Type[] patametersType = { typeof(String) };
object[] invokeParameters = { storageStr };
StorageTypeInfo[] info = (StorageTypeInfo[])st.GetType().GetField(st.ToString()).GetCustomAttributes(typeof(StorageTypeInfo), false);
Type t = Type.GetType(info[0].Implementation, true);
return (AbstractResultStorage)t.GetConstructor(patametersType).Invoke(invokeParameters);
}
internal static bool IsFloatSql(StorageType type)
{
if ((((type != StorageType.Single) && (type != StorageType.Double)) && ((type != StorageType.Decimal) && (type != StorageType.SqlDouble))) && ((type != StorageType.SqlDecimal) && (type != StorageType.SqlMoney)))
{
return (type == StorageType.SqlSingle);
}
return true;
}
public StorageEntry(List<PetBrokerEntry> list, int funds)
{
m_Funds = funds;
m_StorageType = StorageType.Pet;
m_Expires = DateTime.UtcNow + TimeSpan.FromDays(7);
foreach (PetBrokerEntry entry in list)
m_Creatures.Add(entry.Pet);
}
public StorageDescriptor(StorageType type, string friendlyName, string scheme, Func<AccountConfiguration, IStorageProvider> providerFactory, Func<IStorageConfigurator> configuratorFactory, Image smallImage)
{
Type = type;
FriendlyName = friendlyName;
Scheme = scheme;
ProviderFactory = providerFactory;
ConfiguratorFactory = configuratorFactory;
SmallImage = smallImage;
}
public static string BuildUriString(StorageType type, string accountName, string path)
{
if (accountName == null) throw new ArgumentNullException("accountName");
if (path == null) throw new ArgumentNullException("path");
var scheme = StorageRegistry.Descriptors.First(_ => _.Type == type).Scheme;
return string.Format("{0}:///{1}/{2}", scheme, accountName, path);
}
// Checks if a data set exists at the given path.
// Storage type is used to correctly interpret the given path.
public static bool ExistsImpl(String path, StorageType storageType)
{
if (storageType==StorageType.STORAGE_APPRESOURCE && QCARRuntimeUtilities.IsPlayMode())
{
path = "Assets/StreamingAssets/" + path;
}
return (QCARWrapper.Instance.DataSetExists(path, (int)storageType) == 1);
}
public IConfigLoaderProduct InitializeConfigurationLoader(StorageType type, ConfigManager manager)
{
switch (type)
{
case StorageType.Db: { return new DbConfigLoaderProduct(manager); }
case StorageType.Xml: { return new XmlConfigLoaderProduct(manager); }
default: throw new ConfigurationComponentException(this, -1, "Unable to determine where the configuration data should be loaded from?");
}
}
protected override void TryPublish(
Type messageType, TopicId topicId, object message, StorageType storageType,
bool waitForPublishConfirmation, TimeSpan publishConfirmationTimeout,
Dictionary<string, string> headers, TimeSpan expiration)
{
InSingleProcessMemoryAuthorizer.Verify(AuthorizedMessageOperation.Publish, messageType, message, headers);
base.TryPublish(messageType, topicId, message, storageType, waitForPublishConfirmation,
publishConfirmationTimeout, headers, expiration);
}
internal static bool IsInteger(StorageType type) {
return(type == StorageType.Int16 ||
type == StorageType.Int32 ||
type == StorageType.Int64 ||
type == StorageType.UInt16 ||
type == StorageType.UInt32 ||
type == StorageType.UInt64 ||
type == StorageType.SByte ||
type == StorageType.Byte);
}
public async Task<AccountConfiguration> CreateAccount(StorageType type)
{
var descriptor = StorageRegistry.Descriptors.FirstOrDefault(_ => _.Type == type);
if (descriptor == null)
throw new NotImplementedException(string.Format("A provider for type '{0}' is not implemented.", type));
var configurator = descriptor.ConfiguratorFactory();
var account = await configurator.CreateAccount();
return account;
}
private void ConvertXmlStringToByteArray()
{
string s = (string) this._object;
byte[] bytes = new byte[2 + Encoding.Unicode.GetByteCount(s)];
bytes[0] = 0xff;
bytes[1] = 0xfe;
Encoding.Unicode.GetBytes(s, 0, s.Length, bytes, 2);
this._object = bytes;
this._value._int64 = bytes.Length;
this._type = StorageType.ByteArray;
}
internal Bag(StorageType bagType, Item bag, byte size)
: base(InventoryType.Bag, bagType, size, bag)
{
Debug.Requires(bag != null);
Debug.Requires(size % 5 == 0);
Debug.Requires(bagType == StorageType.Backpack ||
bagType == StorageType.BeltPouch ||
bagType == StorageType.Bag1 ||
bagType == StorageType.Bag2 ||
bagType == StorageType.EquipmentPack);
}
public StorageEntry(List<CommodityBrokerEntry> list, int funds)
{
m_Funds = funds;
m_StorageType = StorageType.Commodity;
foreach (CommodityBrokerEntry entry in list)
{
if(entry.Stock > 0)
m_CommodityTypes[entry.CommodityType] = entry.Stock;
}
m_Expires = DateTime.UtcNow + TimeSpan.FromDays(7);
}
private void ApplyStorageTypeSetting( )
{
if ( _settings.PasswordsAreExternal )
{
StorageType = StorageType.External;
_storage.PasswordRepository.PasswordData = ExternalPasswordData( );
}
else
{
StorageType = StorageType.Internal;
_storage.PasswordRepository.PasswordData = InternalPasswordData( );
}
}
public StorageWrapperTypeAttribute(StorageType type)
{
Type = type;
}
public StorageFolderFactory(StorageType storageType, string filePath, string commonFolder)
{
_storageType = storageType;
_filePath = filePath;
_commonFolder = commonFolder;
}
/// <summary> Constructor. </summary>
/// <remarks> Sander.struijk, 25.04.2014. </remarks>
/// <param name="type"> The type. </param>
public IsoStorage(StorageType type)
{
StorageType = type;
}
public ReadStorageItemsJob(BaseDatabase database, StorageType storageType, string storageOwnerId, Action <List <CharacterItem> > onFinished = null) : base(database, onFinished)
{
this.storageType = storageType;
this.storageOwnerId = storageOwnerId;
}
internal static extern ErrorCode PackageManagerRequestMove(SafePackageManagerRequestHandle requestHandle, string name, StorageType moveToStorageType);
private static Parameter GetStringValueFromElementBase(Element element, string propertyName, bool allowUnset, out string propertyValue)
{
propertyValue = string.Empty;
if (element == null)
{
return(null);
}
if (String.IsNullOrEmpty(propertyName))
{
return(null);
}
ElementId elementId = element.Id;
Parameter parameter = GetParameterFromName(elementId, null, propertyName);
if (parameter != null)
{
StorageType storageType = parameter.StorageType;
if (storageType != StorageType.String && storageType != StorageType.ElementId)
{
return(null);
}
if (parameter.HasValue)
{
string propValue;
propValue = parameter.AsString();
if (!string.IsNullOrEmpty(propValue))
{
string propValuetrim = propValue.Trim();
// This is kind of hack to quickly check whether we need to parse the parameter or not
if (((propValuetrim.Length > 1 && propValuetrim[0] == '{') || (propValuetrim.Length > 2 && propValuetrim[1] == '{')) && (propValuetrim[propValuetrim.Length - 1] == '}'))
{
ParamExprResolver pResv = new ParamExprResolver(element, propertyName, propValuetrim);
propertyValue = pResv.GetStringValue();
if (string.IsNullOrEmpty(propertyValue))
{
propertyValue = propValue; // return the original propValue (un-trimmed)
}
}
else
{
propertyValue = propValue; // return the original propValue (un-trimmed)
}
return(parameter);
}
else if (parameter.AsElementId() != null)
{
propertyValue = PropertyUtil.ElementIdParameterAsString(parameter);
return(parameter);
}
}
if (allowUnset)
{
propertyValue = null;
return(parameter);
}
}
return(null);
}
internal static Type GetTypeStorage(StorageType storageType)
{
Debug.Assert(storageType != StorageType.Empty);
return(s_storageClassType[(int)storageType] !);
}
public static DataStorage CreateStorage(DataColumn column, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type dataType, StorageType typeCode)
{
Debug.Assert(typeCode == GetStorageType(dataType), "Incorrect storage type specified");
if ((StorageType.Empty == typeCode) && (null != dataType))
{
if (typeof(INullable).IsAssignableFrom(dataType))
{ // Udt, OracleTypes
return(new SqlUdtStorage(column, dataType));
}
else
{
return(new ObjectStorage(column, dataType)); // non-nullable non-primitives
}
}
switch (typeCode)
{
case StorageType.Empty: throw ExceptionBuilder.InvalidStorageType(TypeCode.Empty);
case StorageType.DBNull: throw ExceptionBuilder.InvalidStorageType((TypeCode)2); // TypeCode.DBNull);
case StorageType.Object: return(new ObjectStorage(column, dataType !));
case StorageType.Boolean: return(new BooleanStorage(column));
case StorageType.Char: return(new CharStorage(column));
case StorageType.SByte: return(new SByteStorage(column));
case StorageType.Byte: return(new ByteStorage(column));
case StorageType.Int16: return(new Int16Storage(column));
case StorageType.UInt16: return(new UInt16Storage(column));
case StorageType.Int32: return(new Int32Storage(column));
case StorageType.UInt32: return(new UInt32Storage(column));
case StorageType.Int64: return(new Int64Storage(column));
case StorageType.UInt64: return(new UInt64Storage(column));
case StorageType.Single: return(new SingleStorage(column));
case StorageType.Double: return(new DoubleStorage(column));
case StorageType.Decimal: return(new DecimalStorage(column));
case StorageType.DateTime: return(new DateTimeStorage(column));
case StorageType.TimeSpan: return(new TimeSpanStorage(column));
case StorageType.String: return(new StringStorage(column));
case StorageType.Guid: return(new ObjectStorage(column, dataType !));
case StorageType.ByteArray: return(new ObjectStorage(column, dataType !));
case StorageType.CharArray: return(new ObjectStorage(column, dataType !));
case StorageType.Type: return(new ObjectStorage(column, dataType !));
case StorageType.DateTimeOffset: return(new DateTimeOffsetStorage(column));
case StorageType.BigInteger: return(new BigIntegerStorage(column));
case StorageType.Uri: return(new ObjectStorage(column, dataType !));
case StorageType.SqlBinary: return(new SqlBinaryStorage(column));
case StorageType.SqlBoolean: return(new SqlBooleanStorage(column));
case StorageType.SqlByte: return(new SqlByteStorage(column));
case StorageType.SqlBytes: return(new SqlBytesStorage(column));
case StorageType.SqlChars: return(new SqlCharsStorage(column));
case StorageType.SqlDateTime: return(new SqlDateTimeStorage(column));
case StorageType.SqlDecimal: return(new SqlDecimalStorage(column));
case StorageType.SqlDouble: return(new SqlDoubleStorage(column));
case StorageType.SqlGuid: return(new SqlGuidStorage(column));
case StorageType.SqlInt16: return(new SqlInt16Storage(column));
case StorageType.SqlInt32: return(new SqlInt32Storage(column));
case StorageType.SqlInt64: return(new SqlInt64Storage(column));
case StorageType.SqlMoney: return(new SqlMoneyStorage(column));
case StorageType.SqlSingle: return(new SqlSingleStorage(column));
case StorageType.SqlString: return(new SqlStringStorage(column));
default:
Debug.Fail("shouldn't be here");
goto case StorageType.Object;
}
}
protected DataStorage(DataColumn column, Type type, object?defaultValue, object nullValue, bool isICloneable, StorageType storageType)
{
Debug.Assert(storageType == GetStorageType(type), "Incorrect storage type specified");
_column = column;
_table = column.Table !;
_dataType = type;
_storageTypeCode = storageType;
_defaultValue = defaultValue;
_nullValue = nullValue;
_isCloneable = isICloneable;
_isCustomDefinedType = IsTypeCustomType(_storageTypeCode);
_isStringType = ((StorageType.String == _storageTypeCode) || (StorageType.SqlString == _storageTypeCode));
_isValueType = DetermineIfValueType(_storageTypeCode, type);
}
protected DataStorage(DataColumn column, Type type, object?defaultValue, object nullValue, StorageType storageType)
: this(column, type, defaultValue, nullValue, false, storageType)
{
}
internal static bool IsNumericSql(StorageType type)
{
return(IsFloatSql(type) ||
IsIntegerSql(type));
}
// This function should only be necessary while using ExperimentalAddParameter.
private static Parameter GetAddedParameter(Element element, string parameterName, StorageType type)
{
IList <Parameter> parameterList = element.GetParameters(parameterName);
if (parameterList == null)
{
return(null);
}
foreach (Parameter parameter in parameterList)
{
if (parameter.StorageType != type)
{
continue;
}
if (parameter.IsReadOnly)
{
continue;
}
Definition paramDefinition = parameter.Definition;
if (paramDefinition == null)
{
continue;
}
if (paramDefinition.ParameterGroup == BuiltInParameterGroup.PG_IFC)
{
return(parameter);
}
}
// Shouldn't get here.
return(null);
}
public StorageHelper(StorageType StorageType, string subFolder = null, StorageSerializer serializerType = StorageSerializer.JSON)
{
_storageType = StorageType;
_subFolder = subFolder;
_serializerType = serializerType;
}
internal static bool IsTypeCustomType(StorageType typeCode)
{
return((StorageType.Object == typeCode) || (StorageType.Empty == typeCode) || (StorageType.CharArray == typeCode));
}
public static bool InitDefaultStorage(StorageType eStoreType, PackType ePackType)
{
bool ret = otapiPINVOKE.InitDefaultStorage((int)eStoreType, (int)ePackType);
return(ret);
}
internal static bool IsSqlType(StorageType storageType)
{
return(StorageType.SqlBinary <= storageType);
}
internal static extern ErrorCode PackageManagerRequestMoveWithCB(SafePackageManagerRequestHandle requestHandle, string name, StorageType moveToStorageType, PackageManagerRequestEventCallback callback, IntPtr userData, out int id);
internal static bool ImplementsINullableValue(StorageType typeCode, Type dataType)
{
Debug.Assert(typeCode == GetStorageType(dataType), "typeCode mismatches dataType");
return((StorageType.Empty == typeCode) && dataType.IsGenericType && (dataType.GetGenericTypeDefinition() == typeof(System.Nullable <>)));
}
public UpdateStorageItemsJob(BaseDatabase database, StorageType storageType, string storageOwnerId, IList <CharacterItem> characterItems, Action onFinished = null) : base(database, onFinished)
{
this.storageType = storageType;
this.storageOwnerId = storageOwnerId;
this.characterItems = characterItems;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
/// <param name="storageType"></param>
public Parameter(ParameterType parameterType, dynamic value, StorageType storageType)
{
m_parameterType = parameterType;
m_value = value;
m_storageType = storageType;
}
/// <summary>
/// Generic class to simplify the storage and retrieval of data to/from Windows.Storage.ApplicationData
/// </summary>
/// <param name="StorageType"></param>
public ObjectStorageHelper(StorageType StorageType)
{
serializer = new XmlSerializer(typeof(T));
storageType = StorageType;
}
public UseStorageAttribute(StorageType type)
{
this.Type = type;
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="storageType">存储器类型</param>
/// <param name="connectionString">连接字符串</param>
public MySqlEntityStorage(StorageType storageType = StorageType.InsertIgnoreDuplicate,
string connectionString = null) : base(storageType,
connectionString)
{
}
/// <summary>
/// Sets the storage type in the KeyValueConfiguration.
/// </summary>
/// <param name="storageType">the storage type</param>
/// <returns></returns>
public KeyValueConfigurationBuilder WithStorageType(StorageType storageType)
{
scBuilder.WithStorageType(storageType);
return(this);
}
public static ElementFilter createParameterFilter(Document doc, ParameterData parameter, string operation, string ruleString)
{
ElementId parameterId = parameter.Id;
ParameterValueProvider fvp = new ParameterValueProvider(parameterId);
StorageType storageType = parameter.StorageType;
FilterRule fRule = null;
FilterInverseRule fInvRule = null;
ElementParameterFilter filter = null;
switch (storageType)
{
case StorageType.String:
case StorageType.Integer:
FilterStringRuleEvaluator fsre = null;
switch (operation)
{
case "равно":
fsre = new FilterStringEquals();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
filter = new ElementParameterFilter(fRule);
break;
case "не равно":
fsre = new FilterStringEquals();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "содержит":
fsre = new FilterStringContains();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
filter = new ElementParameterFilter(fRule);
break;
case "не содержит":
fsre = new FilterStringContains();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "начинается с":
fsre = new FilterStringBeginsWith();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
filter = new ElementParameterFilter(fRule);
break;
case "не начинается с":
fsre = new FilterStringBeginsWith();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "заканчивается на":
fsre = new FilterStringEndsWith();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
filter = new ElementParameterFilter(fRule);
break;
case "не заканчивается на":
fsre = new FilterStringEndsWith();
fRule = new FilterStringRule(fvp, fsre, ruleString, true);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
}
break;
case StorageType.Double:
FilterNumericRuleEvaluator fnre = null;
double ruleValue = Convert.ToDouble(ruleString);
switch (operation)
{
case "равно":
fnre = new FilterNumericEquals();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
case "не равно":
fnre = new FilterNumericEquals();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "больше":
fnre = new FilterNumericGreater();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
case "больше или равно":
fnre = new FilterNumericGreaterOrEqual();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
case "меньше":
fnre = new FilterNumericLess();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
case "меньше или равно":
fnre = new FilterNumericLessOrEqual();
fRule = new FilterDoubleRule(fvp, fnre, ruleValue, 0.0);
filter = new ElementParameterFilter(fRule);
break;
}
break;
case StorageType.ElementId:
var levels = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Levels).ToElements();
var level = levels.Where(i => i.Name == ruleString).FirstOrDefault();
ElementId ruleId = level.Id;
fnre = null;
switch (operation)
{
case "равно":
fnre = new FilterNumericEquals();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
case "не равно":
fnre = new FilterNumericEquals();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
fInvRule = new FilterInverseRule(fRule);
filter = new ElementParameterFilter(fInvRule);
break;
case "выше":
fnre = new FilterNumericGreater();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
case "ровно или выше":
fnre = new FilterNumericGreaterOrEqual();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
case "ниже":
fnre = new FilterNumericLess();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
case "ровно или ниже":
fnre = new FilterNumericLessOrEqual();
fRule = new FilterElementIdRule(fvp, fnre, ruleId);
filter = new ElementParameterFilter(fRule);
break;
}
break;
}
return(filter);
}
public static string ToIoCString(this StorageType storage)
{
return(storage.ToString().ToUpperInvariant());
}
public DatabaseCreateOperation(string databaseName, DatabaseType databaseType, StorageType storageType, ConnectionMetaData metaData, ServerConnectionOptions options, IOrientDBRecordSerializer <byte[]> serializer, IOrientDBLogger logger)
{
if (string.IsNullOrWhiteSpace(databaseName))
{
throw new ArgumentException($"{nameof(databaseName)} cannot be zero length or null.");
}
_metaData = metaData ?? throw new ArgumentNullException($"{nameof(metaData)} cannot be null.");
_options = options ?? throw new ArgumentNullException($"{nameof(options)} cannot be null.");
_serializer = serializer ?? throw new ArgumentNullException($"{nameof(serializer)} cannot be null.");
_logger = logger ?? throw new ArgumentNullException($"{nameof(logger)} cannot be null");
_databaseName = databaseName;
_databaseType = databaseType;
_storageType = storageType;
}
internal void Clear()
{
_isNull = false;
_type = StorageType.Empty;
_object = null;
}
/// <summary>
/// 构造方法
/// </summary>
/// <param name="storageType">存储器类型</param>
/// <param name="connectionString">连接字符串</param>
protected RelationalDatabaseEntityStorageBase(StorageType storageType,
string connectionString = null)
{
ConnectionString = connectionString;
StorageType = storageType;
}
internal static bool IsFloat(StorageType type)
{
return(type == StorageType.Single ||
type == StorageType.Double ||
type == StorageType.Decimal);
}
