void FileSystemItemCustomization(IClassMapper<FileSystemItem> ca)
{
ca.Table(tablePrefix + "FSItem");
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.Lazy(false);
ca.Cache(cm => { cm.Usage(CacheUsage.NonstrictReadWrite); });
ca.Component(x => x.Path, cm =>
{
cm.Property(x => x.Parent, ccm => { ccm.Length(1024); });
cm.Property(x => x.Name, ccm => { ccm.Length(255); });
cm.Property(x => x.IsDirectory, ccm => { });
});
ca.Property(x => x.Created, cm => { cm.NotNullable(true); });
ca.Property(x => x.Updated, cm => { cm.NotNullable(true); });
ca.Property(x => x.Length, cm => { });
//ca.Bag(x => x.Chunks, cm =>
// {
// cm.Key(k => k.Column("FileID"));
// cm.Inverse(true);
// cm.Cascade(Cascade.All);
// cm.OrderBy(ci => ci.Offset);
// cm.Lazy(CollectionLazy.Extra);
// }, cr => cr.OneToMany());
}
public static IPredicate GetPredicate(IClassMapper classMap, object predicate)
{
var wherePredicate = predicate as IPredicate;
if (wherePredicate == null && predicate != null)
{
Type predicateType = typeof(FieldPredicate<>).MakeGenericType(classMap.EntityType);
IList<IPredicate> predicates = new List<IPredicate>();
foreach (var kvp in ReflectionHelper.GetObjectValues(predicate))
{
var fieldPredicate = Activator.CreateInstance(predicateType) as IFieldPredicate;
fieldPredicate.Not = false;
fieldPredicate.Operator = Operator.Eq;
fieldPredicate.PropertyName = kvp.Key;
fieldPredicate.Value = kvp.Value;
predicates.Add(fieldPredicate);
}
return predicates.Count == 1
? predicates[0]
: new PredicateGroup
{
Operator = GroupOperator.And,
Predicates = predicates
};
}
return wherePredicate;
}
public virtual string BuildSelectColumns(IClassMapper classMap)
{
var columns = classMap.Properties
.Where(p => !p.Ignored)
.Select(p => GetColumnName(classMap, p, true));
return columns.AppendStrings();
}
public string SelectSet(IClassMapper classMap, IPredicate predicate, IList<ISort> sort, int firstResult, int maxResults, IDictionary<string, object> parameters)
{
if (sort == null || !sort.Any())
{
throw new ArgumentNullException("Sort", "Sort cannot be null or empty.");
}
if (parameters == null)
{
throw new ArgumentNullException("Parameters");
}
StringBuilder innerSql = new StringBuilder(string.Format("SELECT {0} FROM {1}",
BuildSelectColumns(classMap),
GetTableName(classMap)));
if (predicate != null)
{
innerSql.Append(" WHERE ")
.Append(predicate.GetSql(this, parameters));
}
string orderBy = sort.Select(s => GetColumnName(classMap, s.PropertyName, false) + (s.Ascending ? " ASC" : " DESC")).AppendStrings();
innerSql.Append(" ORDER BY " + orderBy);
string sql = Configuration.Dialect.GetSetSql(innerSql.ToString(), firstResult, maxResults, parameters);
return sql;
}
public override string Create(IClassMapper classMap)
{
var columns = classMap.Properties.Where(p => !(p.Ignored || p.IsReadOnly)).ToArray();
if (!columns.Any())
{
throw new ArgumentException("No columns were mapped.");
}
var columnKeys = columns.Select(p => new KeyValuePair<Type, string>(p.PropertyInfo.PropertyType, GetColumnName(classMap, p, false)))
.ToList();
var sql = new StringBuilder();
sql.AppendFormat("CREATE TABLE IF NOT EXISTS {0}", GetTableName(classMap)).AppendLine();
sql.AppendLine("(");
var index = 0;
var pk = String.Empty;
foreach (var columnKey in columnKeys)
{
var column = columns.FirstOrDefault(f => columnKey.Key == f.PropertyInfo.PropertyType &&
columnKey.Value.IndexOf(f.Name, StringComparison.InvariantCultureIgnoreCase) >= 0);
if (column == null)
continue;
switch (column.KeyType)
{
case KeyType.Identity:
pk = columnKey.Value;
sql.AppendFormat("{0} {1} NOT NULL AUTO_INCREMENT",
pk, Configuration.DataMapper[columnKey.Key]);
break;
default:
sql.AppendFormat("{0} {1} NULL",
columnKey.Value, Configuration.DataMapper[columnKey.Key]);
break;
}
sql.Append(",")
.AppendLine();
index++;
}
if (!String.IsNullOrWhiteSpace(pk))
{
sql.AppendFormat(" PRIMARY KEY ({0})", pk)
.AppendLine();
}
sql.AppendLine(")");
return sql.ToString();
}
void FileSystemChunkCustomization(IClassMapper<FileSystemChunk> ca)
{
ca.Table(tablePrefix + "FSChunk");
ca.Lazy(false);
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.ManyToOne(x => x.BelongsTo, m => { m.Column("FileID"); });
ca.Property(x => x.Offset, cm => { });
ca.Property(cm => cm.Data, cm => { cm.Type(NHibernateUtil.BinaryBlob); cm.Length(ConfigurationBuilder.BlobLength); cm.Lazy(false); });
}
private void BucketCustomization(IClassMapper<Bucket> ca)
{
ca.Table(tablePrefix + "StatisticsBucket");
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.Lazy(false);
ca.Property(x => x.PageID, cm => { cm.NotNullable(true); });
ca.Property(x => x.TimeSlot, cm => { cm.NotNullable(true); });
ca.Property(x => x.Views, cm => { cm.NotNullable(true); });
}
public string Delete(IClassMapper classMap)
{
if (!classMap.Properties.Any(c => c.KeyType != KeyType.NotAKey))
{
throw new ArgumentException("At least one Key column must be defined.");
}
return string.Format("DELETE FROM {0} WHERE {1}",
GetTableName(classMap),
BuildWhere(classMap));
}
public string Delete(IClassMapper classMap, IPredicate predicate, IDictionary<string, object> parameters)
{
StringBuilder sql = new StringBuilder(string.Format("DELETE FROM {0}", GetTableName(classMap)));
if (predicate != null)
{
sql.Append(" WHERE ")
.Append(predicate.GetSql(parameters));
}
return sql.ToString();
}
public override string Create(IClassMapper classMap)
{
var columns = classMap.Properties.Where(p => !(p.Ignored || p.IsReadOnly)).ToArray();
if (!columns.Any())
{
throw new ArgumentException("No columns were mapped.");
}
var columnKeys = columns.Select(p => new KeyValuePair<Type, string>(p.PropertyInfo.PropertyType, GetColumnName(classMap, p, false)))
.ToList();
var sql = new StringBuilder();
sql.AppendFormat(@"IF (OBJECT_ID('{0}', 'U') IS NULL)", GetTableName(classMap))
.AppendLine();
sql.AppendFormat("CREATE TABLE {0}", GetTableName(classMap)).AppendLine();
sql.AppendLine("(");
var index = 0;
foreach (var columnKey in columnKeys)
{
var column = columns.FirstOrDefault(f => columnKey.Key == f.PropertyInfo.PropertyType &&
columnKey.Value.IndexOf(f.Name, StringComparison.InvariantCultureIgnoreCase) >= 0);
if (column == null)
continue;
if (index > 0)
sql.Append(",");
switch (column.KeyType)
{
case KeyType.Identity:
sql.AppendFormat("{0} {1} NOT NULL IDENTITY(1,1) PRIMARY KEY",
columnKey.Value,
Configuration.DataMapper[columnKey.Key]);
break;
default:
sql.AppendFormat("{0} {1} NULL",
columnKey.Value,
Configuration.DataMapper[columnKey.Key]);
break;
}
sql.AppendLine();
index++;
}
sql.AppendLine(")");
return sql.ToString();
}
private void StatisticCustomization(IClassMapper<Statistic> ca)
{
ca.Table(tablePrefix + "Statistics");
ca.ComposedId(x =>
{
x.Property(y => y.TimeSlot);
x.Property(y => y.PageID);
});
//ca.Id(x => new { x.TimeSlot, x.PageID }, cm => { cm.Generator(Generators.Assigned); });
ca.Lazy(false);
ca.Property(x => x.TimeSlot, cm => { cm.NotNullable(true); });
ca.Property(x => x.Views, cm => { cm.NotNullable(true); });
}
public virtual string Delete(IClassMapper classMap, IPredicate predicate, IDictionary<string, object> parameters)
{
if (predicate == null)
{
throw new ArgumentNullException("Predicate");
}
if (parameters == null)
{
throw new ArgumentNullException("Parameters");
}
var sql = new StringBuilder(string.Format("DELETE FROM {0}", GetTableName(classMap)));
sql.Append(" WHERE ").Append(predicate.GetSql(this, parameters));
return sql.ToString();
}
public virtual string Count(IClassMapper classMap, IPredicate predicate, IDictionary<string, object> parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("Parameters");
}
StringBuilder sql = new StringBuilder(string.Format("SELECT COUNT(*) AS {0}Total{1} FROM {2}",
Configuration.Dialect.OpenQuote,
Configuration.Dialect.CloseQuote,
GetTableName(classMap)));
if (predicate != null)
{
sql.Append(" WHERE ")
.Append(predicate.GetSql(this, parameters));
}
return sql.ToString();
}
public string Select(IClassMapper classMap, IPredicate predicate, IList<ISort> sort, IDictionary<string, object> parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("Parameters");
}
StringBuilder sql = new StringBuilder(string.Format("SELECT {0} FROM {1}",
BuildSelectColumns(classMap),
GetTableName(classMap)));
if (predicate != null)
{
sql.Append(" WHERE ")
.Append(predicate.GetSql(this, parameters));
}
if (sort != null && sort.Any())
{
sql.Append(" ORDER BY ")
.Append(sort.Select(s => GetColumnName(classMap, s.PropertyName, false) + (s.Ascending ? " ASC" : " DESC")).AppendStrings());
}
return sql.ToString();
}
void ContentDetailCustomization(IClassMapper<ContentDetail> ca)
{
ca.Table(tablePrefix + "Detail");
ca.Lazy(false);
ca.Cache(cm => { cm.Usage(CacheUsage.NonstrictReadWrite); cm.Region(cacheRegion); });
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.ManyToOne(x => x.EnclosingItem, cm => { cm.Column("ItemID"); cm.NotNullable(true); cm.Fetch(FetchKind.Select); cm.Lazy(LazyRelation.Proxy); });
ca.ManyToOne(x => x.EnclosingCollection, cm => { cm.Column("DetailCollectionID"); cm.Fetch(FetchKind.Select); cm.Lazy(LazyRelation.Proxy); });
ca.Property(x => x.ValueTypeKey, cm => { cm.Column("Type"); cm.Length(10); });
ca.Property(x => x.Name, cm => { cm.Length(50); });
ca.Property(x => x.Meta, cm => { cm.Type(NHibernateUtil.StringClob); cm.Length(stringLength); });
ca.Property(x => x.BoolValue, cm => { });
ca.Property(x => x.DateTimeValue, cm => { });
ca.Property(x => x.IntValue, cm => { });
ca.Component(x => x.LinkedItem, cm =>
{
cm.Property(cr => cr.ID, pm => pm.Column("LinkValue"));
});
//ca.ManyToOne(x => x.LinkedItem, cm => { cm.Column("LinkValue"); cm.NotFound(NotFoundMode.Ignore); cm.Fetch(FetchKind.Select); cm.Lazy(LazyRelation.Proxy); cm.Cascade(Cascade.None); });
ca.Property(x => x.DoubleValue, cm => { });
// if you are using Oracle10g and get
// ORA-01461: can bind a LONG value only for insert into a LONG column
// use the following line instead of the the later one (NOTICE both apply to the same property)
// ca.Property(x => x.StringValue, cm => { cm.Type(NHibernateUtil.AnsiString); cm.Length(stringLength); });
ca.Property(x => x.StringValue, cm => { cm.Type(NHibernateUtil.StringClob); cm.Length(stringLength); });
ca.Property(x => x.ObjectValue, cm => { cm.Column("Value"); cm.Type(NHibernateUtil.Serializable); cm.Length(ConfigurationBuilder.BlobLength); });
}
public virtual string Update(IClassMapper classMap, IPredicate predicate, IDictionary<string, object> parameters)
{
if (predicate == null)
{
throw new ArgumentNullException("Predicate");
}
if (parameters == null)
{
throw new ArgumentNullException("Parameters");
}
var columns = classMap.Properties.Where(p => !(p.Ignored || p.IsReadOnly || p.KeyType == KeyType.Identity));
if (!columns.Any())
{
throw new ArgumentException("No columns were mapped.");
}
var setSql =
columns.Select(
p =>
string.Format(
"{0} = {1}{2}", GetColumnName(classMap, p, false), Configuration.Dialect.ParameterPrefix, p.Name));
return string.Format("UPDATE {0} SET {1} WHERE {2}",
GetTableName(classMap),
setSql.AppendStrings(),
predicate.GetSql(this, parameters));
}
public virtual string IdentitySql(IClassMapper classMap)
{
return Configuration.Dialect.GetIdentitySql(GetTableName(classMap));
}
public virtual string GetColumnName(IClassMapper map, string propertyName, bool includeAlias)
{
IPropertyMap propertyMap = map.Properties.SingleOrDefault(p => p.Name.Equals(propertyName, StringComparison.CurrentCultureIgnoreCase));
if (propertyMap == null)
{
throw new ArgumentException(string.Format("Could not find '{0}' in Mapping.", propertyName));
}
return GetColumnName(map, propertyMap, includeAlias);
}
public string Update(IClassMapper classMap)
{
if (!classMap.Properties.Any(c => c.KeyType != KeyType.NotAKey))
{
throw new ArgumentException("At least one Key column must be defined.");
}
var columns = classMap.Properties.Where(p => !(p.Ignored || p.IsReadOnly || p.KeyType == KeyType.Identity));
var setSql = columns.Select(p => GetColumnName(classMap, p, false) + " = @" + p.Name);
return string.Format("UPDATE {0} SET {1} WHERE {2}",
GetTableName(classMap),
setSql.AppendStrings(),
BuildWhere(classMap));
}
public string Insert(IClassMapper classMap)
{
if (classMap.Properties.Count(c => c.KeyType == KeyType.Identity) > 1)
{
throw new ArgumentException("Can only set 1 property to Identity.");
}
var columns = classMap.Properties.Where(p => !(p.Ignored || p.IsReadOnly || p.KeyType == KeyType.Identity));
var columnNames = columns.Select(p => GetColumnName(classMap, p, false));
var parameters = columns.Select(p => "@" + p.Name);
return string.Format("INSERT INTO {0} ({1}) VALUES ({2})",
GetTableName(classMap),
columnNames.AppendStrings(),
parameters.AppendStrings());
}
public void InvokeCustomizers(System.Type type, IClassMapper mapper)
{
InvokeCustomizers(rootClassCustomizers, type, mapper);
}
void ContentItemCustomization(IClassMapper <ContentItem> ca)
{
ca.Table(tablePrefix + "Item");
ca.Lazy(false);
ca.Cache(cm => { cm.Usage(CacheUsage.NonstrictReadWrite); });
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.Discriminator(cm => { cm.Column("Type"); cm.Type(NHibernateUtil.String); });
ca.Property(x => x.Created, cm => { });
ca.Property(x => x.Published, cm => { });
ca.Property(x => x.Updated, cm => { });
ca.Property(x => x.Expires, cm => { });
ca.Property(x => x.Name, cm => { cm.Length(250); });
ca.Property(x => x.ZoneName, cm => { cm.Length(50); });
ca.Property(x => x.TemplateKey, cm => { cm.Length(50); });
ca.Property(x => x.TranslationKey, cm => { });
ca.Property(x => x.Title, cm => { cm.Length(250); });
ca.Property(x => x.SortOrder, cm => { });
ca.Property(x => x.Visible, cm => { });
ca.Property(x => x.SavedBy, cm => { cm.Length(50); });
ca.Property(x => x.State, cm => { });
ca.Property(x => x.ChildState, cm => { });
ca.Property(x => x.AncestralTrail, cm => { cm.Length(100); });
ca.Property(x => x.VersionIndex, cm => { });
ca.Property(x => x.AlteredPermissions, cm => { });
//ca.ManyToOne(x => x.VersionOf, cm => { cm.Column("VersionOfID"); cm.Lazy(LazyRelation.Proxy); cm.Fetch(FetchKind.Select); });
//ca.Property(x => x.VersionOf, cm =>
//{
// cm.Column("VersionOfID");
// cm.Type<ContentRelationFactory>();
//});
ca.Component(x => x.VersionOf, cm =>
{
cm.Property(cr => cr.ID, pm => pm.Column("VersionOfID"));
});
ca.ManyToOne(x => x.Parent, cm => { cm.Column("ParentID"); cm.Lazy(LazyRelation.Proxy); cm.Fetch(FetchKind.Select); });
ca.Bag(x => x.Children, cm =>
{
cm.Key(k => k.Column("ParentID"));
cm.Inverse(true);
cm.Type <ContentItemListFactory <ContentItem> >();
cm.Cascade(childrenCascade);
cm.OrderBy(ci => ci.SortOrder);
cm.Lazy(childrenLaziness);
cm.BatchSize(batchSize ?? 25);
cm.Cache(m => m.Usage(CacheUsage.NonstrictReadWrite));
}, cr => cr.OneToMany());
ca.Bag(x => x.Details, cm =>
{
cm.Key(k => k.Column("ItemID"));
cm.Inverse(true);
cm.Type <ContentListFactory <ContentDetail> >();
cm.Cascade(Cascade.All | Cascade.DeleteOrphans);
cm.Fetch(CollectionFetchMode.Select);
cm.Lazy(CollectionLazy.Lazy);
cm.Cache(m => m.Usage(CacheUsage.NonstrictReadWrite));
cm.Where("DetailCollectionID IS NULL");
}, cr => cr.OneToMany());
ca.Bag(x => x.DetailCollections, cm =>
{
cm.Key(k => k.Column("ItemID"));
cm.Inverse(true);
cm.Type <ContentListFactory <DetailCollection> >();
cm.Cascade(Cascade.All | Cascade.DeleteOrphans);
cm.Fetch(CollectionFetchMode.Select);
cm.Lazy(CollectionLazy.Lazy);
cm.Cache(m => m.Usage(CacheUsage.NonstrictReadWrite));
}, cr => cr.OneToMany());
ca.Bag(x => x.AuthorizedRoles, cm =>
{
cm.Key(k => k.Column("ItemID"));
cm.Inverse(true);
cm.Cascade(Cascade.All | Cascade.DeleteOrphans);
cm.Fetch(CollectionFetchMode.Select);
cm.Lazy(CollectionLazy.Lazy);
cm.Cache(m => m.Usage(CacheUsage.NonstrictReadWrite));
}, cr => cr.OneToMany());
}
public UsersController(IUsersService service, ILikesService likesService, IClassMapper mapper)
{
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_service = service ?? throw new ArgumentNullException(nameof(service));
_likesService = likesService ?? throw new ArgumentNullException(nameof(likesService));
}
public static void IdGuidComb <TEntity>(this IClassMapper <TEntity> map) where TEntity : BaseGuidModel <TEntity>
{
map.Id(x => x.Id, m => m.Generator(Generators.GuidComb));
}
public virtual string GetColumnName(IClassMapper map, IPropertyMap property, bool includeAlias)
{
string alias = null;
if (property.ColumnName != property.Name && includeAlias)
{
alias = property.Name;
}
return Configuration.Dialect.GetColumnName(GetTableName(map), property.ColumnName, alias);
}
private string BuildWhere(IClassMapper classMap)
{
var where = classMap.Properties
.Where(p => p.KeyType != KeyType.NotAKey)
.Select(p => GetColumnName(classMap, p, false) + " = @" + p.Name);
return where.AppendStrings(" AND ");
}
public virtual string GetTableName(IClassMapper map)
{
return Configuration.Dialect.GetTableName(map.SchemaName, map.TableName, null);
}
void AuthorizedRoleCustomization(IClassMapper<AuthorizedRole> ca)
{
ca.Table(tablePrefix + "AllowedRole");
ca.Lazy(false);
ca.Cache(cm => { cm.Usage(CacheUsage.NonstrictReadWrite); cm.Region(cacheRegion); });
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.ManyToOne(x => x.EnclosingItem, cm => { cm.Column("ItemID"); cm.NotNullable(true); });
ca.Property(x => x.Role, cm => { cm.Length(50); cm.NotNullable(true); });
}
public virtual string Insert(IClassMapper classMap)
{
var columns = classMap.Properties.Where(p => !(p.Ignored || p.IsReadOnly || p.KeyType == KeyType.Identity));
if (!columns.Any())
{
throw new ArgumentException("No columns were mapped.");
}
var columnNames = columns.Select(p => GetColumnName(classMap, p, false));
var parameters = columns.Select(p => Configuration.Dialect.ParameterPrefix + p.Name);
string sql = string.Format("INSERT INTO {0} ({1}) VALUES ({2})",
GetTableName(classMap),
columnNames.AppendStrings(),
parameters.AppendStrings());
return sql;
}
public LambdaDeleteHelper(string connKey, IClassMapper classMap, int?commandTimeout = null)
: base(connKey, classMap, commandTimeout)
{
}
public static void IdHilo <TEntity>(this IClassMapper <TEntity> map) where TEntity : BaseHiLoModel <TEntity>
{
map.IdHilo(100);
}
public string Get(IClassMapper classMap)
{
if (!classMap.Properties.Any(c => c.KeyType != KeyType.NotAKey))
{
throw new ArgumentException("At least one Key column must be defined.");
}
return string.Format("SELECT {0} FROM {1} WHERE {2}",
BuildSelectColumns(classMap),
GetTableName(classMap),
BuildWhere(classMap));
}
void ContentItemCustomization(IClassMapper<ContentItem> ca)
{
ca.Table(tablePrefix + "Item");
ca.Lazy(false);
ca.Cache(cm => { cm.Usage(CacheUsage.NonstrictReadWrite); cm.Region(cacheRegion); });
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.Discriminator(cm => { cm.Column("Type"); cm.Type(NHibernateUtil.String); });
ca.Property(x => x.Created, cm => { });
ca.Property(x => x.Published, cm => { });
ca.Property(x => x.Updated, cm => { });
ca.Property(x => x.Expires, cm => { });
ca.Property(x => x.Name, cm => { cm.Length(250); });
ca.Property(x => x.ZoneName, cm => { cm.Length(50); });
ca.Property(x => x.TemplateKey, cm => { cm.Length(50); });
ca.Property(x => x.TranslationKey, cm => { });
ca.Property(x => x.Title, cm => { cm.Length(250); });
ca.Property(x => x.SortOrder, cm => { });
ca.Property(x => x.Visible, cm => { });
ca.Property(x => x.SavedBy, cm => { cm.Length(50); });
ca.Property(x => x.State, cm => { });
ca.Property(x => x.ChildState, cm => { });
ca.Property(x => x.AncestralTrail, cm => { cm.Length(100); });
ca.Property(x => x.VersionIndex, cm => { });
ca.Property(x => x.AlteredPermissions, cm => { });
//ca.ManyToOne(x => x.VersionOf, cm => { cm.Column("VersionOfID"); cm.Lazy(LazyRelation.Proxy); cm.Fetch(FetchKind.Select); });
//ca.Property(x => x.VersionOf, cm =>
//{
// cm.Column("VersionOfID");
// cm.Type<ContentRelationFactory>();
//});
ca.Component(x => x.VersionOf, cm =>
{
cm.Property(cr => cr.ID, pm => pm.Column("VersionOfID"));
});
ca.ManyToOne(x => x.Parent, cm => { cm.Column("ParentID"); cm.Lazy(LazyRelation.Proxy); cm.Fetch(FetchKind.Select); });
ca.Bag(x => x.Children, cm =>
{
cm.Key(k => k.Column("ParentID"));
cm.Inverse(true);
cm.Type<ContentItemListFactory<ContentItem>>();
cm.Cascade(childrenCascade);
cm.OrderBy(ci => ci.SortOrder);
cm.Lazy(childrenLaziness);
if (childrenBatch)
cm.BatchSize(batchSize ?? 10);
cm.Cache(m => { m.Usage(CacheUsage.NonstrictReadWrite); m.Region(cacheRegion); });
}, cr => cr.OneToMany());
ca.Bag(x => x.Details, cm =>
{
cm.Key(k => k.Column("ItemID"));
cm.Inverse(true);
cm.Type<ContentListFactory<ContentDetail>>();
cm.Cascade(Cascade.All | Cascade.DeleteOrphans);
cm.Fetch(CollectionFetchMode.Select);
cm.Lazy(CollectionLazy.Lazy);
cm.BatchSize(batchSize ?? 10);
cm.Cache(m => { m.Usage(CacheUsage.NonstrictReadWrite); m.Region(cacheRegion); });
cm.Where("DetailCollectionID IS NULL");
}, cr => cr.OneToMany());
ca.Bag(x => x.DetailCollections, cm =>
{
cm.Key(k => k.Column("ItemID"));
cm.Inverse(true);
cm.Type<ContentListFactory<DetailCollection>>();
cm.Cascade(Cascade.All | Cascade.DeleteOrphans);
cm.Fetch(CollectionFetchMode.Select);
cm.Lazy(CollectionLazy.Lazy);
cm.BatchSize(batchSize ?? 10);
cm.Cache(m => { m.Usage(CacheUsage.NonstrictReadWrite); m.Region(cacheRegion); });
}, cr => cr.OneToMany());
ca.Bag(x => x.AuthorizedRoles, cm =>
{
cm.Key(k => k.Column("ItemID"));
cm.Inverse(true);
cm.Cascade(Cascade.All | Cascade.DeleteOrphans);
cm.Fetch(CollectionFetchMode.Select);
cm.Lazy(CollectionLazy.Lazy);
cm.BatchSize(batchSize ?? 25);
cm.Cache(m => { m.Usage(CacheUsage.NonstrictReadWrite); m.Region(cacheRegion); });
}, cr => cr.OneToMany());
}
public dynamic Insert <T>(IDbConnection connection, T entity, IDbTransaction transaction, int?commandTimeout) where T : class
{
IClassMapper classMap = SqlGenerator.Configuration.GetMap <T>();
List <IPropertyMap> nonIdentityKeyProperties = classMap.Properties.Where(p => p.KeyType == KeyType.Guid || p.KeyType == KeyType.Assigned).ToList();
var identityColumn = classMap.Properties.SingleOrDefault(p => p.KeyType == KeyType.Identity);
var generatedColumn = classMap.Properties.SingleOrDefault(p => p.KeyType == KeyType.Generated);
foreach (var column in nonIdentityKeyProperties)
{
if (column.KeyType == KeyType.Guid)
{
Guid comb = SqlGenerator.Configuration.GetNextGuid();
column.PropertyInfo.SetValue(entity, comb, null);
}
}
IDictionary <string, object> keyValues = new ExpandoObject();
string sql = SqlGenerator.Insert(classMap);
if (identityColumn != null)
{
IEnumerable <long> result;
if (SqlGenerator.SupportsMultipleStatements())
{
sql += SqlGenerator.Configuration.Dialect.BatchSeperator + SqlGenerator.IdentitySql(classMap);
result = connection.Query <long>(sql, entity, transaction, false, commandTimeout, CommandType.Text);
}
else
{
connection.Execute(sql, entity, transaction, commandTimeout, CommandType.Text);
sql = SqlGenerator.IdentitySql(classMap);
result = connection.Query <long>(sql, entity, transaction, false, commandTimeout, CommandType.Text);
}
long identityValue = result.First();
int identityInt = Convert.ToInt32(identityValue);
keyValues.Add(identityColumn.Name, identityInt);
identityColumn.PropertyInfo.SetValue(entity, identityInt, null);
}
else if (generatedColumn != null)
{
T inserted = connection.Query <T>(sql, entity, transaction, false, commandTimeout, CommandType.Text).First();
var generatedId = generatedColumn.PropertyInfo.GetValue(inserted, null);
keyValues.Add(generatedColumn.Name, generatedId);
generatedColumn.PropertyInfo.SetValue(entity, generatedId, null);
}
else
{
connection.Execute(sql, entity, transaction, commandTimeout, CommandType.Text);
}
foreach (var column in nonIdentityKeyProperties)
{
keyValues.Add(column.Name, column.PropertyInfo.GetValue(entity, null));
}
if (keyValues.Count == 1)
{
return(keyValues.First().Value);
}
return(keyValues);
}
void DetailCollectionCustomization(IClassMapper<DetailCollection> ca)
{
ca.Table(tablePrefix + "DetailCollection");
ca.Lazy(false);
ca.Cache(cm => { cm.Usage(CacheUsage.NonstrictReadWrite); cm.Region(cacheRegion); });
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.ManyToOne(x => x.EnclosingItem, cm => { cm.Column("ItemID"); cm.Fetch(FetchKind.Select); cm.Lazy(LazyRelation.Proxy); });
ca.Property(x => x.Name, cm => { cm.Length(50); cm.NotNullable(true); });
ca.Bag(x => x.Details, cm =>
{
cm.Key(k => k.Column("DetailCollectionID"));
cm.Inverse(true);
cm.Cascade(Cascade.All | Cascade.DeleteOrphans);
cm.Lazy(CollectionLazy.Lazy);
cm.Fetch(CollectionFetchMode.Select);
cm.Cache(m => { m.Usage(CacheUsage.NonstrictReadWrite); m.Region(cacheRegion); });
}, cr => cr.OneToMany());
}
void ContentDetailCustomization(IClassMapper<ContentDetail> ca)
{
ca.Table(tablePrefix + "Detail");
ca.Lazy(false);
ca.Cache(cm => { cm.Usage(CacheUsage.NonstrictReadWrite); });
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.ManyToOne(x => x.EnclosingItem, cm => { cm.Column("ItemID"); cm.NotNullable(true); cm.Fetch(FetchKind.Select); });
ca.ManyToOne(x => x.EnclosingCollection, cm => { cm.Column("DetailCollectionID"); cm.Fetch(FetchKind.Select); cm.Lazy(LazyRelation.Proxy); });
ca.Property(x => x.ValueTypeKey, cm => { cm.Column("Type"); cm.Length(10); });
ca.Property(x => x.Name, cm => { cm.Length(50); });
ca.Property(x => x.BoolValue, cm => { });
ca.Property(x => x.DateTimeValue, cm => { });
ca.Property(x => x.IntValue, cm => { });
ca.ManyToOne(x => x.LinkedItem, cm => { cm.Column("LinkValue"); cm.Lazy(LazyRelation.Proxy); cm.Cascade(Cascade.None); });
ca.Property(x => x.DoubleValue, cm => { });
ca.Property(x => x.StringValue, cm => { cm.Type(NHibernateUtil.StringClob); cm.Length(stringLength); });
ca.Property(x => x.ObjectValue, cm => { cm.Column("Value"); cm.Type(NHibernateUtil.Serializable); cm.Length(2147483647); });
}
void ContentVersionCustomization(IClassMapper<ContentVersion> ca)
{
ca.Table(tablePrefix + "Version");
ca.Lazy(false);
ca.Cache(cm => { cm.Usage(CacheUsage.NonstrictReadWrite); cm.Region(cacheRegion); });
ca.Id(x => x.ID, cm => { cm.Generator(Generators.Native); });
ca.Component(x => x.Master, cm => { cm.Property(cr => cr.ID, pm => pm.Column("MasterID")); });
ca.Property(x => x.Title, xm => { });
ca.Property(x => x.Published, cm => { });
ca.Property(x => x.FuturePublish, cm => { });
ca.Property(x => x.Expired, cm => { });
ca.Property(x => x.VersionIndex, cm => { });
ca.Property(x => x.Saved, cm => { });
ca.Property(x => x.State, cm => { });
ca.Property(x => x.SavedBy, cm => { });
ca.Property(x => x.ItemCount, cm => { });
ca.Property(x => x.VersionDataXml, cm => { cm.Type(NHibernateUtil.StringClob); cm.Length(stringLength); });
}
public LambdaDeleteHelper(IDbConnection connection, IDbTransaction transaction, IClassMapper classMap, int?commandTimeout = null)
: base(connection, transaction, classMap, commandTimeout)
{
}
