cuongpv/csharpcode
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upload to server

Browse Source 
uploading
This commit is contained in:
Pham Viet Cuong
2025-08-02 05:20:17 +07:00
commit a5eccbd452
984 changed files with 3031800 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
patientman/Datalib/DatabaseGeneric/RelationClasses/DynamicRelation.cs Normal file
View File

@@ -0,0 +1,95 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
//////////////////////////////////////////////////////////////
using System;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Class to define dynamic relations for queries.</summary>
/// <remarks>Dynamic relations are only supported in ansi joins so if you're using Oracle on 8i, you can't use Dynamic Relations. </remarks>
[Serializable]
public class DynamicRelation : DynamicRelationBase
{
/// <summary>Initializes a new instance of the <see cref="DynamicRelation"/> class.</summary>
/// <param name="leftOperand">The left operand, which can only be a derived table definition. No join will take place. </param>
/// <remarks>If a DynamicRelation is created with this CTor, it has to be the only one. It will be ignored if there are more
/// relations in the relation collection.</remarks>
public DynamicRelation(DerivedTableDefinition leftOperand)
{
this.InitClass(JoinHint.None, string.Empty, string.Empty, null, leftOperand, null);
}
/// <summary>Initializes a new instance of the <see cref="DynamicRelation"/> class.</summary>
/// <param name="leftOperand">The left operand.</param>
/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
/// <param name="rightOperand">The right operand.</param>
/// <param name="onClause">The on clause for the join.</param>
public DynamicRelation(DerivedTableDefinition leftOperand, JoinHint joinType, DerivedTableDefinition rightOperand, IPredicate onClause)
{
this.InitClass(joinType, string.Empty, string.Empty, onClause, leftOperand, rightOperand);
}
/// <summary>Initializes a new instance of the <see cref="DynamicRelation"/> class.</summary>
/// <param name="leftOperand">The left operand which is a field.</param>
/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
/// <param name="rightOperand">The right operand which is a derived table.</param>
/// <param name="aliasLeftOperand">The alias of the left operand. If you don't want to / need to alias the left operand (only alias if you have to), specify string.Empty.</param>
/// <param name="onClause">The on clause for the join.</param>
public DynamicRelation(IEntityFieldCore leftOperand, JoinHint joinType, DerivedTableDefinition rightOperand, string aliasLeftOperand, IPredicate onClause)
{
this.InitClass(joinType, aliasLeftOperand, string.Empty, onClause, leftOperand, rightOperand);
}
/// <summary>Initializes a new instance of the <see cref="DynamicRelation"/> class.</summary>
/// <param name="leftOperand">The left operand.</param>
/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
/// <param name="rightOperand">The right operand which is an entity type.</param>
/// <param name="aliasRightOperand">The alias of the right operand. If you don't want to / need to alias the right operand (only alias if you have to), specify string.Empty.</param>
/// <param name="onClause">The on clause for the join.</param>
public DynamicRelation(DerivedTableDefinition leftOperand, JoinHint joinType, Datalib.EntityType rightOperand, string aliasRightOperand, IPredicate onClause)
{
this.InitClass(joinType, string.Empty, aliasRightOperand, onClause, leftOperand, GeneralEntityFactory.Create(rightOperand));
}
/// <summary>Initializes a new instance of the <see cref="DynamicRelation"/> class.</summary>
/// <param name="leftOperand">The left operand, which is an entity.</param>
/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
/// <param name="rightOperand">The right operand which is an entity.</param>
/// <param name="aliasLeftOperand">The alias of the left operand. If you don't want to / need to alias the left operand (only alias if you have to), specify string.Empty.</param>
/// <param name="aliasRightOperand">The alias of the right operand. If you don't want to / need to alias the right operand (only alias if you have to), specify string.Empty.</param>
/// <param name="onClause">The on clause for the join.</param>
public DynamicRelation(Datalib.EntityType leftOperand, JoinHint joinType, Datalib.EntityType rightOperand, string aliasLeftOperand, string aliasRightOperand, IPredicate onClause)
{
this.InitClass(joinType, aliasLeftOperand, aliasRightOperand, onClause, GeneralEntityFactory.Create(leftOperand), GeneralEntityFactory.Create(rightOperand));
}
/// <summary>Initializes a new instance of the <see cref="DynamicRelation"/> class.</summary>
/// <param name="leftOperand">The left operand which is a field.</param>
/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
/// <param name="rightOperand">The right operand which is an entity.</param>
/// <param name="aliasLeftOperand">The alias of the left operand. If you don't want to / need to alias the left operand (only alias if you have to), specify string.Empty.</param>
/// <param name="aliasRightOperand">The alias of the right operand. If you don't want to / need to alias the right operand (only alias if you have to), specify string.Empty.</param>
/// <param name="onClause">The on clause for the join.</param>
public DynamicRelation(IEntityFieldCore leftOperand, JoinHint joinType, Datalib.EntityType rightOperand, string aliasLeftOperand, string aliasRightOperand, IPredicate onClause)
{
this.InitClass(joinType, aliasLeftOperand, aliasRightOperand, onClause, leftOperand, GeneralEntityFactory.Create(rightOperand));
}
/// <summary>Gets the inheritance provider for inheritance info retrieval for entity operands</summary>
/// <returns>The inheritance info provider</returns>
protected override IInheritanceInfoProvider GetInheritanceProvider()
{
return InheritanceInfoProviderSingleton.GetInstance();
}
}
}

