コード例 #1
0
        public ITableEntity AfterLoad(ITableEntity entity)
        {
            if (entity == null)
            {
                return(entity);
            }

            var type         = entity.GetType();
            var rowKey       = this.RowKey(type);
            var partitionKey = this.PartitionKey(type);

            if (!string.IsNullOrWhiteSpace(partitionKey) && type.GetProperty(partitionKey).CanWrite)
            {
                type.GetProperty(partitionKey).SetValue(entity, entity.PartitionKey);
            }

            if (!string.IsNullOrWhiteSpace(rowKey) && type.GetProperty(rowKey).CanWrite)
            {
                type.GetProperty(rowKey).SetValue(entity, entity.RowKey);
            }

            foreach (var p in type.GetProperties())
            {
                var jsonData = p.GetCustomAttribute <JsonDataAttribute>();
                if (jsonData != null)
                {
                    p.SetValue(entity, ToObject(p.PropertyType, (string)type.GetProperty(jsonData.PropertyName).GetValue(entity)));
                }
            }

            return(entity);
        }
コード例 #2
0
        static string ErrorMessage(ITableEntity azureEntity, ITableEntity wossEntity)
        {
            StringBuilder sb = new StringBuilder("Entity mismatch between azure and woss table:\r\n");

            if (azureEntity == null)
            {
                sb.Append("Azure entity is null\r\n");
            }
            else
            {
                sb.Append("Azure entity is " + azureEntity.GetType() + ":\r\n");
                sb.Append(Serialize(azureEntity));
                sb.Append("\r\n");
            }

            if (wossEntity == null)
            {
                sb.Append("Woss entity is null\r\n");
            }
            else
            {
                sb.Append("Woss entity is " + wossEntity.GetType() + ":\r\n");
                sb.Append(Serialize(wossEntity));
            }
            return(sb.ToString());
        }
