This commit is contained in:
skidoodle 2024-03-13 00:33:46 +01:00
commit e124a47765
19374 changed files with 9806149 additions and 0 deletions

View file

@ -0,0 +1,134 @@
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllEntityAssociationsIDToEntityState(MClass as ENTITY, COUNTERNAME, ENTITYSTATENAME, READERNAME)
// [GetEntityName([ENTITY])] asszociációi
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
[if ([ENDROLE.multiplicity] == "1" or [ENDROLE.multiplicity] == "0..1")]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[ENTITYSTATENAME].[ConvertNameToEntityStateAttributeName(GetRoleName([ENDROLE]))].[ConvertNameToEntityStateAttributeName("ID")] = [READERNAME].GetValue([COUNTERNAME]++);
[else]
// XXX [GetRoleName([ENDROLE])] ez az asszociáció asszociációs osztállyal rendelkezik, és még nincs megvalósítva, lásd GenerateLoadAllAttributesAndEntityAssociationsIDToEntityState
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity"))]
[ENTITYSTATENAME].[ConvertNameToEntityStateAttributeName(GetRoleName([STARTROLE]))].[ConvertNameToEntityStateAttributeName("ID")] = [READERNAME].GetValue([COUNTERNAME]++);
[ENTITYSTATENAME].[ConvertNameToEntityStateAttributeName(GetRoleName([ENDROLE]))].[ConvertNameToEntityStateAttributeName("ID")] = [READERNAME].GetValue([COUNTERNAME]++);
[end loop]
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAttributesAndEntityAssociationsIDToEntityState([BASECLASS], [COUNTERNAME], [ENTITYSTATENAME], [READERNAME])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL parancsot, ami felhozza az adatbázisból egy adott //
// entitás összes asszociációs partnerének azonosítóját. //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateLoadAllAssociationIDCommand(MClass as ENTITY)
select
[ConvertNameToSQLTableName([ENTITY.name])].ID,
[GenerateLoadAllAssociationIDCommandColumns([ENTITY])]
[GenerateSerialColumn([ENTITY])]
from
[GenerateLoadAllAttributesCommandTables([ENTITY])]
[GenerateLoadAllAssociationIDCommandJoin([ENTITY])]
where
[if (IsMasterEntity([ENTITY]) == "true")]
([ConvertNameToSQLTableName([ENTITY.name])].SERIAL >= 0)
[else]
[GenerateLoadAllAttributesCommandWhere([ENTITY])]
[end if]
and (rownum < 1000)
end template
//***************************************************************************//
// Legenerálja az asszociációs partnerek tábláinak join-jait. (SQL töredék) //
//***************************************************************************//
template GenerateLoadAllAssociationIDCommandJoin(MClass as ENTITY)
[GenerateLoadAllAssociationIDCommandJoinCore([ENTITY], [ENTITY])]
end template
//***************************************************************************//
// Legenerálja az asszociációs partnerek tábláinak join-jait. (SQL töredék) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAssociationIDCommandJoinCore(MClass as ENTITY, MClass as MASTER)
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
[else]
[if ([STARTROLE.multiplicity] == "1")]
left join [ConvertNameToSQLTableName([PARTNER.name])] on [ConvertNameToSQLTableName([PARTNER.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([MASTER.name])].ID -- a masik tablaban van a kapcsolomezo
[else]
left join [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))] on [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([MASTER.name])].ID -- kapcsolotabla van
[end if]
[end if]
[end if]
[end if]
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAssociationIDCommandJoinCore([BASECLASS], [MASTER])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja az asszociációs partnerek azonosító oszlopait (SQL töredék) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAssociationIDCommandColumns(MClass as ENTITY)
-- [GetEntityName([ENTITY])] asszociációi
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "1")]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))], -- Kötelező asszociációs kapcsolómező
[else]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))], -- Opcionális asszociációs kapcsolómező
[else]
[if ([STARTROLE.multiplicity] == "1")]
[ConvertNameToSQLTableName([PARTNER.name])].ID as [ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))], -- a masik tablaban van a kapcsolomezo
[else]
[ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))], -- kapcsolotabla van
[end if]
[end if]
[end if]
[end if]
[else]
[if ([ENDROLE.multiplicity] == "1" or [ENDROLE.multiplicity] == "0..1")]
-- XXX [GetRoleName([ENDROLE])] ez az asszociáció asszociációs osztállyal rendelkezik, és még nincs megvalósítva, lásd GenerateLoadAllAttributesAndEntityAssociationsIDToEntityState
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity"))]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))], -- Asszociációs mező
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))], -- Asszociációs mező
[end loop]
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAssociationIDCommandColumns([BASECLASS])][break]
[end loop]
[end if]
end template

View file

@ -0,0 +1,124 @@
/* A fájlban lévő sablonokat szinkronban kell tartani a szelekt generáló sablonokkal! */
/* Később kell egy kis refaktoring is! */
//***************************************************************************//
// Legenerálja azt a ciklusmagot, amely egy DataReader-ből kiszippantja //
// az entitás összes attribútumát. //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAttributesToEntityState(MClass as ENTITY, COUNTERNAME, ENTITYSTATENAME, READERNAME)
// [GetEntityName([ENTITY])] attribútumai
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[ENTITYSTATENAME].[ConvertNameToEntityStateAttributeName(GetAttributeName([ATTRIBUTE]))] = [READERNAME].GetValue([COUNTERNAME]++);
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAttributesToEntityState([BASECLASS], [COUNTERNAME], [ENTITYSTATENAME], [READERNAME])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL parancsot helyőrzőkkel, ami felhozza az //
// adatbázisból egy entitás összes attribútumát. //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateLoadAllAttributesCommand(MClass as ENTITY)
select
[ConvertNameToSQLTableName([ENTITY.name])].ID,
[GenerateLoadAllAttributesCommandColumns([ENTITY])]
[GenerateSerialColumn([ENTITY])]
from
[GenerateLoadAllAttributesCommandTables([ENTITY])]
{0}
where
[GenerateLoadAllAttributesCommandWhere([ENTITY])]
{1}
end template
//***************************************************************************//
// Legenerálja a SERIAL rendszeroszlop minősített nevét //
//***************************************************************************//
template GenerateSerialColumn(MClass as ENTITY)
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateSerialColumn([BASECLASS])][break]
[end loop]
[else]
[ConvertNameToSQLTableName([ENTITY.name])].SERIAL
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás összes attribútumát //
// tartalmazza. (a rendszerattribútumokat nem generálja le!) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAttributesCommandColumns(MClass as ENTITY)
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName([ATTRIBUTE.name])],
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAttributesCommandColumns([BASECLASS])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás lekérdezéséhez //
// felsorolja annak tábláit. (join-ok nélkül!) //
//***************************************************************************//
template GenerateLoadAllAttributesCommandTables(MClass as ENTITY)
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAttributesCommandTablesCore([BASECLASS])]
[end loop]
[end if]
[ConvertNameToSQLTableName([ENTITY.name])]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás lekérdezéséhez //
// felsorolja annak tábláit. (join-ok nélkül!) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAttributesCommandTablesCore(MClass as ENTITY)
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAttributesCommandTablesCore([BASECLASS])]
[ConvertNameToSQLTableName([ENTITY.name])],[break]
[end loop]
[else]
[ConvertNameToSQLTableName([ENTITY.name])],
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás tábláit összekapcsolja. //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAttributesCommandWhere(MClass as ENTITY)
[if (IsMasterEntity([ENTITY]) == "false")]
([ConvertNameToSQLTableName(GetBaseClassName([ENTITY], "qqq"))].ID = [ConvertNameToSQLTableName([ENTITY.name])].ID)
[if (GetBaseBaseClassName([ENTITY], "") != "")]
[loop (ENTITY -> SuperClass as BASECLASS)]
and
[GenerateLoadAllAttributesCommandWhere([BASECLASS])][break]
[end loop]
[end if]
[end if]
end template

View file

@ -0,0 +1,31 @@
//***************************************************************************//
// Legenerálja azt a ciklusmagot, amely egy DataReader-ből kiszippantja //
// az entitás összes attribútumát és entitás típusú asszociációjának az //
// azonosítóját. //
//***************************************************************************//
template GenerateLoadAllAttributesAndEntityAssociationsIDToEntityState(MClass as ENTITY, COUNTERNAME, ENTITYSTATENAME, READERNAME)
[GenerateLoadAllAttributesToEntityState([ENTITY], [COUNTERNAME], [ENTITYSTATENAME], [READERNAME])]
[GenerateLoadAllEntityAssociationsIDToEntityState([ENTITY], [COUNTERNAME], [ENTITYSTATENAME], [READERNAME])]
end template
//***************************************************************************//
// Legenerálja azt az SQL parancsot, ami lekérdez egy entitás alaphalmazás. //
//***************************************************************************//
template GenerateLoadAllAttributesAndEntityAssociationsIDCommand(MClass as ENTITY)
select
[ConvertNameToSQLTableName([ENTITY.name])].ID,
[GenerateLoadAllAttributesCommandColumns([ENTITY])]
[GenerateLoadAllAssociationIDCommandColumns([ENTITY])]
[GenerateSerialColumn([ENTITY])]
from
[GenerateLoadAllAttributesCommandTables([ENTITY])]
[GenerateLoadAllAssociationIDCommandJoin([ENTITY])]
where
[if (IsMasterEntity([ENTITY]) == "true")]
([ConvertNameToSQLTableName([ENTITY.name])].SERIAL >= 0)
[else]
[GenerateLoadAllAttributesCommandWhere([ENTITY])]
[end if]
and (rownum < 1000)
end template

View file

@ -0,0 +1,49 @@
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateInsertEntityCommand(MClass as ENTITY)
begin
[GenerateInsertEntityCommandCore([ENTITY])]
end;
end template
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateInsertEntityCommandCore(MClass as ENTITY)
[if (IsMasterEntity([ENTITY]) == "false")]
insert into [ConvertNameToSQLTableName([ENTITY.name])] (
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[ConvertNameToSQLColumnName([ATTRIBUTE.name])],
[end loop]
ID
)
values (
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
:[ConvertNameToCommandParameterName([ATTRIBUTE.name])],
[end loop]
:[ConvertNameToCommandParameterName("ID")]
);
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateInsertEntityCommandCore([BASECLASS])][break]
[end loop]
[else]
insert into [ConvertNameToSQLTableName([ENTITY.name])] (
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[ConvertNameToSQLColumnName([ATTRIBUTE.name])],
[end loop]
ID, SERIAL
)
values (
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
:[ConvertNameToCommandParameterName([ATTRIBUTE.name])],
[end loop]
:[ConvertNameToCommandParameterName("ID")], :[ConvertNameToCommandParameterName("Serial")]
);
[end if]
end template

View file

@ -0,0 +1,505 @@
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás összes attribútumát //
// tartalmazza. (a rendszerattribútumokat nem generálja le!) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAttributesCommandColumns(MClass as ENTITY, PREFIX)
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName([ATTRIBUTE.name])] ""[PREFIX][ATTRIBUTE.name]"",
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAttributesCommandColumns([BASECLASS], [PREFIX])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja egy entitás összes név oszlopát, minősített nevekkel. //
// (SQL töredék) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadNameColumns(MClass as ENTITY, ENTITYALIAS, PREFIX)
[loop (ENTITY -> MAttribute as ATTRIBUTE where GetStereoTypeForAttribute([ATTRIBUTE]) == "DisplayName")]
[ConvertNameToSQLTableName([ENTITYALIAS] "_" [ENTITY.id])].[ConvertNameToSQLColumnName([ATTRIBUTE.name])] ""[PREFIX]a[ENTITYALIAS]_[ATTRIBUTE.name]"",
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadNameColumns([BASECLASS], [ENTITYALIAS], [PREFIX])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás összes attribútumát, //
// asszociációs partnereinek azonosítóját és neveit tartalmazza. //
//***************************************************************************//
template GenerateLoadAllAssociationIDAndNameColumns(MClass as ENTITY, PREFIX)
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "1")]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[GenerateLoadNameColumns([PARTNER], [ENDROLE.id], [PREFIX])]
[else]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[GenerateLoadNameColumns([PARTNER], [ENDROLE.id], [PREFIX])]
[else]
[if ([STARTROLE.multiplicity] == "1")]
[ConvertNameToSQLTableName([PARTNER.name])].ID as [ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[GenerateLoadNameColumns([PARTNER], [ENDROLE.id], [PREFIX])]
[else]
[ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[GenerateLoadNameColumns([PARTNER], [ENDROLE.id], [PREFIX])]
[end if]
[end if]
[end if]
[end if]
[else]
[if ([ENDROLE.multiplicity] == "1" or [ENDROLE.multiplicity] == "0..1")]
[/*-- XXX [GetRoleName([ENDROLE])] ez az asszociáció asszociációs osztállyal rendelkezik, és még nincs megvalósítva, lásd GenerateLoadAllAttributesAndEntityAssociationsIDToEntityState*/]
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity"))]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))],
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[end loop]
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAssociationIDCommandColumns([BASECLASS])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja az asszociációs partnerek azonosító oszlopait (SQL töredék) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAssociationIDCommandColumns(MClass as ENTITY)
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "1")]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[else]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[else]
[if ([STARTROLE.multiplicity] == "1")]
[ConvertNameToSQLTableName([PARTNER.name])].ID as [ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[else]
[ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[end if]
[end if]
[end if]
[end if]
[else]
[if ([ENDROLE.multiplicity] == "1" or [ENDROLE.multiplicity] == "0..1")]
[/*-- XXX [GetRoleName([ENDROLE])] ez az asszociáció asszociációs osztállyal rendelkezik, és még nincs megvalósítva, lásd GenerateLoadAllAttributesAndEntityAssociationsIDToEntityState*/]
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity"))]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))],
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))],
[end loop]
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAssociationIDCommandColumns([BASECLASS])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás lekérdezéséhez //
// felsorolja annak tábláit. (join-ok nélkül!) //
//***************************************************************************//
template GenerateJoinedLoadAllAttributesCommandTables(MClass as ENTITY, MClass as BASE, MAssociationEnd as STARTROLE)
inner join [ConvertNameToSQLTableName([ENTITY.name])] on ([ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([BASE.name])].ID) [/*--4*/]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAttributesCommandTablesCore([BASECLASS], [ENTITY])]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás lekérdezéséhez //
// felsorolja annak tábláit. (join-ok nélkül!) //
//***************************************************************************//
template GenerateLoadAllAttributesCommandTables(MClass as ENTITY)
[ConvertNameToSQLTableName([ENTITY.name])]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAttributesCommandTablesCore([BASECLASS], [ENTITY])]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami egy entitás lekérdezéséhez //
// felsorolja annak tábláit. (join-ok nélkül!) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAttributesCommandTablesCore(MClass as ENTITY, MClass as BASE)
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
inner join [ConvertNameToSQLTableName([ENTITY.name])] on ([ConvertNameToSQLTableName([BASE.name])].ID = [ConvertNameToSQLTableName([ENTITY.name])].ID) [/*--1*/]
[GenerateLoadAllAttributesCommandTablesCore([BASECLASS], [ENTITY])]
[break]
[end loop]
[else]
inner join [ConvertNameToSQLTableName([ENTITY.name])] on ([ConvertNameToSQLTableName([BASE.name])].ID = [ConvertNameToSQLTableName([ENTITY.name])].ID) [/*--2*/]
[end if]
end template
//***************************************************************************//
// Legenerálja egy entitás asszociációs partner azonosító alapján való //
// lekérdezéséhez szükséges kapcsolótáblákat. //
// (SQL töredék a from szekcióban) //
//***************************************************************************//
template GenerateSwitchTablesByAssociation(MClass as ENTITY, MClass as PARTNER, MAssociationEnd as STARTROLE, MAssociationEnd as ENDROLE)
[if ([ENTITY.name] != [PARTNER.name])]
[if ([ENDROLE.multiplicity] == "1")]
[end if]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
[else]
[if ([STARTROLE.multiplicity] == "1")]
[ConvertNameToSQLTableName([PARTNER.name])] T_T_PARTNER,
[else]
[ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE], [STARTROLE]))] T_T_SWITCH,
[end if]
[end if]
[end if]
[if (([ENDROLE.multiplicity] == "1..*") or ([ENDROLE.multiplicity] == "*") or ([ENDROLE.multiplicity] == "0..*"))]
[if (([STARTROLE.multiplicity] == "1") or ([STARTROLE.multiplicity] == "0..1"))]
[ConvertNameToSQLTableName([PARTNER.name])] T_T_PARTNER,
[else]
[ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE], [STARTROLE]))] T_T_SWITCH,
[end if]
[end if]
[else]
[if ([ENDROLE.multiplicity] == "1" or [ENDROLE.multiplicity] == "0..1")]
[else]
[if ([STARTROLE.multiplicity] == "1" or [STARTROLE.multiplicity] == "0..1")]
[ConvertNameToSQLTableName([PARTNER.name])] T_T_PARTNER,
[else]
[ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE], [STARTROLE]))] T_T_SWITCH,
[end if]
[end if]
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami összekapcsolja az entitás //
// asszociációinak tábláit, az entitás táblái nélkül. //
// (from szekció az SQL-ben) //
//***************************************************************************//
template GenerateLoadAllAssociationIDAndNameColumnsCommandJoin(MClass as ENTITY)
[GenerateLoadAllAssociationIDAndNameColumnsCommandJoinCore([ENTITY], [ENTITY])]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami összekapcsolja az entitás //
// asszociációinak tábláit, az entitás táblái nélkül. //
// (from szekció az SQL-ben) //
//***************************************************************************//
template GenerateLoadAllAssociationIDAndNameColumnsCommandJoinCore(MClass as ENTITY, MClass as MASTER)
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "1")]
[GenerateLoadNameColumnsCommandJoinCore([PARTNER], [MASTER], [STARTROLE], [ENDROLE])]
[else]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
[GenerateLoadNameColumnsCommandJoinCore([PARTNER], [MASTER], [STARTROLE], [ENDROLE])]
[else]
[if ([STARTROLE.multiplicity] == "1")]
left join [ConvertNameToSQLTableName([PARTNER.name])] on [ConvertNameToSQLTableName([PARTNER.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([MASTER.name])].ID
[GenerateLoadNameColumnsCommandJoinCore([PARTNER], [MASTER], [STARTROLE], [ENDROLE])]
[else]
left join [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))] on [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([MASTER.name])].ID
[GenerateLoadNameColumnsCommandJoinCore([PARTNER], [MASTER], [STARTROLE], [ENDROLE])]
[end if]
[end if]
[end if]
[end if]
[end if]
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAssociationIDCommandJoinCore([BASECLASS], [MASTER])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja az asszociációs partnerek tábláinak join-jait. (SQL töredék) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadAllAssociationIDCommandJoinCore(MClass as ENTITY, MClass as MASTER)
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
[else]
[if ([STARTROLE.multiplicity] == "1")]
left join [ConvertNameToSQLTableName([PARTNER.name])] on [ConvertNameToSQLTableName([PARTNER.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([MASTER.name])].ID
[else]
left join [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))] on [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([MASTER.name])].ID
[end if]
[end if]
[end if]
[end if]
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
[GenerateLoadAllAssociationIDCommandJoinCore([BASECLASS], [MASTER])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Legenerálja azt az SQL töredéket, ami összekapcsolja az entitás //
// asszociációinak tábláit, az entitás táblái nélkül. Csak azokat az //
// asszociációs partner táblákat kapcsolja hozzá, amelyek rendelkeznek név //
// attribútummal! //
// (from szekció az SQL-ben) //
// //
// REKURZÍV! //
//***************************************************************************//
template GenerateLoadNameColumnsCommandJoinCore(MClass as PARTNER, MClass as MASTER, MAssociationEnd as STARTROLE, MAssociationEnd as ENDROLE)
[if (HasNameAttribures([PARTNER]) == "True")]
[if ([ENDROLE.multiplicity] == "1")]
inner join [ConvertNameToSQLTableName([PARTNER.name])] [ConvertNameToSQLTableName([ENDROLE.id] "_" [PARTNER.id])] on [ConvertNameToSQLTableName([ENDROLE.id] "_" [PARTNER.id])].ID = [ConvertNameToSQLTableName([MASTER.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))]
[else]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
left join [ConvertNameToSQLTableName([PARTNER.name])] [ConvertNameToSQLTableName([ENDROLE.id] "_" [PARTNER.id])] on [ConvertNameToSQLTableName([ENDROLE.id] "_" [PARTNER.id])].ID = [ConvertNameToSQLTableName([MASTER.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))]
[else]
[if ([STARTROLE.multiplicity] == "1")]
left join [ConvertNameToSQLTableName([PARTNER.name])] [ConvertNameToSQLTableName([ENDROLE.id] "_" [PARTNER.id])] on [ConvertNameToSQLTableName([ENDROLE.id] "_" [PARTNER.id])].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([MASTER.name])].ID
[else]
left join [ConvertNameToSQLTableName([PARTNER.name])] [ConvertNameToSQLTableName([ENDROLE.id] "_" [PARTNER.id])] on
([ConvertNameToSQLTableName([ENDROLE.id] "_" [PARTNER.id])].ID = [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))])
and
([ConvertNameToSQLTableName([MASTER.name])].ID = [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))])
[end if]
[end if]
[end if]
[end if]
[end if]
[if (IsMasterEntity([PARTNER]) == "false")]
[loop (PARTNER -> SuperClass as BASECLASS)]
[GenerateLoadNameColumnsCommandJoinCore([BASECLASS], [MASTER], [STARTROLE], [ENDROLE])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// A where szekciót generálja le egy SQL-hez, ami egy adott entitást kérdez //
// le asszociációs partnerek alapján. //
//***************************************************************************//
template GenerateAssociationJoinByAssociationWhere(MClass as ENTITY, MClass as PARTNER, MAssociationEnd as STARTROLE, MAssociationEnd as ENDROLE)
and
[if ([ENTITY.name] != [PARTNER.name])]
[if ([ENDROLE.multiplicity] == "1")]
([ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))])
[end if]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
([ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))])
[else]
[if ([STARTROLE.multiplicity] == "1")]
([ConvertNameToSQLTableName([ENTITY.name])].ID = T_T_PARTNER.[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))])
and
(T_T_PARTNER.ID = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))])
[else]
([ConvertNameToSQLTableName([ENTITY.name])].ID = T_T_SWITCH.[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))])
and
(T_T_SWITCH.[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))])
[end if]
[end if]
[end if]
[if (([ENDROLE.multiplicity] == "1..*") or ([ENDROLE.multiplicity] == "*") or ([ENDROLE.multiplicity] == "0..*"))]
[if (([STARTROLE.multiplicity] == "1") or ([STARTROLE.multiplicity] == "0..1"))]
([ConvertNameToSQLTableName([ENTITY.name])].ID = T_T_PARTNER.[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))])
and
(T_T_PARTNER.ID = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))])
[else]
([ConvertNameToSQLTableName([ENTITY.name])].ID = T_T_SWITCH.[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))])
and
(T_T_SWITCH.[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))])
[end if]
[end if]
[else]
[if ([ENDROLE.multiplicity] == "1" or [ENDROLE.multiplicity] == "0..1")]
[ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]
[else]
[if ([STARTROLE.multiplicity] == "1" or [STARTROLE.multiplicity] == "0..1")]
(T_T_PARTNER.ID = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))])
and
([ConvertNameToSQLTableName([ENTITY.name])].ID = T_T_PARTNER.[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))])
[else]
([ConvertNameToSQLTableName([ENTITY.name])].ID = T_T_SWITCH.[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))])
and
(T_T_SWITCH.[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))])
[end if]
[end if]
[end if]
end template
//***************************************************************************//
// Entitás verziójának felhozása //
//***************************************************************************//
template GenerateGetSerialCommand(MClass as ENTITY)
select
[GenerateSerialColumn([ENTITY])]
from
[GenerateLoadAllAttributesCommandTables([ENTITY])]
where
[if (IsMasterEntity([ENTITY]) == "true")]
([ConvertNameToSQLTableName([ENTITY.name])].SERIAL >= 0)
[else]
[end if]
and ([ConvertNameToSQLTableName([ENTITY.name])].ID = :[ConvertNameToCommandParameterName("ID")])
end template
//***************************************************************************//
// Legenerálja azt a teljes SQL-t helyőrzőkkel, ami egy entitást tölt fel //
// az asszociációs partnereinek azonosítóival együtt. //
//***************************************************************************//
template GenerateLoadAllAttributesAndEntityAssociationsIDCommand(MClass as ENTITY, MAXLASTCHANGEDONLY)
select /*+ {QID}{FID} {HINT} */
[if ([MAXLASTCHANGEDONLY] == "True")]
GETDATE(), COUNT(*)
[else]
[ConvertNameToSQLTableName([ENTITY.name])].ID ""ID"",
[GenerateLoadAllAttributesCommandColumns([ENTITY], "")]
[GenerateLoadAllAssociationIDAndNameColumns([ENTITY], "")]
[GenerateSerialColumn([ENTITY])]
[end if]
from
[GenerateLoadAllAttributesCommandTables([ENTITY])]
[GenerateLoadAllAssociationIDAndNameColumnsCommandJoin([ENTITY])]
{INNERFILTERS}
where
([ConvertNameToSQLTableName(GetMasterEntityNameOf([ENTITY]))].SERIAL >= 0)
[if (IsMasterEntity([ENTITY]) == "true")]
[else]
[end if]
end template
//***************************************************************************//
// Entitás feltöltése partner alapján (SQL töredék) //
//***************************************************************************//
/* nem használt
template GenerateLoadAllAttributesAndEntityAssociationsIDByAssociationCommand(MClass as ENTITY, MClass as PARTNER, MAssociationEnd as STARTROLE, MAssociationEnd as ENDROLE, MAXLASTCHANGEDONLY)
select
[if ([MAXLASTCHANGEDONLY] == "True")]
GETDATE(), COUNT(*)
[else]
[ConvertNameToSQLTableName([ENTITY.name])].ID ""ID"",
[GenerateLoadAllAttributesCommandColumns([ENTITY], "")]
[GenerateLoadAllAssociationIDAndNameColumns([ENTITY], "")]
[GenerateSerialColumn([ENTITY])]
[end if]
from
[GenerateSwitchTablesByAssociation([ENTITY], [PARTNER], [STARTROLE], [ENDROLE])]
[GenerateLoadAllAttributesCommandTables([ENTITY])]
[GenerateLoadAllAssociationIDAndNameColumnsCommandJoin([ENTITY])]
{INNERFILTERS}
where
([ConvertNameToSQLTableName(GetMasterEntityNameOf([ENTITY]))].SERIAL >= 0)
[if (IsMasterEntity([ENTITY]) == "true")]
[else]
[end if]
[GenerateAssociationJoinByAssociationWhere([ENTITY], [PARTNER], [STARTROLE], [ENDROLE])]
end template
*/
//***************************************************************************//
// Entitás feltöltése partner alapján asszociációs osztállyal együtt //
//***************************************************************************//
template GenerateLoadAllAttributesAndEntityAssociationsIDByAssociationCommandWithAssociationClass(MClass as ENTITY, MClass as PARTNER, MClass as ASSOCIATIONCLASS, MAssociationEnd as STARTROLE, MAssociationEnd as ENDROLE, MAXLASTCHANGEDONLY)
select /*+ {QID}{FID} {HINT} */
[if ([MAXLASTCHANGEDONLY] == "True")]
GETDATE(), COUNT(*)
[else]
[ConvertNameToSQLTableName([ENTITY.name])].ID ""ID"",
[GenerateLoadAllAttributesCommandColumns([ENTITY], "")]
[GenerateLoadAllAssociationIDAndNameColumns([ENTITY], "")]
[GenerateSerialColumn([ENTITY])],
[ConvertNameToSQLTableName([ASSOCIATIONCLASS.name])].ID ""_ID"",
[GenerateLoadAllAttributesCommandColumns([ASSOCIATIONCLASS], "_")]
[GenerateLoadAllAssociationIDAndNameColumns([ASSOCIATIONCLASS], "_")]
[GenerateSerialColumn([ASSOCIATIONCLASS])]
[end if]
from
[GenerateLoadAllAttributesCommandTables([ENTITY])]
[GenerateLoadAllAssociationIDAndNameColumnsCommandJoin([ENTITY])]
[GenerateJoinedLoadAllAttributesCommandTables([ASSOCIATIONCLASS], [ENTITY], [STARTROLE])]
[GenerateLoadAllAssociationIDAndNameColumnsCommandJoin([ASSOCIATIONCLASS])]
{INNERFILTERS}
where
([ConvertNameToSQLTableName(GetMasterEntityNameOf([ENTITY]))].SERIAL >= 0)
[if (IsMasterEntity([ENTITY]) == "true")]
[else]
[end if]
and
([ConvertNameToSQLTableName(GetMasterEntityNameOf([ASSOCIATIONCLASS]))].SERIAL >= 0)
[if (IsMasterEntity([ASSOCIATIONCLASS]) == "true")]
[else]
[end if]
and
([ConvertNameToSQLTableName([ASSOCIATIONCLASS.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))])
end template

