|
Letzte
Bearbeitung dieses Dokuments: |
Code
Erklärungen
und Anwendungsbeispiele
Verwandte
Dokumentation
package
js_base.bos;
/*
*
de: Package mit Klassen für den Zugriff auf
Datenbanken.
* en: Package with classes to access
databases. */
import
java.sql.*;
/*
*
de: Package und Klasse für das Ermitteln des
System-Datums.
* en: Package and class to get the
system-date. */
import
java.util.Date;
/*
*
de: Package mit den Klassen für das DBA-
(DataBase-Access-) Object.
* en: Package with the
classes for the DBA- (DataBase-Access-) object. */
import
js_base.dba.*;
/*
*
de: Package mit den Klassen für BO
(Business-Objects) und
allgemeinen Status-Codes.
* en: Package with the
classes for BO (Business-Objects) and common status-codes. */
import
js_base.bo.*;
/*
*
de: Package mit den Klassen für den server-seitigen
Teil
der BO (Business-Objects).
* en: Package with the
classes for the server-side part of BO (Business-Objects). */
import
js_base.bos.*;
/*
*
de:
* JSBS-Package und Klasse mit der
Daten-Struktur mit den minimal notwendigen Parametern.
*
Diese Struktur enthält das Arbeits-Datum des Client-Teils.
*
en:
* JSBS-package and class with the
data-structure containing the minimum set of parameters.
*
This structure contains the working-date of the
client-part. */
import
js_base.structures.JSBS_MinimalParameters;
/**
*
* @author kurt(at)javascout[biz]
* @date
2011-09-27
*
* @description
*
de:
* Server-seitiger Teil des Sets mit Business
Objects für die 'Language' / Sprache.
*
*
Eine Beschreibung der Variablen und des Anwender-bekannten Schlüssels
finden Sie in der
* geerbten Generellen BO-Klasse.
*
*
en:
* Server-Side
Derivation of a set with Business Objects for the 'language'.
*
* For the variables and the user-known key
please refer to the inherited BO-class.
*
* @change-log
*
when who why
*
--------------------------------------------------------
*
*/
public
class JSBS_Language_BOS
extends
JSBS_Language_BO
{
/*
*
VARIABLE / VARIABLES.
* -------------------- */
/*
*
de:
*
Minimales Set von Parameter mit Informationen über Anwender,
Arbeitsplatz
*
und Datum des Client von dem die Datenbank-Operation angefordert
wurde.
*
Verwendet wird der Anwender-Name und das Arbeitsdatum des
Arbeitsplatzes auf
*
dem das Client-Programm ausgeführt wird.
*
Das Datum des Client-Programms kann unterschiedlich zum System-Datum
sein.
*
en:
* Minimal Parameters containing user-, workstation-
and date-information from
* where the request for the
database-operation originated.
* Used is the user-name
and the date the workstation is set to.
* The date of
the workstation might be different of the system-date. */
private
JSBS_MinimalParameters
structJSBS_MinimalParameters
=
null;
/*
*
de:
*
Referenz zur bestehenden Verbindung zur Datenbank.
*
Dieser Werte muss von der aufrufenden Methode als Parameter übergeben
werden
*
wenn diese Klasse 'konstruiert' wird.
*
en:
*
Reference to the established connection to the database.
* This
value has to be passed by the calling method when this class is
constructed. */
private
Connection
structDBCon
=
null;
/*
*
de:
*
Merker ob das Objekt dieser Klasse durch ein BOC (Client-Side-Klasse
eines Business Object)
*
oder durch ein EJB (Enterprise Java Bean) konstruiert wurde.
*
Diese Information wird benötigt wenn ein 'Commit' oder 'Rollback'
ausgeführt werden soll.
*
'Commit' und 'Rollback' werden nur in den Objekten ausgeführt die
direkt von einem BOC oder EJB
*
konstruiert wurden – nicht in Objekten, die von einem anderen BOS
konstruiert wurden.
*
en:
* Flag if
the object of this class was constructed by a BOC (Client-Side-class
of a Business Object)
*
or by an EJB (Enterprise Java Bean).
*
This Information is needed when a 'Commit' or a 'Rollback' has to be
performed.
*
'Commit' and 'Rollback' are only done in objects that were
constructed by BOC or EJB -
*
not in objects that were constructed by another BOS. */
private
boolean bolObjectConstructedByBOC_or_EJB;
/*
*
de:
*
Datenstruktur des DBA-Objektes mit dem die SQL-Kommandos gegen die
Datenbank
*
ausgeführt werden.
*
en:
*
Structure of the DBA object used to perform SQL-commands against the
database. */
private
JSBS_Parameter_DBA
structJSBS_Parameter_DBA
=
new
JSBS_Parameter_DBA();
/*
* --------------------
*
de:
*
CONSTRUCTOR
*
der verwendet wird wenn eine bestehende (und geöffnete!) Verbindung
zur Datenbank
* (Connection) als Parameter übergeben
wird.
*
en:
* CONSTRUCTOR
* when an existing (and
open!) Connection to the database-system is passed. */
public
JSBS_Language_BOS(JSBS_MinimalParameters
parmMinParm,
Connection
parmDBCon) {
/*
*
de:
* Aufrufen der Methode, die das Übernehmen der
Parameter in die Variable dieser
* Klasse ausführt.
*
en:
* Call the method written to do the transfer of the
parameters to the variables
* of this class.
*/
constructionWithDBConnection(parmMinParm,
parmDBCon);
/*
*
de:
* Setzen des Merkers dass das Objekt nicht
von
einem BOC oder EJB konstruiert wurde.
* Überlegung zu
der Entscheidung, den Wert auf 'false' zu setzen – auch wenn das
unlogisch scheinen mag:
*
* + Wenn
dieses BOS-Objekt innerhalb eines anderen BOS konstruiert wird, ist
es zeitsparend und
* und einfacher
verständlich, diese 'Constructor' Methode ohne weiteren Parameter
aufzurufen.
* Mit
dem folgenden Kommando wird jenes Flag gesetzt, das ein zu frühes
Ausführen eines 'commit' oder
* 'rollback'
innerhalb einer Transaktion verhindert.
* + Wenn
dies BOS-Objekt innerhalb eines BOC oder EJB konstruiert wird, dann
ist zu erwarten, dass
* das BOC oder EJB
von einem Design-Pattern (Muster) kopiert wurde.
* In
dem Design-Pattern ist schon der Aufruf des passenden 'Constructors'
mit dieser Variable als
* Parameter
enthalten und damit wird die hier codierte 'Constructor'-Methode
nicht aufgerufen.
*
*
en:
* Set the flag signalling that the object was not
constructed by a BOC or EJB.
*
* Consideration
for the decision to set the value to 'false' – even that seems not
to be logically well-founded:
* + When this
BOS-object is constructed within another BOS it saves time and it is easier
to understand to call this
* method
without a further parameter.
* The
following code sets the flag to prevent a too early 'commit' or
'rollback' within a transaction.
* + If
this BOS was constructed within a BOC or EJB, then it can be
expected, that the constructing BOC
* or
EJB has been copied from a design-pattern.
* This
design-pattern already incorporates the call of the 'fitting'
constructor with this variable
* as
a parameter – therefore this constructor-method is not called.
*/
bolObjectConstructedByBOC_or_EJB
= false;
}
/*
* --------------------
*
de:
* CONSTRUCTOR
* der verwendet wird wenn eine
bestehende (und geöffnete!) Verbindung zur Datenbank
*
(Connection) als Parameter übergeben wird.
*
In den Parametern wird auch übergeben, ob das Objekt dieser Klasse
durch ein BOC oder EJB
*
konstruiert wird.
* en:
* CONSTRUCTOR
*
when an existing (and open!) Connection to the database-system is
passed.
* There is a parameter signalling that this object
is constructed by a BOC or EJB. */
public
JSBS_Language_BOS(JSBS_MinimalParameters
parmMinParm,
Connection
parmDBCon,
boolean
parmObjectConstructedByBOC_or_EJB)
{
/*
*
de: Aufrufen der Methode, die das Kopieren der Parameter ausführt.
*
en: Call the method written to do the copying of the parameters.
*/
constructionWithDBConnection(parmMinParm,
parmDBCon);
/*
*
de: Übernehmen des Werts des Parameters in den Merker.
*
en: Transfer the value from the parameter into the flag.
*/
bolObjectConstructedByBOC_or_EJB
=
parmObjectConstructedByBOC_or_EJB;
}
/*
* --------------------
*
de:
*
CONSTRUCTOR
*
der verwendet wird wenn eine bestehende (und geöffnete!) Verbindung
zur Datenbank
* (Connection) und ein BO der gleichen Klasse
(aus dem die Werte der Variablen übernommen werden)
* als
Parameter übergeben werden.
*
en:
* CONSTRUCTOR
* when an existing (and
open!) Connection to the database-system and a BO of the same class
(which
* values of the variables will be transferred to
this BO) is passed. */
public
JSBS_Language_BOS(JSBS_MinimalParameters
parmMinParm,
Connection
parmDBCon,
JSBS_Language_BO
parmJSBS_Language_BO) {
/*
*
de:
* Aufrufen der Methode, die das Übernehmen der
Parameter in die Variable dieser
* Klasse ausführt.
*
en:
* Call the method written to do the transfer of the
parameters to the variables
* of this class.
*/
constructionWithDBConnection(parmMinParm,
parmDBCon);
/*
*
de:
* Aufrufen der Methode, die das Übernehmen der Werte
der Variablen aus dem als Parameter übergebenen
* Objekt
in die Variablen dieses Objekts ausführt.
*
en:
* Call the method written to do the transfer of the
variable-values of the object passed as parameter
* to the
variables of this object.
*/
copyFromJSBS_Language_BO(parmJSBS_Language_BO);
/*
*
de:
* Setzen des Merkers dass das Objekt nicht
von
einem BOC oder EJB konstruiert wurde.
* Überlegung zu
der Entscheidung, den Wert auf 'false' zu setzen – auch wenn das
unlogisch scheinen mag:
*
* + Wenn
dieses BOS-Objekt innerhalb eines anderen BOS konstruiert wird, ist
es zeitsparend und
* und einfacher
verständlich, diese 'Constructor' Methode ohne weiteren Parameter
aufzurufen.
* Mit
dem folgenden Kommando wird jenes Flag gesetzt, das ein zu frühes
Ausführen eines 'commit' oder
* 'rollback'
innerhalb einer Transaktion verhindert.
* + Wenn
dies BOS-Objekt innerhalb eines BOC oder EJB konstruiert wird, dann
ist zu erwarten, dass
* das BOC oder EJB
von einem Design-Pattern (Muster) kopiert wurde.
* In
dem Design-Pattern ist schon der Aufruf des passenden 'Constructors'
mit dieser Variable als
* Parameter
enthalten und damit wird die hier codierte 'Constructor'-Methode
nicht aufgerufen.
*
*
en:
* Set the flag signalling that the object was not
constructed by a BOC or EJB.
*
* Consideration
for the decision to set the value to 'false' – even that seems not
to be logically well-founded:
* + When this
BOS-object is constructed within another BOS it saves time and it is easier
to understand to call this
* method
without a further parameter.
* The
following code sets the flag to prevent a too early 'commit' or
'rollback' within a transaction.
* + If
this BOS was constructed within a BOC or EJB, then it can be
expected, that the constructing BOC
* or
EJB has been copied from a design-pattern.
* This
design-pattern already incorporates the call of the 'fitting'
constructor with this variable
* as
a parameter – therefore this constructor-method is not called.
*/
bolObjectConstructedByBOC_or_EJB
=
false;
}
/*
* --------------------
*
de:
* CONSTRUCTOR
* der verwendet wird wenn eine
bestehende (und geöffnete!) Verbindung zur Datenbank
*
(Connection) und ein BO der gleichen Klasse (aus dem die Werte der
Variablen übernommen werden)
* als Parameter übergeben
werden.
*
Als zusätzlicher Parameter wird übergeben, ob das Objekt dieser
Klasse durch ein BOC oder EJB
*
konstruiert wird.
* en:
* CONSTRUCTOR
*
when an existing (and open!) Connection to the database-system and a
BO of the same class (which
* values of the variables will
be transferred to this BO) is passed.
* Additionally, there
is a parameter signalling that this object is constructed by a BOC or
EJB. */
public
JSBS_Language_BOS(JSBS_MinimalParameters
parmMinParm,
Connection
parmDBCon,
JSBS_Language_BO
parmJSBS_Language_BO,
boolean
parmObjectConstructedByBOC_or_EJB)
{
/*
*
de: Aufrufen der Methode, die das Kopieren der Parameter ausführt.
*
en: Call the method written to do the copying of the parameters.
*/
constructionWithDBConnection(parmMinParm,
parmDBCon);
/*
*
de:
* Aufrufen der Methode, die das Übernehmen der Werte
der Variablen aus dem als Parameter übergebenen
* Objekt
in die Variablen dieses Objekts ausführt.
*
en:
* Call the method written to do the transfer of the
variable-values of the object passed as parameter
* to the
variables of this object.
*/
copyFromJSBS_Language_BO(parmJSBS_Language_BO);
/*
*
de: Übernehmen des Werts des Parameters in den Merker.
*
en: Transfer the value from the parameter into the flag.
*/
bolObjectConstructedByBOC_or_EJB
=
parmObjectConstructedByBOC_or_EJB;
}
/*
* --------------------
*
de:
*
METHODE zum Kopieren der Werte, die in den Parametern der
'Constructors'
*
übergeben wurden in die Variablen dieses Objekts.
*
en:
* METHOD to copy the values that were passed in the
parameters of the 'constructors'
*
into the variables of this Object. */
private
void
constructionWithDBConnection(
JSBS_MinimalParameters
parmMinParm,
Connection
parmDBConnection) {
structJSBS_MinimalParameters
=
new
JSBS_MinimalParameters(parmMinParm);
structDBCon
=
parmDBConnection;
}
/*
* --------------------
* de:
*
METHODE um die Änderungen, die mit dieser Datenbank-Verbindung
gemacht wurden,
*
als 'gültig' zu markieren (commit).
*
Das 'commit' wird nur ausgeführt, wenn das Objekt durch ein BOC oder
EJB konstruiert
* wurde; d.h. der entsprechende
Parameter im 'Constructor' übergeben wurde.
*
Diese Regel ist eine Konvention damit auch innerhalb eines
BOS-Objekts wieder
*
BOS-Objekte konstruiert werden können. In diesen Objekten wird aber
kein 'commit' oder
*
'rollback' ausgeführt.
*
en:
*
METHOD to 'commit' the changes made with this database-connection.
* The commit is only done if the object was
constructed by a BOC or EJB;
* i.e. the adjacent
parameter was passed in the 'constructor'.
* This rule
is a convention that allows to 'construct' BOS objects within
* BOS-objects. Within these BOS-objects a 'commit' or
'rollback' is not executed. */
private
void commitDBConnection()
{
/*
* de:
* Wenn
dieses BOS-Objekt nicht in einem BOC oder EJB konstruiert wurde, dann
wird diese
* Methode hier beendet weil das commit in
einer 'darüber liegenden' Methode ausgeführt wird.
* en:
* If
this BOS-object has not been constructed in a BOC or EJB, this method
will end here.
* The commit will be performed in a
method 'above'.. */
if
(!
bolObjectConstructedByBOC_or_EJB)
return;
/*
* de:
* 'Commit'
innerhalb einer try/catch-Logik ausführen damit ein eventueller
Fehler beim
* 'commit' abgefangen werden kann.
* en:
* Run the 'commit' within the try/catch-logic to be
able to handle a potential error. */
try
{
/*
* de:
* Prüfen
ob die Verbindung zur Datenbank im 'AutoCommit' Modus geöffnet
wurde. Dann ist ein
* explizites Commit nicht
notwendig.
* Ein Beenden der Methode bei 'autocommit'
verbessert die Performanz.
* en:
* Verify
if the DB-connection was not opened as 'autocommit'.
* In
that case a commit is not needed
* Ending the method
when 'autocommit' was chosen enhances the performance. */
if
(!
structDBCon.getAutoCommit())
structDBCon.commit();
}
catch
(SQLException
SQLExc) {
/*
* de:
* Fehler
im Datenbank-System während des 'commit';
* Fehler an
die aufrufende Methode zurück liefern.
* en:
* Error
of the database-system during 'commit'; report the error to the
calling method. */
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
=
SQLExc.getMessage();
/*
* de: Um
auf der sicheren Seite zu sein zusätzlich ein 'rollback'
ausführen.
* en: To be on the save side: perform a
'rollback'. */
rollbackDBConnection();
}
}
/*
* --------------------
* de:
*
METHODE um die Änderungen, die mit dieser Datenbank-Verbindung
gemacht wurden,
*
'rückgängig' zu machen (rollback); d.h. die Änderungen werden
nicht gültig.
*
Das 'rollback' wird nur ausgeführt, wenn das Objekt durch ein BOC
oder EJB konstruiert
* wurde; d.h. der entsprechende
Parameter im 'Constructor' übergeben wurde.
*
Diese Regel ist eine Konvention damit auch innerhalb eines
BOS-Objekts wieder
*
BOS-Objekte konstruiert werden können. In diesen Objekten wird aber
kein 'commit' oder
*
'rollback' ausgeführt.
*
Generell wäre ein 'rollback' nicht notwendig weil auf ein Set von
Business Objects
*
keine Veränderung ausgeführt wird.
*
Durch Fehler in der Methode die diese Klasse konstruiert kann es aber
vorkommen, dass
*
die 'Connection' zur Datenbank nicht mit 'autocommit' geöffnet wurde
und dann tritt bei
*
verschiedenen DB-Systemen ein Fehler auf wenn kein 'commit' oder
'rollback' ausgeführt
*
wird bevor die 'Connection' zur Datenbank wieder beendet wird.
*
Der Code in dieser Methode ist ein 'Sicherheitsnetz' um den Zugriff
auf die DB auf
*
jeden Fall korrekt zu beenden.
*
en:
*
METHOD to 'rollback' the changes made with this database-connection.
* The rollback is only done if the object was
constructed by a BOC or EJB;
* i.e. the adjacent
parameter was passed in the 'constructor'.
* This rule
is a convention that allows to 'construct' BOS objects within
* BOS-objects. Within these BOS-objects a'commit' or
'rollback' is not executed.
* Generally, a 'rollback'
would not be necessary as there are no changes made
* toward
a set of business objects.
* As a faulty programming
might happen in the method that constructs this class,
* there
might be the 'connection' to the database was not opened with
'autocommit'.
* In that case, an error might be
signalled by some database-systems when the
* 'connection'
to the database ends without a previous 'commit' or
'rollback'.
* The code of this method is a 'safety-net'
to secure a correct end of the
* database-connection
in any case. */
private
void rollbackDBConnection()
{
/*
* de:
* Wenn
dieses BOS-Objekt nicht in einem BOC oder EJB konstruiert wurde, dann
wird diese
* Methode hier beendet.
* en:
* If
this BOS-object has not been constructed in a BOC or EJB, this method
will end here. */
if
(!
bolObjectConstructedByBOC_or_EJB)
return;
/*
* de:
* 'Rollback'
innerhalb einer try/catch-Logik ausführen damit ein eventueller
Fehler beim
* 'Rollback' abgefangen werden kann.
* en:
* Run the 'rollback' within the try/catch-logic to
be
able to handle a potential error. */
try
{
/*
* de:
* Prüfen
ob die Verbindung zur Datenbank im 'AutoCommit' Modus geöffnet
wurde. Dann ist ein
* explizites Commit nicht
notwendig.
* Ein Beenden der Methode bei 'autocommit'
verbessert die Performanz.
* en:
* Verify
if the DB-connection was not opened as 'autocommit'.
* In
that case a commit is not needed
* Ending the method
when 'autocommit' was chosen enhances the performance. */
if
(!
structDBCon.getAutoCommit())
structDBCon.rollback();
}
catch
(SQLException
SQLExc) {
/*
* de:
* Fehler
im Datenbank-System während des 'rollback';
* Fehler
an die aufrufende Methode zurück liefern.
* en:
* Error
of the database-system during 'rollback'; report the error to the
calling method. */
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
=
SQLExc.getMessage();
}
}
/*
* --------------------
* de:
* METHODE
zum Übertragen der Variablen-Werte dieses Business Object auf
die
* Variablen des Data-Base-Acces (DBA) Objekts das
diesem Business Objekt zugeordnet ist.
* en:
* METHOD
to transfer the values of the variables from this Business Object
* to the attributes of the Data-Base-Access (DBA)
Object that is assigned
* to this Business
Object. */
private
void setDBAAttributes(JSBS_Parameter_DBA
parmJSBS_Parameter_DBA) {
/*
* de:
* Methode
der Superklasse (JSBS_BO) aufrufen um die Werte der Allgemeinen
Attribute
* (Common Attributes) zu übertragen.
* en:
* Call the method of the
superclass (JSBS_BO) to transfer the values of the
* Common
Attributes.
*/
setCommonDBAAttributes(parmJSBS_Parameter_DBA);
/*
* de:
Übertragen des Namens der virtuellen Tabelle.
* en:
Transfer the name of the virtual table.
*/
parmJSBS_Parameter_DBA.ParameterName
=
this.CONST_PARAMETER_NAME;
/*
* de:
Übertragen der geschäfts-spezifischen Attribute dieses Business
Object.
* en: Transfer the business specific attributes
of this Business Object. */
parmJSBS_Parameter_DBA.Value01
=
this.ISOLanguageCode;
parmJSBS_Parameter_DBA.Value02
=
this.LanguageCodeForLabelling;
parmJSBS_Parameter_DBA.Value06
=
this.LanguageName;
/*
* de:
* Die Werte für die 20 Marker, die die Sprache für
einzelne 'Themenbereiche'
* (diese sind im
Anwendungsprogramm bestimmt; z.B. Dokumente an Kunden,
* Dokumente
an Zulieferer, GUI des Anwendungsprogramms)
* erlauben,
werden komprimiert in einem Attribut der Datenbank-Tabelle
gespeichert.
* Für das komprimieren wird eine eigenen
Methode aufgerufen.
* en:
* The values
for the 20 Marker (flags), permitting the language for singular
'areas'
* (which are defined within the
application-program; e.g. documents to customers,
* documents
to suppliers, GUI for the application-program) are stored in a
compressed
* string within one attribute of the
database-table. */
parmJSBS_Parameter_DBA.Value03
=
compressMarkerSet();
}
/*
* --------------------
* de:
* METHODE
(nur zur Verwendung innerhalb dieser Klasse) um die
CommonAttributes
* (allgemeine Attribute) aufzubereiten
und dann das DBA-Objekt, das die Daten
* in die
Datenbank einträgt, aufzurufen.
* Der übergebene
Parameter signalisiert, ob dieser der erste Datensatz
eines
* Business Objects ist. In diesem Fall werden
ObjectID, CreatedAt und CreatedBy
* mit Werten
gefüllt.
* en:
* METHOD (just for usage
within this class) to prepare the CommonAttributes and
* then
call the DBA object to insert the data into the database.
* The
passed parameter signals if this is the first dataset of a Business
Object.
* In that case, the ObjectID, CreatedAt and
CreatedBy attributes are filled. */
private
void internalInsert(boolean
parmFirstInsert)
{
/*
* de:
* Die Standard-Werte für zeitliche Gültigkeit des BO
festlegen und die Methode
* aufrufen, die das Einfügen
in die Datenbank erledigt.
* en:
* Get
the values for the (default) time-validity of the BO and call the
method
* which does the real work to insert into the
database.
*/
internalInsert(parmFirstInsert,
JSBS_BO_Services.getNewValidFrom(structJSBS_MinimalParameters),
JSBS_BO_Services.getGoodTillCancelled_SQLDate());
}
/*
* --------------------
* de:
* METHODE
(nur zur Verwendung innerhalb dieser Klasse) um die
CommonAttributes
* (allgemeine Attribute) aufzubereiten
und dann das DBA-Objekt, das die Daten
* in die
Datenbank einträgt, aufzurufen.
* Der übergebene
Parameter signalisiert, ob dieser der erste Datensatz
eines
* Business Objects ist. In diesem Fall werden
ObjectID, CreatedAt und CreatedBy
* mit Werten
gefüllt.
* en:
* METHOD (just for usage
within this class) to prepare the CommonAttributes and
* then
call the DBA object to insert the data into the database.
* The
passed parameter signals if this is the first dataset of a Business
Object.
* In that case, the ObjectID, CreatedAt and
CreatedBy attributes are filled. */
private
void internalInsert(boolean
parmFirstInsert,
java.sql.Date
parmValidFrom,
java.sql.Date
parmValidTill) {
/*
* de:
Zeitliche Gültigkeit des BO aus den Parametern übernehmen.
* en:
Get the time-validity of the BO from the parameters.
*/
ValidFrom
= parmValidFrom;
ValidTill
= parmValidTill;
/*
* de:
* Anwender, der die Änderung ausgeführt hat und die
Systemzeit der Änderung festlegen.
* en:
* Set
the user who made the change and the system-time when the change was
made. */
ChangedBy
= structJSBS_MinimalParameters.strUserName;
ChangedAt
=
new
Timestamp(new
Date().getTime());
/*
* de:
* Ein
Surrogat (interner Schlüssel) für den Datensatz ermitteln und
prüfen,
* ob dieses Surrogat nicht bereits ein
Primärschlüssel in der Datenbank-Tabelle ist.
* Wenn
der Datensatz der erste für ein BO ist, ist das Surrogat auch der
ObjectID des BO.
* en:
* Get a surrogate
for the DataSetID (which is the ObjectID too.
* If it
is the first dataset for a BO) and check if the generated surrogate
is already
* a primary key in the database-table.
*/
int
intTrialCounter
= 9;
do
{
/*
* de:
Methode, die ein Surrogat innerhalb eines großen Wertebereichs
erzeugt, aufrufen.
* en: Call the method that generates
a surrogate within a widespread range. */
DataSetID
=
JSBS_BO_Services.generateSurrogate();
/*
* de:
* Datenbankzugriff ausführen um zu prüfen, ob das
gerade generierte Surrogat bereits
* verwendet
wird.
* en:
* Make a database-access to
check if the just generated surrogate is already used.
*/
boolean
locbolDataSetExists
=
structJSBS_Parameter_DBA.selectByDataSetID(structDBCon,
this.DataSetID);
if
(locbolDataSetExists)
{
/*
* de:
Seltener Fall, dass das generierte Surrogat bereits verwendet wird;
nochmals versuchen.
* en: Rare case that the generated
surrogate is already a key; try again.
*/
intTrialCounter--;
continue;
}
else
{
/*
* de:
Prüfen ob bei der Datenbank-Operation ein Fehler aufgetreten
ist.
* en: Check if there was an error at the database
operation. */
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
> 0) {
/*
* de:
Das DBA-Objekt meldet einen Fehler; Fehler-Meldung in dieses Objekt
übernehmen.
* en: DBA object reports an error;
transfer the Error-Message to this object. */
StatusCode
=
CONST_DB_SYSTEM_ERROR;
StatusMsg
=
structJSBS_Parameter_DBA.ErrorMsg;
return;
}
/*
* de:
* Ein
Datensatz mit dem generierten Surrogat als Primärschlüssel
existiert noch nicht -
* Verarbeitung
fortsetzen.
* Wenn das Business Object das erste Mal in
die Datenbanktabelle aufgenommen wird:
* Werte für
ObjectID, CreatedAt und CreatedBy festlegen.
* en:
* A
dataset with the generated surrogate as primary key does not already
exist -
* continue processing.
* When
the Business Object is inserted for the first time into the
database-table:
* set the values for ObjectID,
CreatedAt and CreatedBy. */
if
(parmFirstInsert)
{
ObjectID
=
DataSetID;
CreatedAt
=
ChangedAt;
CreatedBy
=
ChangedBy;
}
/*
* de:
* Methode zum Eintragen des Datensatzes mit
vollständig aufbereiteten Attributs-Werten
* in die
DB-Tabelle aufrufen.
* en:
* Call the
method to insert a dataset with completly conditioned
attribute-values
* into the database-table.
*/
internalInsert();
/*
* de:
INSERT in die Datenbank-Tabelle abgeschlossen; Methode
beenden.
* en: INSERT into the database-table
completed; end this method. */
return;
}
}
while
(intTrialCounter
> 0);
/*
* de:
* Alle
der 9 generierten Surrogate sind bereits Primärschlüssel in der
Tabelle;
* Datenbank scheinbar voll; Fehler
melden.
* en:
* All of the 9 generated
surrogates were already primary key in the table;
* database
obviously full; report error. */
StatusCode
=
CONST_DB_UNKNOWN_ERROR;
StatusMsg
=
"No
surrogate found after 9 trials; database-table obviously full.";
}
/*
* --------------------
* de:
* METHODE
(nur zur Verwendung innerhalb dieser Klasse) zum Einfügen
eines
* Datensatzes in die Datenbank-Tabelle wenn alle
Attributs-Werte vollständig
* aufbereitet
sind.
* en:
* METHOD (just for usage
within this class) to insert a dataset with completely
* conditioned
attribute-values into the database-table. */
private
void internalInsert()
{
/*
* de:
Übertragen der Werte dieses Business Objects in das
DBA-Objekt.
* en: Transfer the values of this Business
Object to the DBA object.
*/
setDBAAttributes(structJSBS_Parameter_DBA);
/*
* de:
* Methode des DBA Objekts aufrufen und das INSERT in
die Datenbank auf niederer
* Ebene ausführen.
* en:
* Call the method of the DBA object to do the
database
INSERT on the low level.
*/
structJSBS_Parameter_DBA.insert(structDBCon);
/*
* de:
Prüfen ob das INSERT in die Datenbank fehlerfrei war.
* en:
Check if the database INSERT was error-free. */
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
> 0) {
/*
* de:
Fehlermeldung ist nicht leer, Fehler auf dieses Objekt
übertragen.
* en: Error-Message is not empty; transfer
the error to this object. */
StatusCode
=
CONST_DB_SYSTEM_ERROR;
StatusMsg
=
structJSBS_Parameter_DBA.ErrorMsg;
return;
}
/*
* de:
* Fehlermeldung ist leer; d.h. kein Fehler wurde vom
DBA zurück gemeldet.
* Methode beenden.
* en:
* Error-Message is empty; i.e. no error is reported
by
the DBA.
* End this method.
*/
}
/*
* --------------------
* de:
* METHODE
(nur zur Verwendung innerhalb dieser Klasse) um ein DBA Objekt
* mit
den Werten aus diesem Business Object zu füllen und die geänderten
Werte
* auf die Datenbank-Tabelle zu
schreiben.
* Diese Methode ist sehr einfach weil die
Geschäftslogik in der nach
* 'außen sichtbaren'
Methode 'store()' enthalten ist.
* en:
* METHOD
(just for usage within this class) to supply the DBA object with the
* values of this Business Object and write the
changed
values to the database-table
* This method is pretty
simple as the business-logic is contained in the method
* 'store()'
which is 'visible from outside'. */
private
void internalUpdate()
{
/*
* de:
Werte dieses Business Objects auf das DBA Objekt übertragen.
* en:
Transfer the values of this Business Object to the DBA object.
*/
setDBAAttributes(structJSBS_Parameter_DBA);
/*
* de:
* Aufrufen
der Methode des DBA-Objekts und den UPDATE auf der Datenbank
* auf
niederer Ebene ausführen.
* en:
* Call
the method of the DBA object to do the database UPDATE on the low
level.
*/
structJSBS_Parameter_DBA.update(structDBCon);
/*
* de:
Prüfen ob der UPDATE auf der Datenbank fehlerfrei war.
* en:
Check if the database UPDATE was error-free. */
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
> 0) {
/*
* de:
Fehlermeldung des DBA ist nicht leer; Fehler auf dieses Objekt
übertragen.
* en: Error-Message of the DBA is not
empty; transfer the error to this object. */
StatusCode
=
CONST_DB_SYSTEM_ERROR;
StatusMsg
=
structJSBS_Parameter_DBA.ErrorMsg;
}
}
/*
* --------------------
* de:
* METHODE
zum Speichern der Werte in den Variablen dieses Business Object in
der/den
* Datenbank-Tabelle/n; oder technisch
ausgedrückt: Werte 'persistent' machen.
* Diese
Methode ist speziell für den Abgleich von Daten bei einer
MobileClient-Version
* vorgesehen.
* Mit
dieser Methode wird ermöglicht zu prüfen, ob der Primärschlüssel
(DataSetID)
* des auf dem MobileClient einzufügenden
BO bereits auf der Datenbank-Tabelle existiert
* und
wenn nötig kann der DataSetID des bestehenden Datensatzes durch
einen neuen Wert
* ersetzt werden. Das kann notwendig
werden, wenn bei einem MobileClient während des
* asynchronen
Betriebs ein Primärschlüssel generiert wurde der auch auf dem
Server
* generiert wurde. In dieser Methode wird der
Fall geprüft und wenn notwendig wird in
* der Methode
'synchronizedStoreWithPrimaryKeyChange(...)' der Wert für den
DataSetID
* am MobileClient geändert.
* en:
* METHOD to store the values of
the variables from this Business Object
* into the
database-table(s); or in a technical term: make the data
persistent.
* This method is especially written for the
synchronization of data when
* a MobileClient-version
is used.
* This method allows to check if the
primary-key (DataSetID) of the BO to be inserted at
* the
database-table at the MobileClient already exists at the
database-table and,
* if needed, the value of the
DataSetID can be replaced by a new value.
* This might
be necessary when the MobileClient was running asynchronous and a
* primary-key was generated with the same value as a
primary-key on the server.
* Within this method, this
case is checked and, if needed, the DataSetID at
* the
MobileClient will be replaced within the method
* 'synchronizedStoreWithPrimaryKeyChange(...)'.
*/
public
synchronized void synchronizedStore(double
parmDataSetIDToSelect)
{
/*
* de:
Status-Variablen auf 'OK' setzen.
* en: Set the
Status-variables to a state of 'OK'. */
this.StatusCode
=
CONST_OK;
this.StatusMsg
=
"";
/*
* de:
* Prüfen ob der Primärschlüssel (DataSetID)
geändert werden soll und in diesem Fall
* die dafür
vorgesehene Methode aufrufen.
* en:
* Verify
if the primary-key (DataSetID) has to be changed and call the
provided
* method in that case. */
if
((parmDataSetIDToSelect
!= 0) && (this.DataSetID
!=
parmDataSetIDToSelect))
{
synchronizedStoreWithPrimaryKeyChange(parmDataSetIDToSelect);
return;
}
/*
* de:
* Ein
eigenes BOS erstellen und damit prüfen, ob bereits ein Datensatz mit
gleichem Primärschlüssel
* existiert. Ein eigenes
BOS ist notwendig weil sonst beim Lesen die Werte in diesem
BOS
* überschrieben würden
* en:
* Create
an own BOS and use it to verify, if a dataset with the same
primary-key already
* exists. An own BOS is needes as
otherwise the values within this BOS would be overwritten.
*/
JSBS_Language_BOS
existingJSBS_Language_BOS =
new
JSBS_Language_BOS(structJSBS_MinimalParameters,
structDBCon,
false);
existingJSBS_Language_BOS.selectByDataSetID(this.DataSetID);
/*
* de:
* Abhängig davon, ob bereits ein Datensatz mit
gleichem Primärschlüssel existiert
* diesen Ändern
oder einen neuen Datensatz einfügen.
* en:
* Depending on an existing dataset with the same
primary-key, change this dataset
* or insert a new
dataset. */
switch
(existingJSBS_Language_BOS.StatusCode)
{
case
JSBS_BO.CONST_OK:
/*
de: BO mit gesuchtem DataSetID gefunden; dieses BO verändern.
*
en: BO with requested DataSetID found; change this BO. */
internalUpdate();
break;
case
JSBS_BO.CONST_NOT_FOUND:
/*
de: BO mit gesuchtem DataSetID nicht gefunden; dieses BO in die
Datenbank einfügen.
* en: BO with requested DataSetID not
found; insert this BO into the database. */
internalInsert();
break;
default:
/*
* de:
Datenbankfehler aufgetreten; diese Methode nicht fortsetzen.
* en:
Database-Error happened; do not go on with this method.
*/
StatusCode
=
existingJSBS_Language_BOS.StatusCode;
StatusMsg
=
existingJSBS_Language_BOS.StatusMsg;
rollbackDBConnection();
return;
}
/*
* de:
Einfügen oder Ändern auf der Datenbank fehlerfrei.
* en:
Insert or Update on the database without an error.
*/
commitDBConnection();
}
/*
* --------------------
* de:
* METHODE
zum Speichern der Werte in den Variablen dieses Business Object in
der/den
* Datenbank-Tabelle/n wobei auch der
Primärschlüssel (DataSetID) geändert wird.
* Diese
Methode ist speziell für den Abgleich von Daten bei einer
MobileClient-Version
* vorgesehen.
* Diese
Methode ist notwendig, wenn bei einem MobileClient während des
asynchronen
* Betriebs ein Primärschlüssel
generiert wurde der auch auf dem Server generiert wurde.
* In
diesem Fall muss auf dem MobileClient der Primärschlüssel
(DataSetID) geändert
* werden bevor der Datensatz
vom MobileClient auf den Server (oder umgekehrt)
* kopiert
wird.
* Diese Methode prüft, ob der neue
Primärschlüssel noch nicht verwendet wird.
* Falls
auch der neue Primärschlüssel bereits verwendet wird, wird die
Methode
* 'changePrimaryKey()' - in der der
Primärschlüssel geändert wird - aufgerufen.
* en:
* METHOD
to store the values of the variables from this Business Object
* into the database-table(s)with a change of the
primary-key (DataSetID).
* This method is especially
written for the synchronization of data when
* a
MobileClient-version is used.
* This method is needed
when during the asynchronous operation of a MobileClient
* a
primary-key was generated at the MobileClient and the same value was
generated
* at the server.
* At that
case, the primary-key (DataSetID) at the MobileClient has to be
changed
* before the dataset ist copied from the
MobileClient to the server or vice-versa.
* This method
verifies if the new primary-key is not already used.
* If
a dataset with the new primary-key already exists, the primary-key is
changed
* again by calling the method
'changePrimaryKey()'. */
private
synchronized void synchronizedStoreWithPrimaryKeyChange(double
parmDataSetIDToSelect)
{
/*
* de:
* Ein
eigenes BOS erstellen und damit prüfen, ob bereits ein Datensatz mit
gleichem Primärschlüssel
* existiert. Ein eigenes
BOS ist notwendig weil sonst beim Lesen die Werte in diesem
BOS
* überschrieben würden
* en:
* Create
an own BOS and use it to verify, if a dataset with the same
primary-key already
* exists. An own BOS is needes as
otherwise the values within this BOS would be overwritten.
*/
JSBS_Language_BOS
existingJSBS_Language_BOS =
new
JSBS_Language_BOS(structJSBS_MinimalParameters,
structDBCon,
false);
/*
* de:
* 'Ewige' for-Schleife zum Prüfen ob der neue
Primärschlüssel (this.DataSetID) noch nicht
* bei
einem Datensatz existiert bzw. Ändern des Primärschlüssels bei dem
Datensatz, der
*den überprüften Primärschlüssel
verwendet.
* en:
* 'Eternal' for-loop to
verify if the new primary-key (this.DataSetID) does not exist
* on
another dataset. Otherwise change the primary-key at the dataset that
uses the
* primary-key the check was for..
*/
for
(;;)
{
/*
* de:
Mit der Abfrage prüfen, ob der Primärschlüssel schon verwendet
wird.
* en: Verify if the primary-key is already used.
*/
existingJSBS_Language_BOS.selectByDataSetID(this.DataSetID);
/*
* de:
* Abhängig davon, ob bereits ein Datensatz mit dem
Primärschlüssel existiert oder nicht,
* wird die
weitere Verarbeitung gesteuert.
* en:
* Depending if a dataset with the primary-key already exists
or not, the further processing
* is controlled. */
switch
(existingJSBS_Language_BOS.StatusCode)
{
case
JSBS_BO.CONST_NOT_FOUND:
/*
de:
* Datensatz mit dem gleichen Primärschlüssel existiert nicht.
* Übertragen der Werte der Variablen dieses BO auf die
Attribute des DBA-Objektes.
*
en:
* Dataset with the same primary-key does not exist.
* Transfer the values of the variables of this BO to the
attributes of the DBA-object. */
setDBAAttributes(structJSBS_Parameter_DBA);
/*
de:
* Aufrufen der Methode, die das SQL-UPDATE in der
Datenbank-Tabelle ausführt.
*
en:
* Call the method that performs the SQL-UPDATE in the
database-table. */
structJSBS_Parameter_DBA.update(structDBCon,
parmDataSetIDToSelect);
/*
de:
* Prüfen, ob bei der Datenbank-Operation ein Fehler
aufgetreten ist.
*
en:
* Verify if an error occured at the database operation. */
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
> 0) {
/*
* de:
* DBA-Objekt meldet einen Fehler;
* Status-Code setzen und Fehlermeldung aus dem
DBA-Objekt übernehmen.
* en:
* DBA-object reports an error;
* set the status-code and transfer the error-message from the
DBA-object.
*/
StatusCode
=
CONST_DB_SYSTEM_ERROR;
StatusMsg
= structJSBS_Parameter_DBA.ErrorMsg;
}
/*
de:
* UPDATE abgeschlossen, Methode beenden.
*
en:
* UPDATE done; end the Method. */
return;
/*
de:
* Seltener Fall, dass am MobileClient ein Datensatz mit einem
Primärschlüssel
* (DataSetID) existiert der gleich ist wie der eines anderen
BO am Server.
* Austauschen des Wertes des DataSetID am BO auf dem
MobileClient (dieses BO).
*
en:
* Rare case that a dataset on the MobileClient has the same
primary-key (DataSetID)
* as another BO alredy on the server.
* Exchange the value of the DataSetID of the BO of
the MobileClient (this BO). */
case
JSBS_BO.CONST_OK:
/*
de: Methode aufrufen die die Änderung des DataSetID-Wertes vornimmt.
* en: Call the method that performs the changing of the value
of the DataSetID. */
existingJSBS_Language_BOS.changePrimaryKey();
/*
de:
* Prüfen ob in der aufgerufenen Methode ein Fehler
aufgetreten ist.
* In diesem Fall den Status übernehmen und diese Methode
beenden.
* en:
* Verify if an error occured within the called method.
* In that case transfer the status and end this method. */
if (existingJSBS_Language_BOS.StatusCode != JSBS_BO.CONST_OK) {
StatusCode
=
existingJSBS_Language_BOS.StatusCode;
StatusMsg
=
existingJSBS_Language_BOS.StatusMsg;
return;
}
break;
default:
/*
* de:
Datenbankfehler aufgetreten; diese Methode nicht fortsetzen.
* en:
Database-Error happened; do not go on with this method.
*/
StatusCode
=
existingJSBS_Language_BOS.StatusCode;
StatusMsg
=
existingJSBS_Language_BOS.StatusMsg;
return;
}
}
}
/* ---------------------
* de:
* METHODE
zum Ändern des Primärschlüssels
(DataSetID) bei einem bestehenden Datensatz.
* Dieser sehr
seltene Fall kann nur dann eintreten wenn gleichzeitig auf dem
mobilen Client
* und dem Server der gleiche
Primärschlüssel für verschiedene Business-Objects vergeben wurde.
* Dann muss auf der Datenbank des mobilen
Clients der Primärschlüssel
geändert werden.
* en:
*
METHOD to change the primary-key (DataSetID) at an existing dataset.
*
This very rare case might happen if simultaneously the same primary-key
was given to
*
different BO on the MobileClient and at the server. So the primary-key
has to bechanged
*
on the database of the MobileClient. */
protected
synchronized void changePrimaryKey()
{
/*
* de:
*
Aufheben des bestehenden Primärschlüssels um später
den zu ändernden Datensatz wieder
* von der Datenbank lesen
zu können.
* en:
*
Keep the existing primary key to be able to reread the dataset to be
changed from
*
the database again later.
*/
double dblOriginalDataSetID
= this.DataSetID;
/*
* de:
* Holen
eines Surrogates (künstlicher Schlüssel) über die entsprechende
Methode
* und Prüfen, ob das Surrogat bereits als Wert
für einen 'DataSetID' verwendet wurde.
* Dabei werden
maximal 9 Versuche durchgeführt einen 'ungebrauchten' Wert zu
finden.
* en:
*
Get a surrogate with the adjacent method and verify if the surrogate is
already
*
used as value for a 'DataSetID'. A maximum of 9 trials are done to find
an
*
'unused' value.
*/
int
intTrialCounter = 9;
do
{
/* de:
* Methode,
die eine weit gestreute Zufallszahl liefert, aufrufen.
* en:
*
Call the method that generates a random number in a widesoread range.
*/
DataSetID
= JSBS_BO_Services.generateSurrogate();
/* de:
* Datenbankzugriff
zum Prüfen ob dieses Surrogat bereits als Primärschlüssel benutzt wird.
* en:
*
Database-access to check if this surrogate is already used as a
primary-key.
*/
boolean
locbolDataSetExists
=
structJSBS_Parameter_DBA.selectByDataSetID(structDBCon,
this.DataSetID);
/* de:
* Prüfen
ob der seltene Fall eingetreten ist, dass das Surrogat bereits
verwendet wird.
* en:
*
Check for the rare case that this surrogate is already in use.
*/
if
(locbolDataSetExists) {
/* de:
* Reduzieren
des Zählers der noch durchzuführenden Versuche und
* wieder
am Anfang der Schleife beginnen.
* en:
*
Reduce the counter for the remaining trials and start at the begin of
the loop.
*/
intTrialCounter--;
continue;
}
else
{
/* de:
* Vor
dem weiterarbeiten prüfen ob nicht ein Fehler beim DB-Zugriff
aufgetreten ist.
* Ein Fehler wird durch eine nicht
leere Error-Message signalisiert.
* en:
* Check if an error occured at the access to the
database before processing is continued.
* An error is signalled by a non-empty
error-message. */
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
> 0) {
/* de:
* DBA-Objekt
meldet einen Fehler.
* Status-Code setzen und
Fehler-Meldung aus dem DBA-Objekt übernehmen.
* en:
* DBA-object reports an error.
* Set the status-code an transfer the error-message from the
DBA-object.
*/
StatusCode
= CONST_DB_SYSTEM_ERROR;
StatusMsg
= structJSBS_Parameter_DBA.ErrorMsg;
/* de: Verarbeitung
abbrechen.
* en: End the processing.
*/
return;
}
/* de:
* DBA-Objekt
mit generiertem Surrogat existiert noch nicht.
* Für
dieses BO ein UPDATE auf der Datenbank ausführen.
* en:
* DBA-object with the generated surrogate does not already
exist.
* Perform an update on the database for this BO.
*/
setDBAAttributes(structJSBS_Parameter_DBA);
/* de:
* Aufrufen
der Methode die das SQL-UPDATE in der DB-Tabelle ausführt.
* en:
* Call the method that performs the SQL-UPDATE on the
database-table.
*/
structJSBS_Parameter_DBA.update(structDBCon,
dblOriginalDataSetID);
/*
* de:
* Prüfen
ob bei der DB-Operation ein Fehler aufgetreten ist.
* en:
* Check if an error occured during the database-operation.
*/
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
> 0) {
/* de:
* DBA-Objekt
meldet einen Fehler.
* Status-Code setzen und
Fehler-Meldung aus dem DBA-Objekt übernehmen.
* en:
* DBA-object reports an error.
* Set the status-code an transfer the error-message from the
DBA-object.
*/
StatusCode
= CONST_DB_SYSTEM_ERROR;
StatusMsg
= structJSBS_Parameter_DBA.ErrorMsg;
}
/* de: UPDATE
abgeschlossen; Methode beenden.
* en: UPDATE done; end the method.
*/
return;
}
}
while
(intTrialCounter >
0);
}
/*
* --------------------
* de:
* METHODE
zum Speichern der Werte in den Variablen dieses Business Object in
der/den
* Datenbank-Tabelle/n; oder technisch
ausgedrückt: Werte 'persistent' machen.
* Innerhalb
der Methode wird entschieden
* ob dieses Objekt neu
ist und ein INSERT der Daten in die DB-Tabelle notwendig ist oder
* ob die geschäfts-spezifischen Werte geändert
wurden und ein UPDATE erforderlich ist.
* en:
* METHOD
to store the values of the variables from this Business Object
* into the database-table(s); or in a technical
term:
make the data persistent.
* Within the method is
decided
* if this object is new and an INSERT into the
db-table is requiered or
* the business-values of the object
were changed and an UPDATE has to be done. */
public synchronized
void store()
{
/*
* de:
* Aufrufen der Methode in der geprüft wird, ob die Daten des BO konsistent sind.
* en:
* Call the method to check the consistency of the data of this BO.
*/
if (! isConsistentData()) return;
/*
* de:
Status-Variablen auf 'OK' (fehlerfrei) setzen.
* en: Set the
Status-variables to a state of 'OK' (error-free). */
this.StatusCode
=
CONST_OK;
this.StatusMsg
=
"";
/*
* de:
Entscheiden ob das Business Object neu erstellt (ObjectID ist 0) oder
verändert wurde.
* en: Decide if the Business Object
is newly created (ObjectID is 0) or updated. */
if
(ObjectID
==
0) {
/*
* de:
* Speichern
eines neuen Objekts angefordert; prüfen, dass ein Datensatz mit
dem
* gleichen Anwender-bekannten-Schlüssel noch nicht
existiert für das aktuelle Datum.
* en:
* Storing
of a new object requested; check that a dataset with the same
User-Known-Key
* does not already exist for the actual
date. */
boolean
locboolDataSetExists
=
structJSBS_Parameter_DBA.selectByUserKnownKey(structDBCon,
structJSBS_MinimalParameters,
this.CONST_PARAMETER_NAME,
this.ISOLanguageCode,
this.LanguageCodeForLabelling);
if
(locboolDataSetExists)
{
/*
* de:
Datensatz mit dem bekannten Schlüssel existiert bereits; 'Fehler'
melden.
* en: Data-Set with the known key already
exists; report 'error'. */
StatusCode
=
CONST_DUPLICATE_KEY;
StatusMsg
=
"";
rollbackDBConnection();
return;
}
else {
/*
* de:
Prüfen ob ein Datenbankfehler aufgetreten ist.
* en:
Check if a database-error occured. */
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
> 0) {
/*
* de:
Datenbankfehler aufgetreten; diese Methode nicht fortsetzen.
* en:
Database-Error happened; do not go on with this method.
*/
StatusCode
=
CONST_DB_SYSTEM_ERROR;
StatusMsg
=
structJSBS_Parameter_DBA.ErrorMsg;
rollbackDBConnection();
return;
}
}
/*
* de:
* Datensatz
mit dem Anwender-bekannten-Schlüssel existiert noch nicht; mit
INSERT fortsetzen.
* Der übergebene Parameter
signalisiert, dass dieses der erste Datensatz mit
dem
* Anwender-bekannten-Schlüssel
ist.
* en:
* Data-Set with the
User-Known-Key does not already exist; go ahead with INSERT.
* The
passed parameter signals that this is the first Data-Set with the
User-Known-Key. */
internalInsert(true);
/*
* de:
Prüfen ob das INSERT fehlerfrei war; sonst Fehlerbehandlung
beginnen.
* en: Verify if the INSERT was ok; otherwise
start error-handling. */
if
(StatusCode
!=
CONST_OK)
{
rollbackDBConnection();
return;
}
}
else
{
/*
* de:
* Die
Änderung eines Wertes einer Geschäfts-relevanten-Variable ist
erfolgt.
* Das Gültigkeitsende
('ValidTill')
des
aktuell gültigen Datensatzes wird auf den Tag vor
* dem
Arbeitsdatum (ein Parameter aus dem minimalen Set der Parameter)
gesetzt.
* Das ist das Zeichen, dass der Datensatz
nicht länger gültig ist.
* Dann wird ein neuer
Datensatz mit dem gleichen ObjectID eingefügt,
* dessen
Gültigkeitsbeginn ('ValidFrom') das aktuelle Arbeitsdatum ist.
*
* en:
* Change of the value of a
business-relevant variable occured.
* The end of the
validity ('ValidTill') of the actually valid dataset is set to the
day
* before the working-date (a parameter from the minimum
set of parameters).
* That is an indication that the datasat
is no longer valid.
* Thereafter, a new dataset with the
same ObjectID and the actual work-date as
* start of the
validity ('ValidFrom'), which is the actual working-date, is inserted
*//*
* de:
* Zuerst wird der aktuell gültige Datensatz
gelesen um zu prüfen, ob ein anderer
* Anwender in der Zwischenzeit eine
Änderung vorgenommen hat.
* Die Änderung könnte zwischen den Zeitpunkten, als der gerade zu speichernde
Datensatz
* gelesen wurde (um die Daten anzuzeigen) und
jetzt, wo die geänderten Daten
* gespeichert werden
sollen, passiert sein.
*
* Zum Lesen des Vergleichs-BOS
wird ein neues BOS 'konstruiert' und dabei die
bestehende
* DB-Connection als Parameter übergeben.
*
* en:
* First, the actually valid dataset is read to verify if another user made a change
* inbetween.
* The change might have happened in the time between the dataset (which changes are to be
* stored now) was read and now, where the changed data has to be stored.
*
* To read the BOS to compare, a new BOS is 'constructed' and the existing DB-Connection
* is passed as a parameter. */
JSBS_Language_BOS
existingJSBS_Language_BOS
=
new JSBS_Language_BOS(structJSBS_MinimalParameters,
structDBCon,
false);
/*
* de:
* Datensatz über den DatasetID lesen; das bringt den Datensatz der vor der Ausführung
* der Änderung gelesen wurde.
* en:
* Read the dataset by the DataSetID; that gets the dataset as it was read before the
* changes were applied.
*/
existingJSBS_Language_BOS.selectByDataSetID(this.DataSetID);/*
* de:
* Mit
der aufgerufenen Methode muß ein Datensatz gefunden werden.
* Wenn
das nicht der Fall ist, dann eine Fehlerbehandlung durchführen.
* en:
* A dataset must be found with the applied method. If none is found an error-handling
* must be done. */
if
(existingJSBS_Language_BOS.StatusCode
!=
CONST_OK)
{/*
* de:
* Datensatz
nicht gefunden oder ein Fehler beim DB-Zugriff ist
aufgetreten.
* Status-Code in dieses Objekt übernehmen
und Fehlermeldung anpassen.
* en:
* Dataset not found or an error occured when accessing the database.
* Transfer the Status-Code into this object and adapt the error-message. */
this.StatusCode
=
existingJSBS_Language_BOS.StatusCode;
this.StatusMsg
=
"Unexpected
Error during re-read:"
+
existingJSBS_Language_BOS.StatusMsg;/*
* de:
* Rollback
ist nicht notwendig - aber in der aufgerufenen Methode ist auch eine
* Prüfung ob die DB-Connection geschlossen werden muss. Anschließend diese
Methode beenden.
* en:
* Rollback would not be neccesary - but in the called method is a check, if the
* DB-Connection has to be closed, too. End this method thereafter
*/
rollbackDBConnection();
return;
}/*
* de:
* Datensatz
gefunden; so sollte es sein. * Zuerst
prüfen ob die Gültigkeit des Datensatzes in der Zwischenzeit
beendet wurde.
* Das weist auf eine Veränderung des BO
hin.
* en:
* Dataset found; that should be the normal case.
* First is a check if the validity ended inbetween. That indicates a change of the BO. */
if
(this.differentValidTill(
existingJSBS_Language_BOS.ValidTill)){/*
* de:
* Anderer
Benutzer hat das BO inzwischen verändert.
* en:
*
Other user changed the BO inbetween. */
this.StatusCode
=
CONST_CHANGED_INBETWEEN;
this.StatusMsg
=
"";/*
* de:
* Rollback
ist nicht notwendig - aber in der aufgerufenen Methode ist auch eine
* Prüfung ob die DB-Connection geschlossen werden muss. Anschließend diese
Methode beenden.
* en:
* Rollback would not be neccesary - but in the called method is a check, if the
* DB-Connection has to be closed, too. End this method thereafter
*/
rollbackDBConnection();
return;
}/*
* de:
* Noch
prüfen ob überhaupt ein Wert einer geschäfts-relevanten Variable
verändert wurde.
* Wenn keine Veränderung erfolgt ist
wird auch kein neuer Datensatz eingefügt.
* en:
* Additionally check if a value of a business-relevant variable was changed.
* If no change happened, a new dataset will not be inserted*/
if
(!
this.isDifferent(existingJSBS_Language_BOS)){/*
* de:
* Keine
Änderung eines Wertes einer geschäftsrelevanten Variable.
* en:
*
No change of a value of a business-relevant variable. */
this.StatusCode
=
CONST_NOTHING_TO_UPDATE;
this.StatusMsg
=
"";/*
* de:
* Rollback
ist nicht notwendig - aber in der aufgerufenen Methode ist auch eine
* Prüfung ob die DB-Connection geschlossen werden muss. Anschließend diese
Methode beenden.
* en:
* Rollback would not be neccesary - but in the called method is a check, if the
* DB-Connection has to be closed, too. End this method thereafter
*/
rollbackDBConnection();
return;
}
/*
* de:
* Gültigkeit
des bestehenden Datensatzes als 'beendet' markieren.
* Das
wird durch einen Tag vor dem aktuellen Arbeitsdatum im Attribut 'ValidTill' indiziert.
* en:
* Mark the validity of the existing dataset as 'ended'.
* This is indicated by one day before the actual working-date in the attribute 'ValidTill'.
*/
existingJSBS_Language_BOS.ValidTill
=
JSBS_BO_Services.getNewValidTill(structJSBS_MinimalParameters);
/*
* de:
* Änderung
des bestehenden Datensatzes auf der DB-Tabelle durchführen.
* en:
* Execute the change of the existing dataset on the database-table. */
existingJSBS_Language_BOS.internalUpdate();/*
* de:
* Prüfen
ob das Update fehlerfrei durchgeführt wurde.
* Wenn
das nicht der Fall ist, dann eine Fehlerbehandlung durchführen.
* en:
* Check if the update endet without an error.
* If that was not the case then do an error-handling.
*/
if
(existingJSBS_Language_BOS.StatusCode
!=
CONST_OK)
{/*
* de:
* Datensatz
nicht gefunden oder ein Fehler beim DB-Zugriff ist
aufgetreten.
* Status-Code in dieses Objekt übernehmen
und Fehlermeldung anpassen.
* en:
* Dataset not found or an error occured during the access to the database.
* Transfer the Status-Code into this object and adapt the error-message. */
this.StatusCode
=
existingJSBS_Language_BOS.StatusCode;
this.StatusMsg
=
"Unexpected
Error during update of existing record: "
+
existingJSBS_Language_BOS.StatusMsg;/*
* de:
* Rollback
ausführen; in der aufgerufenen Methode wird (wenn notwendig) die DB-Connection
geschlossen.
* Anschließend Methode beenden.
* en:
* Perform a rollback; the DB-connection is closed (if needed) within the called method.
* End the method thereafter.
*/
rollbackDBConnection();
return;
}
/*
* de:
* Als letzte Datenbank-Operation einen neuen Datensatz mit den aktuellen Werten in die
* Datenbank-Tabelle einfügen. Der Parameter (false) teilt der Methode mit, dass der
* Datensatz eine Änderung eines bestehenden BO ist.
* en:
* As last database-operation, insert a new dataset with the actual values into the
* datebase-table. The parameter (false) 'tells' the method, that the inserted dataset
* is a change of an existing BO. */
internalInsert(false);
/*
* de:
Prüfen ob die Datenbank-Operation fehlerfrei war; wenn nicht ein
'rollback' ausführen.
* en: Verify if the
database-operation was error-free; if not do a rollback.
*/
if
(StatusCode
!=
CONST_OK)
{
/*
* de:
* Status für dieses BO wurde in der Methode 'internalInsert(...)' in die passenden Variablen
* übertragen. Rollback einleiten und Methode beenden.
* en:
* Status for this BO was transferred to the associated variables within the method
* 'internalInsert(...)'. Do a rollback and end this method.
*/
rollbackDBConnection();
return;
}
/*
* de:
Alle Datenbank-Operation waren bis jetzt fehlerfrei; Änderungen
bestätigen ('commit').
* en: All database-operations
were error-free till now; commit the changes.
*/
commitDBConnection();
}
}
/*
* --------------------
* de:
* METHODE
zum Selektieren eines speziellen Datensatzes (als Teil eines BO) für einen
* gegebenen DataSetID. Diese Methode wird zum Lesen eines einzigen Datensatzes verwendet.
* Dieser Datensatz ist Teil der Veränderungs-Historie des BO.
* en:
* METHOD to select one specified
dataset (as part of a BO) for a given DataSetID.
* This Method is
used to read a single Dataset. This dataset is a part of the change-history
* of a BO. */
public
synchronized void selectByDataSetID(double parmDataSetID)
{
/*
* de:
Status-Variablen auf 'OK' setzen.
* en: Reset the
Status-variables to a state of OK. */
this.StatusCode
=
JSBS_BO.CONST_OK;
this.StatusMsg
=
"";
/*
* de:
Datenbank-Operation ausführen.
* en: Perform the
database-operation.
*/
if
(structJSBS_Parameter_DBA.selectByDataSetID(structDBCon,
parmDataSetID)) {
/*
* de:
* Datensatz existiert und wurde fehlerfrei gelesen.
* Methode aufrufen die die Werte des
DBA auf das BO überträgt.
* en:
* Dataset exists and reading ended
without
an error.
* Call the method that transfers the values
from the DBA to the BO.
*/
getDBAAttributes(structJSBS_Parameter_DBA);
/*
* de:
* Methode,
die entscheidet ob ein 'Commit' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'commit' is needed, and performing it.
* End
the method thereafter.
*/
commitDBConnection(); return;
}
else
{
/*
* de:
* Kein entsprechender Datensatz gefunden oder ein Fehler ist beim Datenbank-Zugriff aufgetreten.
* Ursache weiter untersuchen.
* en:
* No fitting dataset found or an error occured during the access to the database..
* Investigate further for the cause.
*/
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
< 1) {
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
= "";
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
else
{
/*
* de:
* DBA-Objekt meldet einen Fehler; Status-Code setzen und Fehler-Meldung aus dem
* DBA-Objekt übernehmen.
* en:
* DBA-object reports an error; set the status-code and transfer the error-message
* from the DBA-object.
*/
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
= structJSBS_Parameter_DBA.ErrorMsg;
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
}
}
/*
* --------------------
* de:
* METHODE
zum Selektieren jenes Datensatzes (als Teil eines BO, das durch den Wert in 'parmObjectID'
* eindeutig identifiziert ist) der zum aktuellen Arbeitsdatum gültig ist.
* en:
* METHOD to select the
dataset (as part of a BO which is unique identified by the value in
* 'parmObjectID') which is valid at the actual working-date. */
public
synchronized void selectByObjectID(double parmObjectID)
{
/*
* de:
Status-Variablen auf 'OK' setzen.
* en: Reset the
Status-variables to a state of OK. */
this.StatusCode
=
JSBS_BO.CONST_OK;
this.StatusMsg
=
"";
/*
* de:
Datenbank-Operation ausführen.
* en: Perform the
database-operation.
*/
if
(structJSBS_Parameter_DBA.selectByObjectID(
structDBCon,
structJSBS_MinimalParameters,
parmObjectID)) {
/*
* de:
* Datensatz existiert und wurde fehlerfrei gelesen.
* Methode aufrufen die die Werte des
DBA auf das BO überträgt.
* en:
* Dataset exists and reading ended
without
an error.
* Call the method that transfers the values
from the DBA to the BO.
*/
getDBAAttributes(structJSBS_Parameter_DBA);
/*
* de:
* Methode,
die entscheidet ob ein 'Commit' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'commit' is needed, and performing it.
* End
the method thereafter.
*/
commitDBConnection(); return;
}
else
{
/*
* de:
* Kein entsprechender Datensatz gefunden oder ein Fehler ist beim Datenbank-Zugriff aufgetreten.
* Ursache weiter untersuchen.
* en:
* No fitting dataset found or an error occured during the access to the database..
* Investigate further for the cause.
*/
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
< 1) {
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
= "";
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
else
{
/*
* de:
* DBA-Objekt meldet einen Fehler; Status-Code setzen und Fehler-Meldung aus dem
* DBA-Objekt übernehmen.
* en:
* DBA-object reports an error; set the status-code and transfer the error-message
* from the DBA-object.
*/
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
= structJSBS_Parameter_DBA.ErrorMsg;
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
}
}
/*
* --------------------
* de:
* METHODE
zum Selektieren jenes Datensatzes (als Teil eines BO, das durch die Werte in den
* Parametern eindeutig identifiziert ist) der zum aktuellen Arbeitsdatum gültig ist.
* en:
* METHOD to select the
dataset (as part of a BO which is unique identified by the values in
* the parameters) which is valid at the actual working-date. */
public
synchronized void selectByUserKnownKey(
String parmISOLanguageCode, String parmLanguageCodeForLabelling)
{
/*
* de:
Status-Variablen auf 'OK' setzen.
* en: Reset the
Status-variables to a state of OK. */
this.StatusCode
=
JSBS_BO.CONST_OK;
this.StatusMsg
=
"";
/*
* de:
Datenbank-Operation ausführen.
* en: Perform the
database-operation.
*/
if
(structJSBS_Parameter_DBA.selectByUserKnownKey(
structDBCon,
structJSBS_MinimalParameters, CONST_PARAMETER_NAME,
parmISOLanguageCode, parmLanguageCodeForLabelling)) {
/*
* de:
* Datensatz existiert und wurde fehlerfrei gelesen.
* Methode aufrufen die die Werte des
DBA auf das BO überträgt.
* en:
* Dataset exists and reading ended
without
an error.
* Call the method that transfers the values
from the DBA to the BO.
*/
getDBAAttributes(structJSBS_Parameter_DBA);
/*
* de:
* Methode,
die entscheidet ob ein 'Commit' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'commit' is needed, and performing it.
* End
the method thereafter.
*/
commitDBConnection(); return;
}
else
{
/*
* de:
* Kein entsprechender Datensatz gefunden oder ein Fehler ist beim Datenbank-Zugriff aufgetreten.
* Ursache weiter untersuchen.
* en:
* No fitting dataset found or an error occured during the access to the database.
* Investigate further for the cause.
*/
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
< 1) {
StatusCode
=
JSBS_BO.CONST_NOT_FOUND;
StatusMsg
= "";
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
else
{
/*
* de:
* DBA-Objekt meldet einen Fehler; Status-Code setzen und Fehler-Meldung aus dem
* DBA-Objekt übernehmen.
* en:
* DBA-object reports an error; set the status-code and transfer the error-message
* from the DBA-object.
*/
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
= structJSBS_Parameter_DBA.ErrorMsg;
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
}
}
/*
* --------------------
* de:
* METHODE
zum Selektieren jenes Datensatzes (als Teil eines BO, das in der Sortierreihenfolge
* nach dem BO kommt, das durch die Werte in den Parametern eindeutig identifiziert ist)
* der zum aktuellen Arbeitsdatum gültig ist.
* en:
* METHOD to select the
dataset (as part of a BO, that is in the sort-order after the BO which
* is unique identified by the values in the parameters) which is valid at the actual working-date. */
public
synchronized void selectNext(
String parmISOLanguageCode, String parmLanguageCodeForLabelling)
{
/*
* de:
Status-Variablen auf 'OK' setzen.
* en: Reset the
Status-variables to a state of OK. */
this.StatusCode
=
JSBS_BO.CONST_OK;
this.StatusMsg
=
"";
/*
* de:
Datenbank-Operation ausführen.
* en: Perform the
database-operation.
*/
if
(structJSBS_Parameter_DBA.selectNext(
structDBCon,
structJSBS_MinimalParameters, CONST_PARAMETER_NAME,
parmISOLanguageCode, parmLanguageCodeForLabelling)) {
/*
* de:
* Datensatz existiert und wurde fehlerfrei gelesen.
* Methode aufrufen die die Werte des
DBA auf das BO überträgt.
* en:
* Dataset exists and reading ended
without
an error.
* Call the method that transfers the values
from the DBA to the BO.
*/
getDBAAttributes(structJSBS_Parameter_DBA);
/*
* de:
* Methode,
die entscheidet ob ein 'Commit' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'commit' is needed, and performing it.
* End
the method thereafter.
*/
commitDBConnection(); return;
}
else
{
/*
* de:
* Kein entsprechender Datensatz gefunden oder ein Fehler ist beim Datenbank-Zugriff aufgetreten.
* Ursache weiter untersuchen.
* en:
* No fitting dataset found or an error occured during the access to the database.
* Investigate further for the cause.
*/
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
< 1) {
StatusCode
=
JSBS_BO.CONST_NOT_FOUND;
StatusMsg
= "";
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
else
{
/*
* de:
* DBA-Objekt meldet einen Fehler; Status-Code setzen und Fehler-Meldung aus dem
* DBA-Objekt übernehmen.
* en:
* DBA-object reports an error; set the status-code and transfer the error-message
* from the DBA-object.
*/
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
= structJSBS_Parameter_DBA.ErrorMsg;
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
}
}
/*
* --------------------
* de:
* METHODE
zum Selektieren jenes Datensatzes (als Teil eines BO, das in der Sortierreihenfolge
* vor dem BO kommt, das durch die Werte in den Parametern eindeutig identifiziert ist)
* der zum aktuellen Arbeitsdatum gültig ist.
* en:
* METHOD to select the
dataset (as part of a BO, that is in the sort-order before the BO which
* is unique identified by the values in the parameters) which is valid at the actual working-date. */
public
synchronized void selectPrevious(
String parmISOLanguageCode, String parmLanguageCodeForLabelling)
{
/*
* de:
Status-Variablen auf 'OK' setzen.
* en: Reset the
Status-variables to a state of OK. */
this.StatusCode
=
JSBS_BO.CONST_OK;
this.StatusMsg
=
"";
/*
* de:
Datenbank-Operation ausführen.
* en: Perform the
database-operation.
*/
if
(structJSBS_Parameter_DBA.selectPrevious(
structDBCon,
structJSBS_MinimalParameters, CONST_PARAMETER_NAME,
parmISOLanguageCode, parmLanguageCodeForLabelling)) {
/*
* de:
* Datensatz existiert und wurde fehlerfrei gelesen.
* Methode aufrufen die die Werte des
DBA auf das BO überträgt.
* en:
* Dataset exists and reading ended
without
an error.
* Call the method that transfers the values
from the DBA to the BO.
*/
getDBAAttributes(structJSBS_Parameter_DBA);
/*
* de:
* Methode,
die entscheidet ob ein 'Commit' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'commit' is needed, and performing it.
* End
the method thereafter.
*/
commitDBConnection(); return;
}
else
{
/*
* de:
* Kein entsprechender Datensatz gefunden oder ein Fehler ist beim Datenbank-Zugriff aufgetreten.
* Ursache weiter untersuchen.
* en:
* No fitting dataset found or an error occured during the access to the database..
* Investigate further for the cause.
*/
if
(structJSBS_Parameter_DBA.ErrorMsg.length()
< 1) {
StatusCode
=
JSBS_BO.CONST_NOT_FOUND;
StatusMsg
= "";
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
else
{
/*
* de:
* DBA-Objekt meldet einen Fehler; Status-Code setzen und Fehler-Meldung aus dem
* DBA-Objekt übernehmen.
* en:
* DBA-object reports an error; set the status-code and transfer the error-message
* from the DBA-object.
*/
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
= structJSBS_Parameter_DBA.ErrorMsg;
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist und es wenn
notwendig
* ausführt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed, and performing it,
* and
end the method.
*/
rollbackDBConnection();
return;
}
}
}
/*
* --------------------
* de:
* METHODE
zum 'Deaktivieren' dieses BO.
* 'Deaktivieren' bedeutet,dass die Gültigkeit des aktuell gültigenen Datensatzes und
* eventuell in Zukunft gültiger Datensätze beendet wird.
* Dazu wird in den Datensätzen, deren Wert im Attribut 'ValidTill' (Gültig bis Datum)
* gleich oder größer als das aktuelle Datum (dieses wurde beim 'Konstruieren' dieses
* Objekts als Teil der Struktur 'JSBS_MinimalParameters' übergeben) ist, der Wert in
* 'ValidTill' auf den Tag vor dem aktuellen Tag gesetzt.
* Zur Dokumentation wer (welcher Anwender) zu welcher Systemzeit das 'Deaktivieren'
* ausgeführt hat, wird ein neuer Datensatz eingefügt der mit dem aktuellen Datum beginnt
* und am Tag vor dem aktuellen Datum endet.
* en:
* METHOD
to 'deactivate' this BO.
* 'Deactivate' means, that the validity of the actual valid dataset and datasets
* that are potentially valid in the future will end.
* To achieve that, all datasets with a value in the attribute 'ValidTill' (date) that
* is equal or greater than the actual date (this was passed as a part of the structure
* 'JSBS_MinimalParameters' at the 'construction' of this object), the value of
* 'ValidTill' is set to the date before the actual day.
* To document who (which user) did the 'deactivate' at which system-time, a new dataset,
* which starts with the actual day and ends the day before, is inserted. */
public
synchronized void deactivate() {
/*
* de:
Status-Variablen auf 'OK' setzen.
* en: Reset the
Status-variables to a state of OK. */
this.StatusCode
=
JSBS_BO.CONST_OK;
this.StatusMsg
=
"";
/*
* de:
* Prüfen ob das BO überhaupt deaktiviert werden darf oder ob noch Referenzen darauf
* vorhanden sind.
* Ein eventueller Fehlercode wird in der Methode 'isReferenced' gesetzt.
* en:
* Verify, if this BO is allowed to be deactivated or if there are still references
* to it exist.
* An occured error-code is set within the method 'isReferenced'.
*/
if (isReferenced()) {
/*
* de:
* Das BO darf nicht deaktiviert werden weil es noch von einem anderen BO referenziert
* wird. Status-Code (warum das BO nicht deaktiviert werden darf) und Status-Message
* (üblicherweise der Anwender-Bekannte-Schlüssel des referenzierenden BO) werden in
* der Methode 'isReferenced' mit Werten versorgt.
* Ein Rollback wäre zwar nicht notwendig - in der aufgerufenen Methode wird aber auch
* geprüft, ob die DB-Connection geschlossen werden muss.
* Anschließend die Methode beenden.
* en:
* The BO is not allowed to be deactivated as it is referenced by another BO.
* The status-code (why the BO is not allowed to be deactivated) and the status-message
* (usually the user-known-key of the referencing BO) is set within the method
* 'isReferenced'.
* Rollback would not be needed - but in the called method there is a check if the
* DB-connection has to be closed, too.
* End the method thereafter.
*/
rollbackDBConnection();
return;
}
else
{
/*
* de:
* DBA-Set für den Zugriff auf die Datenbank-Tabelle
'konstruieren'.
* Mit diesem DBA-Set werden alle Datensätze für den ObjectID selektiert.
* en:
* 'Construct' the DBA-set for the
access to the database-table.
* With this DBA-set, all datasets for the ObjectID will be selected.
*/
JSBS_Parameter_DBA_Set structJSBS_Parameter_DBA_Set = new
JSBS_Parameter_DBA_Set();
/*
* de:
Datenbank-Operation ausführen.
* en: Perform the
database-operation.
*/
structJSBS_Parameter_DBA_Set.selectAllByObjectID(structDBCon,
this.ObjectID);
/*
* de:
* Über die Länge des Textes mit einer eventuellen
Fehler-Nachricht prüfen, ob die
* Datenbank-Abfrage mit einem Fehler beendet wurde.
* en:
* Use
the text with a possible error-message to verify if the
database-access endet with
* an error. */
if
(structJSBS_Parameter_DBA_Set.ErrorMsg.length() > 0) {
/*
* de:
* DBA-Set
Objekt meldet einen Fehler.
* Status-Code setzen und
die Fehlermeldung aus dem DBA-Set auf dieses BOS
übernehmen.
* en:
* DBA-set object
reports an error.
* Set the status-code and transfer
the error-message to this BOS.
*/
StatusCode
=
JSBS_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
= structJSBS_Parameter_DBA_Set.ErrorMsg;
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist (und es wenn
notwendig
* ausführt) und wenn notwendig die DB-Connection schließt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed (and performing it if needed) and also
* closing the DB-Connection if needed. End the method thereafter.
*/
rollbackDBConnection();
return;
}/*
* de:
* Kein Fehler beim Datenbank-Zugriff aufgetreten; Set mit den Datensätzen weiter bearbeiten.
* Dazu Hilf-Variablen für die Bearbeitung des Vectors definieren.
* en:
* No error ocurred at the access to the database; continue processing the set with the dataset.
* To do this, define auxilliary variables first.
*/
int intDBA_Set_Size
= structJSBS_Parameter_DBA_Set.vecRecordSet.size();
int intDBA_Set_Index;
/*
*
de:
* Ein BOS definieren dessen Methoden später für das ordnungsgemäße 'Beenden' eines
* Datensatzes verwendet werden können.
* en:
* Define a BOS which methods can be used later for a correct 'termination' of a
* dataset. */
JSBS_Language_BOS structJSBS_Language_BOS =
new JSBS_Language_BOS(structJSBS_MinimalParameters, structDBCon);
/*
*
de:
* Datumswerte, die für Vergleiche gebraucht werden im java.sql.Date Format erstellen
* bzw. Werte in anderen Formaten gleich umwandeln.
* en:
* Define date-values that are needed for comparisons in the java.sql.Date-format or
* convert values in other formats, respectively. */
java.sql.Date dteWorkDate =
new java.sql.Date(structJSBS_MinimalParameters.calWorkDate.getTime().getTime());
java.sql.Date dteReadValidTill;
/*
*
de:
* In einer for-Schleife jeden Datensatz untersuchen und bei Bedarf 'beenden'.
* en:
* Use a for loop to inspect each dataset and 'end' it if needed. */
for
(intDBA_Set_Index
= 0; intDBA_Set_Index < intDBA_Set_Size; intDBA_Set_Index++)
{
/*
*
de:
* Den durch den Index gewählten Datensatz in eine eigene
Variable übertragen.
* Damit kann er leichter
verarbeitet werden.
* en:
* Move
the dataset selected by the index to an own variable.
* This
allows an easier processing. */
structJSBS_Parameter_DBA =
(JSBS_Parameter_DBA)
structJSBS_Parameter_DBA_Set.vecRecordSet.elementAt(intDBA_Set_Index);
/*
*
de:
* Letzten Tag der Gültigkeit ('ValidTill') in eine eigene Variable übertragen.
* Damit wird eine spätere Verarbeitung einfacher.
* en:
* Transfer the last day of validity ('ValidTill') to an own variable.
* That makes later processing easier. */
dteReadValidTill = structJSBS_Parameter_DBA.ValidTill;
/*
*
de:
* Nur jene Datensätze 'deaktivieren' die am oder nach dem aktuellen Arbeits-Datum enden.
* en:
* 'Deactivate' only those datasets that end at or after the actual working-date. */
if
(structJSBS_Parameter_DBA_Set.endsAfterWorkDate(dteWorkDate, dteReadValidTill))
{
/*
*
de:
* Werte des DBA in das vorher 'konstruierte' BOS übernehmen. Grund für die Weiterarbeit mit dem BOS:
* In der BOS-Klasse sind schon alle Methoden implementiert die die Gültigkeit eines BO
* ordnungsgemäß beenden.
*
en:
* Transfer the values of the DBA into the BOS 'constructed' earlier. Reason for using the BOS
* for further processing: The BOS-class has all methods implemented that take care for a correct end of
* the validity of a BO. */
structJSBS_Language_BOS.getDBAAttributes(structJSBS_Parameter_DBA);
/*
*
de:
* Ende der Gültigkeit des Datensatzes in Abhängigkeit vom aktuellen Arbeitsdatum setzen.
*
en:
* Set the value for the end of the validity of the dataset depending on the actual work-date. */
structJSBS_Language_BOS.ValidTill =
JSBS_BO_Services.getNewValidTill(structJSBS_MinimalParameters);
/*
*
de:
* Status-Code initialisieren weil dieser bei einer 'internen' Methode nicht initialisiert wird.
*
en:
* Initialize the status-code as this is not done at an 'internal' method. */
structJSBS_Language_BOS.StatusCode = JSBS_BO.CONST_OK;
/*
*
de:
* Methode zum Ändern des Datensatzes auf der Datenbank-Tabelle aufrufen.
*
en:
* Call the method to change the dataset on the database-table. */
structJSBS_Language_BOS.internalUpdate();
/*
*
de:
* Prüfen, ob beim Update ein Fehler aufgetreten ist.
*
en:
* Check if an error occured at the update. */
if (structJSBS_Language_BOS.StatusCode != JSBS_BO.CONST_OK) {/* * de:
* Fehler-Code und Fehler-Meldung auf dieses BO
übernehmen.
* en:
* DBA-set object
reports an error.
* Transfer the status-code and transfer
the error-message to this BOS.
*/
StatusCode
=
structJSBS_Language_BOS.StatusCode;
StatusMsg
= structJSBS_Language_BOS.StatusMsg;
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist (und es wenn
notwendig
* ausführt) und wenn notwendig die DB-Connection schließt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed (and performing it if needed) and also
* closing the DB-Connection if needed. End the method thereafter.
*/
rollbackDBConnection();
return;
}
/*
*
de:
* Neuen Datensatz mit der Information wer wann das BO 'deaktiviert' hat, einfügen.
*
en:
* Insert a new dataset with the information when the BO was 'deactivated' and who did it. */
structJSBS_Language_BOS.internalInsert(false,
JSBS_BO_Services.getNewValidFrom(structJSBS_MinimalParameters),
JSBS_BO_Services.getNewValidTill(structJSBS_MinimalParameters));
/*
*
de:
* Prüfen, ob beim Insert ein Fehler aufgetreten ist.
*
en:
* Check if an error occured at the update. */
if (structJSBS_Language_BOS.StatusCode != JSBS_BO.CONST_OK) {/* * de:
* Fehler-Code und Fehler-Meldung auf dieses BO
übernehmen.
* en:
* DBA-set object
reports an error.
* Transfer the status-code and transfer
the error-message to this BOS.
*/
StatusCode
=
structJSBS_Language_BOS.StatusCode;
StatusMsg
= structJSBS_Language_BOS.StatusMsg;
/*
* de:
* Methode,
die entscheidet ob ein 'Rollback' auszuführen ist (und es wenn
notwendig
* ausführt) und wenn notwendig die DB-Connection schließt, aufrufen und Methode
beenden.
* en:
* Call the method deciding
if a 'rollback' is needed (and performing it if needed) and also
* closing the DB-Connection if needed. End the method thereafter.
*/
rollbackDBConnection();
return;
}
/*
*
de: Ende des 'if' zum Bearbeiten noch gültiger Datensätze.
*
en: End of the 'if' to process still valid datasets.
*/
}
/*
*
de: Ende der 'for'-Schleife.
*
en: End of the 'for'-loop.
*/
}
/*
* de:
* Änderungen auf der Datenbank ohne Fehler. Methode die das Commit ausführt und wenn
* notwendig die DB-Connection schließt, aufrufen und Methode
beenden.
* en:
* Changes on the database without errors. Call the method that executes the commit and
* also closing the DB-Connection if needed. End the method thereafter.
*/
commitDBConnection();
return;
}
}
/*
* --------------------
* de:
* METHODE
zum Prüfen, ob auf dieses BO in einem anderen BO eine Referenz vorhanden ist.
*
* DIESE METHODE MUSS IN DER KLASSE IHRES ANWENDUNGSPROGRAMMS ÜBERSCHRIEBEN WERDEN !
* Hier in dieser Basisklasse kann der Code noch nicht 'wissen', in welchen BO Ihres
* Anwendungsprogramms die Sprache referenziert wird.
* Deswegen muss in Ihrerm Anwendungsprogramm eine spezifische Klasse implementiert
* werden in der diese Methode ('isReferenced()') um die speziellen Prüfungen auf
* Referenzen für das Datenmodell Ihres Anwendungsprogramms erweitert wird.
*
* Diese Methode dient dazu, zu prüfen, ob das BO 'deaktiviert' werden darf oder nicht.
* Nicht deaktiviert werden darf das BO wenn in einem anderen BO eine Inkonsistenz entstehen
* würde.
*
* en:
* METHOD to verify if a reference to this BO exists in another BO.
*
* THIS METHOD HAS TO BE OVERWRITTEN IN THE CLASS OF YOUR APPLICATION-PROGRAM.
* Within this base-class, the does not 'know' in which BO of your application-program
* the language is referenced.
* Therefore, a specific class has to be implemented within your application-program in
* which this method ('isReferenced()') is extended by specific verifications for the
* references of the data-model of your application.
*
* This method serves the purpose to check, if this BO is allowed to be 'deactivated' or not.
* The deactivation is prohibited if this would lead to an inconsitency in another BO. */
public boolean isReferenced() {
/*
* de:
* Spezielle Prüfung für den Haupt-Eintrag einer Sprache. Dieser ist erkennbar an einer leeren
* Zeichenkette in der Variable 'LanguageCodeForLabelling'.
* Nur für diesen wird die Prüfung auf Referenzierung durchgeführt.
* Alle anderen Einträge definieren nur die Bezeichnung (LanguageName) in einer anderen Sprache
* und können sofort 'deaktiviert' werden.
* en:
* Special verification for the main-entry of a language. This is recognised by an empty string
* in the variable 'LanguageCodeForLabelling'.
* Only for such an entry the verification for a reference is done.
* All other entries just define the LanguageName in another language and can be 'deactivated'
* immediately. */
if (this.LanguageCodeForLabelling.trim().length() > 0) return false;/*
* de:
* Besonderheit bei diesem BO ist, dass der 'Haupt-Eintrag' für eine Sprache nicht deaktiviert
* werden darf wenn dazu noch ein Eintrag für die Bezeichnung in anderer Sprache vorhanden ist.
* Der 'Haupt-Eintrag' ist daran erkennbar, dass der Wert im 'LanguageCodeForLabelling' eine
* leere Zeichenkette ist.
* Der Haupt-Eintrag enthält die Standard-Bezeichnung für die Sprache (im Attribut 'LanguageName')
* und die Marker, für welche Themenbereiche im Anwendungsprogramm die Sprache erlaubt ist.
*
* en:
* Specific feature of this BO is, that the 'main-entry' for a language may not be 'deactivated'
* as long as an entry for the naming of the language in another language exists.
* The 'main-entry' is identified by an emptry string as value in 'LanguageCodeForLabelling'..
* The main-entry contains the default naming of the language (in the attribute 'LanguageName')
* and the Marker, for which areas in the application-program this language is permitted. */
/*
*
de:
* Ein BOS-Set definieren dessen Methoden für das Abfragen weiterer Datensätze verwendet wird.
* en:
* Define a BOS-Set which methods are used to select further datasets. */
JSBS_Language_BOS_Set structreferencingJSBS_Language_BOS_Set =
new JSBS_Language_BOS_Set(structJSBS_MinimalParameters, structDBCon);
/*
*
de:
* Abfragen aller aktuell oder in Zukunft gültigen Datensätze mit dem gleichen Sprach-Code wie
* dieses BO.
* en:
* Select all datasets with the same language-code as this BO that are valid now or in the future. */
structreferencingJSBS_Language_BOS_Set.selectValidAndFutureByISOLanguageCode(
this.ISOLanguageCode);
/*
* de:
* Abfragen ob die Datenbank-Operation fehlerfrei war und abhängig davon
* die weitere Verarbeitung vornehmen.
* en:
* Check if the database-operation endet without an error and depending
* on that continue processing. */
switch
(structreferencingJSBS_Language_BOS_Set.StatusCode)
{
case
JSBS_BO.CONST_OK:
/*
de:
* BO mit gesuchtem ISOLanguageCode gefunden.
* Weiter prüfen, ob nur ein Datensatz (der hier bearbeitete) oder mehrere gefunden wurden.
*
en:
* BO with requested ISOLanguageCode found.
* Continue with a check if only one dataset (the one processed here) or several were found. */
if (structreferencingJSBS_Language_BOS_Set.vecRecordSet.size() > 1) {
/*
de:
* Neben dem gerade bearbeiteten BO für den Haupteintrag existiert noch ein weiterer Datensatz.
* Bedingt durch die Abfrage muss das ein Datensatz für die Bezeichnung in einer weiteren
* Sprache sein. Status-Code setzen; dieser ist in der geerbten BO-Klasse definiert.
*
en:
* Additionally to the just processed BO for the main-entry another dataset exists.
* Conditioned by the selection, this must be a dataset for the naming in another language.
* Set the Status-Code; the value is defined within the inherited BO-class. */
StatusCode
= JSBS_Language_BO.CONST_DEACTIVATE_INHIBIT_REASON_AdditionalLanguageLabelling;/*
* de:
* Zur Information des Anwenders den Sprach-Code für die Bezeichnung aus dem
* zweiten BO der Liste extrahieren und in der Fehlermeldung zurück liefern.
* en:
* For an information of the user, extract the language-code for the labelling
* of the language from the second BO within the list und return it in the
* error-message.
*/
JSBS_Language_BO structreferencingJSBS_Language_BO =
(JSBS_Language_BO) structreferencingJSBS_Language_BOS_Set.vecRecordSet.elementAt(1);
StatusMsg
= structreferencingJSBS_Language_BO.LanguageCodeForLabelling;
return true;
}
break;
case
JSBS_BO.CONST_NOT_FOUND:
/*
de:
* Sollte nicht vorkommen weil zumindest der gerade bearbeitet Datensatz gefunden
* werden sollte. Trotzdem nicht abbrechen.
* en:
* Should not happen as at least the just processed dataset should be found.
* Do not end the method however. */
break;
default:
/*
* de:
Datenbankfehler aufgetreten; diese Methode nicht fortsetzen.
* en:
Database-Error happened; do not go on with this method.
*/
StatusCode
= structreferencingJSBS_Language_BOS_Set.StatusCode;
StatusMsg
=
structreferencingJSBS_Language_BOS_Set.StatusMsg;
return true;
}/* ********************
* de:
* Prüfen, ob diese Sprache als Bezeichnungssprache für ein Land (Country) verwendet wird.
* Dazu ein BOS-Set für die Prüfung auf Fremdschlüsselreferenz definieren.
* en:
* Verify, if this language is used als labelling language for a country.
* To do this define a BOS-Set for the verification of a foreign-key.
*/
JSBS_Country_BOS_Set structJSBS_Country_BOS_Set =
new JSBS_Country_BOS_Set(structJSBS_MinimalParameters, structDBCon, true);
/*
* de:
* Methode zum Selektieren aller Datensätze mit dieser Sprache als
* Bezeichnungssprache aufrufen.
* en:
* Call the method to select all datasets with this language as
* labelling language.
*/
structJSBS_Country_BOS_Set.selectValidAndFutureByLanguageCodeForLabelling(
this.ISOLanguageCode);
/*
* de:
* Abfragen ob die Datenbank-Operation fehlerfrei war und abhängig davon
* die weitere Verarbeitung vornehmen.
* en:
* Check if the database-operation endet without an error and depending
* on that continue processing. */
switch
(structJSBS_Country_BOS_Set.StatusCode)
{
case
JSBS_BO.CONST_OK:
/*
de:
* BO mit dem gesuchten Sprach-Code gefunden.
* Zur Sicherheit prüfen ob auch wirklich BO im Vector sind.
*
en:
* BO with requested language-code found.
* As a safety net check if the vector contains really at least one BO. */
if (structJSBS_Country_BOS_Set.vecRecordSet.size() > 0) {
/*
de:
* Entsprechende Status-Code setzen; dieser ist in der geerbten BO-Klasse definiert.
*
en:
* Set the Status-Code; the value is defined within the inherited BO-class. */
StatusCode
= JSBS_Language_BO.CONST_DEACTIVATE_INHIBIT_REASON_Referenced_In_Country;
/*
de:
* Zur Information des Anwenders die Anwender-bekannte Identifikation aus dem ersten BO der
* Liste extrahieren und in der Status-Message zurück liefern.
*
en:
* As an information for the user, extract the user-known identification from the first BO
* of the list and return it within the status-message. */
JSBS_Country_BO structJSBS_Country_BO = (JSBS_Country_BO)
structJSBS_Country_BOS_Set.vecRecordSet.elementAt(0);
StatusMsg
= structJSBS_Country_BO.ISOCountryCode
+ "/" + structJSBS_Country_BO.LanguageCodeForLabelling;/*
* de:
* 'true' als Flag an die aufrufende Methode zurück liefern; damit wird dieses BO nicht deaktiviert.
* en:
* For an information of the user, extract the language-code for the labelling
* of the language from the second BO within the list und return it in the
* error-message.
*/ return true;
}
break;
case
JSBS_BO.CONST_NOT_FOUND:
/*
de:
* Dieses BO wird nicht referenziert;
* dieses 'case' ist implementiert weil dieser Status kein Fehler ist.
* en:
* This BO is not referenced;
* this 'case' implemented as this status is not an error. */
break;
default:
/*
* de:
Datenbankfehler aufgetreten; diese Methode nicht fortsetzen.
* en:
Database-Error happened; do not go on with this method.
*/
StatusCode
= structJSBS_Country_BOS_Set.StatusCode;
StatusMsg
= structJSBS_Country_BOS_Set.StatusMsg;
return true;
}/* ********************
* de:
* Prüfen, ob diese Sprache als Bezeichnungssprache für eine Währung (Currency) verwendet wird.
* Dazu ein BOS-Set für die Prüfung auf Fremdschlüsselreferenz definieren.
* en:
* Verify, if this language is used als labelling language for a currency.
* To do this define a BOS-Set for the verification of a foreign-key.
*/
JSBS_Currency_BOS_Set structJSBS_Currency_BOS_Set =
new JSBS_Currency_BOS_Set(structJSBS_MinimalParameters, structDBCon, true);
/*
* de:
* Methode zum Selektieren aller Datensätze mit dieser Sprache als
* Bezeichnungssprache aufrufen.
* en:
* Call the method to select all datasets with this language as
* labelling language.
*/
structJSBS_Currency_BOS_Set.selectValidAndFutureByLanguageCodeForLabelling(
this.ISOLanguageCode);
/*
* de:
* Abfragen ob die Datenbank-Operation fehlerfrei war und abhängig davon
* die weitere Verarbeitung vornehmen.
* en:
* Check if the database-operation endet without an error and depending
* on that continue processing. */
switch
(structJSBS_Currency_BOS_Set.StatusCode)
{
case
JSBS_BO.CONST_OK:
/*
de:
* BO mit dem gesuchten Sprach-Code gefunden.
* Zur Sicherheit prüfen ob auch wirklich BO im Vector sind.
*
en:
* BO with requested language-code found.
* As a safety net check if the vector contains really at least one BO. */
if (structJSBS_Currency_BOS_Set.vecRecordSet.size() > 0) {
/*
de:
* Entsprechende Status-Code setzen; dieser ist in der geerbten BO-Klasse definiert.
*
en:
* Set the Status-Code; the value is defined within the inherited BO-class. */
StatusCode
= JSBS_Language_BO.CONST_DEACTIVATE_INHIBIT_REASON_Referenced_In_Currency;
/*
de:
* Zur Information des Anwenders die Anwender-bekannte Identifikation aus dem ersten BO der
* Liste extrahieren und in der Status-Message zurück liefern.
*
en:
* As an information for the user, extract the user-known identification from the first BO
* of the list and return it within the status-message. */
JSBS_Currency_BO structJSBS_Currency_BO = (JSBS_Currency_BO)
structJSBS_Currency_BOS_Set.vecRecordSet.elementAt(0);
StatusMsg
= structJSBS_Currency_BO.ISOCurrencyCode
+ "/" + structJSBS_Currency_BO.LanguageCodeForLabelling;/*
* de:
* 'true' als Flag an die aufrufende Methode zurück liefern; damit wird dieses BO nicht deaktiviert.
* en:
* For an information of the user, extract the language-code for the labelling
* of the language from the second BO within the list und return it in the
* error-message.
*/ return true;
}
break;
case
JSBS_BO.CONST_NOT_FOUND:
/*
de:
* Dieses BO wird nicht referenziert;
* dieses 'case' ist implementiert weil dieser Status kein Fehler ist.
* en:
* This BO is not referenced;
* this 'case' implemented as this status is not an error. */
break;
default:
/*
* de:
Datenbankfehler aufgetreten; diese Methode nicht fortsetzen.
* en:
Database-Error happened; do not go on with this method.
*/
StatusCode
= structJSBS_Currency_BOS_Set.StatusCode;
StatusMsg
= structJSBS_Currency_BOS_Set.StatusMsg;
return true;
}/*
* de: Wenn keine Referenz gefunden wurde dann wird hier die Methode beendet.
* en: If a reference was not found the method is ended here.
*/
return false;
}
/*
* --------------------
* de:
* METHODE
zum Prüfen auf Konsistenz der Werte dieses BO.
*
* Diese Methode hat die Funktion einer 'Notbremse' die verhindert, dass ein BO
* mit in sich widersprüchlichen Werten in die Datenbank eingefügt wird.
* Nachdem der Zusammenhang der Werte im BO für die Sprache einfach ist, wird
* hier nur eine einfache Korrektur der 'Marker' vorgenommen wenn das BO nicht
* der 'Haupt-Eintrag' für eine Sprache ist.
* Die Korrektur der Marker erfolgt hier weil es in der Benutzeroberfläche
* komplizierter ist - besonders wenn der Benutzer zwischen einem Haupt-Eintrag
* und einem Eintrag für die Bezeichnung einer Sprache in einer anderen Sprache
* wechselt.
*
* en:
* METHOD to verify the consistency of the values of a BO.
*
* This method has the function of an 'emergency brake' to avoid that a BO with
* inconsistent values is inserted into the database.
* As the relation of the values within the BO for the language is simple, only a
* simple correction of the 'Marker' ist done if the BO is not the 'main-entry' for
* a language.
* The correction of the Marker is done here because it is more difficult within the
* user-interface - particularly to keep the choice of the Markers if the user changes
* between the main-entry and an entry for naming the language in a different language. */
public boolean isConsistentData() {
/*
* de:
* Spezielle Prüfung ob dieses BO nicht der Haupt-Eintrag einer Sprache ist sondern 'nur'
* die Bezeichnung ('LanguageName') in einer anderen Sprache.
* Bei so einem Eintrag haben die Werte der Marker keine Bedeutung.
* en:
* Special verification if this BO is not the main-entry of a Language but 'only'
* the 'LanguageName' in another language.
* Within such an entry the values of the markers are meaningless. */ if (this.LanguageCodeForLabelling.trim().length() > 0) { this.Marker01 = false; this.Marker02 = false; this.Marker03 = false; this.Marker04 = false; this.Marker05 = false; this.Marker06 = false; this.Marker07 = false; this.Marker08 = false; this.Marker09 = false; this.Marker10 = false; this.Marker11 = false; this.Marker12 = false; this.Marker13 = false; this.Marker14 = false; this.Marker15 = false; this.Marker16 = false; this.Marker17 = false; this.Marker18 = false; this.Marker19 = false; this.Marker20 = false;/*
* de:
* Prüfen ob für diese zusätzlich definierte Sprach-Bezeichnung
* auch ein Haupt-Eintrag existiert.
* Der anschließende Code ist ein zusätzliches Sicherheitsnetz wenn die Prüfung bei
* der Eingabe der Daten lückenhaft war.
* en:
* Verify a main-entry exists for this additionally defined language-name.
* The following code is an additional safety-net if the verification during entry
* of the data did not completely check the consistency.
*/
/*
* de:
* Ein BOS definieren mit dem der Haupt-Eintrag selektiert wird.
* en:
* Define a BOS used to select the main-entry.
*/ JSBS_Language_BOS structJSBS_Language_BOS = new JSBS_Language_BOS(structJSBS_MinimalParameters, structDBCon, true); structJSBS_Language_BOS.selectByUserKnownKey(this.ISOLanguageCode, "");
/*
* de:
* Prüfen ob der Haupt-Eintrag existiert bzw. Fehler behandeln.
* en:
* Verify if the main-entry exist or process the error, respectively.
*/ switch (structJSBS_Language_BOS.StatusCode) { case JSBS_BO.CONST_OK:
/*
* de:
* Erwarteter Status; Haupt-Eintrag für die Sprache exisitert.
* en:
* Expected status; main-entry for the language exists.
*/ break; case JSBS_BO.CONST_NOT_FOUND:
/*
* de:
* Haupt-Eintrag für die Sprache exisitert nicht; der hier geprüfte Eintrag für eine
* zusätzliche Bezeichnung in einer anderen Sprache darf nicht gespeichert werden.
* Fehler-Meldung erstellen und diese Methode beenden.
* en:
* Main-entry for the language does not exist; the entry (checked here) for an additional
* language-name in another language is not allowed to be stored.
* Create the error-message and end this method.
*/ this.StatusCode = JSBS_Language_BO.CONST_ERROR_No_Default_Dataset_For_ISOLanguageCode; this.StatusMsg = ""; return false; default:
/*
* de:
* Ein anderer Fehler ist beim Zugriff auf die Datenbank aufgetreten.
* Status-Code und -Meldung auf dieses BO übernehmen und diese Methode beenden.
* en:
* Another error occured during the .
*/ this.StatusCode = structJSBS_Language_BOS.StatusCode; this.StatusMsg = structJSBS_Language_BOS.StatusMsg; return false; }
}
/*
* de:
* Aufrufen der Methode der geerbten Klasse in der die Konsistenz der allgemeinen Attribute
* (Common Attributes) geprüft wird.
* en:
* Call the method of the inherited base-class that verifies the consistency of the
* Common Attributes.
*/
if (! super.isConsistentData()) return false;
/*
* de:
* In der Methode wurden keine Prüfungen durchgeführt; als 'Konsistent' beenden.
* en:
* No verifications were done within this method;end as 'consistent'.
*/
return true;
}
}
Die Methoden dieser Klasse werden nur von Methoden innerhalb des JavaScout Basis-Systems aufgerufen und sind nicht für eine allgemeine Verwendung gedacht.
|
Dokument |
Inhalt |
|
|
|