Seitenhistorie

...

Über den Entitäten-Wizard muss dann die tatsächlich genutzte Währungsentität als Referenzentität in die Attribute "Basiswährung" und "Zielwährung" der beiden Entitäten "Wechselkurs" und "Währungsrechner" eingetragen werden.

Schritt 5: Objektimporte Objektimport anlegen

Objektimport („Konfiguration“ > „Import & Export“) anlegen zur Strukturdefinition „Currency Converter“. Dazu kann die mitgelieferte CSV-Dateien Datei „Currency_Converter.csv“ (zu finden im Unterverzeichnis „data“ der ZIP-Datei) verwendet werden.

Schritt 6: Objektimport ausführen

Wenn der angelegte Objektimport ausgeführt wird, wird ein Währungsrechner-Objekt angelegt.

Hinweis
Achtung: Voraussetzung ist die Existenz der zwei Währungen EUR und USD.

...

Schritt 7: Zuordnung von Regeln im Regelmanagement

...

Quellnuclet	Regeltyp	Regel	Zielnuclet	Entität
ExchangeRates	Aktualisieren	ValidateBaseCurrency	das Nuclet, in dem die tatsächlich von Ihnen genutzte Währungsentität liegt	ihre eigene Währungsentität
ExchangeRates	Anlegen	ValidateBaseCurrency	das Nuclet, in dem die tatsächlich von Ihnen genutzte Währungsentität liegt	ihre eigene Währungsentität
ExchangeRates	Löschen	ValidateBaseCurrency	das Nuclet, in dem die tatsächlich von Ihnen genutzte Währungsentität liegt	ihre eigene Währungsentität

Schritt 8: Anpassungen in den Java-Regeln

eigene Währungsentität
ExchangeRates	Löschen	ValidateBaseCurrency	das Nuclet, in dem die tatsächlich von Ihnen genutzte Währungsentität liegt	ihre eigene Währungsentität

Schritt 8: Anpassungen in den Java-Regeln

Das Wechselkurs-Nuclet funktioniert mit jeder beliebigen Währungsentität, daher sind bei einer Integration einige Anpassungen in den Java-Regeln durchzuführen:

	Java-Package	Java-Regel	Kurzbeschreibung
a	org.nuclet.exchangerates.wrapper	CurrencyWrapper	Wrapper-Objekt für Währungen, d.h. hier wird eine Schnittstelle zur tatsächlich genutzten Währungsentität definiert
b	org.nuclet.exchangerates.facade	CurrencyFacade	Definition von notwendigen Datenbankzugriffen auf die tatsächlich genutzte Währungsentität
c	org.nuclet.exchangerates.rule	ValidateBaseCurrency	Nutzung des in 8a) definierten Wrapper-Objekts, d.h. das Business-Objekt der Währungsentität aus dem RuleContext wird "gewrappt"

a) CurrencyWrapper

Die Klasse CurrencyWrapper dient als Nuclet-Schnittstelle zur tatsächlich genutzten Währungsentität. Der Methoden und der Konstruktor der Klasse sind mit anwendungsspezifischem Verhalten zu befüllen. Beispiele dazu sind jeweils in Kommentarblöcken angegeben; diese Beispiele sind bei der Integration also an die tatächlich genutzte Währungsentität (bzw. deren BusinessObject-Klasse) anzupassen.

Codeblock

language	java
title	org.nuclet.exchangerates.wrapper.CurrencyWrapper
collapse	true

package org.nuclet.exchangerates.wrapper;


import org.nuclos.api.businessobject.BusinessObject;

// @replace
//
// mit eigenem Code zu ersetzen, Beispiel:
//
// import org.nuclet.currency.Currency;


/**
 * Konkrete Wrapper-Klasse für Währungsobjekte
 * 
 */
public class CurrencyWrapper extends AbstractCurrencyWrapper 
{
    public CurrencyWrapper(final BusinessObject currency)
    {
        // @replace Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
        //
        // Beispiel:
        //
        // if (currency instanceof Currency) {
        //    this.businessObject = currency;
        // }
    }
    
    /**
     * Liefert die Datenbank-ID des Währungsobjektes.
     */
    public Long getId()
    {
        return this.businessObject.getId();
    }
 