View file

@ -0,0 +1,3 @@
//***************************************************************************//
// Under constuction... //
//***************************************************************************//

View file

@ -0,0 +1,65 @@
//***************************************************************************//
// Legenerálja a DataAccessInterfaces.csproj fájl tartalmát. //
//***************************************************************************//
template KretaGenerateDataAccessIterfaceProject()
[BOM]<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{68318C3F-0779-4755-848E-B270F6BAC40B}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Kreta.DataAccess.Interfaces</RootNamespace>
<AssemblyName>Kreta.DataAccess.Interfaces</AssemblyName>
<TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<SccProjectName>SAK</SccProjectName>
<SccLocalPath>SAK</SccLocalPath>
<SccAuxPath>SAK</SccAuxPath>
<SccProvider>SAK</SccProvider>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Core" />
</ItemGroup>
<ItemGroup>
<Compile Include="..\Tools\SharedAssemblyInfo.cs">
<Link>Properties\SharedAssemblyInfo.cs</Link>
</Compile>
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="IEntity.cs" />
<Compile Include="IAssociatedCollection.cs" />
[loop (Instances -> MClass where GetStereoType([MClass]) == "Entity")]
<Compile Include="I[MClass.name].cs" />
[end loop]
</ItemGroup>
<ItemGroup />
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
end template

View file

@ -0,0 +1,85 @@
//***************************************************************************//
// Legenerálja a DataAccess.csproj fájl tartalmát. //
//***************************************************************************//
template KretaGenerateDataAccessProject()
[BOM]<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{B91833B5-0BA0-4E8B-9159-B991F15D3FC4}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>[ProjectName]</RootNamespace>
<AssemblyName>Kreta.DataAccessGenerated</AssemblyName>
<TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
<FileAlignment>4096</FileAlignment>
<SccProjectName>SAK</SccProjectName>
<SccLocalPath>SAK</SccLocalPath>
<SccAuxPath>SAK</SccAuxPath>
<SccProvider>SAK</SccProvider>
<ProjectType>Local</ProjectType>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<RunCodeAnalysis>false</RunCodeAnalysis>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
<UseVSHostingProcess>true</UseVSHostingProcess>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugSymbols>false</DebugSymbols>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<RunCodeAnalysis>false</RunCodeAnalysis>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
<UseVSHostingProcess>true</UseVSHostingProcess>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\Kreta.DataAccessInterfaceGenerated\Kreta.DataAccess.Interfaces.csproj">
<Project>{68318c3f-0779-4755-848e-b270f6bac40b}</Project>
<Name>Kreta.DataAccess.Interfaces</Name>
</ProjectReference>
<ProjectReference Include="..\Sda.DataProvider\Sda.DataProvider.csproj">
<Project>{9ac4fd13-81f5-48ac-aa21-ba774c4dc771}</Project>
<Name>Sda.DataProvider</Name>
</ProjectReference>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
<ProjectReference Include="..\Framework\Kreta.Framework.csproj">
<Name>Kreta.Framework</Name>
<Project>{320EF478-7155-441D-B1E9-47EC3E57FB45}</Project>
<Package>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</Package>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Compile Include="..\Tools\SharedAssemblyInfo.cs">
<Link>Properties\SharedAssemblyInfo.cs</Link>
</Compile>
<Compile Include="Properties\AssemblyInfo.cs" />
<!-- BEGIN Generated file list -->
[loop (Instances -> MClass where GetStereoType([MClass]) == "Entity")]
<Compile Include="Entities\\[MClass.name].cs" />
<Compile Include="DataAccessors\\[MClass.name]DA.cs" />
[end loop]
[loop (Instances -> MClass as ENTITY where IsClassView([ENTITY]) == "View")]
<Compile Include="View\\[ENTITY.name].cs" />
[end loop]
<!-- END Generated file list -->
</ItemGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
</Project>
end template

View file

@ -0,0 +1,74 @@
//***************************************************************************//
// Legenerálja a megadott entitás törlését elvégzo DA muveletet. //
//***************************************************************************//
template GenerateDeleteEntity(MClass as ENTITY)
#region DeleteEntity
private const string m_FizikaiDeleteCommandText = @"DELETE FROM [ConvertNameToSQLTableName([ENTITY.name])] WHERE (ID = :[ConvertNameToCommandParameterName("ID")]) ";
private const string m_LogikaiDeleteCommandText = @"
UPDATE [ConvertNameToSQLTableName([ENTITY.name])]
SET TOROLT = 'T' ,
SERIAL = SERIAL + 1,
[if(GetTaggedValue([ENTITY], "dkt") == "true")]
DELETER = :[ConvertNameToCommandParameterName("Deleter")],
DELETED = :[ConvertNameToCommandParameterName("Deleted")],
[end if]
LASTCHANGED = :[ConvertNameToCommandParameterName("LastChanged")],
MODIFIER = :[ConvertNameToCommandParameterName("Modifier")]
WHERE (ID = :[ConvertNameToCommandParameterName("ID")]) ";
public override void DeleteEntity([ENTITY.name] entity, bool logikai = true)
{
var _deleteCommandText = logikai ? m_LogikaiDeleteCommandText : m_FizikaiDeleteCommandText;
using ([GetCSharpSQLCommandType()] command = DAUtil.CreateCommand(_deleteCommandText))
{
command.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpSQLIDType()]).Value = entity.ID;
if (logikai)
{
DateTime lastchanged = DateTime.Now;
var modifier = UserContext.Instance.UniqueIdentifier;
command.Parameters.Add("[ConvertNameToCommandParameterName("LastChanged")]", [GetCSharpDatasetType("DateTime", "")]).Value = lastchanged;
command.Parameters.Add("[ConvertNameToCommandParameterName("Modifier")]", [GetCSharpSQLIDType()]).Value = modifier;
[if(GetTaggedValue([ENTITY], "dkt") == "true")]
command.Parameters.Add("[ConvertNameToCommandParameterName("Deleted")]", [GetCSharpDatasetType("DateTime", "")]).Value = lastchanged;
command.Parameters.Add("[ConvertNameToCommandParameterName("Deleter")]", [GetCSharpSQLIDType()]).Value = modifier;
[end if]
}
if (command.ExecuteNonQuery() != 1)
{
throw new EntityNotFoundException("[ENTITY.name]", entity.ID);
}
}
[if (IsMasterEntity([ENTITY]) == "false" && GetInheritance([ENTITY]) != "tpc")]
entity.InheritedDA.DeleteEntity(entity, logikai);
[end if]
}
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where ([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity"))]
private const string m_DeleteBy[DefineRoleName([STARTROLE])]And[DefineRoleName([ENDROLE])]CommandText = @"
delete from [ConvertNameToSQLTableName([ENTITY.name])]
where
([ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([STARTROLE]))])
and
([ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]) ";
public void DeleteBy[DefineRoleName([STARTROLE])]And[DefineRoleName([ENDROLE])](int [ConvertRoleToName([STARTROLE])], int [ConvertRoleToName([ENDROLE])])
{
using ([GetCSharpSQLCommandType()] command = DAUtil.CreateCommand(m_DeleteBy[DefineRoleName([STARTROLE])]And[DefineRoleName([ENDROLE])]CommandText))
{
command.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([STARTROLE]))]", [GetCSharpSQLIDType()]).Value = [ConvertRoleToName([STARTROLE])];
command.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]", [GetCSharpSQLIDType()]).Value = [ConvertRoleToName([ENDROLE])];
command.ExecuteNonQuery();
}
}
[end loop]
[end loop]
#endregion
end template

View file

@ -0,0 +1,268 @@
//***************************************************************************//
// Nevet generál egy entitáslista DA-jának //
//***************************************************************************//
proc GenerateEntityCollectionDAName(startrole, endrole)
return [startrole] "_" [endrole] "_DA";
end proc
//***************************************************************************//
// Legenerálja a magadott osztályhoz tartozó entitáslista DA-inak tejles //
// forráskódját //
//***************************************************************************//
template GenerateEntityCollectionDAs(MClass)
[loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
[if (([StartRole.multiplicity] == "0..*") or ([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*"))]
internal class [GenerateEntityCollectionDAName([EndClass.name], DefineRoleName([StartRole]))] : EntityCollectionDA<[EndClass.name], [MClass.name]>
{
internal protected [GenerateEntityCollectionDAName([EndClass.name], DefineRoleName([StartRole]))]([EndClass.name] owner)
: base(owner)
{
}
private const string m_Filter = @" and ([ConvertNameToSQLTableName([MClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName("ID")]) ";
public override void LoadCollection(IAssociatedEntityCollection<[MClass.name]> collection)
{
new [MClass.name]DBHelper().LoadByPartnerId(collection, m_Filter, Owner.ID);
}
public override void AddItem([MClass.name] entity)
{
entity.[ConvertRoleToName([EndRole])] = Owner.ID;
[if ([StartRole.id] < [EndRole.id])]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([StartRole])], [GetRoleClassName([EndRole])]>("[DefineRoleName([StartRole])]_[DefineRoleName([EndRole])]");
assochandler.BeforeInsert(entity.[DefineRoleName([StartRole])], entity.[DefineRoleName([EndRole])]);
[else]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([EndRole])], [GetRoleClassName([StartRole])]>("[DefineRoleName([EndRole])]_[DefineRoleName([StartRole])]");
assochandler.BeforeInsert(entity.[DefineRoleName([EndRole])], entity.[DefineRoleName([StartRole])]);
[end if]
entity.Insert(true);
[if ([StartRole.id] < [EndRole.id])]
assochandler.AfterInsert(entity.[DefineRoleName([StartRole])], entity.[DefineRoleName([EndRole])]);
[else]
assochandler.AfterInsert(entity.[DefineRoleName([EndRole])], entity.[DefineRoleName([StartRole])]);
[end if]
}
public override void DeleteItem([MClass.name] entity)
{
[if ([StartRole.id] < [EndRole.id])]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([StartRole])], [GetRoleClassName([EndRole])]>("[DefineRoleName([StartRole])]_[DefineRoleName([EndRole])]");
assochandler.BeforeDelete(entity.[DefineRoleName([StartRole])], entity.[DefineRoleName([EndRole])]);
[else]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([EndRole])], [GetRoleClassName([StartRole])]>("[DefineRoleName([EndRole])]_[DefineRoleName([StartRole])]");
assochandler.BeforeDelete(entity.[DefineRoleName([EndRole])], entity.[DefineRoleName([StartRole])]);
[end if]
entity.Delete(true); // egyszeruen töröljük az asszociációs osztályt
[if ([StartRole.id] < [EndRole.id])]
assochandler.AfterDelete(entity.[DefineRoleName([StartRole])], entity.[DefineRoleName([EndRole])]);
[else]
assochandler.AfterDelete(entity.[DefineRoleName([EndRole])], entity.[DefineRoleName([StartRole])]);
[end if]
}
}
[end if]
[if (([EndRole.multiplicity] == "0..*") or ([EndRole.multiplicity] == "1..*") or ([EndRole.multiplicity] == "*"))]
internal class [GenerateEntityCollectionDAName([StartClass.name], DefineRoleName([EndRole]))] : EntityCollectionDA<[StartClass.name], [MClass.name]>
{
internal protected [GenerateEntityCollectionDAName([StartClass.name], DefineRoleName([EndRole]))]([StartClass.name] owner)
: base(owner)
{
}
private const string m_Filter = @" and ([ConvertNameToSQLTableName([MClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = :[ConvertNameToCommandParameterName("ID")]) ";
public override void LoadCollection(IAssociatedEntityCollection<[MClass.name]> collection)
{
new [MClass.name]DBHelper().LoadByPartnerId(collection, m_Filter, Owner.ID);
}
public override void AddItem([MClass.name] entity)
{
entity.[ConvertRoleToName([StartRole])] = Owner.ID;
[if ([StartRole.id] < [EndRole.id])]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([StartRole])], [GetRoleClassName([EndRole])]>("[DefineRoleName([StartRole])]_[DefineRoleName([EndRole])]");
assochandler.BeforeInsert(entity.[DefineRoleName([StartRole])], entity.[DefineRoleName([EndRole])]);
[else]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([EndRole])], [GetRoleClassName([StartRole])]>("[DefineRoleName([EndRole])]_[DefineRoleName([StartRole])]");
assochandler.BeforeInsert(entity.[DefineRoleName([EndRole])], entity.[DefineRoleName([StartRole])]);
[end if]
entity.Insert(true);
[if ([StartRole.id] < [EndRole.id])]
assochandler.AfterInsert(entity.[DefineRoleName([StartRole])], entity.[DefineRoleName([EndRole])]);
[else]
assochandler.AfterInsert(entity.[DefineRoleName([EndRole])], entity.[DefineRoleName([StartRole])]);
[end if]
}
public override void DeleteItem([MClass.name] entity)
{
[if ([StartRole.id] < [EndRole.id])]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([StartRole])], [GetRoleClassName([EndRole])]>("[DefineRoleName([StartRole])]_[DefineRoleName([EndRole])]");
assochandler.BeforeDelete(entity.[DefineRoleName([StartRole])], entity.[DefineRoleName([EndRole])]);
[else]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([EndRole])], [GetRoleClassName([StartRole])]>("[DefineRoleName([EndRole])]_[DefineRoleName([StartRole])]");
assochandler.BeforeDelete(entity.[DefineRoleName([EndRole])], entity.[DefineRoleName([StartRole])]);
[end if]
entity.Delete(true); // egyszeruen töröljük az asszociációs osztályt
[if ([StartRole.id] < [EndRole.id])]
assochandler.AfterDelete(entity.[DefineRoleName([StartRole])], entity.[DefineRoleName([EndRole])]);
[else]
assochandler.AfterDelete(entity.[DefineRoleName([EndRole])], entity.[DefineRoleName([StartRole])]);
[end if]
}
}
[end if]
[end loop]
[end loop]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (GetStereoType([PartnerClass]) == "Entity"))]
[if ([StartRole.id] != [EndRole.id])]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([StartRole.multiplicity] == "*" or [StartRole.multiplicity] == "1..*" or [StartRole.multiplicity] == "0..*")]
[if (([PartnerClass.name] != [MClass.name]) or ([PartnerClass.name] == [MClass.name] and [MClass.name] != DefineRoleName([StartRole])))]
/// <summary>
/// Az osztály elvégzi az UML modell '[PartnerClass.name] -> [MClass.name] ([DefineRoleName([StartRole])])'
/// asszociációjának teljes kezelését.
/// </summary>
internal class [GenerateEntityCollectionDAName([PartnerClass.name], DefineRoleName([StartRole]))] : EntityCollectionDA<[PartnerClass.name], [MClass.name]>
{
internal protected [GenerateEntityCollectionDAName([PartnerClass.name], DefineRoleName([StartRole]))]([PartnerClass.name] owner)
: base(owner)
{
}
[if ([EndRole.multiplicity] == "0..1" or [EndRole.multiplicity] == "1")]
// Nincs kapcsolótábla
private const string m_Filter = @" and ([ConvertNameToSQLTableName([MClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName("ID")]) ";
[else]
// Kapcsolótábla van
private const string m_Filter = @" and (exists (select 1 from [ConvertNameToSQLTableScript(ConvertAssociationRolesToSwitchTableName([EndRole],[StartRole]))] where [ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = [ConvertNameToSQLTableName([MClass.name])].ID and [ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName("ID")])) ";
[end if]
public override void LoadCollection(IAssociatedEntityCollection<[MClass.name]> collection)
{
new [MClass.name]DBHelper().LoadByPartnerId(collection, m_Filter, Owner.ID);
}
private static [GetCSharpSQLCommandType()] [GenerateCommandCreatorName("Insert" DefineRoleName([StartRole]))]()
{
[GetCSharpSQLCommandType()] result = new [GetCSharpSQLCommandType()]();
[if ([EndRole.multiplicity] == "0..1" or [EndRole.multiplicity] == "1")]
// nincs kapcsolótábla...
result.CommandText = @"update [ConvertNameToSQLTableName([MClass.name])] set [ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))] where (ID = :[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))])";
[else]
// kapcsolótábla van...
result.CommandText = @"insert into [ConvertNameToSQLTableScript(ConvertAssociationRolesToSwitchTableName([EndRole],[StartRole]))] ([ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], [ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))]) values (:[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))], :[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))])";
[end if]
result.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))]", [GetCSharpSQLIDType()]);
result.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))]", [GetCSharpSQLIDType()]);
return result;
}
private void DoAdd([PartnerClass.name] owner, [MClass.name] partner)
{
using ([GetCSharpSQLCommandType()] command = [GenerateCommandCreatorName("Insert" DefineRoleName([StartRole]))]())
{
[GenerateCommandInit("command")]
command.Parameters\["[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))]"\].Value = owner.ID;
command.Parameters\["[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))]"\].Value = partner.ID;
command.ExecuteNonQuery();
}
}
public override void AddItem([MClass.name] entity)
{
[if ([StartRole.id] < [EndRole.id])]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([StartRole])], [GetRoleClassName([EndRole])]>("[DefineRoleName([StartRole])]_[DefineRoleName([EndRole])]");
[else]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([EndRole])], [GetRoleClassName([StartRole])]>("[DefineRoleName([EndRole])]_[DefineRoleName([StartRole])]");
[end if]
[if ([StartRole.id] < [EndRole.id])]
assochandler.BeforeInsert(entity, this.Owner);
[else]
assochandler.BeforeInsert(this.Owner, entity);
[end if]
[if ([EndRole.multiplicity] == "1")]
entity.Modify[DefineRoleName([EndRole])](this.Owner);
if (entity.State == EntityState.Modified)
{
entity.UpdateAssociations(true);
}
else
{
entity.Insert(true);
}
[else]
this.DoAdd(this.Owner, entity);
[end if]
[if ([StartRole.id] < [EndRole.id])]
assochandler.AfterInsert(entity, this.Owner);
[else]
assochandler.AfterInsert(this.Owner, entity);
[end if]
}
private static [GetCSharpSQLCommandType()] [GenerateCommandCreatorName("Delete" DefineRoleName([StartRole]))]()
{
[GetCSharpSQLCommandType()] result = new [GetCSharpSQLCommandType()]();
[if ([EndRole.multiplicity] == "0..1" or [EndRole.multiplicity] == "1")]
// nincs kapcsolótábla...
result.CommandText = @"update [ConvertNameToSQLTableName([MClass.name])] set [ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = null where ([ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))] and ID = :[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))])";
[else]
// kapcsolótábla van...
result.CommandText = @"delete from [ConvertNameToSQLTableScript(ConvertAssociationRolesToSwitchTableName([EndRole],[StartRole]))] where ([ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))]) and ([ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))])";
[end if]
result.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))]", [GetCSharpSQLIDType()]);
result.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))]", [GetCSharpSQLIDType()]);
return result;
}
private void DoRemove([PartnerClass.name] owner, [MClass.name] partner)
{
using ([GetCSharpSQLCommandType()] command = [GenerateCommandCreatorName("Delete" DefineRoleName([StartRole]))]())
{
[GenerateCommandInit("command")]
command.Parameters\["[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))]"\].Value = owner.ID;
command.Parameters\["[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))]"\].Value = partner.ID;
command.ExecuteNonQuery();
}
}
public override void DeleteItem([MClass.name] entity)
{
[if ([StartRole.id] < [EndRole.id])]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([StartRole])], [GetRoleClassName([EndRole])]>("[DefineRoleName([StartRole])]_[DefineRoleName([EndRole])]");
[else]
var assochandler = AssociationHandlerManager.Create<[GetRoleClassName([EndRole])], [GetRoleClassName([StartRole])]>("[DefineRoleName([EndRole])]_[DefineRoleName([StartRole])]");
[end if]
[if ([StartRole.id] < [EndRole.id])]
assochandler.BeforeDelete(entity, this.Owner);
[else]
assochandler.BeforeDelete(this.Owner, entity);
[end if]
[if ([EndRole.multiplicity] == "1")]
entity.Delete(true);
[else]
this.DoRemove(this.Owner, entity);
[end if]
[if ([StartRole.id] < [EndRole.id])]
assochandler.AfterDelete(entity, this.Owner);
[else]
assochandler.AfterDelete(this.Owner, entity);
[end if]
}
}
[end if]
[end if]
[end if]
[end if]
[end loop]
end template

View file