コード例 #3
0
        internal static IDictionary <string, object> Build(ITableEntity entity)
        {
            var properties = entity.GetType().GetProperties(Flags);

            var result = new Dictionary <string, object>();

            for (var i = 0; i < properties.Length; i++)
            {
                if (string.Compare(properties[i].Name, "TableName", StringComparison.OrdinalIgnoreCase) == 0 ||
                    string.Compare(properties[i].Name, "Timestamp", StringComparison.OrdinalIgnoreCase) == 0 ||
                    string.Compare(properties[i].Name, "ETag", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    continue;
                }

                var entityInfo = new EntityPropertyInfo(properties[i].GetValue(entity), properties[i].PropertyType);

                result.Add(properties[i].Name, entityInfo.Value);

                if (entityInfo.EdmDataType != null)
                {
                    result.Add(properties[i].Name + "@odata.type", entityInfo.EdmDataType);
                }
            }

            return(result);
        }
コード例 #4
0
        private static async Task Track(CloudTable table, ITableEntity entity, TraceWriter log)
        {
            log.Info($"Track {entity.GetType().Name}: {entity.RowKey}");

            var operation = TableOperation.InsertOrReplace(entity);

            await table.ExecuteAsync(operation).ConfigureAwait(false);
        }
コード例 #5
0
 public void ReadEntity(ITableEntity entity, IDictionary <string, EntityProperty> properties)
 {
     Entity = new T();
     Metadatas.Clear();
     ReadProp(entity, entity.GetType().GetProperties(), properties);
     ReadProp(Entity, EntityProperties, properties);
     ReadMetadatas(Metadatas, EntityProperties, properties);
 }
コード例 #6
0
        public void AttachObject(ITableEntity tableEntity, bool asModified)
        {
            var method = Get_GetTable_Method(tableEntity.GetType());

            var table = method.Invoke(LinqToSqlContext, null) as ITable;

            table.Attach(tableEntity, asModified);
        }
コード例 #7
0
        /// <summary>
        /// Replace (update) an existing table entity.
        /// </summary>
        /// <param name="tableEntity">Table entity to replace (update).</param>
        public void ReplaceEntity(
            ITableEntity tableEntity)
        {
            var table           = GetTableReference(tableEntity.GetType().Name);
            var insertOperation = TableOperation.InsertOrReplace(tableEntity);

            table.Execute(insertOperation);
        }
コード例 #8
0
        public void AddObject(ITableEntity tableEntity)
        {
            var method = Get_GetTable_Method(tableEntity.GetType());

            var table = method.Invoke(LinqToSqlContext, null) as ITable;

            table.InsertOnSubmit(tableEntity);
        }
コード例 #9
0
        //public async Task DestoryTablesForDevOnlyAsync(string onlyThisTableByName = null)
        //{
        //	if (_connectionString != "UseDevelopmentStorage=true;")
        //		throw new Exception("this will delete all your datas. only for dev/test purposes. Connection string must = \"UseDevelopmentStorage=true;\"");


        //	var tables = await _tableClient.ListTablesSegmentedAsync()
        //	foreach (var table in _tableClient.ListTables().Where(x => x.Name == onlyThisTableByName || onlyThisTableByName == null))
        //		await table.DeleteAsync();
        //}
        public async Task InsertOrReplaceAsync(ITableEntity e, string overrideTableName = null)
        {
            var table = _tableClient.GetTableReference(overrideTableName ?? e.GetType().Name);
            await table.CreateIfNotExistsAsync();

            var insertOperation = TableOperation.InsertOrReplace(e);
            await table.ExecuteAsync(insertOperation);
        }
コード例 #10
0
ファイル: Table.cs プロジェクト: BernieCook/CommandQueue
        /// <summary>
        /// Replace (update) an existing table entity.
        /// </summary>
        /// <param name="tableEntity">Table entity to replace (update).</param>
        public void ReplaceEntity(
            ITableEntity tableEntity)
        {
            var table = GetTableReference(tableEntity.GetType().Name);
            var insertOperation = TableOperation.InsertOrReplace(tableEntity);

            table.Execute(insertOperation);
        }
コード例 #11
0
        public void AttachObject(ITableEntity tableEntity, ITableEntity original)
        {
            var method = Get_GetTable_Method(tableEntity.GetType());

            var table = method.Invoke(LinqToSqlContext, null) as ITable;

            table.Attach(tableEntity, original);
        }
コード例 #12
0
        //public static void DecryptBytes(this Blob document)
        //{
        //    var cryptoProperties = document.GetType().GetProperties()
        //        .Where(prop => prop.GetCustomAttributes(true).Length > 0); //typeof(CryptoAttribute), true));
        //    foreach (var cryptoProperty in cryptoProperties)
        //    {
        //        var encryptedValue = cryptoProperty.GetValue(document);
        //        var decryptedValue = Decrypt(encryptedValue);
        //        cryptoProperty.SetValue(document, decryptedValue);
        //    }
        //}

        public static void EncryptFields(this ITableEntity document)
        {
            var cryptoProperties = document.GetType().GetProperties()
                                   .Where(prop => prop.GetCustomAttributes(true).Length > 0); //typeof(CryptoAttribute), true));

            foreach (var cryptoProperty in cryptoProperties)
            {
                var decryptedValue = cryptoProperty.GetValue(document);
                var encryptedValue = Encrypt(decryptedValue);
                cryptoProperty.SetValue(document, encryptedValue);
            }
        }
コード例 #13
0
        public IDictionary <string, EntityProperty> WriteEntity(ITableEntity entity)
        {
            Dictionary <string, EntityProperty> retVals = new Dictionary <string, EntityProperty>();

            var objectProperties = entity.GetType().
                                   GetProperties()
                                   .Union(EntityProperties);

            foreach (var metadata in Metadatas)
            {
                if (retVals.ContainsKey(metadata.Key))
                {
                    continue;
                }
                retVals.Add(metadata.Key, CreateEntityPropertyFromObject(metadata.Value));
            }
            foreach (PropertyInfo property in objectProperties)
            {
                // reserved properties
                if (property.Name == TableConstants.PartitionKey ||
                    property.Name == TableConstants.RowKey ||
                    property.Name == TableConstants.Timestamp ||
                    property.Name == TableConstants.Etag ||
                    property.Name == nameof(Entity))

                {
                    continue;
                }

                // Enforce public getter / setter

                if (property.GetSetMethod() == null || !property.GetSetMethod().IsPublic || property.GetGetMethod() == null || !property.GetGetMethod().IsPublic)

                {
                    continue;
                }

                var newProperty = CreateEntityPropertyFromObject(property.GetValue(Entity, null), property);

                // property will be null for unknown type
                if (newProperty != null && !retVals.ContainsKey(property.Name))
                {
                    retVals.Add(property.Name, newProperty);
                }
            }

            return(retVals);
        }
コード例 #14
0
ファイル: TableAttribute.cs プロジェクト: hempe/vabulu
        public ITableEntity BeforeSave(ITableEntity entity)
        {
            if (this.BeforeQuery(entity) == null)
            {
                return(entity);
            }
            var type = entity.GetType();

            foreach (var p in type.GetProperties())
            {
                var jsonData = p.GetCustomAttributes(typeof(JsonDataAttribute), true).Cast <JsonDataAttribute>().FirstOrDefault();
                if (jsonData == null)
                {
                    continue;
                }
                type.GetProperty(jsonData.PropertyName).SetValue(entity, ToJson(p.GetValue(entity)));
            }

            return(entity);
        }
コード例 #15
0
        public ITableEntity BeforeQuery(ITableEntity entity)
        {
            if (entity == null)
            {
                return(entity);
            }
            var type         = entity.GetType();
            var rowKey       = this.RowKey(type);
            var partitionKey = this.PartitionKey(type);

            if (!string.IsNullOrWhiteSpace(partitionKey) && type.GetProperty(partitionKey).CanRead)
            {
                entity.PartitionKey = (string)type.GetProperty(partitionKey).GetValue(entity);
            }

            if (!string.IsNullOrWhiteSpace(rowKey) && type.GetProperty(rowKey).CanRead)
            {
                entity.RowKey = (string)type.GetProperty(rowKey).GetValue(entity);
            }

            return(entity);
        }
コード例 #16
0
        internal static void ReadAndUpdateTableEntityWithEdmTypeResolver(ITableEntity entity, Dictionary <string, string> entityAttributes, EntityReadFlags flags, Func <string, string, string, string, EdmType> propertyResolver, OperationContext ctx)
        {
            Dictionary <string, EntityProperty> dictionary  = ((flags & EntityReadFlags.Properties) > (EntityReadFlags)0) ? new Dictionary <string, EntityProperty>() : null;
            Dictionary <string, EdmType>        dictionary2 = null;

            if (entity.GetType() != typeof(DynamicTableEntity))
            {
                if (!TableEntity.DisablePropertyResolverCache)
                {
                    dictionary2 = TableEntity.PropertyResolverCache.GetOrAdd(entity.GetType(), CreatePropertyResolverDictionary);
                }
                else
                {
                    Logger.LogVerbose(ctx, "Property resolver cache is disabled.");
                    dictionary2 = CreatePropertyResolverDictionary(entity.GetType());
                }
            }
            if (flags > (EntityReadFlags)0)
            {
                foreach (KeyValuePair <string, string> entityAttribute in entityAttributes)
                {
                    if (entityAttribute.Key == "PartitionKey")
                    {
                        entity.PartitionKey = entityAttribute.Value;
                    }
                    else if (entityAttribute.Key == "RowKey")
                    {
                        entity.RowKey = entityAttribute.Value;
                    }
                    else if (entityAttribute.Key == "Timestamp")
                    {
                        if ((flags & EntityReadFlags.Timestamp) != 0)
                        {
                            entity.Timestamp = DateTime.Parse(entityAttribute.Value, CultureInfo.InvariantCulture);
                        }
                    }
                    else if ((flags & EntityReadFlags.Properties) > (EntityReadFlags)0)
                    {
                        if (propertyResolver != null)
                        {
                            Logger.LogVerbose(ctx, "Using the property resolver provided via TableRequestOptions to deserialize the entity.");
                            try
                            {
                                EdmType edmType = propertyResolver(entity.PartitionKey, entity.RowKey, entityAttribute.Key, entityAttribute.Value);
                                Logger.LogVerbose(ctx, "Attempting to deserialize '{0}' as type '{1}'", entityAttribute.Key, edmType.GetType().ToString());
                                try
                                {
                                    dictionary.Add(entityAttribute.Key, EntityProperty.CreateEntityPropertyFromObject(entityAttribute.Value, edmType.GetType()));
                                }
                                catch (FormatException innerException)
                                {
                                    throw new StorageException(string.Format(CultureInfo.InvariantCulture, "Failed to parse property '{0}' with value '{1}' as type '{2}'", entityAttribute.Key, entityAttribute.Value, edmType.ToString()), innerException)
                                          {
                                              IsRetryable = false
                                          };
                                }
                            }
                            catch (StorageException)
                            {
                                throw;
                            }
                            catch (Exception innerException2)
                            {
                                throw new StorageException("The custom property resolver delegate threw an exception. Check the inner exception for more details.", innerException2)
                                      {
                                          IsRetryable = false
                                      };
                            }
                        }
                        else if (entity.GetType() != typeof(DynamicTableEntity))
                        {
                            Logger.LogVerbose(ctx, "Using the default property resolver to deserialize the entity.");
                            if (dictionary2 != null)
                            {
                                dictionary2.TryGetValue(entityAttribute.Key, out EdmType value);
                                Logger.LogVerbose(ctx, "Attempting to deserialize '{0}' as type '{1}'", entityAttribute.Key, value);
                                dictionary.Add(entityAttribute.Key, EntityProperty.CreateEntityPropertyFromObject(entityAttribute.Value, value));
                            }
                        }
                        else
                        {
                            Logger.LogVerbose(ctx, "No property resolver available. Deserializing the entity properties as strings.");
                            dictionary.Add(entityAttribute.Key, EntityProperty.CreateEntityPropertyFromObject(entityAttribute.Value, typeof(string)));
                        }
                    }
                }
                if ((flags & EntityReadFlags.Properties) > (EntityReadFlags)0)
                {
                    entity.ReadEntity(dictionary, ctx);
                }
            }
        }
コード例 #17
0
        internal static void ReadAndUpdateTableEntityWithEdmTypeResolver(ITableEntity entity, Dictionary <string, string> entityAttributes, EntityReadFlags flags, Func <string, string, string, string, EdmType> propertyResolver, OperationContext ctx)
        {
            Dictionary <string, EntityProperty> entityProperties           = (flags & EntityReadFlags.Properties) > 0 ? new Dictionary <string, EntityProperty>() : null;
            Dictionary <string, EdmType>        propertyResolverDictionary = null;

            // Try to add the dictionary to the cache only if it is not a DynamicTableEntity. If DisablePropertyResolverCache is true, then just use reflection and generate dictionaries for each entity.
            if (entity.GetType() != typeof(DynamicTableEntity))
            {
#if WINDOWS_DESKTOP && !WINDOWS_PHONE
                if (!TableEntity.DisablePropertyResolverCache)
                {
                    propertyResolverDictionary = TableEntity.PropertyResolverCache.GetOrAdd(entity.GetType(), TableOperationHttpResponseParsers.CreatePropertyResolverDictionary);
                }
                else
                {
                    Logger.LogVerbose(ctx, SR.PropertyResolverCacheDisabled);
                    propertyResolverDictionary = TableOperationHttpResponseParsers.CreatePropertyResolverDictionary(entity.GetType());
                }
#else
                propertyResolverDictionary = TableOperationHttpResponseParsers.CreatePropertyResolverDictionary(entity.GetType());
#endif
            }

            if (flags > 0)
            {
                foreach (KeyValuePair <string, string> prop in entityAttributes)
                {
                    if (prop.Key == TableConstants.PartitionKey)
                    {
                        entity.PartitionKey = (string)prop.Value;
                    }
                    else if (prop.Key == TableConstants.RowKey)
                    {
                        entity.RowKey = (string)prop.Value;
                    }
                    else if (prop.Key == TableConstants.Timestamp)
                    {
                        if ((flags & EntityReadFlags.Timestamp) == 0)
                        {
                            continue;
                        }

                        entity.Timestamp = DateTime.Parse(prop.Value, CultureInfo.InvariantCulture);
                    }
                    else if ((flags & EntityReadFlags.Properties) > 0)
                    {
                        if (propertyResolver != null)
                        {
                            Logger.LogVerbose(ctx, SR.UsingUserProvidedPropertyResolver);
                            try
                            {
                                EdmType type = propertyResolver(entity.PartitionKey, entity.RowKey, prop.Key, prop.Value);
                                Logger.LogVerbose(ctx, SR.AttemptedEdmTypeForTheProperty, prop.Key, type.GetType().ToString());
                                try
                                {
                                    entityProperties.Add(prop.Key, EntityProperty.CreateEntityPropertyFromObject(prop.Value, type.GetType()));
                                }
                                catch (FormatException ex)
                                {
                                    throw new StorageException(string.Format(CultureInfo.InvariantCulture, SR.FailParseProperty, prop.Key, prop.Value, type.ToString()), ex)
                                          {
                                              IsRetryable = false
                                          };
                                }
                            }
                            catch (StorageException)
                            {
                                throw;
                            }
                            catch (Exception ex)
                            {
                                throw new StorageException(SR.PropertyResolverThrewError, ex)
                                      {
                                          IsRetryable = false
                                      };
                            }
                        }
                        else if (entity.GetType() != typeof(DynamicTableEntity))
                        {
                            EdmType edmType;
                            Logger.LogVerbose(ctx, SR.UsingDefaultPropertyResolver);

                            if (propertyResolverDictionary != null)
                            {
                                propertyResolverDictionary.TryGetValue(prop.Key, out edmType);
                                Logger.LogVerbose(ctx, SR.AttemptedEdmTypeForTheProperty, prop.Key, edmType);
                                entityProperties.Add(prop.Key, EntityProperty.CreateEntityPropertyFromObject(prop.Value, edmType));
                            }
                        }
                        else
                        {
                            Logger.LogVerbose(ctx, SR.NoPropertyResolverAvailable);
                            entityProperties.Add(prop.Key, EntityProperty.CreateEntityPropertyFromObject(prop.Value, typeof(string)));
                        }
                    }
                }

                if ((flags & EntityReadFlags.Properties) > 0)
                {
                    entity.ReadEntity(entityProperties, ctx);
                }
            }
        }
コード例 #18
0
 private static string BuildMessage(ITableEntity entity)
 {
     return($"Entity was changed by someone else.\r\n- Entity type: {entity.GetType().FullName}\r\n- PK: {entity.PartitionKey}\r\n- RK: {entity.RowKey}\r\n- ETag: {entity.ETag}\r\n- Timestamp: {entity.Timestamp}");
 }