    /**
     * Liefert den ISO-4217-Code des Währungsobjektes.
     * @see https://de.wikipedia.org/wiki/ISO_4217
     * @see https://en.wikipedia.org/wiki/ISO_4217
     */
    public String getIso4217Code()
    {
        // @replace Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
        //
        // Beispiel:
        //
        // return ((Currency)this.businessObject).getIso4217Code();
        
        return null;
    }
    
    /**
     * Liefert die Anzahl der Nachkommastellen im Währungssystem der Währung
     * 
     * @return die Anzahl der Nachkommastellen im Währungssystem der Währung
     */
    public Integer getNumberOfDigits()
    {
        // @replace Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
        //
        // Beispiel:
        //
        // return ((Currency)this.businessObject).getNumberOfDigits();
        
        return null;
    }
    
    /**
     * Yields information, if the currency is marked as "base currency" 
     * 
     * @return true, falls die Währungs als "base currency" markiert ist
     */
    public Boolean getIsBaseCurrency()
    {
        // @replace Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
        //
        // Beispiel:
        //
        // return ((Currency)this.businessObject).getIsBaseCurrency();
        
        return null;
    }
}

b) CurrencyFacade

In der Klasse CurrencyFacade sind die Methoden getBaseCurrencies() und getCurrencyByIso4217Code() mit anwendungsspezifischem Verhalten gefüllt werden. Ein Beispiel dazu ist jeweils in einem Kommentarblock angegeben, dieses Beispiel ist an die tatächlich genutzte Währungsentität (bzw. deren BusinessObject-Klasse) anzupassen.

Codeblock

language	java
title	org.nuclet.exchangerates.facade.CurrencyFacade

package org.nuclet.exchangerates.facade;


import java.util.ArrayList;
import java.util.List;

import org.nuclos.api.businessobject.Query;
import org.nuclos.api.businessobject.QueryOperation;
import org.nuclos.api.businessobject.SearchExpression;
import org.nuclos.api.context.JobContext;
import org.nuclos.api.context.RuleContext;
import org.nuclos.api.exception.BusinessException; 
import org.nuclos.api.provider.QueryProvider;
import org.nuclos.api.provider.BusinessObjectProvider;

import org.nuclet.exchangerates.wrapper.AbstractCurrencyWrapper;
import org.nuclet.exchangerates.wrapper.CurrencyWrapper;

// @replace! Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
//
// Beispiel:
// 
// import org.nuclet.currency.Currency;


/**
 * Facade for Business Objects of type "Currency"
 * 
 */
public class CurrencyFacade extends AbstractCurrencyFacade
{        
    public CurrencyFacade(final JobContext jobContext)
    {
        super(jobContext);
    }
    
    public CurrencyFacade(final RuleContext ruleContext)
    {
        super(ruleContext);
    }
       
    /**
     * Liefert die Singleton-Instanz dieser Klasse
     *
     */
    public static CurrencyFacade getInstance(final JobContext jobContext)
    {
        return new CurrencyFacade(jobContext);
    }
    
    public static CurrencyFacade getInstance(final RuleContext ruleContext)
    {
        return new CurrencyFacade(ruleContext);
    }
    
    /**
     * Fetches all currencies marked as "base currency" from the database and returns
     * a list of wrapped currency objects
     * 
     * @return a list of wrapped currency objects
     */
    protected List<AbstractCurrencyWrapper> getBaseCurrencies() throws BusinessException
    {
        // @replace! Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
        //
        // Beispiel:
        // 
        // final Query<Currency> queryGetBaseCurrency = QueryProvider.create(Currency.class);
        // queryGetBaseCurrency.where(new SearchExpression(Currency.IsBaseCurrency, Boolean.TRUE, QueryOperation.EQUALS));
        //                
        // final List<Currency> lstBaseCurrencies = QueryProvider.execute(queryGetBaseCurrency);
        // final List<AbstractCurrencyWrapper> lstWrappedBaseCurrencies = new ArrayList<AbstractCurrencyWrapper>();
        //    
        // for (final Currency currency : lstBaseCurrencies) {
        //     lstWrappedBaseCurrencies.add(new CurrencyWrapper(currency));
        // }
         
        // return lstWrappedBaseCurrencies;
        
        return null;
    }
    
