示例#1
0
        public EasyTableItemBinding(ParameterInfo parameter, EasyTableContext context, BindingProviderContext bindingContext)
        {
            _parameter = parameter;
            _context   = context;

            // set up binding for '{ItemId}'-type bindings
            if (_context.ResolvedId != null)
            {
                _bindingTemplate = BindingTemplate.FromString(_context.ResolvedId);
                _bindingTemplate.ValidateContractCompatibility(bindingContext.BindingDataContract);
            }
        }
示例#2
0
        internal static bool IsValidQueryType(Type paramType, EasyTableContext context)
        {
            if (paramType.IsGenericType &&
                paramType.GetGenericTypeDefinition() == typeof(IMobileServiceTableQuery <>))
            {
                // IMobileServiceTableQuery<JObject> is not supported.
                Type coreType = TypeUtility.GetCoreType(paramType);
                if (coreType != typeof(JObject) &&
                    EasyTableUtility.IsCoreTypeValidItemType(paramType, context))
                {
                    return(true);
                }
            }

            return(false);
        }
示例#3
0
        internal static bool IsValidCollectorType(Type paramType, EasyTableContext context)
        {
            if (paramType.IsGenericType)
            {
                Type genericType = paramType.GetGenericTypeDefinition();
                if (genericType == typeof(ICollector <>) || genericType == typeof(IAsyncCollector <>))
                {
                    Type coreType = TypeUtility.GetCoreType(paramType);
                    if (IsValidEasyTableOutputType(coreType, context))
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
示例#4
0
        internal static bool IsValidOutType(Type paramType, EasyTableContext context)
        {
            if (paramType.IsByRef)
            {
                Type coreType = paramType.GetElementType();
                if (coreType.IsArray)
                {
                    coreType = coreType.GetElementType();
                }

                if (IsValidEasyTableOutputType(coreType, context))
                {
                    return(true);
                }
            }

            return(false);
        }
        internal static bool IsMobileServiceTableType(Type paramType, EasyTableContext context)
        {
            if (paramType == typeof(IMobileServiceTable) &&
                !string.IsNullOrEmpty(context.ResolvedTableName))
            {
                return(true);
            }

            if (paramType.IsGenericType &&
                paramType.GetGenericTypeDefinition() == typeof(IMobileServiceTable <>))
            {
                if (EasyTableUtility.IsCoreTypeValidItemType(paramType, context))
                {
                    return(true);
                }
            }

            return(false);
        }
        /// <summary>
        /// Evaluates whether the specified type is valid for use with EasyTables.
        /// If the type is <see cref="JObject"/>, then the ResolvedTableName property on
        /// <see cref="EasyTableAttribute"/> is required.
        /// If the type is not <see cref="JObject"/>, then it must contain a single public
        /// string 'Id' property.
        /// </summary>
        /// <param name="itemType">The type to evaluate.</param>
        /// <param name="context">The <see cref="EasyTableContext"/>.</param>
        /// <returns></returns>
        public static bool IsValidItemType(Type itemType, EasyTableContext context)
        {
            // We cannot support a type of JObject without a TableName.
            if (itemType == typeof(JObject))
            {
                return(!string.IsNullOrEmpty(context.ResolvedTableName));
            }

            // POCO types must have a string id property (case insensitive).
            IEnumerable <PropertyInfo> idProperties = itemType.GetProperties()
                                                      .Where(p => string.Equals("id", p.Name, StringComparison.OrdinalIgnoreCase) && p.PropertyType == typeof(string));

            if (idProperties.Count() != 1)
            {
                return(false);
            }

            return(true);
        }
        public Task <IBinding> TryCreateAsync(BindingProviderContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ParameterInfo      parameter = context.Parameter;
            EasyTableAttribute attribute = parameter.GetEasyTableAttribute();

            if (attribute == null)
            {
                return(Task.FromResult <IBinding>(null));
            }

            if (_easyTableConfig.MobileAppUri == null &&
                string.IsNullOrEmpty(attribute.MobileAppUri))
            {
                throw new InvalidOperationException(
                          string.Format(CultureInfo.CurrentCulture,
                                        "The Easy Tables Uri must be set either via a '{0}' app setting, via the EasyTableAttribute.MobileAppUri property or via EasyTableConfiguration.MobileAppUri.",
                                        EasyTablesConfiguration.AzureWebJobsMobileAppUriName));
            }

            EasyTableContext easyTableContext = CreateContext(_easyTableConfig, attribute, _nameResolver);

            IBindingProvider compositeProvider = new CompositeBindingProvider(new IBindingProvider[]
            {
                new EasyTableOutputBindingProvider(_jobHostConfig, easyTableContext),
                new EasyTableQueryBinding(context.Parameter, easyTableContext),
                new EasyTableTableBinding(parameter, easyTableContext),
                new EasyTableItemBinding(parameter, easyTableContext, context)
            });

            return(compositeProvider.TryCreateAsync(context));
        }
 public EasyTableTableValueProvider(ParameterInfo parameter, EasyTableContext context)
 {
     _parameter = parameter;
     _context   = context;
 }
 public EasyTableTableBinding(ParameterInfo parameter, EasyTableContext context)
 {
     _parameter = parameter;
     _context   = context;
 }
        internal static async Task SetValueInternalAsync(JObject originalItem, object newItem, EasyTableContext context)
        {
            JObject currentValue = null;
            bool    isJObject    = newItem.GetType() == typeof(JObject);

            if (isJObject)
            {
                currentValue = newItem as JObject;
            }
            else
            {
                currentValue = JObject.FromObject(newItem);
            }

            if (HasChanged(originalItem, currentValue))
            {
                // make sure it's not the Id that has changed
                if (!string.Equals(GetId(originalItem), GetId(currentValue), StringComparison.Ordinal))
                {
                    throw new InvalidOperationException("Cannot update the 'Id' property.");
                }

                if (isJObject)
                {
                    IMobileServiceTable table = context.Client.GetTable(context.ResolvedTableName);
                    await table.UpdateAsync((JObject)newItem);
                }
                else
                {
                    // If TableName is specified, add it to the internal table cache. Now items of this type
                    // will operate on the specified TableName.
                    if (!string.IsNullOrEmpty(context.ResolvedTableName))
                    {
                        context.Client.AddToTableNameCache(newItem.GetType(), context.ResolvedTableName);
                    }
                    IMobileServiceTable <T> table = context.Client.GetTable <T>();
                    await table.UpdateAsync((T)newItem);
                }
            }
        }
 public EasyTableItemValueBinder(ParameterInfo parameter, EasyTableContext context, string id)
 {
     _parameter = parameter;
     _context   = context;
     _id        = id;
 }
示例#12
0
 public EasyTableAsyncCollector(EasyTableContext context)
 {
     _context = context;
 }
示例#13
0
 public EasyTableOutputBindingProvider(JobHostConfiguration jobHostConfig, EasyTableContext easyTableContext)
 {
     _jobHostConfig    = jobHostConfig;
     _easyTableContext = easyTableContext;
 }
示例#14
0
 internal static bool IsValidEasyTableOutputType(Type paramType, EasyTableContext context)
 {
     // Output bindings also support objects as long as ResolvedTableName is valid
     return(EasyTableUtility.IsValidItemType(paramType, context) ||
            (paramType == typeof(object) && !string.IsNullOrEmpty(context.ResolvedTableName)));
 }
        /// <summary>
        /// Gets the core type of the specified type. Then validates that it is
        /// usable with Easy Tables.
        /// </summary>
        /// <param name="type">The type to evaluate.</param>
        /// <param name="context">The <see cref="EasyTableContext"/>.</param>
        /// <returns></returns>
        public static bool IsCoreTypeValidItemType(Type type, EasyTableContext context)
        {
            Type coreType = TypeUtility.GetCoreType(type);

            return(IsValidItemType(coreType, context));
        }