public Zetbox.API.Async.ZbTask TriggerFetchChildrenAsync()
{
if (_triggerFetchChildrenTask != null) return _triggerFetchChildrenTask;
List<Zetbox.App.Test.MethodTest> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchChildrenTask = Context.GetListOfAsync<Zetbox.App.Test.MethodTest>(this, "Children")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchChildrenTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Test.MethodTest>();
});
}
_triggerFetchChildrenTask.OnResult(t =>
{
_Children = new OneNRelationList<Zetbox.App.Test.MethodTest>(
"Parent",
null,
this,
OnChildrenCollectionChanged,
serverList);
});
return _triggerFetchChildrenTask;
}
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 Zetbox.API.Async.ZbTask TriggerFetchAccessControlListAsync()
{
if (_triggerFetchAccessControlListTask != null) return _triggerFetchAccessControlListTask;
List<Zetbox.App.Base.AccessControl> serverList = null;
if (Helper.IsPersistedObject(this))
{
_triggerFetchAccessControlListTask = Context.GetListOfAsync<Zetbox.App.Base.AccessControl>(this, "AccessControlList")
.OnResult(t =>
{
serverList = t.Result;
});
}
else
{
_triggerFetchAccessControlListTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, () =>
{
serverList = new List<Zetbox.App.Base.AccessControl>();
});
}
_triggerFetchAccessControlListTask.OnResult(t =>
{
_AccessControlList = new OneNRelationList<Zetbox.App.Base.AccessControl>(
"ObjectClass",
null,
this,
OnAccessControlListCollectionChanged,
serverList);
});
return _triggerFetchAccessControlListTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchBSideAsync()
{
if (_triggerFetchBSideTask != null) return _triggerFetchBSideTask;
_triggerFetchBSideTask = Context.FetchRelationAsync<Zetbox.App.Test.ASide_connectsTo_BSide_RelationEntryMemoryImpl>(new Guid("3555da6e-0e9b-4f7c-903e-a51f3cce7cd9"), RelationEndRole.A, this);
_triggerFetchBSideTask.OnResult(r =>
{
_BSide
= new ObservableBSideCollectionWrapper<Zetbox.App.Test.N_to_M_relations_A, Zetbox.App.Test.N_to_M_relations_B, Zetbox.App.Test.ASide_connectsTo_BSide_RelationEntryMemoryImpl, ICollection<Zetbox.App.Test.ASide_connectsTo_BSide_RelationEntryMemoryImpl>>(
this,
new RelationshipFilterASideCollection<Zetbox.App.Test.ASide_connectsTo_BSide_RelationEntryMemoryImpl>(this.Context, this));
// _BSide.CollectionChanged is managed by OnBSideCollectionChanged() and called from the RelationEntry
});
return _triggerFetchBSideTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchRelationsAsync()
{
if (_triggerFetchRelationsTask != null) return _triggerFetchRelationsTask;
_triggerFetchRelationsTask = Context.FetchRelationAsync<Zetbox.App.Base.RoleMembership_resolves_Relations_RelationEntryMemoryImpl>(new Guid("f74d425f-e733-4cba-baca-f4a05fbc0a80"), RelationEndRole.A, this);
_triggerFetchRelationsTask.OnResult(r =>
{
_Relations
= new ObservableBSideListWrapper<Zetbox.App.Base.RoleMembership, Zetbox.App.Base.Relation, Zetbox.App.Base.RoleMembership_resolves_Relations_RelationEntryMemoryImpl, ICollection<Zetbox.App.Base.RoleMembership_resolves_Relations_RelationEntryMemoryImpl>>(
this,
new RelationshipFilterASideCollection<Zetbox.App.Base.RoleMembership_resolves_Relations_RelationEntryMemoryImpl>(this.Context, this));
// _Relations.CollectionChanged is managed by OnRelationsCollectionChanged() and called from the RelationEntry
});
return _triggerFetchRelationsTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchInputsAsync()
{
if (_triggerFetchInputsTask != null) return _triggerFetchInputsTask;
if (!Inputs_was_eagerLoaded) _triggerFetchInputsTask = Context.FetchRelationAsync<Zetbox.App.Base.CalculatedReference_dependsOn_InputProperties_RelationEntryMemoryImpl>(new Guid("47595643-e8d0-48ef-82c7-2d24de8a784e"), RelationEndRole.A, this);
else _triggerFetchInputsTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, null);
_triggerFetchInputsTask.OnResult(r =>
{
_Inputs
= new ObservableBSideCollectionWrapper<Zetbox.App.Base.CalculatedObjectReferenceProperty, Zetbox.App.Base.Property, Zetbox.App.Base.CalculatedReference_dependsOn_InputProperties_RelationEntryMemoryImpl, ICollection<Zetbox.App.Base.CalculatedReference_dependsOn_InputProperties_RelationEntryMemoryImpl>>(
this,
new RelationshipFilterASideCollection<Zetbox.App.Base.CalculatedReference_dependsOn_InputProperties_RelationEntryMemoryImpl>(this.Context, this));
// _Inputs.CollectionChanged is managed by OnInputsCollectionChanged() and called from the RelationEntry
});
return _triggerFetchInputsTask;
}
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<Zetbox.App.Base.CompoundObject> TriggerFetchCompoundObjectDefinitionAsync()
{
if (_triggerFetchCompoundObjectDefinitionTask != null) return _triggerFetchCompoundObjectDefinitionTask;
if (_fk_CompoundObjectDefinition.HasValue)
_triggerFetchCompoundObjectDefinitionTask = Context.FindAsync<Zetbox.App.Base.CompoundObject>(_fk_CompoundObjectDefinition.Value);
else
_triggerFetchCompoundObjectDefinitionTask = new Zetbox.API.Async.ZbTask<Zetbox.App.Base.CompoundObject>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchCompoundObjectDefinitionTask.OnResult(t =>
{
if (OnCompoundObjectDefinition_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.Base.CompoundObject>(t.Result);
OnCompoundObjectDefinition_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchCompoundObjectDefinitionTask;
}
public Zetbox.API.Async.ZbTask<Zetbox.App.Calendar.WorkSchedule> TriggerFetchBaseWorkScheduleAsync()
{
if (_triggerFetchBaseWorkScheduleTask != null) return _triggerFetchBaseWorkScheduleTask;
if (_fk_BaseWorkSchedule.HasValue)
_triggerFetchBaseWorkScheduleTask = Context.FindAsync<Zetbox.App.Calendar.WorkSchedule>(_fk_BaseWorkSchedule.Value);
else
_triggerFetchBaseWorkScheduleTask = new Zetbox.API.Async.ZbTask<Zetbox.App.Calendar.WorkSchedule>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchBaseWorkScheduleTask.OnResult(t =>
{
if (OnBaseWorkSchedule_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.Calendar.WorkSchedule>(t.Result);
OnBaseWorkSchedule_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchBaseWorkScheduleTask;
}
public Zetbox.API.Async.ZbTask<Zetbox.App.Base.Identity> TriggerFetchChangedByAsync()
{
if (_triggerFetchChangedByTask != null) return _triggerFetchChangedByTask;
if (_fk_ChangedBy.HasValue)
_triggerFetchChangedByTask = Context.FindAsync<Zetbox.App.Base.Identity>(_fk_ChangedBy.Value);
else
_triggerFetchChangedByTask = new Zetbox.API.Async.ZbTask<Zetbox.App.Base.Identity>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchChangedByTask.OnResult(t =>
{
if (OnChangedBy_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.Base.Identity>(t.Result);
OnChangedBy_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchChangedByTask;
}
public Zetbox.API.Async.ZbTask<Zetbox.App.Base.Relation> TriggerFetchAParentAsync()
{
if (_triggerFetchAParentTask != null) return _triggerFetchAParentTask;
if (_fk_AParent.HasValue)
_triggerFetchAParentTask = Context.FindAsync<Zetbox.App.Base.Relation>(_fk_AParent.Value);
else
_triggerFetchAParentTask = new Zetbox.API.Async.ZbTask<Zetbox.App.Base.Relation>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchAParentTask.OnResult(t =>
{
if (OnAParent_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.Base.Relation>(t.Result);
OnAParent_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchAParentTask;
}
public Zetbox.API.Async.ZbTask<Zetbox.App.GUI.ViewModelDescriptor> TriggerFetchDefaultPropertyViewModelDescriptorAsync()
{
if (_triggerFetchDefaultPropertyViewModelDescriptorTask != null) return _triggerFetchDefaultPropertyViewModelDescriptorTask;
if (_fk_DefaultPropertyViewModelDescriptor.HasValue)
_triggerFetchDefaultPropertyViewModelDescriptorTask = Context.FindAsync<Zetbox.App.GUI.ViewModelDescriptor>(_fk_DefaultPropertyViewModelDescriptor.Value);
else
_triggerFetchDefaultPropertyViewModelDescriptorTask = new Zetbox.API.Async.ZbTask<Zetbox.App.GUI.ViewModelDescriptor>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchDefaultPropertyViewModelDescriptorTask.OnResult(t =>
{
if (OnDefaultPropertyViewModelDescriptor_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.GUI.ViewModelDescriptor>(t.Result);
OnDefaultPropertyViewModelDescriptor_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchDefaultPropertyViewModelDescriptorTask;
}
public Zetbox.API.Async.ZbTask<at.dasz.DocumentManagement.File> TriggerFetchFileAsync()
{
if (_triggerFetchFileTask != null) return _triggerFetchFileTask;
if (_fk_File.HasValue)
_triggerFetchFileTask = Context.FindAsync<at.dasz.DocumentManagement.File>(_fk_File.Value);
else
_triggerFetchFileTask = new Zetbox.API.Async.ZbTask<at.dasz.DocumentManagement.File>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchFileTask.OnResult(t =>
{
if (OnFile_Getter != null)
{
var e = new PropertyGetterEventArgs<at.dasz.DocumentManagement.File>(t.Result);
OnFile_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchFileTask;
}
public Zetbox.API.Async.ZbTask<Zetbox.App.GUI.ControlKind> TriggerFetchControlKindAsync()
{
if (_triggerFetchControlKindTask != null) return _triggerFetchControlKindTask;
if (_fk_ControlKind.HasValue)
_triggerFetchControlKindTask = Context.FindAsync<Zetbox.App.GUI.ControlKind>(_fk_ControlKind.Value);
else
_triggerFetchControlKindTask = new Zetbox.API.Async.ZbTask<Zetbox.App.GUI.ControlKind>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchControlKindTask.OnResult(t =>
{
if (OnControlKind_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.GUI.ControlKind>(t.Result);
OnControlKind_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchControlKindTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchMemberAsync()
{
if (_triggerFetchMemberTask != null) return _triggerFetchMemberTask;
_triggerFetchMemberTask = Context.FetchRelationAsync<Zetbox.App.Base.Identities_memberOf_Groups_RelationEntryMemoryImpl>(new Guid("3efb7ae8-ba6b-40e3-9482-b45d1c101743"), RelationEndRole.B, this);
_triggerFetchMemberTask.OnResult(r =>
{
_Member
= new ObservableASideCollectionWrapper<Zetbox.App.Base.Identity, Zetbox.App.Base.Group, Zetbox.App.Base.Identities_memberOf_Groups_RelationEntryMemoryImpl, ICollection<Zetbox.App.Base.Identities_memberOf_Groups_RelationEntryMemoryImpl>>(
this,
new RelationshipFilterBSideCollection<Zetbox.App.Base.Identities_memberOf_Groups_RelationEntryMemoryImpl>(this.Context, this));
// _Member.CollectionChanged is managed by OnMemberCollectionChanged() and called from the RelationEntry
});
return _triggerFetchMemberTask;
}
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 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 TriggerFetchShowByPropertiesAsync()
{
if (_triggerFetchShowByPropertiesTask != null) return _triggerFetchShowByPropertiesTask;
_triggerFetchShowByPropertiesTask = Context.FetchRelationAsync<Zetbox.App.GUI.ObjRefProp_shows_Methods_RelationEntryMemoryImpl>(new Guid("02b3e9d5-fc2e-4ffe-8867-0977b88437cc"), RelationEndRole.B, this);
_triggerFetchShowByPropertiesTask.OnResult(r =>
{
_ShowByProperties
= new ObservableASideCollectionWrapper<Zetbox.App.Base.ObjectReferenceProperty, Zetbox.App.Base.Method, Zetbox.App.GUI.ObjRefProp_shows_Methods_RelationEntryMemoryImpl, ICollection<Zetbox.App.GUI.ObjRefProp_shows_Methods_RelationEntryMemoryImpl>>(
this,
new RelationshipFilterBSideCollection<Zetbox.App.GUI.ObjRefProp_shows_Methods_RelationEntryMemoryImpl>(this.Context, this));
// _ShowByProperties.CollectionChanged is managed by OnShowByPropertiesCollectionChanged() and called from the RelationEntry
});
return _triggerFetchShowByPropertiesTask;
}
public Zetbox.API.Async.ZbTask<Zetbox.App.SchemaMigration.SourceTable> TriggerFetchSourceTableAsync()
{
if (_triggerFetchSourceTableTask != null) return _triggerFetchSourceTableTask;
if (_fk_SourceTable.HasValue)
_triggerFetchSourceTableTask = Context.FindAsync<Zetbox.App.SchemaMigration.SourceTable>(_fk_SourceTable.Value);
else
_triggerFetchSourceTableTask = new Zetbox.API.Async.ZbTask<Zetbox.App.SchemaMigration.SourceTable>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchSourceTableTask.OnResult(t =>
{
if (OnSourceTable_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.SchemaMigration.SourceTable>(t.Result);
OnSourceTable_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchSourceTableTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchRevisionsAsync()
{
if (_triggerFetchRevisionsTask != null) return _triggerFetchRevisionsTask;
_triggerFetchRevisionsTask = Context.FetchRelationAsync<at.dasz.DocumentManagement.Document_has_Revisions_RelationEntryMemoryImpl>(new Guid("69d27812-e981-443b-a94b-dfe1a95f3aad"), RelationEndRole.A, this);
_triggerFetchRevisionsTask.OnResult(r =>
{
_Revisions
= new ObservableBSideListWrapper<at.dasz.DocumentManagement.File, Zetbox.App.Base.Blob, at.dasz.DocumentManagement.Document_has_Revisions_RelationEntryMemoryImpl, ICollection<at.dasz.DocumentManagement.Document_has_Revisions_RelationEntryMemoryImpl>>(
this,
new RelationshipFilterASideCollection<at.dasz.DocumentManagement.Document_has_Revisions_RelationEntryMemoryImpl>(this.Context, this));
// _Revisions.CollectionChanged is managed by OnRevisionsCollectionChanged() and called from the RelationEntry
});
return _triggerFetchRevisionsTask;
}
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<Zetbox.App.Test.One_to_N_relations_One> TriggerFetchOneSideAsync()
{
if (_triggerFetchOneSideTask != null) return _triggerFetchOneSideTask;
if (_fk_OneSide.HasValue)
_triggerFetchOneSideTask = Context.FindAsync<Zetbox.App.Test.One_to_N_relations_One>(_fk_OneSide.Value);
else
_triggerFetchOneSideTask = new Zetbox.API.Async.ZbTask<Zetbox.App.Test.One_to_N_relations_One>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchOneSideTask.OnResult(t =>
{
if (OnOneSide_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.Test.One_to_N_relations_One>(t.Result);
OnOneSide_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchOneSideTask;
}
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 TriggerFetchGroupsAsync()
{
if (_triggerFetchGroupsTask != null) return _triggerFetchGroupsTask;
if (!Groups_was_eagerLoaded) _triggerFetchGroupsTask = Context.FetchRelationAsync<Zetbox.App.GUI.NavigationScreen_accessed_by_Groups_RelationEntryMemoryImpl>(new Guid("b88c12ac-eabe-4aee-913e-5edd9d2a193a"), RelationEndRole.A, this);
else _triggerFetchGroupsTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, null);
_triggerFetchGroupsTask.OnResult(r =>
{
_Groups
= new ObservableBSideCollectionWrapper<Zetbox.App.GUI.NavigationEntry, Zetbox.App.Base.Group, Zetbox.App.GUI.NavigationScreen_accessed_by_Groups_RelationEntryMemoryImpl, ICollection<Zetbox.App.GUI.NavigationScreen_accessed_by_Groups_RelationEntryMemoryImpl>>(
this,
new RelationshipFilterASideCollection<Zetbox.App.GUI.NavigationScreen_accessed_by_Groups_RelationEntryMemoryImpl>(this.Context, this));
// _Groups.CollectionChanged is managed by OnGroupsCollectionChanged() and called from the RelationEntry
});
return _triggerFetchGroupsTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchTestCustomObjects_ManyList_NavAsync()
{
if (_triggerFetchTestCustomObjects_ManyList_NavTask != null) return _triggerFetchTestCustomObjects_ManyList_NavTask;
_triggerFetchTestCustomObjects_ManyList_NavTask = Context.FetchRelationAsync<Zetbox.App.Test.MB_Many_Role_has_TCO_ManyList_Role_RelationEntryMemoryImpl>(new Guid("d1e0da3e-ce64-4587-b62d-70c0f4371d97"), RelationEndRole.A, this);
_triggerFetchTestCustomObjects_ManyList_NavTask.OnResult(r =>
{
_TestCustomObjects_ManyList_Nav
= new ObservableBSideCollectionWrapper<Zetbox.App.Test.Muhblah, Zetbox.App.Test.TestCustomObject, Zetbox.App.Test.MB_Many_Role_has_TCO_ManyList_Role_RelationEntryMemoryImpl, ICollection<Zetbox.App.Test.MB_Many_Role_has_TCO_ManyList_Role_RelationEntryMemoryImpl>>(
this,
new RelationshipFilterASideCollection<Zetbox.App.Test.MB_Many_Role_has_TCO_ManyList_Role_RelationEntryMemoryImpl>(this.Context, this));
// _TestCustomObjects_ManyList_Nav.CollectionChanged is managed by OnTestCustomObjects_ManyList_NavCollectionChanged() and called from the RelationEntry
});
return _triggerFetchTestCustomObjects_ManyList_NavTask;
}
public Zetbox.API.Async.ZbTask<Zetbox.App.Base.ObjectClass> TriggerFetchTypeAsync()
{
if (_triggerFetchTypeTask != null) return _triggerFetchTypeTask;
if (_fk_Type.HasValue)
_triggerFetchTypeTask = Context.FindAsync<Zetbox.App.Base.ObjectClass>(_fk_Type.Value);
else
_triggerFetchTypeTask = new Zetbox.API.Async.ZbTask<Zetbox.App.Base.ObjectClass>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchTypeTask.OnResult(t =>
{
if (OnType_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.Base.ObjectClass>(t.Result);
OnType_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchTypeTask;
}
public Zetbox.API.Async.ZbTask<Zetbox.App.Test.TestCustomObject> TriggerFetchTestCustomObjects_One_NavAsync()
{
if (_triggerFetchTestCustomObjects_One_NavTask != null) return _triggerFetchTestCustomObjects_One_NavTask;
if (_fk_TestCustomObjects_One_Nav.HasValue)
_triggerFetchTestCustomObjects_One_NavTask = Context.FindAsync<Zetbox.App.Test.TestCustomObject>(_fk_TestCustomObjects_One_Nav.Value);
else
_triggerFetchTestCustomObjects_One_NavTask = new Zetbox.API.Async.ZbTask<Zetbox.App.Test.TestCustomObject>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchTestCustomObjects_One_NavTask.OnResult(t =>
{
if (OnTestCustomObjects_One_Nav_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.Test.TestCustomObject>(t.Result);
OnTestCustomObjects_One_Nav_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchTestCustomObjects_One_NavTask;
}
public Zetbox.API.Async.ZbTask<Zetbox.App.Base.ObjectReferenceProperty> TriggerFetchNavigatorAsync()
{
if (_triggerFetchNavigatorTask != null) return _triggerFetchNavigatorTask;
if (_fk_Navigator.HasValue)
_triggerFetchNavigatorTask = Context.FindAsync<Zetbox.App.Base.ObjectReferenceProperty>(_fk_Navigator.Value);
else
_triggerFetchNavigatorTask = new Zetbox.API.Async.ZbTask<Zetbox.App.Base.ObjectReferenceProperty>(Zetbox.API.Async.ZbTask.Synchron, () => null);
_triggerFetchNavigatorTask.OnResult(t =>
{
if (OnNavigator_Getter != null)
{
var e = new PropertyGetterEventArgs<Zetbox.App.Base.ObjectReferenceProperty>(t.Result);
OnNavigator_Getter(this, e);
t.Result = e.Result;
}
});
return _triggerFetchNavigatorTask;
}
public Zetbox.API.Async.ZbTask TriggerFetchDestinationPropertyAsync()
{
if (_triggerFetchDestinationPropertyTask != null) return _triggerFetchDestinationPropertyTask;
if (!DestinationProperty_was_eagerLoaded) _triggerFetchDestinationPropertyTask = Context.FetchRelationAsync<Zetbox.App.SchemaMigration.SourceColumn_created_Property_RelationEntryMemoryImpl>(new Guid("fb27e3f8-3615-4f3b-ae2a-2b89b8782e27"), RelationEndRole.A, this);
else _triggerFetchDestinationPropertyTask = new Zetbox.API.Async.ZbTask(Zetbox.API.Async.ZbTask.Synchron, null);
_triggerFetchDestinationPropertyTask.OnResult(r =>
{
_DestinationProperty
= new ObservableBSideListWrapper<Zetbox.App.SchemaMigration.SourceColumn, Zetbox.App.Base.Property, Zetbox.App.SchemaMigration.SourceColumn_created_Property_RelationEntryMemoryImpl, ICollection<Zetbox.App.SchemaMigration.SourceColumn_created_Property_RelationEntryMemoryImpl>>(
this,
new RelationshipFilterASideCollection<Zetbox.App.SchemaMigration.SourceColumn_created_Property_RelationEntryMemoryImpl>(this.Context, this));
// _DestinationProperty.CollectionChanged is managed by OnDestinationPropertyCollectionChanged() and called from the RelationEntry
});
return _triggerFetchDestinationPropertyTask;
}
