1137 lines
39 KiB
C#
1137 lines
39 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Kreta.DataAccess.Interfaces;
|
|
using Kreta.Framework;
|
|
using Kreta.Framework.Actions;
|
|
using Kreta.Framework.Collections;
|
|
using Kreta.Framework.Collections.Generic;
|
|
using Kreta.Framework.Entities;
|
|
using Kreta.Framework.Entities.Generic;
|
|
using Kreta.Framework.Exceptions;
|
|
|
|
namespace SDA.Kreta.Entities
|
|
{
|
|
/// <summary>
|
|
/// Az UML modell Szervezet entitásának megvalósítása.
|
|
/// </summary>
|
|
/// <remarks>A kód teljes egészében generált, kézi módosítása nem megengedett!</remarks>
|
|
[Entity("Szervezet")]
|
|
// alapértelmezett EntityHistoryMode
|
|
public class Szervezet : Entity, ISzervezet
|
|
{
|
|
internal protected Szervezet()
|
|
: base()
|
|
{
|
|
}
|
|
|
|
public class AttributeInfo
|
|
{
|
|
public const string Azonosito = "Azonosito";
|
|
public const string IsNavSzinkronizalt = "IsNavSzinkronizalt";
|
|
public const string IsSzinkronizalt = "IsSzinkronizalt";
|
|
public const string Nev = "Nev";
|
|
public const string Tipus = "Tipus";
|
|
public const string Szervezetcim = "Szervezetcim";
|
|
public const string DualishelyszintipusId = "DualishelyszintipusId";
|
|
}
|
|
|
|
public class AttributeLengthInfo
|
|
{
|
|
public const int AzonositoLength = 20;
|
|
public const int NevLength = 255;
|
|
public const int SzervezetcimLength = 500;
|
|
}
|
|
|
|
#region General
|
|
private SzervezetDA m_DA = new SzervezetDA();
|
|
|
|
protected static Szervezet FakeSzervezet { get; set; }
|
|
|
|
public static Szervezet GiveAnInstance()
|
|
{
|
|
Szervezet result = FakeSzervezet == null
|
|
? new Szervezet()
|
|
: (Szervezet)FakeSzervezet.MemberwiseClone();
|
|
result.Reset();
|
|
result.SetDefaultData();
|
|
|
|
return result;
|
|
}
|
|
|
|
protected void SetDefaultData()
|
|
{
|
|
if (UserContext.Instance != null)
|
|
{
|
|
if (UserContext.Instance.IntezmenyId > 0)
|
|
{
|
|
IntezmenyId = UserContext.Instance.IntezmenyId;
|
|
}
|
|
|
|
if (UserContext.Instance.AktivTanevId > 0)
|
|
{
|
|
TanevId = UserContext.Instance.AktivTanevId;
|
|
}
|
|
|
|
m_State = EntityState.Uninitialized;
|
|
}
|
|
}
|
|
|
|
protected override IEntityDataAccessor GetDataAccessor() { return m_DA; }
|
|
protected internal virtual IEntityDataAccessor InheritedDA { get { return null; } }
|
|
|
|
[Obsolete("Ezt ne használjátok, mert mindenhova bele kellene fogalmazni a tanév szűrést is! Meg fog majd szűnni!")]
|
|
public static IEntityCollection<Szervezet> LoadAll()
|
|
{
|
|
return LoadWithFilter("");
|
|
}
|
|
|
|
[Obsolete("Ezt ne használjátok, mert mindenhova bele kellene fogalmazni a tanév szűrést is! Meg fog majd szűnni!")]
|
|
public static IEntityCollection<Szervezet> LoadAll(ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
|
|
{
|
|
return LoadWithFilter("", columnFilterMode, columns);
|
|
}
|
|
|
|
[Obsolete("Ezt ne használjátok, mert mindenhova bele kellene fogalmazni a tanév szűrést is! Meg fog majd szűnni!")]
|
|
public static IEntityCollection<Szervezet> LoadWithFilter(string filter, Dictionary<string, object> commandParameters = null)
|
|
{
|
|
var result = new EntityCollection<Szervezet>();
|
|
new SzervezetDA().LoadWithFilter(result, filter, commandParameters);
|
|
return result;
|
|
}
|
|
|
|
[Obsolete("Ezt ne használjátok, mert mindenhova bele kellene fogalmazni a tanév szűrést is! Meg fog majd szűnni!")]
|
|
public static IEntityCollection<Szervezet> LoadWithFilter(string filter, ColumnFilterMode columnFilterMode, IEnumerable<string> columns, Dictionary<string, object> commandParameters = null)
|
|
{
|
|
var result = new EntityCollection<Szervezet>();
|
|
new SzervezetDA().LoadWithFilter(result, filter, columnFilterMode, columns, commandParameters);
|
|
return result;
|
|
}
|
|
|
|
protected override void StoreOriginalValues()
|
|
{
|
|
base.StoreOriginalValues();
|
|
OriginalValues.Add("Azonosito", (object)m_Azonosito);
|
|
OriginalValues.Add("IsNavSzinkronizalt", (object)m_IsNavSzinkronizalt);
|
|
OriginalValues.Add("IsSzinkronizalt", (object)m_IsSzinkronizalt);
|
|
OriginalValues.Add("Nev", (object)m_Nev);
|
|
OriginalValues.Add("Tipus", (object)m_Tipus);
|
|
OriginalValues.Add("Szervezetcim", (Szervezetcim == null ? (object)DBNull.Value : (object)m_Szervezetcim));
|
|
OriginalValues.Add("DualishelyszintipusId", (object)m_DualishelyszintipusId);
|
|
OriginalValues.Add("ParentSzervezetId", (m_ParentSzervezetId < 0 ? (object)DBNull.Value : (object)m_ParentSzervezetId));
|
|
OriginalValues.Add("IntezmenyId", (m_IntezmenyId < 0 ? (object)DBNull.Value : (object)m_IntezmenyId));
|
|
OriginalValues.Add("TanevId", (m_TanevId < 0 ? (object)DBNull.Value : (object)m_TanevId));
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region Ellenőrzés
|
|
|
|
protected override void Validate(bool skipValidateAttributes = false)
|
|
{
|
|
base.Validate();
|
|
|
|
if (!skipValidateAttributes)
|
|
{
|
|
// korlátos hosszúságú mezők ellenőrzése...
|
|
if (m_Azonosito != null && m_Azonosito.Length > 20)
|
|
{
|
|
throw new InvalidEntityAttributeException("Szervezet", "Azonosito", EntityAttributeError.TooLong);
|
|
}
|
|
if (m_Nev != null && m_Nev.Length > 255)
|
|
{
|
|
throw new InvalidEntityAttributeException("Szervezet", "Nev", EntityAttributeError.TooLong);
|
|
}
|
|
if (m_Szervezetcim != null && m_Szervezetcim.Length > 500)
|
|
{
|
|
throw new InvalidEntityAttributeException("Szervezet", "Szervezetcim", EntityAttributeError.TooLong);
|
|
}
|
|
}
|
|
|
|
// kötelező asszociációk ellenőrzése...
|
|
if (m_IntezmenyId == -1) { throw new InvalidEntityAttributeException("Szervezet", "IntezmenyId", EntityAttributeError.Empty); }
|
|
if (m_TanevId == -1) { throw new InvalidEntityAttributeException("Szervezet", "TanevId", EntityAttributeError.Empty); }
|
|
|
|
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Alaphelyzetbe állítás
|
|
protected override void Reset()
|
|
{
|
|
base.Reset();
|
|
|
|
// alaphelyzetbe állítjuk az egyszerű mezőket
|
|
this.m_Azonosito = "";
|
|
this.m_IsNavSzinkronizalt = false;
|
|
this.m_IsSzinkronizalt = false;
|
|
this.m_Nev = "";
|
|
this.m_Tipus = -1;
|
|
this.m_Szervezetcim = null;
|
|
this.m_DualishelyszintipusId = -1;
|
|
|
|
// alaphelyzetbe állítjuk az asszociációkból származó mezőket
|
|
this.m_Terem = null; // EntityCollection
|
|
this.m_Csoport = null; // EntityCollection
|
|
this.m_MunkaugyiAdatok = null; // EntityCollection
|
|
this.m_TanuloTanugyiAdatok = null; // EntityCollection
|
|
this.m_Tantargy = null; // EntityCollection
|
|
this.m_ChildSzervezet = null; // EntityCollection
|
|
this.m_ParentSzervezetId = -1;
|
|
this.m_ParentSzervezet = null; // Entity
|
|
this.m_SzakmunkaSzerzodes = null; // EntityCollection
|
|
this.m_Igazolas = null; // EntityCollection
|
|
this.m_IntezmenyId = -1;
|
|
this.m_Intezmeny = null; // Entity
|
|
this.m_TanevId = -1;
|
|
this.m_Tanev = null; // Entity
|
|
}
|
|
|
|
#endregion
|
|
|
|
protected override void DeAssociateBeforeDelete(bool runHandler = false)
|
|
{
|
|
// Nem kaszkád törölhető asszociációk ellenőrzése, hogy üresek-e...
|
|
|
|
if (this.Terem.Count > 0)
|
|
{
|
|
throw new EntityDeleteFailedException("Szervezet", "Terem", EntityUtil.GetAssociationDescription("T_TEREM_OSSZES", "C_SZERVEZETID")); // nincs kapcsolotabla
|
|
}
|
|
if (this.Csoport.Count > 0)
|
|
{
|
|
throw new EntityDeleteFailedException("Szervezet", "Csoport", EntityUtil.GetAssociationDescription("T_CSOPORT_OSSZES", "C_SZERVEZETID")); // nincs kapcsolotabla
|
|
}
|
|
if (this.MunkaugyiAdatok.Count > 0)
|
|
{
|
|
throw new EntityDeleteFailedException("Szervezet", "MunkaugyiAdatok", EntityUtil.GetAssociationDescription("T_MUNKAUGYIADATOK_OSSZES", "C_SZERVEZETID")); // nincs kapcsolotabla
|
|
}
|
|
if (this.TanuloTanugyiAdatok.Count > 0)
|
|
{
|
|
throw new EntityDeleteFailedException("Szervezet", "TanuloTanugyiAdatok", EntityUtil.GetAssociationDescription("T_TANULOTANUGYIADATOK_OSSZES", "C_SZERVEZETID")); // nincs kapcsolotabla
|
|
}
|
|
if (this.Tantargy.Count > 0)
|
|
{
|
|
throw new EntityDeleteFailedException("Szervezet", "Tantargy", EntityUtil.GetAssociationDescription("T_TANTARGY_OSSZES", "C_SZERVEZETID")); // nincs kapcsolotabla
|
|
}
|
|
if (this.ChildSzervezet.Count > 0)
|
|
{
|
|
throw new EntityDeleteFailedException("Szervezet", "ChildSzervezet", EntityUtil.GetAssociationDescription("T_SZERVEZET_OSSZES", "C_PARENTSZERVEZETID")); // nincs kapcsolotabla
|
|
}
|
|
// ParentSzervezet esetében mi mutatunk a másikra: startrole: *, endrole: 0..1
|
|
if (this.SzakmunkaSzerzodes.Count > 0)
|
|
{
|
|
throw new EntityDeleteFailedException("Szervezet", "SzakmunkaSzerzodes", EntityUtil.GetAssociationDescription("T_SZAKMUNKASZERZODES_OSSZES", "C_SZERVEZETID")); // nincs kapcsolotabla
|
|
}
|
|
if (this.Igazolas.Count > 0)
|
|
{
|
|
throw new EntityDeleteFailedException("Szervezet", "Igazolas", EntityUtil.GetAssociationDescription("T_IGAZOLAS_OSSZES", "C_SZERVEZETID")); // nincs kapcsolotabla
|
|
}
|
|
// Intezmeny esetében mi mutatunk a másikra: startrole: *, endrole: 1
|
|
// Tanev esetében mi mutatunk a másikra: startrole: *, endrole: 1
|
|
|
|
// kaszkád törlések...
|
|
|
|
}
|
|
|
|
#region Mezők és tulajdonságok
|
|
|
|
#region Egyszerű mezők
|
|
|
|
#region Azonosito
|
|
|
|
protected internal string m_Azonosito;
|
|
|
|
/// <summary>
|
|
/// Duális, Dobbantó, Orientációs, Műhely iskola kapcsolódó szervezetek táblája
|
|
/// </summary>
|
|
[EntityProperty("Azonosito", EntityPropertyBaseType.ValueType, typeof(string), EntityCopyMethod.ShallowCopy)]
|
|
public virtual string Azonosito
|
|
{
|
|
get
|
|
{
|
|
return m_Azonosito;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
|
|
if (m_Azonosito == value) return;
|
|
m_Azonosito = value;
|
|
FieldModified("Azonosito", value);
|
|
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsNavSzinkronizalt
|
|
|
|
protected internal bool m_IsNavSzinkronizalt;
|
|
|
|
/// <summary>
|
|
/// T_MUNKASZERZODESEK betöltésekor bekerült vagy nem?
|
|
/// </summary>
|
|
[EntityProperty("IsNavSzinkronizalt", EntityPropertyBaseType.ValueType, typeof(bool), EntityCopyMethod.ShallowCopy)]
|
|
public virtual bool IsNavSzinkronizalt
|
|
{
|
|
get
|
|
{
|
|
return m_IsNavSzinkronizalt;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
|
|
if (m_IsNavSzinkronizalt == value) return;
|
|
m_IsNavSzinkronizalt = value;
|
|
FieldModified("IsNavSzinkronizalt", value);
|
|
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IsSzinkronizalt
|
|
|
|
protected internal bool m_IsSzinkronizalt;
|
|
|
|
/// <summary>
|
|
/// Külső forrásból származó adat-e?
|
|
/// </summary>
|
|
[EntityProperty("IsSzinkronizalt", EntityPropertyBaseType.ValueType, typeof(bool), EntityCopyMethod.ShallowCopy)]
|
|
public virtual bool IsSzinkronizalt
|
|
{
|
|
get
|
|
{
|
|
return m_IsSzinkronizalt;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
|
|
if (m_IsSzinkronizalt == value) return;
|
|
m_IsSzinkronizalt = value;
|
|
FieldModified("IsSzinkronizalt", value);
|
|
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Nev
|
|
|
|
protected internal string m_Nev;
|
|
|
|
/// <summary>
|
|
/// Duális, Dobbantó, Orientációs, Műhely iskola kapcsolódó szervezetek táblája
|
|
/// </summary>
|
|
[EntityProperty("Nev", EntityPropertyBaseType.ValueType, typeof(string), EntityCopyMethod.ShallowCopy)]
|
|
public virtual string Nev
|
|
{
|
|
get
|
|
{
|
|
return m_Nev;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
|
|
if (m_Nev == value) return;
|
|
m_Nev = value;
|
|
FieldModified("Nev", value);
|
|
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Tipus
|
|
|
|
protected internal int m_Tipus;
|
|
|
|
/// <summary>
|
|
/// 1- Duális, 2 - Orinetációs, 3 - Műhely Iskola, 4, Dobbantó
|
|
/// </summary>
|
|
[EntityProperty("Tipus", EntityPropertyBaseType.ValueType, typeof(int), EntityCopyMethod.ShallowCopy)]
|
|
public virtual int Tipus
|
|
{
|
|
get
|
|
{
|
|
return m_Tipus;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
|
|
if (m_Tipus == value) return;
|
|
m_Tipus = value;
|
|
FieldModified("Tipus", value);
|
|
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Szervezetcim
|
|
|
|
protected internal string m_Szervezetcim;
|
|
|
|
/// <summary>
|
|
/// Duális képzőhely címe
|
|
/// </summary>
|
|
[EntityProperty("Szervezetcim", EntityPropertyBaseType.ValueType, typeof(string), EntityCopyMethod.ShallowCopy)]
|
|
public virtual string Szervezetcim
|
|
{
|
|
get
|
|
{
|
|
return m_Szervezetcim;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
|
|
if (m_Szervezetcim == value) return;
|
|
m_Szervezetcim = value;
|
|
FieldModified("Szervezetcim", value);
|
|
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region DualishelyszintipusId
|
|
|
|
protected internal int /* DictionaryItem */ m_DualishelyszintipusId;
|
|
|
|
/// <summary>
|
|
/// Nincs definiálva megjegyzés.
|
|
/// </summary>
|
|
[EntityProperty("DualishelyszintipusId", EntityPropertyBaseType.ValueType, typeof(int /* DictionaryItem */), EntityCopyMethod.ShallowCopy)]
|
|
[EntityDictionaryItemProperty("DualishelyszintipusId", "DualisHelyszinTipus", typeof(SDA.Kreta.Entities.DualisHelyszinTipus))]
|
|
|
|
public virtual int /* DictionaryItem */ DualishelyszintipusId
|
|
{
|
|
get
|
|
{
|
|
return m_DualishelyszintipusId;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
|
|
if (m_DualishelyszintipusId == value) return;
|
|
m_DualishelyszintipusId = value;
|
|
FieldModified("DualishelyszintipusId", value);
|
|
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region Asszociációkkal kapcsolatos dolgok
|
|
|
|
protected internal virtual bool LoadByTeremId(int id)
|
|
{
|
|
return m_DA.LoadByTeremId(id, this);
|
|
}
|
|
|
|
protected internal virtual bool LoadByCsoportId(int id)
|
|
{
|
|
return m_DA.LoadByCsoportId(id, this);
|
|
}
|
|
|
|
protected internal virtual bool LoadByMunkaugyiAdatokId(int id)
|
|
{
|
|
return m_DA.LoadByMunkaugyiAdatokId(id, this);
|
|
}
|
|
|
|
protected internal virtual bool LoadByTanuloTanugyiAdatokId(int id)
|
|
{
|
|
return m_DA.LoadByTanuloTanugyiAdatokId(id, this);
|
|
}
|
|
|
|
protected internal virtual bool LoadByTantargyId(int id)
|
|
{
|
|
return m_DA.LoadByTantargyId(id, this);
|
|
}
|
|
|
|
protected internal virtual bool LoadByChildSzervezetId(int id)
|
|
{
|
|
return m_DA.LoadByChildSzervezetId(id, this);
|
|
}
|
|
|
|
protected internal virtual bool LoadBySzakmunkaSzerzodesId(int id)
|
|
{
|
|
return m_DA.LoadBySzakmunkaSzerzodesId(id, this);
|
|
}
|
|
|
|
protected internal virtual bool LoadByIgazolasId(int id)
|
|
{
|
|
return m_DA.LoadByIgazolasId(id, this);
|
|
}
|
|
|
|
#region Szervezet (*) -> Szervezet (0..1)
|
|
|
|
protected internal int m_ParentSzervezetId = -1;
|
|
|
|
/// <summary>
|
|
/// A(z) ParentSzervezet asszociáció végpontjának ID-ja.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// - Insert() előtt célszerű kitölteni
|
|
/// - Update() nincs rá hatással: ezt a mezőt nem frissíti
|
|
/// - LoadByID() felhozza ezt a mezőt
|
|
/// </remarks>
|
|
public virtual int ParentSzervezetId
|
|
{
|
|
get
|
|
{
|
|
return InternalParentSzervezetId;
|
|
}
|
|
set
|
|
{
|
|
InternalParentSzervezetId = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ez egy külön bejárat a DA számára
|
|
/// <summary>
|
|
internal int InternalParentSzervezetId
|
|
{
|
|
get
|
|
{
|
|
if (m_ParentSzervezet != null)
|
|
{
|
|
return m_ParentSzervezet.ID;
|
|
}
|
|
else
|
|
{
|
|
return m_ParentSzervezetId;// XXX az meg nem teljesen OK
|
|
}
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
if (m_ParentSzervezetId != value)
|
|
{
|
|
m_ParentSzervezetId = value;
|
|
m_ParentSzervezet = null;
|
|
FieldModified("ParentSzervezetId", value);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ez egy külön bejárat a DA számára
|
|
/// <summary>
|
|
internal void ModifyParentSzervezet(Szervezet value)
|
|
{
|
|
m_ParentSzervezetId = value != null ? value.ID : -1;
|
|
m_ParentSzervezet = value;
|
|
FieldModified("ParentSzervezetId", value != null ? (object)value.ID : DBNull.Value);
|
|
}
|
|
|
|
protected internal void SetParentSzervezet(Szervezet value)
|
|
{
|
|
m_ParentSzervezet = value;
|
|
if (value != null)
|
|
{
|
|
m_ParentSzervezetId = value.ID;
|
|
}
|
|
else
|
|
{
|
|
m_ParentSzervezetId = -1;
|
|
}
|
|
}
|
|
|
|
protected Szervezet m_ParentSzervezet = null;
|
|
|
|
ISzervezet ISzervezet.ParentSzervezet
|
|
{
|
|
get { return ParentSzervezet; }
|
|
set { ParentSzervezet = value as Szervezet; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Nincs definiálva megjegyzés.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és Szervezet entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("ParentSzervezet", EntityPropertyBaseType.Entity, typeof(Szervezet), EntityCopyMethod.ShallowCopy)]
|
|
public virtual Szervezet ParentSzervezet
|
|
{
|
|
get
|
|
{
|
|
if ((m_ParentSzervezet == null) && (m_ParentSzervezetId != -1))
|
|
{
|
|
SDA.Kreta.Entities.Szervezet partner = SDA.Kreta.Entities.Szervezet.GiveAnInstance();
|
|
partner.LoadByID(m_ParentSzervezetId);
|
|
|
|
this.SetParentSzervezet(partner);
|
|
}
|
|
// természetesen null-t adunk vissza, ha nem tudtunk felhozni semmit
|
|
return m_ParentSzervezet;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
if (value != null)
|
|
{
|
|
if ((m_ParentSzervezet == null) || (value.ID != m_ParentSzervezet.ID))
|
|
{
|
|
if (value.State != EntityState.Initialized)
|
|
{
|
|
throw new EntityStateException(value.State);
|
|
}
|
|
if ((this.State != EntityState.New))
|
|
{
|
|
// Lista van a másik oldalon, úgyhogy a lista DA-ját használjuk
|
|
SDA.Kreta.Entities.Szervezet_ChildSzervezet_DA da = new Szervezet_ChildSzervezet_DA(value);
|
|
da.AddItem(this);
|
|
this.SetParentSzervezet(value);
|
|
}
|
|
else
|
|
{
|
|
this.SetParentSzervezet(value);
|
|
}
|
|
FieldModified("ParentSzervezetId", value.ID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// ki kell törölni a kapcsolatot az adatbázisban
|
|
this.SetParentSzervezet(null);
|
|
UpdateAssociations();
|
|
FieldModified("ParentSzervezetId", DBNull.Value);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Szervezet (*) -> Intezmeny (1)
|
|
|
|
protected internal int m_IntezmenyId = -1;
|
|
|
|
/// <summary>
|
|
/// A(z) Intezmeny asszociáció végpontjának ID-ja.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// - Insert() előtt célszerű kitölteni
|
|
/// - Update() nincs rá hatással: ezt a mezőt nem frissíti
|
|
/// - LoadByID() felhozza ezt a mezőt
|
|
/// </remarks>
|
|
public virtual int IntezmenyId
|
|
{
|
|
get
|
|
{
|
|
return InternalIntezmenyId;
|
|
}
|
|
set
|
|
{
|
|
InternalIntezmenyId = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ez egy külön bejárat a DA számára
|
|
/// <summary>
|
|
internal int InternalIntezmenyId
|
|
{
|
|
get
|
|
{
|
|
if (m_Intezmeny != null)
|
|
{
|
|
return m_Intezmeny.ID;
|
|
}
|
|
else
|
|
{
|
|
return m_IntezmenyId;// XXX az meg nem teljesen OK
|
|
}
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
if (m_IntezmenyId != value)
|
|
{
|
|
m_IntezmenyId = value;
|
|
m_Intezmeny = null;
|
|
FieldModified("IntezmenyId", value);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ez egy külön bejárat a DA számára
|
|
/// <summary>
|
|
internal void ModifyIntezmeny(Intezmeny value)
|
|
{
|
|
m_IntezmenyId = value != null ? value.ID : -1;
|
|
m_Intezmeny = value;
|
|
FieldModified("IntezmenyId", value != null ? (object)value.ID : DBNull.Value);
|
|
}
|
|
|
|
protected internal void SetIntezmeny(Intezmeny value)
|
|
{
|
|
m_Intezmeny = value;
|
|
if (value != null)
|
|
{
|
|
m_IntezmenyId = value.ID;
|
|
}
|
|
else
|
|
{
|
|
m_IntezmenyId = -1;
|
|
}
|
|
}
|
|
|
|
protected Intezmeny m_Intezmeny = null;
|
|
|
|
IIntezmeny ISzervezet.Intezmeny
|
|
{
|
|
get { return Intezmeny; }
|
|
set { Intezmeny = value as Intezmeny; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Nincs definiálva megjegyzés.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és Intezmeny entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("Intezmeny", EntityPropertyBaseType.Entity, typeof(Intezmeny), EntityCopyMethod.ShallowCopy)]
|
|
public virtual Intezmeny Intezmeny
|
|
{
|
|
get
|
|
{
|
|
if ((m_Intezmeny == null) && (m_IntezmenyId != -1))
|
|
{
|
|
SDA.Kreta.Entities.Intezmeny partner = SDA.Kreta.Entities.Intezmeny.GiveAnInstance();
|
|
partner.LoadByID(m_IntezmenyId);
|
|
|
|
this.SetIntezmeny(partner);
|
|
}
|
|
// természetesen null-t adunk vissza, ha nem tudtunk felhozni semmit
|
|
return m_Intezmeny;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
if (value != null)
|
|
{
|
|
if ((m_Intezmeny == null) || (value.ID != m_Intezmeny.ID))
|
|
{
|
|
if (value.State != EntityState.Initialized)
|
|
{
|
|
throw new EntityStateException(value.State);
|
|
}
|
|
if ((this.State != EntityState.New))
|
|
{
|
|
// Lista van a másik oldalon, úgyhogy a lista DA-ját használjuk
|
|
SDA.Kreta.Entities.Intezmeny_Szervezet_DA da = new Intezmeny_Szervezet_DA(value);
|
|
da.AddItem(this);
|
|
this.SetIntezmeny(value);
|
|
}
|
|
else
|
|
{
|
|
this.SetIntezmeny(value);
|
|
}
|
|
FieldModified("IntezmenyId", value.ID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// ki kell törölni a kapcsolatot az adatbázisban
|
|
this.SetIntezmeny(null);
|
|
UpdateAssociations();
|
|
FieldModified("IntezmenyId", DBNull.Value);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Szervezet (*) -> Tanev (1)
|
|
|
|
protected internal int m_TanevId = -1;
|
|
|
|
/// <summary>
|
|
/// A(z) Tanev asszociáció végpontjának ID-ja.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// - Insert() előtt célszerű kitölteni
|
|
/// - Update() nincs rá hatással: ezt a mezőt nem frissíti
|
|
/// - LoadByID() felhozza ezt a mezőt
|
|
/// </remarks>
|
|
public virtual int TanevId
|
|
{
|
|
get
|
|
{
|
|
return InternalTanevId;
|
|
}
|
|
set
|
|
{
|
|
InternalTanevId = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ez egy külön bejárat a DA számára
|
|
/// <summary>
|
|
internal int InternalTanevId
|
|
{
|
|
get
|
|
{
|
|
if (m_Tanev != null)
|
|
{
|
|
return m_Tanev.ID;
|
|
}
|
|
else
|
|
{
|
|
return m_TanevId;// XXX az meg nem teljesen OK
|
|
}
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
if (m_TanevId != value)
|
|
{
|
|
m_TanevId = value;
|
|
m_Tanev = null;
|
|
FieldModified("TanevId", value);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ez egy külön bejárat a DA számára
|
|
/// <summary>
|
|
internal void ModifyTanev(Tanev value)
|
|
{
|
|
m_TanevId = value != null ? value.ID : -1;
|
|
m_Tanev = value;
|
|
FieldModified("TanevId", value != null ? (object)value.ID : DBNull.Value);
|
|
}
|
|
|
|
protected internal void SetTanev(Tanev value)
|
|
{
|
|
m_Tanev = value;
|
|
if (value != null)
|
|
{
|
|
m_TanevId = value.ID;
|
|
}
|
|
else
|
|
{
|
|
m_TanevId = -1;
|
|
}
|
|
}
|
|
|
|
protected Tanev m_Tanev = null;
|
|
|
|
ITanev ISzervezet.Tanev
|
|
{
|
|
get { return Tanev; }
|
|
set { Tanev = value as Tanev; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Nincs definiálva megjegyzés.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és Tanev entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("Tanev", EntityPropertyBaseType.Entity, typeof(Tanev), EntityCopyMethod.ShallowCopy)]
|
|
public virtual Tanev Tanev
|
|
{
|
|
get
|
|
{
|
|
if ((m_Tanev == null) && (m_TanevId != -1))
|
|
{
|
|
SDA.Kreta.Entities.Tanev partner = SDA.Kreta.Entities.Tanev.GiveAnInstance();
|
|
partner.LoadByID(m_TanevId);
|
|
|
|
this.SetTanev(partner);
|
|
}
|
|
// természetesen null-t adunk vissza, ha nem tudtunk felhozni semmit
|
|
return m_Tanev;
|
|
}
|
|
set
|
|
{
|
|
CheckModifyable();
|
|
if (value != null)
|
|
{
|
|
if ((m_Tanev == null) || (value.ID != m_Tanev.ID))
|
|
{
|
|
if (value.State != EntityState.Initialized)
|
|
{
|
|
throw new EntityStateException(value.State);
|
|
}
|
|
if ((this.State != EntityState.New))
|
|
{
|
|
// Lista van a másik oldalon, úgyhogy a lista DA-ját használjuk
|
|
SDA.Kreta.Entities.Tanev_Szervezet_DA da = new Tanev_Szervezet_DA(value);
|
|
da.AddItem(this);
|
|
this.SetTanev(value);
|
|
}
|
|
else
|
|
{
|
|
this.SetTanev(value);
|
|
}
|
|
FieldModified("TanevId", value.ID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// ki kell törölni a kapcsolatot az adatbázisban
|
|
this.SetTanev(null);
|
|
UpdateAssociations();
|
|
FieldModified("TanevId", DBNull.Value);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region Szervezet (0..1) -> Terem (*)
|
|
protected IAssociatedEntityCollection<Terem> m_Terem = null;
|
|
|
|
IReadOnlyList<ITerem> ISzervezet.Terem => Terem.Cast<ITerem>().ToList();
|
|
|
|
/// <summary>
|
|
/// A kapcsolódó szervezet ID-ja
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és Terem entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("Terem", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<Terem>), EntityCopyMethod.DeepCopy, "SzervezetId")]
|
|
public virtual IAssociatedEntityCollection<Terem> Terem
|
|
{
|
|
get
|
|
{
|
|
if (m_Terem == null)
|
|
{
|
|
m_Terem = new AssociatedEntityCollection<Szervezet, Terem>(
|
|
new Szervezet_Terem_DA(this)
|
|
);
|
|
m_Terem.Load();
|
|
}
|
|
return m_Terem;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Szervezet (0..1) -> Csoport (*)
|
|
protected IAssociatedEntityCollection<Csoport> m_Csoport = null;
|
|
|
|
IReadOnlyList<ICsoport> ISzervezet.Csoport => Csoport.Cast<ICsoport>().ToList();
|
|
|
|
/// <summary>
|
|
/// A kapcsolódó szervezet ID-ja
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és Csoport entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("Csoport", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<Csoport>), EntityCopyMethod.DeepCopy, "SzervezetId")]
|
|
public virtual IAssociatedEntityCollection<Csoport> Csoport
|
|
{
|
|
get
|
|
{
|
|
if (m_Csoport == null)
|
|
{
|
|
m_Csoport = new AssociatedEntityCollection<Szervezet, Csoport>(
|
|
new Szervezet_Csoport_DA(this)
|
|
);
|
|
m_Csoport.Load();
|
|
}
|
|
return m_Csoport;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Szervezet (0..1) -> MunkaugyiAdatok (*)
|
|
protected IAssociatedEntityCollection<MunkaugyiAdatok> m_MunkaugyiAdatok = null;
|
|
|
|
IReadOnlyList<IMunkaugyiAdatok> ISzervezet.MunkaugyiAdatok => MunkaugyiAdatok.Cast<IMunkaugyiAdatok>().ToList();
|
|
|
|
/// <summary>
|
|
/// A kapcsolódó szervezet ID-ja
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és MunkaugyiAdatok entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("MunkaugyiAdatok", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<MunkaugyiAdatok>), EntityCopyMethod.DeepCopy, "SzervezetId")]
|
|
public virtual IAssociatedEntityCollection<MunkaugyiAdatok> MunkaugyiAdatok
|
|
{
|
|
get
|
|
{
|
|
if (m_MunkaugyiAdatok == null)
|
|
{
|
|
m_MunkaugyiAdatok = new AssociatedEntityCollection<Szervezet, MunkaugyiAdatok>(
|
|
new Szervezet_MunkaugyiAdatok_DA(this)
|
|
);
|
|
m_MunkaugyiAdatok.Load();
|
|
}
|
|
return m_MunkaugyiAdatok;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Szervezet (0..1) -> TanuloTanugyiAdatok (*)
|
|
protected IAssociatedEntityCollection<TanuloTanugyiAdatok> m_TanuloTanugyiAdatok = null;
|
|
|
|
IReadOnlyList<ITanuloTanugyiAdatok> ISzervezet.TanuloTanugyiAdatok => TanuloTanugyiAdatok.Cast<ITanuloTanugyiAdatok>().ToList();
|
|
|
|
/// <summary>
|
|
/// A kapcsolódó szervezet ID-ja
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és TanuloTanugyiAdatok entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("TanuloTanugyiAdatok", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<TanuloTanugyiAdatok>), EntityCopyMethod.DeepCopy, "SzervezetId")]
|
|
public virtual IAssociatedEntityCollection<TanuloTanugyiAdatok> TanuloTanugyiAdatok
|
|
{
|
|
get
|
|
{
|
|
if (m_TanuloTanugyiAdatok == null)
|
|
{
|
|
m_TanuloTanugyiAdatok = new AssociatedEntityCollection<Szervezet, TanuloTanugyiAdatok>(
|
|
new Szervezet_TanuloTanugyiAdatok_DA(this)
|
|
);
|
|
m_TanuloTanugyiAdatok.Load();
|
|
}
|
|
return m_TanuloTanugyiAdatok;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Szervezet (0..1) -> Tantargy (*)
|
|
protected IAssociatedEntityCollection<Tantargy> m_Tantargy = null;
|
|
|
|
IReadOnlyList<ITantargy> ISzervezet.Tantargy => Tantargy.Cast<ITantargy>().ToList();
|
|
|
|
/// <summary>
|
|
/// A kapcsolódó szervezet ID-ja
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és Tantargy entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("Tantargy", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<Tantargy>), EntityCopyMethod.DeepCopy, "SzervezetId")]
|
|
public virtual IAssociatedEntityCollection<Tantargy> Tantargy
|
|
{
|
|
get
|
|
{
|
|
if (m_Tantargy == null)
|
|
{
|
|
m_Tantargy = new AssociatedEntityCollection<Szervezet, Tantargy>(
|
|
new Szervezet_Tantargy_DA(this)
|
|
);
|
|
m_Tantargy.Load();
|
|
}
|
|
return m_Tantargy;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Szervezet (0..1) -> Szervezet (*)
|
|
protected IAssociatedEntityCollection<Szervezet> m_ChildSzervezet = null;
|
|
|
|
IReadOnlyList<ISzervezet> ISzervezet.ChildSzervezet => ChildSzervezet.Cast<ISzervezet>().ToList();
|
|
|
|
/// <summary>
|
|
/// Nincs definiálva megjegyzés.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és Szervezet entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("ChildSzervezet", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<Szervezet>), EntityCopyMethod.DeepCopy, "ParentSzervezetId")]
|
|
public virtual IAssociatedEntityCollection<Szervezet> ChildSzervezet
|
|
{
|
|
get
|
|
{
|
|
if (m_ChildSzervezet == null)
|
|
{
|
|
m_ChildSzervezet = new AssociatedEntityCollection<Szervezet, Szervezet>(
|
|
new Szervezet_ChildSzervezet_DA(this)
|
|
);
|
|
m_ChildSzervezet.Load();
|
|
}
|
|
return m_ChildSzervezet;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Szervezet (0..1) -> SzakmunkaSzerzodes (*)
|
|
protected IAssociatedEntityCollection<SzakmunkaSzerzodes> m_SzakmunkaSzerzodes = null;
|
|
|
|
IReadOnlyList<ISzakmunkaSzerzodes> ISzervezet.SzakmunkaSzerzodes => SzakmunkaSzerzodes.Cast<ISzakmunkaSzerzodes>().ToList();
|
|
|
|
/// <summary>
|
|
/// Nincs definiálva megjegyzés.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és SzakmunkaSzerzodes entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("SzakmunkaSzerzodes", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<SzakmunkaSzerzodes>), EntityCopyMethod.DeepCopy, "SzervezetId")]
|
|
public virtual IAssociatedEntityCollection<SzakmunkaSzerzodes> SzakmunkaSzerzodes
|
|
{
|
|
get
|
|
{
|
|
if (m_SzakmunkaSzerzodes == null)
|
|
{
|
|
m_SzakmunkaSzerzodes = new AssociatedEntityCollection<Szervezet, SzakmunkaSzerzodes>(
|
|
new Szervezet_SzakmunkaSzerzodes_DA(this)
|
|
);
|
|
m_SzakmunkaSzerzodes.Load();
|
|
}
|
|
return m_SzakmunkaSzerzodes;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Szervezet (0..1) -> Igazolas (*)
|
|
protected IAssociatedEntityCollection<Igazolas> m_Igazolas = null;
|
|
|
|
IReadOnlyList<IIgazolas> ISzervezet.Igazolas => Igazolas.Cast<IIgazolas>().ToList();
|
|
|
|
/// <summary>
|
|
/// A kapcsolódó szervezet Id-ja
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Az UML modellben szereplő Szervezet és Igazolas entitások közötti asszociáció megvalósítása.
|
|
/// </remarks>
|
|
[EntityProperty("Igazolas", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<Igazolas>), EntityCopyMethod.DeepCopy, "SzervezetId")]
|
|
public virtual IAssociatedEntityCollection<Igazolas> Igazolas
|
|
{
|
|
get
|
|
{
|
|
if (m_Igazolas == null)
|
|
{
|
|
m_Igazolas = new AssociatedEntityCollection<Szervezet, Igazolas>(
|
|
new Szervezet_Igazolas_DA(this)
|
|
);
|
|
m_Igazolas.Load();
|
|
}
|
|
return m_Igazolas;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|