public void Trash(Bean bean)
{
EnsureDispensed(bean);
if (bean.GetKey(_keyAccess) == null)
{
return;
}
ImplicitTransaction(() =>
{
bean.BeforeTrash();
foreach (var observer in _observers)
{
observer.BeforeTrash(bean);
}
_storage.Trash(bean.GetKind(), bean.GetKey(_keyAccess));
bean.AfterTrash();
foreach (var observer in _observers)
{
observer.AfterTrash(bean);
}
return(true);
});
}
/// <summary>
/// Links the current Bean with another Bean in a m:n relational manner and
/// provides data (linkProps) for the Link.
/// </summary>
/// <param name="bean">Bean to be linked.</param>
/// <param name="linkProps">Dictionary of Link Properties.</param>
/// <returns>true, if successful</returns>
public bool LinkWith(Bean bean, IDictionary <string, object> linkProps = null)
{
var ls = GetLinkScenario(bean.GetKind());
var linkedKindPkValue = bean.GetKeyValue();
var linkBean = Api.FindOne(false, ls.LinkKind,
"WHERE " + ls.LinkingKindFkName + " = {0} AND " + ls.LinkedKindFkName + " = {1}",
ls.LinkingKindPkValue, linkedKindPkValue);
if (linkBean != null)
{
throw LinkAlreadyExistsException.New(ls.LinkingKind, ls.LinkedKind);
}
linkBean = Api.Dispense(ls.LinkKind);
if (linkProps != null)
{
linkBean.Import(linkProps);
}
linkBean
.Put(ls.LinkingKindFkName, ls.LinkingKindPkValue)
.Put(ls.LinkedKindFkName, linkedKindPkValue)
.Store();
return(true);
}
public Pagination <T> LPaginate <T>(bool useCache, int pageNo = 1, int perPage = 10,
string propsIgnorelist = "", string expr = null, params object[] parameters)
where T : Bean, new()
{
var kind = Bean.GetKind <T>();
var result = new Pagination <T>(Count(true, kind, expr, parameters), pageNo, perPage);
result.Data = Paginate <T>(useCache, result.CurrentPage, perPage,
propsIgnorelist, expr, parameters);
return(result);
}
/// <summary>
/// Unlinks a Bean from the current Bean when they are related in a m:n relational way.
/// </summary>
/// <param name="bean">Bean to be unlinked.</param>
/// <returns>true, if successful</returns>
public bool Unlink(Bean bean)
{
var ls = GetLinkScenario(bean.GetKind());
var linkBean = Api.FindOne(false, ls.LinkKind,
"WHERE " + ls.LinkingKindFkName + " = {0} AND " + ls.LinkedKindFkName + " = {1}",
ls.LinkingKindPkValue, bean.GetKeyValue());
linkBean?.Trash();
return(true);
}
public T[] Paginate <T>(bool useCache, int pageNo = 1, int perPage = 10,
string propsIgnorelist = "", string expr = null, params object[] parameters)
where T : Bean, new()
{
var kind = Bean.GetKind <T>();
var pagination = new Pagination(Count(true, kind, expr, parameters), pageNo, perPage);
return(Rows(useCache, kind,
$"{expr}\r\n{_details.Paginate(pagination.CurrentPage, perPage)}",
parameters)
.Select(row => _crud.RowToBean <T>(row).FCleanse <T>(propsIgnorelist))
.ToArray());
}
/// <summary>
/// Detaches a referencing Bean from the current Bean. The referencing bean
/// may be trashed (deleted) or retained in the table but then as orphaned Bean.
/// If the Foreign Key Name of the (owned) Bean differs form the
/// Name of the Owner Bean, it is possible to pass an alias name.
/// </summary>
/// <param name="bean">Bean to be detached.</param>
/// <param name="trashOwned">Delete or retain Bean as orphaned Bean.</param>
/// <param name="fkAlias">Alias for the Owner Bean's Foreign Key Name (w/o Primary Key Name)</param>
/// <returns>true, if successful</returns>
public bool DetachOwned(Bean bean, bool trashOwned = false, string fkAlias = "")
{
if (trashOwned)
{
bean.Trash();
}
else
{
var foreignKey = GetFkName(fkAlias == string.Empty ? GetKind() : fkAlias);
if (!Api.IsKnownKindColumn(bean.GetKind(), foreignKey))
{
throw MissingForeignKeyColumnException.Create(bean.GetKind(), foreignKey);
}
bean
.Put(foreignKey, null)
.Store();
}
return(true);
}
/// <summary>
/// Attaches an owner Bean in a Manner of a 1:n relation. The owner
/// represents the "1"-side of this relation. If the Foreign Key Name
/// of the (owned) Bean differs form the Name of the Owner Bean, it
/// is possible to pass an alias name.
/// </summary>
/// <param name="bean">Owner Bean</param>
/// <param name="fkAlias">Alias for the Owner Bean's Foreign Key Name (w/o Primary Key Name)</param>
/// <returns>true, if successful</returns>
public bool AttachOwner(Bean bean, string fkAlias = "")
{
var foreignKey = GetFkName(fkAlias == string.Empty ? bean.GetKind() : fkAlias);
if (!Api.IsKnownKindColumn(GetKind(), foreignKey))
{
throw MissingForeignKeyColumnException.Create(GetKind(), foreignKey);
}
Put(foreignKey, bean.GetKeyValue());
Store();
return(true);
}
/// <summary>
/// Attaches a Bean to this bean in a manner of a 1:n reference. The Bean to attach
/// has the Foreign key that references to this Bean's Id.
/// If the Foreign Key Name of the (owned) Bean differs form the
/// Name of the Owner Bean, it is possible to pass an alias name.
/// </summary>
/// <param name="bean">Bean to be attached. It references the current Bean via Foreign Key.</param>
/// <param name="fkAlias">Alias for the Owner Bean's Foreign Key Name (w/o Primary Key Name)</param>
/// <returns>true, if successful</returns>
public bool AttachOwned(Bean bean, string fkAlias = "")
{
var foreignKey = GetFkName(fkAlias == string.Empty ? GetKind() : fkAlias);
var relatingKind = bean.GetKind();
if (!Api.IsKnownKindColumn(relatingKind, foreignKey))
{
throw MissingForeignKeyColumnException.Create(relatingKind, foreignKey);
}
bean
.Put(foreignKey, GetKeyValue())
.Store();
return(true);
}
public Tuple <bool, string> Validate(Bean bean)
{
var kind = bean.GetKind();
if (!_beanRules.ContainsKey(kind))
{
return
(new Tuple <bool, string>(true, string.Empty));
}
var failures =
_beanRules[kind]
.Where(br => br.Test(bean) == false)
.Aggregate(new StringBuilder(),
(sb, br) => sb.AppendLine(br.Message), sb => sb.ToString()
);
return
(new Tuple <bool, string>(failures == string.Empty, failures));
}
public T[] Find <T>(bool useCache, string expr = null, params object[] parameters) where T : Bean, new()
{
return(Rows(useCache, Bean.GetKind <T>(), expr, parameters)
.Select(_crud.RowToBean <T>)
.ToArray());
}
public long Count <T>(bool useCache, string expr = null, params object[] parameters) where T : Bean, new()
{
return(Count(useCache, Bean.GetKind <T>(), expr, parameters));
}
public IEnumerable <T> FindIterator <T>(string expr = null, params object[] parameters) where T : Bean, new()
{
return(RowsIterator(Bean.GetKind <T>(), expr, parameters)
.Select(_crud.RowToBean <T>));
}
public T FindOne <T>(bool useCache, string expr = null, params object[] parameters) where T : Bean, new()
{
return(_crud.RowToBean <T>(Row(useCache, Bean.GetKind <T>(), expr, parameters)));
}
public bool IsNew(Bean bean)
{
return(IsNew(bean.GetKind(), bean.Export()));
}
public object Store(Bean bean)
{
EnsureDispensed(bean);
var isNew = _storage.IsNew(bean);
ImplicitTransaction(() =>
{
bean.BeforeStore();
if (isNew)
{
bean.BeforeInsert();
}
else
{
bean.BeforeUpdate();
}
foreach (var observer in _observers)
{
observer.BeforeStore(bean);
if (isNew)
{
observer.BeforeInsert(bean);
}
else
{
observer.BeforeUpdate(bean);
}
}
var key = _storage.Store(bean.GetKind(), bean.Export(), DirtyTracking ? bean.GetDirtyNames() : null);
if (key is CompoundKey)
{
// !!! compound keys must not change during insert/update
}
else
{
bean.SetKey(_keyAccess, key);
}
if (isNew)
{
bean.AfterInsert();
}
else
{
bean.AfterUpdate();
}
bean.AfterStore();
foreach (var observer in _observers)
{
if (isNew)
{
observer.AfterInsert(bean);
}
else
{
observer.AfterUpdate(bean);
}
observer.AfterStore(bean);
}
return(true);
});
bean.ForgetDirtyBackup();
return(bean.GetKey(_keyAccess));
}
public T Load <T>(object key) where T : Bean, new()
{
return(RowToBean <T>(_storage.Load(Bean.GetKind <T>(), key)));
}