/// <summary>
/// Liefert die mit den aktuellen Einstellungen gefilterte und sortierte Menge zurück
/// </summary>
/// <param name="sortType"></param>
/// <returns></returns>
public IQueryable <TEntityView> selectSorted(string sortType)
{
try
{
int entityCount = selectCount("");
if (entityCount > 0)
{
var views = new List <TEntityView>(entityCount);
// Dummy für die definition neuer Datensätze am Anfang aufnehmen
var dummy = createDummy();
if (dummy != null)
{
views.Add(dummy);
}
foreach (var entity in sort(filter(EntityCollection)))
{
views.Add(CreateView(entity));
}
return(views.AsQueryable());
}
else
{
return((new List <TEntityView>()).AsQueryable());
}
}
catch (Exception ex)
{
throw BoBaseException.Create("selectSorted", ex);
}
}
/// <summary>
/// Wendet auf die Menge der Entites alle definierten Filter an. Das Ergebnis ist die
/// gefilterte Menge. Diese wird anschließend sortiert
/// </summary>
/// <returns></returns>
public IQueryable<TEntity> ApplyFilterAndSort()
{
try
{
return sort(filter(EntityCollection));
}
catch (Exception ex)
{
throw BoBaseException.Create("ApplyFilterAndSort", ex);
}
}
//----------------------------------------------------------------------------------------------------------------
// Existenztests
/// <summary>
/// Prüft, ob die gefilterte Menge überhaupt ein Element enthält
/// </summary>
/// <returns></returns>
public bool Any()
{
try
{
return filter(EntityCollection).Any();
}
catch (Exception ex)
{
throw BoBaseException.Create("Any", ex);
}
}
/// <summary>
/// Wendet auf die Menge der Entites alle definierten Filter an. Das Ergebnis ist die
/// gefilterte Menge. Diese wird anschließend nach mehreren Spalten sortiert
/// </summary>
/// <returns></returns>
public IQueryable<TEntity> ApplyFilterAndMultiSort()
{
try
{
if (MultisortOn)
return multiSort(filter(EntityCollection));
else
throw new Exception("Multisort aktuell abgeschaltet. Damit ist ApplyFilterAndMultisort unzulässig");
}
catch (Exception ex)
{
throw BoBaseException.Create("ApplyFilterAndMultiSort", ex);
}
}
public override void Delete(int id)
{
try
{
var entity = ORMContext.EventLog.Where(r => r.id == id).First();
ORMContext.EventLog.DeleteOnSubmit(entity);
ORMContext.SubmitChanges();
}
catch (Exception ex)
{
throw BoBaseException.Create("delete", ex);
}
}
public void deleteAll()
{
try
{
var all = ORMContext.EventLog;
ORMContext.EventLog.DeleteAllOnSubmit(all);
ORMContext.SubmitChanges();
}
catch (Exception ex)
{
throw BoBaseException.Create("deleteAll", ex);
}
}
public int selectCount(string sortType, int StartRowIndex, int PageSize)
{
try
{
int count = filter(EntityCollection).Count();
// Wenn ein Dummy erzeugt wird, dann ist dieser mitzuzählen
var dummy = createDummy();
return(dummy == null ? count : count + 1);
}
catch (Exception ex)
{
throw BoBaseException.Create("selectCount", ex);
}
}
/// <summary>
/// Wendet eine Aktion auf alle Elemente einer gefilterten und sortierten Menge an
/// </summary>
/// <param name="processView">Anzuwendende Aktion(z.B. Lambda- Ausdruck)</param>
public void ForEachSortedAndSelected(Action<TEntityView> processView)
{
try
{
if (Any())
{
foreach (var entity in sort(filter(EntityCollection)))
{
processView(CreateView(entity));
}
}
}
catch (Exception ex)
{
throw BoBaseException.Create("ForEachSelected", ex);
}
}
public List <string> GetFileNameStartsWith(string Prefix, int SetCount)
{
try
{
if (SetCount > 0)
{
return(ORMContext.Files.Where(r => r.filename.StartsWith(Prefix)).Take(SetCount).Select(r => r.filename).ToList());
}
else
{
return(ORMContext.Files.Where(r => r.filename.StartsWith(Prefix)).Select(r => r.filename).ToList());
}
}
catch (Exception ex)
{
throw BoBaseException.Create("GetFilenameStartsWith", ex);
}
}
/// <summary>
/// Aktualisieren eines Entity mit den Daten aus der View
/// </summary>
/// <param name="view"></param>
public virtual void Update(TEntityView view)
{
Type viewType = view.GetType();
// Die Defaultlogik gilt nur für Views, die IEntityView implementieren
if (view is IEntityView <TEntity, TEntityId> )
{
try
{
var iview = (IEntityView <TEntity, TEntityId>)view;
if (iview.IsDummyView)
{
Debug.WriteLine("Update: Neues Entity wird eingefügt");
var entity = CreateEntity();
iview.SetEntity(entity);
iview.UpdateEntity();
AddEntityToEntityCollection(iview.Entity);
}
else
{
var flt = CreateIdFilter(iview.Id);
var tab = flt.filterImpl(EntityCollection);
if (!tab.Any())
{
Debug.WriteLine("Update: Entity mit der Id" + iview.Id.ToString() + " existiert und wird aktualisiert werden");
var entity = tab.First();
iview.SetEntity(entity);
iview.UpdateEntity();
}
}
SubmitChanges();
}
catch (Exception ex)
{
throw BoBaseException.Create("Update", ex);
}
}
else
{
throw BoBaseException.Create("Update: View implementiert keine IEntityView Schnittstelle. Die allgemeine BoBase.Update Methode kann keine Aktualisierung durchführen");
}
}
/// <summary>
/// Zugriff auf ein Entity, das durch seine id identifiziert wird. Muß in abgeleiteten
/// Klassen implementiert werden.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public IQueryable<TEntityView> selectById(TEntityId id)
{
try
{
var lst = new List<TEntityView>(1);
var flt = CreateIdFilter(id);
var tab = flt.filterImpl(EntityCollection);
if (tab.Any())
lst.Add(CreateView(tab.First()));
return lst.AsQueryable();
}
catch (Exception ex)
{
throw BoBaseException.Create("selectById", ex);
}
}
/// <summary>
/// Liefert einen Ausschnitt aus dre mit den aktuellen Einstellungen gefilterte und sortierte Menge zurück.
/// </summary>
/// <param name="sortType"></param>
/// <param name="StartRowIndex"></param>
/// <param name="PageSize"></param>
/// <returns></returns>
public IQueryable<TEntityView> selectSorted(string sortType, int StartRowIndex, int PageSize)
{
try
{
var views = new List<TEntityView>(PageSize);
// Dummy für die definition neuer Datensätze am Anfang aufnehmen
var dummy = createDummy();
if (dummy != null)
views.Add(dummy);
foreach (var entity in sort(filter(EntityCollection)).Skip(StartRowIndex).Take(PageSize))
{
views.Add(CreateView(entity));
}
return views.AsQueryable();
}
catch (Exception ex)
{
throw BoBaseException.Create("selectSorted", ex);
}
}
/// <summary>
/// Implementiert das Sortieren nach beliebiger Spalte für die Objektdatasource
/// </summary>
/// <param name="tab"></param>
/// <returns></returns>
public IQueryable <TEntity> sort(IQueryable <TEntity> tab)
{
if (string.IsNullOrEmpty(_sortColname))
{
_sortColname = _defaultSortCol;
}
if (tab == null)
{
return(null);
}
if (tab.Count() == 0)
{
return(tab);
}
if (string.IsNullOrEmpty(_sortColname))
{
// Fall: keine Sortierung erwünscht
return(tab);
}
else if (typeof(TEntityView).GetProperty(_sortColname) != null)
{
// Fall: Die Spalte stammt aus der aktuellen View
// Namen der Eigenschaft einer EntityView auf die Eigenschaft eines zugrundeliegenden Entity abbilden
string Colname = mapPropertyToColName(typeof(TEntityView), _sortColname);
// Sortieren bezüglich abgeleiteter Spalten in den Views
IQueryable <TEntity> tabff;
if (sortByDerivat(tab, Colname, _sortDesc, out tabff))
{
return(tabff);
}
// Wenn die Spalte keine abgeleitete Spalte ist, dann sortieren nach den tatsächlichen Spalten
return(OrderFunc <TEntity>(tab, Colname, _sortDesc));
}
else
{
// Fall: Die Spalte stammt aus einer anderen View als der aktuellen
// Feststellen, aus welcher View der ColName stammt
foreach (Type tview in AllEntityViewTypes())
{
// Nur Views != aktuellen View betrachten
if (tview != typeof(TEntityView))
{
System.Reflection.PropertyInfo pinfo = tview.GetProperty(_sortColname);
if (pinfo != null)
{
// Instanz des Sortieres für die andere View erstellen
Type[] constuctorArgTypes = Type.EmptyTypes;
System.Reflection.ConstructorInfo ctor = GetBoThatInclude(tview).GetConstructor(constuctorArgTypes);
Debug.Assert(ctor != null, "Der Konstruktor der Business Objekt");
object[] constructorArgs = { };
object boOther = ctor.Invoke(constructorArgs);
// Eigenschaften des neuen Business- Objektes setzen
System.Reflection.PropertyInfo propSort = GetBoThatInclude(tview).GetProperty("SortColumn");
propSort.SetValue(boOther, _sortColname, null);
System.Reflection.PropertyInfo propSortDir = GetBoThatInclude(tview).GetProperty("SortDirection");
propSortDir.SetValue(boOther, SortDirection, null);
// sort- Methode aufrufen
Type[] sortArgTypes = new Type[] { typeof(IQueryable <TEntity>) };
System.Reflection.MethodInfo miSort = GetBoThatInclude(tview).GetMethod("sort", sortArgTypes);
Debug.Assert(miSort != null, "Die Sortiermethode ist im Business- Objekt nicht enthalten");
object[] sortArgs = { tab };
return(miSort.Invoke(boOther, sortArgs) as IQueryable <TEntity>);
}
}
}
//return tab;
// Fehler, falls Spalte nicht gefunden wurde
throw BoBaseException.Create("sort", null);
}
}
