/// <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); } }