@ -0,0 +1,385 @@
//***************************************************************************//
// Legenerálja a magadott osztályhoz tartozó DataAccessor tejles //
// forráskódját //
//***************************************************************************//
template GenerateEntityDA(MClass as ENTITY)
[BOM]using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using Kreta.Framework;
using Kreta.Framework.Collections;
using Kreta.Framework.Collections.Generic;
using Kreta.Framework.Entities;
using Kreta.Framework.Entities.Associations;
using Kreta.Framework.Entities.Generic;
namespace SDA.[ProjectName].Entities
{
[GenerateDBHelper([ENTITY])]
internal class [ENTITY.name]DA : EntityDataAccessor<[ENTITY.name]>
{
private static [ENTITY.name]DBHelper m_dbhelper = new [ENTITY.name]DBHelper();
protected override IEntityDBHelper<[ENTITY.name]> dbhelper
{
get { return m_dbhelper; }
}
#region Load
[GenerateLoadByID([ENTITY])]
[GenerateLoadBaseSet([ENTITY])]
#endregion
[GenerateInsertEntity([ENTITY])]
[GenerateUpdateEntity([ENTITY])]
[GenerateDeleteEntity([ENTITY])]
[GenerateUpdateAssociations([ENTITY])]
#region Asszociációkkal kapcsolatos adatbázisműveletek (entitásspecifikus)
[GenerateEntityLoaders([ENTITY])]
#endregion
}
[GenerateEntityCollectionDAs([ENTITY])]
}
end template
template GenerateDynamicColums(MClass, entityname)
[loop (MClass->MAttribute)]
{ "[MAttribute.name]", "[ConvertNameToSQLTableName([entityname])].[ConvertNameToSQLColumnName([MAttribute.name])]" },
[end loop]
[if (IsMasterEntity([MClass]) == "false")]
[loop (MClass -> SuperClass as MBaseClass)]
[if (GetInheritance([MClass]) == "tpc")]
[GenerateDynamicColums([MBaseClass], [MClass.name])][break]
[else]
[GenerateDynamicColums([MBaseClass], [MBaseClass.name])][break]
[end if]
[end loop]
[end if]
end template
//***************************************************************************//
//***************************************************************************//
template GenerateDBHelper(MClass as ENTITY)
internal sealed class [ENTITY.name]DBHelper : EntityDBHelper<[ENTITY.name]>
{
private Dictionary<string, string> dynamicColumns = new Dictionary<string, string>()
{
[GenerateDynamicColums([ENTITY], [ENTITY.name])]
};
private const string dynamicQueryCommandText =
"select " +
"[ConvertNameToSQLTableName([ENTITY.name])].ID, " +
"{COLUMNS}" +
[GenerateDynamicFieldListWithBaseClassFields([ENTITY], [ENTITY.name])]
"from " +
"[ConvertNameToSQLTableName([ENTITY.name])] " +
[loop (ENTITY -> SuperClass as MBaseClass)]
"[GenerateSuperClassTableList([ENTITY])] " +
[break]
[end loop]
"where " +
"(1 = 1) ";
private const string emptyQueryCommandText =
"select " +
"[ConvertNameToSQLTableName([ENTITY.name])].ID, " +
[GenerateFieldListWithBaseClassFields([ENTITY], [ENTITY.name])]
"from " +
"[ConvertNameToSQLTableName([ENTITY.name])] " +
[loop (ENTITY -> SuperClass as MBaseClass)]
"[GenerateSuperClassTableList([ENTITY])] " +
[break]
[end loop]
"where " +
"(1 = 1) ";
public override string EmptyQueryCommandText
{
get
{
return emptyQueryCommandText;
}
}
public override string DynamicQueryCommandText
{
get
{
return dynamicQueryCommandText;
}
}
public override IDictionary<string, string> DynamicColumns
{
get
{
return dynamicColumns;
}
}
protected override [ENTITY.name] CreateEntityInstance()
{
return [ENTITY.name].GiveAnInstance();
}
#region Lekérdezés
public override void LoadEntityFields([ENTITY.name] entity, [GetCSharpSQLDataReaderType()] reader)
{
[GenerateLoadEntityCore([ENTITY], 1, "entity", "reader")]
}
public override void LoadEntityFields([ENTITY.name] entity, [GetCSharpSQLDataReaderType()] reader, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
{
int index = 1;
if (columns == null)
{
columns = new List<string>(index);
}
[GenerateDynamicLoadEntityCore([ENTITY], "entity", "reader")]
}
#endregion
#region Paraméter kötés
public override void BindAttributes([ENTITY.name] entity, [GetCSharpSQLCommandType()] command)
{
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> MAttribute as ATTRIBUTE where [ATTRIBUTE.name] != [MBaseClass.name])]
[if (IsComputedAttribute([ATTRIBUTE]) == _False())]
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
DAUtil.BindParameter(command, "[ConvertNameToCommandParameterName([ATTRIBUTE.name])]", [GetCSharpDatasetType([ATTRIBUTE.type],IsAttributeUnicode([ATTRIBUTE]))][SDA_GetFieldLength([ATTRIBUTE])], entity.m_[ATTRIBUTE.name], false);
[else]
DAUtil.BindParameter(command, "[ConvertNameToCommandParameterName([ATTRIBUTE.name])]", [GetCSharpDatasetType([ATTRIBUTE.type],IsAttributeUnicode([ATTRIBUTE]))][SDA_GetFieldLength([ATTRIBUTE])], entity.m_[ATTRIBUTE.name], entity.m_[ATTRIBUTE.name] == null);
[end if]
[end if]
[end loop]
[end loop]
[end if]
[loop (ENTITY -> MAttribute as ATTRIBUTE where [ATTRIBUTE.name] != [ENTITY.name])]
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
DAUtil.BindParameter(command, "[ConvertNameToCommandParameterName([ATTRIBUTE.name])]", [GetCSharpDatasetType([ATTRIBUTE.type],IsAttributeUnicode([ATTRIBUTE]))][SDA_GetFieldLength([ATTRIBUTE])], entity.m_[ATTRIBUTE.name], false);
[else]
DAUtil.BindParameter(command, "[ConvertNameToCommandParameterName([ATTRIBUTE.name])]", [GetCSharpDatasetType([ATTRIBUTE.type],IsAttributeUnicode([ATTRIBUTE]))][SDA_GetFieldLength([ATTRIBUTE])], entity.m_[ATTRIBUTE.name], entity.m_[ATTRIBUTE.name] == null);
[end if]
[end loop]
}
public override void DynamicBindAttributes([ENTITY.name] entity, [GetCSharpSQLCommandType()] command)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> MAttribute as ATTRIBUTE where [ATTRIBUTE.name] != [MBaseClass.name])]
[if (IsComputedAttribute([ATTRIBUTE]) == _False())]
if (entity.HasChangedas("[ATTRIBUTE.name]"))
{
sb.Append("[ConvertNameToSQLColumnName([ATTRIBUTE.name])] = :[ConvertNameToCommandParameterName([ATTRIBUTE.name])],");
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
DAUtil.BindParameter(command, "[ConvertNameToCommandParameterName([ATTRIBUTE.name])]", [GetCSharpDatasetType([ATTRIBUTE.type],IsAttributeUnicode([ATTRIBUTE]))][SDA_GetFieldLength([ATTRIBUTE])], entity.m_[ATTRIBUTE.name], false);
[else]
DAUtil.BindParameter(command, "[ConvertNameToCommandParameterName([ATTRIBUTE.name])]", [GetCSharpDatasetType([ATTRIBUTE.type],IsAttributeUnicode([ATTRIBUTE]))][SDA_GetFieldLength([ATTRIBUTE])], entity.m_[ATTRIBUTE.name], entity.m_[ATTRIBUTE.name] == null);
[end if]
}
[end if]
[end loop]
[end loop]
[end if]
[loop (ENTITY -> MAttribute as ATTRIBUTE where [ATTRIBUTE.name] != [ENTITY.name])]
[if (IsComputedAttribute([ATTRIBUTE]) == _False())]
if (entity.HasChanged("[ATTRIBUTE.name]"))
{
sb.Append("[ConvertNameToSQLColumnName([ATTRIBUTE.name])] = :[ConvertNameToCommandParameterName([ATTRIBUTE.name])],");
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
DAUtil.BindParameter(command, "[ConvertNameToCommandParameterName([ATTRIBUTE.name])]", [GetCSharpDatasetType([ATTRIBUTE.type],IsAttributeUnicode([ATTRIBUTE]))][SDA_GetFieldLength([ATTRIBUTE])], entity.m_[ATTRIBUTE.name], false);
[else]
DAUtil.BindParameter(command, "[ConvertNameToCommandParameterName([ATTRIBUTE.name])]", [GetCSharpDatasetType([ATTRIBUTE.type],IsAttributeUnicode([ATTRIBUTE]))][SDA_GetFieldLength([ATTRIBUTE])], entity.m_[ATTRIBUTE.name], entity.m_[ATTRIBUTE.name] == null);
[end if]
}
[end if]
[end loop]
command.CommandText = command.CommandText.Replace("{COLUMNS}", sb.ToString());
}
public override void BindAssociations([ENTITY.name] entity, [GetCSharpSQLCommandType()] command)
{
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNERCLASS where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNERCLASS]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "1")]
DAUtil.BindIdParameter(command, "[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]", entity.Internal[ConvertRoleToName([ENDROLE])]);
[else]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
DAUtil.BindIdParameter(command, "[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]", entity.Internal[ConvertRoleToName([ENDROLE])]);
[end if]
[end if]
[end if]
[end if]
[end loop]
[end loop]
[end if]
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNERCLASS where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNERCLASS]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "1")]
DAUtil.BindIdParameter(command, "[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]", entity.Internal[ConvertRoleToName([ENDROLE])]);
[else]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
DAUtil.BindIdParameter(command, "[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]", entity.Internal[ConvertRoleToName([ENDROLE])]);
[end if]
[end if]
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity" ))]
DAUtil.BindIdParameter(command, "[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]", entity.[ConvertRoleToName([ENDROLE])]);
DAUtil.BindIdParameter(command, "[ConvertNameToCommandParameterName(ConvertRoleToName([STARTROLE]))]", entity.[ConvertRoleToName([STARTROLE])]);
[end loop]
[end loop]
}
#endregion
}
end template
//***************************************************************************//
// Legenerálja egy adott entitás lekérdezéseit, összerendeléseit, //
// szétkapcsolásait. //
//***************************************************************************//
template GenerateEntityLoaders(MClass as ENTITY)
#region Mint asszociációs osztály
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity" ))]
[if (([STARTROLE.multiplicity] == "0..1") or ([STARTROLE.multiplicity] == "1"))]
private const string m_LoadBy[DefineRoleName([ENDROLE])]Filter = @" and ([ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName("ID")]) ";
\[Obsolete("Teszteletlen, Cimby-t értesíteni kell erről, de azonnal!")\]
public bool LoadBy[DefineRoleName([ENDROLE])]([ENDCLASS.name] partner, [ENTITY.name] entity)
{
return dbhelper.LoadByPartnerId(entity, m_LoadBy[ConvertRoleToName([ENDROLE])]Filter, partner.ID);
}
[end if]
[if (([ENDROLE.multiplicity] == "0..1") or ([ENDROLE.multiplicity] == "1"))]
private const string m_LoadBy[DefineRoleName([STARTROLE])]Filter = @" and ([ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = :[ConvertNameToCommandParameterName("ID")]) ";
public bool LoadBy[DefineRoleName([STARTROLE])]([STARTCLASS.name] partner, [ENTITY.name] entity)
{
return dbhelper.LoadByPartnerId(entity, m_LoadBy[DefineRoleName([STARTROLE])]Filter, partner.ID);
}
[end if]
[end loop]
[end loop]
#endregion
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNERCLASS where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNERCLASS]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([STARTROLE.multiplicity] == "1" or [STARTROLE.multiplicity] == "0..1")]
[if ([ENDROLE.multiplicity] == "1")]
// a kapcsolómező nálunk van
private const string m_LoadBy[ConvertRoleToName([ENDROLE])]Filter = @" and ([ConvertNameToSQLTableName([ENTITY.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName("ID")]) ";
[else]
[if ([STARTROLE.multiplicity] == "0..1" and ([ENDROLE.multiplicity] == "0..1"))]
// kapcsolótábla van
private const string m_LoadBy[ConvertRoleToName([ENDROLE])]Filter = @" and (exists (select 1 from [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE], [STARTROLE]))] where [ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([ENTITY.name])].ID and [ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName("ID")])) ";
[else]
[if ([ENTITY.name] != [PARTNERCLASS.name])]
// kapcsolómező a másik táblában van, és nem önmagára mutat
private const string m_LoadBy[ConvertRoleToName([ENDROLE])]Filter = @" and (exists (select 1 from [ConvertNameToSQLTableName([PARTNERCLASS.name])] where [ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([ENTITY.name])].ID and [ConvertNameToSQLTableName([PARTNERCLASS.name])].ID = :[ConvertNameToCommandParameterName("ID")])) ";
[else]
// önmagára mutat
private const string m_LoadBy[ConvertRoleToName([ENDROLE])]Filter = @" and (exists (select 1 from [ConvertNameToSQLTableName([PARTNERCLASS.name])] T_TEMP where T_TEMP.[ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = [ConvertNameToSQLTableName([ENTITY.name])].ID and T_TEMP.ID = :[ConvertNameToCommandParameterName("ID")])) ";
[end if]
[end if]
[end if]
public bool LoadBy[ConvertRoleToName([ENDROLE])](int id, [ENTITY.name] entity)
{
return dbhelper.LoadByPartnerId(entity, m_LoadBy[ConvertRoleToName([ENDROLE])]Filter, id);
}
[if (([STARTROLE.multiplicity] == "0..1") and ([ENDROLE.multiplicity] == "0..1"))]
private const string m_Associate[DefineRoleName([ENDROLE])]CommandText = @"
insert into [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE], [STARTROLE]))]
( [ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))], [ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] )
values ( :[ConvertNameToCommandParameterName(ConvertRoleToName([STARTROLE]))], :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))] )";
public void Associate[DefineRoleName([ENDROLE])]([ENTITY.name] entity, [PARTNERCLASS.name] partner)
{
using([GetCSharpSQLCommandType()] command = DAUtil.CreateCommand(m_Associate[DefineRoleName([ENDROLE])]CommandText))
{
command.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([STARTROLE]))]", [GetCSharpSQLIDType()]).Value = entity.ID;
command.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]", [GetCSharpSQLIDType()]).Value = partner.ID;
command.ExecuteNonQuery(); // EntityDA.tdl 207
}
}
private const string m_DeAssociate[DefineRoleName([ENDROLE])]CommandText = @"
delete from [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE], [STARTROLE]))]
where ([ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([STARTROLE]))])";
public void DeAssociate[DefineRoleName([ENDROLE])]([ENTITY.name] entity)
{
using([GetCSharpSQLCommandType()] command = DAUtil.CreateCommand(m_DeAssociate[DefineRoleName([ENDROLE])]CommandText))
{
command.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([STARTROLE]))]", [GetCSharpSQLIDType()]).Value = entity.ID;
command.ExecuteNonQuery(); // EntityDA.tdl 219
}
}
[end if]
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity" ))]
public bool LoadBy[DefineRoleName([STARTROLE])]([STARTCLASS.name] start, [ENDCLASS.name] end, [ENTITY.name] entity)
{
using ([GetCSharpSQLCommandType()] command = dbhelper.CreateEmptyQueryCommand())
{
command.CommandText += @" and ([ConvertNameToSQLColumnName(ConvertRoleToName([STARTROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([STARTROLE]))]) and ([ConvertNameToSQLColumnName(ConvertRoleToName([ENDROLE]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]) ";
command.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([STARTROLE]))]", [GetCSharpSQLIDType()]).Value = start.ID;
command.Parameters.Add("[ConvertNameToCommandParameterName(ConvertRoleToName([ENDROLE]))]", [GetCSharpSQLIDType()]).Value = end.ID;
return dbhelper.LoadSingleEntity(entity, command); // EntityDA.tdl 457
}
}
public bool LoadBy[DefineRoleName([ENDROLE])]([ENDCLASS.name] start, [STARTCLASS.name] end, [ENTITY.name] entity)
{
return this.LoadBy[DefineRoleName([STARTROLE])](end, start, entity);
}
[end loop]
[end loop]
end template

View file

@ -0,0 +1,163 @@
//***************************************************************************//
// Legenerálja a DA-hoz az insert művelet megvalósítását. //
//***************************************************************************//
template GenerateInsertEntity(MClass as ENTITY)
#region InsertEntity
private const string m_InsertCommandText = @"
insert into [ConvertNameToSQLTableName([ENTITY.name])] (
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> MAttribute as ATTRIBUTE where [ATTRIBUTE.name] != [MBaseClass.name])]
[if (IsComputedAttribute([ATTRIBUTE]) == _False())]
[ConvertNameToSQLColumnName([ATTRIBUTE.name])],
[end if]
[end loop]
[end loop]
[end if]
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if (([EndRole.multiplicity] == "1") or (([EndRole.multiplicity] == "0..1") and (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))))]
[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))],
[end if]
[end if]
[end loop]
[end loop]
[end if]
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))],
[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))],
[end loop]
[end loop]
[end loop]
[end if]
[loop (ENTITY -> MAttribute as ATTRIBUTE where [ATTRIBUTE.name] != [ENTITY.name])]
[if (IsComputedAttribute([ATTRIBUTE]) == _False())]
[ConvertNameToSQLColumnName([ATTRIBUTE.name])],
[end if]
[end loop]
[loop (ENTITY -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if (([EndRole.multiplicity] == "1") or (([EndRole.multiplicity] == "0..1") and (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))))]
[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))],
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))],
[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))],
[end loop]
[end loop]
TOROLT,
SERIAL,
CREATED,
[if (IsMasterEntity([ENTITY]) == "true" || GetInheritance([ENTITY]) == "tpc")]
CREATOR)
[else]
CREATOR,
ID)
[end if]
values (
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> MAttribute as ATTRIBUTE where [ATTRIBUTE.name] != [MBaseClass.name])]
[if (IsComputedAttribute([ATTRIBUTE]) == _False())]
:[ConvertNameToCommandParameterName([ATTRIBUTE.name])],
[end if]
[end loop]
[end loop]
[end if]
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if (([EndRole.multiplicity] == "1") or (([EndRole.multiplicity] == "0..1") and (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))))]
:[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))],
[end if]
[end if]
[end loop]
[end loop]
[end if]
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
:[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))],
:[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))],
[end loop]
[end loop]
[end loop]
[end if]
[loop (ENTITY -> MAttribute as ATTRIBUTE where [ATTRIBUTE.name] != [ENTITY.name])]
[if (IsComputedAttribute([ATTRIBUTE]) == _False())]
:[ConvertNameToCommandParameterName([ATTRIBUTE.name])],
[end if]
[end loop]
[loop (ENTITY -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if (([EndRole.multiplicity] == "1") or (([EndRole.multiplicity] == "0..1") and (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))))]
:[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))],
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
:[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))],
:[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))],
[end loop]
[end loop]
:[ConvertNameToCommandParameterName("Torolt")],
:[ConvertNameToCommandParameterName("Serial")],
:[ConvertNameToCommandParameterName("Created")],
[if (IsMasterEntity([ENTITY]) == "true" || GetInheritance([ENTITY]) == "tpc")]
:[ConvertNameToCommandParameterName("Creator")]);
SELECT SCOPE_IDENTITY() as ID;
[else]
:[ConvertNameToCommandParameterName("Creator")],
:[ConvertNameToCommandParameterName("ID")] ) -- Leszármaztatott entitás ID-ja
[end if]
";
public override void InsertEntity([ENTITY.name] entity)
{
[if (IsMasterEntity([ENTITY]) == "false" && GetInheritance([ENTITY]) != "tpc")]
entity.InheritedDA.InsertEntity(entity);
[else]
entity.Serial = 0;
[if (GetTaggedValue([ENTITY], "anonymous") == "all" || GetTaggedValue([ENTITY], "anonymous") == "insert")]
SetEntityCreator(entity, DateTime.Now, "??????");
[else]
SetEntityCreator(entity, DateTime.Now, UserContext.Instance.UniqueIdentifier);
[end if]
[end if]
using ([GetCSharpSQLCommandType()] command = DAUtil.CreateCommand(m_InsertCommandText))
{
dbhelper.BindAttributes(entity, command);
dbhelper.BindAssociations(entity, command);
command.Parameters.Add("[ConvertNameToCommandParameterName("Torolt")]", [GetCSharpDatasetType("Boolean", "")]).Value = false;
command.Parameters.Add("[ConvertNameToCommandParameterName("Serial")]", [GetCSharpDatasetType("Integer", "")]).Value = 0;
command.Parameters.Add("[ConvertNameToCommandParameterName("Created")]", [GetCSharpDatasetType("DateTime", "")]).Value = entity.EntityCreated;
command.Parameters.Add("[ConvertNameToCommandParameterName("Creator")]", [GetCSharpDatasetType("ID", "")]).Value = entity.EntityCreator;
[if (IsMasterEntity([ENTITY]) == "true" || GetInheritance([ENTITY]) == "tpc")]
entity.ID = Convert.ToInt32(command.ExecuteScalar());
[else]
command.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpDatasetType("ID", "")]).Value = entity.ID; // leszármaztatott entitás ID-ja
command.ExecuteNonQuery();
[end if]
}
}
#endregion
end template

View file

@ -0,0 +1,26 @@
//***************************************************************************//
// Legenerálja a DA-hoz az alaphalmaz lekérdezését megvalósító műveletet. //
//***************************************************************************//
template GenerateLoadBaseSet(MClass as ENTITY)
\[Obsolete("Ezt ne használjátok, mert mindenhova bele kellene fogalmazni a tanév szűrést is! Meg fog majd szűnni!")\]
public override void LoadWithFilter(IEntityCollection<[ENTITY.name]> collection, string filter, Dictionary<string, object> commandParameters = null)
{
using (SDA.DataProvider.SDACommand command = dbhelper.CreateEmptyQueryCommand())
{
command.CommandText += filter;
dbhelper.CreateParameterBinding(command, commandParameters);
dbhelper.LoadEntityCollection(collection, command);
}
}
\[Obsolete("Ezt ne használjátok, mert mindenhova bele kellene fogalmazni a tanév szűrést is! Meg fog majd szűnni!")\]
public override void LoadWithFilter(IEntityCollection<[ENTITY.name]> collection, string filter, ColumnFilterMode columnFilterMode, IEnumerable<string> columns, Dictionary<string, object> commandParameters = null)
{
using (SDA.DataProvider.SDACommand command = dbhelper.CreateDynamicQueryCommand(columnFilterMode, columns))
{
command.CommandText += filter;
dbhelper.CreateParameterBinding(command, commandParameters);
dbhelper.LoadEntityCollection(collection, command, columnFilterMode, columns);
}
}
end template

View file

@ -0,0 +1,34 @@
//***************************************************************************//
// Legenerálja a DA rétegbe egy entitás lekérdezését azonosító alapján //
//***************************************************************************//
template GenerateLoadByID(MClass as ENTITY)
public override bool LoadEntity([ENTITY.name] entity, int entityId)
{
return LoadById(entity, entityId);
}
public override bool FilteredLoadEntity([ENTITY.name] entity, int entityId, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
{
return LoadById(entity, entityId, columnFilterMode, columns);
}
public bool LoadById([ENTITY.name] entity, int entityId)
{
using (SDA.DataProvider.SDACommand command = dbhelper.CreateEmptyQueryCommand())
{
command.CommandText += " and ([ConvertNameToSQLTableName([ENTITY.name])].ID = :[ConvertNameToCommandParameterName("ID")]) ";
command.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpSQLIDType()]).Value = entityId;
return dbhelper.LoadSingleEntity(entity, command);
}
}
public bool LoadById([ENTITY.name] entity, int entityId, ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
{
using (SDA.DataProvider.SDACommand command = dbhelper.CreateDynamicQueryCommand(columnFilterMode, columns))
{
command.CommandText += " and ([ConvertNameToSQLTableName([ENTITY.name])].ID = :[ConvertNameToCommandParameterName("ID")]) ";
command.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpSQLIDType()]).Value = entityId;
return dbhelper.LoadSingleEntity(entity, command, columnFilterMode, columns);
}
}
end template

View file

@ -0,0 +1,132 @@
//***************************************************************************//
// Legenerálja a DA-hoz a zárolási műveletet. //
//***************************************************************************//
template GenerateNoWaitForLock(ENTITYNAME)
#region No wait for lock
private string GetNoWaitForLockCommandText()
{
string result = null;
switch (SDAServer.Instance.Configuration.DataBaseType)
{
case DataBaseType.MSSQL:
{
result = "select SERIAL from [ConvertNameToSQLTableName([ENTITYNAME])] with(updlock) where ID = :[ConvertNameToCommandParameterName("ID")] {0} ";
break;
}
case DataBaseType.ORACLE:
case DataBaseType.NATIVEORACLE:
{
result = "select SERIAL from [ConvertNameToSQLTableName([ENTITYNAME])] where ID = :[ConvertNameToCommandParameterName("ID")] {0} for update nowait ";
break;
}
default:
{
throw new NotSupportedException(SDAServer.Instance.Configuration.DataBaseType.ToString());
}
}
result = String.Format(result, "");
return result;
}
public int NoWaitForLock([ENTITYNAME] entity)
{
//Console.WriteLine("*** NoWaitForLock 35");
using ([GetCSharpSQLCommandType()] command = DataAccessor.CreateCommand(this.GetNoWaitForLockCommandText()))
{
command.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpSQLIDType()]).Value = entity.ID;
int result = -1;
using ([GetCSharpSQLDataReaderType()] reader = command.ExecuteReader())
{
if (reader.Read())
{
result = Convert.ToInt32(reader.GetValue(0));
if (reader.Read())
{
throw new Kreta.Framework.DataIntegrityException("Egyediség megsértése: [ENTITYNAME].");
}
}
else
{
throw new Kreta.Framework.Exceptions.EntityNotFoundException("[ENTITYNAME]", entity.ID);
}
}
return result;
}
}
#endregion
end template
/* REFACTOR
template GenerateNoWaitForLock(classname)
#region No wait for lock
[GenerateCommandGetterProperty("NoWaitForLock")]
/// <summary>
///
/// </summary>
/// <returns>A műveletet elvégző SQL parancs.</returns>
private [GetCSharpSQLCommandType()] [GenerateCommandCreatorName("NoWaitForLock")]()
{
[GetCSharpSQLCommandType()] result = new [GetCSharpSQLCommandType()]();
result.CommandType = CommandType.Text;
result.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpSQLIDType()]);
switch (SDAServer.Instance.Configuration.DataBaseType)
{
case DataBaseType.MSSQL:
{
result.CommandText = "select SERIAL from [ConvertNameToSQLTableName([classname])] with(updlock) where ID = :[ConvertNameToCommandParameterName("ID")] ";
break;
}
case DataBaseType.ORACLE:
case DataBaseType.NATIVEORACLE:
{
result.CommandText = "select SERIAL from [ConvertNameToSQLTableName([classname])] where ID = :[ConvertNameToCommandParameterName("ID")] ";
result.CommandText += " for update nowait";
break;
}
default:
{
throw new NotSupportedException(SDAServer.Instance.Configuration.DataBaseType.ToString());
}
}
return result;
}
/// <summary>
///
/// </summary>
public int NoWaitForLock([classname] entity)
{
[GetCSharpSQLDataReaderType()] reader = null;
[GetCSharpSQLCommandType()] command = this.[ConvertNameToCommandName("NoWaitForLock")];
[GenerateCommandInit("command")]
command.Parameters\["[ConvertNameToCommandParameterName("ID")]"\].Value = entity.ID;
int result = -1;
using (reader = command.ExecuteReader())
{
if (reader.Read())
{
result = Convert.ToInt32(reader.GetValue(0));
System.Diagnostics.Debug.Assert(reader.Read() == false, "Több ilyen entitást találtam az adatbázisban..."); // XXX
}
else
{
throw new Kreta.Framework.Exceptions.EntityNotFoundException("[classname]", entity.ID);
}
}
return result;
}
#endregion
end template
*/

View file

@ -0,0 +1,89 @@
//***************************************************************************//
// Legenerálja egy entitás asszociációinak módosítóműveletét a DA-ban //
//***************************************************************************//
template GenerateUpdateAssociations(MClass as ENTITY)
#region UpdateAssociations
private const string m_UpdateAssociationCommandText = @"
update [ConvertNameToSQLTableName([ENTITY.name])]
set
[if (GetInheritance([ENTITY]) == "tpc")]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if (([EndRole.multiplicity] == "1") or (([EndRole.multiplicity] == "0..1") and (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity]=="*") or ([StartRole.multiplicity]=="0..*"))))]
[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))],
[end if]
[end if]
[end loop]
[end loop]
[loop (ENTITY -> SuperClass as MBaseClass)]
[loop (MBaseClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))],
[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))],
[end loop]
[end loop]
[end loop]
[end if]
[loop (ENTITY -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if (([EndRole.multiplicity] == "1") or (([EndRole.multiplicity] == "0..1") and (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity]=="*") or ([StartRole.multiplicity]=="0..*"))))]
[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))],
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([EndRole]))],
[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = :[ConvertNameToCommandParameterName(ConvertRoleToName([StartRole]))],
[end loop]
[end loop]
SERIAL = ISNULL(SERIAL,0) + 1,
LASTCHANGED = :[ConvertNameToCommandParameterName("LastChanged")],
MODIFIER = :[ConvertNameToCommandParameterName("Modifier")]
where
[if (IsMasterEntity([ENTITY]) == "true")]
(ID = :[ConvertNameToCommandParameterName("ID")]) and (ISNULL(SERIAL,0) = :[ConvertNameToCommandParameterName("Serial")])
[else]
(ID = :[ConvertNameToCommandParameterName("ID")])
[end if]
";
public override bool UpdateAssociations([ENTITY.name] entity)
{
[if (IsMasterEntity([ENTITY]) == "false")]
if (entity.InheritedDA.UpdateAssociations(entity) == false)
{
return false;
}
[end if]
using ([GetCSharpSQLCommandType()] command = DAUtil.CreateCommand(m_UpdateAssociationCommandText))
{
dbhelper.BindAssociations(entity, command);
DateTime lastchanged = DateTime.Now;
var modifier = UserContext.Instance.UniqueIdentifier;
command.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpDatasetType("ID", "")]).Value = entity.ID;
[if (IsMasterEntity([ENTITY]) == "true")]
command.Parameters.Add("[ConvertNameToCommandParameterName("Serial")]", [GetCSharpDatasetType("Integer", "")]).Value = entity.Serial;
[end if]
command.Parameters.Add("[ConvertNameToCommandParameterName("LastChanged")]", [GetCSharpDatasetType("DateTime", "")]).Value = lastchanged;
command.Parameters.Add("[ConvertNameToCommandParameterName("Modifier")]", [GetCSharpDatasetType("ID", "")]).Value = modifier;
bool result = (command.ExecuteNonQuery() == 1);
[if (IsMasterEntity([ENTITY]) == "true")]
if (result == true)
{
entity.Serial++;
SetEntityModifier(entity, lastchanged, modifier);
}
[end if]
return result;
}
}
#endregion
end template

View file

@ -0,0 +1,64 @@
//***************************************************************************//
// Legenerálja egy entitás módosító műveletét a DA-ban //
//***************************************************************************//
template GenerateUpdateEntity(MClass as ENTITY)
#region UpdateEntity
private const string m_UpdateAttributesCommandText = @"
update [ConvertNameToSQLTableName([ENTITY.name])]
set
{COLUMNS}
SERIAL = ISNULL(SERIAL,0) + 1,
LASTCHANGED = :[ConvertNameToCommandParameterName("LastChanged")],
MODIFIER = :[ConvertNameToCommandParameterName("Modifier")],
TOROLT = :[ConvertNameToCommandParameterName("Torolt")]
where
[if (IsMasterEntity([ENTITY]) == "true")]
(ID = :[ConvertNameToCommandParameterName("ID")]) and (ISNULL(SERIAL,0) = :[ConvertNameToCommandParameterName("Serial")])
[else]
(ID = :[ConvertNameToCommandParameterName("ID")])
[end if]
";
public override bool UpdateEntity([ENTITY.name] entity)
{
[if (IsMasterEntity([ENTITY]) == "false")]
if (entity.InheritedDA.UpdateEntity(entity) == false)
{
return false;
}
[end if]
using ([GetCSharpSQLCommandType()] command = DAUtil.CreateCommand(m_UpdateAttributesCommandText))
{
bool result = true;
dbhelper.DynamicBindAttributes(entity, command);
[if (IsMasterEntity([ENTITY]) == "true")]
[if (GetTaggedValue([ENTITY], "anonymous") == "all" || GetTaggedValue([ENTITY], "anonymous") == "update")]
SetEntityModifier(entity, DateTime.Now, "??????");
[else]
SetEntityModifier(entity, DateTime.Now, UserContext.Instance.UniqueIdentifier);
[end if]
[end if]
command.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpDatasetType("ID", "")]).Value = entity.ID;
[if (IsMasterEntity([ENTITY]) == "true")]
command.Parameters.Add("[ConvertNameToCommandParameterName("Serial")]", [GetCSharpDatasetType("Integer", "")]).Value = entity.Serial;
[end if]
command.Parameters.Add("[ConvertNameToCommandParameterName("LastChanged")]", [GetCSharpDatasetType("DateTime", "")]).Value = entity.EntityLastChanged;
command.Parameters.Add("[ConvertNameToCommandParameterName("Modifier")]", [GetCSharpDatasetType("ID", "")]).Value = entity.EntityModifier;
command.Parameters.Add("[ConvertNameToCommandParameterName("Torolt")]", [GetCSharpDatasetType("Boolean", "")]).Value = entity.Torolt;
result = (command.ExecuteNonQuery() == 1);
[if(IsMasterEntity([ENTITY]) == "true")]
if (result == true)
entity.Serial++;
[end if]
return result;
}
}
#endregion
end template

View file

