/// <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;
}
}
