private void Mapping(Action<KeyManyToOnePart> mappingDefinition)
{
var classMap = new ClassMap<ExampleClass>();
var map = classMap.CompositeId()
.KeyProperty(x => x.Id)
.KeyReference(x => x.Parent, mappingDefinition);
mapping = classMap;
}
/// <summary>
/// Creates a new <see cref="T:TypeMap" /> with the specified <see cref="T:Type" /> and <see cref="T:IMappingProvider" />.
/// </summary>
/// <param name="t"><see cref="T:Type" /> of object to map.</param>
/// <param name="provider"><see cref="T:IMappingProvider" /> to use for creating a <see cref="T:TypeMap" /></param>
public TypeMap( Type t, IMappingProvider provider )
{
this.m_fields = new List<FieldMap>();
this.m_children = new List<PersistentFieldMap>();
this.m_referenced = new List<FieldMap>();
this.m_foreignkeys = new List<FieldMap>();
this.Warnings = new List<string>();
this.Type = t;
this.NamingConvention = ConventionTable.Instance.NamingConvention;
provider.MapByType( t, this );
}
public DatabaseFactory(IConnectionStringProvider connectionStringProvider, IMappingProvider mappingProvider)
{
DatabaseFactoryConfigOptions options = new DatabaseFactoryConfigOptions();
var connectionString = connectionStringProvider.GetConnectionString();
var mappings = mappingProvider.GetMappings();
options.Database = () => new LoggingDatabase(connectionString);
options.PocoDataFactory = FluentMappingConfiguration.Configure(mappings);
databaseFactory = new NPoco.DatabaseFactory(options);
}
/// <summary>
/// Instantiates PersistentPackage to be used for persistence operations.
/// <remarks>This is useful when you have a sub class instantiated and want to deserialize or serialize it's base.</remarks>
/// </summary>
/// <param name="o"><see cref="T:Object"/> marked with <see cref="T:Ikarii.Lib.Data.Alpaca.PersistentAttribute"/>.</param>
/// <param name="t"><see cref="T:Type"/> marked with <see cref="T:Ikarii.Lib.Data.Alpaca.PersistentAttribute"/>.</param>
/// <param name="parent">Parent <see cref="T:ObjectTypeMap"/> which will be used in operations where the ForeignKey of this object is needed.</param>
/// <param name="mappingProvider">The <see cref="T:IMappingProvider"/> used to create the <see cref="T:PersistentObject"/>.</param>
internal ObjectPackage( object o, Type t, TypeMap parent, IMappingProvider mappingProvider )
{
this.MappingProvider = mappingProvider;
this.ParentMap = parent;
this.Instance = o;
if ( TypeCache.ContainsType( t ) )
{
this.Map = TypeCache.GetType( t );
}
else
{
this.Map = new TypeMap( t, mappingProvider );
TypeCache.AddType( t, this.Map );
}
}
public CourseService(
IRepository <Course> courses,
IRepository <StudentCourse> studentCourses,
IMappingProvider mapper,
ISaver saver)
{
Guard.WhenArgument(courses, "Courses can not be null!").IsNull().Throw();
Guard.WhenArgument(studentCourses, "StudentCourses can not be null!").IsNull().Throw();
Guard.WhenArgument(mapper, "Mapper can not be null!").IsNull().Throw();
Guard.WhenArgument(saver, "Saver can not be null!").IsNull().Throw();
this.courses = courses;
this.studentCourses = studentCourses;
this.mapper = mapper;
this.saver = saver;
}
public override SelectionResult SelectCollection(IDbHelper db, IMappingProvider mappingProvider, IDictionary <object, string> tableMapping, IQueryExpression queryExpression)
{
//检查pageSize和pageIndex是否合法
Util.CheckPageSizeAndPageIndex(queryExpression.PageSize, queryExpression.PageIndex);
SqlAnalyseResult sqlAnalyseResult = SqlAnalyzer.Analyse(mappingProvider, queryExpression);
StringBuilder sb = new StringBuilder();
IDbCommand cmd = db.Connection.CreateCommand();
int counter = 1;
GenerateSelectSql_SelectFromWhereOrder(sb, cmd.Parameters, ref counter, queryExpression, sqlAnalyseResult, mappingProvider, tableMapping);
//执行sql
cmd.CommandText = sb.ToString();
cmd.CommandType = CommandType.Text;
if (queryExpression.PageIndex != null && queryExpression.PageSize != null)
{
//分页的时候需要包装分页语句
WrapPaging(db, cmd, queryExpression.PageSize.Value, queryExpression.PageIndex.Value);
}
SelectionResult result = new SelectionResult();
result.ObjectFiller = sqlAnalyseResult.ObjectFiller;
//先关闭datarader
if (queryExpression.ReturnMatchedCount)
{
if (sqlAnalyseResult.HasGroup)
{
result.TotalMatchedCount = SelectCountGroup(db, mappingProvider, tableMapping, queryExpression.EntityType, queryExpression, sqlAnalyseResult);
}
else
{
result.TotalMatchedCount = SelectCount(db, mappingProvider, tableMapping, queryExpression.EntityType, queryExpression.Wheres);
}
}
result.DataReader = db.ExecuteReader(cmd);
return(result);
}
/// <summary>
/// 收集queryExpression中所有用的到属性名
/// </summary>
/// <param name="mappingProvider"></param>
/// <param name="queryExpression"></param>
/// <returns></returns>
public static SqlAnalyseResult Analyse(IMappingProvider mappingProvider, IQueryExpression queryExpression)
{
//使用sorted是为了判断gethashcode时是否缓存中已经存在
//在分析时taskPropertyNames只是判断是否要输出，是否有合计函数
SortedDictionary <IPropertyExpression, string> taskPropertyNames = new SortedDictionary <IPropertyExpression, string>();
//必须先分析输出部分，因为输出部分包含是否要填充的信息
CollectPropertyNames(taskPropertyNames, queryExpression.Selects);
CollectPropertyNames(taskPropertyNames, queryExpression.Wheres);
CollectPropertyNames(taskPropertyNames, queryExpression.OrderBys);
CollectPropertyNames(taskPropertyNames, queryExpression.Havings);
CollectPropertyNames(taskPropertyNames, queryExpression.GroupBys);
return(Analyse(mappingProvider, queryExpression.EntityType, taskPropertyNames));
}
private void Mapping(Action <DynamicComponentPart <IDictionary> > mappingDefinition)
{
var classMap = new ClassMap <PropertyTarget>();
classMap.Id(x => x.Id);
var map = classMap.DynamicComponent(x => x.ExtensionData, m =>
{
m.Map(x => (string)x["Name"]);
m.Map(x => (int)x["Age"]);
m.Map(x => (string)x["Profession"]);
});
mappingDefinition(map);
mapping = classMap;
mappingType = typeof(PropertyTarget);
}
public UserServices(
IRepository <User> userRepo,
IMappingProvider mappingProvider,
IMemoryCache cache,
IRepository <Currency> currencyRepo,
IRepository <Balance> balanceRepo,
IRepository <UserBankDetails> userBankDetailsRepo,
IRepository <BalanceType> balanceTypeRepo)
{
this.balanceTypeRepo = balanceTypeRepo;
this.mappingProvider = mappingProvider;
this.userRepo = userRepo;
this.currencyRepo = currencyRepo;
this.balanceRepo = balanceRepo;
this.cache = cache;
this.userBankDetailsRepo = userBankDetailsRepo;
}
public void ThrowArgumentNullException_WithMessageContainingMappingProvider_WhenMappingProviderIsNull()
{
// Arrange
var mockedTripService = new Mock <ITripService>();
var mockedTagService = new Mock <ITagService>();
var mockedCarService = new Mock <ICarService>();
IMappingProvider mappingProvider = null;
// Act and Assert
Assert.That(
() => new TripController(
mockedTripService.Object,
mockedTagService.Object,
mockedCarService.Object,
mappingProvider),
Throws.ArgumentNullException.With.Message.Contain(nameof(mappingProvider)));
}
public void ThrowsArgumentNullException_WhenMapper_IsNull()
{
// Arrange
var tracksServiceFake = new Mock <ITracksService>();
var challengesServiceFake = new Mock <IChallengesService>();
IMappingProvider mapper = null;
var fileSystemFake = new Mock <IFileSystemService>();
var fileUtilsFake = new Mock <IFileUnits>();
// Act & Assert
Assert.Throws <ArgumentNullException>(() => new ChallengeController(
tracksServiceFake.Object,
challengesServiceFake.Object,
fileSystemFake.Object,
mapper,
fileUtilsFake.Object));
}
public override int Delete(IDbHelper db, IMappingProvider mappingProvider, IDictionary <object, string> tableMapping, object entityType, ICondition condition)
{
//ITable table=getTables().getTableByClass(clazz);
IQueryExpression queryExpression = new QueryExpression();
queryExpression.EntityType = entityType;
queryExpression.Wheres.Add(condition);
SqlAnalyseResult sqlAnalyseResult = SqlAnalyzer.Analyse(mappingProvider, queryExpression);
//执行关联删除
var sb = new StringBuilder();
var command = db.Connection.CreateCommand();
int parameterCounter = 1;
sb.Append("delete ");
sb.Append(sqlAnalyseResult.MasterTableNameAlias);
sb.Append(" from ");
sb.Append(GetTableName(entityType, mappingProvider, tableMapping));
sb.Append(" ");
sb.Append(sqlAnalyseResult.MasterTableNameAlias);
if (sqlAnalyseResult.ForeignTables.Count == 0)
{
//说明是无关联表的条件，只是本表的条件
sb.Append(" where ");
GenerateSelectSql_Where(sb, command.Parameters, ref parameterCounter, queryExpression.Wheres, sqlAnalyseResult, true, mappingProvider);
}
else
{
//说明有关联表的条件，需要多表关联
sb.Append(" where exists (");
SqlServerCreateSqlExists(sb, command.Parameters, ref parameterCounter, queryExpression.Wheres, sqlAnalyseResult, mappingProvider, tableMapping);
sb.Append(")");
}
//执行sql
command.CommandText = sb.ToString();
command.CommandType = CommandType.Text;
int returnCount = db.ExecuteNonQuery(command);
return(returnCount);
}
public UserTestsService(IMappingProvider mapper,
IDateTimeProvider dateTime,
ITestService testService,
ICategoriesService categoriesService,
IUserTestAnswersService utaService,
IRepository <UserTests> userTests,
IGenericShuffler shuffler,
ISaver saver)
{
this.mapper = mapper;
this.dateTime = dateTime;
this.testService = testService;
this.categoriesService = categoriesService;
this.utaService = utaService;
this.userTests = userTests;
this.shuffler = shuffler;
this.saver = saver;
}
public TwitterService(
IApiProvider apiProvider,
IJsonProvider jsonProvider,
IMappingProvider mapper
)
{
this.apiProvider = apiProvider
??
throw new ArgumentNullException(nameof(apiProvider));
this.jsonProvider = jsonProvider
??
throw new ArgumentNullException(nameof(jsonProvider));
this.mapper = mapper
??
throw new ArgumentNullException(nameof(mapper));
this.baseUrl = "https://api.twitter.com/1.1/";
}
public TweetsController(
ITwitterService twitterService,
ITwitterUserService twitterUserService,
IFavouriteUserService favouriteUserService,
ITweetService tweetService,
IMappingProvider mapper,
UserManager <User> userManager,
IMemoryCache memoryCache
)
{
this.tweetService = tweetService ?? throw new ArgumentNullException(nameof(tweetService));
this.twitterService = twitterService ?? throw new ArgumentNullException(nameof(twitterService));
this.twitterUserService = twitterUserService ?? throw new ArgumentNullException(nameof(twitterUserService));
this.favouriteUserService = favouriteUserService ?? throw new ArgumentNullException(nameof(favouriteUserService));
this.mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
this.userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
this.memoryCache = memoryCache ?? throw new ArgumentNullException(nameof(memoryCache));
}
public TestService(IRepository <Test> testRepository,
IRepository <User> userRepository,
IRepository <Category> categoryRepository,
IRepository <Question> questionsRepository,
IRepository <Answer> answersRepository,
ICategoryService categoryService,
ISaver saver,
IMappingProvider mapper)
{
this.testRepository = testRepository;
this.userRepository = userRepository;
this.categoryRepository = categoryRepository;
this.questionsRepository = questionsRepository;
this.answersRepository = answersRepository;
this.categoryService = categoryService;
this.saver = saver;
this.mapper = mapper;
}
public CoursesController(
ICourseService courseService,
IStudentService studentService,
IStudentCourseService studentCourseService,
IMappingProvider mapper,
UserManager <Student> userManager)
{
Guard.WhenArgument(courseService, "Course Service can not be null!").IsNull().Throw();
Guard.WhenArgument(studentService, "Student Service can not be null!").IsNull().Throw();
Guard.WhenArgument(studentCourseService, "StudentCourse Service can not be null!").IsNull().Throw();
Guard.WhenArgument(mapper, "Mapper can not be null!").IsNull().Throw();
Guard.WhenArgument(userManager, "User Manager").IsNull().Throw();
this.courseService = courseService;
this.studentService = studentService;
this.studentCourseService = studentCourseService;
this.mapper = mapper;
this.userManager = userManager;
}
public ChallengeController(
ITracksService tracks,
IChallengesService challenges,
IFileSystemService fileSystem,
IMappingProvider mapper,
IFileUnits fileUtils)
{
Guard.WhenArgument(tracks, nameof(tracks)).IsNull().Throw();
Guard.WhenArgument(mapper, nameof(mapper)).IsNull().Throw();
Guard.WhenArgument(challenges, nameof(challenges)).IsNull().Throw();
Guard.WhenArgument(fileSystem, nameof(fileSystem)).IsNull().Throw();
Guard.WhenArgument(fileUtils, nameof(fileUtils)).IsNull().Throw();
this.tracks = tracks;
this.mapper = mapper;
this.challenges = challenges;
this.fileSystem = fileSystem;
this.fileUtils = fileUtils;
}
/// <summary>
/// Constructor with DI support
/// </summary>
/// <param name="logger">The logger interface</param>
/// <param name="mappingProvider">The mapping provider interface</param>
/// <param name="targetPageUriResolver">The target page uri resolver</param>
/// <param name="pagePreTransformations">The list of post transformations to call</param>
/// <param name="pagePostTransformations">The list of pre transformations to call</param>
/// <param name="pageTransformationOptions">The options</param>
/// <param name="pageGenerator">The page generator to create the actual SPO modern page</param>
/// <param name="telemetry">The telemetry service</param>
public DefaultPageTransformator(
ILogger <DefaultPageTransformator> logger,
IMappingProvider mappingProvider,
ITargetPageUriResolver targetPageUriResolver,
IEnumerable <IPagePreTransformation> pagePreTransformations,
IEnumerable <IPagePostTransformation> pagePostTransformations,
IOptions <PageTransformationOptions> pageTransformationOptions,
IPageGenerator pageGenerator,
TelemetryService telemetry)
{
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.mappingProvider = mappingProvider ?? throw new ArgumentNullException(nameof(mappingProvider));
this.targetPageUriResolver = targetPageUriResolver ?? throw new ArgumentNullException(nameof(targetPageUriResolver));
this.pagePreTransformations = pagePreTransformations ?? throw new ArgumentNullException(nameof(pagePreTransformations));
this.pagePostTransformations = pagePostTransformations ?? throw new ArgumentNullException(nameof(pagePostTransformations));
this.defaultPageTransformationOptions = pageTransformationOptions ?? throw new ArgumentNullException(nameof(pageTransformationOptions));
this.pageGenerator = pageGenerator ?? throw new ArgumentNullException(nameof(pageGenerator));
this.telemetry = telemetry ?? throw new ArgumentNullException(nameof(telemetry));
}
public SubmissionsService(
IEfRepository <Submission> submissionRepository,
IEfRepository <Challenge> challengeRepository,
IEfData efData,
ITimeProvider timeProvider,
IMappingProvider mapper)
{
Guard.WhenArgument(submissionRepository, nameof(submissionRepository)).IsNull().Throw();
Guard.WhenArgument(challengeRepository, nameof(challengeRepository)).IsNull().Throw();
Guard.WhenArgument(efData, nameof(efData)).IsNull().Throw();
Guard.WhenArgument(timeProvider, nameof(timeProvider)).IsNull().Throw();
Guard.WhenArgument(mapper, nameof(mapper)).IsNull().Throw();
this.submissionRepository = submissionRepository;
this.challengeRepository = challengeRepository;
this.efData = efData;
this.timeProvider = timeProvider;
this.mapper = mapper;
}
private void SqlServerCreateSqlExists(
StringBuilder sb, IDataParameterCollection parameters, ref int parameterCounter,
ICondition condition, SqlAnalyseResult sqlAnalyseResult, IMappingProvider mappingProvider,
IDictionary <object, string> tableMapping
)
{
int tableIndex = 0;
if (sqlAnalyseResult.ForeignTables.Count > 0)
{
sb.Append("select 1 from ");
foreach (var sqlTable in sqlAnalyseResult.ForeignTables)
{
if (tableIndex > 0)
{
sb.Append(",");
}
tableIndex++;
sb.Append(GetTableName(sqlTable.ForeignEntityType, mappingProvider, tableMapping));
sb.Append(" ");
sb.Append(sqlTable.ForeignTableNameAlias);
}
tableIndex = 0;
foreach (var sqlTable in sqlAnalyseResult.ForeignTables)
{
foreach (var sqlRelationColumn in sqlTable.RelationColumns)
{
sb.Append(tableIndex > 0 ? " and " : " where ");
tableIndex++;
sb.Append(sqlRelationColumn.Expression);
}
}
}
//condition
//if (condition.Count <= 0) return;
sb.Append(tableIndex > 0 ? " and " : " where ");
GenerateSelectSql_Where(sb, parameters, ref parameterCounter,
condition, sqlAnalyseResult, true, mappingProvider);
//order 不需要order
}
public Document BuildDocumentForMapping <T>(T item, IMappingProvider mapping)
{
var doc = new Document();
foreach (var map in mapping.Mappings)
{
//var value = map.
var value = map.Member.GetValue(item) ?? string.Empty; //handle this better?
if (map.ExpressionDelegate != null)
{
var obj = map.ExpressionDelegate.DynamicInvoke(value);
value = obj;
}
var field = new Field(map.Name, value.ToString(), map.Store, map.Index, map.TermVector);
doc.Add(field);
}
return(doc);
}
public override bool Exists(IDbHelper db, IMappingProvider mappingProvider, IDictionary <object, string> tableMapping, object entityType, ICondition condition)
{
IQueryExpression queryExpression = new QueryExpression();
queryExpression.EntityType = entityType;
queryExpression.Wheres.Add(condition);
SqlAnalyseResult sqlAnalyseResult = SqlAnalyzer.Analyse(mappingProvider, queryExpression);
StringBuilder sb = new StringBuilder();
IDbCommand command = db.Connection.CreateCommand();
int parameterCounter = 1;
sb.Append("select 0 ");
GenerateSelectSql_FromWhere(sb, command.Parameters, ref parameterCounter, queryExpression, sqlAnalyseResult, mappingProvider, tableMapping);
if (Util.HasCondition(condition))
{
sb.Append(" and ");
}
else
{
sb.Append(" where ");
}
sb.Append(" rownum<2");
//执行sql
command.CommandText = sb.ToString();
command.CommandType = CommandType.Text;
IDataReader dataReader = db.ExecuteReader(command);
bool exists = dataReader.Read();
dataReader.Close();
return(exists);
}
protected virtual IDbCommand CreateCommand(IDbHelper session, IMappingProvider mappingProvider, object commandType, IDictionary <string, object> values)
{
IStatement statement = mappingProvider.GetStatement(commandType);
IDbCommand dbCommand = session.Connection.CreateCommand();
dbCommand.CommandText = statement.CommandText;
dbCommand.CommandType = statement.CommandType;
foreach (KeyValuePair <string, IParameter> kv in statement.Parameters)
{
object peropertyValue = values[kv.Key];
IParameter parameter = kv.Value;
IDataParameter dataParameter = CreateParameter(parameter.ParameterName, peropertyValue, parameter.PropertyType, parameter.Size);
dataParameter.Direction = parameter.Direction;
dbCommand.Parameters.Add(dataParameter);
}
return(dbCommand);
}
public ChallengesService(
IEfRepository <Challenge> challengesRepository,
IEfRepository <Test> testsRepository,
IEfRepository <FileDecription> fileDescriptionRepository,
IEfRepository <Category> categoriesRepository,
IEfData efData,
IMappingProvider mapper)
{
Guard.WhenArgument(challengesRepository, nameof(challengesRepository)).IsNull().Throw();
Guard.WhenArgument(testsRepository, nameof(testsRepository)).IsNull().Throw();
Guard.WhenArgument(categoriesRepository, nameof(categoriesRepository)).IsNull().Throw();
Guard.WhenArgument(fileDescriptionRepository, nameof(fileDescriptionRepository)).IsNull().Throw();
Guard.WhenArgument(efData, nameof(efData)).IsNull().Throw();
Guard.WhenArgument(mapper, nameof(mapper)).IsNull().Throw();
this.challengesRepository = challengesRepository;
this.testsRepository = testsRepository;
this.categoriesRepository = categoriesRepository;
this.fileDescriptionRepository = fileDescriptionRepository;
this.efData = efData;
this.mapper = mapper;
}
public override int Delete(IDbHelper db, IMappingProvider mappingProvider, IDictionary <object, string> tableMapping, object entityType, ICondition condition)
{
//ITable table=getTables().getTableByClass(clazz);
IQueryExpression queryExpression = new QueryExpression();
queryExpression.EntityType = entityType;
queryExpression.Wheres.Add(condition);
SqlAnalyseResult sqlAnalyseResult = SqlAnalyzer.Analyse(mappingProvider, queryExpression);
if (sqlAnalyseResult.ForeignTables.Count > 0)
{
//不支持
throw ExceptionFactory.NotSupported("SQLite不支持多表关联更新");
}
//执行关联删除
StringBuilder sb = new StringBuilder();
IDbCommand command = db.Connection.CreateCommand();
int parameterCounter = 1;
string tableName = GetTableName(entityType, mappingProvider, tableMapping);
sb.Append("delete from ");
sb.Append(tableName);
//说明是无关联表的条件，只是本表的条件
sb.Append(" where ");
GenerateSelectSql_Where(sb, command.Parameters, ref parameterCounter, queryExpression.Wheres, sqlAnalyseResult, false, mappingProvider);
//执行sql
command.CommandText = sb.ToString();
command.CommandType = CommandType.Text;
int returnCount = db.ExecuteNonQuery(command);
return(returnCount);
}
public virtual int ExecuteNonQuery(IDbHelper db, IMappingProvider mappingProvider, object commandType, IDictionary <string, object> values)
{
IStatement statement = mappingProvider.GetStatement(commandType);
IDbCommand dbCommand = CreateCommand(db, mappingProvider, commandType, values);
int returnCount = db.ExecuteNonQuery(dbCommand);
foreach (KeyValuePair <string, IParameter> kv in statement.OutParameters)
{
IParameter parameter = kv.Value;
IDataParameter dataParameter = (IDataParameter)dbCommand.Parameters[parameter.ParameterName];
object value = ConvertDbValue(dataParameter.Value, parameter.PropertyType);
if (values.ContainsKey(kv.Key))
{
values[kv.Key] = value;
}
else
{
values.Add(kv.Key, value);
}
}
return(returnCount);
}
/// <summary>
/// 매핑이 수행되기 전에 초기화할 수 있는 작업입니다.
/// </summary>
/// <param name="sourceProvider"><see cref="IMappingProvider"/> 를 구현하는 원본 매핑 프로바이더 입니다.</param>
/// <param name="targetProvider"><see cref="IMappingProvider"/> 를 구현하는 대상 매핑 프로바이더 입니다.</param>
public override void StartOfAssign(IMappingProvider sourceProvider, IMappingProvider targetProvider)
{
base.StartOfAssign(sourceProvider, targetProvider);
var mappingkeyOfSourceProvider = sourceProvider.MappingKeys;
if (Object.ReferenceEquals(this, targetProvider))
{
var requiredParamProperies = this.ParamPropertyAttributeDictionary.Where(o =>
{
return(this.ParamPropertyAttributeDictionary[o.Key.ToString()].IsRequired);
})
.ToDictionary(o => o.Key);
foreach (var attr in requiredParamProperies)
{
if (mappingkeyOfSourceProvider.Contains(attr.Key) == false)
{
throw new MappingException(ExceptionRS.키_O는_필수_매핑키_입니다_이_매핑키가_대상_데이터소스에_존재하지않아_매핑할_수_없습니다, attr.Key);
}
}
}
}
public int SelectCountGroup(IDbHelper db, IMappingProvider mappingProvider, IDictionary <object, string> tableMapping, object entityType, IQueryExpression queryExpression, SqlAnalyseResult sqlAnalyseResult)
{
StringBuilder sb = new StringBuilder();
IDbCommand command = db.Connection.CreateCommand();
int parameterCounter = 1;
//创建一个QueryExpression
sb.Append("select count(0) from (");
//select
sb.Append("select 1 as A_A_A ");
//from where
GenerateSelectSql_FromWhere(sb, command.Parameters, ref parameterCounter, queryExpression, sqlAnalyseResult, mappingProvider, tableMapping);
sb.Append(") a");
//执行sql
command.CommandText = sb.ToString();
command.CommandType = CommandType.Text;
IDataReader dataReader = db.ExecuteReader(command);
int count = 0;
if (dataReader.Read())
{
count = Convert.ToInt32(dataReader[0]);
}
dataReader.Close();
return(count);
}
public TripService(
Func <IUnitOfWorkEF> unitOfWork,
IProjectableRepositoryEf <UsersTrips> userTripsRepo,
ICityService cityService,
IMappingProvider mappingProvider,
ITagService tagService,
IProjectableRepositoryEf <Trip> tripRepo,
IDateTimeProvider dateTimeProvider)
: base(unitOfWork)
{
Guard.WhenArgument(userTripsRepo, nameof(userTripsRepo)).IsNull().Throw();
Guard.WhenArgument(cityService, nameof(cityService)).IsNull().Throw();
Guard.WhenArgument(mappingProvider, nameof(mappingProvider)).IsNull().Throw();
Guard.WhenArgument(tripRepo, nameof(tripRepo)).IsNull().Throw();
Guard.WhenArgument(tagService, nameof(tagService)).IsNull().Throw();
Guard.WhenArgument(dateTimeProvider, nameof(dateTimeProvider)).IsNull().Throw();
this.userTripsRepo = userTripsRepo;
this.cityService = cityService;
this.mappingProvider = mappingProvider;
this.tripRepo = tripRepo;
this.tagService = tagService;
this.dateTimeProvider = dateTimeProvider;
}
public IConfiguration AddFromAssembly(Assembly assembly)
{
foreach (var type1 in Enumerable.Select(Enumerable.Where(Enumerable.Select(assembly.GetExportedTypes(), type => new
{
type = type,
entity = Enumerable.FirstOrDefault <Type>(Enumerable.Select(Enumerable.Where(type.GetInterfaces(), interfaceType =>
{
if (interfaceType.IsGenericType)
{
return(interfaceType.GetGenericTypeDefinition() == typeof(ILuceneMappingOverride <>));
}
return(false);
}), interfaceType => interfaceType.GetGenericArguments()[0]))
}), param0 => param0.entity != (Type)null), param0 => new
{
OverrideType = param0.type,
EntityType = param0.entity
}))
{
object instance = Activator.CreateInstance(type1.OverrideType);
IMappingProvider mappingProvider = (IMappingProvider)Activator.CreateInstance(typeof(LuceneMapping <>).MakeGenericType(new Type[1]
{
type1.EntityType
}));
type1.OverrideType.GetMethod("Override");
GetType().GetMethod("AddOverride", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod(new Type[1]
{
type1.EntityType
}).Invoke((object)this, new object[2]
{
(object)type1.EntityType,
instance
});
}
return(this);
}
private void Mapping(Action<SubclassMap<ExampleInheritedClass>> mappingDefinition)
{
var classMap = new ClassMap<ExampleClass>();
var subclassMap = new SubclassMap<ExampleInheritedClass>();
mappingDefinition(subclassMap);
model.Add(subclassMap);
mapping = classMap;
mappingType = typeof(ExampleClass);
}
private void Mapping(Action<SubclassMap<ExampleInheritedClass>> mappingDefinition)
{
var classMap = new ClassMap<ExampleClass>();
classMap.Id(x => x.Id);
classMap.DiscriminateSubClassesOnColumn("col");
var subclassMap = new SubclassMap<ExampleInheritedClass>();
mappingDefinition(subclassMap);
model.Add(subclassMap);
mapping = classMap;
mappingType = typeof(ExampleClass);
}
/// <summary>
/// Instantiates PersistentPackage to be used for persistence operations.
/// </summary>
/// <param name="t"><see cref="Type"/> marked with <see cref="Ikarii.Lib.Data.Alpaca.Meta.PersistentAttribute"/>.</param>
/// <param name="parent">Parent <see cref="PersistentObject"/> which will be used in operations where the ForeignKey of this object is needed.</param>
/// <param name="mappingProvider">The <see cref="IMappingProvider"/> used to create the <see cref="PersistentObject"/>.</param>
internal ObjectPackage( Type t, TypeMap parent, IMappingProvider mappingProvider )
: this(t.Assembly.CreateInstance( t.FullName ), t, parent, mappingProvider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SilkveilContainer" /> type.
/// </summary>
/// <param name="containerBinder">The container binder.</param>
/// <param name="requestListeners">The request listeners.</param>
/// <param name="downloadMappingResolver">The download mapping resolver.</param>
/// <param name="redirectMappingResolver">The redirect mapping resolver.</param>
/// <param name="downloadMappingProvider">The download mapping provider.</param>
/// <param name="redirectMappingProvider">The redirect mapping provider.</param>
/// <param name="contentSources">The content sources.</param>
/// <param name="streamSplitter">The stream splitter.</param>
/// <param name="httpStreamFactory">The HTTP stream factory.</param>
public SilkveilContainer(IContainerBinder containerBinder, IEnumerable<IRequestListener> requestListeners, IMappingResolver<IDownloadMapping> downloadMappingResolver, IMappingResolver<IRedirectMapping> redirectMappingResolver, IMappingProvider<IDownloadMapping> downloadMappingProvider, IMappingProvider<IRedirectMapping> redirectMappingProvider, IEnumerable<IContentSource> contentSources, IStreamSplitter streamSplitter, IHttpStreamFactory httpStreamFactory)
{
Enforce.IsNotNull(containerBinder, () => containerBinder);
Enforce.IsNotNullOrEmpty(requestListeners, () => requestListeners);
Enforce.IsNotNull(downloadMappingResolver, () => downloadMappingResolver);
Enforce.IsNotNull(redirectMappingResolver, () => redirectMappingResolver);
Enforce.IsNotNull(downloadMappingProvider, () => downloadMappingProvider);
Enforce.IsNotNull(redirectMappingProvider, () => redirectMappingProvider);
Enforce.IsNotNullOrEmpty(contentSources, () => contentSources);
Enforce.IsNotNull(streamSplitter, () => streamSplitter);
Enforce.IsNotNull(httpStreamFactory, () => httpStreamFactory);
this._requestListeners = requestListeners;
this._downloadMappingResolver = downloadMappingResolver;
this._redirectMappingResolver = redirectMappingResolver;
this._downloadMappingProvider = downloadMappingProvider;
this._redirectMappingProvider = redirectMappingProvider;
this._contentSources = contentSources;
this._streamSplitter = streamSplitter;
this._httpStreamFactory = httpStreamFactory;
containerBinder
// Bind IIS request to all request listeners.
.Bind(this, "HandleInternal", from r in this._requestListeners select (Action<string>)r.Handle)
// Bind download request listener to download mapping resolver.
.Bind<Guid>(
from r in this._requestListeners where r.GetType() == typeof(DownloadRequestListener) select r,
"ValidUriDetected", this._downloadMappingResolver.ResolveGuid)
// Bind download request listener to download mapping resolver.
.Bind<Guid>(
from r in this._requestListeners where r.GetType() == typeof(RedirectRequestListener) select r,
"ValidUriDetected", this._redirectMappingResolver.ResolveGuid)
// Bind download mapping resolver to download mapping provider.
.Bind<Guid>(this._downloadMappingResolver, "RequestMapping", this._downloadMappingProvider.ReadById)
// Bind redirect mapping resolver to redirect mapping provider.
.Bind<Guid>(this._redirectMappingResolver, "RequestMapping", this._redirectMappingProvider.ReadById)
// Bind download mapping provider to download mapping resolver.
.Bind<IDownloadMapping>(this._downloadMappingProvider, "MappingAvailable",
this._downloadMappingResolver.RequestedMappingAvailable)
// Bind redirect mapping provider to redirect mapping resolver.
.Bind<IRedirectMapping>(this._redirectMappingProvider, "MappingAvailable",
this._redirectMappingResolver.RequestedMappingAvailable)
// Bind download mapping resolver to all content sources.
.Bind<IDownloadMapping>(this._downloadMappingResolver, "MappingResolved",
m => this._contentSources.ForEach(c => c.Request(m.Uri)))
// Bind all content sources to stream splitter.
.Bind<Stream>(this._contentSources, "ContentAvailable", this._streamSplitter.Split)
// Bind stream splitter to IIS response.
.Bind<IStreamPart>(this._streamSplitter, "StreamPartAvailable", this.OnResponsePartAvailable)
// Bind redirect mapping resolver to the HTTP stream factory.
.Bind<IRedirectMapping>(this._redirectMappingResolver, "MappingResolved",
this._httpStreamFactory.CreateRedirect)
// Bind HTTP stream factory to itself.
.Bind(this._httpStreamFactory, "StreamAvailable",
new Action<Stream>[]
{
this._httpStreamFactory.RequestStatusCode,
this._httpStreamFactory.RequestHeaders
})
// Bind HTTP stream factory to IIS response.
.Bind<IDictionary<string, string>>(this._httpStreamFactory, "HeadersAvailable", this.OnHeadersAvailable)
.Bind<int>(this._httpStreamFactory, "StatusCodeAvailable", this.OnStatusCodeAvailable);
}
private void Mapping(Action<ComponentPart<ComponentTarget>> mappingDefinition)
{
var classMap = new ClassMap<PropertyTarget>();
classMap.Id(x => x.Id);
var map = classMap.Component(x => x.Component, mappingDefinition);
mappingDefinition(map);
mapping = classMap;
mappingType = typeof(PropertyTarget);
}
/// <summary>
/// 매핑이 수행되기 전에 초기화할 수 있는 작업입니다.
/// </summary>
/// <param name="sourceProvider"><see cref="IMappingProvider"/> 를 구현하는 원본 매핑 프로바이더 입니다.</param>
/// <param name="targetProvider"><see cref="IMappingProvider"/> 를 구현하는 대상 매핑 프로바이더 입니다.</param>
public override void StartOfAssign(IMappingProvider sourceProvider, IMappingProvider targetProvider)
{
base.StartOfAssign(sourceProvider, targetProvider);
var mappingkeyOfSourceProvider = sourceProvider.MappingKeys;
if (Object.ReferenceEquals(this, targetProvider))
{
var requiredParamProperies = this.ParamPropertyAttributeDictionary.Where(o =>
{
return this.ParamPropertyAttributeDictionary[o.Key.ToString()].IsRequired;
})
.ToDictionary(o => o.Key);
foreach (var attr in requiredParamProperies)
{
if (mappingkeyOfSourceProvider.Contains(attr.Key) == false)
throw new MappingException(ExceptionRS.키_O는_필수_매핑키_입니다_이_매핑키가_대상_데이터소스에_존재하지않아_매핑할_수_없습니다, attr.Key);
}
}
}
public void Add(IMappingProvider provider)
{
Add(provider.GetClassMapping());
}
private void Mapping(Action<OneToOnePart<ExampleParentClass>> mappingDefinition)
{
var classMap = new ClassMap<ExampleClass>();
var map = classMap.HasOne(x => x.Parent);
mappingDefinition(map);
mapping = classMap;
mappingType = typeof(ExampleClass);
}
private void Mapping(Action<DynamicComponentPart<IDictionary>> mappingDefinition)
{
var classMap = new ClassMap<PropertyTarget>();
classMap.Id(x => x.Id);
var map = classMap.DynamicComponent(x => x.ExtensionData, m =>
{
m.Map(x => (string)x["Name"]);
m.Map(x => (int)x["Age"]);
m.Map(x => (string)x["Profession"]);
});
mappingDefinition(map);
mapping = classMap;
mappingType = typeof(PropertyTarget);
}
private void Mapping(Action<ManyToOnePart<ExampleParentClass>> mappingDefinition)
{
var classMap = new ClassMap<ExampleClass>();
classMap.Id(x => x.Id);
var map = classMap.References(x => x.Parent);
mappingDefinition(map);
mapping = classMap;
mappingType = typeof(ExampleClass);
}
public void Add(IMappingProvider provider)
{
classProviders.Add(provider);
}
private void Mapping(Expression<Func<ExampleClass, object>> property, Action<PropertyBuilder> mappingDefinition)
{
var classMap = new ClassMap<ExampleClass>();
classMap.Id(x => x.Id);
var map = classMap.Map(property);
mappingDefinition(map);
mapping = classMap;
mappingType = typeof(ExampleClass);
}
public QuestionService(IDataRepository <Question> questionRepo, IDataSaver dataSaver, IMappingProvider mapper)
{
this.questionRepo = questionRepo ?? throw new ArgumentNullException(nameof(questionRepo));
this.dataSaver = dataSaver ?? throw new ArgumentNullException(nameof(dataSaver));
this.mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
private void Mapping(Action<OneToManyPart<ExampleClass>> mappingDefinition)
{
var classMap = new ClassMap<ExampleParentClass>();
classMap.Id(x => x.Id);
var map = classMap.HasMany(x => x.Examples)
.AsArray(x => x.Id);
mappingDefinition(map);
mapping = classMap;
mappingType = typeof(ExampleParentClass);
}
public void Add(IMappingProvider provider)
{
classProviders.Add(provider);
}
public void Add(IMappingProvider provider)
{
mappings.Add(provider);
}
public AdministerTestController(ITestService testService, IMappingProvider mapper)
{
this.testService = testService;
this.mapper = mapper;
}
private void Mapping(Expression<Func<ValidVersionClass, object>> property, Action<VersionPart> mappingDefinition)
{
var classMap = new ClassMap<ValidVersionClass>();
classMap.Id(x => x.Id);
var map = classMap.Version(property);
mappingDefinition(map);
mapping = classMap;
mappingType = typeof(ValidVersionClass);
}
private void Mapping(Action<ClassMap<ExampleClass>> mappingDefinition)
{
var classMap = new ClassMap<ExampleClass>();
classMap.Id(x => x.Id);
mappingDefinition(classMap);
mapping = classMap;
mappingType = typeof(ExampleClass);
}
protected override void Context()
{
_mapping = LuceneMapper.GetMappingForType(typeof (TestObject));
}
/// <summary>
/// Initializes a new instance of the <see cref="MappingService"/> type.
/// </summary>
/// <param name="mappingProvider">The mapping provider.</param>
public MappingService(IMappingProvider mappingProvider)
{
this._mappingProvider = mappingProvider;
}
private void Mapping(Action<JoinPart<ExampleClass>> mappingDefinition)
{
var classMap = new ClassMap<ExampleClass>();
classMap.Id(x => x.Id);
classMap.Join("table", mappingDefinition);
mapping = classMap;
mappingType = typeof(ExampleClass);
}