@ -0,0 +1,47 @@
//***************************************************************************//
// Legenerálja a DA-hoz a zárolási műveletet. //
// //
// NINCS HASZNÁLVA! //
//***************************************************************************//
template GenerateWaitForLock(classname)
#region Wait for lock
[GenerateCommandGetterProperty("WaitForLock")]
/// <summary>
///
/// </summary>
/// <returns>A műveletet elvégző SQL parancs.</returns>
private [GetCSharpSQLCommandType()] [GenerateCommandCreatorName("WaitForLock")]()
{
[GetCSharpSQLCommandType()] result = new [GetCSharpSQLCommandType()]();
result.CommandType = CommandType.Text;
result.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpSQLIDType()]);
result.Parameters.Add("[ConvertNameToCommandParameterName("TimeOut")]", [GetCSharpSQLIDType()]);// XXX nem hasznalt parameter!
result.CommandText =
"select " +
"SERIAL " +
"from " +
"[ConvertNameToSQLTableName([classname])] " +
"where " +
"ID = :[ConvertNameToCommandParameterName("ID")] " +
"for update";
return result;
}
/// <summary>
///
/// </summary>
public void WaitForLock([classname] entity, int timeout)
{
[GetCSharpSQLCommandType()] command = this.[ConvertNameToCommandName("WaitForLock")];
[GenerateCommandInit("command")]
command.Parameters\["[ConvertNameToCommandParameterName("ID")]"\].Value = entity.ID;
command.Parameters\["[ConvertNameToCommandParameterName("TimeOut")]"\].Value = timeout;
command.ExecuteNonQuery(); // XXX nincs rendesen kigyurva!
}
#endregion
end template

View file

@ -0,0 +1,44 @@
//***************************************************************************//
// Legenerálja a DA-hoz a zárolási műveletet. //
// //
// NINCS HASZNÁLVA! //
//***************************************************************************//
template GenerateWaitLock(classname)
#region Wait lock
[GenerateCommandGetterProperty("WaitLock")]
/// <summary>
///
/// </summary>
/// <returns>A műveletet elvégző SQL parancs.</returns>
private [GetCSharpSQLCommandType()] [GenerateCommandCreatorName("WaitLock")]()
{
[GetCSharpSQLCommandType()] result = new [GetCSharpSQLCommandType()]();
result.CommandType = CommandType.Text;
result.Parameters.Add("[ConvertNameToCommandParameterName("ID")]", [GetCSharpSQLIDType()]);
result.CommandText =
"select " +
"SERIAL " +
"from " +
"[ConvertNameToSQLTableName([classname])] " +
"where " +
"ID = :[ConvertNameToCommandParameterName("ID")] " +
"for update";
return result;
}
/// <summary>
///
/// </summary>
public void WaitLock([classname] entity)
{
[GetCSharpSQLCommandType()] command = this.[ConvertNameToCommandName("WaitLock")];
[GenerateCommandInit("command")]
command.Parameters\["[ConvertNameToCommandParameterName("ID")]"\].Value = entity.ID;
command.ExecuteNonQuery(); // XXX nincs rendesen kigyurva!
}
#endregion
end template

View file

@ -0,0 +1,69 @@
//***************************************************************************//
// Legenerálja egy entitás testreszabható leszármazottjának forráskód vázát. //
//***************************************************************************//
template GenerateCustomEntity(MClass as ENTITY)
[BOM]using System;
using System.Linq;
using System.Xml;
using SDA.Framework;
using SDA.Framework.Classes;
using SDA.Framework.Entities;
using SDA.Framework.Query;
using SDA.Framework.Exceptions;
using SDA.[ProjectName].Entities;
namespace SDA.[ProjectName].CustomEntities
{
public partial class Custom[ENTITY.name] : [ENTITY.name]
{
public new static Custom[ENTITY.name] GiveAnInstance()
{
return (Custom[ENTITY.name])Entities.[ENTITY.name].GiveAnInstance();
}
#region Kézzel írt kód
//#ACD# M(["CustomEntity(" [ENTITY.guid] ")"])
//#end ACD#
#endregion
}
}
namespace SDA.[ProjectName].DirectXML
{
public class CustomDX[ENTITY.name]BaseSet : DX[ENTITY.name]BaseSet
{
#region Kézzel írt kód
//#ACD# M(["CustomDX" [ENTITY.name] "BaseSet"])
//#end ACD#
#endregion
}
sealed class CustomDX[ENTITY.name]ByID : DX[ENTITY.name]ByID
{
public CustomDX[ENTITY.name]ByID(int id)
: base(id) { }
#region Kézzel írt kód
//#ACD# M(["CustomDX" [ENTITY.name] "ById"])
//#end ACD#
#endregion
}
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
sealed class CustomDX[ENTITY.name]By[GetRoleName([ENDROLE])]ID : DX[ENTITY.name]By[GetRoleName([ENDROLE])]ID
{
public CustomDX[ENTITY.name]By[GetRoleName([ENDROLE])]ID(int [ToLower(GetRoleName([ENDROLE]) "ID")])
: base([ToLower(GetRoleName([ENDROLE]) "ID")]) { }
#region Kézzel írt kód
//#ACD# M(["CustomDX" [ENTITY.name] "By" GetRoleName([ENDROLE]) "Id"])
//#end ACD#
#endregion
}
[end loop]
}
end template

View file

@ -0,0 +1,323 @@
//***************************************************************************//
// Legenerálja a megadott osztályhoz tartozó entitás teljes forráskódját. //
//***************************************************************************//
template GenerateEntity(MClass as ENTITY)
[BOM]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.[ProjectName].Entities
{
/// <summary>
/// Az UML modell [ENTITY.name] 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("[ENTITY.name]")\]
[if (GetTaggedValue([ENTITY], "disabledsecuritymode") == "read")]
\[Kreta.Framework.Security.EntitySecurityDisabled(Kreta.Framework.Security.EntitySecurityDisabledMode.DISABLE_READ)\]
[else]
[if (GetTaggedValue([ENTITY], "disabledsecuritymode") == "readwrite")]
\[Kreta.Framework.Security.EntitySecurityDisabled(Kreta.Framework.Security.EntitySecurityDisabledMode.DISABLE_READWRITE)\]
[end if]
[end if]
[GenerateEntityHistoryModeAttribute([ENTITY])]
public class [ENTITY.name] : [GetBaseClassName([ENTITY], "Entity")], I[ENTITY.name]
{
internal protected [ENTITY.name]()
: base()
{
}
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
public new class AttributeInfo : [BASECLASS.name].AttributeInfo
{
[end loop]
[else]
public class AttributeInfo
{
[end if]
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
public const string [ATTRIBUTE.name] = "[ATTRIBUTE.name]";
[end loop]
}
[if (IsMasterEntity([ENTITY]) == "false")]
[loop (ENTITY -> SuperClass as BASECLASS)]
public new class AttributeLengthInfo : [BASECLASS.name].AttributeLengthInfo
{
[end loop]
[else]
public class AttributeLengthInfo
{
[end if]
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[if (GetCSharpType([ATTRIBUTE.type]) == "string")]
public const int [ATTRIBUTE.name]Length = [GetAttributeLength([ATTRIBUTE])];
[end if]
[end loop]
}
[GenerateGeneralSection([ENTITY])]
[//GenerateXMLSection([ENTITY])]
[GenerateEntityValidation([ENTITY])]
[GenerateEntityReset([ENTITY])]
[GenerateDeAssociateBeforeDelete([ENTITY])]
#region Mezők és tulajdonságok
[GenerateSimpleFields([ENTITY])]
#region Asszociációkkal kapcsolatos dolgok
[GenerateAssociationClassFields([ENTITY])]
[GenerateFirstCaseAssociations([ENTITY])]
[//GenerateSecondCaseAssociations([ENTITY])]
[GenerateThirdCaseAssociations([ENTITY])]
[//GenerateFourthCaseAssociations([ENTITY])]
#endregion
#endregion
}
}
end template
//***************************************************************************//
// Legenerálja azt a metódust, ami törlés előtt elvégzi az asszociációinak //
// felbontását, hogy ezzel törölhetővé tegye az entitást. //
//***************************************************************************//
template GenerateDeAssociateBeforeDelete(MClass as ENTITY)
protected override void DeAssociateBeforeDelete(bool runHandler = false)
{
// Nem kaszkád törölhető asszociációk ellenőrzése, hogy üresek-e...
[loop (ENTITY -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass
where (([StartRole.id] != [EndRole.id])
and GetStereoType([PartnerClass]) == "Entity")
and IsCascadeDelete([CurrentAssoc]) == "False"
)]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if (
([StartRole.multiplicity] == "1" and [EndRole.multiplicity] == "0..1"))]
[if ([ENTITY.name] != [PartnerClass.name] or [EndRole.isNavigable] == "TRUE")]
if (this.[DefineRoleName([EndRole])] != null)
{
[/*
// startrole: [StartRole.multiplicity], endrole: [EndRole.multiplicity]
*/]
throw new EntityDeleteFailedException("[ENTITY.name]", "[DefineRoleName([EndRole])]", EntityUtil.GetAssociationDescription("[ConvertNameToSQLTableName([PartnerClass.name])]", "[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))]")); // nincs kapcsolotabla
}
[else]
// [DefineRoleName([EndRole])] esetében önmagunkra mutatunk, nincs mit ellenőrizni. startrole: [StartRole.multiplicity], endrole: [EndRole.multiplicity]
[end if]
[else]
[if ([StartRole.multiplicity] == "0..1" and [EndRole.multiplicity] == "0..1")]
[if ([ENTITY.name] != [PartnerClass.name] or [EndRole.isNavigable] == "TRUE")]
if (this.[DefineRoleName([EndRole])] != null)
{
throw new EntityDeleteFailedException("[ENTITY.name]", "[DefineRoleName([EndRole])]", EntityUtil.GetAssociationDescription("[ConvertNameToSQLTableName([PartnerClass.name])]", "ID")); // *-* + kapcsolotabla
}
[end if]
[else]
[if(
([StartRole.multiplicity] == "1" and [EndRole.multiplicity] == "1..*") or
([StartRole.multiplicity] == "1" and [EndRole.multiplicity] == "*") or
([StartRole.multiplicity] == "1" and [EndRole.multiplicity] == "0..*") or
([StartRole.multiplicity] == "0..1" and [EndRole.multiplicity] == "1..*") or
([StartRole.multiplicity] == "0..1" and [EndRole.multiplicity] == "*") or
([StartRole.multiplicity] == "0..1" and [EndRole.multiplicity] == "0..*")
/*
([StartRole.multiplicity] == "0..*" and [EndRole.multiplicity] == "0..*") or
([StartRole.multiplicity] == "1..*" and [EndRole.multiplicity] == "0..*") or
([StartRole.multiplicity] == "*" and [EndRole.multiplicity] == "0..*") or
([StartRole.multiplicity] == "0..*" and [EndRole.multiplicity] == "*") or
([StartRole.multiplicity] == "1..*" and [EndRole.multiplicity] == "*") or
([StartRole.multiplicity] == "*" and [EndRole.multiplicity] == "*") or
([StartRole.multiplicity] == "0..*" and [EndRole.multiplicity] == "1..*") or
([StartRole.multiplicity] == "1..*" and [EndRole.multiplicity] == "1..*") or
([StartRole.multiplicity] == "*" and [EndRole.multiplicity] == "1..*")
*/
)]
[if ([ENTITY.name] != [PartnerClass.name] or [EndRole.isNavigable] == "TRUE")]
if (this.[DefineRoleName([EndRole])].Count > 0)
{
[/*
// startrole: [StartRole.multiplicity], endrole: [EndRole.multiplicity]
*/]
throw new EntityDeleteFailedException("[ENTITY.name]", "[DefineRoleName([EndRole])]", EntityUtil.GetAssociationDescription("[ConvertNameToSQLTableName([PartnerClass.name])]", "[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))]")); // nincs kapcsolotabla
}
[else]
// [DefineRoleName([EndRole])] esetében önmagunkra mutatunk, nincs mit ellenőrizni. startrole: [StartRole.multiplicity], endrole: [EndRole.multiplicity]
[end if]
[else]
[if (
([StartRole.multiplicity] == "0..*" and [EndRole.multiplicity] == "0..*") or
([StartRole.multiplicity] == "1..*" and [EndRole.multiplicity] == "0..*") or
([StartRole.multiplicity] == "*" and [EndRole.multiplicity] == "0..*") or
([StartRole.multiplicity] == "0..*" and [EndRole.multiplicity] == "*") or
([StartRole.multiplicity] == "1..*" and [EndRole.multiplicity] == "*") or
([StartRole.multiplicity] == "*" and [EndRole.multiplicity] == "*") or
([StartRole.multiplicity] == "0..*" and [EndRole.multiplicity] == "1..*") or
([StartRole.multiplicity] == "1..*" and [EndRole.multiplicity] == "1..*") or
([StartRole.multiplicity] == "*" and [EndRole.multiplicity] == "1..*")
)]
[if ([ENTITY.name] != [PartnerClass.name] or [EndRole.isNavigable] == "TRUE")]
if (this.[DefineRoleName([EndRole])].Count > 0)
{
[/*
// startrole: [StartRole.multiplicity], endrole: [EndRole.multiplicity]
*/]
throw new EntityDeleteFailedException("[ENTITY.name]", "[DefineRoleName([EndRole])]", EntityUtil.GetAssociationDescription("[ConvertNameToSQLTableName([PartnerClass.name])]", "ID")); // *-* + kapcsolotabla
}
[end if]
[else]
// [DefineRoleName([EndRole])] esetében mi mutatunk a másikra: startrole: [StartRole.multiplicity], endrole: [EndRole.multiplicity]
[end if]
[end if]
[end if]
[end if]
[else]
[loop (CurrentAssoc -> AssociationClass)]
[if ([ENTITY.name] != DefineRoleName([EndRole]) or [EndRole.isNavigable] == "TRUE")]
[if ([EndRole.multiplicity] == "1" or [EndRole.multiplicity] == "0..1")]
if (this.[DefineRoleName([EndRole])] != null)
{
[/*
// asszociacios osztaly
*/]
throw new EntityDeleteFailedException("[ENTITY.name]", "[DefineRoleName([EndRole])]", EntityUtil.GetAssociationDescription("[ConvertNameToSQLTableName([AssociationClass.name])]", "[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))]"));
}
[else]
if (this.[DefineRoleName([EndRole])].Count > 0)
{
[/*
// asszociacios osztaly
*/]
throw new EntityDeleteFailedException("[ENTITY.name]", "[DefineRoleName([EndRole])]", EntityUtil.GetAssociationDescription("[ConvertNameToSQLTableName([AssociationClass.name])]", "[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))]"));
}
[end if]
[else]
// [DefineRoleName([EndRole])] esetében nincs ilyen property, nem navigálható, névütközés, stb., nincs mit ellenőrizni. startrole: [StartRole.multiplicity], endrole: [EndRole.multiplicity]
[end if]
[end loop]
[end if]
[end loop]
// kaszkád törlések...
[loop (ENTITY -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass
where (([StartRole.id] != [EndRole.id])
and GetStereoType([PartnerClass]) == "Entity")
and IsCascadeDelete([CurrentAssoc]) == "True"
)]
[if (([PartnerClass.name] != [ENTITY.name]) or ([PartnerClass.name] == [ENTITY.name] and [ENTITY.name] != DefineRoleName([EndRole])))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([StartRole.multiplicity] == "1" and [EndRole.multiplicity] == "0..1")]
if (this.[DefineRoleName([EndRole])] != null)
{
if (this.[DefineRoleName([EndRole])].State != EntityState.Removed)
{
if (this.[DefineRoleName([EndRole])].ID != this.ID)
{
this.[DefineRoleName([EndRole])].CascadeDelete(runHandler); // Kötelezően ránk mutat...
}
}
}
[else]
[if(
([StartRole.multiplicity] == "1" and [EndRole.multiplicity] == "1..*") or
([StartRole.multiplicity] == "1" and [EndRole.multiplicity] == "*") or
([StartRole.multiplicity] == "1" and [EndRole.multiplicity] == "0..*")
)]
foreach ([PartnerClass.name] partner in this.[DefineRoleName([EndRole])])
{
if (partner.State != EntityState.Removed)
{
if (partner.ID != this.ID)
{
partner.CascadeDelete(runHandler); // Kötelezően ránk mutat...
}
}
}
[else]
[if ([EndRole.multiplicity] == "0..1")]
this.[DefineRoleName([EndRole])] = null;
[else]
[if ([EndRole.multiplicity] != "1")]
this.[DefineRoleName([EndRole])].RemoveAll();
[end if]
[end if]
[end if]
[end if]
[else]
[loop (CurrentAssoc -> AssociationClass)]
[if ([EndRole.multiplicity] == "1" or [EndRole.multiplicity] == "0..1")]
if (this.[DefineRoleName([EndRole])] != null)
{
if (this.[DefineRoleName([EndRole])].State != EntityState.Removed)
{
if (this.[DefineRoleName([EndRole])].ID != this.ID)
{
this.[DefineRoleName([EndRole])].CascadeDelete(runHandler); // Asszociációs osztály
}
}
}
[else]
foreach ([AssociationClass.name] associationclass in this.[DefineRoleName([EndRole])])
{
if (associationclass.State != EntityState.Removed)
{
if (associationclass.ID != this.ID)
{
associationclass.CascadeDelete(runHandler); // Asszociációs osztály
}
}
}
[end if]
[end loop]
[end if]
[end if]
[end loop]
[if (IsMasterEntity([ENTITY]) == "false")]
base.DeAssociateBeforeDelete(runHandler);
[end if]
}
end template
proc GenerateEntityHistoryModeAttribute(MClass as ENTITY)
local temp;
[temp] = GetTaggedValue([ENTITY], "historymode");
if ([temp] != "")
if (searchstr([temp], ",", 0) != "-1")
return "[EntityHistoryModeAttribute(\"" [temp] "\")]";
else
return "[EntityHistoryModeAttribute(EntityHistoryModes." [temp] ")]";
end if
else
return "// alapértelmezett EntityHistoryMode";
//return "[EntityHistoryModeAttribute(EntityHistoryModes.Default)] // alapértelmezett EntityHistoryModesß";
end if
end proc

View file

@ -0,0 +1,19 @@
//***************************************************************************//
// A megadott entitáshoz tipizált listát generál //
//***************************************************************************//
template GenerateEntityCollection()
[BOM]using System;
using Kreta.Framework;
using Kreta.Framework.Entities;
using Kreta.Framework.Entities.Generic;
using Kreta.Framework.Collections;
using Kreta.Framework.Collections.Generic;
namespace SDA.[ProjectName].Entities
{
//kompatibilitás miatt
[loop (Instances -> MClass WHERE GetStereoType([MClass]) == "Entity")]
public class [MClass.name]Collection = EntityCollection<[MClass.name]> { }
[end loop]
}
end template

View file

@ -0,0 +1,123 @@
//***************************************************************************//
// '1..*' és '*' végpontú asszociációs osztály nélküli asszociációs mezőket //
// és tulajdonságokat állít elő a megadott entitáshoz (harmadik eset) //
//***************************************************************************//
template GenerateThirdCaseAssociations(MClass as ENTITY)
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNERCLASS where (GetStereoType([PARTNERCLASS]) == "Entity") )]
[if ([STARTROLE.id] != [ENDROLE.id])]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "*" or [ENDROLE.multiplicity] == "1..*" or [ENDROLE.multiplicity] == "0..*")]
[if (([PARTNERCLASS.name] != [ENTITY.name]) or ([PARTNERCLASS.name] == [ENTITY.name] and [ENTITY.name] != DefineRoleName([ENDROLE])))]
#region [ENTITY.name] ([STARTROLE.multiplicity]) -> [PARTNERCLASS.name] ([ENDROLE.multiplicity])
protected IAssociatedEntityCollection<[PARTNERCLASS.name]> m_[DefineRoleName([ENDROLE])] = null;
IReadOnlyList<I[PARTNERCLASS.name]> I[ENTITY.name].[DefineRoleName([ENDROLE])] => [DefineRoleName([ENDROLE])].Cast<I[PARTNERCLASS.name]>().ToList();
/// <summary>
[if ([CURRENTASSOCIATION.description] != "")]
[ConvertDescriptionToCSharpSummary([CURRENTASSOCIATION.description])]
[else]
/// Nincs definiálva megjegyzés.
[end if]
/// </summary>
/// <remarks>
/// Az UML modellben szereplő [ENTITY.name] és [PARTNERCLASS.name] entitások közötti asszociáció megvalósítása.
/// </remarks>
[if ([STARTROLE.multiplicity] == "1" or [STARTROLE.multiplicity] == "0..1")]
\[EntityProperty("[DefineRoleName([ENDROLE])]", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<[PARTNERCLASS.name]>), EntityCopyMethod.DeepCopy, "[ConvertRoleToName([STARTROLE])]")\]
[else]
\[EntityProperty("[DefineRoleName([ENDROLE])]", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<[PARTNERCLASS.name]>), EntityCopyMethod.ShallowCopy, "[ConvertRoleToName([STARTROLE])]", "[ConvertRoleToName([ENDROLE])]", "[ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([ENDROLE],[STARTROLE]))]")\]
[end if]
public virtual IAssociatedEntityCollection<[PARTNERCLASS.name]> [DefineRoleName([ENDROLE])]
{
get
{
if (m_[DefineRoleName([ENDROLE])] == null)
{
m_[DefineRoleName([ENDROLE])] = new AssociatedEntityCollection<[ENTITY.name], [PARTNERCLASS.name]>(
new [GenerateEntityCollectionDAName([ENTITY.name], DefineRoleName([ENDROLE]))](this)
);
m_[DefineRoleName([ENDROLE])].Load();
}
return m_[DefineRoleName([ENDROLE])];
}
}
[if ([STARTROLE.multiplicity] == "0..*" or [STARTROLE.multiplicity] == "*" or [STARTROLE.multiplicity] == "1..*")]
/// <summary>
/// Teljesítményre optimalizált metódus a(z) [DefineRoleName([ENDROLE])] hozzárendelésre. <b>Ne használd, ha nem muszáj!</b>
/// </summary>
public void AddTo[DefineRoleName([ENDROLE])]([PARTNERCLASS.name] partner)
{
if (m_[DefineRoleName([ENDROLE])] == null)
{
new [GenerateEntityCollectionDAName([ENTITY.name], DefineRoleName([ENDROLE]))](this).AddItem(partner);
}
else
{
[DefineRoleName([ENDROLE])].Add(partner);
}
}
/// <summary>
/// Teljesítményre optimalizált metódus a(z) [DefineRoleName([ENDROLE])] szétrendelésre. <b>Ne használd, ha nem muszáj!</b>
/// </summary>
public void RemoveFrom[DefineRoleName([ENDROLE])]([PARTNERCLASS.name] partner)
{
if (m_[DefineRoleName([ENDROLE])] == null)
{
new [GenerateEntityCollectionDAName([ENTITY.name], DefineRoleName([ENDROLE]))](this).DeleteItem(partner);
}
else
{
[DefineRoleName([ENDROLE])].Remove(partner);
}
}
[end if]
#endregion
[end if]
[end if]
[end if]
[end if]
[end loop]
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNERCLASS where (GetStereoType([PARTNERCLASS]) == "Entity") )]
[if ([STARTROLE.id] != [ENDROLE.id])]
[if (HasAssociationClass([CURRENTASSOCIATION]) != "")]
[if ([ENDROLE.multiplicity] == "*" or [ENDROLE.multiplicity] == "1..*" or [ENDROLE.multiplicity] == "0..*")]
[if (([PARTNERCLASS.name] != [ENTITY.name]) or ([PARTNERCLASS.name] == [ENTITY.name] and [ENTITY.name] != DefineRoleName([ENDROLE])))]
[loop (CURRENTASSOCIATION -> AssociationClass as ASSOCIATIONCLASS)]
protected internal IAssociatedEntityCollection<[ASSOCIATIONCLASS.name]> m_[DefineRoleName([ENDROLE])] = null;
IReadOnlyList<I[ASSOCIATIONCLASS.name]> I[ENTITY.name].[DefineRoleName([ENDROLE])] => [DefineRoleName([ENDROLE])].Cast<I[ASSOCIATIONCLASS.name]>().ToList();
/// <summary>
///
/// </summary>
#region [ENTITY.name] ([STARTROLE.multiplicity]) -> [PARTNERCLASS.name] ([ENDROLE.multiplicity]) [ASSOCIATIONCLASS.name]
\[EntityProperty("[DefineRoleName([ENDROLE])]", EntityPropertyBaseType.EntityCollection, typeof(IAssociatedEntityCollection<[ASSOCIATIONCLASS.name]>), EntityCopyMethod.DeepCopy, "[ConvertRoleToName([STARTROLE])]")\]
public virtual IAssociatedEntityCollection<[ASSOCIATIONCLASS.name]> [DefineRoleName([ENDROLE])]
{
get
{
if (m_[DefineRoleName([ENDROLE])] == null)
{
m_[DefineRoleName([ENDROLE])] = new AssociatedEntityCollection<[ENTITY.name], [ASSOCIATIONCLASS.name]>(
new [GenerateEntityCollectionDAName([ENTITY.name], DefineRoleName([ENDROLE]))](this)
);
m_[DefineRoleName([ENDROLE])].Load();
}
return m_[DefineRoleName([ENDROLE])];
}
}
#endregion
[end loop]
[end if]
[end if]
[end if]
[end if]
[end loop]
end template

View file

@ -0,0 +1,110 @@
template GenerateEntityInterface(MClass as ENTITY)
[BOM]using System;
using System.Collections.Generic;
namespace Kreta.DataAccess.Interfaces
{
public interface I[ENTITY.name] : I[GetBaseClassName([ENTITY], "Entity")]
{
[GenerateSimpleInterfaceFields([ENTITY])]
[GenerateAssociationClassInterfaceFields([ENTITY])]
[GenerateFirstCaseInterfaceAssociations([ENTITY])]
[GenerateThirdCaseInterfaceAssociations([ENTITY])]
}
}
end template
template GenerateAssociationClassInterfaceFields(MClass)
[loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
[GetCSharpType("ID")] [ConvertRoleToName([StartRole])] { get; set; }
I[StartClass.name] [DefineRoleName([StartRole])] { get; set; }
[GetCSharpType("ID")] [ConvertRoleToName([EndRole])] { get; set; }
I[EndClass.name] [DefineRoleName([EndRole])] { get; set; }
[end loop]
[end loop]
end template
template GenerateSimpleInterfaceFields(MClass as ENTITY)
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[GenerateInterfaceAttributeProperty([ENTITY], [ATTRIBUTE])]
[end loop]
end template
template GenerateInterfaceAttributeProperty(MClass as ENTITY, MAttribute as ATTRIBUTE)
[if (IsComputedAttribute([ATTRIBUTE]) == _False())]
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
[GetCSharpType([ATTRIBUTE.type])] [ATTRIBUTE.name] { get; set; }
[else]
[GetCSharpNullableType([ATTRIBUTE.type])] [ATTRIBUTE.name] { get; set; }
[end if]
[else]
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
[GetCSharpType([ATTRIBUTE.type])] [ATTRIBUTE.name] { get; }
[else]
[GetCSharpNullableType([ATTRIBUTE.type])] [ATTRIBUTE.name] { get; }
[end if]
[end if]
end template
template GenerateFirstCaseInterfaceAssociations(MClass)
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([EndRole.multiplicity] == "1" or [EndRole.multiplicity] == "0..1")]
[if (([PartnerClass.name] != [MClass.name]) or ([PartnerClass.name] == [MClass.name] and [MClass.name] != DefineRoleName([EndRole])))]
[if ([StartRole.multiplicity] == "1..*" or [StartRole.multiplicity] == "*" or [StartRole.multiplicity] == "0..*" or [EndRole.multiplicity] == "1")]
int [ConvertRoleToName([EndRole])] { get; set; }
[end if]
I[PartnerClass.name] [DefineRoleName([EndRole])] { get; set; }
[end if]
[end if]
[end if]
[end loop]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) != "")]
[if ([EndRole.multiplicity] == "1" or [EndRole.multiplicity] == "0..1")]
[if (([PartnerClass.name] != [MClass.name]) or ([PartnerClass.name] == [MClass.name] and [MClass.name] != DefineRoleName([EndRole])))]
[loop (CurrentAssoc -> AssociationClass)]
I[AssociationClass.name] [DefineRoleName([EndRole])] { get; set; }
[end loop]
[end if]
[end if]
[end if]
[end loop]
end template
template GenerateThirdCaseInterfaceAssociations(MClass as ENTITY)
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNERCLASS where (GetStereoType([PARTNERCLASS]) == "Entity") )]
[if ([STARTROLE.id] != [ENDROLE.id])]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "*" or [ENDROLE.multiplicity] == "1..*" or [ENDROLE.multiplicity] == "0..*")]
[if (([PARTNERCLASS.name] != [ENTITY.name]) or ([PARTNERCLASS.name] == [ENTITY.name] and [ENTITY.name] != DefineRoleName([ENDROLE])))]
IReadOnlyList<I[PARTNERCLASS.name]> [DefineRoleName([ENDROLE])] { get; }
[end if]
[end if]
[end if]
[end if]
[end loop]
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNERCLASS where (GetStereoType([PARTNERCLASS]) == "Entity") )]
[if ([STARTROLE.id] != [ENDROLE.id])]
[if (HasAssociationClass([CURRENTASSOCIATION]) != "")]
[if ([ENDROLE.multiplicity] == "*" or [ENDROLE.multiplicity] == "1..*" or [ENDROLE.multiplicity] == "0..*")]
[if (([PARTNERCLASS.name] != [ENTITY.name]) or ([PARTNERCLASS.name] == [ENTITY.name] and [ENTITY.name] != DefineRoleName([ENDROLE])))]
[loop (CURRENTASSOCIATION -> AssociationClass as ASSOCIATIONCLASS)]
IReadOnlyList<I[ASSOCIATIONCLASS.name]> [DefineRoleName([ENDROLE])] { get; }
[end loop]
[end if]
[end if]
[end if]
[end if]
[end loop]
end template

