/// <summary> /// Assigns the default value rule. /// </summary> /// <param name="metaFieldName">Name of the meta field.</param> /// <param name="defaultValue">The default value.</param> /// <returns></returns> public MappingRule AssignDefaultValueRule(string metaFieldName, string defaultValue) { if (metaFieldName == null) { throw new ArgumentNullException("metaFieldName"); } if (defaultValue == null) { throw new ArgumentNullException("defaultValue"); } if (this.MappingDocument.Count == 0) { throw new ArgumentException("MappingDocument is empty, create MappingElement or call CreateDefaultMapping."); } //RemoveRuleByColumn(srcColumnName); RemoveRuleByMetaField(metaFieldName); MappingRule retVal = MappingRule.CreateDefaultValue(metaFieldName, defaultValue); MappingElement mapping = this.MappingDocument[0]; mapping.Add(retVal); return(retVal); }
public void MappingDocSeriliazationTest() { MappingDocument mapDoc = new MappingDocument(); MappingElement mapeElColl = new MappingElement(); mapeElColl.ClassName = "Class1"; mapeElColl.TableName = "Table1"; mapeElColl.PrimaryKeyName = "Id"; MappingRule mapEl = new MappingRule(); mapEl.ColumnName = "column1"; mapEl.FieldName = "field1"; mapEl.DefaultValue = "somevalue"; mapeElColl.Add(mapEl); mapDoc.Add(mapeElColl); string xml = MappingDocument.GetXml(mapDoc); MappingDocument loadedDoc = MappingDocument.LoadFromXml(xml); string xml2 = MappingDocument.GetXml(loadedDoc); if (xml != xml2) { throw new AssertFailedException(); } }
public void TestFromBody() { var sub = new DefaultRouteValueSubstitution(); Expression <Func <ControllerSample, ModelSample, ModelSample> > lambda = (c, m) => c.ControllerMethodPut(m.Id, m); var methodCallExpression = (MethodCallExpression)lambda.Body; var apiExplorerMoq = new Mock <IApiExplorer>(); apiExplorerMoq.Setup(_ => _.ApiDescriptions).Returns(new Collection <ApiDescription>() { new ApiDescription() { HttpMethod = HttpMethod.Get } }); var mr = new MappingRule(methodCallExpression, apiExplorerMoq.Object); var payload = _fixture.CreateAnonymous <ModelSample>(); var fields = ActionFieldsGenerator.Generate(mr, apiExplorerMoq.Object.ApiDescriptions[0], payload); Assume.That(fields, Is.Not.Null); var names = fields.ConvertAll(f => f.FieldName); Assume.That(names, Is.EquivalentTo(new[] { "Id", "Name", "Price", "email_address" })); var types = fields.ConvertAll(f => f.FieldType); Assume.That(types, Is.EqualTo(new object[] { null, null, null, "email" })); var values = fields.ConvertAll(f => f.FieldValue); Assume.That(values, Is.EqualTo(new object[] { payload.Id.ToString(), payload.Name, payload.Price.ToString(), payload.EMailAddress })); }
public static void AddToExceptions(int channelId, int productId) { CanonDataContext db = Cdb.Instance; MappingRule rule = db.MappingRules.Where(r => r.ChannelId == channelId && r.ProductId == productId).FirstOrDefault(); if (rule != null) { db.MappingRules.DeleteOnSubmit(rule); } Excluded old = db.Excludeds.FirstOrDefault(d => d.ChannelId == channelId && d.ProductId == productId); if (old != null) { return; } Excluded exc = new Excluded(); exc.ProductId = productId; exc.ChannelId = channelId; db.Excludeds.InsertOnSubmit(exc); db.SubmitChanges(); CanonProductsLog.Add(channelId, productId, MappingLogEnum.AddedToExceptions); }
private static MetadataPlainObjects.Fields GenerateFromGet(MappingRule mappingRule, ApiDescription apiDescription, object originalObject) { if (apiDescription.HttpMethod != HttpMethod.Get) { return(null); } var result = new MetadataPlainObjects.Fields(); int argumentCounter = 0; result.AddRange( from parameter in mappingRule.MethodExpression.Method.GetParameters() let isMemberExpression = mappingRule.MethodExpression.Arguments[argumentCounter++] is MemberExpression where mappingRule.ParameterDelegates.ContainsKey(parameter.Name) let paramDelegate = mappingRule.ParameterDelegates.ContainsKey(parameter.Name) ? mappingRule.ParameterDelegates[parameter.Name] : null select new MetadataPlainObjects.Field { FieldName = parameter.Name, FieldValue = (isMemberExpression && paramDelegate != null) ? paramDelegate.DynamicInvoke(originalObject).ToString() : null }); return(result); }
public BarMappingRuleItem(string targetBarNumber, MappingRule mappingRule) { TargetBarNumber = targetBarNumber; CreditsMappedBarNumber = mappingRule.CreditBarNumber; DebitsMappedBarNumber = mappingRule.DebitBarNumber; IsCustomMapping = true; }
public void MapApiDescription() { Expression <Func <ControllerSample, int> > lambda = (test) => test.FakeMethod(); var methodCallExpression = (MethodCallExpression)lambda.Body; var actionDescriptor = new ReflectedHttpActionDescriptor(_fixture.CreateAnonymous <HttpControllerDescriptor>(), methodCallExpression.Method); var apiExplorerMoq = new Mock <IApiExplorer>(); apiExplorerMoq.Setup(_ => _.ApiDescriptions).Returns(new Collection <ApiDescription>() { new ApiDescription() { ActionDescriptor = actionDescriptor } }); var mappingRule = new MappingRule(methodCallExpression, apiExplorerMoq.Object); Assume.That(mappingRule.MethodExpression, Is.EqualTo(methodCallExpression)); Assume.That(mappingRule.ApiDescriptions, Is.Not.Empty); Assume.That(mappingRule.ParameterDelegates, Is.Empty); Assume.That(mappingRule.Names, Is.Empty); Assume.That(mappingRule.Type, Is.EqualTo(MappingRule.RuleType.Default)); }
public static MetadataPlainObjects.Fields Generate(MappingRule mappingRule, ApiDescription apiDescription, object originalObject) { var fromBodyParameterType = (from param in mappingRule.MethodExpression.Method.GetParameters() let fromBodyAttr = param.GetCustomAttribute <FromBodyAttribute>() where fromBodyAttr != null select param.ParameterType).FirstOrDefault(); if (fromBodyParameterType == null) { return(GenerateFromGet(mappingRule, apiDescription, originalObject)); } var result = new MetadataPlainObjects.Fields(); result.AddRange(from property in fromBodyParameterType.GetProperties() let fieldName = GetFieldName(property) let propVal = property.GetValue(originalObject) let jsonIgnore = property.GetCustomAttribute <JsonIgnoreAttribute>() where jsonIgnore == null select new MetadataPlainObjects.Field { FieldName = fieldName, FieldType = GetFieldType(property), FieldValue = propVal == null ? null : propVal.ToString() }); return(result); }
public void TestSubstitution() { var sub = new DefaultRouteValueSubstitution(); Expression <Func <ControllerSample, ModelSample, ModelSample> > lambda = (c, m) => c.ControllerMethod(m.Id, m.Name, QueryParameter.Is <string>(), QueryParameter.Is <int>()); var methodCallExpression = (MethodCallExpression)lambda.Body; var apiExplorerMoq = new Mock <IApiExplorer>(); apiExplorerMoq.Setup(_ => _.ApiDescriptions).Returns(new Collection <ApiDescription>() { new ApiDescription() { } }); var mr = new MappingRule(methodCallExpression, apiExplorerMoq.Object); var payload = new ModelSample() { Id = 1, Name = "test &?{}<>", Price = 3.2 }; var result = sub.Substitute("/Product/{id}/Details?query={query}&skip={skip}&displayname={name}", mr, payload); Assume.That(result, Is.EqualTo("/Product/1/Details?query=:query&skip=:skip&displayname=test+%26%3f%7b%7d%3c%3e")); }
/// <summary> /// Updates this element from a tag. /// </summary> /// <param name="tag">The tag.</param> protected virtual void UpdateFromTag(MappingRule tag) { if (tag.Visibility.HasValue) { Visibility = tag.Visibility.Value; } }
public void CheckIfPriceIsChanged(int channelId, string productName, string productUrl, decimal price) { CanonDataContext db = Cdb.Instance; //try to find mapping rule MappingRule mr = db.MappingRules.Where(m => m.ChannelId == channelId && m.MonitoredName == productName && m.MonitoredUrl == productUrl).FirstOrDefault(); if (mr == null) { return; } decimal?currentPrice = CanonMapping.GetCurrentMapPrice(channelId, productName, productUrl); if (currentPrice == null) { return; } if ((decimal)currentPrice == price) { CanonProductsLog.Add(channelId, mr.ProductId, MappingLogEnum.PriceWithoutChanges); } else { CanonProductsLog.Add(channelId, mr.ProductId, MappingLogEnum.NewPrice, price.ToString()); } }
public static void AddMapping(int relevanceId) { CanonDataContext db = Cdb.Instance; try { CurrentRelevance cr = db.CurrentRelevances.Where(c => c.RelId == relevanceId).FirstOrDefault(); if (cr != null) { MappingRule rule = db.MappingRules.Where(r => r.ChannelId == cr.ChannelId && r.ProductId == cr.ProductId).FirstOrDefault(); if (rule == null) { //NEW rule MappingRule mr = new MappingRule(); mr.ChannelId = cr.ChannelId; mr.ProductId = cr.ProductId; mr.MonitoredName = cr.ProductName; mr.MonitoredUrl = cr.ProductUrl; db.MappingRules.InsertOnSubmit(mr); CanonProductsLog.Add(cr.ChannelId, cr.ProductId, MappingLogEnum.NewMappingRule); } else { //UPDATED rule rule.MonitoredName = cr.ProductName; rule.MonitoredUrl = cr.ProductUrl; CanonProductsLog.Add(cr.ChannelId, cr.ProductId, MappingLogEnum.ChangedMappingRule); } db.SubmitChanges(); } } catch (Exception) { } }
protected override void UpdateFromTag(MappingRule tag) { base.UpdateFromTag(tag); AllowProperty = !tag.Property.HasValue || tag.Property.Value; IsPersistent = tag.Persist.HasValue && tag.Persist.Value; if (tag.CustomVtbl.HasValue) { CustomVtbl = tag.CustomVtbl.Value; } if (tag.MethodCheckReturnType.HasValue) { CheckReturnType = tag.MethodCheckReturnType.Value; } if (tag.ParameterUsedAsReturnType.HasValue) { ForceReturnType = tag.ParameterUsedAsReturnType.Value; } if (tag.AlwaysReturnHResult.HasValue) { AlwaysReturnHResult = tag.AlwaysReturnHResult.Value; } if (tag.RawPtr.HasValue) { RequestRawPtr = tag.RawPtr.Value; } }
protected override void UpdateFromMappingRule(MappingRule tag) { base.UpdateFromMappingRule(tag); if (tag.EnumHasFlags.HasValue) { IsFlag = tag.EnumHasFlags.Value; } }
public void Complex() { Expression <Func <ControllerSample, ModelSample, ModelSample> > lambda = (test, model) => test.ControllerMethod(model.Id, model.Name, QueryParameter.Is <string>(), QueryParameter.Is <int>()); var methodCallExpression = (MethodCallExpression)lambda.Body; var httpControllerDescriptor = _fixture.CreateAnonymous <HttpControllerDescriptor>(); var apiExplorerMoq = new Mock <IApiExplorer>(); apiExplorerMoq.Setup(_ => _.ApiDescriptions).Returns(new Collection <ApiDescription>() { new ApiDescription() { ActionDescriptor = new ReflectedHttpActionDescriptor(httpControllerDescriptor, methodCallExpression.Method), HttpMethod = HttpMethod.Get, RelativePath = "/api" } }); var mappingRule = new MappingRule(methodCallExpression, apiExplorerMoq.Object); _actionConfiguration.AddMappingRule(mappingRule); _actionConfiguration.Configure(); var originalType = typeof(ModelSample); var strategy = _defaultStrategyFactory.Build(_actionConfiguration, originalType); Assume.That(strategy.ClassKey(originalType), Is.StringContaining("_NHateoas.Tests.ModelSample_SP_SR")); var typeBuilder = new TypeBuilder(originalType, strategy); var type = typeBuilder.BuildType(); Assume.That(type.Name, Is.EqualTo(originalType.Name)); Assume.That(type.FullName, Is.StringContaining("_NHateoas.Tests.ModelSample_SP_SR")); var props = type.GetProperties(); Assume.That(props, Is.Not.Empty); var propNames = props.ToList().ConvertAll(p => p.Name); Assume.That(propNames, Is.EquivalentTo(new[] { "Id", "Name", "Price", "EMailAddress", "get_modelsample_by_id_name_query_skip" })); var propTypes = props.ToList().ConvertAll(p => p.PropertyType.Name); Assume.That(propTypes, Is.EquivalentTo(new[] { "Int32", "String", "Double", "String", "String" })); var instance = Activator.CreateInstance(type); var original = _fixture.CreateAnonymous <ModelSample>(); strategy.ActivateInstance(instance, original, _actionConfiguration); var propValues = props.ToList().ConvertAll(p => p.GetValue(instance).ToString()); Assume.That(propValues, Is.EquivalentTo(new[] { original.Id.ToString(), original.Name, original.Price.ToString(), original.EMailAddress, "/api" })); }
protected override void UpdateFromMappingRule(MappingRule tag) { base.UpdateFromMappingRule(tag); IsCallback = tag.IsCallbackInterface ?? false; IsDualCallback = tag.IsDualCallbackInterface ?? false; AutoGenerateShadow = tag.AutoGenerateShadow ?? false; ShadowName = tag.ShadowName; VtblName = tag.VtblName; }
public List <string> Build(MappingRule mappingRule, string method) { if (mappingRule.Names.Any()) { return(mappingRule.Names); } return(_defaultRouteNameBuilder.Value.Build(mappingRule, method)); }
private static bool RuleMatch(MappingRule rule, Type type) { var assemblyMatch = rule.Assembly == null || rule.Assembly == type.Assembly; var namespaceMatch = string.IsNullOrEmpty(rule.Namespace) || type.FullName.StartsWith(rule.Namespace + ".", StringComparison.Ordinal); return(assemblyMatch && namespaceMatch); }
private static string[] GetClassArray(MappingRule mappingRule) { var returnType = mappingRule.MethodExpression.Method.ReturnType; if (returnType.IsGenericType && typeof(IEnumerable <>).IsAssignableFrom(returnType.GetGenericTypeDefinition())) { return(new[] { SirenMetadataProvider.QueryClassName }); } return(null); }
public List <string> Build(MappingRule mappingRule, string method) { var methodName = method.ToLower(); var name = new StringBuilder(); var actionMethodInfo = mappingRule.MethodExpression.Method; var returnType = actionMethodInfo.ReturnType; if (typeof(HttpResponseMessage).IsAssignableFrom(returnType)) { var attributes = actionMethodInfo.GetCustomAttributes <ResponseTypeAttribute>().ToList(); if (attributes.Any()) { returnType = attributes.First().ResponseType; } } if (returnType.IsGenericType && typeof(IEnumerable <>).IsAssignableFrom(returnType.GetGenericTypeDefinition())) { returnType = returnType.GetGenericArguments()[0]; methodName = "query"; } name.Append(methodName); if (returnType != typeof(void) && !returnType.IsAssignableFrom(typeof(HttpResponseMessage))) { name.AppendFormat("_{0}", returnType.Name.ToLower()); } var parameters = actionMethodInfo.GetParameters(); if (parameters.Any()) { name.AppendFormat("_by"); } foreach (var parameterInfo in parameters) { if (parameterInfo.GetType() == returnType) { continue; } name.AppendFormat("_{0}", parameterInfo.Name.ToLower()); } return(new List <string> { name.ToString() }); }
public static List <string> GetRelList(MappingRule mapping, ApiDescription apiDescription, List <string> rels) { var result = new List <string>(rels); var returnType = mapping.MethodExpression.Method.ReturnType; if (returnType.IsGenericType && typeof(IEnumerable <>).IsAssignableFrom(returnType.GetGenericTypeDefinition())) { result.Add(SirenMetadataProvider.QueryClassName); } return(result); }
protected override void UpdateFromMappingRule(MappingRule tag) { base.UpdateFromMappingRule(tag); AllowProperty = !tag.Property.HasValue || tag.Property.Value; IsPersistent = tag.Persist.HasValue && tag.Persist.Value; if (tag.CustomVtbl.HasValue) { CustomVtbl = tag.CustomVtbl.Value; } }
public void ReturnHttpresponseAttributedParam() { Expression <Func <ControllerSample, ModelSample, HttpResponseMessage> > lambda = (c, m) => c.ControllerHttpResponseMessageMethodWithTypeParam(m.Price); var methodCallExpression = (MethodCallExpression)lambda.Body; var mappingRule = new MappingRule(methodCallExpression, null); var result = _routeNameBuilder.Build(mappingRule, "get"); Assume.That(result, Is.EquivalentTo(new[] { "get_string_by_price" })); }
public void ReturnHttpresponse() { Expression <Func <ControllerSample, HttpResponseMessage> > lambda = (c) => c.ControllerHttpResponseMessageMethod(); var methodCallExpression = (MethodCallExpression)lambda.Body; var mappingRule = new MappingRule(methodCallExpression, null); var result = _routeNameBuilder.Build(mappingRule, "get"); Assume.That(result, Is.EquivalentTo(new[] { "get" })); }
public void ReturnModel() { Expression <Func <ControllerSample, ModelSample, ModelSample> > lambda = (c, m) => c.ControllerMethod(m.Id, m.Name, QueryParameter.Is <string>(), QueryParameter.Is <int>()); var methodCallExpression = (MethodCallExpression)lambda.Body; var mappingRule = new MappingRule(methodCallExpression, null); var result = _routeNameBuilder.Build(mappingRule, "get"); Assume.That(result, Is.EquivalentTo(new[] { "get_modelsample_by_id_name_query_skip" })); }
public void ReturnEnumerable() { Expression <Func <ControllerSample, ModelSample, IEnumerable <ModelSample> > > lambda = (c, m) => c.ControllerQueryMethod(m.Id, m.Name, m.Name, m.Id); var methodCallExpression = (MethodCallExpression)lambda.Body; var mappingRule = new MappingRule(methodCallExpression, null); var result = _routeNameBuilder.Build(mappingRule, "get"); Assume.That(result, Is.EquivalentTo(new[] { "query_modelsample_by_id_name_query_skip" })); }
protected override void UpdateFromTag(MappingRule tag) { base.UpdateFromTag(tag); if (tag.ParameterUsedAsReturnType.HasValue) { IsUsedAsReturnType = tag.ParameterUsedAsReturnType.Value; } if (tag.ParameterAttribute.HasValue && (tag.ParameterAttribute.Value & ParamAttribute.Fast) != 0) { _isFast = true; } DefaultValue = tag.DefaultValue; }
public string Substitute(string templateUrl, MappingRule mapping, Object data) { var methodParameters = mapping.MethodExpression.Method.GetParameters(); var expressionArguments = mapping.MethodExpression.Arguments.GetEnumerator(); var result = new StringBuilder(templateUrl); foreach (var methodParameter in methodParameters) { expressionArguments.MoveNext(); var parameterTemplateName = string.Format("{{{0}}}", methodParameter.Name); if (!templateUrl.Contains(parameterTemplateName)) { continue; } if (!mapping.ParameterDelegates.ContainsKey(methodParameter.Name)) { Debug.Write(string.Format("Unable to obtain delegate for parameter {0}, URL: {1}", methodParameter.Name, templateUrl)); continue; } var paramDelegate = mapping.ParameterDelegates[methodParameter.Name]; var paramResult = paramDelegate.DynamicInvoke(data); if (paramResult == null) { Debug.Write(string.Format("Unable to get result for parameter {0}, URL: {1}", methodParameter.Name, templateUrl)); continue; } var stringResult = paramResult.ToString(); var expressionArgunemt = (expressionArguments.Current as MethodCallExpression); if (expressionArgunemt != null && expressionArgunemt.Method.DeclaringType == typeof(QueryParameter)) { result.Replace(parameterTemplateName, stringResult); } else { result.Replace(parameterTemplateName, HttpUtility.UrlEncode(stringResult)); } } return(result.ToString()); }
protected override void UpdateFromMappingRule(MappingRule tag) { base.UpdateFromMappingRule(tag); Align = tag.StructPack ?? 0; HasMarshalType = tag.StructHasNativeValueType ?? false; GenerateAsClass = tag.StructToClass ?? false; HasCustomMarshal = tag.StructCustomMarshal ?? false; IsStaticMarshal = tag.IsStaticMarshal ?? false; HasCustomNew = tag.StructCustomNew ?? false; if (HasCustomMarshal || IsStaticMarshal || HasCustomNew || GenerateAsClass) { HasMarshalType = true; } }
public static void Tag <T>(this CppElement element, string regex, MappingRule tag) where T : CppElement { string regexStr = CppElement.StripRegex(regex); if (typeof(CppMethod).IsAssignableFrom(typeof(T)) || typeof(CppStruct).IsAssignableFrom(typeof(T))) { LastCppOuterElement = regexStr; } else if ((typeof(T) == typeof(CppParameter) || typeof(T) == typeof(CppField)) && !regexStr.Contains("::")) { regexStr = LastCppOuterElement + "::" + regexStr; } //element.Logger.Flush(); element.Modify <T>(regexStr, ProcessTag(tag)); }
public CsStruct(CppStruct cppStruct, string name, MappingRule tag = null) : base(cppStruct, name) { tag ??= cppStruct?.Rule; Align = tag?.StructPack ?? Align; HasMarshalType = tag?.StructHasNativeValueType ?? HasMarshalType; GenerateAsClass = tag?.StructToClass ?? GenerateAsClass; HasCustomMarshal = tag?.StructCustomMarshal ?? HasCustomMarshal; IsStaticMarshal = tag?.IsStaticMarshal ?? IsStaticMarshal; HasCustomNew = tag?.StructCustomNew ?? HasCustomNew; if (HasCustomMarshal || IsStaticMarshal || HasCustomNew || GenerateAsClass) { HasMarshalType = true; } }