60
patientman/Datalib/DatabaseGeneric/RelationClasses/TblAgeGroupRelations.cs Normal file
View File

@@ -0,0 +1,60 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblAgeGroup. </summary>
public partial class TblAgeGroupRelations
{
/// <summary>CTor</summary>
public TblAgeGroupRelations()
{
}
/// <summary>Gets all relations of the TblAgeGroupEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
return toReturn;
}
#region Class Property Declarations
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblAgeGroupRelations
{
/// <summary>CTor</summary>
static StaticTblAgeGroupRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblAgencyRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblAgency. </summary>
public partial class TblAgencyRelations
{
/// <summary>CTor</summary>
public TblAgencyRelations()
{
}
/// <summary>Gets all relations of the TblAgencyEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblReferraltoServiceEntityUsingAgencyTypeId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblAgencyEntity and TblReferraltoServiceEntity over the 1:n relation they have, using the relation between the fields:
/// TblAgency.AgencyTypeId - TblReferraltoService.AgencyTypeId
/// </summary>
public virtual IEntityRelation TblReferraltoServiceEntityUsingAgencyTypeId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblReferraltoServices" , true);
relation.AddEntityFieldPair(TblAgencyFields.AgencyTypeId, TblReferraltoServiceFields.AgencyTypeId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblAgencyEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferraltoServiceEntity", false);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblAgencyRelations
{
internal static readonly IEntityRelation TblReferraltoServiceEntityUsingAgencyTypeIdStatic = new TblAgencyRelations().TblReferraltoServiceEntityUsingAgencyTypeId;
/// <summary>CTor</summary>
static StaticTblAgencyRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblChildRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblChild. </summary>
public partial class TblChildRelations
{
/// <summary>CTor</summary>
public TblChildRelations()
{
}
/// <summary>Gets all relations of the TblChildEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblPregnanceInfoEntityUsingPreganceId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblChildEntity and TblPregnanceInfoEntity over the m:1 relation they have, using the relation between the fields:
/// TblChild.PreganceId - TblPregnanceInfo.UniqueKey
/// </summary>
public virtual IEntityRelation TblPregnanceInfoEntityUsingPreganceId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPregnanceInfo", false);
relation.AddEntityFieldPair(TblPregnanceInfoFields.UniqueKey, TblChildFields.PreganceId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPregnanceInfoEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblChildEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblChildRelations
{
internal static readonly IEntityRelation TblPregnanceInfoEntityUsingPreganceIdStatic = new TblChildRelations().TblPregnanceInfoEntityUsingPreganceId;
/// <summary>CTor</summary>
static StaticTblChildRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblClinicInfoRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblClinicInfo. </summary>
public partial class TblClinicInfoRelations
{
/// <summary>CTor</summary>
public TblClinicInfoRelations()
{
}
/// <summary>Gets all relations of the TblClinicInfoEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblPatientEntityUsingPatientId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblClinicInfoEntity and TblPatientEntity over the m:1 relation they have, using the relation between the fields:
/// TblClinicInfo.PatientId - TblPatient.PatientId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPatient", false);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblClinicInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblClinicInfoEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblClinicInfoRelations
{
internal static readonly IEntityRelation TblPatientEntityUsingPatientIdStatic = new TblClinicInfoRelations().TblPatientEntityUsingPatientId;
/// <summary>CTor</summary>
static StaticTblClinicInfoRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblCommuneRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblCommune. </summary>
public partial class TblCommuneRelations
{
/// <summary>CTor</summary>
public TblCommuneRelations()
{
}
/// <summary>Gets all relations of the TblCommuneEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblDistrictEntityUsingDistrictid);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblCommuneEntity and TblDistrictEntity over the m:1 relation they have, using the relation between the fields:
/// TblCommune.Districtid - TblDistrict.Districtid
/// </summary>
public virtual IEntityRelation TblDistrictEntityUsingDistrictid
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblDistrict", false);
relation.AddEntityFieldPair(TblDistrictFields.Districtid, TblCommuneFields.Districtid);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblDistrictEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblCommuneEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblCommuneRelations
{
internal static readonly IEntityRelation TblDistrictEntityUsingDistrictidStatic = new TblCommuneRelations().TblDistrictEntityUsingDistrictid;
/// <summary>CTor</summary>
static StaticTblCommuneRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblDiaryRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblDiary. </summary>
public partial class TblDiaryRelations
{
/// <summary>CTor</summary>
public TblDiaryRelations()
{
}
/// <summary>Gets all relations of the TblDiaryEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblPatientEntityUsingPatientId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblDiaryEntity and TblPatientEntity over the m:1 relation they have, using the relation between the fields:
/// TblDiary.PatientId - TblPatient.PatientId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPatient", false);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblDiaryFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblDiaryEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblDiaryRelations
{
internal static readonly IEntityRelation TblPatientEntityUsingPatientIdStatic = new TblDiaryRelations().TblPatientEntityUsingPatientId;
/// <summary>CTor</summary>
static StaticTblDiaryRelations()
{
}
}
}

92
patientman/Datalib/DatabaseGeneric/RelationClasses/TblDistrictRelations.cs Normal file
View File

@@ -0,0 +1,92 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblDistrict. </summary>
public partial class TblDistrictRelations
{
/// <summary>CTor</summary>
public TblDistrictRelations()
{
}
/// <summary>Gets all relations of the TblDistrictEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblCommuneEntityUsingDistrictid);
toReturn.Add(this.TblProvinceEntityUsingProvinceid);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblDistrictEntity and TblCommuneEntity over the 1:n relation they have, using the relation between the fields:
/// TblDistrict.Districtid - TblCommune.Districtid
/// </summary>
public virtual IEntityRelation TblCommuneEntityUsingDistrictid
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblCommunes" , true);
relation.AddEntityFieldPair(TblDistrictFields.Districtid, TblCommuneFields.Districtid);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblDistrictEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblCommuneEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblDistrictEntity and TblProvinceEntity over the m:1 relation they have, using the relation between the fields:
/// TblDistrict.Provinceid - TblProvince.Provinceid
/// </summary>
public virtual IEntityRelation TblProvinceEntityUsingProvinceid
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblProvince", false);
relation.AddEntityFieldPair(TblProvinceFields.Provinceid, TblDistrictFields.Provinceid);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblProvinceEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblDistrictEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblDistrictRelations
{
internal static readonly IEntityRelation TblCommuneEntityUsingDistrictidStatic = new TblDistrictRelations().TblCommuneEntityUsingDistrictid;
internal static readonly IEntityRelation TblProvinceEntityUsingProvinceidStatic = new TblDistrictRelations().TblProvinceEntityUsingProvinceid;
/// <summary>CTor</summary>
static StaticTblDistrictRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblExaminationInfoRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblExaminationInfo. </summary>
public partial class TblExaminationInfoRelations
{
/// <summary>CTor</summary>
public TblExaminationInfoRelations()
{
}
/// <summary>Gets all relations of the TblExaminationInfoEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblPatientEntityUsingPatientId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblExaminationInfoEntity and TblPatientEntity over the m:1 relation they have, using the relation between the fields:
/// TblExaminationInfo.PatientId - TblPatient.PatientId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPatient", false);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblExaminationInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblExaminationInfoEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblExaminationInfoRelations
{
internal static readonly IEntityRelation TblPatientEntityUsingPatientIdStatic = new TblExaminationInfoRelations().TblPatientEntityUsingPatientId;
/// <summary>CTor</summary>
static StaticTblExaminationInfoRelations()
{
}
}
}

211
patientman/Datalib/DatabaseGeneric/RelationClasses/TblPatientRelations.cs Normal file
View File

@@ -0,0 +1,211 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblPatient. </summary>
public partial class TblPatientRelations
{
/// <summary>CTor</summary>
public TblPatientRelations()
{
}
/// <summary>Gets all relations of the TblPatientEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblClinicInfoEntityUsingPatientId);
toReturn.Add(this.TblDiaryEntityUsingPatientId);
toReturn.Add(this.TblExaminationInfoEntityUsingPatientId);
toReturn.Add(this.TblPreClinicsInfoEntityUsingPatientId);
toReturn.Add(this.TblPregnanceInfoEntityUsingPatientId);
toReturn.Add(this.TblReferralsToEntityUsingPatientId);
toReturn.Add(this.TblReferraltoServiceEntityUsingPatientId);
toReturn.Add(this.TblTreatmentInfoEntityUsingPatientId);
toReturn.Add(this.TblReferralFromPlaceEntityUsingReferralId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblPatientEntity and TblClinicInfoEntity over the 1:n relation they have, using the relation between the fields:
/// TblPatient.PatientId - TblClinicInfo.PatientId
/// </summary>
public virtual IEntityRelation TblClinicInfoEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblClinicInfos" , true);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblClinicInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblClinicInfoEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPatientEntity and TblDiaryEntity over the 1:n relation they have, using the relation between the fields:
/// TblPatient.PatientId - TblDiary.PatientId
/// </summary>
public virtual IEntityRelation TblDiaryEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblDiaries" , true);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblDiaryFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblDiaryEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPatientEntity and TblExaminationInfoEntity over the 1:n relation they have, using the relation between the fields:
/// TblPatient.PatientId - TblExaminationInfo.PatientId
/// </summary>
public virtual IEntityRelation TblExaminationInfoEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblExaminationInfos" , true);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblExaminationInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblExaminationInfoEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPatientEntity and TblPreClinicsInfoEntity over the 1:n relation they have, using the relation between the fields:
/// TblPatient.PatientId - TblPreClinicsInfo.PatientId
/// </summary>
public virtual IEntityRelation TblPreClinicsInfoEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblPreClinicsInfos" , true);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblPreClinicsInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPreClinicsInfoEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPatientEntity and TblPregnanceInfoEntity over the 1:n relation they have, using the relation between the fields:
/// TblPatient.PatientId - TblPregnanceInfo.PatientId
/// </summary>
public virtual IEntityRelation TblPregnanceInfoEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblPregnanceInfos" , true);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblPregnanceInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPregnanceInfoEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPatientEntity and TblReferralsToEntity over the 1:n relation they have, using the relation between the fields:
/// TblPatient.PatientId - TblReferralsTo.PatientId
/// </summary>
public virtual IEntityRelation TblReferralsToEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblReferralsTos" , true);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblReferralsToFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferralsToEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPatientEntity and TblReferraltoServiceEntity over the 1:n relation they have, using the relation between the fields:
/// TblPatient.PatientId - TblReferraltoService.PatientId
/// </summary>
public virtual IEntityRelation TblReferraltoServiceEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblReferraltoServices" , true);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblReferraltoServiceFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferraltoServiceEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPatientEntity and TblTreatmentInfoEntity over the 1:n relation they have, using the relation between the fields:
/// TblPatient.PatientId - TblTreatmentInfo.PatientId
/// </summary>
public virtual IEntityRelation TblTreatmentInfoEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblTreatmentInfos" , true);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblTreatmentInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentInfoEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPatientEntity and TblReferralFromPlaceEntity over the m:1 relation they have, using the relation between the fields:
/// TblPatient.ReferralId - TblReferralFromPlace.ReferralId
/// </summary>
public virtual IEntityRelation TblReferralFromPlaceEntityUsingReferralId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblReferralFromPlace", false);
relation.AddEntityFieldPair(TblReferralFromPlaceFields.ReferralId, TblPatientFields.ReferralId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferralFromPlaceEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblPatientRelations
{
internal static readonly IEntityRelation TblClinicInfoEntityUsingPatientIdStatic = new TblPatientRelations().TblClinicInfoEntityUsingPatientId;
internal static readonly IEntityRelation TblDiaryEntityUsingPatientIdStatic = new TblPatientRelations().TblDiaryEntityUsingPatientId;
internal static readonly IEntityRelation TblExaminationInfoEntityUsingPatientIdStatic = new TblPatientRelations().TblExaminationInfoEntityUsingPatientId;
internal static readonly IEntityRelation TblPreClinicsInfoEntityUsingPatientIdStatic = new TblPatientRelations().TblPreClinicsInfoEntityUsingPatientId;
internal static readonly IEntityRelation TblPregnanceInfoEntityUsingPatientIdStatic = new TblPatientRelations().TblPregnanceInfoEntityUsingPatientId;
internal static readonly IEntityRelation TblReferralsToEntityUsingPatientIdStatic = new TblPatientRelations().TblReferralsToEntityUsingPatientId;
internal static readonly IEntityRelation TblReferraltoServiceEntityUsingPatientIdStatic = new TblPatientRelations().TblReferraltoServiceEntityUsingPatientId;
internal static readonly IEntityRelation TblTreatmentInfoEntityUsingPatientIdStatic = new TblPatientRelations().TblTreatmentInfoEntityUsingPatientId;
internal static readonly IEntityRelation TblReferralFromPlaceEntityUsingReferralIdStatic = new TblPatientRelations().TblReferralFromPlaceEntityUsingReferralId;
/// <summary>CTor</summary>
static StaticTblPatientRelations()
{
}
}
}

92
patientman/Datalib/DatabaseGeneric/RelationClasses/TblPreClinicsInfoRelations.cs Normal file
View File

@@ -0,0 +1,92 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblPreClinicsInfo. </summary>
public partial class TblPreClinicsInfoRelations
{
/// <summary>CTor</summary>
public TblPreClinicsInfoRelations()
{
}
/// <summary>Gets all relations of the TblPreClinicsInfoEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblPatientEntityUsingPatientId);
toReturn.Add(this.TblTestEntityUsingTestid);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblPreClinicsInfoEntity and TblPatientEntity over the m:1 relation they have, using the relation between the fields:
/// TblPreClinicsInfo.PatientId - TblPatient.PatientId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPatient", false);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblPreClinicsInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPreClinicsInfoEntity", true);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPreClinicsInfoEntity and TblTestEntity over the m:1 relation they have, using the relation between the fields:
/// TblPreClinicsInfo.Testid - TblTest.Testid
/// </summary>
public virtual IEntityRelation TblTestEntityUsingTestid
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblTest", false);
relation.AddEntityFieldPair(TblTestFields.Testid, TblPreClinicsInfoFields.Testid);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTestEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPreClinicsInfoEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblPreClinicsInfoRelations
{
internal static readonly IEntityRelation TblPatientEntityUsingPatientIdStatic = new TblPreClinicsInfoRelations().TblPatientEntityUsingPatientId;
internal static readonly IEntityRelation TblTestEntityUsingTestidStatic = new TblPreClinicsInfoRelations().TblTestEntityUsingTestid;
/// <summary>CTor</summary>
static StaticTblPreClinicsInfoRelations()
{
}
}
}

92
patientman/Datalib/DatabaseGeneric/RelationClasses/TblPregnanceInfoRelations.cs Normal file
View File

@@ -0,0 +1,92 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblPregnanceInfo. </summary>
public partial class TblPregnanceInfoRelations
{
/// <summary>CTor</summary>
public TblPregnanceInfoRelations()
{
}
/// <summary>Gets all relations of the TblPregnanceInfoEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblChildEntityUsingPreganceId);
toReturn.Add(this.TblPatientEntityUsingPatientId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblPregnanceInfoEntity and TblChildEntity over the 1:n relation they have, using the relation between the fields:
/// TblPregnanceInfo.UniqueKey - TblChild.PreganceId
/// </summary>
public virtual IEntityRelation TblChildEntityUsingPreganceId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblChildren" , true);
relation.AddEntityFieldPair(TblPregnanceInfoFields.UniqueKey, TblChildFields.PreganceId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPregnanceInfoEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblChildEntity", false);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblPregnanceInfoEntity and TblPatientEntity over the m:1 relation they have, using the relation between the fields:
/// TblPregnanceInfo.PatientId - TblPatient.PatientId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPatient", false);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblPregnanceInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPregnanceInfoEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblPregnanceInfoRelations
{
internal static readonly IEntityRelation TblChildEntityUsingPreganceIdStatic = new TblPregnanceInfoRelations().TblChildEntityUsingPreganceId;
internal static readonly IEntityRelation TblPatientEntityUsingPatientIdStatic = new TblPregnanceInfoRelations().TblPatientEntityUsingPatientId;
/// <summary>CTor</summary>
static StaticTblPregnanceInfoRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblProvinceRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblProvince. </summary>
public partial class TblProvinceRelations
{
/// <summary>CTor</summary>
public TblProvinceRelations()
{
}
/// <summary>Gets all relations of the TblProvinceEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblDistrictEntityUsingProvinceid);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblProvinceEntity and TblDistrictEntity over the 1:n relation they have, using the relation between the fields:
/// TblProvince.Provinceid - TblDistrict.Provinceid
/// </summary>
public virtual IEntityRelation TblDistrictEntityUsingProvinceid
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblDistricts" , true);
relation.AddEntityFieldPair(TblProvinceFields.Provinceid, TblDistrictFields.Provinceid);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblProvinceEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblDistrictEntity", false);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblProvinceRelations
{
internal static readonly IEntityRelation TblDistrictEntityUsingProvinceidStatic = new TblProvinceRelations().TblDistrictEntityUsingProvinceid;
/// <summary>CTor</summary>
static StaticTblProvinceRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblReferralFromPlaceRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblReferralFromPlace. </summary>
public partial class TblReferralFromPlaceRelations
{
/// <summary>CTor</summary>
public TblReferralFromPlaceRelations()
{
}
/// <summary>Gets all relations of the TblReferralFromPlaceEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblPatientEntityUsingReferralId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblReferralFromPlaceEntity and TblPatientEntity over the 1:n relation they have, using the relation between the fields:
/// TblReferralFromPlace.ReferralId - TblPatient.ReferralId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingReferralId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblPatients" , true);
relation.AddEntityFieldPair(TblReferralFromPlaceFields.ReferralId, TblPatientFields.ReferralId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferralFromPlaceEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblReferralFromPlaceRelations
{
internal static readonly IEntityRelation TblPatientEntityUsingReferralIdStatic = new TblReferralFromPlaceRelations().TblPatientEntityUsingReferralId;
/// <summary>CTor</summary>
static StaticTblReferralFromPlaceRelations()
{
}
}
}

108
patientman/Datalib/DatabaseGeneric/RelationClasses/TblReferralRelations.cs Normal file
View File

@@ -0,0 +1,108 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 3.1
// Code is generated on: Sunday, February 23, 2014 10:56:42 AM
// Code is generated using templates: SD.TemplateBindings.SharedTemplates.NET20
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblReferral. </summary>
public partial class TblReferralRelations
{
/// <summary>CTor</summary>
public TblReferralRelations()
{
}
/// <summary>Gets all relations of the TblReferralEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblAgencyEntityUsingAgencyTypeId);
toReturn.Add(this.TblPatientEntityUsingPatientId);
toReturn.Add(this.TblServiceEntityUsingServiceId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblReferralEntity and TblAgencyEntity over the m:1 relation they have, using the relation between the fields:
/// TblReferral.AgencyTypeId - TblAgency.AgencyTypeId
/// </summary>
public virtual IEntityRelation TblAgencyEntityUsingAgencyTypeId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblAgency", false);
relation.AddEntityFieldPair(TblAgencyFields.AgencyTypeId, TblReferralFields.AgencyTypeId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblAgencyEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferralEntity", true);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblReferralEntity and TblPatientEntity over the m:1 relation they have, using the relation between the fields:
/// TblReferral.PatientId - TblPatient.PatientId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPatient", false);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblReferralFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferralEntity", true);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblReferralEntity and TblServiceEntity over the m:1 relation they have, using the relation between the fields:
/// TblReferral.ServiceId - TblService.ServiceId
/// </summary>
public virtual IEntityRelation TblServiceEntityUsingServiceId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblService", false);
relation.AddEntityFieldPair(TblServiceFields.ServiceId, TblReferralFields.ServiceId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblServiceEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferralEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblReferralRelations
{
internal static readonly IEntityRelation TblAgencyEntityUsingAgencyTypeIdStatic = new TblReferralRelations().TblAgencyEntityUsingAgencyTypeId;
internal static readonly IEntityRelation TblPatientEntityUsingPatientIdStatic = new TblReferralRelations().TblPatientEntityUsingPatientId;
internal static readonly IEntityRelation TblServiceEntityUsingServiceIdStatic = new TblReferralRelations().TblServiceEntityUsingServiceId;
/// <summary>CTor</summary>
static StaticTblReferralRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblReferralsToRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblReferralsTo. </summary>
public partial class TblReferralsToRelations
{
/// <summary>CTor</summary>
public TblReferralsToRelations()
{
}
/// <summary>Gets all relations of the TblReferralsToEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblPatientEntityUsingPatientId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblReferralsToEntity and TblPatientEntity over the m:1 relation they have, using the relation between the fields:
/// TblReferralsTo.PatientId - TblPatient.PatientId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPatient", false);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblReferralsToFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferralsToEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblReferralsToRelations
{
internal static readonly IEntityRelation TblPatientEntityUsingPatientIdStatic = new TblReferralsToRelations().TblPatientEntityUsingPatientId;
/// <summary>CTor</summary>
static StaticTblReferralsToRelations()
{
}
}
}

92
patientman/Datalib/DatabaseGeneric/RelationClasses/TblReferraltoServiceRelations.cs Normal file
View File

@@ -0,0 +1,92 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblReferraltoService. </summary>
public partial class TblReferraltoServiceRelations
{
/// <summary>CTor</summary>
public TblReferraltoServiceRelations()
{
}
/// <summary>Gets all relations of the TblReferraltoServiceEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblAgencyEntityUsingAgencyTypeId);
toReturn.Add(this.TblPatientEntityUsingPatientId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblReferraltoServiceEntity and TblAgencyEntity over the m:1 relation they have, using the relation between the fields:
/// TblReferraltoService.AgencyTypeId - TblAgency.AgencyTypeId
/// </summary>
public virtual IEntityRelation TblAgencyEntityUsingAgencyTypeId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblAgency", false);
relation.AddEntityFieldPair(TblAgencyFields.AgencyTypeId, TblReferraltoServiceFields.AgencyTypeId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblAgencyEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferraltoServiceEntity", true);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblReferraltoServiceEntity and TblPatientEntity over the m:1 relation they have, using the relation between the fields:
/// TblReferraltoService.PatientId - TblPatient.PatientId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPatient", false);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblReferraltoServiceFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblReferraltoServiceEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblReferraltoServiceRelations
{
internal static readonly IEntityRelation TblAgencyEntityUsingAgencyTypeIdStatic = new TblReferraltoServiceRelations().TblAgencyEntityUsingAgencyTypeId;
internal static readonly IEntityRelation TblPatientEntityUsingPatientIdStatic = new TblReferraltoServiceRelations().TblPatientEntityUsingPatientId;
/// <summary>CTor</summary>
static StaticTblReferraltoServiceRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblRegimenRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblRegimen. </summary>
public partial class TblRegimenRelations
{
/// <summary>CTor</summary>
public TblRegimenRelations()
{
}
/// <summary>Gets all relations of the TblRegimenEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblTreatmentInfoEntityUsingRegimenid);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblRegimenEntity and TblTreatmentInfoEntity over the 1:n relation they have, using the relation between the fields:
/// TblRegimen.Regimenid - TblTreatmentInfo.Regimenid
/// </summary>
public virtual IEntityRelation TblTreatmentInfoEntityUsingRegimenid
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblTreatmentInfos" , true);
relation.AddEntityFieldPair(TblRegimenFields.Regimenid, TblTreatmentInfoFields.Regimenid);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblRegimenEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentInfoEntity", false);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblRegimenRelations
{
internal static readonly IEntityRelation TblTreatmentInfoEntityUsingRegimenidStatic = new TblRegimenRelations().TblTreatmentInfoEntityUsingRegimenid;
/// <summary>CTor</summary>
static StaticTblRegimenRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblRegimenStopReasonRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblRegimenStopReason. </summary>
public partial class TblRegimenStopReasonRelations
{
/// <summary>CTor</summary>
public TblRegimenStopReasonRelations()
{
}
/// <summary>Gets all relations of the TblRegimenStopReasonEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblTreatmentInfoEntityUsingReasonId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblRegimenStopReasonEntity and TblTreatmentInfoEntity over the 1:n relation they have, using the relation between the fields:
/// TblRegimenStopReason.ReasonId - TblTreatmentInfo.ReasonId
/// </summary>
public virtual IEntityRelation TblTreatmentInfoEntityUsingReasonId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblTreatmentInfos" , true);
relation.AddEntityFieldPair(TblRegimenStopReasonFields.ReasonId, TblTreatmentInfoFields.ReasonId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblRegimenStopReasonEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentInfoEntity", false);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblRegimenStopReasonRelations
{
internal static readonly IEntityRelation TblTreatmentInfoEntityUsingReasonIdStatic = new TblRegimenStopReasonRelations().TblTreatmentInfoEntityUsingReasonId;
/// <summary>CTor</summary>
static StaticTblRegimenStopReasonRelations()
{
}
}
}

60
patientman/Datalib/DatabaseGeneric/RelationClasses/TblServiceRelations.cs Normal file
View File

@@ -0,0 +1,60 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblService. </summary>
public partial class TblServiceRelations
{
/// <summary>CTor</summary>
public TblServiceRelations()
{
}
/// <summary>Gets all relations of the TblServiceEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
return toReturn;
}
#region Class Property Declarations
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblServiceRelations
{
/// <summary>CTor</summary>
static StaticTblServiceRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblTestRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblTest. </summary>
public partial class TblTestRelations
{
/// <summary>CTor</summary>
public TblTestRelations()
{
}
/// <summary>Gets all relations of the TblTestEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblPreClinicsInfoEntityUsingTestid);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblTestEntity and TblPreClinicsInfoEntity over the 1:n relation they have, using the relation between the fields:
/// TblTest.Testid - TblPreClinicsInfo.Testid
/// </summary>
public virtual IEntityRelation TblPreClinicsInfoEntityUsingTestid
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblPreClinicsInfos" , true);
relation.AddEntityFieldPair(TblTestFields.Testid, TblPreClinicsInfoFields.Testid);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTestEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPreClinicsInfoEntity", false);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblTestRelations
{
internal static readonly IEntityRelation TblPreClinicsInfoEntityUsingTestidStatic = new TblTestRelations().TblPreClinicsInfoEntityUsingTestid;
/// <summary>CTor</summary>
static StaticTblTestRelations()
{
}
}
}

124
patientman/Datalib/DatabaseGeneric/RelationClasses/TblTreatmentInfoRelations.cs Normal file
View File

@@ -0,0 +1,124 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblTreatmentInfo. </summary>
public partial class TblTreatmentInfoRelations
{
/// <summary>CTor</summary>
public TblTreatmentInfoRelations()
{
}
/// <summary>Gets all relations of the TblTreatmentInfoEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblPatientEntityUsingPatientId);
toReturn.Add(this.TblRegimenEntityUsingRegimenid);
toReturn.Add(this.TblRegimenStopReasonEntityUsingReasonId);
toReturn.Add(this.TblTreatmentEntityUsingTreatmentId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblTreatmentInfoEntity and TblPatientEntity over the m:1 relation they have, using the relation between the fields:
/// TblTreatmentInfo.PatientId - TblPatient.PatientId
/// </summary>
public virtual IEntityRelation TblPatientEntityUsingPatientId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblPatient", false);
relation.AddEntityFieldPair(TblPatientFields.PatientId, TblTreatmentInfoFields.PatientId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblPatientEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentInfoEntity", true);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblTreatmentInfoEntity and TblRegimenEntity over the m:1 relation they have, using the relation between the fields:
/// TblTreatmentInfo.Regimenid - TblRegimen.Regimenid
/// </summary>
public virtual IEntityRelation TblRegimenEntityUsingRegimenid
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblRegiman", false);
relation.AddEntityFieldPair(TblRegimenFields.Regimenid, TblTreatmentInfoFields.Regimenid);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblRegimenEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentInfoEntity", true);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblTreatmentInfoEntity and TblRegimenStopReasonEntity over the m:1 relation they have, using the relation between the fields:
/// TblTreatmentInfo.ReasonId - TblRegimenStopReason.ReasonId
/// </summary>
public virtual IEntityRelation TblRegimenStopReasonEntityUsingReasonId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblRegimenStopReason", false);
relation.AddEntityFieldPair(TblRegimenStopReasonFields.ReasonId, TblTreatmentInfoFields.ReasonId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblRegimenStopReasonEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentInfoEntity", true);
return relation;
}
}
/// <summary>Returns a new IEntityRelation object, between TblTreatmentInfoEntity and TblTreatmentEntity over the m:1 relation they have, using the relation between the fields:
/// TblTreatmentInfo.TreatmentId - TblTreatment.TreatmentId
/// </summary>
public virtual IEntityRelation TblTreatmentEntityUsingTreatmentId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.ManyToOne, "TblTreatment", false);
relation.AddEntityFieldPair(TblTreatmentFields.TreatmentId, TblTreatmentInfoFields.TreatmentId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentEntity", false);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentInfoEntity", true);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblTreatmentInfoRelations
{
internal static readonly IEntityRelation TblPatientEntityUsingPatientIdStatic = new TblTreatmentInfoRelations().TblPatientEntityUsingPatientId;
internal static readonly IEntityRelation TblRegimenEntityUsingRegimenidStatic = new TblTreatmentInfoRelations().TblRegimenEntityUsingRegimenid;
internal static readonly IEntityRelation TblRegimenStopReasonEntityUsingReasonIdStatic = new TblTreatmentInfoRelations().TblRegimenStopReasonEntityUsingReasonId;
internal static readonly IEntityRelation TblTreatmentEntityUsingTreatmentIdStatic = new TblTreatmentInfoRelations().TblTreatmentEntityUsingTreatmentId;
/// <summary>CTor</summary>
static StaticTblTreatmentInfoRelations()
{
}
}
}

76
patientman/Datalib/DatabaseGeneric/RelationClasses/TblTreatmentRelations.cs Normal file
View File

@@ -0,0 +1,76 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblTreatment. </summary>
public partial class TblTreatmentRelations
{
/// <summary>CTor</summary>
public TblTreatmentRelations()
{
}
/// <summary>Gets all relations of the TblTreatmentEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
toReturn.Add(this.TblTreatmentInfoEntityUsingTreatmentId);
return toReturn;
}
#region Class Property Declarations
/// <summary>Returns a new IEntityRelation object, between TblTreatmentEntity and TblTreatmentInfoEntity over the 1:n relation they have, using the relation between the fields:
/// TblTreatment.TreatmentId - TblTreatmentInfo.TreatmentId
/// </summary>
public virtual IEntityRelation TblTreatmentInfoEntityUsingTreatmentId
{
get
{
IEntityRelation relation = new EntityRelation(SD.LLBLGen.Pro.ORMSupportClasses.RelationType.OneToMany, "TblTreatmentInfos" , true);
relation.AddEntityFieldPair(TblTreatmentFields.TreatmentId, TblTreatmentInfoFields.TreatmentId);
relation.InheritanceInfoPkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentEntity", true);
relation.InheritanceInfoFkSideEntity = InheritanceInfoProviderSingleton.GetInstance().GetInheritanceInfo("TblTreatmentInfoEntity", false);
return relation;
}
}
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblTreatmentRelations
{
internal static readonly IEntityRelation TblTreatmentInfoEntityUsingTreatmentIdStatic = new TblTreatmentRelations().TblTreatmentInfoEntityUsingTreatmentId;
/// <summary>CTor</summary>
static StaticTblTreatmentRelations()
{
}
}
}

60
patientman/Datalib/DatabaseGeneric/RelationClasses/TblWaitingListRelations.cs Normal file
View File

@@ -0,0 +1,60 @@
///////////////////////////////////////////////////////////////
// This is generated code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 4.2
// Code is generated on:
// Code is generated using templates: SD.TemplateBindings.SharedTemplates
// Templates vendor: Solutions Design.
// Templates version:
//////////////////////////////////////////////////////////////
using System;
using System.Collections;
using System.Collections.Generic;
using Datalib;
using Datalib.FactoryClasses;
using Datalib.HelperClasses;
using SD.LLBLGen.Pro.ORMSupportClasses;
namespace Datalib.RelationClasses
{
/// <summary>Implements the relations factory for the entity: TblWaitingList. </summary>
public partial class TblWaitingListRelations
{
/// <summary>CTor</summary>
public TblWaitingListRelations()
{
}
/// <summary>Gets all relations of the TblWaitingListEntity as a list of IEntityRelation objects.</summary>
/// <returns>a list of IEntityRelation objects</returns>
public virtual List<IEntityRelation> GetAllRelations()
{
List<IEntityRelation> toReturn = new List<IEntityRelation>();
return toReturn;
}
#region Class Property Declarations
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSubTypeRelation(string subTypeEntityName) { return null; }
/// <summary>stub, not used in this entity, only for TargetPerEntity entities.</summary>
public virtual IEntityRelation GetSuperTypeRelation() { return null;}
#endregion
#region Included Code
#endregion
}
/// <summary>Static class which is used for providing relationship instances which are re-used internally for syncing</summary>
internal static class StaticTblWaitingListRelations
{
/// <summary>CTor</summary>
static StaticTblWaitingListRelations()
{
}
}
}