View file

@ -0,0 +1,85 @@
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateEntityState(MClass as ENTITY)
internal class [ConvertNameToEntityStateName([ENTITY.name])] : [ConvertNameToEntityStateName(GetBaseClassName([ENTITY], "Entity"))] {
#region Attribútumok
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
public object [ConvertNameToEntityStateAttributeName([ATTRIBUTE.name])]; // [GetCSharpTypeOfAttribute([ATTRIBUTE])]
[end loop]
#endregion
#region Asszociációk
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
[if ([ENDROLE.multiplicity] == "0..1" or [ENDROLE.multiplicity] == "1")]
public [ConvertNameToEntityStateName([PARTNER.name])] [ConvertNameToEntityStateAttributeName(GetRoleName([ENDROLE]))];
[else]
public [ConvertNameToEntityStateCollectionName([PARTNER.name])] [ConvertNameToEntityStateAttributeName(GetRoleName([ENDROLE]))];
[end if]
[end loop]
#endregion
#region Asszociációs mezők
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity"))]
public [ConvertNameToEntityStateName([STARTCLASS.name])] [ConvertNameToEntityStateAttributeName(GetRoleName([STARTROLE]))];
public [ConvertNameToEntityStateName([ENDCLASS.name])] [ConvertNameToEntityStateAttributeName(GetRoleName([ENDROLE]))];
[end loop]
[end loop]
#endregion
#region Alaphelyzetbe állítás
public override void Reset() {
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
this.[ConvertNameToEntityStateAttributeName([ATTRIBUTE.name])] = null;
[end loop]
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
this.[ConvertNameToEntityStateAttributeName(GetRoleName([ENDROLE]))] = null; // XXX vagy inkább megtartsuk és a tartalmát ürítsük?
[end loop]
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity"))]
this.[ConvertNameToEntityStateAttributeName(GetRoleName([STARTROLE]))] = null; // XXX vagy inkább megtartsuk és a tartalmát ürítsük?
this.[ConvertNameToEntityStateAttributeName(GetRoleName([ENDROLE]))] = null; // XXX vagy inkább megtartsuk és a tartalmát ürítsük?
[end loop]
[end loop]
base.Reset();
}
#endregion
}
public class [ConvertNameToEntityStateCollectionName([ENTITY.name])] {
}
end template
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
proc ConvertNameToEntityStateName(ENTITYNAME)
return [ENTITYNAME] "DataObject ";
end proc
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
proc ConvertNameToEntityStateCollectionName(ENTITYNAME)
return [ENTITYNAME] "DataObjectCollection";
end proc
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
proc ConvertNameToEntityStateAttributeName(ATTRIBUTENAME)
return [ATTRIBUTENAME];
end proc

View file

@ -0,0 +1,334 @@
//***************************************************************************//
// 0..1 végpontú asszociációs osztály nélküli asszociációs mezőket és //
// tulajdonságokat állít elő a megadott entitáshoz (első eset) //
//***************************************************************************//
template GenerateFirstCaseAssociations(MClass)
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([StartRole.multiplicity] == "1" or [StartRole.multiplicity] == "0..1")]
protected internal virtual bool LoadBy[ConvertRoleToName([EndRole])](int id)
{
return m_DA.LoadBy[ConvertRoleToName([EndRole])](id, this);
}
[end if]
[end if]
[end loop]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([EndRole.multiplicity] == "1" or [EndRole.multiplicity] == "0..1")]
[if (([PartnerClass.name] != [MClass.name]) or ([PartnerClass.name] == [MClass.name] and [MClass.name] != DefineRoleName([EndRole])))]
#region [MClass.name] ([StartRole.multiplicity]) -> [PartnerClass.name] ([EndRole.multiplicity])
protected internal int m_[ConvertRoleToName([EndRole])] = [GetCSharpDefaultValueOfType("ID")];
[if ([StartRole.multiplicity] == "1..*" or [StartRole.multiplicity] == "*" or [StartRole.multiplicity] == "0..*" or [EndRole.multiplicity] == "1")]
/// <summary>
/// A(z) [DefineRoleName([EndRole])] 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 [ConvertRoleToName([EndRole])]
{
get
{
return Internal[ConvertRoleToName([EndRole])];
}
set
{
Internal[ConvertRoleToName([EndRole])] = value;
}
}
[end if]
/// <summary>
/// Ez egy külön bejárat a DA számára
/// <summary>
internal int Internal[ConvertRoleToName([EndRole])]
{
get
{
if (m_[DefineRoleName([EndRole])] != null)
{
return m_[DefineRoleName([EndRole])].ID;
}
else
{
return m_[ConvertRoleToName([EndRole])];// XXX az meg nem teljesen OK
}
}
set
{
CheckModifyable();
[if (IsReadonlyAssociation([CurrentAssoc]) == "True")]
if (this.ID > 0)
{
Entity partner = this.[DefineRoleName([EndRole])];
if (partner != null)
{
throw new ReadOnlyEntityAttributeException("[MClass.name]", "[ConvertRoleToName([EndRole])]");
}
}
[end if]
if (m_[ConvertRoleToName([EndRole])] != value)
{
m_[ConvertRoleToName([EndRole])] = value;
m_[DefineRoleName([EndRole])] = null;
FieldModified("[ConvertRoleToName([EndRole])]", value);
}
}
}
/// <summary>
/// Ez egy külön bejárat a DA számára
/// <summary>
internal void Modify[DefineRoleName([EndRole])]([PartnerClass.name] value)
{
m_[ConvertRoleToName([EndRole])] = value != null ? value.ID : [GetCSharpDefaultValueOfType("ID")];
m_[DefineRoleName([EndRole])] = value;
FieldModified("[ConvertRoleToName([EndRole])]", value != null ? (object)value.ID : DBNull.Value);
}
protected internal void Set[DefineRoleName([EndRole])]([PartnerClass.name] value)
{
m_[DefineRoleName([EndRole])] = value;
if (value != null)
{
m_[ConvertRoleToName([EndRole])] = value.ID;
}
else
{
m_[ConvertRoleToName([EndRole])] = [GetCSharpDefaultValueOfType("ID")];
}
}
protected [PartnerClass.name] m_[DefineRoleName([EndRole])] = null;
I[PartnerClass.name] I[MClass.name].[DefineRoleName([EndRole])]
{
get { return [DefineRoleName([EndRole])]; }
set { [DefineRoleName([EndRole])] = value as [PartnerClass.name]; }
}
/// <summary>
[if ([CurrentAssoc.description] != "")]
[ConvertDescriptionToCSharpSummary([CurrentAssoc.description])]
[else]
/// Nincs definiálva megjegyzés.
[end if]
/// </summary>
/// <remarks>
/// Az UML modellben szereplő [MClass.name] és [PartnerClass.name] entitások közötti asszociáció megvalósítása.
/// </remarks>
[if ([StartRole.multiplicity] == "1" or [StartRole.multiplicity] == "0..1")]
\[EntityProperty("[DefineRoleName([EndRole])]", EntityPropertyBaseType.Entity, typeof([PartnerClass.name]), EntityCopyMethod.DeepCopy)\]
[else]
\[EntityProperty("[DefineRoleName([EndRole])]", EntityPropertyBaseType.Entity, typeof([PartnerClass.name]), EntityCopyMethod.ShallowCopy)\]
[end if]
public virtual [PartnerClass.name] [DefineRoleName([EndRole])]
{
get
{
[if ([EndRole.multiplicity] == "0..1" and ([StartRole.multiplicity] == "1" or [StartRole.multiplicity] == "0..1"))]
if (m_[DefineRoleName([EndRole])] == null)
{
SDA.[ProjectName].Entities.[PartnerClass.name] partner = SDA.[ProjectName].Entities.[PartnerClass.name].GiveAnInstance();
if (partner.LoadBy[ConvertRoleToName([StartRole])](this.ID) == false)
{
return null;
}
if (partner.ID != [GetCSharpDefaultValueOfType("ID")])
{
this.Set[DefineRoleName([EndRole])](partner);
[if (([StartRole.multiplicity] != "1..*") and ([StartRole.multiplicity] != "*") and ([StartRole.multiplicity] != "0..*"))]
partner.Set[DefineRoleName([StartRole])](this);
[end if]
}
else
{
this.Set[DefineRoleName([EndRole])](null);
}
}
[else]
if ((m_[DefineRoleName([EndRole])] == null) && (m_[ConvertRoleToName([EndRole])] != [GetCSharpDefaultValueOfType("ID")]))
{
SDA.[ProjectName].Entities.[PartnerClass.name] partner = SDA.[ProjectName].Entities.[PartnerClass.name].GiveAnInstance();
partner.LoadByID(m_[ConvertRoleToName([EndRole])]);
this.Set[DefineRoleName([EndRole])](partner);
[if (([StartRole.multiplicity] != "1..*") and ([StartRole.multiplicity] != "*") and ([StartRole.multiplicity] != "0..*"))]
// itt be kell linkelni magunkat a partnerbe, ha ott nem lista van
partner.Set[DefineRoleName([StartRole])](this);
[end if]
}
[end if]
// természetesen null-t adunk vissza, ha nem tudtunk felhozni semmit
return m_[DefineRoleName([EndRole])];
}
set
{
CheckModifyable();
if (value != null)
{
if ((m_[DefineRoleName([EndRole])] == null) || (value.ID != m_[DefineRoleName([EndRole])].ID))
{
if (value.State != EntityState.Initialized)
{
throw new EntityStateException(value.State);
}
if ((this.State != EntityState.New))
{
[if ([StartRole.multiplicity] == "1..*" or [StartRole.multiplicity] == "*" or [StartRole.multiplicity] == "0..*")]
// Lista van a másik oldalon, úgyhogy a lista DA-ját használjuk
SDA.[ProjectName].Entities.[GenerateEntityCollectionDAName([PartnerClass.name], DefineRoleName([StartRole]))] da = new [GenerateEntityCollectionDAName([PartnerClass.name], DefineRoleName([StartRole]))](value);
da.AddItem(this);
this.Set[DefineRoleName([EndRole])](value);
[else]
[if (([EndRole.multiplicity] == "0..1") and ([StartRole.multiplicity] == "0..1"))]
m_DA.DeAssociate[DefineRoleName([EndRole])](this);
m_DA.Associate[DefineRoleName([EndRole])](this, value);
this.Set[DefineRoleName([EndRole])](value);
[else]
if (this.m_[ConvertRoleToName([EndRole])] != [GetCSharpDefaultValueOfType("ID")])
{
// Unlinkelni kell a régi partnert, ha van
SDA.[ProjectName].Entities.[PartnerClass.name] oldpartner = SDA.[ProjectName].Entities.[PartnerClass.name].GiveAnInstance();
[/*oldpartner.LoadByID(this.m_[ConvertRoleToName([EndRole])]);*/]
oldpartner.LoadBy[ConvertRoleToName([StartRole])](this.ID);
if (oldpartner.ID != [GetCSharpDefaultValueOfType("ID")])
{
oldpartner.Set[DefineRoleName([StartRole])](null);
oldpartner.UpdateAssociations();
}
}
this.Set[DefineRoleName([EndRole])](value);
value.Set[DefineRoleName([StartRole])](this);
UpdateAssociations();
value.UpdateAssociations();
[end if]
[end if]
}
else
{
this.Set[DefineRoleName([EndRole])](value);
}
FieldModified("[ConvertRoleToName([EndRole])]", value.ID);
}
}
else
{
[if (([EndRole.multiplicity] == "0..1") and ([StartRole.multiplicity] == "0..1"))]
m_DA.DeAssociate[DefineRoleName([EndRole])](this);
this.Set[DefineRoleName([EndRole])](null);
[else]
[if (([StartRole.multiplicity] != "1..*") and ([StartRole.multiplicity] != "*") and ([StartRole.multiplicity] != "0..*"))]
// unlinkelni kell a régi partnert, ha van
SDA.[ProjectName].Entities.[PartnerClass.name] oldpartner = SDA.[ProjectName].Entities.[PartnerClass.name].GiveAnInstance();
oldpartner.LoadByID(m_[ConvertRoleToName([EndRole])]);
if (oldpartner.ID != [GetCSharpDefaultValueOfType("ID")])
{
oldpartner.Set[DefineRoleName([StartRole])](null);
oldpartner.UpdateAssociations();
}
[end if]
// ki kell törölni a kapcsolatot az adatbázisban
this.Set[DefineRoleName([EndRole])](null);
UpdateAssociations();
[end if]
FieldModified("[ConvertRoleToName([EndRole])]", DBNull.Value);
}
}
}
#endregion
[end if]
[end if]
[end if]
[end loop]
[if (IsMasterEntity([MClass]) == "false" && HasSubTanev([MClass]) == "true")]
public override int TanevId
{
get
{
return base.TanevId;
}
set
{
InternalAlTanevId = value;
base.TanevId = value;
}
}
[end if]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) != "")]
[if ([EndRole.multiplicity] == "1" or [EndRole.multiplicity] == "0..1")]
[if (([PartnerClass.name] != [MClass.name]) or ([PartnerClass.name] == [MClass.name] and [MClass.name] != DefineRoleName([EndRole])))]
[loop (CurrentAssoc -> AssociationClass)]
#region [MClass.name] ([StartRole.multiplicity]) -> [PartnerClass.name] ([EndRole.multiplicity]) [AssociationClass.name]
protected internal [AssociationClass.name] m_[DefineRoleName([EndRole])] = null;
I[PartnerClass.name] I[MClass.name].[DefineRoleName([EndRole])]
{
get { return [DefineRoleName([EndRole])]; }
set { [DefineRoleName([EndRole])] = value as [PartnerClass.name]; }
}
\[EntityProperty("[DefineRoleName([EndRole])]", EntityPropertyBaseType.Entity, typeof([AssociationClass.name]), EntityCopyMethod.DeepCopy)\]
public virtual [AssociationClass.name] [DefineRoleName([EndRole])]
{
get
{
if (m_[DefineRoleName([EndRole])] == null)
{
m_[DefineRoleName([EndRole])] = SDA.[ProjectName].Entities.[AssociationClass.name].GiveAnInstance();
m_[DefineRoleName([EndRole])].LoadBy[DefineRoleName([StartRole])](this);
}
if (m_[DefineRoleName([EndRole])].ID != [GetCSharpDefaultValueOfType("ID")])
{
return m_[DefineRoleName([EndRole])];
}
else
{
return null;
}
}
set
{
CheckModifyable();
if (m_[DefineRoleName([EndRole])] == null)
{
// felhozzuk a régit, ha van
m_[DefineRoleName([EndRole])] = SDA.[ProjectName].Entities.[AssociationClass.name].GiveAnInstance();
m_[DefineRoleName([EndRole])].LoadBy[DefineRoleName([StartRole])](this);
}
if (m_[DefineRoleName([EndRole])].ID != [GetCSharpDefaultValueOfType("ID")])
{
// és ha van, akkor kitöröljük
m_[DefineRoleName([EndRole])].Delete();
}
if (value != null)
{
value.[ConvertRoleToName([StartRole])] = this.ID;
value.Insert();
}
m_[DefineRoleName([EndRole])] = value;
}
}
#endregion
[end loop]
[end if]
[end if]
[end if]
[end loop]
end template

View file

@ -0,0 +1,227 @@
//***************************************************************************//
// Legenerálja a megadott entitás általános szekcióját //
//***************************************************************************//
template GenerateGeneralSection(MClass)
#region General
private [MClass.name]DA m_DA = new [MClass.name]DA();
protected static [MClass.name] Fake[MClass.name] { get; set; }
[if (IsMasterEntity([MClass]) == "true")]
public static [MClass.name] GiveAnInstance()
[else]
public static new [MClass.name] GiveAnInstance()
[end if]
{
[MClass.name] result = Fake[MClass.name] == null
? new [MClass.name]()
: ([MClass.name])Fake[MClass.name].MemberwiseClone();
result.Reset();
result.SetDefaultData();
return result;
}
[if (IsMasterEntity([MClass]) == "true")]
protected void SetDefaultData()
[else]
protected new void SetDefaultData()
[end if]
{
[if (HasIntezmeny([MClass]) == "true" || HasSubIntezmeny([MClass]) == "true")]
if (UserContext.Instance != null)
{
if (UserContext.Instance.IntezmenyId > 0)
{
[if (HasIntezmeny([MClass]) == "true")]
IntezmenyId = UserContext.Instance.IntezmenyId;
[end if]
[if(HasSubIntezmeny([MClass]) == "true")]
AlIntezmenyId = UserContext.Instance.IntezmenyId;
[end if]
}
[if (HasTanev([MClass]) == "true" || HasSubTanev([MClass]) == "true")]
if (UserContext.Instance.AktivTanevId > 0)
{
[if (HasTanev([MClass]) == "true")]
TanevId = UserContext.Instance.AktivTanevId;
[end if]
[if(HasSubTanev([MClass]) == "true")]
AlTanevId = UserContext.Instance.AktivTanevId;
[end if]
}
[end if]
m_State = EntityState.Uninitialized;
}
[end if]
}
protected override IEntityDataAccessor GetDataAccessor() { return m_DA; }
[if (IsMasterEntity([MClass]) == "true")]
protected internal virtual IEntityDataAccessor InheritedDA { get { return null; } }
[else]
protected internal new IEntityDataAccessor InheritedDA { get { return base.GetDataAccessor(); } }
[end if]
\[Obsolete("Ezt ne használjátok, mert mindenhova bele kellene fogalmazni a tanév szűrést is! Meg fog majd szűnni!")\]
[if (IsMasterEntity([MClass]) == "true")]
public static IEntityCollection<[MClass.name]> LoadAll()
[else]
public static new IEntityCollection<[MClass.name]> LoadAll()
[end if]
{
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!")\]
[if (IsMasterEntity([MClass]) == "true")]
public static IEntityCollection<[MClass.name]> LoadAll(ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
[else]
public static new IEntityCollection<[MClass.name]> LoadAll(ColumnFilterMode columnFilterMode, IEnumerable<string> columns)
[end if]
{
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!")\]
[if (IsMasterEntity([MClass]) == "true")]
public static IEntityCollection<[MClass.name]> LoadWithFilter(string filter, Dictionary<string, object> commandParameters = null)
[else]
public static new IEntityCollection<[MClass.name]> LoadWithFilter(string filter, Dictionary<string, object> commandParameters = null)
[end if]
{
var result = new EntityCollection<[MClass.name]>();
new [MClass.name]DA().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!")\]
[if (IsMasterEntity([MClass]) == "true")]
public static IEntityCollection<[MClass.name]> LoadWithFilter(string filter, ColumnFilterMode columnFilterMode, IEnumerable<string> columns, Dictionary<string, object> commandParameters = null)
[else]
public static new IEntityCollection<[MClass.name]> LoadWithFilter(string filter, ColumnFilterMode columnFilterMode, IEnumerable<string> columns, Dictionary<string, object> commandParameters = null)
[end if]
{
var result = new EntityCollection<[MClass.name]>();
new [MClass.name]DA().LoadWithFilter(result, filter, columnFilterMode, columns, commandParameters);
return result;
}
protected override void StoreOriginalValues()
{
base.StoreOriginalValues();
[loop (MClass -> MAttribute as ATTRIBUTE)]
[if (IsAttributeLoggable([ATTRIBUTE]) == "true")]
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
OriginalValues.Add("[ATTRIBUTE.name]", (object)m_[ATTRIBUTE.name]);
[else]
OriginalValues.Add("[ATTRIBUTE.name]", ([ATTRIBUTE.name] == null ? (object)DBNull.Value : (object)m_[ATTRIBUTE.name]));
[end if]
[else]
// [ATTRIBUTE.name] ([ATTRIBUTE.type]) nem naplózandó attribútum, mert túl hosszú ([GetAttributeLength([ATTRIBUTE])])
[end if]
[end loop]
[loop (MClass -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNERCLASS where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNERCLASS]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "1" or [ENDROLE.multiplicity] == "0..1")]
[if (([PARTNERCLASS.name] != [MClass.name]) or ([PARTNERCLASS.name] == [MClass.name] and [MClass.name] != DefineRoleName([ENDROLE])))]
OriginalValues.Add("[ConvertRoleToName([ENDROLE])]", (m_[ConvertRoleToName([ENDROLE])] < 0 ? (object)DBNull.Value : (object)m_[ConvertRoleToName([ENDROLE])]));
[end if]
[end if]
[end if]
[end loop]
[loop (MClass -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity"))]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity" ))]
OriginalValues.Add("[ConvertRoleToName([STARTROLE])]", m_[ConvertRoleToName([STARTROLE])]);
OriginalValues.Add("[ConvertRoleToName([ENDROLE])]", m_[ConvertRoleToName([ENDROLE])]);
[end loop]
[end loop]
}
#endregion
end template
//***************************************************************************//
// Visszaadja egy attribútumról, hogy a megváltozása naplózandó-e, vagy sem. //
// true, ha naplózni kell a változását; egyébként false. //
//***************************************************************************//
proc IsAttributeLoggable(MAttribute)
if ([MAttribute.type] == "Binary")
return "false";
end if
local temp;
[temp] = GetTaggedValue([MAttribute], "history");
if ([temp] != "")
return ToLower([temp]);
end if
// if ([MAttribute.type] == "LongString")
// return "false";
// end if
//
// if ([MAttribute.type] == "String" and GetAttributeLength([MAttribute]) > 200)
// return "false";
// end if
return "true";
end proc
proc HasIntezmeny(MClass)
local HasIntezmeny = "false";
loop (MClass->Role as StartRole ->MAssociation as CurentAssoc ->MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id]!=[EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))
if([PartnerClass.name] == "Intezmeny")
[HasIntezmeny] = "true";
end if
end loop
if([MClass.name] == "Fenntarto" || [MClass.name] == "MobilDbInfo")
[HasIntezmeny] = "false";
end if
return [HasIntezmeny];
end proc
proc HasSubIntezmeny(MClass)
local HasIntezmeny = "false";
loop (MClass->Role as StartRole ->MAssociation as CurentAssoc ->MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id]!=[EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))
if([PartnerClass.name] == "Intezmeny" && [EndRole.name] == [StartRole.name] "AlIntezmeny")
[HasIntezmeny] = "true";
end if
end loop
return [HasIntezmeny];
end proc
proc HasTanev(MClass)
local HasTanev = "false";
loop (MClass->Role as StartRole ->MAssociation as CurentAssoc ->MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id]!=[EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))
if([PartnerClass.name] == "Tanev")
[HasTanev] = "true";
end if
end loop
if([MClass.name] == "MobilDbInfo")
[HasTanev] = "false";
end if
return [HasTanev];
end proc
proc HasSubTanev(MClass)
local HasTanev = "false";
loop (MClass->Role as StartRole ->MAssociation as CurentAssoc ->MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id]!=[EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))
if([PartnerClass.name] == "Tanev" && [EndRole.name] == [StartRole.name] "AlTanev")
[HasTanev] = "true";
end if
end loop
return [HasTanev];
end proc

View file

@ -0,0 +1,21 @@
template GenerateIEntityBaseClass()
[BOM]namespace Kreta.DataAccess.Interfaces
{
public interface IEntity
{
int ID { get; set; }
bool Torolt { get; set; }
}
}
end template
template GenerateIAssociatedCollection()
[BOM]using System.Collections.Generic;
namespace Kreta.DataAccess.Interfaces
{
public interface IAssociatedCollection<out TEntityType> : IEnumerable<TEntityType>
{
}
}
end template

View file

