|
Letzte
Bearbeitung dieses Dokuments: |
Code
Erklärungen
und Anwendungsbeispiele
Verwandte
Dokumentation
package
js_base.boc;
/*
* de: Packages mit den Klassen für
SQL-Datenbanken.
* en: Packages with the classes for the
SQL-classes. */
import
java.sql.*;
/*
* de: Packages mit der Klasse für das Bearbeiten
eines 'Vector'.
* en: Packages with the classe to
manipulatea 'Vector'. */
import
java.util.*;
/*
* de:
* Packages mit den Klassen für die
Elemente der Benutzeroberfläche (GUI)
* Diese Klassen
werden benötigt weil in dieser Klasse auch die Methode für den
* Aufbau der Tabelle (JTable) mit der Auswahl-Liste gefundener
Datensätze enthalten ist.
* en:
* Packages with the classes for
the elements of the Graphic User Interface (GUI)
* These
classes are needed because this classes contains the method to build
* the JTable with the selection list of found datasets.
*/
import
javax.swing.*;/*
* de: Packages mit der Generellen und Server-seitige
Klasse für dieses BO.
* en: Packages with the general
an server-side class for this BO. */
import
js_base.bo.*;
import
js_base.bos.*;
/*
* de:
* Klasse für die effiziente
Verwaltung der Verbindungen zur Datenbank.
* Wird
verwendet wenn das Anwendungsprogramm als Einzelplatz-System
konfiguriert ist
* und der Zugriff direkt auf die
Datenbank erfolgt.
* en:
* Class for a
performant administration of the connection to the database.
* Is
used in case that the application program is configured as
'stand-alone' and
* the database is directly accessed.
*/
import
js_base.connections.JSBS_DB_ConnectionManager;
/*
* de:
* Interface für die Verbindung des Clients zum
EJB ('Remote interface').
* Wird verwendet wenn das
Anwendungsprogramm als Client/Server konfiguriert ist und
der
* Zugriff über den EJB-Mechanismus erfolgt.
*
en:
* Interface handling the connection of the client
with the EJB ('Remote interface').
* Is used in case
that the application program is configured as 'client/server' and
* the database is accessed over the EJB-mechanism.
*/
import
js_base.ejb.interfaces.remote.JSBS_StandardEJBBeanRemote;
/*
de:
* Package mit der Klasse für das StartFrame (aus
dem Parameter verwendet werden) und
* Methoden für die
Bearbeitung von JFrames.
* en:
* Package with the
class for the StartFrame (which delivers parameters needed) and
*
and methods to manipulate JFrames. */
import
js_base.frame.*;
/*
de:
* Klasse mit speziellen Werten des Client-programms die
auf der Server-Seite
* des BO benötigt werden.
*
en:
* Class with specific values of the client-program
which are needed at the
* server-side of the BO. */import
js_base.structures.JSBS_MinimalParameters;
/**
*
* @author kurt(at)javascout[biz]
* @date
2010-11-03
*
* @description
* de:
*
Client-seitiger Teil des Business Object für die 'Currency'
(Währung).
*
* Innerhalb
dieser Klasse wird die Entscheidung getroffen ob das
Anwendungsprogramm
* als 'Stand-Alone' Version (mit
der Datenbank auf dem gleichen Computer) oder
*
als 'Client-Server' Version (bei der die Daten auf einem Java
Application Server / JAS
* gehalten werden und die
Daten über den Mechanismus der EJB (Enterprise Java Beans)
*
verwaltet werden.
* -------------------
* en: *
Client-Side derivation of the Business Object for the
'Currency'.
*
* Within this class the
selection is made, if the application is running with the database
* on the same machine (Stand-Alone) or
* it
is a 'client-server' application and the data is held on a
Java-Application-Server (JAS)
* and has to be
retrieved using the EJB (Enterprise Java Bean) mechanism.
*
*
@change-log
*
when who why
*
--------------------------------------------------------
*
*/
public
class JSBS_Currency_BOC_Set
extends
JSBS_Currency_BO_Set {
/* ---------------------
* de:
* KONSTANTE für die
symbolischen Namen der 'Spalten' in der Matrix der formatierten
Daten.
* Diese symbolischen Namen werden in der Methode
'buildRawDataVector' verwendet.
* Über
XML-Parameter in der Datei 'DisplayStrings.xml' wird damit die
Anordnung dieser
* Spalten für die Auswahl-Tabelle
gesteuert.
* ---------------------
* en:
* CONSTANTS
for the symbolic names of the 'columns' within the matrix of the
formatted data.
* These symbolic names are used within
the method 'buildRawDataVector'.
* The layout of these
columns at a table for selection-choices is controlled by
XML-parameters
* within the file 'DisplayStrings.xml'.
*/
public
static final String
CONST_ColumnName_ISOCurrencyCode
=
"ISOCurrencyCode";
public
static final String
CONST_ColumnName_LanguageCodeForLabelling
=
"LanguageCodeForLabelling";
public
static final String
CONST_ColumnName_CurrencyName
=
"CurrencyName";
public
static final String CONST_ColumnName_LanguageCodeForLabellingAndCurrencyName
=
"LanguageCodeForLabellingAndCurrencyName";
public
static final String
CONST_ColumnName_MiddleRateToLeadCurrency
=
"MiddleRateToLeadCurrency";
public
static final String
CONST_ColumnName_BuyingRateToLeadCurrency
=
"BuyingRateToLeadCurrency";
public
static final String
CONST_ColumnName_SellingRateToLeadCurrency
=
"SellingRateToLeadCurrency";
/* ---------------------
* VARIABLE dieser Klasse / VARIABLES of this
class.
* --------------------- */
/*
*
de:
* Referenz auf das Start-Frame (CommandCenter), das bei
der 'Konstruktion' eines Objekts
* dieser Klasse übergeben
wurde.
* Über diese Referenz werden jene Parameter
abgefragt, die steuern, ob der zugehörige
* Server-Side
Teil des BO direkt 'konstruiert' werden soll (bei einer StandAlone /
Einzelplatz-
* Version) oder ein EJB (Enterprise-Java-Bean)
aufgerufen werden muss (bei einer Client/Server-
*
Version).
* en: *
Reference to the Start-Frame (CommandCenter) that was passed during
the 'construction' of *
an object of this class.
* This reference is used to access the
parameter, which control if the associated
*
Server-Side
part of the BO
will
be constructed directly (at a StandAlone-Version) or
* an
EJB (Enterprise-Java-Bean) has to be called (at a
Client/Server-Version). */
private
JSBS_StartFrame frmCC
=
null;
/*
*
de:
* Referenz auf das Task-Frame, das das Objekt dieser
Klasse 'konstruiert' hat.
* Diese Referenz wird benötigt um
den genauen Namen der Klasse des Task-Frames zu ermitteln
*
wenn in der Methode 'setToGUI(...)' die Tabelle aufgebaut werden
muss.
* en: *
Reference to the Task-Frame that 'constructed' an object of this
class.
* This reference is needed to get the exact name of
the class (of the Task-Frame) when
*
a
table has to be build within the method 'setToGUI(...)'. */
private
JSBS_TaskFrame frmTask
=
null;
/*
*
de:
*
Referenz zur bestehenden Verbindung zur Datenbank.
*
Dieser Wert muss von der aufrufenden Methode als Parameter übergeben
werden
*
wenn diese Klasse 'konstruiert' wird.
*
en:
*
Referenc 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:
*
Referenz zur Datenbank-Verbindung die durch den ConnectionManager
verwaltet wird.
*
Dieser Wert wird vom ConnectionManager vergeben wenn eine Verbindung
zur Datenbank
*
hergestellt wurde und wird gebraucht, um die Verbindung zur
Datenbank an den
*
ConnectionManager 'zurückzugeben' wenn die Verbindung in dieser Klasse
nicht mehr
*
gebraucht wird.
*
en:
* Reference
to the DB-Connection administered by the
ConnectionManager.
* Provided from the
ConnectionManager at the establishing of a DB-Connection
and
* needed to return the DB-Connection to the
ConnectionManager when the Connection
*
is no longer needed within
this class. */
private
int intDBConReference
=
0;
/*
*
de:
* Objekt für den Abgleich bei einer 'MobileClient' Version.
* In der Klasse ist implementiert, wie die Daten eines mobilen Client mit den Daten
* am Server abgeglichen werden nachdem der mobile Client wieder mit dem Server verbunden ist.
*
en:
* Object for the synchronisation at a 'MobileClient' version.
* Within that class is implemented, how the data of a mobile client is synchronised with
* the data of the server after the mobile client is reconnected to the server.
*
within this class. */
private
JSBS_Currency_BO_Synchronizer
structJSBS_Currency_BO_Synchronizer
=
null;
/*
*
CONSTRUCTOR
* --------------------
* de:
*
Übernehmen des jeweiligen Tasks der diese Klasse konstruiert hat
(und als Parameter übergeben
* wird) und speichern des Task
in den oberhalb definierten Variablen.
* Das Objekt des
Start-Frame (parmfrmStart) könnte zwar aus dem Task-Frame ermittelt
werden - aus
* Gründen der Komptibilität zu den
Design-Patterns (Muster) für die Entwicklung eines
*
Anwendungsprogramms werden aber beide Werte übergeben.
*
en: * Takes
the task that constructed this class (which is passed as a parameter)
and stores it
* in the above defined variable.
*
The object of the Start-Frame (parmfrmStart) could be derived from
the Task-Frame - for
* the compatibility to the
design-pattern (templates) for the development of an application-
*
program, both values are passed. */
public
JSBS_Currency_BOC_Set(JSBS_StartFrame
parmfrmStart, JSBS_TaskFrame parmfrmTask) {
frmCC
= parmfrmStart;
frmTask
= parmfrmTask;
}
/*
* --------------------
*
de:
* Spezieller 'Constructor' für diese Klasse.
* Dieser 'Constructor' wird gebraucht, weil eine Variable dieses BOC auch direkt
* im JSBS_StartFrame definiert ist. Dort wird es von der Methode zum Füllen von
* Comboboxen für die Auswahl einer Sprache gebraucht.
* Die Variable für das Task-Frame wird in dieser Constructor-Methode mit gültigen Werten
* versorgt.
* en: * Particular 'Constructor' for this class.
* This 'Constructor' is needed as a variable of this BOC is defined directly within
* the JSBS_StartFrame. There it is used by the method to fill combo-boxes with valid
* values for the selection of a language. * The variable for the Task-Frame is supplied with valid values within this constuctor-
* method. */
public
JSBS_Currency_BOC_Set(JSBS_StartFrame
parmfrmStart) {
frmCC
= parmfrmStart;
frmTask
=
new
JSBS_TaskFrame(frmCC);
}
/*
*
METHODEN / METHODS
* ----------------------
*/
/*
* --------------------
* de:
* METHODE
zum Herstellen einer Verbindung zum Datenbanksystem.
* Der
Parameter steuert ob die Verbindung mit 'autocommit' versehen
wird
* (wenn der Parameter 'parmReadOnly' 'true'
ist).
* Das Setzen von 'autocommit' verbessert die
Performanz des Datenbanksystem;
* verhindert aber eine
programm-gesteuerte Ausführung der Transaktion damit
die
* Integrität von Datenänderungen erhalten
bleibt.
* en:
* METHOD to establish a
connection to the database-system.
* The parameter
controls if the connection is set to 'autocommit'
* (when
the parameter 'parmReadOnly' is 'true').
* Setting
'autocommit' increases the performance of the database-system
* but
prevents a program-controlled transaction-sequence to keep the
integrity of
* data-relations. */
private
boolean getDatabaseConnection(boolean
parmReadOnly)
{
/*
* de:
* Eine Referenz zu einer Datenbank-Verbindung vom
ConnectionManager anfordern.
* Die Referenz-Nummer wird in
der globalen Variable dieser Klasse gespeichert.
* en:
* Get a reference to the database-connection provided by
the ConnectionManager
* The reference-number will be stored
within the global variable of this class. */
intDBConReference
=
frmCC.structJSBS_DB_ConnectionManager.reserveConnection(this,
parmReadOnly);
/*
* de:
* Prüfen
ob eine Verbindung zur Datenbank verfügbar ist
(ConnectionReference >= 0);
* sonst einen Fehler
zurück liefern.
* en:
* Check if the
database-connection is available (ConnectionReference >= 0);
* otherwise return error. */
if
(intDBConReference
<
0) {
StatusCode
=
JSBS_Currency_BO.CONST_DB_SYSTEM_ERROR;
StatusMsg
= frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
return
false;
}
/*
* de:
Datenbank-Verbindung holen und in der Variable in dieser Klasse
abspeichern.
* en: Get the database-connection and
store it in the variable within this class. */
structDBCon
=
frmCC.structJSBS_DB_ConnectionManager.getReservedConnection(this,
intDBConReference);
return
true;
}
/*
* --------------------
*
de:
* METHODE zum Aufbau der Matrix mit den formatierten
Daten.
* In dieser Matrix sind in der ersten 'Zeile' die
symbolischen Spalten-Namen enthalten.
* Über
XML-Parameter in der Datei 'DisplayStrings.xml' wird damit die
Anordnung der
* Spalten für die Auswahl-Tabelle
gesteuert.
* Die 'Matrix' besteht aus einem 'Vector' der für
jede Zeile wieder einen 'Vector'
* mit den Daten für
die Spalten enthält.
* In der ersten 'Zeile' der Matrix
sind die symbolischen Spaltennamen
enthalten.
* --------------------
* en: *
METHOD to build the matrix with the formatted data.
* This
matrix contains the symbolic column-names within the first
'row'.
* The order of the columns in the table for
selection-choices can be controlled by
* XML-parameters
within the file 'DisplayStrings.xml'.
* The 'matrix'
consists of a 'vector' which contains further 'vectors' for each
'line'
* which contains the data for the 'columns' of
this 'line'.
* The first 'line' of the 'matrix'
contains the symbolic column-names. */
public
void buildRawDataVector()
{
/*
* de:
* Vector für die Zeilen
leeren; dieser Vector ist in der geerbten Basisklasse
definiert.
* en:
* Empty the vector for
the lines; this vector is defined in the inherited base-class
*/
vecRawDisplayData.removeAllElements();
/*
* de:
* Neuen 'Vector' für die
erste Zeile 'konstruieren'; diese Zeile enthält
die
* symbolischen Namen für die
Spalten.
* en:
* Construct a new 'vector'
for the first line; this vector contains the symbolic
* names
for the columns. */
Vector
vecHeader = new
Vector();
/* de:
Die Konstante für die Zeilen-Nummer ist in der geerbten
Basisklasse definiert.
* en: The constant for the
line-number is defined within the inherited base-class.
*/
vecHeader.addElement(CONST_ColumnName_RowNr);
vecHeader.addElement(CONST_ColumnName_ISOCurrencyCode);
vecHeader.addElement(CONST_ColumnName_LanguageCodeForLabelling);
vecHeader.addElement(CONST_ColumnName_CurrencyName);
vecHeader.addElement(CONST_ColumnName_LanguageCodeForLabellingAndCurrencyName);
vecHeader.addElement(CONST_ColumnName_MiddleRateToLeadCurrency);
vecHeader.addElement(CONST_ColumnName_BuyingRateToLeadCurrency);
vecHeader.addElement(CONST_ColumnName_SellingRateToLeadCurrency);
/* de:
Die gerade erstellte 'Zeile' einfügen.
* en:
Insert the just created 'line'.
*/
vecRawDisplayData.addElement(vecHeader);
/*
* de: In einer for-Schleife die Daten dieses BO-Set in
die Matrix einfügen.
* en: Use a for-loop to
insert the data of this BO-Set into the matrix. */
int
locintVectorIndex;
int
locintVectorSize
= vecRecordSet.size();
for
(locintVectorIndex
= 0; locintVectorIndex < locintVectorSize; locintVectorIndex++)
{
/*
* de: Neuen 'Vector' für die Zeile
'konstruieren'.
* en: Construct a new 'vector' for the
line. */
Vector
vecData = new
Vector();
/*
* de:
* Die
Zeilennummer als Spalte einfügen;
* das
Formatieren erfolgt in der Methode für die Anzeige.
*/
vecData.addElement(locintVectorIndex
+ 1);
/*
* de:
* Das indizierte BO aus der Liste
mit den (von der Datenbank gelesenen) BO 'herauslösen'.
* Die
Werte werden auf ein neu 'konstruiertes' BO kopiert weil innerhalb
des Vector
* nur mit Referenzen gearbeitet wird und
deswegen ein Objekt, auf das der Vector 'zeigen'
* kann,
notwendig ist.
* en:
* Get the indicated
BO from the list with the BO (read from the database).
* The
values are transferred to a new 'constructed' BO. The reason for that
algorithm is, that
* within a vector only references
can be used, therefore a new object the vector can point to
* is
needed. */
JSBS_Currency_BO
tmpJSBS_Currency_BO
=
new
JSBS_Currency_BO();
tmpJSBS_Currency_BO.copyFromJSBS_Currency_BO
(
(JSBS_Currency_BO)
vecRecordSet.elementAt(locintVectorIndex));
/*
* de:
* Werte der Variablen aus dem
'herausgelösten' BO in den 'Matrix'-Vector einfügen.
* Das
Formatieren numerischer Werte erfolgt in der Methode für die
Anzeige.
* en:
* Insert the values of the
BO derived from the list-vector into the 'matrix'-vector.
* Formatting of numeric values is done within the
method for display.
*/
vecData.addElement(tmpJSBS_Currency_BO.ISOCurrencyCode);
vecData.addElement(tmpJSBS_Currency_BO.LanguageCodeForLabelling);
vecData.addElement(tmpJSBS_Currency_BO.CurrencyName);
/*
* de:
* Aufbauen eines kombinierten Textes
mit dem Sprach-Code in der die Bezeichnung der
* Währung ist
und die Bezeichnung der Währung.
* Weil für die
Standard-Währungs-Bezeichnung kein Sprach-Code für die Bezeichnung
* verfügbar ist, wird in diesem Fall nur die
Standard-Bezeichnung der Währung angezeigt.
* en:
*
Build a combined text with the language-code defining the language
for the
* currency-name and the currency-name.
*
As there is no language-code for the default-currency-name, only the
default-currency-name
* is displayed in that case.
*/
String strLanguageCodeForLabellingAndCurrencyName = "";
/*
* de:
* Prüfen ob der Datensatz eine
zusätzliche Bezeichnung der Währung abbildet und in
*
diesem Fall den Sprach-Code für die Bezeichnung der Währung in die
gerade definierte
* Zeichenkette einfügen.
* en:
*
Verify, if the dataset represents an additional currency-name. In
that case add the
* language-code for this additional
language into the just defined string. */
if
(tmpJSBS_Currency_BO.LanguageCodeForLabelling.trim().length()
> 0)
strLanguageCodeForLabellingAndCurrencyName
+=
tmpJSBS_Currency_BO.LanguageCodeForLabelling
+
":
";
/*
* de:
* Bezeichnung für die Währung auf
jeden Fall zur Zeichenkette hinzufügen und die
* gesamte
Zeichenkette in den Vector mit den Roh-Daten einfügen.
* en:
*
Unconditionally add the currency-name to the string and insert the
string into
* the vector with the raw-data.
*/
strLanguageCodeForLabellingAndCurrencyName
+= tmpJSBS_Currency_BO.CurrencyName;
vecData.addElement(strLanguageCodeForLabellingAndCurrencyName);
/* *** */
vecData.addElement(tmpJSBS_Currency_BO.MiddleRateToLeadCurrency);
vecData.addElement(tmpJSBS_Currency_BO.BuyingRateToLeadCurrency);
vecData.addElement(tmpJSBS_Currency_BO.SellingRateToLeadCurrency);
/*
* de:
Die gerade erstellte 'Zeile' einfügen.
* en:
Insert the just created 'line'.
*/
vecRawDisplayData.addElement(vecData);
}
}
/*
* --------------------
*
de:
* METHODE zum Anzeigen der Werte aus diesem BO-Set in
einem GUI-Element der Klasse JTable. *
Diese Methode verwendet eine Methode aus der Basisklasse
'JSBS_XML_DisplayStrings'
* um ein GUI-Element der Klasse
'JTable' mit den Daten zu füllen.
* Im Parameter
'parmArrayColumnWidth' wird eine Information über die Breite der
Spalten
* in der Tabelle übergeben.
*
*
en: *
METHOD to dispay the values of this BO-Set within a GUI-Element of
class JTable.
* This method uses a method from the
base-class 'JSBS_XML_DisplayStrings' to fill
* a GUI-element
of class 'JTable' with data.
* Within the parameter
'parmArrayColumnWidth', an information about the width of the
*
columns of the table is passed. */
public
void setToGUI(JTable
parmJTable, String []
parmArrayColumnWidth)
{
/*
* de:
* Namen der Klasse des Task-Frames
ermitteln.
* Dieser Wert wird gebraucht um die Anordnung und
Breite der Spalten in der Tabelle (JTable)
* aus der
XML-Struktur auslesen zu können.
* en:
* Get
the name of the class of the task-frame.
* This value is
needed to read the order and the width of the column for the
JTable
* out of the XML-structure. */
String
strFrameClassName = frmTask.getClass().getName();
/*
* de:
* Methode zum Füllen der Tabelle
aufrufen.
* en:
* Call the method to fill the
JTable. */
frmTask.frmCC.structJSBS_XML_DisplayStrings.processJTable(
parmJTable,
strFrameClassName,
vecRawDisplayData,
parmArrayColumnWidth);
}
/*
* --------------------
*
de:
* METHODE zum Aufrufen des nebenläufigen Prozess
(Thread) zum Abgleichen von BO wenn das *
Anwendungsprogramm in der Version 'MobileClient' läuft.
*
* en: *
METHOD to call the thread to synchronize BO if the
application-programm runs with the
* version 'MobileClient'.
*/
private
void synchronizeBO()
{
/*
* de:
* Zuerst prüfen ob schon ein Objekt
für den nebenläufigen Prozess (Thread) existiert
* und bei
Bedarf ein Thread-Objekt konstruieren.
* en:
*
First check if an object for the thread already exist and construct
one if needed. */
if
(structJSBS_Currency_BO_Synchronizer
==
null)
structJSBS_Currency_BO_Synchronizer
=
new
JSBS_Currency_BO_Synchronizer(frmCC,
frmTask);
/*
* de:
* Dieses BO-Set (gesamtes Objekt) an
den Synchronizer übergeben.
* Der nebenläufige, asynchrone
Prozess wird in der aufgerufenen Methode gestartet.
* en:
* Pass this BO-set (complete object)
to
the Synchronizer.
* The asynchronous thread will be started
within the called method. */
structJSBS_Currency_BO_Synchronizer.passBOList(this);
}
/*
* --------------------
*
de:
* METHODE zum Vergleichen von zwei BO-Sets und Übernehmen der jeweils neuesten Version *
eines BO in das vecRecordSet dieses Objekts.
* --------------------
* en: *
METHOD to compare two BO-sets and transfer of the newest version of a BO into the
* vecRecordSet of this object. */
private
void mergeList(JSBS_Currency_BO_Set parmJSBS_Currency_BO_Set_1,
JSBS_Currency_BO_Set parmJSBS_Currency_BO_Set_2)
{
/*
* de: Zuerst Prüfen ob gültige Werte in den Parametern vorhanden sind.
* en: First verify if valid values are passed in the parameters.
*/
if
(parmJSBS_Currency_BO_Set_1 == null) {
this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
this.StatusMsg = "mergeList: parmJSBS_Currency_BO_Set_1 is 'null'";
}
if
(parmJSBS_Currency_BO_Set_1.vecRecordSet == null) {
this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
this.StatusMsg = "mergeList: parmJSBS_Currency_BO_Set_1.vecRecordSet is 'null'";
}
if
(parmJSBS_Currency_BO_Set_2 == null) {
this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
this.StatusMsg = "mergeList: parmJSBS_Currency_BO_Set_2 is 'null'";
}
if
(parmJSBS_Currency_BO_Set_2.vecRecordSet == null) {
this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
this.StatusMsg = "mergeList: parmJSBS_Currency_BO_Set_2.vecRecordSet is 'null'";
}
/*
* de: Variable die für den Abgleich gebraucht werden definieren.
* en: Define the variables that are needed for the merge.
*/
int intVectorSizeThis;
int intVectorIndexThis;
int intVectorSizeParm;
int intVectorIndexParm;
JSBS_Currency_BO locJSBS_Currency_BO_This;
JSBS_Currency_BO locJSBS_Currency_BO_Parm;
JSBS_Currency_BO locJSBS_Currency_BO_ToInsert;
/*
* de:
* Vector mit den BO dieses Objekts leeren und BO aus dem Vector des Parameter 1 übertragen.
* en:
* Empty the vector with the BO of this object and transfer the BO from the vector of Parameter 1.
*/
vecRecordSet = new Vector();
intVectorSizeParm = parmJSBS_Currency_BO_Set_1.vecRecordSet.size();
for
(intVectorIndexParm = 0; intVectorIndexParm < intVectorSizeParm; intVectorIndexParm++) {
locJSBS_Currency_BO_Parm = (JSBS_Currency_BO) parmJSBS_Currency_BO_Set_1.vecRecordSet.elementAt(intVectorIndexParm);
locJSBS_Currency_BO_ToInsert = new JSBS_Currency_BO();
locJSBS_Currency_BO_ToInsert.copyFromJSBS_Currency_BO(locJSBS_Currency_BO_Parm);
vecRecordSet.addElement(locJSBS_Currency_BO_ToInsert);
}
/*
* de:
* In einem zweiten Durchgang alle BO des Parameter 2 mit den bereits im vecRecordSet dieses
* Objektes enthaltenen vergleichen.
* Sind im Parameter 2 neue oder 'jüngere' BO enthalten, dann diese in das vecRecordSet dieses
* Objektes einfügen bzw. 'ältere' ersetzen. * en:
* In a second pass, compare all BO from the Parameter 2 with the ones already contained in
* vecRecordSet of this object.
* If Parameter 2 contains new or 'younger' BO, then insert them into the vecRecordSet of this
* object or replace 'older' ones.
*/
intVectorSizeParm = parmJSBS_Currency_BO_Set_2.vecRecordSet.size();
for
(intVectorIndexParm = 0; intVectorIndexParm < intVectorSizeParm; intVectorIndexParm++) {
locJSBS_Currency_BO_Parm = (JSBS_Currency_BO) parmJSBS_Currency_BO_Set_2.vecRecordSet.elementAt(intVectorIndexParm);
/*
* de:
* BO für das eventuelle Einfügen mit dem BO aus dem Parameter 2 versorgen. Das wird später zum
* Signalisieren benutzt, ob das BO aus dem Parameter 2 eingefügt werden soll. * en:
* Set the BO used for inserting to the BO of parameter 2. This is used later to signal, if the BO
* from Parameter 2
has to be inserted.
*/
locJSBS_Currency_BO_ToInsert = new JSBS_Currency_BO();
locJSBS_Currency_BO_ToInsert.copyFromJSBS_Currency_BO(locJSBS_Currency_BO_Parm);
/*
* de:
* In einer inneren for-Schleife das BO-Set dieses Objektes durchsuchen und die BO vergleichen. * en:
* Use an inner for-loop to inspect the BO-Set of this object and compare the BO.
*/
intVectorSizeThis = this.vecRecordSet.size();
for
(intVectorIndexThis = 0; intVectorIndexThis < intVectorSizeThis; intVectorIndexThis++) {
locJSBS_Currency_BO_This = (JSBS_Currency_BO) this.vecRecordSet.elementAt(intVectorIndexThis);
/*
* de:
* Vergleichen ob die beiden BO den gleichen ObjectID haben - also das gleiche BO sind. * en:
* Compare if both BO have the same ObjectID - i.e. they are the same BO.
*/
if
(locJSBS_Currency_BO_This.ObjectID == locJSBS_Currency_BO_Parm.ObjectID) {
/*
de:
* Markieren, dass dieses BO nicht mehr in das vecRecordSet dieses Objekts eingefügt werden muss. * en:
* Mark that this BO does not have to be inserted into the vecRecordSet of this object.
*/
locJSBS_Currency_BO_ToInsert = null;
/*
de: Prüfen, ob das BO aus dem Parameter 2 'jünger' ist. * en: Check, if the BO in parameter 2 is 'younger'.
*/
if
(locJSBS_Currency_BO_This.ChangedAt.before(locJSBS_Currency_BO_Parm.ChangedAt)) {
/*
de:
* BO aus dem Parameter 2 ist 'jünger'; dessen Werte in das BO im vecRecordSet dieses Objekts übertragen. * en:
* BO from parameter 2 is 'younger'; transfer its values into the BO in vecRecordSet of this object.
*/
((JSBS_Currency_BO) this.vecRecordSet.elementAt(intVectorIndexThis)).
copyFromJSBS_Currency_BO(locJSBS_Currency_BO_Parm);
}
}
}
/*
* de:
* Prüfen ob das bearbeitete BO aus dem Parameter 2 in das vecRecordSet dieses Objekts eingefügt werden muss. * en:
* Verify, if the BO from the parameter 2 has to be inserted into the vecRecordSet of this object.
*/
if
(locJSBS_Currency_BO_ToInsert != null)
vecRecordSet.addElement(locJSBS_Currency_BO_ToInsert);
}
}
/* * -------------------- *
de: *
METHODEN zum Lesen aller Datensätze (nicht mehr gültig, aktuell
gültig, erst in Zukunft gültig) *
für den gegeben ObjectID von der Datenbank. *
en: *
METHODS to read all datasets (no longer valid, actually valid, valid
in the future) for the *
given ObjectID
from
the database. *//* * de:
METHODE zum Lesen der Daten von der lokalen Datenbank. *
en: METHOD
to read the data from the local database. */ protected
void selectAllByObjectID_DB(double
parmObjectID)
{/*
de: *
Datenbank läuft auf der lokalen Maschine; Verbindung zur Datenbank
herstellen. *
en: *
Database is running on the local machine; establish the connection to
the database. */ getDatabaseConnection(true);/*
de: *
Prüfen ob eine Verbindung zur Datenbank hergestellt werden
konnte. *
Eine Referenznummer gleich oder größer 0 bedeutet eine
ordnungsgemäße Verbindung zur DB. *
en: *
Verify if a connection to the database could have been
established. *
A reference-number of 0 or greater signals a proper connection to the
database. */ if
(intDBConReference
<
0) {/*
de: *
Fehler beim Verbinden zur Datenbank; über Status-Variable an die
aufrufende Methode *
signalisieren. Diese Methode beenden. *
en: *
Error when connecting to the database; signal this to the calling
method using *
the status-variables. End this Method. */ StatusCode
=
JSBS_Currency_BO.CONST_DB_SYSTEM_ERROR; StatusMsg
=
frmCC.structJSBS_DB_ConnectionManager.StatusMsg; return;
}/*
de: *
Datenbank läuft auf der lokalen Maschine; 'Server-Seitige' Klasse
des BO direkt *
'konstruieren'. *
Verbindung zur Datenbank und die Werte dieser 'Client-seitigen'
BO-Klasse *
als Parameter übertragen. *
en: *
Database is running on the local machine; construct the 'Server-Side'
BO directly. * Pass
the database-connection and the values of this 'Client-Side' BO as
parameters. */
JSBS_Currency_BOS_Set
bosJSBS_Currency_BOS_Set = new
JSBS_Currency_BOS_Set(frmTask.structMinParm,
structDBCon,
true);
/*
de: Aufrufen der Methode, die die Operation auf der Datenbank
ausführt. *
en: Call the method to perform the database-operation(s).
*/ bosJSBS_Currency_BOS_Set.selectAllByObjectID(parmObjectID);/*
de: *
Übertragen der zurückgelieferten Werte der Variablen und des Status. *
Ausserdem kann auf das BOS nicht mehr zugegriffen werden sobald diese
Methode beendet ist. *
en: *
Transfer the returned values of the variables and the Status. *
Additionally the values of the BOS can no longer be accesses as soon
as this method has ended.
*/ copyFromJSBS_Currency_BO_Set(bosJSBS_Currency_BOS_Set);/*
de: *
Verbindung zur Datenbank an den Connection-Manager zurück geben. *
Der Connection Manager verwaltet die offenen Verbindungen zur
Datenbank und verwendet *
sie wieder bei der nächsten Anforderung. *
en: *
Return the connection to the database to the Connection-Manager.
* The
Connection-Manager administers open connections to the database and
reuses it *
at the next request.
*/ frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this,
intDBConReference); }/* * de:
METHODE zum Lesen der Daten über den JAS (Java Application
Server). *
en: METHOD
to read the data via the JAS (Java Application Server).
*/ protected
void selectAllByObjectID_JAS(double
parmObjectID)
{/*
de: Der Zugriff auf die Datenbank läuft über den
EJB-Mechanismus. *
en: Access to the database is by using the EJB-mechanism.
*/ try
{/*
de: *
Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote
interface') für *
den Aufruf von Methoden des EJB. *
Die Methode zum Instanziieren ist im Start-Frame implementiert. *
en: *
Instantiate (construct) the client-side object ('Remote interface')
for calling *
methods of the EJB. *
The method to instantiate is implemented in the Start-Frame.
*/ JSBS_StandardEJBBeanRemote
remoteJSBS_StandardEJBBean
= frmCC.get_JSBS_StandardEJBBeanRemote();/* *
de: Prüfen, ob überhaupt eine Verbindung zum JAS hergestellt werden
konnte. *
en: Verify if a connection to the JAS has been established.
*/ if
(remoteJSBS_StandardEJBBean
== null)
{/* *
de: Keine Verbindung zum JAS; Fehler zurückmelden. *
en: No connection to the JAS; report error.
*/ this.StatusCode
=
JSBS_Currency_BO.CONST_DB_UNKNOWN_ERROR; this.StatusMsg
=
"No
connection to JAS; method:
JSBS_Currency_BOC.selectAllByObjectID()"; return;
}/*
de: *
Aufrufen der 'Wrapper'-Methode des EJB. In dieser 'Wrapper'-Methode
wird die - zu diesem *
Client-seitigen Teil des BO - passende Server-seitige Methode
aufgerufen. *
Neue Werte für die Variablen des BO und eventuelle Fehlermeldungen
sind im zurückgelieferten *
BO enthalten. *
en: *
Call the 'wrapper'-method of the EJB. Within this 'wrapper'-method
the server-side method *
- which fits this method of the client-side derivation of the BO - is
called. *
New values for variables of the BO and probably occured
error-messages are contained in the *
returned BO. */
JSBS_Currency_BO_Set
boJSBS_Currency_BO_Set =
remoteJSBS_StandardEJBBean.
JSBS_Currency_BO_Set__selectAllByObjectID(frmTask.structMinParm,
parmObjectID);/*
de: *
Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil
des BO) kopieren. *
en: *
Copy the values of the returned BO to this BOC (client-side
derivation of the BO). */
this.copyFromJSBS_Currency_BO_Set(boJSBS_Currency_BO_Set);
} catch (Exception
e) {/*
de: *
Fehler beim Ausführen der Methode des EJB. *
Fehlermeldung aus der Exception übernehmen und Status setzen. *
en: *
Error when executing the method of the EJB. *
Transfer the error-message from the Exception and set status.
*/ this.StatusCode
=
JSBS_Currency_BO.CONST_DB_UNKNOWN_ERROR; this.StatusMsg
= e.getMessage();
} }
/*
* --------------------
*
de:
* METHODE zum Lesen aller aktuell gültigen Währungen von
der Datenbank.
* en: *
METHOD to read all currencies valid at the actual data from the
database. */
public
void selectAllByObjectID(double
parmObjectID)
{/*
*
de: Entscheiden mit welcher Version das Anwendungsprogramm läuft. *
en: Decide what version the application runs. */
switch
(frmCC.RunVersion)
{
case
JSBS_StartFrame.CONST_StandAlone:/*
de: *
Einzelplatzversion. Datenbank läuft auf der lokalen Maschine;
Spezielle Methode aufrufen. *
en: *
Stand-alone version. Database is running on the local machine; call
the specialized method. */
selectAllByObjectID_DB(parmObjectID);
break;
case
JSBS_StartFrame.CONST_FatClient:/*
de: *
Client-Server-Version. *
Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java
Application Server); spezielle Methode aufrufen. *
en: *
Client-Server-version. *
Data is accessed via the EJB-mechanism and the JAS (Java Application
Server); call the specialized method. */
selectAllByObjectID_JAS(parmObjectID);
break;
case
JSBS_StartFrame.CONST_MobileClient:/*
de: *
Zuerst die Daten von der lokalen Datenbank abfragen.
Per
Definition muss das immer möglich sein. *
en: *
Read the data from the local database. As per definition this must
always be possible. */
selectAllByObjectID_DB(parmObjectID);/*
de: *
Prüfen, ob ein Fehler bei der Abfrage auf der lokalen Datenbank
aufgetreten ist. In diesem Fall die *
Methode beenden - damit ist der Status für die aufrufende Methode
verfügbar. *
en: *
Verify, if an error occured when reading the local database. In that
case end this method - that makes *
the status available for the calling method. */
if
((this.StatusCode
==
JSBS_BO.CONST_OK)
|| (this.StatusCode
==
JSBS_BO.CONST_NOT_FOUND))
{/*
de: 'Erlaubte' Status-Codes für die Abfrage von der lokalen
Datenbank. *
en: 'Permitted' status-codes for the read from the local database.
*/
}
else
return;/*
de: *
Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt
die weitere Verarbeitung. *
en: *
Verify, if the connection to the JAS exists. The further processing
depends
on the result. */
if
(frmCC.testJASConnection())
{/*
de: *
BO-Sets für die Daten der lokalen Datenbank und den Daten vom JAS
konstruieren. *
Damit können später die jeweiligen Daten verglichen und
Unterschiede behandelt werden. *
en: *
Construct BO-Sets for the data from the local database and the data
from the JAS. *
This allows to compare the data later and process differences. */
JSBS_Currency_BO_Set
structJSBS_Currency_BO_Set_Local = new
JSBS_Currency_BO_Set();
JSBS_Currency_BO_Set
structJSBS_Currency_BO_Set_JAS = new
JSBS_Currency_BO_Set();/*
de: *
Ergebnis der Abfrage der lokalen Datenbank auf die dafür vorgesehene
Variable übertragen und den *
Vector mit den BO in diesem Objekt leeren. *
en: *
Transfer the result of the read from the local database to the
variable designated for that. *
Empty the vector with the BO within this object thereafter. */
structJSBS_Currency_BO_Set_Local.copyFromJSBS_Currency_BO_Set(this);
vecRecordSet.removeAllElements();/*
de: Daten vom JAS abfragen. *
en: Read the data from the JAS. */
selectAllByObjectID_JAS(parmObjectID);/*
de: *
Prüfen, ob ein Fehler bei der Abfrage vom JAS aufgetreten ist. In
diesem Fall die *
Methode beenden - damit ist der Status für die aufrufende Methode
verfügbar. *
en: *
Verify, if an error occured when reading from the JAS. In that case
end this method - that makes *
the status available for the calling method. */
if
((this.StatusCode
==
JSBS_BO.CONST_OK)
|| (this.StatusCode
==
JSBS_BO.CONST_NOT_FOUND))
{/*
de: 'Erlaubte' Status-Codes für die Abfrage über den JAS. *
en: 'Permitted' status-codes for the read via the JAS.
*/
}
else
return;/*
de: *
Ergebnis der Abfrage über den JAS auf die dafür vorgesehene
Variable übertragen und den *
Vector mit den BO in diesem Objekt leeren. *
en: *
Transfer the result of the read via the JAS to the variable
designated for that. *
Empty the vector with the BO within this object thereafter. */
structJSBS_Currency_BO_Set_JAS.copyFromJSBS_Currency_BO_Set(this);
vecRecordSet.removeAllElements();/*
de: Methode zum Abgleich der Daten von beiden Quellen aufrufen. *
en: Call the method that merges the data from both sources. */
mergeList(structJSBS_Currency_BO_Set_Local,
structJSBS_Currency_BO_Set_JAS);/*
de: *
Methode zum Sortieren nach dem Währungs-Code aufrufen weil die BO nach
dem Abgleich nach *
ihrer Herkunft sortiert sind. *
en: *
Call the method to sort by currency-code as the BO are sorted by
their source after the merge. */
sortByLeadingCurrency_ISOCurrencyCode_LanguageCodeForLabelling();
}
break;
}
/*
* de: Methode aufrufen, die die Matrix für die
Anzeige der Daten erstellt.
* en: Call the method that
builds the matrix for the display of the data.
*/
buildRawDataVector();
}
/* * -------------------- *
de: *
METHODEN zum Lesen aller aktuell gültigen Datensätze von der
Datenbank. *
en: *
METHODS to read all datasets valid at the actual data from the
database. *//* * de:
METHODE zum Lesen der Daten von der lokalen Datenbank. *
en: METHOD
to read the data from the local database. */ private
void selectAllValid_DB()
{/*
de: *
Datenbank läuft auf der lokalen Maschine; Verbindung zur Datenbank
herstellen. *
en: *
Database is running on the local machine; establish the connection to
the database. */ getDatabaseConnection(true);/*
de: *
Prüfen ob eine Verbindung zur Datenbank hergestellt werden
konnte. *
Eine Referenznummer gleich oder größer 0 bedeutet eine
ordnungsgemäße Verbindung zur DB. *
en: *
Verify if a connection to the database could have been
established. *
A reference-number of 0 or greater signals a proper connection to the
database. */ if
(intDBConReference
<
0) {/*
de: *
Fehler beim Verbinden zur Datenbank; über Status-Variable an die
aufrufende Methode *
signalisieren. Diese Methode beenden. *
en: *
Error when connecting to the database; signal this to the calling
method using *
the status-variables. End this Method. */ StatusCode
=
JSBS_Currency_BO.CONST_DB_SYSTEM_ERROR; StatusMsg
=
frmCC.structJSBS_DB_ConnectionManager.StatusMsg; return;
}/*
de: *
Datenbank läuft auf der lokalen Maschine; 'Server-Seitige' Klasse
des BO direkt *
'konstruieren'. *
Verbindung zur Datenbank und die Werte dieser 'Client-seitigen'
BO-Klasse *
als Parameter übertragen. *
en: *
Database is running on the local machine; construct the 'Server-Side'
BO directly. * Pass
the database-connection and the values of this 'Client-Side' BO as
parameters. */
JSBS_Currency_BOS_Set
bosJSBS_Currency_BOS_Set = new
JSBS_Currency_BOS_Set(frmTask.structMinParm,
structDBCon,
true);
/*
de: Aufrufen der Methode, die die Operation auf der Datenbank
ausführt. *
en: Call the method to perform the database-operation(s).
*/ bosJSBS_Currency_BOS_Set.selectAllValid();/*
de: *
Übertragen der zurückgelieferten Werte der Variablen und des Status. *
Ausserdem kann auf das BOS nicht mehr zugegriffen werden sobald diese
Methode beendet ist. *
en: *
Transfer the returned values of the variables and the Status. *
Additionally the values of the BOS can no longer be accesses as soon
as this method has ended.
*/ copyFromJSBS_Currency_BO_Set(bosJSBS_Currency_BOS_Set);/*
de: *
Verbindung zur Datenbank an den Connection-Manager zurück geben. *
Der Connection Manager verwaltet die offenen Verbindungen zur
Datenbank und verwendet *
sie wieder bei der nächsten Anforderung. *
en: *
Return the connection to the database to the Connection-Manager.
* The
Connection-Manager administers open connections to the database and
reuses it *
at the next request.
*/ frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this,
intDBConReference); }/* * de:
METHODE zum Lesen der Daten über den JAS (Java Application
Server). *
en: METHOD
to read the data via the JAS (Java Application Server).
*/ private
void selectAllValid_JAS()
{/*
de: Der Zugriff auf die Datenbank läuft über den
EJB-Mechanismus. *
en: Access to the database is by using the EJB-mechanism.
*/ try
{/*
de: *
Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote
interface') für *
den Aufruf von Methoden des EJB. *
Die Methode zum Instanziieren ist im Start-Frame implementiert. *
en: *
Instantiate (construct) the client-side object ('Remote interface')
for calling *
methods of the EJB. *
The method to instantiate is implemented in the Start-Frame.
*/ JSBS_StandardEJBBeanRemote
remoteJSBS_StandardEJBBean
= frmCC.get_JSBS_StandardEJBBeanRemote();/* *
de: Prüfen, ob überhaupt eine Verbindung zum JAS hergestellt werden
konnte. *
en: Verify if a connection to the JAS has been established.
*/ if
(remoteJSBS_StandardEJBBean
== null)
{/* *
de: Keine Verbindung zum JAS; Fehler zurückmelden. *
en: No connection to the JAS; report error.
*/ this.StatusCode
=
JSBS_Currency_BO.CONST_DB_UNKNOWN_ERROR; this.StatusMsg
=
"No
connection to JAS; method:
JSBS_Currency_BOC.selectAllValid()"; return;
}/*
de: *
Aufrufen der 'Wrapper'-Methode des EJB. In dieser 'Wrapper'-Methode
wird die - zu diesem *
Client-seitigen Teil des BO - passende Server-seitige Methode
aufgerufen. *
Neue Werte für die Variablen des BO und eventuelle Fehlermeldungen
sind im zurückgelieferten *
BO enthalten. *
en: *
Call the 'wrapper'-method of the EJB. Within this 'wrapper'-method
the server-side method *
- which fits this method of the client-side derivation of the BO - is
called. *
New values for variables of the BO and probably occured
error-messages are contained in the *
returned BO. */
JSBS_Currency_BO_Set
boJSBS_Currency_BO_Set =
remoteJSBS_StandardEJBBean.
JSBS_Currency_BO_Set__selectAllValid(frmTask.structMinParm);/*
de: *
Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil
des BO) kopieren. *
en: *
Copy the values of the returned BO to this BOC (client-side
derivation of the BO). */
this.copyFromJSBS_Currency_BO_Set(boJSBS_Currency_BO_Set);
} catch (Exception
e) {/*
de: *
Fehler beim Ausführen der Methode des EJB. *
Fehlermeldung aus der Exception übernehmen und Status setzen. *
en: *
Error when executing the method of the EJB. *
Transfer the error-message from the Exception and set status.
*/ this.StatusCode
=
JSBS_Currency_BO.CONST_DB_UNKNOWN_ERROR; this.StatusMsg
= e.getMessage();
} }
/*
* --------------------
*
de:
* METHODE zum Lesen aller aktuell gültigen Währungen von
der Datenbank.
* en: *
METHOD to read all currencies valid at the actual data from the
database. */
public
void selectAllValid()
{/*
*
de: Entscheiden mit welcher Version das Anwendungsprogramm läuft. *
en: Decide what version the application runs. */
switch
(frmCC.RunVersion)
{
case
JSBS_StartFrame.CONST_StandAlone:/*
de: *
Einzelplatzversion. Datenbank läuft auf der lokalen Maschine;
Spezielle Methode aufrufen. *
en: *
Stand-alone version. Database is running on the local machine; call
the specialized method. */
selectAllValid_DB();
break;
case
JSBS_StartFrame.CONST_FatClient:/*
de: *
Client-Server-Version. *
Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java
Application Server); spezielle Methode aufrufen. *
en: *
Client-Server-version. *
Data is accessed via the EJB-mechanism and the JAS (Java Application
Server); call the specialized method. */
selectAllValid_JAS();
break;
case
JSBS_StartFrame.CONST_MobileClient:/*
de: *
Zuerst die Daten von der lokalen Datenbank abfragen.
Per
Definition muss das immer möglich sein. *
en: *
Read the data from the local database. As per definition this must
always be possible. */
selectAllValid_DB();/*
de: *
Prüfen, ob ein Fehler bei der Abfrage auf der lokalen Datenbank
aufgetreten ist. In diesem Fall die *
Methode beenden - damit ist der Status für die aufrufende Methode
verfügbar. *
en: *
Verify, if an error occured when reading the local database. In that
case end this method - that makes *
the status available for the calling method. */
if
((this.StatusCode
==
JSBS_BO.CONST_OK)
|| (this.StatusCode
==
JSBS_BO.CONST_NOT_FOUND))
{/*
de: 'Erlaubte' Status-Codes für die Abfrage von der lokalen
Datenbank. *
en: 'Permitted' status-codes for the read from the local database.
*/
}
else
return;/*
de: *
Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt
die weitere Verarbeitung. *
en: *
Verify, if the connection to the JAS exists. The further processing
depends
on the result. */
if
(frmCC.testJASConnection())
{/*
de: *
BO-Sets für die Daten der lokalen Datenbank und den Daten vom JAS
konstruieren. *
Damit können später die jeweiligen Daten verglichen und
Unterschiede behandelt werden. *
en: *
Construct BO-Sets for the data from the local database and the data
from the JAS. *
This allows to compare the data later and process differences. */
JSBS_Currency_BO_Set
structJSBS_Currency_BO_Set_Local = new
JSBS_Currency_BO_Set();
JSBS_Currency_BO_Set
structJSBS_Currency_BO_Set_JAS = new
JSBS_Currency_BO_Set();/*
de: *
Ergebnis der Abfrage der lokalen Datenbank auf die dafür vorgesehene
Variable übertragen und den *
Vector mit den BO in diesem Objekt leeren. *
en: *
Transfer the result of the read from the local database to the
variable designated for that. *
Empty the vector with the BO within this object thereafter. */
structJSBS_Currency_BO_Set_Local.copyFromJSBS_Currency_BO_Set(this);
vecRecordSet.removeAllElements();/*
de: Daten vom JAS abfragen. *
en: Read the data from the JAS. */
selectAllValid_JAS();/*
de: *
Prüfen, ob ein Fehler bei der Abfrage vom JAS aufgetreten ist. In
diesem Fall die *
Methode beenden - damit ist der Status für die aufrufende Methode
verfügbar. *
en: *
Verify, if an error occured when reading from the JAS. In that case
end this method - that makes *
the status available for the calling method. */
if
((this.StatusCode
==
JSBS_BO.CONST_OK)
|| (this.StatusCode
==
JSBS_BO.CONST_NOT_FOUND))
{/*
de: 'Erlaubte' Status-Codes für die Abfrage über den JAS. *
en: 'Permitted' status-codes for the read via the JAS.
*/
}
else
return;/*
de: *
Ergebnis der Abfrage über den JAS auf die dafür vorgesehene
Variable übertragen und den *
Vector mit den BO in diesem Objekt leeren. *
en: *
Transfer the result of the read via the JAS to the variable
designated for that. *
Empty the vector with the BO within this object thereafter. */
structJSBS_Currency_BO_Set_JAS.copyFromJSBS_Currency_BO_Set(this);
vecRecordSet.removeAllElements();/*
de: Methode zum Abgleich der Daten von beiden Quellen aufrufen. *
en: Call the method that merges the data from both sources. */
mergeList(structJSBS_Currency_BO_Set_Local,
structJSBS_Currency_BO_Set_JAS);/*
de: *
Methode zum Sortieren nach dem Währungs-Code aufrufen weil die BO nach
dem Abgleich nach *
ihrer Herkunft sortiert sind. *
en: *
Call the method to sort by currency-code as the BO are sorted by
their source after the merge. */
sortByLeadingCurrency_ISOCurrencyCode_LanguageCodeForLabelling();
}
break;
}
/*
* de: Methode aufrufen, die die Matrix für die
Anzeige der Daten erstellt.
* en: Call the method that
builds the matrix for the display of the data.
*/
buildRawDataVector();
}
/* * -------------------- *
de: *
METHODEN zum Lesen aller aktuell gültigen Datensätze für den
gegebenen Währungs-Code *
von der Datenbank. *
en: *
METHODS to read all dataset valid at the actual data for the given currency-code *
from the database. *//* * de:
METHODE zum Lesen der Daten von der lokalen Datenbank. *
en: METHOD
to read the data from the local database. */ private
void selectByISOCurrencyCode_DB(String
parmISOCurrencyCode) {/*
de: *
Datenbank läuft auf der lokalen Maschine; Verbindung zur Datenbank
herstellen. *
en: *
Database is running on the local machine; establish the connection to
the database. */ getDatabaseConnection(true);/*
de: *
Prüfen ob eine Verbindung zur Datenbank hergestellt werden
konnte. *
Eine Referenznummer gleich oder größer 0 bedeutet eine
ordnungsgemäße Verbindung zur DB. *
en: *
Verify if a connection to the database could have been
established. *
A reference-number of 0 or greater signals a proper connection to the
database. */ if
(intDBConReference
<
0) {/*
de: *
Fehler beim Verbinden zur Datenbank; über Status-Variable an die
aufrufende Methode *
signalisieren. Diese Methode beenden. *
en: *
Error when connecting to the database; signal this to the calling
method using *
the status-variables. End this Method. */ StatusCode
=
JSBS_Currency_BO.CONST_DB_SYSTEM_ERROR; StatusMsg
=
frmCC.structJSBS_DB_ConnectionManager.StatusMsg; return;
}/*
de: *
Datenbank läuft auf der lokalen Maschine; 'Server-Seitige' Klasse
des BO direkt *
'konstruieren'. *
Verbindung zur Datenbank und die Werte dieser 'Client-seitigen'
BO-Klasse *
als Parameter übertragen. *
en: *
Database is running on the local machine; construct the 'Server-Side'
BO directly. * Pass
the database-connection and the values of this 'Client-Side' BO as
parameters. */
JSBS_Currency_BOS_Set
bosJSBS_Currency_BOS_Set = new
JSBS_Currency_BOS_Set(frmTask.structMinParm,
structDBCon,
true);
/*
de: Aufrufen der Methode, die die Operation auf der Datenbank
ausführt. *
en: Call the method to perform the database-operation(s).
*/ bosJSBS_Currency_BOS_Set.selectByISOCurrencyCode(parmISOCurrencyCode);/*
de: *
Übertragen der zurückgelieferten Werte der Variablen und des Status. *
Ausserdem kann auf das BOS nicht mehr zugegriffen werden sobald diese
Methode beendet ist. *
en: *
Transfer the returned values of the variables and the Status. *
Additionally the values of the BOS can no longer be accesses as soon
as this method has ended.
*/ copyFromJSBS_Currency_BO_Set(bosJSBS_Currency_BOS_Set);/*
de: *
Verbindung zur Datenbank an den Connection-Manager zurück geben. *
Der Connection Manager verwaltet die offenen Verbindungen zur
Datenbank und verwendet *
sie wieder bei der nächsten Anforderung. *
en: *
Return the connection to the database to the Connection-Manager.
* The
Connection-Manager administers open connections to the database and
reuses it *
at the next request.
*/ frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this,
intDBConReference); }/* * de:
METHODE zum Lesen der Daten über den JAS (Java Application
Server). *
en: METHOD
to read the data via the JAS (Java Application Server).
*/ private
void selectByISOCurrencyCode_JAS(String
parmISOCurrencyCode) {/*
de: Der Zugriff auf die Datenbank läuft über den
EJB-Mechanismus. *
en: Access to the database is by using the EJB-mechanism.
*/ try
{/*
de: *
Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote
interface') für *
den Aufruf von Methoden des EJB. *
Die Methode zum Instanziieren ist im Start-Frame implementiert. *
en: *
Instantiate (construct) the client-side object ('Remote interface')
for calling *
methods of the EJB. *
The method to instantiate is implemented in the Start-Frame.
*/ JSBS_StandardEJBBeanRemote
remoteJSBS_StandardEJBBean
= frmCC.get_JSBS_StandardEJBBeanRemote();/* *
de: Prüfen, ob überhaupt eine Verbindung zum JAS hergestellt werden
konnte. *
en: Verify if a connection to the JAS has been established.
*/ if
(remoteJSBS_StandardEJBBean
== null)
{/* *
de: Keine Verbindung zum JAS; Fehler zurückmelden. *
en: No connection to the JAS; report error.
*/ this.StatusCode
=
JSBS_Currency_BO.CONST_DB_UNKNOWN_ERROR; this.StatusMsg
=
"No
connection to JAS; method:
JSBS_Currency_BOC.selectByISOCurrencyCode()"; return;
}/*
de: *
Aufrufen der 'Wrapper'-Methode des EJB. In dieser 'Wrapper'-Methode
wird die - zu diesem *
Client-seitigen Teil des BO - passende Server-seitige Methode
aufgerufen. *
Neue Werte für die Variablen des BO und eventuelle Fehlermeldungen
sind im zurückgelieferten *
BO enthalten. *
en: *
Call the 'wrapper'-method of the EJB. Within this 'wrapper'-method
the server-side method *
- which fits this method of the client-side derivation of the BO - is
called. *
New values for variables of the BO and probably occured
error-messages are contained in the *
returned BO. */
JSBS_Currency_BO_Set
boJSBS_Currency_BO_Set =
remoteJSBS_StandardEJBBean.
JSBS_Currency_BO_Set__selectByISOCurrencyCode(frmTask.structMinParm,
parmISOCurrencyCode);/*
de: *
Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil
des BO) kopieren. *
en: *
Copy the values of the returned BO to this BOC (client-side
derivation of the BO). */
this.copyFromJSBS_Currency_BO_Set(boJSBS_Currency_BO_Set);
} catch (Exception
e) {/*
de: *
Fehler beim Ausführen der Methode des EJB. *
Fehlermeldung aus der Exception übernehmen und Status setzen. *
en: *
Error when executing the method of the EJB. *
Transfer the error-message from the Exception and set status.
*/ this.StatusCode
=
JSBS_Currency_BO.CONST_DB_UNKNOWN_ERROR; this.StatusMsg
= e.getMessage();
} }
/*
* --------------------
*
de:
* METHODE zum Lesen aller aktuell gültigen Währungen von
der Datenbank.
* en: *
METHOD to read all currencies valid at the actual data from the
database. */
public
void selectByISOCurrencyCode(String
parmISOCurrencyCode) {/*
*
de: Entscheiden mit welcher Version das Anwendungsprogramm läuft. *
en: Decide what version the application runs. */
switch
(frmCC.RunVersion)
{
case
JSBS_StartFrame.CONST_StandAlone:/*
de: *
Einzelplatzversion. Datenbank läuft auf der lokalen Maschine;
Spezielle Methode aufrufen. *
en: *
Stand-alone version. Database is running on the local machine; call
the specialized method. */
selectByISOCurrencyCode_DB(parmISOCurrencyCode);
break;
case
JSBS_StartFrame.CONST_FatClient:/*
de: *
Client-Server-Version. *
Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java
Application Server); spezielle Methode aufrufen. *
en: *
Client-Server-version. *
Data is accessed via the EJB-mechanism and the JAS (Java Application
Server); call the specialized method. */
selectByISOCurrencyCode_JAS(parmISOCurrencyCode);
break;
case
JSBS_StartFrame.CONST_MobileClient:/*
de: *
Zuerst die Daten von der lokalen Datenbank abfragen.
Per
Definition muss das immer möglich sein. *
en: *
Read the data from the local database. As per definition this must
always be possible. */
selectByISOCurrencyCode_DB(parmISOCurrencyCode);/*
de: *
Prüfen, ob ein Fehler bei der Abfrage auf der lokalen Datenbank
aufgetreten ist. In diesem Fall die *
Methode beenden - damit ist der Status für die aufrufende Methode
verfügbar. *
en: *
Verify, if an error occured when reading the local database. In that
case end this method - that makes *
the status available for the calling method. */
if
((this.StatusCode
==
JSBS_BO.CONST_OK)
|| (this.StatusCode
==
JSBS_BO.CONST_NOT_FOUND))
{/*
de: 'Erlaubte' Status-Codes für die Abfrage von der lokalen
Datenbank. *
en: 'Permitted' status-codes for the read from the local database.
*/
}
else
return;/*
de: *
Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt
die weitere Verarbeitung. *
en: *
Verify, if the connection to the JAS exists. The further processing
depends
on the result. */
if
(frmCC.testJASConnection())
{/*
de: *
BO-Sets für die Daten der lokalen Datenbank und den Daten vom JAS
konstruieren. *
Damit können später die jeweiligen Daten verglichen und
Unterschiede behandelt werden. *
en: *
Construct BO-Sets for the data from the local database and the data
from the JAS. *
This allows to compare the data later and process differences. */
JSBS_Currency_BO_Set
structJSBS_Currency_BO_Set_Local = new
JSBS_Currency_BO_Set();
JSBS_Currency_BO_Set
structJSBS_Currency_BO_Set_JAS = new
JSBS_Currency_BO_Set();/*
de: *
Ergebnis der Abfrage der lokalen Datenbank auf die dafür vorgesehene
Variable übertragen und den *
Vector mit den BO in diesem Objekt leeren. *
en: *
Transfer the result of the read from the local database to the
variable designated for that. *
Empty the vector with the BO within this object thereafter. */
structJSBS_Currency_BO_Set_Local.copyFromJSBS_Currency_BO_Set(this);
vecRecordSet.removeAllElements();/*
de: Daten vom JAS abfragen. *
en: Read the data from the JAS. */
selectByISOCurrencyCode_JAS(parmISOCurrencyCode);/*
de: *
Prüfen, ob ein Fehler bei der Abfrage vom JAS aufgetreten ist. In
diesem Fall die *
Methode beenden - damit ist der Status für die aufrufende Methode
verfügbar. *
en: *
Verify, if an error occured when reading from the JAS. In that case
end this method - that makes *
the status available for the calling method. */
if
((this.StatusCode
==
JSBS_BO.CONST_OK)
|| (this.StatusCode
==
JSBS_BO.CONST_NOT_FOUND))
{/*
de: 'Erlaubte' Status-Codes für die Abfrage über den JAS. *
en: 'Permitted' status-codes for the read via the JAS.
*/
}
else
return;/*
de: *
Ergebnis der Abfrage über den JAS auf die dafür vorgesehene
Variable übertragen und den *
Vector mit den BO in diesem Objekt leeren. *
en: *
Transfer the result of the read via the JAS to the variable
designated for that. *
Empty the vector with the BO within this object thereafter. */
structJSBS_Currency_BO_Set_JAS.copyFromJSBS_Currency_BO_Set(this);
vecRecordSet.removeAllElements();/*
de: Methode zum Abgleich der Daten von beiden Quellen aufrufen. *
en: Call the method that merges the data from both sources. */
mergeList(structJSBS_Currency_BO_Set_Local,
structJSBS_Currency_BO_Set_JAS);/*
de: *
Methode zum Sortieren nach dem Währungs-Code aufrufen weil die BO nach
dem Abgleich nach *
ihrer Herkunft sortiert sind. *
en: *
Call the method to sort by currency-code as the BO are sorted by
their source after the merge. */
sortByLeadingCurrency_ISOCurrencyCode_LanguageCodeForLabelling();
}
break;
}
/*
* de: Methode aufrufen, die die Matrix für die
Anzeige der Daten erstellt.
* en: Call the method that
builds the matrix for the display of the data.
*/
buildRawDataVector();
}
}
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 |
|
|
|