public Zetbox.API.Async.ZbTask TriggerFetchChildrenAsync()
{
if (_triggerFetchChildrenTask != null) return _triggerFetchChildrenTask;
List<Zetbox.App.GUI.NavigationEntry> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchChildrenTask = Context.GetListOfAsync<Zetbox.App.GUI.NavigationEntry>(this, "Children")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchChildrenTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.GUI.NavigationEntry>();
});
}
_triggerFetchChildrenTask.OnResult(t =>
{
_Children = new OneNRelationList<Zetbox.App.GUI.NavigationEntry>(
"Parent",
"Children_pos",
this,
OnChildrenCollectionChanged,
serverList);
});
return _triggerFetchChildrenTask;
}
public OneSide(List <INSide> initialObjects)
{
_list = new OneNRelationList <INSide>("OneSide", "OneSide_pos", this, () => OnPropertyChanged("NSide"), initialObjects);
}
public Zetbox.API.Async.ZbTask TriggerFetchWorkScheduleRulesAsync()
{
if (_triggerFetchWorkScheduleRulesTask != null) return _triggerFetchWorkScheduleRulesTask;
List<Zetbox.App.Calendar.WorkScheduleRule> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchWorkScheduleRulesTask = Context.GetListOfAsync<Zetbox.App.Calendar.WorkScheduleRule>(this, "WorkScheduleRules")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchWorkScheduleRulesTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Calendar.WorkScheduleRule>();
});
}
_triggerFetchWorkScheduleRulesTask.OnResult(t =>
{
_WorkScheduleRules = new OneNRelationList<Zetbox.App.Calendar.WorkScheduleRule>(
"WorkSchedule",
null,
this,
OnWorkScheduleRulesCollectionChanged,
serverList);
});
return _triggerFetchWorkScheduleRulesTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchOrderedNSideAsync()
{
if (_triggerFetchOrderedNSideTask != null) return _triggerFetchOrderedNSideTask;
List<Zetbox.App.Test.One_to_N_relations_OrderedN> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchOrderedNSideTask = Context.GetListOfAsync<Zetbox.App.Test.One_to_N_relations_OrderedN>(this, "OrderedNSide")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchOrderedNSideTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Test.One_to_N_relations_OrderedN>();
});
}
_triggerFetchOrderedNSideTask.OnResult(t =>
{
_OrderedNSide = new OneNRelationList<Zetbox.App.Test.One_to_N_relations_OrderedN>(
"OneSide",
"OrderedNSide_pos",
this,
OnOrderedNSideCollectionChanged,
serverList);
});
return _triggerFetchOrderedNSideTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchTestCustomObjects_List_NavAsync()
{
if (_triggerFetchTestCustomObjects_List_NavTask != null) return _triggerFetchTestCustomObjects_List_NavTask;
List<Zetbox.App.Test.TestCustomObject> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchTestCustomObjects_List_NavTask = Context.GetListOfAsync<Zetbox.App.Test.TestCustomObject>(this, "TestCustomObjects_List_Nav")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchTestCustomObjects_List_NavTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Test.TestCustomObject>();
});
}
_triggerFetchTestCustomObjects_List_NavTask.OnResult(t =>
{
_TestCustomObjects_List_Nav = new OneNRelationList<Zetbox.App.Test.TestCustomObject>(
"MubBlah_Nav",
null,
this,
OnTestCustomObjects_List_NavCollectionChanged,
serverList);
});
return _triggerFetchTestCustomObjects_List_NavTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchParameterAsync()
{
if (_triggerFetchParameterTask != null) return _triggerFetchParameterTask;
List<Zetbox.App.Base.BaseParameter> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchParameterTask = Context.GetListOfAsync<Zetbox.App.Base.BaseParameter>(this, "Parameter")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchParameterTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Base.BaseParameter>();
});
}
_triggerFetchParameterTask.OnResult(t =>
{
_Parameter = new OneNRelationList<Zetbox.App.Base.BaseParameter>(
"Method",
"Parameter_pos",
this,
OnParameterCollectionChanged,
serverList);
});
return _triggerFetchParameterTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchEnumEntriesAsync()
{
if (_triggerFetchEnumEntriesTask != null) return _triggerFetchEnumEntriesTask;
List<Zetbox.App.SchemaMigration.SourceEnum> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchEnumEntriesTask = Context.GetListOfAsync<Zetbox.App.SchemaMigration.SourceEnum>(this, "EnumEntries")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchEnumEntriesTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.SchemaMigration.SourceEnum>();
});
}
_triggerFetchEnumEntriesTask.OnResult(t =>
{
_EnumEntries = new OneNRelationList<Zetbox.App.SchemaMigration.SourceEnum>(
"SourceColumn",
null,
this,
OnEnumEntriesCollectionChanged,
serverList);
});
return _triggerFetchEnumEntriesTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchSubClassesAsync()
{
if (_triggerFetchSubClassesTask != null) return _triggerFetchSubClassesTask;
List<Zetbox.App.Base.ObjectClass> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchSubClassesTask = Context.GetListOfAsync<Zetbox.App.Base.ObjectClass>(this, "SubClasses")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchSubClassesTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Base.ObjectClass>();
});
}
_triggerFetchSubClassesTask.OnResult(t =>
{
_SubClasses = new OneNRelationList<Zetbox.App.Base.ObjectClass>(
"BaseObjectClass",
null,
this,
OnSubClassesCollectionChanged,
serverList);
});
return _triggerFetchSubClassesTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchNEndsAsync()
{
if (_triggerFetchNEndsTask != null) return _triggerFetchNEndsTask;
List<Zetbox.App.Test.OrderedNEnd> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchNEndsTask = Context.GetListOfAsync<Zetbox.App.Test.OrderedNEnd>(this, "NEnds")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchNEndsTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Test.OrderedNEnd>();
});
}
_triggerFetchNEndsTask.OnResult(t =>
{
_NEnds = new OneNRelationList<Zetbox.App.Test.OrderedNEnd>(
"OneEnd",
"NEnds_pos",
this,
OnNEndsCollectionChanged,
serverList);
});
return _triggerFetchNEndsTask;
}
public OneSide(List<INSide> initialObjects)
{
_list = new OneNRelationList<INSide>("OneSide", "OneSide_pos", this, () => OnPropertyChanged("NSide"), initialObjects);
}
public Zetbox.API.Async.ZbTask TriggerFetchFilterConfigurationsAsync()
{
if (_triggerFetchFilterConfigurationsTask != null) return _triggerFetchFilterConfigurationsTask;
List<Zetbox.App.GUI.ObjectClassFilterConfiguration> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchFilterConfigurationsTask = Context.GetListOfAsync<Zetbox.App.GUI.ObjectClassFilterConfiguration>(this, "FilterConfigurations")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchFilterConfigurationsTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.GUI.ObjectClassFilterConfiguration>();
});
}
_triggerFetchFilterConfigurationsTask.OnResult(t =>
{
_FilterConfigurations = new OneNRelationList<Zetbox.App.GUI.ObjectClassFilterConfiguration>(
"ObjectClass",
null,
this,
OnFilterConfigurationsCollectionChanged,
serverList);
});
return _triggerFetchFilterConfigurationsTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchAntwortenAsync()
{
if (_triggerFetchAntwortenTask != null) return _triggerFetchAntwortenTask;
List<Zetbox.App.Test.Antwort> serverList = null;
if (Helper.IsPersistedObject(this))
{
if (AntwortenIds != null)
{
_triggerFetchAntwortenTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = AntwortenIds.Select(id => Context.Find<Zetbox.App.Test.Antwort>(id)).ToList();
AntwortenIds = null; // allow id list to be garbage collected
});
}
else
{
_triggerFetchAntwortenTask = Context.GetListOfAsync<Zetbox.App.Test.Antwort>(this, "Antworten")
.OnResult(t =>
{
serverList = t.Result;
});
}
}
else
{
_triggerFetchAntwortenTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Test.Antwort>();
});
}
_triggerFetchAntwortenTask.OnResult(t =>
{
_Antworten = new OneNRelationList<Zetbox.App.Test.Antwort>(
"Fragebogen",
"gute_Antworten_pos",
this,
OnAntwortenCollectionChanged,
serverList);
});
return _triggerFetchAntwortenTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchStagingDatabasesAsync()
{
if (_triggerFetchStagingDatabasesTask != null) return _triggerFetchStagingDatabasesTask;
List<Zetbox.App.SchemaMigration.StagingDatabase> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchStagingDatabasesTask = Context.GetListOfAsync<Zetbox.App.SchemaMigration.StagingDatabase>(this, "StagingDatabases")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchStagingDatabasesTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.SchemaMigration.StagingDatabase>();
});
}
_triggerFetchStagingDatabasesTask.OnResult(t =>
{
_StagingDatabases = new OneNRelationList<Zetbox.App.SchemaMigration.StagingDatabase>(
"MigrationProject",
null,
this,
OnStagingDatabasesCollectionChanged,
serverList);
});
return _triggerFetchStagingDatabasesTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchMethodsAsync()
{
if (_triggerFetchMethodsTask != null) return _triggerFetchMethodsTask;
List<Zetbox.App.Base.Method> serverList = null;
if (Helper.IsPersistedObject(this))
{
if (MethodsIds != null)
{
_triggerFetchMethodsTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = MethodsIds.Select(id => Context.Find<Zetbox.App.Base.Method>(id)).ToList();
MethodsIds = null; // allow id list to be garbage collected
});
}
else
{
_triggerFetchMethodsTask = Context.GetListOfAsync<Zetbox.App.Base.Method>(this, "Methods")
.OnResult(t =>
{
serverList = t.Result;
});
}
}
else
{
_triggerFetchMethodsTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Base.Method>();
});
}
_triggerFetchMethodsTask.OnResult(t =>
{
_Methods = new OneNRelationList<Zetbox.App.Base.Method>(
"ObjectClass",
null,
this,
OnMethodsCollectionChanged,
serverList);
});
return _triggerFetchMethodsTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchConstraintsAsync()
{
if (_triggerFetchConstraintsTask != null) return _triggerFetchConstraintsTask;
List<Zetbox.App.Base.InstanceConstraint> serverList = null;
if (Helper.IsPersistedObject(this))
{
if (ConstraintsIds != null)
{
_triggerFetchConstraintsTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = ConstraintsIds.Select(id => Context.Find<Zetbox.App.Base.InstanceConstraint>(id)).ToList();
ConstraintsIds = null; // allow id list to be garbage collected
});
}
else
{
_triggerFetchConstraintsTask = Context.GetListOfAsync<Zetbox.App.Base.InstanceConstraint>(this, "Constraints")
.OnResult(t =>
{
serverList = t.Result;
});
}
}
else
{
_triggerFetchConstraintsTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Base.InstanceConstraint>();
});
}
_triggerFetchConstraintsTask.OnResult(t =>
{
_Constraints = new OneNRelationList<Zetbox.App.Base.InstanceConstraint>(
"Constrained",
null,
this,
OnConstraintsCollectionChanged,
serverList);
});
return _triggerFetchConstraintsTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchTasksAsync()
{
if (_triggerFetchTasksTask != null) return _triggerFetchTasksTask;
List<Zetbox.App.Projekte.Task> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchTasksTask = Context.GetListOfAsync<Zetbox.App.Projekte.Task>(this, "Tasks")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchTasksTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Projekte.Task>();
});
}
_triggerFetchTasksTask.OnResult(t =>
{
_Tasks = new OneNRelationList<Zetbox.App.Projekte.Task>(
"Projekt",
null,
this,
OnTasksCollectionChanged,
serverList);
});
return _triggerFetchTasksTask;
}