@ -0,0 +1,494 @@
//***************************************************************************//
// Megjegyzés? //
// //
// REKURZÍV! //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateMidasBaseSetLoadEntityCore(MClass, offset, entityname, readername)
// [MClass.name] mezői
[setVar("counter", [offset])]
[loop (MClass -> MAttribute where [MAttribute.name] != [MClass.name])]
if (reader.IsDBNull([counter]) == false)
{
[entityname].[MAttribute.name] = [GenerateReaderRead([MAttribute.type], [counter], [readername])];
}
else
{
[entityname].[MAttribute.name] = [GetCSharpDefaultValueOfAttribute([MAttribute])]; // Attribútum
}
[setVar("counter", incr([counter]))]
[end loop]
[/* Asszociacios mezok */]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([EndRole.multiplicity] == "1" or [EndRole.multiplicity] == "0..1")]
if ([readername].IsDBNull([counter]) == false)
{
[entityname].[ConvertRoleToName([EndRole])] = [GenerateReaderRead("ID", [counter], [readername])]; // Asszociációs mező
}
else
{
[entityname].[ConvertRoleToName([EndRole])] = [GetCSharpDefaultValueOfType("ID")];
}
[setVar("counter", incr([counter]))]
[end if]
[end if]
[end loop]
[/* Ha az entitas asszociacios osztaly, akkor ilyenek is vannak */]
[loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
[entityname].[ConvertRoleToName([StartRole])] = [GenerateReaderRead("ID", [counter], [readername])]; // Asszociációs mező
[setVar("counter", incr([counter]))]
[entityname].[ConvertRoleToName([EndRole])] = [GenerateReaderRead("ID", [counter], [readername])]; // Asszociációs mező
[setVar("counter", incr([counter]))]
[end loop]
[end loop]
[if (GetBaseClassName([MClass], [""]) != [""] )]
[loop (MClass -> SuperClass as BASECLASS)]
[GenerateMidasBaseSetLoadEntityCore([BASECLASS], [counter], [entityname], [readername])][break]
[end loop]
[else]
[entityname].Serial = [GenerateReaderRead("Integer", [counter], [readername])];
[end if]
end template
//***************************************************************************//
// Megjegyzés? //
// //
// REKURZÍV! //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateMidasFieldListWithBaseClassFields(MClass)
[loop (MClass->MAttribute)]
"[ConvertNameToSQLTableName([MClass.name])].[ConvertNameToSQLColumnName([MAttribute.name])], " +
[end loop]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([EndRole.multiplicity] == "1")]
"[ConvertNameToSQLTableName([MClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + // Kötelező asszociációs kapcsolómező
[else]
[if ([EndRole.multiplicity] == "0..1")]
[if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))]
"[ConvertNameToSQLTableName([MClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + // Opcionális asszociációs kapcsolómező
[else]
[if ([StartRole.multiplicity] == "1")]
"[ConvertNameToSQLTableName([PartnerClass.name])].ID as [ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + // a masik tablaban van a kapcsolomezo
[else]
"[ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([EndRole],[StartRole]))].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + // kapcsolotabla van
[end if]
[end if]
[end if]
[end if]
[end if]
[end loop]
[loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
"[ConvertNameToSQLTableName([MClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))], " + // Asszociációs mező
"[ConvertNameToSQLTableName([MClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([EndRole]))], " + // Asszociációs mező
[end loop]
[end loop]
[if (IsMasterEntity([MClass]) == "false")]
[loop (MClass -> SuperClass as BASECLASS)]
[GenerateMidasFieldListWithBaseClassFields([BASECLASS])][break]
[end loop]
[else]
"[ConvertNameToSQLTableName([MClass.name])].SERIAL " +
[end if]
end template
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
proc GenerateMidasTableListCore(MClass, tables)
loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))
if (HasAssociationClass([CurrentAssoc]) == "")
if ([EndRole.multiplicity] == "0..1")
if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))
else
if ([StartRole.multiplicity] == "1")
[tables] = AddDistinctValueToTokenSet([tables], [PartnerClass.name]);
//info = "\n>>>>>>>>>>>>>" [tables] "<<<<<<<<<<<<<<<\n";
else
[tables] = AddDistinctValueToTokenSet([tables], ConvertAssociationRolesToSwitchTableName([EndRole],[StartRole]));
//info = "\n>>>>>>>>>>>>>" [tables] "<<<<<<<<<<<<<<<\n";
end if
end if
end if
end if
end loop
return [tables];
end proc
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
proc GenerateMidasTableList(MClass)
local tables = "";
[tables] = GenerateMidasTableListCore([MClass], [tables]);
if (IsMasterEntity([MClass]) == "false")
loop (MClass -> SuperClass as BASECLASS)
[tables] = GenerateMidasTableListCore([BASECLASS], [tables]);
break;
end loop
end if
return [tables];
end proc
//***************************************************************************//
// Megjegyzés? //
// //
// REKURZÍV! //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateMidasBaseSetLoaderWhereClause(MClass)
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([EndRole.multiplicity] == "0..1")]
[if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))]
[else]
[if ([StartRole.multiplicity] == "1")]
"([ConvertNameToSQLTableName([PartnerClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = [ConvertNameToSQLTableName([MClass.name])].ID) and " + // a masik tablaban van a kapcsolomezo
[else]
"([ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([EndRole],[StartRole]))].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = [ConvertNameToSQLTableName([MClass.name])].ID) and " + // kapcsolotabla van
[end if]
[end if]
[end if]
[end if]
[end loop]
[if (IsMasterEntity([MClass]) == "false")]
[loop (MClass -> SuperClass as BASECLASS)]
[GenerateMidasBaseSetLoaderWhereClause([BASECLASS])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Megjegyzés? //
// //
// REKURZÍV! //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateJoins(MClass as current, MClass as master)
[loop (current -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([EndRole.multiplicity] == "0..1")]
[if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))]
[else]
[if ([StartRole.multiplicity] == "1")]
"left join [ConvertNameToSQLTableName([PartnerClass.name])] on [ConvertNameToSQLTableName([PartnerClass.name])].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = [ConvertNameToSQLTableName([master.name])].ID " + // a masik tablaban van a kapcsolomezo
[else]
"left join [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([EndRole],[StartRole]))] on [ConvertNameToSQLTableName(ConvertAssociationRolesToSwitchTableName([EndRole],[StartRole]))].[ConvertNameToSQLColumnName(ConvertRoleToName([StartRole]))] = [ConvertNameToSQLTableName([master.name])].ID " + // kapcsolotabla van
[end if]
[end if]
[end if]
[end if]
[end loop]
[if (IsMasterEntity([current]) == "false")]
[loop (current -> SuperClass as BASECLASS)]
[GenerateJoins([BASECLASS], [master])][break]
[end loop]
[end if]
end template
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateLoadMidasBaseSet(MClass)
#region Load entity base set
[GenerateCommandGetterProperty("LoadMidasBaseSet")]
private [GetCSharpSQLCommandType()] [GenerateCommandCreatorName("LoadMidasBaseSet")]()
{
[GetCSharpSQLCommandType()] result = new [GetCSharpSQLCommandType()]();
result.CommandType = CommandType.Text;
result.CommandText =
"select " +
"[ConvertNameToSQLTableName([MClass.name])].ID, " +
[GenerateMidasFieldListWithBaseClassFields([MClass])]
"from " +
[if (IsMasterEntity([MClass]) == "true")]
"[ConvertNameToSQLTableName([MClass.name])] " +
[else]
"[GenerateSuperClassTableList([MClass])] " +
[end if]
[GenerateJoins([MClass], [MClass])]
"where " +
[if (IsMasterEntity([MClass]) == "true")]
"[ConvertNameToSQLTableName([MClass.name])].SERIAL >= 0" +
[else]
[SDA_GetSuperClassSelectFilter([MClass])] +
[end if]
"and rownum < 1000";
[/*
// a partnertablak meg a kapcsolotablak
[loop (Instances -> TokenSet(GenerateMidasTableList([MClass])))]
"[ConvertNameToSQLTableName([TokenSet.line])], " +
[end loop]
"where " +
[GenerateMidasBaseSetLoaderWhereClause([MClass])]
[if (IsMasterEntity([MClass]) == "true")]
"[ConvertNameToSQLTableName([MClass.name])].SERIAL >= 0";
[else]
[SDA_GetSuperClassSelectFilter([MClass])];
[end if]
*/]
return result;
}
/// <summary>
///
/// </summary>
/// <param name="collection">Az adatbázisból felhozott entitásokat tartalmazó lista</param>
public bool LoadMidasBaseSet([MClass.name]Collection collection)
{
[GetCSharpSQLDataReaderType()] reader = null;
[GetCSharpSQLCommandType()] command = this.[ConvertNameToCommandName("LoadMidasBaseSet")];
[GenerateCommandInit("command")]
// Hajrá!
using (reader = command.ExecuteReader())
{
while (reader.Read())
{
[MClass.name] entity = [MClass.name].GiveAnInstance();
entity.ID = [GenerateReaderRead("ID", 0, "reader")];
[GenerateMidasBaseSetLoadEntityCore([MClass], 1, "entity", "reader")]
collection.AddEntity(entity);
}
return true;
}
}
#endregion
end template
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
proc GenerateMidasSave(buildername, attributename, type)
switch (ToLower([type]))
case "integer": return [buildername] ".Append(" [attributename] ".ToString());";
case "string": return [buildername] ".Append(this.HtmlEncode(" [attributename] "));";
case "datetime": return [buildername] ".Append(this.DateTimeToMidasString(" [attributename] "));";
case "boolean": return [buildername] ".Append(" [attributename] ".ToString());";
case "char": //return [buildername] ".Append(this.HtmlEncode(" [attributename] ".ToString()));";
return [buildername] ".Append(this.HtmlEncode(" [attributename] "));";
case "double": return [buildername] ".Append(" [attributename] ".ToString());";
case "float": return [buildername] ".Append(" [attributename] ".ToString());";
case "id": return [buildername] ".Append("[attributename] " != " GetCSharpDefaultValueOfType("ID") " ? " [attributename] ".ToString() : \"\");";
case "dictionaryitem": return [buildername] ".Append(" [attributename] ".ToString()); /* XXX DictionaryItem */ ";
case "binary": return "if (" [attributename] " != null) { " [buildername] ".Append(System.Convert.ToBase64String(" [attributename] ")); }";
end switch
return "/* ERROR Ismeretlen típus: " [type] " */";
end proc
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
template GenerateMidasSupport(MClass)
[/*
#region Midas támogatás
[if (IsMasterEntity([MClass]) == "true")]
public [MClass.name]Collection MidasBaseSet
[else]
public new [MClass.name]Collection MidasBaseSet
[end if]
{
get
{
[MClass.name]Collection result = [MClass.name]Collection.GiveAnInstance();
this.m_DA.LoadMidasBaseSet(result);
return result;
}
}
public override string FieldsToDelphiTClientDataSetXML(int parentid, bool needid, string nameprefix)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
[if (IsMasterEntity([MClass]) == "false")]
builder.Append(base.FieldsToDelphiTClientDataSetXML(parentid, needid, nameprefix));
[else]
if (needid == true)
{
builder.Append("SELECTED=\\"");
builder.Append("False");
builder.Append("\\" ");
builder.Append("ID=\\"");
[GenerateMidasSave("builder", "this.ID", "ID")]
builder.Append("\\" ");
builder.Append("ParentID=\\"");
[GenerateMidasSave("builder", "parentid", "ID")]
builder.Append("\\" ");
builder.Append("Serial=\\"");
[GenerateMidasSave("builder", "this.Serial", "Integer")]
builder.Append("\\" ");
}
[end if]
[loop (MClass -> MAttribute)]
builder.Append(nameprefix + "[MAttribute.name]=\\"");
[GenerateMidasSave("builder", "this.m_" [MAttribute.name], [MAttribute.type])]
builder.Append("\\" ");
[if ([MAttribute.type] == "DictionaryItem")]
builder.Append(nameprefix + "[MAttribute.name]_DNAME=\\"");
if (this.[MAttribute.name] != [GetCSharpDefaultValueOfType("ID")])
{
//SDA.[ProjectName].Entities.[MAttribute.defaultValue] temp = SDA.[ProjectName].Entities.[MAttribute.defaultValue].GiveAnInstance();
//temp.LoadByID(this.[MAttribute.name]);
//SDA.[ProjectName].Entities.[MAttribute.defaultValue] temp = (SDA.[ProjectName].Entities.[MAttribute.defaultValue])SDAServer.Instance.GetEntityFromCache(this.[MAttribute.name]);
SDA.[ProjectName].Entities.DictionaryItemBase temp = (SDA.[ProjectName].Entities.DictionaryItemBase)SDAServer.Instance.GetEntityFromCache(this.[MAttribute.name]);
if (temp == null)
{
temp = SDA.[ProjectName].Entities.[MAttribute.defaultValue].GiveAnInstance();
temp.LoadByID(this.[MAttribute.name]);
SDAServer.Instance.AddEntityToCache(temp);
}
[GenerateMidasSave("builder", "temp.Name", "string")]
}
builder.Append("\\" ");
[end if]
[end loop]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if (([PartnerClass.name] != [MClass.name]) or ([PartnerClass.name] == [MClass.name] and [MClass.name] != DefineRoleName([EndRole])))]
[if ([EndRole.multiplicity] == "1")]
builder.Append("[ConvertRoleToName([EndRole])]=\\"");
[GenerateMidasSave("builder", "this.m_" ConvertRoleToName([EndRole]), "ID")]
builder.Append("\\" ");
[end if]
[if ([EndRole.multiplicity] == "0..1")]
builder.Append(nameprefix + "[ConvertRoleToName([EndRole])]=\\"");
[GenerateMidasSave("builder", "this.m_" ConvertRoleToName([EndRole]), "ID")]
builder.Append("\\" ");
[end if]
[end if]
[end if]
[end loop]
return builder.ToString();
}
//public override string MetainfoToDelphiTClientDataSetXML()
//{
// return this.MetainfoToDelphiTClientDataSetXML(true);
//}
public override string MetainfoToDelphiTClientDataSetXML(bool needid, string nameprefix)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
[if (IsMasterEntity([MClass]) == "false")]
builder.Append(base.MetainfoToDelphiTClientDataSetXML(needid, nameprefix));
[else]
if (needid == true)
{
builder.Append("<FIELD attrname=\\"SELECTED\\" fieldtype=\\"boolean\\"/>");
builder.Append("<FIELD attrname=\\"ID\\" fieldtype=\\"i4\\"/>");
builder.Append("<FIELD attrname=\\"ParentID\\" fieldtype=\\"i4\\"/>");
builder.Append("<FIELD attrname=\\"Serial\\" fieldtype=\\"i4\\"/>");
}
[end if]
[loop (MClass -> MAttribute)]
builder.Append("<FIELD attrname=\\"");
builder.Append(nameprefix + "[MAttribute.name]");
builder.Append("\\" fieldtype=\\"");
builder.Append("[GetMidasType([MAttribute.type])]");
builder.Append("\\" WIDTH=\\"");
builder.Append("[GetAttributeLength([MAttribute])]");
builder.Append("\\"/>");
[if ([MAttribute.type] == "DictionaryItem")]
builder.Append("<FIELD attrname=\\"");
builder.Append(nameprefix + "[MAttribute.name]_DNAME");
builder.Append("\\" fieldtype=\\"string\\"");
builder.Append(" WIDTH=\\"200\\"/>");
[end if]
[end loop]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([EndRole.multiplicity] == "1" or [EndRole.multiplicity] == "0..1")]
[if (([PartnerClass.name] != [MClass.name]) or ([PartnerClass.name] == [MClass.name] and [MClass.name] != DefineRoleName([EndRole])))]
builder.Append("<FIELD attrname=\\"");
builder.Append(nameprefix + "[ConvertRoleToName([EndRole])]");
builder.Append("\\" fieldtype=\\"");
builder.Append("[GetMidasType("ID")]");
builder.Append("\\"/>");
[end if]
[end if]
[end if]
[end loop]
return builder.ToString();
}
[if (IsMasterEntity([MClass]) == "true")]
public static string GetDatapacketMetainfo(string prefix)
[else]
public static new string GetDatapacketMetainfo(string prefix)
[end if]
{
return m_DatapacketMetaInfo.Replace("{PREFIX}", prefix);
}
[if (IsMasterEntity([MClass]) == "true")]
public static string GetDatapacketMetainfo()
[else]
public static new string GetDatapacketMetainfo()
[end if]
{
return GetDatapacketMetainfo("");
}
private static readonly string m_DatapacketMetaInfo =
@"<FIELD attrname=""{PREFIX}ID"" fieldtype=""i4""/>
<FIELD attrname=""{PREFIX}Serial"" fieldtype=""i4""/>
[GenerateDataPacketMetadataAttributes([MClass], "{PREFIX}")]
[GenerateDataPacketMetadataAssociations([MClass], "{PREFIX}")]";
#endregion
*/]
end template
//***************************************************************************//
// Megjegyzés? //
// //
// VALÓSZÍNŰLEG MÁR ELAVULT, ÉS NEM HASZNÁLT! //
//***************************************************************************//
proc GetMidasType(type)
switch(ToLower([type]))
case "integer": return "i4";
case "string": return "string";
case "boolean": return "boolean";
case "float": return "r8"; // XXX
case "char": return "string"; // XXX
case "datetime": return "dateTime";
case "id": return "i4";
case "binary": return "bin.hex\"\" SUBTYPE=\"\"Binary";
case "dictionaryitem": return "i4";
end switch
return "object /* ERROR Ismeretlen tipus: " [type] " */";
end proc

View file