    /**
     * Fetches the currency which determined by a given ISO 4217 code from the database
     * 
     * @param strIso4217Code the ISO 4217 code of the currency to be found
     * 
     * @return the currency which is marked as "base currency" from the database
     * @throws BusinessException, if more than one currency-objects are found 
     */
    public AbstractCurrencyWrapper getCurrencyByIso4217Code(final String strIso4217Code)
    {
        // @replace! Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
        //
        // Beispiel:
        // 
        //  final Query<Currency> queryGetCurrency = QueryProvider.create(Currency.class);
        //  queryGetCurrency.where(Currency.Iso4217Code.eq(strIso4217Code));
        //                 
        //  final List<Currency> listCurrency = QueryProvider.execute(queryGetCurrency);
        //     
        //  if (listCurrency != null && listCurrency.size() > 0) {    
        //     return new CurrencyWrapper(listCurrency.get(0));
        //  } else {
        //      return null;
        //  }
        
        return null;
    }
    
    
        
}

c) ValidateBaseCurrency

In der Regel ValidateBaseCurrency ist die BusinessObject-Klasse des tatsächlich genutzte Währungsobjektes einzutragen.

Codeblock

language	java
title	org.nuclet.exchangerates.rule.ValidateBaseCurrency

package org.nuclet.exchangerates.rule;
 
import org.nuclos.api.rule.DeleteRule;
import org.nuclos.api.rule.InsertRule;
import org.nuclos.api.rule.UpdateRule;
import org.nuclos.api.context.DeleteContext;
import org.nuclos.api.context.InsertContext;
import org.nuclos.api.context.RuleContext;
import org.nuclos.api.context.UpdateContext;
import org.nuclos.api.annotation.Rule;
import org.nuclos.api.exception.BusinessException;
import org.nuclos.api.provider.BusinessObjectProvider;
import org.nuclos.api.provider.QueryProvider;
 
import org.nuclet.common.rule.AbstractRule;   

import org.nuclet.exchangerates.logic.CurrencyLogic;
import org.nuclet.exchangerates.wrapper.AbstractCurrencyWrapper;
import org.nuclet.exchangerates.wrapper.CurrencyWrapper;

// @replace! Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
//
// Beispiel:
//   
// import org.nuclet.currency.Currency;

/** 
 * @name ValidateBaseCurrency      
 * @description Checks if exactly one base currency is declared
 * @usage      
 * @change  
 * 
 * 
 */
@Rule(name="ValidateBaseCurrency", description="Checks if exactly one base currency is declared")
public class ValidateBaseCurrency extends AbstractRule implements InsertRule, UpdateRule, DeleteRule
{
    public void insert(InsertContext context) throws BusinessException 
    {
        // @replace Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
        //
        // Beispiel:
        //
        // validateBaseCurrency(context, new CurrencyWrapper(context.getBusinessObject(Currency.class)));
    }
    
    public void update(UpdateContext context) throws BusinessException 
    {
        // @replace Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
        //
        // Beispiel:
        //
        // validateBaseCurrency(context, new CurrencyWrapper(context.getBusinessObject(Currency.class)));     
    }
    
    public void delete(DeleteContext context) throws BusinessException 
    {
        // @replace Bitte bei Nuclet-Integration mit eigenem Code ersetzen!
        //
        // Beispiel:
        //
        // validateBaseCurrency(context, new CurrencyWrapper(context.getBusinessObject(Currency.class)));            
    }
    
    
    private void validateBaseCurrency(final RuleContext context,
        final AbstractCurrencyWrapper currency) throws BusinessException     
    {
        initialize(context);
        
        final CurrencyLogic currencyLogic = new CurrencyLogic(context);
        currencyLogic.validateCurrency(currency); 
    }
}

Schritt Schritt 9: Layout-Anpassungen

Im Layout "Currency" können Sie die Wechselkurse als Unterformular einbinden.

...

Version	Datum	Typ	Änderungen
1.0.0	12.08.2013	initiale Version	Trennung von Wechselkursfunktionalität und Währungsentität aus Currency-Nuclet

...

Seitenhierarchie

Versionen im Vergleich

Alte Version 19

Neue Version 20

Schlüssel