internal UriTemplatePart(string part, MappingAttribute source, ICustomAttributeProvider member, bool hasDefaultValue = false) { Part = ((source is FromQueryStringAttribute) && (part[0] == '&') ? part.Substring(1) : part); Source = source; Member = member; HasDefaultValue = hasDefaultValue; }
internal override void Add(string part, MappingAttribute source, ICustomAttributeProvider member, bool hasDefaultValue = false) { base.Add(part, source, member, hasDefaultValue); if (ControlledEntityType == null) { return; } int indexOf = -1; Type implementation; var identifierSegment = this .Where((item, index) => (item.Source is FromUrlAttribute) && (item.Member is ParameterInfo) && ((implementation = ControlledEntityType.GetInterfaces().First(@interface => (@interface.IsGenericType) && (@interface.GetGenericTypeDefinition() == typeof(IControlledEntity <>)))) != null) && (((ParameterInfo)item.Member).ParameterType == implementation.GetProperty("Key").PropertyType) && ((indexOf = index) != -1)) .FirstOrDefault(); if ((indexOf <= 1) || ((indexOf > 1) && (!(this[indexOf - 1].Member is MethodInfo)))) { return; } this[indexOf] = this[indexOf - 1]; this[indexOf - 1] = identifierSegment; }
private Row ConvertToRow <T>(T entity, int rowIndex, Dictionary <string, Cell> cellMapping) { if (entity == null) { throw new ArgumentException("Please confirm whether curren entity is null!"); } Row row = new Row() { RowIndex = (uint)rowIndex }; Type type = entity.GetType(); PropertyInfo[] properties = type.GetProperties(); foreach (PropertyInfo property in properties) { object[] attrs = property.GetCustomAttributes(typeof(MappingAttribute), true); if (attrs == null || attrs.Length <= 0) { continue; } MappingAttribute attr = (MappingAttribute)attrs[0]; object value = property.FastGetValue(entity); if (value == null) { value = string.Empty; } string cellAddress = GetCellAddressByMapping(rowIndex, attr, cellMapping); Cell resultCell = row.CreateCell(cellAddress); resultCell.SetCellText(value); SetStyleIndexByCellFormatOption(resultCell, value, cellFormatOption, attr); } return(row); }
private static Property GetGroupingProperty(TypeInfo modelType, MappingAttribute attribData) { var propertyName = attribData?.GroupBy; if (string.IsNullOrWhiteSpace(propertyName)) { return(null); } var propData = modelType.GetProperty(propertyName); if (propData == null) { return(null); } var propAttrib = propData.GetCustomAttribute <MappingAttribute>(); var property = new Property { PropertyName = propData.Name, ColumnName = propAttrib?.ColumnName ?? propData.Name, PropertyInfo = propData, UnderlyingType = propData.GetActualType() }; property.UnderlyingTypeInfo = property.UnderlyingType.GetTypeInfo(); property.Mapper = property.UnderlyingTypeInfo.GetPropertyMapper(); return(property); }
private string GetDbType(Type type, MappingAttribute attribute) { int length = attribute.Length == 0 ? 255 : attribute.Length; if (type == typeof(string)) { return(string.Format("VARCHAR({0})", length)); } if (type == typeof(int)) { return("INT"); } if (type == typeof(bool)) { return("SMALLINT(6)"); } if (type == typeof(long)) { return("BIGINT(20)"); } if (type == typeof(Guid)) { return("CHAR(36)"); } if (type == typeof(DateTime)) { return("DATETIME"); } return(string.Format("VARCHAR({0})", length)); }
private Dictionary <string, Cell> GetHeaderCellMapping(Type type) { Dictionary <string, Cell> results = new Dictionary <string, Cell>(); var sharedTablePart = document.GetSharedStringTable(); var headerCell = worksheet.GetRow(header).Elements <Cell>(); if (headerCell == null) { throw new NullReferenceException("Check that the header information exist!"); } PropertyInfo[] properties = type.GetProperties(); foreach (PropertyInfo property in properties) { foreach (Cell cell in headerCell) { object[] attrs = property.GetCustomAttributes(typeof(MappingAttribute), true); if (attrs == null || attrs.Length <= 0) { continue; } MappingAttribute attr = (MappingAttribute)attrs[0]; if (attr.MappingKey == worksheet.GetCellValue(cell, sharedTablePart)) { results.Add(attr.MappingKey, cell); break; } } } return(results); }
private void GenResult(ILGenerator ilGen, MappingAttribute attribute, Type returnType, int index) { var resultDto = attribute.Dto; var valueType = resultDto.IsValueType; ilGen.DeclareLocal(resultDto); ilGen.Emit(valueType ? OpCodes.Unbox_Any : OpCodes.Castclass, attribute.Dto); ilGen.Emit(OpCodes.Stloc_1); ilGen.Emit(OpCodes.Ldsfld, typeof(MethodInformation).GetFields()[0]); ilGen.Emit(OpCodes.Ldc_I4_S, index); ilGen.Emit(OpCodes.Callvirt, typeof(List <Delegate>).GetMethod("get_Item")); ilGen.Emit(OpCodes.Ldc_I4_1); ilGen.Emit(OpCodes.Newarr, typeof(object)); ilGen.Emit(OpCodes.Dup); ilGen.Emit(OpCodes.Ldc_I4_0); ilGen.Emit(OpCodes.Ldloc_1); if (valueType) { ilGen.Emit(OpCodes.Box, resultDto); } ilGen.Emit(OpCodes.Stelem_Ref); ilGen.Emit(OpCodes.Callvirt, typeof(Delegate).GetMethod("DynamicInvoke")); ilGen.Emit(OpCodes.Castclass, returnType); }
private static void GenResult(ILGenerator ilGen, MappingAttribute mappingAttribute) { var property = mappingAttribute.Dto; if (!property.IsValueType) { ilGen.Emit(OpCodes.Castclass, mappingAttribute.Dto); } var propertyNames = mappingAttribute.Path.Split('.').Where(s => !s.Equals("")).ToArray(); for (var i = 0; i < propertyNames.Length; ++i) { var propertyName = propertyNames[i]; if (property.IsValueType) { ilGen.DeclareLocal(property); if (i == 0) { ilGen.Emit(OpCodes.Unbox_Any, property); } ilGen.Emit(OpCodes.Stloc, i + 1); ilGen.Emit(OpCodes.Ldloca_S, i + 1); } var aux = property?.GetProperty(propertyName); ilGen.Emit(OpCodes.Call, aux?.GetGetMethod()); property = aux?.PropertyType; } }
public PropertyMapper(PropertyInfo propertyInfo, MappingAttribute mappingAttribute) { if (propertyInfo == null) { throw new MappingException("PropertyMapping must contain the PropertyInfo or else it cant map the property"); } if (mappingAttribute == null) { throw new MappingException("A PropertyMapping must have a mapping attribute specified"); } Info = propertyInfo; MappingInfo = mappingAttribute; _mapper = new Mapper(); if (mappingAttribute.Mapping == MappingType.Relationship && mappingAttribute.ToSingle == false) { ListElementType = Info.PropertyType.GetGenericArguments().FirstOrDefault(); Type genericListType = typeof(List <>); GeneratedListType = genericListType.MakeGenericType(new[] { ListElementType }); AddMethod = GeneratedListType.GetMethod(AddMethodName); } }
public MethodInformation ProcessMethod(MethodInfo method) { MappingAttribute mappingAttribute = null; GetAttribute getAttribute = null; IList <Type> args = method.GetParameters().Select(arg => arg.ParameterType).ToList(); foreach (var attr in method.GetCustomAttributes <Attribute>()) { switch (attr) { case MappingAttribute ma: mappingAttribute = ma; break; case GetAttribute ga: getAttribute = ga; break; } } var info = new MethodInformation { Name = method.Name, ReturnType = method.ReturnType, Args = args }; if (mappingAttribute != null) { info.Mapping = mappingAttribute; } if (getAttribute != null) { info.Get = getAttribute; } info.MethodAttrs = method.Attributes; return(info); }
protected virtual XElement VisitMemberAccess(MemberExpression member) { if (member.Expression != null && member.Expression.NodeType == ExpressionType.Constant) { LambdaExpression lambda = Expression.Lambda(member); Delegate fn = lambda.Compile(); return(VisitConstant(Expression.Constant(fn.DynamicInvoke(null), member.Type))); } else { CurrentMember = member.Member; if (member.Member.DeclaringType == typeof(DateTime) || member.Member.DeclaringType == typeof(Nullable <DateTime>)) { switch (member.Member.Name) { case "Now": case "Today": return(new XElement("Value", new XAttribute("Type", "DateTime"), new XElement("Today"))); default: LambdaExpression lambda = Expression.Lambda(member); Delegate fn = lambda.Compile(); return(VisitConstant(Expression.Constant(fn.DynamicInvoke(null), member.Type))); } } else if (member.Expression is MemberExpression) { try { MappingAttribute currentMappingAttribute = ((MappingAttribute)MappingAttribute.GetMappingAttribute(((MemberExpression)member.Expression).Member)); if (currentMappingAttribute.TypeAsText == "Lookup") { CurrentMember = (member.Expression as MemberExpression).Member; if (member.Member.Name == "Id") { return(new XElement("FieldRef", new XAttribute("Name", CurrentMembersMappingAttribute.ColumnName), new XAttribute("LookupId", "TRUE"))); } else { return(new XElement("FieldRef", new XAttribute("Name", CurrentMembersMappingAttribute.ColumnName))); } } } catch (PropertyNotMappedException) { if ((member.Expression as MemberExpression).Member.Name != QueryParameter.Name) { LambdaExpression lambda = Expression.Lambda(member); Delegate fn = lambda.Compile(); return(VisitConstant(Expression.Constant(fn.DynamicInvoke(null), member.Type))); } } //Get parent member as current member is primitive } return(new XElement("FieldRef", new XAttribute("Name", CurrentMembersMappingAttribute.ColumnName))); } }
/// <summary> /// 获取泛型类中指定属性值 /// </summary> /// <returns></returns> public static string GetFullTypeName(this Type type) { object[] attrList = type.GetCustomAttributes(typeof(MappingAttribute), false); if (attrList != null) { MappingAttribute categoryInfo = (MappingAttribute)attrList[0]; return(categoryInfo.FullTypeName); } return(""); }
internal void Add(string part, MappingAttribute source, ICustomAttributeProvider member, bool hasDefaultValue = false) { part = (_isRegexMode ? ((source is FromQueryStringAttribute) ? part.Replace("=[^&]+", String.Empty) : part) : part).Trim('/'); if (part.Length == 0) { return; } (source is FromQueryStringAttribute ? (UriTemplatePartList)_queryString : _segments).Add(part, source, member, hasDefaultValue); }
private string GetTableName(Type type) { MappingAttribute table = GetEntityAttribute <MappingAttribute>(type); string tableName = type.Name; if (table != null) { tableName = table.Name; } return(tableName); }
private T ConvertToGeneric <T>(int rowIndex, SharedStringTablePart sharedTablePart, Dictionary <string, Cell> cellMapping, ConstructorInfo constructorInfo) { T target = (T)constructorInfo.Invoke(null); Type type = target.GetType(); PropertyInfo[] properties = type.GetProperties(); foreach (PropertyInfo property in properties) { object[] attrs = property.GetCustomAttributes(typeof(MappingAttribute), true); MappingAttribute attr = (MappingAttribute)attrs[0]; string cellValue = GetCellValueWithMapping(rowIndex, attr, cellMapping, sharedTablePart); object propertyValue = ParserFromString(property.PropertyType, cellValue); } return(target); }
private static List <PropertyMappingInfo> LoadPropertyMappingInfo(Type objType) { List <PropertyMappingInfo> mapInfoList = new List <PropertyMappingInfo>(); foreach (PropertyInfo info in objType.GetProperties()) { MappingAttribute mapAttr = (MappingAttribute)Attribute.GetCustomAttribute(info, typeof(MappingAttribute)); if (mapAttr == null && (System.Type.GetTypeCode(info.PropertyType) != TypeCode.Object || info.PropertyType == new System.TimeSpan().GetType())) { //mapAttr = new MappingAttribute(string.Concat(info.Name, ",un-insert,un-update")); mapAttr = new MappingAttribute(info.Name); } if (mapAttr != null) { PropertyMappingInfo mapInfo = new PropertyMappingInfo(mapAttr.DataFieldName, mapAttr.NullValue, info); mapInfoList.Add(mapInfo); } } return(mapInfoList); }
public object Request(params object[] args) { StackTrace stackTrace = new StackTrace(); MethodInfo callSite = (MethodInfo)stackTrace.GetFrame(1).GetMethod(); /* * The callsite is the caller method. */ //Get the path GetAttribute get = (GetAttribute)callSite.GetCustomAttribute(typeof(GetAttribute)); String path = get.path; //Replace the variables in the string with their values int i = 0; foreach (ParameterInfo param in callSite.GetParameters()) { path = path.Replace("{" + param.Name + "}", args[i++].ToString()); } //Get The Map Attribute MappingAttribute map = (MappingAttribute)callSite.GetCustomAttribute(typeof(MappingAttribute)); //Get the object path String[] paths = map.path.Split('.'); //http request object objToReturn = req.Get(path, map.dest); //Return the desired object based on path for (int j = 1; j < paths.Length; j++) { PropertyInfo pi = objToReturn.GetType().GetProperty(paths[j]); objToReturn = pi.GetValue(objToReturn); } return(objToReturn); }
private string GetCellAddressByMapping(int rowIndex, MappingAttribute attribute, Dictionary <string, Cell> cellMapping) { int cellIndex = 1; string cellAddress = string.Empty; switch (attribute.MappingOption) { case MappingOption.FieldName: cellIndex = cellMapping[attribute.MappingKey].GetCellIndex(); cellAddress = SpreadsheetExtender.ToCellAddress(rowIndex, cellIndex); break; case MappingOption.ColumnName: cellAddress = attribute.MappingKey + rowIndex; break; case MappingOption.ColumnIndex: cellAddress = SpreadsheetExtender.ToCellAddress(rowIndex, int.Parse(attribute.MappingKey)); break; } return(cellAddress); }
private string GetMethodUrl(string method, object[] objParams) { string methodUrl = ""; MemberInfo[] arr = typeof(T).GetMethods(); for (int i = 0; i < arr.Length; i++) { if (arr[i].Name.Equals(method)) { MappingAttribute mapUrl = (MappingAttribute)arr[i].GetCustomAttributes(typeof(MappingAttribute), false)[0]; methodUrl = mapUrl.MethodUrl; break; } } for (int i = 0; i < objParams.Length; i++) { methodUrl = methodUrl.Replace("{" + i + "}", objParams[i].ToString()); } return(methodUrl); }
public TEntity Load <TEntity>(object id) where TEntity : new() { if (id is SqlPredicate) { throw new ArgumentException("Entity id was expected but SqlPredicate found. You probably wanted to use Load<TEntity>(QueryBuilder.Create().SetWhereStatement(sqlPredicate))."); } MappingAttribute identityMapping = FindIdentity <TEntity>(); if (identityMapping == null) { throw new Exception(string.Format("Entity {0} has no primary key defined.", typeof(TEntity).Name)); } var results = Load <TEntity>(QueryBuilder.Create().SetWhereStatement(QB.Eq(identityMapping.Name, id))); if (results.Count > 1) { throw new Exception(string.Format("There is more than one record with id {0} of entity {1}.", id, typeof(TEntity).Name)); } return(results.FirstOrDefault()); }
private static void GenResult(ILGenerator ilGen, MappingAttribute mappingAttribute, Type returnType) { var resultDto = mappingAttribute.Dto; if (mappingAttribute.With != null) //MODE WITH { var resultWith = mappingAttribute.With; var funcType = typeof(Func <object>); ilGen.Emit(OpCodes.Ldftn, resultDto.GetMethod(resultWith)); ilGen.Emit(OpCodes.Newobj, funcType.GetConstructors()[0]); ilGen.Emit(OpCodes.Callvirt, funcType.GetMethod("Invoke")); ilGen.Emit(OpCodes.Castclass, returnType); } else //MODE PATH { if (!resultDto.IsValueType) { ilGen.Emit(OpCodes.Castclass, mappingAttribute.Dto); } var propertyNames = mappingAttribute.Path.Split('.').Where(s => s.Length > 0).ToList(); for (var i = 0; i < propertyNames.Count; ++i) { var propertyName = propertyNames[i]; if (resultDto.IsValueType) { ilGen.DeclareLocal(resultDto); if (i == 0) { ilGen.Emit(OpCodes.Unbox_Any, resultDto); } ilGen.Emit(OpCodes.Stloc, i + 1); ilGen.Emit(OpCodes.Ldloca_S, i + 1); } var aux = resultDto?.GetProperty(propertyName); ilGen.Emit(OpCodes.Call, aux?.GetGetMethod()); resultDto = aux?.PropertyType; } } }
private static void SetPropertyFromCell(object entity, string columnName, object cellValue) { if (entity == null) { throw new ArgumentNullException("entity"); } var properties = entity.GetType().GetRuntimeProperties(); foreach (var property in properties) { MappingAttribute attribute = property.GetCustomAttributes(typeof(MappingAttribute), true).Cast <MappingAttribute>().FirstOrDefault(); if (attribute == null) { continue; } if (attribute.Name == columnName) { if (property.PropertyType == typeof(bool) && cellValue is short) { cellValue = (short)cellValue != 0; } if (property.PropertyType == typeof(bool) && cellValue is int) { cellValue = (int)cellValue != 0; } if (property.PropertyType == typeof(bool) && cellValue is long) { cellValue = (long)cellValue != 0; } if (cellValue == DBNull.Value) { cellValue = null; } property.SetValue(entity, cellValue, null); } } }
private string GetCellValueWithMapping(int rowIndex, MappingAttribute attribute, Dictionary <string, Cell> cellMapping, SharedStringTablePart sharedTablePart) { string cellValue = string.Empty; switch (attribute.MappingOption) { case MappingOption.FieldName: Cell cell = cellMapping[attribute.MappingKey]; int cellIndex = cell.GetCellIndex(); cellValue = worksheet.GetCellValue(rowIndex, cellIndex, sharedTablePart); break; case MappingOption.ColumnName: cellValue = worksheet.GetCellValue(attribute.MappingKey + rowIndex.ToString(), sharedTablePart); break; case MappingOption.ColumnIndex: cellValue = worksheet.GetCellValue(rowIndex, int.Parse(attribute.MappingKey), sharedTablePart); break; } return(cellValue); }
public override DbCommand GetInsertCommand(object entity) { MappingAttribute typeAttribute = entity.GetType().GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (typeAttribute == null) { throw new Exception(string.Format("Nazwa tabeli nie została określona dla typu {0}.", entity.GetType().Name)); } MySqlCommand command = Connection.CreateCommand() as MySqlCommand; StringBuilder sb = new StringBuilder(); sb.Append("INSERT INTO "); sb.Append(typeAttribute.Name); sb.Append(" ("); bool first = true; var properties = entity.GetType().GetOrderedProperties().ToList(); foreach (var property in properties) { if (property.GetValue(entity) == null) { continue; } MappingAttribute attribute = property.GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (attribute == null) { continue; } if (attribute.IsSpecialColumn) { continue; } if (!first) { sb.Append(", "); } sb.Append(string.Format("{0}", attribute.Name)); first = false; } sb.Append(") VALUES ("); first = true; int parameter = 0; foreach (var property in properties) { if (property.GetValue(entity) == null) { continue; } MappingAttribute attribute = property.GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (attribute == null) { continue; } if (attribute.IsSpecialColumn) { continue; } if (!first) { sb.Append(", "); } sb.Append(string.Format("@P{0}", parameter)); command.Parameters.Add(string.Format("@P{0}", parameter), property.GetValue(entity)); first = false; parameter++; } sb.Append(")"); command.CommandText = sb.ToString(); return(command); }
public override DbCommand GetUpdateCommand(object entity) { MappingAttribute typeAttribute = entity.GetType().GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (typeAttribute == null) { throw new Exception(string.Format("Nazwa tabeli nie została określona dla typu {0}.", entity.GetType().Name)); } MySqlCommand command = Connection.CreateCommand() as MySqlCommand; StringBuilder sb = new StringBuilder(); sb.Append("UPDATE "); sb.Append(typeAttribute.Name); sb.Append(" SET "); bool first = true; PropertyInfo idProperty = null; int parameter = 0; foreach (var property in entity.GetType().GetOrderedProperties()) { if (property.GetValue(entity) == null) { continue; } MappingAttribute attribute = property.GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (attribute == null) { continue; } if (attribute.IsSpecialColumn) { continue; } if (attribute.IsPrimaryKey) { idProperty = property; continue; } if (!first) { sb.Append(", "); } sb.Append(string.Format("{0} = @P{1}", attribute.Name, parameter)); command.Parameters.Add(string.Format("@P{0}", parameter), property.GetValue(entity)); first = false; parameter++; } if (idProperty == null) { throw new Exception("Brak kolumny id."); } MappingAttribute idAttribute = idProperty.GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; sb.Append(string.Format(" WHERE {0}=@P{1};", idAttribute.Name, parameter)); command.Parameters.Add(string.Format("@P{0}", parameter), idProperty.GetValue(entity)); parameter++; command.CommandText = sb.ToString(); return(command); }
public override DbCommand GetUpdateSchemaCommand(Type entityType) { MappingAttribute typeAttribute = entityType.GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (typeAttribute == null) { typeAttribute = new MappingAttribute(entityType.Name); } MySqlCommand command = Connection.CreateCommand() as MySqlCommand; command.CommandText = string.Format("SELECT * FROM information_schema.tables WHERE table_schema = '{0}' AND table_name = '{1}' LIMIT 1;", Connection.Database, typeAttribute.Name); MySqlDataAdapter adapter = new MySqlDataAdapter(command); DataTable table = new DataTable(); adapter.Fill(table); bool tableExists = table.Rows.Count > 0; var properties = entityType.GetOrderedProperties().ToList(); var sb = new StringBuilder(); if (tableExists) { command = Connection.CreateCommand() as MySqlCommand; command.CommandText = string.Format("SHOW COLUMNS FROM {0}", typeAttribute.Name); adapter = new MySqlDataAdapter(command); table = new DataTable(); adapter.Fill(table); sb.AppendFormat("ALTER TABLE {0} ", typeAttribute.Name); bool first = true; bool newPropertiesExist = false; foreach (var property in properties) { MappingAttribute attribute = property.GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (attribute == null) { continue; } if (attribute.IsSpecialColumn) { continue; } if (table.Rows.Cast <DataRow>().Any(r => (string)r["Field"] == attribute.Name)) { continue; } if (!first) { sb.Append(","); } newPropertiesExist = true; sb.AppendFormat(" ADD COLUMN {0} {1}", attribute.Name, GetDbType(property.PropertyType, attribute)); first = false; } if (!newPropertiesExist) { return(null); } } else { sb.AppendFormat("CREATE TABLE {0} (", typeAttribute.Name); bool first = true; MappingAttribute primaryKeyAttribute = null; var foreignKeyAttributes = new List <MappingAttribute>(); foreach (var property in properties) { MappingAttribute attribute = property.GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (attribute == null) { continue; } if (attribute.IsSpecialColumn) { continue; } if (attribute.IsPrimaryKey) { primaryKeyAttribute = attribute; } if (!string.IsNullOrWhiteSpace(attribute.ForeignColumn) && !string.IsNullOrWhiteSpace(attribute.ForeignTable)) { foreignKeyAttributes.Add(attribute); } if (!first) { sb.Append(","); } sb.AppendFormat(" {0} {1} {2}", attribute.Name, GetDbType(property.PropertyType, attribute), attribute.IsPrimaryKey || attribute.IsNotNull ? "NOT NULL" : "DEFAULT NULL"); first = false; } if (primaryKeyAttribute != null) { if (!first) { sb.Append(","); } sb.AppendFormat(" PRIMARY KEY ({0}), UNIQUE KEY {0}_UNIQUE ({0})", primaryKeyAttribute.Name); } first = false; foreach (var attribute in foreignKeyAttributes) { if (!first) { sb.Append(","); } sb.AppendFormat(" KEY FK_{0}_idx ({0}), CONSTRAINT FK_{0} FOREIGN KEY ({0}) REFERENCES {1} ({2}) ON DELETE NO ACTION ON UPDATE NO ACTION", attribute.Name, attribute.ForeignTable, attribute.ForeignColumn); } sb.Append(") ENGINE=InnoDB DEFAULT CHARSET=utf8;"); } command = Connection.CreateCommand() as MySqlCommand; command.CommandText = sb.ToString(); return(command); }
private void SetStyleIndexByCellFormatOption(Cell cell, object value, CellFormatOption option, MappingAttribute attribute) { int styleIndex = 0; switch (cellFormatOption) { case CellFormatOption.KeepStyle: break; case CellFormatOption.OverWrite: styleIndex = SpreadsheetExtender.GetCellStyleIndex(styleSheet, value); cell.SetCellStyle(styleIndex); break; case CellFormatOption.ReferenceStyle: if (string.IsNullOrEmpty(attribute.ReferenceStyle)) { styleIndex = SpreadsheetExtender.GetCellStyleIndex(styleSheet, value); } else { Cell refCell = SpreadsheetExtender.GetCell(worksheet, attribute.ReferenceStyle); if (refCell == null) { throw new ArgumentException("Please confirm the cell to reference is not null!"); } if (refCell.StyleIndex == null || (refCell.StyleIndex != null && !refCell.StyleIndex.HasValue)) { styleIndex = SpreadsheetExtender.GetCellStyleIndex(styleSheet, value); } else { styleIndex = int.Parse(refCell.StyleIndex.ToString()); } cell.SetCellStyle(styleIndex); } break; } }
public override DbCommand GetSelectCommand <TEntity>(QueryBuilder builder) { int parameterCounter = 0; MappingAttribute typeAttribute = typeof(TEntity).GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (typeAttribute == null) { throw new Exception(string.Format("Nazwa tabeli nie została określona dla typu {0}.", typeof(TEntity).Name)); } StringBuilder sb = new StringBuilder(); sb.Append("SELECT "); bool first = true; //Jeśli kolumny nie są wyspecyfikowane, dodaj na podstawie propertiesów: if (!builder.AreColumnsSpecified) { foreach (PropertyInfo property in typeof(TEntity).GetOrderedProperties()) { MappingAttribute attribute = property.GetCustomAttributes(typeof(MappingAttribute), true).FirstOrDefault() as MappingAttribute; if (attribute == null) { continue; } if (attribute.IsSpecialColumn) { continue; //Ta kolumna będzie dodana przez klasę SpecialColumn } if (!first) { sb.Append(", "); } sb.Append(string.Format("{0}", attribute.Name)); first = false; } } else { if (!builder.SpecialColumns.Any() && !builder.Columns.Any()) { sb.Append("*"); //Nie ma żadnych kolumn, ale programista użył SpecifyColumns. Dodaj gwiazdkę. } else { sb.Append(string.Join(", ", builder.Columns)); //Kolumny są wyspecyfikowane } } foreach (SpecialColumn specialColumn in builder.SpecialColumns) { if (!first) { sb.Append(", "); } sb.Append(string.Format("{0} AS {1}", specialColumn.GetColumnStatement(), specialColumn.Alias)); first = false; } sb.Append(string.Format(" FROM {0}", typeAttribute.Name)); if (builder.WhereStatement != null) { string sql = builder.WhereStatement.GetSql(ref parameterCounter); if (!Extensions.IsNullOrWhiteSpaceOrEmptyParentheses(sql)) { sb.Append(" WHERE "); sb.Append(sql); } } if (builder.SortModes.Count > 0) { sb.Append(" ORDER BY "); sb.Append(string.Join(", ", builder.SortModes.Select(sm => sm.GetOrderByStatement()))); } if (builder.Limit > 0) { sb.Append(" LIMIT "); if (builder.Offset > 0) { sb.Append(string.Format(" {0},", builder.Offset)); } sb.Append(string.Format(" {0}", builder.Limit)); } DbCommand command = Connection.CreateCommand(); command.CommandText = sb.ToString(); if (builder.WhereStatement != null) { int paramNumber = 0; foreach (var parameter in builder.WhereStatement.GetParameterValues()) { command.Parameters.Add(new MySqlParameter(string.Format("@P{0}", paramNumber), parameter)); paramNumber++; } } return(command); }
public ItemMapper(PropertyInfo property, MappingAttribute attribute) { _property = property; _attribute = attribute; }
internal virtual void Add(string part, MappingAttribute source, ICustomAttributeProvider member, bool hasDefaultValue = false) { Add(new UriTemplatePart(part, source, member, hasDefaultValue)); }