@ -0,0 +1,80 @@
//***************************************************************************//
// Pool támogató szekciót generál egy osztályhoz //
//***************************************************************************//
template GeneratePoolableSection(classname, ismasterentity, customname)
#region Pool-lal kapcsolatos műveletek
private static readonly PoolableFactory m_Factory = new [classname]Factory();
private static readonly ObjectPool m_Pool = new ObjectPool(m_Factory);
protected override PoolableFactory GetFactory() { return m_Factory; }
protected override ObjectPool GetPool() { return m_Pool; }
private sealed class [classname]Factory : PoolableFactory
{
public Poolable CreateObject() { return new [customname](); }
}
/// <summary>
/// Visszaad egy alapállapotú [classname] entitáspéldányt, lehetőleg pool-ból.
/// </summary>
/// <returns>Egy alapállapotú [classname] példány.</returns>
[if ([ismasterentity] == "true")]
public static [classname] GiveAnInstance()
[else]
public static new [classname] GiveAnInstance()
[end if]
{
[classname] result = ([classname])m_Factory.CreateObject();
result.Reset();
return result;
}
#endregion
end template
//***************************************************************************//
// Legenerálja egy entitás Reset() metódusát //
//***************************************************************************//
template GenerateEntityReset(MClass)
#region Alaphelyzetbe állítás
protected override void Reset()
{
base.Reset();
// alaphelyzetbe állítjuk az egyszerű mezőket
[loop (MClass -> MAttribute where [MAttribute.name] != [MClass.name])]
this.m_[MAttribute.name] = [GetCSharpDefaultValueOfAttribute([MAttribute])];
[end loop]
// alaphelyzetbe állítjuk az asszociációkból származó mezőket
[loop (MClass -> MAssociation as CurrentAssoc-> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass])=="Entity") )]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id]<[EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
this.m_[ConvertRoleToName([StartRole])] = [GetCSharpDefaultValueOfType("ID")]; // ID
this.m_[ConvertRoleToName([EndRole])] = [GetCSharpDefaultValueOfType("ID")]; // ID
[end loop]
[end loop]
[loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (([PartnerClass.name] != [MClass.name]) or ([PartnerClass.name] == [MClass.name] and [MClass.name] != DefineRoleName([EndRole])))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[//if (([EndRole.multiplicity] == "1") or (([EndRole.multiplicity] == "0..1") and (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))))]
[if (([EndRole.multiplicity] == "1") or ([EndRole.multiplicity] == "0..1"))]
this.m_[ConvertRoleToName([EndRole])] = [GetCSharpDefaultValueOfType("ID")];
this.m_[DefineRoleName([EndRole])] = null; // Entity
[end if]
[if ([EndRole.multiplicity] == "*" or [EndRole.multiplicity] == "1..*" or [EndRole.multiplicity] == "0..*")]
this.m_[DefineRoleName([EndRole])] = null; // EntityCollection
[end if]
[else]
[if ([EndRole.multiplicity] == "1" or [EndRole.multiplicity] == "0..1")]
[end if]
[if ([EndRole.multiplicity] == "*" or [EndRole.multiplicity] == "1..*" or [EndRole.multiplicity] == "0..*")]
[end if]
[end if]
[end if]
[end loop]
}
#endregion
end template

View file

@ -0,0 +1,165 @@
//***************************************************************************//
// Legenerálja egy entitás attribútumaiból a mezőket és a tulajdonságokat //
// Rendbe van téve //
//***************************************************************************//
template GenerateSimpleFields(MClass as ENTITY)
#region Egyszerű mezők
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
#region [ATTRIBUTE.name]
[GenerateAttributeProperty([ENTITY], [ATTRIBUTE])]
#endregion
[end loop]
#endregion
end template
//***************************************************************************//
// Rendbe van téve //
//***************************************************************************//
template GenerateAttributeProperty(MClass as ENTITY, MAttribute as ATTRIBUTE)
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
protected internal [GetCSharpType([ATTRIBUTE.type])] m_[ATTRIBUTE.name];
[else]
protected internal [GetCSharpNullableType([ATTRIBUTE.type])] m_[ATTRIBUTE.name];
[end if]
/// <summary>
[if ([ATTRIBUTE.description] != "")]
[ConvertDescriptionToCSharpSummary([ATTRIBUTE.description])]
[else]
/// Nincs definiálva megjegyzés.
[end if]
/// </summary>
\[EntityProperty("[ATTRIBUTE.name]", EntityPropertyBaseType.ValueType, typeof([GetCSharpType([ATTRIBUTE.type])]), EntityCopyMethod.ShallowCopy)\]
[if (IsDictionaryItem([ATTRIBUTE]) == _True())]
\[EntityDictionaryItemProperty("[ATTRIBUTE.name]", "[GetDictionaryItemClass([ATTRIBUTE])]", typeof(SDA.[ProjectName].Entities.[GetDictionaryItemClass([ATTRIBUTE])]))\]
[end if]
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
public virtual [GetCSharpType([ATTRIBUTE.type])] [ATTRIBUTE.name]
[else]
public virtual [GetCSharpNullableType([ATTRIBUTE.type])] [ATTRIBUTE.name]
[end if]
{
get
{
[if ((ToLower([ATTRIBUTE.type]) == "string" || ToLower([ATTRIBUTE.type]) == "longstring") && IsTrimmed([ATTRIBUTE]) == _True())]
return m_[ATTRIBUTE.name] == null ? m_[ATTRIBUTE.name] : m_[ATTRIBUTE.name].Trim();
[else]
return m_[ATTRIBUTE.name];
[end if]
}
[if (IsComputedAttribute([ATTRIBUTE]) == _False())]
set
{
[if (IsReadonlyAttribute([ATTRIBUTE]) == _True())]
// readonly attribútum
[GenerateReadonlyAttributeSetter([ENTITY], [ATTRIBUTE])]
[else]
[GenerateAttributeSetter([ENTITY], [ATTRIBUTE])]
[end if]
}
[end if]
}
[if (IsMultiLanguage([ATTRIBUTE]) == _True())]
[if (GetLanguageIndex([ATTRIBUTE]) == "0")]
/// <summary>
/// A(z) [ATTRIBUTE.name] értéke a jelenlegi nyelven. Csak megjelenítéshez használni!
/// </summary>
public [GetCSharpType([ATTRIBUTE.type])] Get[ATTRIBUTE.name]()
{
return Get[ATTRIBUTE.name](EntityUtil.CurrentLanguageIndex);
}
private [GetCSharpType([ATTRIBUTE.type])] Get[ATTRIBUTE.name](int languageIndex)
{
switch (languageIndex)
{
case 1:
{
return (string.IsNullOrEmpty([ATTRIBUTE.name]_1) ? [ATTRIBUTE.name] : [ATTRIBUTE.name]_1);
}
case 2:
{
return (string.IsNullOrEmpty([ATTRIBUTE.name]_2) ? [ATTRIBUTE.name] : [ATTRIBUTE.name]_2);
}
case 3:
{
return (string.IsNullOrEmpty([ATTRIBUTE.name]_3) ? [ATTRIBUTE.name] : [ATTRIBUTE.name]_3);
}
case 4:
{
return (string.IsNullOrEmpty([ATTRIBUTE.name]_4) ? [ATTRIBUTE.name] : [ATTRIBUTE.name]_4);
}
default:
{
return [ATTRIBUTE.name];
}
}
}
[end if]
[end if]
end template
//***************************************************************************//
// Rendbe van téve //
//***************************************************************************//
template GenerateReadonlyAttributeSetter(MClass as ENTITY, MAttribute as ATTRIBUTE)
CheckModifyable();
if (m_[ATTRIBUTE.name] == null || this.ID <= 0)
{
[if (IsDefaultonlyAttribute([ATTRIBUTE]) == _True())]
m_[ATTRIBUTE.name] = [GetCSharpDefaultValueOfAttribute([ATTRIBUTE])];
[else]
[if ((ToLower([ATTRIBUTE.type]) == "string" || ToLower([ATTRIBUTE.type]) == "longstring") && IsTrimmed([ATTRIBUTE]) == _True())]
m_[ATTRIBUTE.name] = value == null ? value : value.Trim();
[else]
m_[ATTRIBUTE.name] = value;
[end if]
[end if]
FieldModified("[ATTRIBUTE.name]", value);
}
else
{
throw new ReadOnlyEntityAttributeException("[ENTITY.name]", "[ATTRIBUTE.name]");
}
end template
//***************************************************************************//
// Rendbe van téve //
//***************************************************************************//
template GenerateAttributeSetter(MClass as ENTITY, MAttribute as ATTRIBUTE)
CheckModifyable();
[if (IsDefaultonlyAttribute([ATTRIBUTE]) == _True())]
m_[ATTRIBUTE.name] = [GetCSharpDefaultValueOfAttribute([ATTRIBUTE])];
FieldModified("[ATTRIBUTE.name]", value);
[else]
[if (ToLower([ATTRIBUTE.type]) == "string" || ToLower([ATTRIBUTE.type]) == "binary" || ToLower([ATTRIBUTE.type]) == "longstring")]
[if ((ToLower([ATTRIBUTE.type]) == "string" || ToLower([ATTRIBUTE.type]) == "longstring") && IsTrimmed([ATTRIBUTE]) == _True())]
value = (value == null) ? value : value.Trim();
[end if]
if (m_[ATTRIBUTE.name] == value) return;
m_[ATTRIBUTE.name] = value;
FieldModified("[ATTRIBUTE.name]", value);
[else]
if (m_[ATTRIBUTE.name] == value) return;
m_[ATTRIBUTE.name] = value;
FieldModified("[ATTRIBUTE.name]", value);
[end if]
[end if]
end template

View file

@ -0,0 +1,96 @@
//***************************************************************************//
// Legenerálja a megadott entitás Validate() metódusát //
//***************************************************************************//
template GenerateEntityValidation(MClass as ENTITY)
#region Ellenőrzés
protected override void Validate(bool skipValidateAttributes = false)
{
base.Validate();
[if (IsProtectedDictionaryItem([ENTITY]) == "True")]
// Védett kódtétel...
//if (m_Protected == false) { throw new InvalidEntityAttributeException("[ENTITY.name]", "Protected", EntityAttributeError.Unknown); }
[end if]
[if (IsEntityDictionaryItem([ENTITY]) == "True")]
[if (GetTaggedValue([ENTITY], "dkt") != "true")]
if (m_Protected && (HasChanged("Name") || HasChanged("Code")))
[else]
if (!m_IsModosithato && (HasChanged("Name") || HasChanged("Code")))
[end if]
{
throw new ProtectedDictionaryItemException("[ENTITY.name]", ID);
}
[end if]
if (!skipValidateAttributes)
{
// korlátos hosszúságú mezők ellenőrzése...
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[if (GetCSharpType([ATTRIBUTE.type]) == "string")]
if (m_[ATTRIBUTE.name] != null && m_[ATTRIBUTE.name].Length > [GetAttributeLength([ATTRIBUTE])])
{
[if (IsAttributeTruncateable([ATTRIBUTE]) == _True())]
m_[ATTRIBUTE.name] = m_[ATTRIBUTE.name].Substring(0,[GetAttributeLength([ATTRIBUTE])]-3) + "...";
[else]
throw new InvalidEntityAttributeException("[ENTITY.name]", "[ATTRIBUTE.name]", EntityAttributeError.TooLong);
[end if]
}
[end if]
[end loop]
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[loop (ATTRIBUTE -> TaggedValue where toLower([TaggedValue.tag]) == "value")]
if (m_[ATTRIBUTE.name] != null && this.m_[ATTRIBUTE.name] != "")
{
if (EntityUtil.VerifyRegEx(m_[ATTRIBUTE.name], @"[PrepareRegEx([TaggedValue.value])]") == false)
{
throw new InvalidEntityAttributeException("[ENTITY.name]", "[ATTRIBUTE.name]", EntityAttributeError.WrongFormat);
}
}
[end loop]
[end loop]
}
// kötelező asszociációk ellenőrzése...
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNERCLASS where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNERCLASS]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "1")]
if (m_[ConvertRoleToName([ENDROLE])] == [GetCSharpDefaultValueOfType("ID")]) { throw new InvalidEntityAttributeException("[ENTITY.name]", "[ConvertRoleToName([ENDROLE])]", EntityAttributeError.Empty); }
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity") )]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity" ))]
if (this.[ConvertRoleToName([ENDROLE])] == [GetCSharpDefaultValueOfType("ID")]) { throw new InvalidEntityAttributeException("[ENTITY.name]", "[ConvertRoleToName([ENDROLE])]", EntityAttributeError.Empty); }
if (this.[ConvertRoleToName([STARTROLE])] == [GetCSharpDefaultValueOfType("ID")]) { throw new InvalidEntityAttributeException("[ENTITY.name]", "[ConvertRoleToName([STARTROLE])]", EntityAttributeError.Empty); }
[end loop]
[end loop]
[/* // XXX '1..*' !
[loop (MClass->Role as StartRole ->MAssociation as CurrentAssoc ->MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([EndRole.multiplicity] == "1..*")]
//if (this.m_[ConvertRoleToName([EndRole])] == [GetCSharpDefaultValueOfType("ID")]) { throw new InvalidEntityAttributeException(); }
[end if]
[end if]
[end loop]
*/]
}
#endregion
end template
//***************************************************************************//
// A reguláris kifejezésben lecsréli a " karaktert "" karakterekre. Ez //
// amiatt kell, hogy a C# szintaktikának megfelelő legyen, mert @-cal //
// deklaráljuk a sztringliterált. //
//***************************************************************************//
proc PrepareRegEx(input)
local result = replace([input], """", """""");
return [result];
end proc

View file

@ -0,0 +1,295 @@
//***************************************************************************//
// Visszaadja, hogy egy adott entitás rendelkezik-e attribútumokkal, vagy //
// sem. Az ősosztály attribútumait figyelmen kívül hagyja. //
// true, ha rendelkezik legalább egy UML-ben definiált attribútummal; //
// egyébként false. //
//***************************************************************************//
proc HasAttributes(MClass)
loop (MClass -> MAttribute)
return "true";
end loop
return "false";
end proc
//***************************************************************************//
// Segédproc, a GenerateXMLSection() template használja. Visszaadja, hogy //
// kell-e temp lokális változót deklarálni, vagy sem. Ez attól függ, hogy az //
// entitás rendelkezik-e attribútummal, vagy asszociációval, amit XML-ből //
// be kell tölteni, vagy sem. //
// true, ha szükséges temp változó deklarálni; egyébként false. //
//***************************************************************************//
proc NeedTemporaryXmlNode(MClass)
if (HasAttributes([MClass]) == "true")
return "true";
end if
loop (MClass -> Role as StartRole -> MAssociation as CurrentAssoc -> MAssociationEnd as EndRole -> MClass as PartnerClass where (([StartRole.id] != [EndRole.id]) and GetStereoType([PartnerClass]) == "Entity"))
if (HasAssociationClass([CurrentAssoc]) == "")
if ([EndRole.multiplicity] == "1")
return "true";
else
if ([EndRole.multiplicity] == "0..1")
if (([StartRole.multiplicity] == "1..*") or ([StartRole.multiplicity] == "*") or ([StartRole.multiplicity] == "0..*"))
return "true";
end if
end if
end if
end if
end loop
loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity") )
loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id]<[EndRole.id] and GetStereoType([EndClass]) == "Entity" ))
return "true";
end loop
end loop
return "false";
end proc
//***************************************************************************//
// Név és típus alapján elkészíti az XML DOM-ból való betöltést //
//***************************************************************************//
proc GenerateLoadFromXMLExpression(name, type)
switch (ToLower([type]))
case "integer": return "Int32.Parse(" [name] ".InnerText, LanguageContext.Current.RegionSettings)";
case "string": return [name] ".InnerText";
case "datetime": return "DateTime.Parse(" [name] ".InnerText, LanguageContext.Current.RegionSettings)";
case "boolean": return "Boolean.Parse(" [name] ".InnerText)";
case "char": //return [name] ".InnerText[0]";
return [name] ".InnerText";
case "double": return "Double.Parse(" [name] ".InnerText, LanguageContext.Current.RegionSettings)";
case "float": return "Double.Parse(" [name] ".InnerText, LanguageContext.Current.RegionSettings)";
case "id": return "Int32.Parse(" [name] ".InnerText, LanguageContext.Current.RegionSettings)";
case "dictionaryitem": return "Int32.Parse(" [name] ".InnerText, LanguageContext.Current.RegionSettings) /* XXX DictionaryItem */ ";
case "binary": return "System.Convert.FromBase64String(" [name] ".InnerText)";
case "longstring": return "System.Text.UnicodeEncoding.Unicode.GetString(System.Convert.FromBase64String(" [name] ".InnerText))";
end switch
return "/* ERROR: ismeretlen tipus: " [type] " */";
end proc
//***************************************************************************//
// Legenerálja a megadott entitás XML-lel kapcsolatos dolgait //
//***************************************************************************//
template GenerateXMLSection(MClass as ENTITY)
#region XML támogatás
protected override void DoLoadFromXml(XmlNode entityNode) {
base.DoLoadFromXml(entityNode);
[if (NeedTemporaryXmlNode([ENTITY]) == "true")]
XmlNode current = null;
[end if]
[loop (ENTITY -> MAttribute as ATTRIBUTE where [ATTRIBUTE.name] != [ENTITY.name])]
if ((current = entityNode.SelectSingleNode(\"./field\[@name='[ATTRIBUTE.name]'\]\")) != null) {
[if (IsDefaultonlyAttribute([ATTRIBUTE]) == _True())]
if (current.FirstChild.Name == "default") {
[ATTRIBUTE.name] = [GetCSharpDefaultValueOfAttribute([ATTRIBUTE])];
}
else {
throw new InvalidEntityAttributeException("[ENTITY.name]", "[ATTRIBUTE.name]", EntityAttributeError.NotAllowed);
}
[else]
if (current.FirstChild.Name == "null") {
[if (IsAttributeRequired([ATTRIBUTE]) == _True())]
[ATTRIBUTE.name] = [GetCSharpDefaultValueOfAttribute([ATTRIBUTE])];
[if (HasDefaultValue([ATTRIBUTE]) == "True")]
[else]
//kotelezo attirbutum de validalasnal majd elszall!
m_[ATTRIBUTE.name]IsNull = true;
[end if]
[else]
[ATTRIBUTE.name] = [GetCSharpDefaultValueOfAttribute([ATTRIBUTE])]; // XXX kell???
[if (HasDefaultValue([ATTRIBUTE]) == "True")]
[else]
[ATTRIBUTE.name]IsNull = true;
[end if]
[end if]
}
else {
[ATTRIBUTE.name] = [GenerateLoadFromXMLExpression("current", [ATTRIBUTE.type])];
}
[end if]
}
[end loop]
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CurrentAssoc -> MAssociationEnd as ENDROLE -> MClass as PartnerClass where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PartnerClass]) == "Entity"))]
[if (HasAssociationClass([CurrentAssoc]) == "")]
[if ([ENDROLE.multiplicity] == "1")]
[if (IsA([PartnerClass], "User") == "True" and IsDefaultonlyAssociation([CurrentAssoc]) == "True")]
if ((current = entityNode.SelectSingleNode(\"./field\[@name='[ConvertRoleToName([ENDROLE])]'\]\")) != null) {
if (current.FirstChild.Name == "default") {
this.Internal[ConvertRoleToName([ENDROLE])] = UserContext.Instance.UserID;
}
else {
throw new InvalidEntityAttributeException("[ENTITY.name]", "[ConvertRoleToName([ENDROLE])]", EntityAttributeError.NotAllowed);
}
}
[else]
if ((current = entityNode.SelectSingleNode(\"./field\[@name='[ConvertRoleToName([ENDROLE])]'\]\")) != null) {
this.Internal[ConvertRoleToName([ENDROLE])] = [GenerateLoadFromXMLExpression("current", "ID")]; // kötelező asszociáció
}
[end if]
[else]
[if ([ENDROLE.multiplicity] == "0..1")]
[if (([STARTROLE.multiplicity] == "1..*") or ([STARTROLE.multiplicity] == "*") or ([STARTROLE.multiplicity] == "0..*"))]
[if (IsA([PartnerClass], "User") == "True" and IsDefaultonlyAssociation([CurrentAssoc]) == "True")]
if ((current = entityNode.SelectSingleNode(\"./field\[@name='[ConvertRoleToName([ENDROLE])]'\]\")) != null) {
if (current.FirstChild.Name == "default") {
this.Internal[ConvertRoleToName([ENDROLE])] = UserContext.Instance.UserID;
}
else {
throw new InvalidEntityAttributeException("[ENTITY.name]", "[ConvertRoleToName([ENDROLE])]", EntityAttributeError.NotAllowed);
}
}
[else]
if ((current = entityNode.SelectSingleNode(\"./field\[@name='[ConvertRoleToName([ENDROLE])]'\]\")) != null) {
if (current.FirstChild.Name == "null") {
this.Internal[ConvertRoleToName([ENDROLE])] = [GetCSharpDefaultValueOfType("ID")];
}
else {
if (current.InnerText != "") {
this.Internal[ConvertRoleToName([ENDROLE])] = [GenerateLoadFromXMLExpression("current", "ID")]; // nem kötelező asszociáció
}
else {
this.Internal[ConvertRoleToName([ENDROLE])] = [GetCSharpDefaultValueOfType("ID")];
}
}
}
[end if]
[end if]
[end if]
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CurrentAssoc -> MAssociationEnd as STARTROLE -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity") )]
[loop (CurrentAssoc -> MAssociationEnd as ENDROLE -> MClass as EndClass where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([EndClass]) == "Entity" ))]
if ((current = entityNode.SelectSingleNode(\"./field\[@name='[ConvertRoleToName([ENDROLE])]'\]\")) != null) {
this.[ConvertRoleToName([ENDROLE])] = [GenerateLoadFromXMLExpression("current", "ID")]; // asszociációs osztályos asszociáció egyik végpontja
}
if ((current = entityNode.SelectSingleNode(\"./field\[@name='[ConvertRoleToName([STARTROLE])]'\]\")) != null) {
this.[ConvertRoleToName([STARTROLE])] = [GenerateLoadFromXMLExpression("current", "ID")]; // asszociációs osztályos asszociáció másik végpontja
}
[end loop]
[end loop]
}
protected override void DoSaveToXml(EntityXMLAdapter adapter) {
base.DoSaveToXml(adapter);
[GenerateEntitySaveAllAttributes([ENTITY], "adapter")]
[GenerateEntitySaveAllAssociations([ENTITY], "adapter")]
}
#endregion
end template
//***************************************************************************//
// Legenerálja azt a kódtöredéket, ami egy adott entitás összes attribútumát //
// XML-be sorosítja. //
//***************************************************************************//
template GenerateEntitySaveAllAttributes(MClass as ENTITY, ADAPTERNAME)
// [GetEntityName([ENTITY])] attribútumai
[loop (ENTITY -> MAttribute as ATTRIBUTE)]
[if ([ATTRIBUTE.type] == "DictionaryItem")]
EntityUtil.WriteDictionaryItemXml([ADAPTERNAME], "[ATTRIBUTE.name]", "[ATTRIBUTE.defaultValue]", m_[ATTRIBUTE.name], m_[ATTRIBUTE.name]IsNull);
[else]
EntityUtil.[GetWriteXmlMethod([ATTRIBUTE.type])]([ADAPTERNAME], "[ATTRIBUTE.name]", m_[ATTRIBUTE.name], m_[ATTRIBUTE.name]IsNull);
[end if]
[/*
[if ([ATTRIBUTE.type] == "ID" or [ATTRIBUTE.type] == "String" or [ATTRIBUTE.type] == "Binary")]
if (m_[ATTRIBUTE.name]IsNull == false) {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], [ATTRIBUTE.name], [ATTRIBUTE.type], "m_" [ATTRIBUTE.name], "")]
}
else {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], [ATTRIBUTE.name], [ATTRIBUTE.type], "(object)null", "")]
}
[else]
[if ([ATTRIBUTE.type] == "DictionaryItem")]
if (m_[ATTRIBUTE.name]IsNull == false) {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], [ATTRIBUTE.name], [ATTRIBUTE.type], "m_" [ATTRIBUTE.name], [ATTRIBUTE.defaultValue])]
}
else {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], [ATTRIBUTE.name], [ATTRIBUTE.type], "(object)null", [ATTRIBUTE.defaultValue])]
}
[else]
if (m_[ATTRIBUTE.name]IsNull == false) {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], [ATTRIBUTE.name], [ATTRIBUTE.type], "m_" [ATTRIBUTE.name], "")]
}
else {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], [ATTRIBUTE.name], [ATTRIBUTE.type], "(object)null", "")]
}
[end if]
[end if]
*/]
[end loop]
end template
//***************************************************************************//
//***************************************************************************//
proc GetWriteXmlMethod(ATTRIBUTETYPE)
switch (ToLower([ATTRIBUTETYPE]))
case "integer": return "WriteIntegerXml";
case "string": return "WriteStringXml";
case "datetime": return "WriteDateTimeXml";
case "boolean": return "WriteBooleanXml";
case "char": return "WriteCharXml";
case "double": return "WriteDoubleXml";
case "float": return "WriteDoubleXml";
case "id": return "WriteIntegerXml";
case "binary": return "WriteBinaryXml";
case "longstring": return "WriteLongStringXml";
end switch
return "/* ERROR: ismeretlen tipus: " [ATTRIBUTETYPE] " */";
end proc
//***************************************************************************//
// Legenerálja azt a kódtöredéket, ami egy adott entitás összes //
// asszociációját XML-be sorosítja. //
//***************************************************************************//
template GenerateEntitySaveAllAssociations(MClass as ENTITY, ADAPTERNAME)
// [GetEntityName([ENTITY])] asszociációi
[loop (ENTITY -> Role as STARTROLE -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as PARTNER where (([STARTROLE.id] != [ENDROLE.id]) and GetStereoType([PARTNER]) == "Entity"))]
[if (HasAssociationClass([CURRENTASSOCIATION]) == "")]
[if ([ENDROLE.multiplicity] == "1" or [ENDROLE.multiplicity] == "0..1")]
EntityUtil.WriteAssociationIdXml([ADAPTERNAME], "[GetRoleName([ENDROLE])]", m_[ConvertRoleToName([ENDROLE])], (m_[ConvertRoleToName([ENDROLE])] == [GetCSharpDefaultValueOfType("ID")]));
[/*
if (m_[ConvertRoleToName([ENDROLE])] != [GetCSharpDefaultValueOfType("ID")]) {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], GetRoleName([ENDROLE]), "AssociationID", "this.m_" ConvertRoleToName([ENDROLE]), "")]
}
else {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], GetRoleName([ENDROLE]), "AssociationID", "(object)null", "")]
}
*/]
[end if]
[end if]
[end loop]
[loop (ENTITY -> MAssociation as CURRENTASSOCIATION -> MAssociationEnd as STARTROLE -> MClass as STARTCLASS where (GetStereoType([STARTCLASS]) == "Entity") )]
[loop (CURRENTASSOCIATION -> MAssociationEnd as ENDROLE -> MClass as ENDCLASS where([STARTROLE.id] < [ENDROLE.id] and GetStereoType([ENDCLASS]) == "Entity" ))]
EntityUtil.WriteAssociationIdXml([ADAPTERNAME], "[GetRoleName([STARTROLE])]", m_[ConvertRoleToName([STARTROLE])], (m_[ConvertRoleToName([STARTROLE])] == [GetCSharpDefaultValueOfType("ID")]));
EntityUtil.WriteAssociationIdXml([ADAPTERNAME], "[GetRoleName([ENDROLE])]", m_[ConvertRoleToName([ENDROLE])], (m_[ConvertRoleToName([ENDROLE])] == [GetCSharpDefaultValueOfType("ID")]));
[/*
if (m_[ConvertRoleToName([STARTROLE])] != [GetCSharpDefaultValueOfType("ID")]) {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], GetRoleName([STARTROLE]), "AssociationID", "this.m_" ConvertRoleToName([STARTROLE]), "")]
}
else {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], GetRoleName([STARTROLE]), "AssociationID", "(object)null", "")]
}
if (m_[ConvertRoleToName([ENDROLE])] != [GetCSharpDefaultValueOfType("ID")]) {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], GetRoleName([ENDROLE]), "AssociationID", "this.m_" ConvertRoleToName([ENDROLE]), "")]
}
else {
[GenerateEntityWrapperSaveToXMLExpression([ADAPTERNAME], GetRoleName([ENDROLE]), "AssociationID", "(object)null", "")]
}
*/]
[end loop]
[end loop]
end template

View file

@ -0,0 +1,204 @@
//***************************************************************************//
// Nulladik típusú asszociációs mezőket gyárt a megadott entitáshoz //
//***************************************************************************//
template GenerateAssociationClassFields(MClass)
[loop (MClass -> MAssociation as CurrentAssoc -> MAssociationEnd as StartRole -> MClass as StartClass where (GetStereoType([StartClass]) == "Entity"))]
[loop (CurrentAssoc -> MAssociationEnd as EndRole -> MClass as EndClass where([StartRole.id] < [EndRole.id] and GetStereoType([EndClass]) == "Entity" ))]
#region [StartClass.name] ([StartRole.multiplicity]) -> [EndClass.name] ([EndRole.multiplicity]) [MClass.name]
public void DeleteBy[DefineRoleName([StartRole])]And[DefineRoleName([EndRole])](int startId, int endId)
{
DeAssociateBeforeDelete();
m_DA.DeleteBy[DefineRoleName([StartRole])]And[DefineRoleName([EndRole])](startId, endId);
}
public void DeleteBy[DefineRoleName([EndRole])]And[DefineRoleName([StartRole])](int startId, int endId)
{
DeAssociateBeforeDelete();
m_DA.DeleteBy[DefineRoleName([StartRole])]And[DefineRoleName([EndRole])](endId, startId);
}
protected internal [GetCSharpType("ID")] m_[ConvertRoleToName([StartRole])];
protected internal [StartClass.name] m_[DefineRoleName([StartRole])] = null;
/// <summary>
/// Csak akkor használhatod, ha pontosan tudod, hogy mit csinál és hogyan, és
/// milyen mellékhatásai lehetnek!
/// </summary>
public [GetCSharpType("ID")] [ConvertRoleToName([StartRole])]
{
get
{
return m_[ConvertRoleToName([StartRole])];
}
set
{
m_[ConvertRoleToName([StartRole])] = value;
FieldModified("[ConvertRoleToName([StartRole])]", value);
}
}
[if (([EndRole.multiplicity] == "0..1") or ([EndRole.multiplicity] == "1"))]
internal void LoadBy[DefineRoleName([StartRole])]([StartClass.name] entity)
{
m_DA.LoadBy[DefineRoleName([StartRole])](entity, this);
}
[end if]
public bool LoadBy[DefineRoleName([StartRole])]([StartClass.name] entity, [EndClass.name] partner)
{
if (m_DA.LoadBy[DefineRoleName([StartRole])](entity, partner, this) == true)
{
SetLoaded();
return true;
}
else
{
return false;
}
}
I[StartClass.name] I[MClass.name].[DefineRoleName([StartRole])]
{
get { return [DefineRoleName([StartRole])]; }
set { [DefineRoleName([StartRole])] = value as [StartClass.name]; }
}
/// <summary>
[if ([CurrentAssoc.description] != "")]
[ConvertDescriptionToCSharpSummary([CurrentAssoc.description])]
[else]
/// Nincs definiálva megjegyzés.
[end if]
/// </summary>
/// <remarks>
/// Az entitás szerepel a(z) '[StartClass.name] ([StartRole.multiplicity]) -> [EndClass.name] ([EndRole.multiplicity])' asszociációban, mint asszociációs osztály.
/// </remarks>
[if ([StartRole.multiplicity] == "1" or [StartRole.multiplicity] == "0..1")]
\[EntityProperty("[DefineRoleName([StartRole])]", EntityPropertyBaseType.Entity, typeof([StartClass.name]), EntityCopyMethod.DeepCopy)\]
[else]
\[EntityProperty("[DefineRoleName([StartRole])]", EntityPropertyBaseType.Entity, typeof([StartClass.name]), EntityCopyMethod.ShallowCopy)\]
[end if]
public [StartClass.name] [DefineRoleName([StartRole])]
{
get
{
if (m_[ConvertRoleToName([StartRole])] == -1)
{
return null;
}
if (m_[DefineRoleName([StartRole])] == null || m_[DefineRoleName([StartRole])].ID != m_[ConvertRoleToName([StartRole])])
{
m_[DefineRoleName([StartRole])] = SDA.[ProjectName].Entities.[StartClass.name].GiveAnInstance();
m_[DefineRoleName([StartRole])].LoadByID(m_[ConvertRoleToName([StartRole])]);
}
return m_[DefineRoleName([StartRole])];
}
set
{
m_[DefineRoleName([StartRole])] = value;
[ConvertRoleToName([StartRole])] = value.ID;
if (this.State != EntityState.New)
{
UpdateAssociations(true);
}
FieldModified("[ConvertRoleToName([StartRole])]", value.ID);
}
}
protected internal [GetCSharpType("ID")] m_[ConvertRoleToName([EndRole])];
protected internal [EndClass.name] m_[DefineRoleName([EndRole])] = null;
/// <summary>
/// Csak akkor használhatod, ha pontosan tudod, hogy mit csinál és hogyan, és
/// milyen mellékhatásai lehetnek!
/// </summary>
public [GetCSharpType("ID")] [ConvertRoleToName([EndRole])]
{
get
{
return this.m_[ConvertRoleToName([EndRole])];
}
set
{
this.m_[ConvertRoleToName([EndRole])] = value;
FieldModified("[ConvertRoleToName([EndRole])]", value);
}
}
[if (([StartRole.multiplicity] == "0..1") or ([StartRole.multiplicity] == "1"))]
internal void LoadBy[DefineRoleName([EndRole])]([EndClass.name] entity)
{
this.m_DA.LoadBy[DefineRoleName([EndRole])](entity, this);
}
[end if]
public bool LoadBy[DefineRoleName([EndRole])]([EndClass.name] entity, [StartClass.name] partner)
{
if (this.m_DA.LoadBy[DefineRoleName([EndRole])](entity, partner, this) == true)
{
this.SetState(EntityState.Initialized);
return true;
}
else
{
return false;
}
}
I[EndClass.name] I[MClass.name].[DefineRoleName([EndRole])]
{
get { return [DefineRoleName([EndRole])]; }
set { [DefineRoleName([EndRole])] = value as [EndClass.name]; }
}
/// <summary>
[if ([CurrentAssoc.description] != "")]
[ConvertDescriptionToCSharpSummary([CurrentAssoc.description])]
[else]
/// Nincs definiálva megjegyzés.
[end if]
/// </summary>
/// <remarks>
/// Az entitás szerepel a(z) '[StartClass.name] ([StartRole.multiplicity]) -> [EndClass.name] ([EndRole.multiplicity])' asszociációban, mint asszociációs osztály.
/// </remarks>
[if ([StartRole.multiplicity] == "1" or [StartRole.multiplicity] == "0..1")]
\[EntityProperty("[DefineRoleName([EndRole])]", EntityPropertyBaseType.Entity, typeof([EndClass.name]), EntityCopyMethod.DeepCopy)\]
[else]
\[EntityProperty("[DefineRoleName([EndRole])]", EntityPropertyBaseType.Entity, typeof([EndClass.name]), EntityCopyMethod.ShallowCopy)\]
[end if]
public [EndClass.name] [DefineRoleName([EndRole])]
{
get
{
if (m_[ConvertRoleToName([EndRole])] == -1)
{
return null;
}
if (m_[DefineRoleName([EndRole])] == null || m_[DefineRoleName([EndRole])].ID != m_[ConvertRoleToName([EndRole])])
{
m_[DefineRoleName([EndRole])] = SDA.[ProjectName].Entities.[EndClass.name].GiveAnInstance();
m_[DefineRoleName([EndRole])].LoadByID(m_[ConvertRoleToName([EndRole])]);
}
return m_[DefineRoleName([EndRole])];
}
set
{
m_[DefineRoleName([EndRole])] = value;
this.[ConvertRoleToName([EndRole])] = value.ID;
if (this.State != EntityState.New)
{
UpdateAssociations(true);
}
FieldModified("[ConvertRoleToName([EndRole])]", value.ID);
}
}
#endregion
[end loop]
[end loop]
end template

View file

@ -0,0 +1,117 @@
proc GenerateViewAttributeLoad(TYPE, VALUE)
switch (ToLower([TYPE]))
case "integer": return "Convert.ToInt32(" [VALUE] ")";
case "string": return "Convert.ToString(" [VALUE] ")";
case "datetime": return "Convert.ToDateTime(" [VALUE] ")";
case "boolean": return "(" [VALUE] ".ToString() == \"T\")";
case "char": return "Convert.ToString(" [VALUE] ")";
case "double": return "Convert.ToDouble(" [VALUE] ")";
case "float": return "Convert.ToDouble(" [VALUE] ")";
case "id": return "Convert.ToInt32(" [VALUE] ")";
case "dictionaryitem": return "Convert.ToInt32(" [VALUE] ")";
case "binary": return "(byte[])(" [VALUE] ")";
case "longstring": return "Convert.ToString(" [VALUE] ")";
end switch
end proc
template GenerateViewBase(MClass as VIEW)
[BOM]using System;
using System.Collections;
using System.Data;
using Kreta.Framework;
namespace SDA.[ProjectName].Entities
{
[GenerateViewCollection([VIEW])]
public class [VIEW.name] : ViewBase
{
[loop (VIEW -> MAttribute as ATTRIBUTE)]
protected [GetCSharpType([ATTRIBUTE.type])] m_[ATTRIBUTE.name] = [GetCSharpDefaultValueOfAttribute([ATTRIBUTE])];
protected bool m_Is[ATTRIBUTE.name]Null = true;
[end loop]
#region Tulajdonságok
[loop (VIEW -> MAttribute as ATTRIBUTE)]
public virtual [GetCSharpType([ATTRIBUTE.type])] [ATTRIBUTE.name]
{
get
{
return m_[ATTRIBUTE.name];
}
}
public virtual bool Is[ATTRIBUTE.name]Null
{
get
{
return m_Is[ATTRIBUTE.name]Null;
}
}
[end loop]
#endregion
#region Betöltés
internal void InternalLoadFromReader([GetCSharpSQLDataReaderType()] reader)
{
LoadFromReader(reader);
}
protected override void LoadFromReader([GetCSharpSQLDataReaderType()] reader)
{
[loop (VIEW -> MAttribute as ATTRIBUTE)]
int [ToLower([ATTRIBUTE.name])]ordinal = reader.GetOrdinal("[ATTRIBUTE.name]");
[end loop]
[loop (VIEW -> MAttribute as ATTRIBUTE)]
if (reader.IsDBNull([ToLower([ATTRIBUTE.name])]ordinal) == false)
{
m_Is[ATTRIBUTE.name]Null = false;
m_[ATTRIBUTE.name] = [GenerateViewAttributeLoad([ATTRIBUTE.type], "reader.GetValue(" ToLower([ATTRIBUTE.name]) "ordinal" ")")];
}
else
{
m_Is[ATTRIBUTE.name]Null = true;
}
[end loop]
}
#endregion
}
}
end template
template GenerateViewCollection(MClass as VIEW)
public class [VIEW.name]Collection : ViewCollectionBase
{
protected override void LoadFromReader([GetCSharpSQLDataReaderType()] reader)
{
while (reader.Read())
{
[VIEW.name] item = new [VIEW.name]();
item.InternalLoadFromReader(reader);
Add(item);
}
}
protected void Add([VIEW.name] item)
{
m_Items.Add(item);
}
public [VIEW.name] this\[int index\]
{
get
{
return ([VIEW.name])m_Items\[index\];
}
}
}
end template

View file

@ -0,0 +1,354 @@
template GenerateBaseClasses()
abstract class MetaElementBase : IMetaDataBase
{
readonly string _id;
readonly Guid _guid;
readonly TagedValueCollection _tagedValues;
public string ID { get { return _id; } }
public Guid GUID { get { return _guid; } }
public TagedValueCollection TagedValues { get { return _tagedValues; } }
public string Name { get; set; }
public string Description { get; set; }
protected MetaElementBase(int id, string guid)
{
_id = id.ToString(CultureInfo.InvariantCulture);
_guid = new Guid(guid);
_tagedValues = new TagedValueCollection();
Name = Description = "";
}
}
sealed class MetaPaletteLink : IMetaPaletteLink
{
public string Name { get; private set; }
public MetaPaletteCollection PartnerPalettes { get; private set; }
public IMetaPalette OwnerPalette { get; private set; }
public IMetaPaletteAssociation Association { get; private set; }
void SelectChildPalettes(IMetaPalette curentPalette)
{
foreach (IMetaPalette child in curentPalette.InheritedMetaPalettes.Values)
{
PartnerPalettes.Add(child.Name, child);
SelectChildPalettes(child);
}
}
public MetaPaletteLink(IMetaPaletteRole targetRole, IMetaPalette ownerPalette)
{
OwnerPalette = ownerPalette;
Association = targetRole.Association;
IMetaPalette endMetaPalette = targetRole.OwnerMetaPalette;
IMetaPalette startMetaPalette = targetRole.Association.AssociatedRoles.Values
.First(startRole => startRole.ID != targetRole.ID)
.OwnerMetaPalette;
// név beállítása
if (startMetaPalette == OwnerPalette) // sima link, megyezik az asszociációval
{
Name = string.IsNullOrEmpty(targetRole.Name) ?
endMetaPalette.Name : // nincs role definiálva
targetRole.Name; // van role definiálva
}
else // ez a link egy asszociációs osztály szemszögéből látja az asszociációt
{
Name = string.IsNullOrEmpty(targetRole.Name) ?
endMetaPalette.Name + OwnerPalette.Name : // nincs role definiálva
targetRole.Name + OwnerPalette.Name; // van role definiálva
}
// elkészítem a partner paletták listáját
PartnerPalettes = new MetaPaletteCollection { { targetRole.OwnerMetaPalette.Name, targetRole.OwnerMetaPalette } };
SelectChildPalettes(targetRole.OwnerMetaPalette);
// normál asszociációs link
if( OwnerPalette != startMetaPalette || Association.AssociationMetaPalette == null )
{
return;
}
PartnerPalettes.Add(Association.AssociationMetaPalette.Name, Association.AssociationMetaPalette);
SelectChildPalettes(Association.AssociationMetaPalette);
}
}
sealed class MetaPalette : MetaElementBase, IMetaPalette
{
public string DBTableName { get; set; }
// ReSharper disable once MemberCanBePrivate.Local
internal string BaseMetaPaletteName { get; set; }
readonly Lazy<IMetaPalette> _baseMetaPalette;
IMetaPalette GetBaseMetaPalette()
{
IMetaPalette baseMetaPalette;
if (BaseMetaPaletteName != null &&
_palettes.TryGetValue(BaseMetaPaletteName, out baseMetaPalette))
{
return baseMetaPalette;
}
return null;
}
public IMetaPalette BaseMetaPalette { get { return BaseMetaPaletteName == null ? null : _baseMetaPalette.Value; } }
// ReSharper disable once MemberCanBePrivate.Local
internal string AssociationID { get; set; }
readonly Lazy<IMetaPaletteAssociation> _association;
IMetaPaletteAssociation GetAssociation()
{
IMetaPaletteAssociation association;
if (AssociationID != null &&
_associations.TryGetValue(AssociationID, out association))
{
return association;
}
return null;
}
public IMetaPaletteAssociation Association { get { return AssociationID == null ? null : _association.Value; } }
readonly Lazy<MetaPaletteCollection> _inheritedMetaPalettes;
MetaPaletteCollection GetInheritedMetaPalettes()
{
var inheritedMetaPalettes = new MetaPaletteCollection();
foreach (IMetaPalette palette in
_palettes.Values
.Where(p => p.BaseMetaPalette == this))
{
inheritedMetaPalettes.Add(palette.Name, palette);
}
return inheritedMetaPalettes;
}
public MetaPaletteCollection InheritedMetaPalettes { get { return _inheritedMetaPalettes.Value; } }
readonly Lazy<MetaPaletteFieldCollection> _fields;
MetaPaletteFieldCollection GetAttributes()
{
var fields = new MetaPaletteFieldCollection();
foreach (IMetaPaletteField field in
_attributes.Values
.Where(f => f.OwnerMetaPalette == this))
{
fields.Add(field.Name, field);
}
return fields;
}
public MetaPaletteFieldCollection Attributes { get { return _fields.Value; } }
readonly Lazy<MetaPaletteFieldCollection> _allFields;
MetaPaletteFieldCollection GetAllAttributes()
{
var allFields = new MetaPaletteFieldCollection();
for (IMetaPalette current = this; current != null; current = current.BaseMetaPalette)
{
foreach (IMetaPaletteField field in current.Attributes.Values)
{
allFields.Add(field.Name, field);
}
}
return allFields;
}
public MetaPaletteFieldCollection AllAttributes { get { return _allFields.Value; } }
readonly Lazy<MetaPaletteLinkCollection> _links;
MetaPaletteLinkCollection GetLinks()
{
var links = new MetaPaletteLinkCollection();
for (IMetaPalette current = this; current != null; current = current.BaseMetaPalette)
{
// ReSharper disable once AccessToModifiedClosure
foreach (MetaPaletteLink mpl in
current.Roles.Values
.Select(startRole => new MetaPaletteLink(
startRole.Association.AssociatedRoles.Values.First(endRole => startRole.ID != endRole.ID),
current)))
{
links.Add(mpl.Name, mpl);
}
if (current.Association == null)
{
continue;
}
// ReSharper disable once AccessToModifiedClosure
foreach (MetaPaletteLink mpl in
current.Association.AssociatedRoles.Values
.Select(role => new MetaPaletteLink(role, current)))
{
links.Add(mpl.Name, mpl);
}
}
return links;
}
public MetaPaletteLinkCollection Links { get { return _links.Value; } }
readonly Lazy<MetaPaletteRoleCollection> _connectedRoles;
MetaPaletteRoleCollection GetRoles()
{
var connectedRoles = new MetaPaletteRoleCollection();
foreach (IMetaPaletteRole role in
_roles.Values
.Where(r => r.OwnerMetaPalette == this))
{
connectedRoles.Add(role.ID, role);
}
return connectedRoles;
}
// ReSharper disable once MemberHidesStaticFromOuterClass
public MetaPaletteRoleCollection Roles { get { return _connectedRoles.Value; } }
public MetaPalette(int id, string guid)
: base(id, guid)
{
_baseMetaPalette = new Lazy<IMetaPalette>(GetBaseMetaPalette);
_association = new Lazy<IMetaPaletteAssociation>(GetAssociation);
_inheritedMetaPalettes = new Lazy<MetaPaletteCollection>(GetInheritedMetaPalettes);
_fields = new Lazy<MetaPaletteFieldCollection>(GetAttributes);
_allFields = new Lazy<MetaPaletteFieldCollection>(GetAllAttributes);
_links = new Lazy<MetaPaletteLinkCollection>(GetLinks);
_connectedRoles = new Lazy<MetaPaletteRoleCollection>(GetRoles);
}
}
sealed class MetaPaletteField : MetaElementBase, IMetaPaletteField
{
public AttributeType Type { get; set; }
public string DBFieldName { get; set; }
// ReSharper disable once MemberCanBePrivate.Local
internal string OwnerMetaPaletteName { get; set; }
readonly Lazy<IMetaPalette> _ownerMetaPalette;
IMetaPalette GetOwnerMetaPalette()
{
IMetaPalette ownerMetaPalette;
if (OwnerMetaPaletteName != null &&
_palettes.TryGetValue(OwnerMetaPaletteName, out ownerMetaPalette))
{
return ownerMetaPalette;
}
return null;
}
public IMetaPalette OwnerMetaPalette { get { return OwnerMetaPaletteName == null ? null : _ownerMetaPalette.Value; } }
public MetaPaletteField(int id, string guid)
: base(id, guid)
{
_ownerMetaPalette = new Lazy<IMetaPalette>(GetOwnerMetaPalette);
}
}
sealed class MetaPaletteRole : MetaElementBase, IMetaPaletteRole
{
public string Multiplicity { get; set; }
// ReSharper disable once MemberCanBePrivate.Local
internal string OwnerMetaPaletteName { get; set; }
readonly Lazy<IMetaPalette> _ownerMetaPalette;
IMetaPalette GetOwnerMetaPalette()
{
IMetaPalette ownerMetaPalette;
if (OwnerMetaPaletteName != null &&
_palettes.TryGetValue(OwnerMetaPaletteName, out ownerMetaPalette))
{
return ownerMetaPalette;
}
return null;
}
public IMetaPalette OwnerMetaPalette { get { return OwnerMetaPaletteName == null ? null : _ownerMetaPalette.Value; } }
// ReSharper disable once MemberCanBePrivate.Local
internal string MetaPaletteAssociationName { get; set; }
readonly Lazy<IMetaPaletteAssociation> _association;
IMetaPaletteAssociation GetAssociation()
{
IMetaPaletteAssociation association;
if (MetaPaletteAssociationName != null &&
_associations.TryGetValue(MetaPaletteAssociationName, out association))
{
return association;
}
return null;
}
public IMetaPaletteAssociation Association { get { return MetaPaletteAssociationName == null ? null : _association.Value; } }
public MetaPaletteRole(int id, string guid)
: base(id, guid)
{
_ownerMetaPalette = new Lazy<IMetaPalette>(GetOwnerMetaPalette);
_association = new Lazy<IMetaPaletteAssociation>(GetAssociation);
}
}
sealed class MetaPaletteAssociation : MetaElementBase, IMetaPaletteAssociation
{
// ReSharper disable once MemberCanBePrivate.Local
internal string AssociationMetaPaletteName { get; set; }
readonly Lazy<IMetaPalette> _associationMetaPalette;
IMetaPalette GetAssociationMetaPalette()
{
IMetaPalette associationMetaPalette;
if (AssociationMetaPaletteName != null &&
_palettes.TryGetValue(AssociationMetaPaletteName, out associationMetaPalette))
{
return associationMetaPalette;
}
return null;
}
public IMetaPalette AssociationMetaPalette { get { return AssociationMetaPaletteName == null ? null : _associationMetaPalette.Value; } }
readonly Lazy<MetaPaletteRoleCollection> _associatedMetaPaletteRoles;
MetaPaletteRoleCollection GetAssociatedRoles()
{
var associatedMetaPaletteRoles = new MetaPaletteRoleCollection();
foreach (IMetaPaletteRole role in
_roles.Values
.Where(r => r.Association == this))
{
associatedMetaPaletteRoles.Add(role.ID, role);
}
return associatedMetaPaletteRoles;
}
public MetaPaletteRoleCollection AssociatedRoles { get { return _associatedMetaPaletteRoles.Value; } }
public MetaPaletteAssociation(int id, string guid)
: base(id, guid)
{
_associationMetaPalette = new Lazy<IMetaPalette>(GetAssociationMetaPalette);
_associatedMetaPaletteRoles = new Lazy<MetaPaletteRoleCollection>(GetAssociatedRoles);
}
}
end template

View file

@ -0,0 +1,250 @@
//***************************************************************************//
// Legenerálja a metamodell teljes forráskódját. //
//***************************************************************************//
template GenerateMetaModel()
[BOM]using System;
using SDA.Framework.MetaPaletteShema;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
namespace SDA.[ProjectName].MetaPaletteShema
{
public sealed class [ProjectName]MetaPaletteStructure : AbstractMetaPaletteStructure
{
#region Base classes
[GenerateBaseClasses()]
#endregion Base classes
#region Static variables
[loop (Instances -> MClass Where( GetStereoType([MClass]) == "Entity" ))]
[GenerateMetaPalette([MClass])]
[GenerateMetaPaletteField([MClass])]
[GenerateMetaPaletteRole([MClass])]
[GenerateMetaPaletteAssociation([MClass])]
[end loop]
static readonly MetaPaletteCollection _palettes = new MetaPaletteCollection();
static readonly MetaPaletteFieldCollection _attributes = new MetaPaletteFieldCollection();
static readonly MetaPaletteRoleCollection _roles = new MetaPaletteRoleCollection();
static readonly MetaPaletteAssociationCollection _associations = new MetaPaletteAssociationCollection();
#endregion Static variables
static [ProjectName]MetaPaletteStructure()
{
IMetaPalette palette;
IMetaPaletteField field;
IMetaPaletteRole role;
IMetaPaletteAssociation association;
foreach (var value in
typeof([ProjectName]MetaPaletteStructure)
.GetFields(BindingFlags.Static|BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.DeclaredOnly)
.Select(f => f.GetValue(null)))
{
if ((palette = value as IMetaPalette) != null)
{
_palettes.Add(palette.Name, palette);
}
if ((field = value as IMetaPaletteField) != null)
{
_attributes.Add(field.ID, field);
}
if ((role = value as IMetaPaletteRole) != null)
{
_roles.Add(role.ID, role);
}
if ((association = value as IMetaPaletteAssociation) != null)
{
_associations.Add(association.ID, association);
}
}
}
#region Abstract members
public override MetaPaletteCollection Palettes { get { return _palettes; } }
public override MetaPaletteFieldCollection Attributes { get { return _attributes; } }
public override MetaPaletteRoleCollection AssociationRoles { get { return _roles; } }
public override MetaPaletteAssociationCollection Associations { get { return _associations; } }
#endregion Abstract members
}
}
end template
//***************************************************************************//
// Egy listat keszit a dictionaryitemekrol //
//***************************************************************************//
template DictionaryItemList()
[loop (Instances -> MClass)]
[if (IsEntity([MClass]) == "True")]
[if (IsProtectedDictionaryItem([MClass]) == "True")]
[GetEntityName([MClass])];[ConvertNameToSQLTableScript(GetEntityName([MClass]))];[IsProtectedDictionaryItem([MClass])];[GetPackage([MClass])]
[end if]
[end if]
[end loop]
end template
template GenerateMetaPalette(MClass)
public static readonly IMetaPalette [MClass.name] = new MetaPalette([MClass.id], "[split([MClass.guid], "_", 1)]")
{
Name = @"[MClass.name]",
[if ([MClass.description]!="")]
Description = "[replace([MClass.description],"\"","\\\"")]",
[end if]
[setVar("hastag", "")]
[loop (MClass -> TaggedValue)]
[if ([hastag]=="")]
TagedValues =
{
[setVar("hastag", "X")]
[end if]
{ @"[TaggedValue.tag]", @"[TaggedValue.value]" },
[end loop]
[if ([hastag]!="")]
},
[end if]
DBTableName = @"[ConvertNameToSQLTableName([MClass.name])]",
[setVar("scn","")]
[loop (MClass -> SuperClass as sc)]
[setVar("scn",[sc.name])]
[end loop]
[if ([scn]!="")]
BaseMetaPaletteName = @"[scn]",
[end if]
[setVar("associd", "")]
[loop (MClass -> MAssociation as assoc )]
[setVar("associd", [assoc.id])]
[end loop]
[if ([associd]!="")]
AssociationID = "[associd]",
[end if]
};
end template
template GenerateMetaPaletteField(MClass)
[loop (MClass -> MAttribute)]
internal static readonly IMetaPaletteField Attribute[MAttribute.id] = new MetaPaletteField([MAttribute.id], "[split([MAttribute.guid], "_", 1)]")
{
OwnerMetaPaletteName = @"[MClass.name]",
Name = @"[MAttribute.name]",
Type = AttributeType.[MAttribute.type],
[if ([MAttribute.description]!="")]
Description = "[replace([MAttribute.description],"\"","\\\"")]",
[end if]
[setVar("hastag", "")]
[loop (MAttribute -> TaggedValue)]
[if ([hastag]=="")]
TagedValues =
{
[setVar("hastag", "X")]
[end if]
{ @"[TaggedValue.tag]", @"[TaggedValue.value]" },
[end loop]
[if ([MAttribute.type]=="DictionaryItem")]
[if ([hastag]=="")]
TagedValues =
{
[setVar("hastag", "X")]
[end if]
{ @"DictionaryItemType", @"[MAttribute.defaultValue]" },
[else]
[if ([MAttribute.defaultValue]!="")]
[if ([hastag]=="")]
TagedValues =
{
[setVar("hastag", "X")]
[end if]
{ @"_DefaultValue_", @"[replace([MAttribute.defaultValue],"\"","\"\"")]" },
[end if]
[end if]
[if (GetStereoTypeForAttribute([MAttribute])=="DisplayName")]
[if ([hastag]=="")]
TagedValues =
{
[setVar("hastag", "X")]
[end if]
{ @"_DisplayName_", @"true" },
[end if]
[if ([hastag]!="")]
},
[end if]
DBFieldName = @"[ConvertNameToSQLColumnName([MAttribute.name])]",
};
[end loop]
end template
template GenerateMetaPaletteRole(MClass)
[loop (MClass -> Role as StartRole -> MAssociation -> MAssociationEnd as EndRole -> MClass as EndClass Where( ( GetStereoType([EndClass]) == "Entity" ) and ( [StartRole.id] != [EndRole.id] ) ))]
internal static readonly IMetaPaletteRole Role[StartRole.id] = new MetaPaletteRole([StartRole.id], "[split([StartRole.guid], "_", 1)]")
{
OwnerMetaPaletteName = @"[MClass.name]",
[if ([StartRole.name]!="")]
Name = @"[StartRole.name]",
[end if]
[if ([StartRole.description]!="")]
Description = "[replace([StartRole.description],"\"","\\\"")]",
[end if]
[setVar("hastag", "")]
[loop (StartRole -> TaggedValue)]
[if ([hastag]=="")]
TagedValues =
{
[setVar("hastag", "X")]
[end if]
{ @"[TaggedValue.tag]", @"[TaggedValue.value]" },
[end loop]
[if ([hastag]!="")]
},
[end if]
Multiplicity = "[StartRole.multiplicity]",
MetaPaletteAssociationName = "[MAssociation.id]",
};
[end loop]
end template
template GenerateMetaPaletteAssociation(MClass)
[loop (MClass -> Role as StartRole -> MAssociation -> MAssociationEnd as EndRole -> MClass as EndClass Where( ( GetStereoType([EndClass]) == "Entity" ) and ( [StartRole.id] < [EndRole.id] ) ) )]
internal static readonly IMetaPaletteAssociation Association[MAssociation.id] = new MetaPaletteAssociation([MAssociation.id], "[split([MAssociation.guid], "_", 1)]")
{
[if ([MAssociation.name]!="")]
Name = @"[MAssociation.name]",
[end if]
[if ([MAssociation.description]!="")]
Description = "[replace([MAssociation.description],"\"","\\\"")]",
[end if]
[setVar("hastag", "")]
[loop (MAssociation -> TaggedValue)]
[if ([hastag]=="")]
TagedValues =
{
[setVar("hastag", "X")]
[end if]
{ @"[TaggedValue.tag]", @"[TaggedValue.value]" },
[end loop]
[if ([hastag]!="")]
},
[end if]
[setVar("assocclassname","")]
[loop (MAssociation -> AssociationClass)]
[setVar("assocclassname",[AssociationClass.name])]
[end loop]
[if ([assocclassname]!="")]
AssociationMetaPaletteName = @"[assocclassname]",
[end if]
};
[end loop]
end template

View file

@ -0,0 +1,211 @@
//***************************************************************************//
// Project fájl
//***************************************************************************//
USES Server/DataAccess/DataAccessProject;
// USES Server/DataAccess/DataAccessInterfaceProject;
//***************************************************************************//
// Entitással kapcsolatos dolgok //
//***************************************************************************//
USES Server/DataAccess/Entity/Entity;
USES Server/DataAccess/Entity/EntityCollection;
USES Server/DataAccess/Entity/General;
USES Server/DataAccess/Entity/Pooling;
USES Server/DataAccess/Entity/Property;
USES Server/DataAccess/Entity/XMLSupport;
USES Server/DataAccess/Entity/Validate;
USES Server/DataAccess/Entity/ZeroTypeAssociation;
USES Server/DataAccess/Entity/EntityTypeAssociation;
USES Server/DataAccess/Entity/EntityCollectionTypeAssociation;
USES Server/DataAccess/Entity/Midas;
USES Server/DataAccess/Entity/EntityState;
//***************************************************************************//
// Entitás Interface -hez tartozó dolgok //
//***************************************************************************//
USES Server/DataAccess/Entity/InterfaceBase;
USES Server/DataAccess/Entity/EntityInterface;
//***************************************************************************//
// Adathozzáférési réteghez (DA) tartozó dolgok //
//***************************************************************************//
USES Server/DataAccess/DataAccessor/EntityDA;
USES Server/DataAccess/DataAccessor/EntityCollectionDA;
USES Server/DataAccess/DataAccessor/LoadByID;
USES Server/DataAccess/DataAccessor/LoadBaseSet;
USES Server/DataAccess/DataAccessor/InsertEntity;
USES Server/DataAccess/DataAccessor/UpdateEntity;
USES Server/DataAccess/DataAccessor/DeleteEntity;
USES Server/DataAccess/DataAccessor/NoWaitForLock;
USES Server/DataAccess/DataAccessor/WaitForLock;
USES Server/DataAccess/DataAccessor/WaitLock;
USES Server/DataAccess/DataAccessor/UpdateAssociations;
USES Server/DataAccess/View/ViewBase;
//USES Server/DataAccess/DAUtil/AllAttributes;
//USES Server/DataAccess/DAUtil/AllAttributesAndAssociationID;
//USES Server/DataAccess/DAUtil/AllAssociationID;
USES Server/DataAccess/DBCommands/LoadCommands;
//***************************************************************************//
// Egyéb segéd dolgok //
//***************************************************************************//
USES Common/Converters;
USES Common/ModelDataRetreive;
USES Common/DAUtil;
USES Common/CommonUtil;
USES Common/StringUtil;
USES Common/CSharpUtil;
USES Common/std;
//***************************************************************************//
// Belépési pont //
//***************************************************************************//
proc main()
Init();
GenerateProjectFile();
GenerateEntities();
GenerateViews();
GenerateDAs();
// GenerateCollections();
// GenerateDirectXMLDAs();
end proc
//***************************************************************************//
// Általános inicializálás //
//***************************************************************************//
proc Init()
// Nyelv
setLanguage("csharp");
setVar("COMMANDCACHE", "False");
setVar("QUERY_MAX_RECORDS", "2000");
// Adatbázis
setVar("DBTYPE", "SDA");
//info = "Application Name: " [ProjectName] "\n";
// Célkönyvtárak
setVar("SOURCE_DIR", [OutputDir]);
setVar("PROJECTFILE_DIR", "/Kreta.DataAccessGenerated");
setVar("INTERFACEPROJECTFILE_DIR", "/Kreta.DataAccessInterfaceGenerated");
setVar("COLLECTION_DIR", "/Kreta.DataAccessGenerated/Collections");
setVar("DATAACCESSOR_DIR", "/Kreta.DataAccessGenerated/DataAccessors");
setVar("ENTITYBEAN_DIR", "/Kreta.DataAccessGenerated/Entities");
setVar("VIEW_DIR", "/Kreta.DataAccessGenerated/View");
// UTF-8 BOM bájtok
setVar("BOM", "\xEF\xBB\xBF");
end proc
//***************************************************************************//
// Legenerálja a project fájlt (DataAccess.csproj) //
// A generálás engedélyezéséhez a GENERATEPROJECTFILE globális változó //
// értékének True -nak kell lennie! //
//***************************************************************************//
proc GenerateProjectFile()
if ([GENERATEPROJECTFILE] == "True")
info = "Generating project file...\t\t\t";
setOutput( [SOURCE_DIR] [PROJECTFILE_DIR] "/" "Kreta.DataAccessGenerated.csproj" );
out = KretaGenerateDataAccessProject();
// setOutput( [SOURCE_DIR] [INTERFACEPROJECTFILE_DIR] "/" "Kreta.DataAccess.Interfaces.csproj" );
// out = KretaGenerateDataAccessIterfaceProject();
info = "DONE.\n";
end if
end proc
//***************************************************************************//
// Legenerálja a dataaccessorokat az összes entitáshoz. //
// A generálás engedélyezéséhez a DATAACCESSOR globális változó értékének //
// True -nak kell lennie! //
//***************************************************************************//
proc GenerateDAs()
if ([DATAACCESSOR] == "True")
info = "Generating DA for MClass...";
loop (Instances -> MClass WHERE GetStereoType([MClass]) == "Entity")
//info = "Generating DA for " [MClass.name] "...\t\t";
setOutput( [SOURCE_DIR] [DATAACCESSOR_DIR] "/" [MClass.name] "DA.cs" );
out = GenerateEntityDA( [MClass] );
//info = "DONE.\n";
end loop
info = "DONE.\n";
end if
end proc
//***************************************************************************//
// Legenerálja a tipizált listákat az összes entitáshoz. //
// A generálás engedélyezéséhez a ENTITYCOLLECTION globális változó //
// értékének True -nak kell lennie! //
//***************************************************************************//
proc GenerateCollections()
if ([ENTITYCOLLECTION] == "True")
// loop (Instances -> MClass WHERE GetStereoType([MClass]) == "Entity")
info = "Generating EntityCollections.cs";
setOutput( [SOURCE_DIR] [COLLECTION_DIR] "/" "EntityCollections.cs" );
// out = GenerateEntityCollection( [MClass] );
out = GenerateEntityCollection();
info = "DONE.\n";
// end loop
end if
end proc
//***************************************************************************//
// Legenerálja az összes entitás forráskódját. (Teszteszabásukkal együtt!) //
// A generálás engedélyezéséhez az ENTITY globális változó értékének True //
// -nak kell lennie! //
//***************************************************************************//
proc GenerateEntities()
if ([ENTITY] == "True")
info = "Generating Entity... ";
setOutput( [SOURCE_DIR] [INTERFACEPROJECTFILE_DIR] "/IEntity.cs" );
out = GenerateIEntityBaseClass();
setOutput( [SOURCE_DIR] [INTERFACEPROJECTFILE_DIR] "/IAssociatedCollection.cs" );
out = GenerateIAssociatedCollection();
loop (Instances -> MClass WHERE GetStereoType([MClass]) == "Entity")
//info = "Generating Entity " [MClass.name] "...\t\t";
setOutput( [SOURCE_DIR] [ENTITYBEAN_DIR] "/" [MClass.name] ".cs" );
out = GenerateEntity( [MClass] );
setOutput( [SOURCE_DIR] [INTERFACEPROJECTFILE_DIR] "/I"[MClass.name] ".cs" );
out = GenerateEntityInterface( [MClass] );
//info = "DONE.\n";
end loop
info = "DONE.\n";
end if
end proc
proc GenerateViews()
if ([ENTITY] == "True" or [VIEW] == "True")
info = "Generating view...";
loop (Instances -> MClass as ENTITY where IsClassView([ENTITY]) == "View")
//info = "Generating view " [ENTITY.name] "...\t\t";
setOutput( [SOURCE_DIR] [VIEW_DIR] "/" [ENTITY.name] ".cs" );
out = GenerateViewBase([ENTITY]);
//info = "DONE.\n";
end loop
info = "DONE.\n";
end if
end proc

View file

@ -0,0 +1,42 @@
//***************************************************************************//
// A MetaModel dolgai //
//***************************************************************************//
USES Server/MetaModel/MetaModelGenerator;
USES Server/MetaModel/BaseClasses;
//***************************************************************************//
// Egyéb segéd dolgok //
//***************************************************************************//
USES Common/std;
USES Common/Converters;
USES Common/ModelDataRetreive;
USES Common/CommonUtil;
USES Common/StringUtil;
USES Common/ActionUtil;
//***************************************************************************//
// Belépési pont //
//***************************************************************************//
proc main()
// initialize the output and other context information
Init();
setOutput( [OutputDir] "/" "DictionaryItems.txt" );
// Ide nem rakom be a BOM-ot, mert elrontja a generálást
// out = [BOM];
out = DictionaryItemList();
end proc
//***************************************************************************//
// Általános inicializálás //
//***************************************************************************//
proc Init()
//current language
setLanguage("SQL");
mkdir([OutputDir]);
// UTF-8 BOM bájtok
setVar("BOM", "\xEF\xBB\xBF");
end proc