View Javadoc

1   ////////////////////////////////////////////////////////////////////////////////
2   //CabaWeb
3   //Copyright (C) 2004  Thomas Vogt <Thomas.Vogt@TVC-Software.com>
4   //
5   //This library is free software; you can redistribute it and/or
6   //modify it under the terms of the GNU Lesser General Public
7   //License as published by the Free Software Foundation; either
8   //version 2.1 of the License, or (at your option) any later version.
9   //
10  //This library is distributed in the hope that it will be useful,
11  //but WITHOUT ANY WARRANTY; without even the implied warranty of
12  //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  //Lesser General Public License for more details.
14  //
15  //You should have received a copy of the GNU Lesser General Public
16  //License along with this library; if not, write to the Free Software
17  //Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  ////////////////////////////////////////////////////////////////////////////////
19  
20  package org.fhw.cabaweb.data.initialdata;
21  
22  import java.util.Collection;
23  import java.util.Iterator;
24  
25  import org.apache.commons.logging.Log;
26  import org.apache.commons.logging.LogFactory;
27  
28  import org.fhw.cabaweb.data.DataInterfaceErgebnissdatenFeldbeschreibungen;
29  import org.fhw.cabaweb.data.DataInterfaceErgebnissdatenFeldnamen;
30  import org.fhw.cabaweb.data.DataInterfaceErgebnissdatenGruppierungsbeschreibungen;
31  import org.fhw.cabaweb.data.DataInterfaceErgebnissdatenGruppierungsnamen;
32  import org.fhw.cabaweb.data.DataInterfaceErgebnissdatenUntergruppierungsbeschreibungen;
33  import org.fhw.cabaweb.data.DataInterfaceErgebnissdatenUntergruppierungsnamen;
34  import org.fhw.cabaweb.data.DataInterfaceProjekte;
35  import org.fhw.cabaweb.data.DataInterfaceSprachen;
36  import org.fhw.cabaweb.data.constants.Constants;
37  import org.fhw.cabaweb.ojb.dataobjects.Ergebnissdaten_Feldbeschreibungen;
38  import org.fhw.cabaweb.ojb.dataobjects.Ergebnissdaten_Feldnamen;
39  import org.fhw.cabaweb.ojb.dataobjects.Ergebnissdaten_Gruppierungsbeschreibungen;
40  import org.fhw.cabaweb.ojb.dataobjects.Ergebnissdaten_Gruppierungsnamen;
41  import org.fhw.cabaweb.ojb.dataobjects.Ergebnissdaten_Untergruppierungsbeschreibungen;
42  import org.fhw.cabaweb.ojb.dataobjects.Ergebnissdaten_Untergruppierungsnamen;
43  import org.fhw.cabaweb.ojb.dataobjects.Projekte;
44  import org.fhw.cabaweb.ojb.dataobjects.Sprachen;
45  
46  /***
47   * Die Klasse tr&auml;gt die Startwerte (Zuordnungen) für die Ergebnisdaten in die Tabellen ein.
48   *
49   * @author  <a href="mailto:thomas.vogt@tvc-software.com">Thomas Vogt</a>
50   * @version Version 1.0 01.09.2004
51   */
52  public final class ErgebnissDatenInitialisierung
53  {
54      /*** Commons Logging Instanz */
55      private static Log log = LogFactory.getLog("org.fhw.cabaweb.data.initialdata.ErgebnissDatenInitialisierung");
56  
57      /* ----- Konstruktoren / Destruktoren ----- */
58  
59      /***
60       * Standardkonstruktor der nicht zug&auml;nglich sein soll, da dies eine Utility Klasse ist
61       */
62      protected ErgebnissDatenInitialisierung()
63      {
64          throw new UnsupportedOperationException(); // Aufrufe aus eventuellen SubKlassen verhindern
65      }
66  
67      /***
68       * Tr&auml;gt die Startwerte (Zuordnungen) für die Ergebnisdaten in die Datenbank ein
69       *
70       * @param projektnummer Die Projektnummer
71       */
72      public final static void ergebnissDatenInitialisieren(Integer projektnummer)
73      {
74          boolean returnvalue = true;
75  
76          /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
77          DataInterfaceProjekte dip = new DataInterfaceProjekte();
78          /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
79          DataInterfaceSprachen dis = new DataInterfaceSprachen();
80          /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
81          DataInterfaceErgebnissdatenGruppierungsnamen dieg = new DataInterfaceErgebnissdatenGruppierungsnamen();
82          /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
83          DataInterfaceErgebnissdatenGruppierungsbeschreibungen diegb = new DataInterfaceErgebnissdatenGruppierungsbeschreibungen();
84          /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
85          DataInterfaceErgebnissdatenUntergruppierungsnamen dieug = new DataInterfaceErgebnissdatenUntergruppierungsnamen();
86          /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
87          DataInterfaceErgebnissdatenUntergruppierungsbeschreibungen dieugb = new DataInterfaceErgebnissdatenUntergruppierungsbeschreibungen();
88          /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
89          DataInterfaceErgebnissdatenFeldnamen dief = new DataInterfaceErgebnissdatenFeldnamen();
90          /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
91          DataInterfaceErgebnissdatenFeldbeschreibungen diefb = new DataInterfaceErgebnissdatenFeldbeschreibungen();
92  
93          Projekte projekt = (Projekte) dip.sucheProjektnummer(projektnummer);
94          Collection sprachen = dis.sucheSprachname(Constants.DEUTSCH_KEY);
95          Sprachen sprache = null;
96          Iterator sprachenIterator = sprachen.iterator();
97          if (sprachenIterator.hasNext())
98          {
99              sprache = (Sprachen) sprachenIterator.next();
100         }
101 
102         /* Ergebnissdaten Gruppierungsnamen */
103         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_GRUNDDATEN_KEY));
104         if (!returnvalue)
105             log.error(" FAILED");
106         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_ERFOLGSRECHNUNG_KEY));
107         if (!returnvalue)
108             log.error(" FAILED");
109         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_VERMOEGENSRECHNUNG_KEY));
110         if (!returnvalue)
111             log.error(" FAILED");
112         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_FINANZIERUNG_KEY));
113         if (!returnvalue)
114             log.error(" FAILED");
115         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_ENTSCHEIDUNGEN_KEY));
116         if (!returnvalue)
117             log.error(" FAILED");
118         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_MARKTFORSCHUNGSDIENST_KEY));
119         if (!returnvalue)
120             log.error(" FAILED");
121         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_VOLLKOSTENRECHNUNG_KEY));
122         if (!returnvalue)
123             log.error(" FAILED");
124         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_GRENZKOSTENRECHNUNG_KEY));
125         if (!returnvalue)
126             log.error(" FAILED");
127         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_BEWERTUNGSUEBERBLICK_KEY));
128         if (!returnvalue)
129             log.error(" FAILED");
130         returnvalue = dieg.erzeugen(new Ergebnissdaten_Gruppierungsnamen(null, projekt, Constants.EG_NICHTZUGEORDNET_KEY));
131         if (!returnvalue)
132             log.error(" FAILED");
133 
134         /* Ergebnissdaten Gruppierungsbeschreibungen und Untergruppierungsnamen*/
135         Collection ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_GRUNDDATEN_KEY);
136         Ergebnissdaten_Gruppierungsnamen ergebnissdatenGruppierungsname = null;
137         Iterator ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
138         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
139         {
140             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
141         }
142         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Tabelle 20", "Tabelle 20: Ergebnisse zu den Grunddaten"));
143         if (!returnvalue)
144             log.error(" FAILED");
145         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_GRUNDDATENINDICES_KEY));
146         if (!returnvalue)
147             log.error(" FAILED");
148         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_GRUNDDATENVERTRIEB_KEY));
149         if (!returnvalue)
150             log.error(" FAILED");
151         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_GRUNDDATENPRODUKTION_KEY));
152         if (!returnvalue)
153             log.error(" FAILED");
154         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_GRUNDDATENBESCHAFFUNG_KEY));
155         if (!returnvalue)
156             log.error(" FAILED");
157 
158         ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_ERFOLGSRECHNUNG_KEY);
159         ergebnissdatenGruppierungsname = null;
160         ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
161         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
162         {
163             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
164         }
165         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Tabelle 21", "Tabelle 21: Ergebnisse zur Erfolgsrechnung"));
166         if (!returnvalue)
167             log.error(" FAILED");
168         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_ERFOLGSRECHNUNGVERTRIEB_KEY));
169         if (!returnvalue)
170             log.error(" FAILED");
171         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_ERFOLGSRECHNUNGPRODUKTION_KEY));
172         if (!returnvalue)
173             log.error(" FAILED");
174         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_ERFOLGSRECHNUNGBESCHAFFUNG_KEY));
175         if (!returnvalue)
176             log.error(" FAILED");
177         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_ERFOLGSRECHNUNGOVERHEAD_KEY));
178         if (!returnvalue)
179             log.error(" FAILED");
180         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_ERFOLGSRECHNUNGERFOLGSVERWENDUNG_KEY));
181         if (!returnvalue)
182             log.error(" FAILED");
183 
184         ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_VERMOEGENSRECHNUNG_KEY);
185         ergebnissdatenGruppierungsname = null;
186         ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
187         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
188         {
189             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
190         }
191         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Tabelle 22", "Tabelle 22: Ergebnisse zur Verm&ouml;gensrechnung"));
192         if (!returnvalue)
193             log.error(" FAILED");
194         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_VERMOEGENSRECHNUNGAKTIVA_KEY));
195         if (!returnvalue)
196             log.error(" FAILED");
197         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_VERMOEGENSRECHNUNGPASSIVA_KEY));
198         if (!returnvalue)
199             log.error(" FAILED");
200 
201         ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_FINANZIERUNG_KEY);
202         ergebnissdatenGruppierungsname = null;
203         ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
204         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
205         {
206             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
207         }
208         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Tabelle 23", "Tabelle 23: Ergebnisse zur Finanzierung"));
209         if (!returnvalue)
210             log.error(" FAILED");
211         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_FINANZIERUNGENDEVQ_KEY));
212         if (!returnvalue)
213             log.error(" FAILED");
214         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_FINANZIERUNGLAUFENDESQUARTAL_KEY));
215         if (!returnvalue)
216             log.error(" FAILED");
217         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_FINANZIERUNGUMFANZIERUNG_KEY));
218         if (!returnvalue)
219             log.error(" FAILED");
220         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_FINANZIERUNGZINSEN_KEY));
221         if (!returnvalue)
222             log.error(" FAILED");
223         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_FINANZIERUNGLIQUIDITAETSAENDERUNG_KEY));
224         if (!returnvalue)
225             log.error(" FAILED");
226 
227         ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_ENTSCHEIDUNGEN_KEY);
228         ergebnissdatenGruppierungsname = null;
229         ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
230         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
231         {
232             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
233         }
234         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Tabelle 24", "Tabelle 24: Tats&auml;chliche Entscheidungen des Unternehmens"));
235         if (!returnvalue)
236             log.error(" FAILED");
237         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_ENTSCHEIDUNGENVERTRIEB_KEY));
238         if (!returnvalue)
239             log.error(" FAILED");
240         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_ENTSCHEIDUNGENPRODUKTION_KEY));
241         if (!returnvalue)
242             log.error(" FAILED");
243         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_ENTSCHEIDUNGENFINANZIERUNG_KEY));
244         if (!returnvalue)
245             log.error(" FAILED");
246         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_ENTSCHEIDUNGENSONSTIGE_KEY));
247         if (!returnvalue)
248             log.error(" FAILED");
249 
250         ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_MARKTFORSCHUNGSDIENST_KEY);
251         ergebnissdatenGruppierungsname = null;
252         ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
253         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
254         {
255             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
256         }
257         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Tabelle 25", "Tabelle 25: Marktforschungsdienst"));
258         if (!returnvalue)
259             log.error(" FAILED");
260 
261         ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_VOLLKOSTENRECHNUNG_KEY);
262         ergebnissdatenGruppierungsname = null;
263         ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
264         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
265         {
266             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
267         }
268         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Tabelle A1.1", "Tabelle A1.1: Ergebnisse zur Voll-Kostenrechnung"));
269         if (!returnvalue)
270             log.error(" FAILED");
271         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_VOLLKOSTENRECHNUNGERLOES_KEY));
272         if (!returnvalue)
273             log.error(" FAILED");
274         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_VOLLKOSTENRECHNUNGKOSTEN_KEY));
275         if (!returnvalue)
276             log.error(" FAILED");
277         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_VOLLKOSTENRECHNUNGGEWINN_KEY));
278         if (!returnvalue)
279             log.error(" FAILED");
280         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_VOLLKOSTENRECHNUNGPRODUZIERTEMENGE_KEY));
281         if (!returnvalue)
282             log.error(" FAILED");
283         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_VOLLKOSTENRECHNUNGABGESETZTEMENGE_KEY));
284         if (!returnvalue)
285             log.error(" FAILED");
286 
287         ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_GRENZKOSTENRECHNUNG_KEY);
288         ergebnissdatenGruppierungsname = null;
289         ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
290         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
291         {
292             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
293         }
294         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Tabelle A1.2", "Tabelle A1.2: Ergebnisse zur Grenz-Kostenrechnung"));
295         if (!returnvalue)
296             log.error(" FAILED");
297         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_GRENZKOSTENRECHNUNGGRENZERLOES_KEY));
298         if (!returnvalue)
299             log.error(" FAILED");
300         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_GRENZKOSTENRECHNUNGGRENZMARKETINGKOSTEN_KEY));
301         if (!returnvalue)
302             log.error(" FAILED");
303         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_GRENZKOSTENRECHNUNGGRENZHERSTELLKOSTEN_KEY));
304         if (!returnvalue)
305             log.error(" FAILED");
306         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_GRENZKOSTENRECHNUNGGRENZGEWINN_KEY));
307         if (!returnvalue)
308             log.error(" FAILED");
309         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_GRENZKOSTENRECHNUNGPRODUKTIONLETZTEZONE_KEY));
310         if (!returnvalue)
311             log.error(" FAILED");
312 
313         ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_BEWERTUNGSUEBERBLICK_KEY);
314         ergebnissdatenGruppierungsname = null;
315         ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
316         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
317         {
318             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
319         }
320         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Bewertungs&uuml;berblick", "Bewertungs&uuml;berblick"));
321         if (!returnvalue)
322             log.error(" FAILED");
323         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_BEWERTUNGSUEBERBLICKUNTERNEHMENSBEWERTUNG_KEY));
324         if (!returnvalue)
325             log.error(" FAILED");
326         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_BEWERTUNGSUEBERBLICKKOORDINATIONSBEWERTUNG_KEY));
327         if (!returnvalue)
328             log.error(" FAILED");
329         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_BEWERTUNGSUEBERBLICKVERTRIEBSBEWERTUNG_KEY));
330         if (!returnvalue)
331             log.error(" FAILED");
332         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_BEWERTUNGSUEBERBLICKPRODUKTIONSBEWERTUNG_KEY));
333         if (!returnvalue)
334             log.error(" FAILED");
335         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_BEWERTUNGSUEBERBLICKFINANZIERUNGSBEWERTUNG_KEY));
336         if (!returnvalue)
337             log.error(" FAILED");
338 
339         ergebnissdatenGruppierungsnamen = dieg.sucheGruppierungsname(projektnummer, Constants.EG_NICHTZUGEORDNET_KEY);
340         ergebnissdatenGruppierungsname = null;
341         ergebnissdatenGruppierungsnamenIterator = ergebnissdatenGruppierungsnamen.iterator();
342         if (ergebnissdatenGruppierungsnamenIterator.hasNext())
343         {
344             ergebnissdatenGruppierungsname = (Ergebnissdaten_Gruppierungsnamen) ergebnissdatenGruppierungsnamenIterator.next();
345         }
346         returnvalue = diegb.erzeugen(new Ergebnissdaten_Gruppierungsbeschreibungen(ergebnissdatenGruppierungsname, sprache, "Nicht zugeordnet", "Nicht zugeordnet"));
347         if (!returnvalue)
348             log.error(" FAILED");
349         returnvalue = dieug.erzeugen(new Ergebnissdaten_Untergruppierungsnamen(null, ergebnissdatenGruppierungsname, Constants.EUG_NICHTZUGEORDNET_KEY));
350         if (!returnvalue)
351             log.error(" FAILED");
352 
353         /* Ergebnissdaten Untergruppierungsbeschreibungen und Feldnamen*/
354         Collection ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_GRUNDDATENINDICES_KEY);
355         Ergebnissdaten_Untergruppierungsnamen ergebnissdatenUntergruppierungsname = null;
356         Iterator ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
357         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
358         {
359             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
360         }
361         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(1) INDICES", "(1) INDICES"));
362         if (!returnvalue)
363             log.error(" FAILED");
364         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double6", Constants.EF_GRUNDDATENINFLATIONSRATE_KEY));
365         if (!returnvalue)
366             log.error(" FAILED");
367         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double8", Constants.EF_GRUNDDATENLOHNERHOEHUNG_KEY));
368         if (!returnvalue)
369             log.error(" FAILED");
370         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double10", Constants.EF_GRUNDDATENSAISONINDEX_KEY));
371         if (!returnvalue)
372             log.error(" FAILED");
373         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double11", Constants.EF_GRUNDDATENKONJUNKTURINDEX_KEY));
374         if (!returnvalue)
375             log.error(" FAILED");
376         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(4), "Ergebnissdaten_Double", "double12", Constants.EF_GRUNDDATENINFLATIONSRATEVORHERSAGE_KEY));
377         if (!returnvalue)
378             log.error(" FAILED");
379         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(5), "Ergebnissdaten_Double", "double13", Constants.EF_GRUNDDATENLOHNERHOEHUNGVORHERSAGE_KEY));
380         if (!returnvalue)
381             log.error(" FAILED");
382         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(6), "Ergebnissdaten_Double", "double14", Constants.EF_GRUNDDATENSAISONINDEXVORHERSAGE_KEY));
383         if (!returnvalue)
384             log.error(" FAILED");
385         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(7), "Ergebnissdaten_Double", "double15", Constants.EF_GRUNDDATENKONJUNKURINDEXVORHERSAGE_KEY));
386         if (!returnvalue)
387             log.error(" FAILED");
388 
389         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_GRUNDDATENVERTRIEB_KEY);
390         ergebnissdatenUntergruppierungsname = null;
391         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
392         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
393         {
394             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
395         }
396         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(2) VERTRIEB", "(2) VERTRIEB"));
397         if (!returnvalue)
398             log.error(" FAILED");
399         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(8), "Ergebnissdaten_Integer", "integer20", Constants.EF_UEBERSCHRIFTGRUNDDATENPREISE_KEY));
400         if (!returnvalue)
401             log.error(" FAILED");
402         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(9), "Ergebnissdaten_Double", "double16", Constants.EF_GRUNDDATENVERKAUFSPREISNOMINAL_KEY));
403         if (!returnvalue)
404             log.error(" FAILED");
405         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(10), "Ergebnissdaten_Double", "double17", Constants.EF_GRUNDDATENVERKAUFSPREISREAL_KEY));
406         if (!returnvalue)
407             log.error(" FAILED");
408         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(11), "Ergebnissdaten_Double", "double18", Constants.EF_GRUNDDATENVERKAUFSPREISWIRKSAM_KEY));
409         if (!returnvalue)
410             log.error(" FAILED");
411         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(12), "Ergebnissdaten_Integer", "integer21", Constants.EF_UEBERSCHRIFTGRUNDDATENMENGEN_KEY));
412         if (!returnvalue)
413             log.error(" FAILED");
414         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(13), "Ergebnissdaten_Double", "double19", Constants.EF_GRUNDDATENABSETZBAREMENGE_KEY));
415         if (!returnvalue)
416             log.error(" FAILED");
417         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(14), "Ergebnissdaten_Double", "double20", Constants.EF_GRUNDDATENABSETZBAREMENGEWEGENDEFIZIT_KEY));
418         if (!returnvalue)
419             log.error(" FAILED");
420         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(15), "Ergebnissdaten_Double", "double21", Constants.EF_GRUNDDATENMINDERABSATZWEGENHOHEMPREIS_KEY));
421         if (!returnvalue)
422             log.error(" FAILED");
423         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(16), "Ergebnissdaten_Double", "double22", Constants.EF_GRUNDDATENABGESETZTEMENGE_KEY));
424         if (!returnvalue)
425             log.error(" FAILED");
426         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(17), "Ergebnissdaten_Double", "double23", Constants.EF_GRUNDDATENLIEFERDEFIZIT_KEY));
427         if (!returnvalue)
428             log.error(" FAILED");
429         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(18), "Ergebnissdaten_Integer", "integer22", Constants.EF_UEBERSCHRIFTGRUNDDATENFERTIGPRODUKTE_KEY));
430         if (!returnvalue)
431             log.error(" FAILED");
432         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(19), "Ergebnissdaten_Double", "double24", Constants.EF_GRUNDDATENLAGERZUGANGFERTIGPRODUKTE_KEY));
433         if (!returnvalue)
434             log.error(" FAILED");
435         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(20), "Ergebnissdaten_Double", "double25", Constants.EF_GRUNDDATENLAGERABGANGFERTIGPRODUKTE_KEY));
436         if (!returnvalue)
437             log.error(" FAILED");
438         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(21), "Ergebnissdaten_Double", "double26", Constants.EF_GRUNDDATENLAGERMENGEFERTIGPRODUKTE_KEY));
439         if (!returnvalue)
440             log.error(" FAILED");
441         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(22), "Ergebnissdaten_Integer", "integer23", Constants.EF_UEBERSCHRIFTGRUNDDATENSONSTIGE_KEY));
442         if (!returnvalue)
443             log.error(" FAILED");
444         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(23), "Ergebnissdaten_Double", "double27", Constants.EF_GRUNDDATENMARKTANTEIL_KEY));
445         if (!returnvalue)
446             log.error(" FAILED");
447         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(24), "Ergebnissdaten_Double", "double28", Constants.EF_GRUNDDATENUMSATZANTEIL_KEY));
448         if (!returnvalue)
449             log.error(" FAILED");
450         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(25), "Ergebnissdaten_Integer", "integer24", Constants.EF_GRUNDDATENMARKTFORSCHUNGSDIENST_KEY));
451         if (!returnvalue)
452             log.error(" FAILED");
453         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(26), "Ergebnissdaten_Double", "double29", Constants.EF_GRUNDDATENWIRKSAMEMARKETINGKOSTEN_KEY));
454         if (!returnvalue)
455             log.error(" FAILED");
456 
457         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_GRUNDDATENPRODUKTION_KEY);
458         ergebnissdatenUntergruppierungsname = null;
459         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
460         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
461         {
462             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
463         }
464         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(3) PRODUKTION", "(3) PRODUKTION"));
465         if (!returnvalue)
466             log.error(" FAILED");
467         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(27), "Ergebnissdaten_Integer", "integer25", Constants.EF_UEBERSCHRIFTGRUNDDATENPRODUKTIONSMENGEN_KEY));
468         if (!returnvalue)
469             log.error(" FAILED");
470         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(28), "Ergebnissdaten_Double", "double31", Constants.EF_GRUNDDATENNOMINALEPRODUKTIONSMENGE_KEY));
471         if (!returnvalue)
472             log.error(" FAILED");
473         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(29), "Ergebnissdaten_Double", "double32", Constants.EF_GRUNDDATENFEHLERHAFTEPRODUKTIONSMENGE_KEY));
474         if (!returnvalue)
475             log.error(" FAILED");
476         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(30), "Ergebnissdaten_Double", "double33", Constants.EF_GRUNDDATENNACHBEARBEITETEPRODUKTIONSMENGE_KEY));
477         if (!returnvalue)
478             log.error(" FAILED");
479         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(31), "Ergebnissdaten_Double", "double34", Constants.EF_GRUNDDATENGUTEPRODUKTIONSMENGE_KEY));
480         if (!returnvalue)
481             log.error(" FAILED");
482         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(32), "Ergebnissdaten_Integer", "integer26", Constants.EF_UEBERSCHRIFTGRUNDDATENPRODUKTART_KEY));
483         if (!returnvalue)
484             log.error(" FAILED");
485         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(33), "Ergebnissdaten_Integer", "integer27", Constants.EF_GRUNDDATENPRODUZIERTEPRODUKTART_KEY));
486         if (!returnvalue)
487             log.error(" FAILED");
488         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(34), "Ergebnissdaten_Double", "double35", Constants.EF_GRUNDDATENFORSCHUNGUNDENTWICKLUNGWIRKSAM_KEY));
489         if (!returnvalue)
490             log.error(" FAILED");
491         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(38), "Ergebnissdaten_Integer", "integer28", Constants.EF_GRUNDDATENLIZENZERWERBPRODUKTART_KEY));
492         if (!returnvalue)
493             log.error(" FAILED");
494         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(39), "Ergebnissdaten_Double", "double37", Constants.EF_GRUNDDATENLIZENZERWERBSKOSTEN_KEY));
495         if (!returnvalue)
496             log.error(" FAILED");
497         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(40), "Ergebnissdaten_Integer", "integer30", Constants.EF_GRUNDDATENLIZENZVERKAUFPRODUKTART_KEY));
498         if (!returnvalue)
499             log.error(" FAILED");
500         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(41), "Ergebnissdaten_Double", "double38", Constants.EF_GRUNDDATENLIZENZVERKAUFSERLOESE_KEY));
501         if (!returnvalue)
502             log.error(" FAILED");
503         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(42), "Ergebnissdaten_Integer", "integer32", Constants.EF_GRUNDDATENMAXIMALMOEGLICHEPRODUKTARTFOLGEQUARTAL_KEY));
504         if (!returnvalue)
505             log.error(" FAILED");
506         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(43), "Ergebnissdaten_Integer", "integer33", Constants.EF_UEBERSCHRIFTGRUNDDATENZEITWIRTSCHAFT_KEY));
507         if (!returnvalue)
508             log.error(" FAILED");
509         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(44), "Ergebnissdaten_Double", "double39", Constants.EF_GRUNDDATENFERTIGUNGSZEITPROSTUECK_KEY));
510         if (!returnvalue)
511             log.error(" FAILED");
512         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(45), "Ergebnissdaten_Double", "double41", Constants.EF_GRUNDDATENKAPAZITAETSAUSLASTUNG_KEY));
513         if (!returnvalue)
514             log.error(" FAILED");
515         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(46), "Ergebnissdaten_Double", "double42", Constants.EF_GRUNDDATENKAPAZITAETSBESTANDFOLGEQUARTAL_KEY));
516         if (!returnvalue)
517             log.error(" FAILED");
518         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(47), "Ergebnissdaten_Integer", "integer34", Constants.EF_UEBERSCHRIFTGRUNDDATENKOSTEN_KEY));
519         if (!returnvalue)
520             log.error(" FAILED");
521         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(48), "Ergebnissdaten_Double", "double43", Constants.EF_GRUNDDATENQUALITAETSKOSTEN_KEY));
522         if (!returnvalue)
523             log.error(" FAILED");
524         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(49), "Ergebnissdaten_Double", "double44", Constants.EF_GRUNDDATENQUALITAETSKOSTENNACHARBEITSLOHNKOSTEN_KEY));
525         if (!returnvalue)
526             log.error(" FAILED");
527 
528         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_GRUNDDATENBESCHAFFUNG_KEY);
529         ergebnissdatenUntergruppierungsname = null;
530         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
531         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
532         {
533             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
534         }
535         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(4) BESCHAFFUNG", "(4) BESCHAFFUNG"));
536 //        if (!returnvalue)
537 //            log.error(" FAILED");
538 //        returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(50), "Ergebnissdaten_Integer", "integer35", Constants.EF_UEBERSCHRIFTGRUNDDATENROHSTOFFE_KEY));
539         if (!returnvalue)
540             log.error(" FAILED");
541         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(51), "Ergebnissdaten_Double", "double46", Constants.EF_GRUNDDATENROHSTOFFKAUFNORMALUNDEXPRESS_KEY));
542         if (!returnvalue)
543             log.error(" FAILED");
544         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(52), "Ergebnissdaten_Double", "double47", Constants.EF_GRUNDDATENROHSTOFFVERBRAUCHQUARTAL_KEY));
545         if (!returnvalue)
546             log.error(" FAILED");
547         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(53), "Ergebnissdaten_Double", "double48", Constants.EF_GRUNDDATENROHSTOFFLAGERBESTANDQUARTALSENDE_KEY));
548         if (!returnvalue)
549             log.error(" FAILED");
550         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(54), "Ergebnissdaten_Double", "double49", Constants.EF_GRUNDDATENROHSTOFFWERTQUARTALSENDE_KEY));
551         if (!returnvalue)
552             log.error(" FAILED");
553 
554         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_ERFOLGSRECHNUNGVERTRIEB_KEY);
555         ergebnissdatenUntergruppierungsname = null;
556         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
557         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
558         {
559             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
560         }
561         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(1) VERTRIEB", "(1) VERTRIEB"));
562         if (!returnvalue)
563             log.error(" FAILED");
564         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double51", Constants.EF_ERFOLGSRECHNUNGVERTRIEB_KEY));
565         if (!returnvalue)
566             log.error(" FAILED");
567         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double52", Constants.EF_ERFOLGSRECHNUNGUMSATZERLOESE_KEY));
568         if (!returnvalue)
569             log.error(" FAILED");
570         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double53", Constants.EF_ERFOLGSRECHNUNGMARKETINGKOSTEN_KEY));
571         if (!returnvalue)
572             log.error(" FAILED");
573         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double54", Constants.EF_ERFOLGSRECHNUNGLAGERZUGANGFERTIGPRODUKTE_KEY));
574         if (!returnvalue)
575             log.error(" FAILED");
576         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(4), "Ergebnissdaten_Double", "double55", Constants.EF_ERFOLGSRECHNUNGLAGERABGANGFERTIGPRODUKTE_KEY));
577         if (!returnvalue)
578             log.error(" FAILED");
579         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(5), "Ergebnissdaten_Double", "double56", Constants.EF_ERFOLGSRECHNUNGLAGERUNGSKOSTENFERTIGPRODUKTE_KEY));
580         if (!returnvalue)
581             log.error(" FAILED");
582         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(6), "Ergebnissdaten_Double", "double57", Constants.EF_ERFOLGSRECHNUNGMARKTFORSCHUNGSKOSTEN_KEY));
583         if (!returnvalue)
584             log.error(" FAILED");
585 
586         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_ERFOLGSRECHNUNGPRODUKTION_KEY);
587         ergebnissdatenUntergruppierungsname = null;
588         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
589         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
590         {
591             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
592         }
593         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(2) PRODUKTION", "(2) PRODUKTION"));
594         if (!returnvalue)
595             log.error(" FAILED");
596         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(7), "Ergebnissdaten_Double", "double58", Constants.EF_ERFOLGSRECHNUNGPRODUKTION_KEY));
597         if (!returnvalue)
598             log.error(" FAILED");
599         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(8), "Ergebnissdaten_Double", "double59", Constants.EF_ERFOLGSRECHNUNGFORSCHUNGSUNDENTWICKLUNGSKOSTEN_KEY));
600         if (!returnvalue)
601             log.error(" FAILED");
602         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(9), "Ergebnissdaten_Double", "double60", Constants.EF_ERFOLGSRECHNUNGLIZENZERWERBSKOSTEN_KEY));
603         if (!returnvalue)
604             log.error(" FAILED");
605         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(10), "Ergebnissdaten_Double", "double61", Constants.EF_ERFOLGSRECHNUNGLIZENZVERKAUFSERLOESE_KEY));
606         if (!returnvalue)
607             log.error(" FAILED");
608         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(11), "Ergebnissdaten_Double", "double62", Constants.EF_ERFOLGSRECHNUNGAUFARBEITUNGSKOSTEN_KEY));
609         if (!returnvalue)
610             log.error(" FAILED");
611         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(12), "Ergebnissdaten_Double", "double63", Constants.EF_ERFOLGSRECHNUNGQUALITAETSSICHERUNGSKOSTEN_KEY));
612         if (!returnvalue)
613             log.error(" FAILED");
614         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(13), "Ergebnissdaten_Double", "double64", Constants.EF_ERFOLGSRECHNUNGFERTIGUNGSLOHNKOSTEN_KEY));
615         if (!returnvalue)
616             log.error(" FAILED");
617         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(14), "Ergebnissdaten_Double", "double65", Constants.EF_ERFOLGSRECHNUNGFLKOHNEUEBERSTUNDENUNDNACHARBEIT_KEY));
618         if (!returnvalue)
619             log.error(" FAILED");
620         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(15), "Ergebnissdaten_Double", "double66", Constants.EF_ERFOLGSRECHNUNGUEBERSTUNDENZUSCHLAEGEFLKOHNEUEBERSTUNDENUNDNACHARBEIT_KEY));
621         if (!returnvalue)
622             log.error(" FAILED");
623         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(16), "Ergebnissdaten_Double", "double67", Constants.EF_ERFOLGSRECHNUNGNACHARBEITSKOSTENOHNEUEBERSTUNDEN_KEY));
624         if (!returnvalue)
625             log.error(" FAILED");
626         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(17), "Ergebnissdaten_Double", "double68", Constants.EF_ERFOLGSRECHNUNGUEBERSTUNDENZUSCHLAEGENACHARBEITSKOSTENOHNEUEBERSTUNDEN_KEY));
627         if (!returnvalue)
628             log.error(" FAILED");
629         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(18), "Ergebnissdaten_Double", "double69", Constants.EF_ERFOLGSRECHNUNGSCHICHTWECHSELKOSTEN_KEY));
630         if (!returnvalue)
631             log.error(" FAILED");
632         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(19), "Ergebnissdaten_Double", "double70", Constants.EF_ERFOLGSRECHNUNGABSCHREIBUNGSKOSTEN_KEY));
633         if (!returnvalue)
634             log.error(" FAILED");
635 
636         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_ERFOLGSRECHNUNGBESCHAFFUNG_KEY);
637         ergebnissdatenUntergruppierungsname = null;
638         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
639         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
640         {
641             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
642         }
643         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(3) BESCHAFFUNG", "(3) BESCHAFFUNG"));
644         if (!returnvalue)
645             log.error(" FAILED");
646         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(20), "Ergebnissdaten_Double", "double71", Constants.EF_ERFOLGSRECHNUNGBESCHAFFUNG_KEY));
647         if (!returnvalue)
648             log.error(" FAILED");
649         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(21), "Ergebnissdaten_Double", "double72", Constants.EF_ERFOLGSRECHNUNGANLAGENPROJEKTIERUNGSKOSTEN_KEY));
650         if (!returnvalue)
651             log.error(" FAILED");
652         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(22), "Ergebnissdaten_Double", "double73", Constants.EF_ERFOLGSRECHNUNGROHSTOFFVERBRAUCHSKOSTEN_KEY));
653         if (!returnvalue)
654             log.error(" FAILED");
655         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(23), "Ergebnissdaten_Double", "double74", Constants.EF_ERFOLGSRECHNUNGROHSTOFFBESTELLUNGSKOSTEN_KEY));
656         if (!returnvalue)
657             log.error(" FAILED");
658         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(24), "Ergebnissdaten_Double", "double75", Constants.EF_ERFOLGSRECHNUNGLAGERKOSTENROHSTOFFE_KEY));
659         if (!returnvalue)
660             log.error(" FAILED");
661 
662         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_ERFOLGSRECHNUNGOVERHEAD_KEY);
663         ergebnissdatenUntergruppierungsname = null;
664         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
665         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
666         {
667             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
668         }
669         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(4) OVERHEAD", "(4) OVERHEAD"));
670         if (!returnvalue)
671             log.error(" FAILED");
672         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(25), "Ergebnissdaten_Double", "double76", Constants.EF_ERFOLGSRECHNUNGOVERHEAD_KEY));
673         if (!returnvalue)
674             log.error(" FAILED");
675         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(26), "Ergebnissdaten_Double", "double77", Constants.EF_ERFOLGSRECHNUNGVERWALTUNGSKOSTEN_KEY));
676         if (!returnvalue)
677             log.error(" FAILED");
678         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(27), "Ergebnissdaten_Double", "double78", Constants.EF_ERFOLGSRECHNUNGBERATUNGSKOSTEN_KEY));
679         if (!returnvalue)
680             log.error(" FAILED");
681         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(28), "Ergebnissdaten_Double", "double79", Constants.EF_ERFOLGSRECHNUNGZINSKOSTENKONTOKORRENTKREDIT_KEY));
682         if (!returnvalue)
683             log.error(" FAILED");
684         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(29), "Ergebnissdaten_Double", "double80", Constants.EF_ERFOLGSRECHNUNGZINSKOSTENBANKDARLEHEN_KEY));
685         if (!returnvalue)
686             log.error(" FAILED");
687 
688         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_ERFOLGSRECHNUNGERFOLGSVERWENDUNG_KEY);
689         ergebnissdatenUntergruppierungsname = null;
690         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
691         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
692         {
693             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
694         }
695         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(5) ERFOLGSVERWENDUNG", "(5) ERFOLGSVERWENDUNG"));
696         if (!returnvalue)
697             log.error(" FAILED");
698         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(30), "Ergebnissdaten_Double", "double81", Constants.EF_ERFOLGSRECHNUNGERFOLGVORSTEUERN_KEY));
699         if (!returnvalue)
700             log.error(" FAILED");
701         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(31), "Ergebnissdaten_Double", "double82", Constants.EF_ERFOLGSRECHNUNGSTEUERN_KEY));
702         if (!returnvalue)
703             log.error(" FAILED");
704         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(32), "Ergebnissdaten_Double", "double83", Constants.EF_ERFOLGSRECHNUNGERFOLGNACHSTEUERN_KEY));
705         if (!returnvalue)
706             log.error(" FAILED");
707         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(33), "Ergebnissdaten_Double", "double84", Constants.EF_ERFOLGSRECHNUNGDIVIDENDE_KEY));
708         if (!returnvalue)
709             log.error(" FAILED");
710         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(34), "Ergebnissdaten_Double", "double85", Constants.EF_ERFOLGSRECHNUNGRUECKLAGENZUFUEHRUNG_KEY));
711         if (!returnvalue)
712             log.error(" FAILED");
713 
714         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_VERMOEGENSRECHNUNGAKTIVA_KEY);
715         ergebnissdatenUntergruppierungsname = null;
716         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
717         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
718         {
719             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
720         }
721         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(1) AKTIVA", "(1) AKTIVA"));
722         if (!returnvalue)
723             log.error(" FAILED");
724         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double86", Constants.EF_VERMOEGENSRECHNUNGAKTIVA_KEY));
725         if (!returnvalue)
726             log.error(" FAILED");
727         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double87", Constants.EF_VERMOEGENSRECHNUNGANLAGEVERMOEGEN_KEY));
728         if (!returnvalue)
729             log.error(" FAILED");
730         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double88", Constants.EF_VERMOEGENSRECHNUNGROHSTOFFLAGERBESTAND_KEY));
731         if (!returnvalue)
732             log.error(" FAILED");
733         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double89", Constants.EF_VERMOEGENSRECHNUNGLAGERBESTANDFERTIGPRODUKTE_KEY));
734         if (!returnvalue)
735             log.error(" FAILED");
736         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(4), "Ergebnissdaten_Double", "double90", Constants.EF_VERMOEGENSRECHNUNGKASSE_KEY));
737         if (!returnvalue)
738             log.error(" FAILED");
739         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(5), "Ergebnissdaten_Double", "double91", Constants.EF_VERMOEGENSRECHNUNGKAPITALERHOEHUNG_KEY));
740         if (!returnvalue)
741             log.error(" FAILED");
742 
743         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_VERMOEGENSRECHNUNGPASSIVA_KEY);
744         ergebnissdatenUntergruppierungsname = null;
745         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
746         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
747         {
748             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
749         }
750         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(2) PASSIVA", "(2) PASSIVA"));
751         if (!returnvalue)
752             log.error(" FAILED");
753         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(6), "Ergebnissdaten_Double", "double92", Constants.EF_VERMOEGENSRECHNUNGPASSIVA_KEY));
754         if (!returnvalue)
755             log.error(" FAILED");
756         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(7), "Ergebnissdaten_Double", "double93", Constants.EF_VERMOEGENSRECHNUNGEIGENKAPITAL_KEY));
757         if (!returnvalue)
758             log.error(" FAILED");
759         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(8), "Ergebnissdaten_Double", "double94", Constants.EF_VERMOEGENSRECHNUNGUNVERZINSLICHEVERBINDLICHKEITEN_KEY));
760         if (!returnvalue)
761             log.error(" FAILED");
762         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(9), "Ergebnissdaten_Double", "double95", Constants.EF_VERMOEGENSRECHNUNGKONTOKORRENTKREDIT_KEY));
763         if (!returnvalue)
764             log.error(" FAILED");
765         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(10), "Ergebnissdaten_Double", "double96", Constants.EF_VERMOEGENSRECHNUNGBANKKREDIT_KEY));
766         if (!returnvalue)
767             log.error(" FAILED");
768 
769         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_FINANZIERUNGENDEVQ_KEY);
770         ergebnissdatenUntergruppierungsname = null;
771         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
772         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
773         {
774             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
775         }
776         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(1) ENDE VORQUARTAL", "(1) ENDE VORQUARTAL"));
777         if (!returnvalue)
778             log.error(" FAILED");
779         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double97", Constants.EF_FINANZIERUNGBANKDARLEHEN_KEY));
780         if (!returnvalue)
781             log.error(" FAILED");
782         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double98", Constants.EF_FINANZIERUNGKONTOKORRENTKREDIT_KEY));
783         if (!returnvalue)
784             log.error(" FAILED");
785         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double99", Constants.EF_FINANZIERUNGKAPITALERHOEHUNG_KEY));
786         if (!returnvalue)
787             log.error(" FAILED");
788         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double100", Constants.EF_FINANZIERUNGKASSE_KEY));
789         if (!returnvalue)
790             log.error(" FAILED");
791         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(4), "Ergebnissdaten_Double", "double101", Constants.EF_FINANZIERUNGUNVERZINSLICHEVERBINDLICHKEITEN_KEY));
792         if (!returnvalue)
793             log.error(" FAILED");
794         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(5), "Ergebnissdaten_Double", "double102", Constants.EF_FINANZIERUNGSALDO_KEY));
795         if (!returnvalue)
796             log.error(" FAILED");
797 
798         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_FINANZIERUNGLAUFENDESQUARTAL_KEY);
799         ergebnissdatenUntergruppierungsname = null;
800         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
801         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
802         {
803             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
804         }
805         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(2) LAUFENDES QUARTAL", "(2) LAUFENDES QUARTAL"));
806         if (!returnvalue)
807             log.error(" FAILED");
808         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(6), "Ergebnissdaten_Double", "double103", Constants.EF_FINANZIERUNGLIQUIDITAETSWIRKSAMERERFOLGOHNEZINSEN_KEY));
809         if (!returnvalue)
810             log.error(" FAILED");
811         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(7), "Ergebnissdaten_Double", "double104", Constants.EF_FINANZIERUNGKAPITALBEDARF_KEY));
812         if (!returnvalue)
813             log.error(" FAILED");
814 
815         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_FINANZIERUNGUMFANZIERUNG_KEY);
816         ergebnissdatenUntergruppierungsname = null;
817         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
818         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
819         {
820             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
821         }
822         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(3) UMFINANZIERUNG", "(3) UMFINANZIERUNG"));
823         if (!returnvalue)
824             log.error(" FAILED");
825         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(8), "Ergebnissdaten_Double", "double105", Constants.EF_FINANZIERUNGOPTIMALERKONTOKORRENTKREDIT_KEY));
826         if (!returnvalue)
827             log.error(" FAILED");
828         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(9), "Ergebnissdaten_Double", "double106", Constants.EF_FINANZIERUNGOPTIMALEAENDERUNGKONTOKORRENTKREDIT_KEY));
829         if (!returnvalue)
830             log.error(" FAILED");
831         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(10), "Ergebnissdaten_Double", "double107", Constants.EF_FINANZIERUNGOPTIMALEAENDERUNGBANKDARLEHEN_KEY));
832         if (!returnvalue)
833             log.error(" FAILED");
834 
835         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_FINANZIERUNGZINSEN_KEY);
836         ergebnissdatenUntergruppierungsname = null;
837         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
838         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
839         {
840             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
841         }
842         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(4) ZINSEN", "(4) ZINSEN"));
843         if (!returnvalue)
844             log.error(" FAILED");
845         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(11), "Ergebnissdaten_Double", "double108", Constants.EF_FINANZIERUNGDURCHSCHNITTLICHERZINSSATZ_KEY));
846         if (!returnvalue)
847             log.error(" FAILED");
848         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(12), "Ergebnissdaten_Double", "double109", Constants.EF_FINANZIERUNGZUVIELBEZAHLTEZINSEN_KEY));
849         if (!returnvalue)
850             log.error(" FAILED");
851 
852         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_FINANZIERUNGLIQUIDITAETSAENDERUNG_KEY);
853         ergebnissdatenUntergruppierungsname = null;
854         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
855         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
856         {
857             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
858         }
859         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(5) LIQUIDIT&Auml;TS&Auml;NDERUNG", "(5) LIQUIDIT&Auml;TS&Auml;NDERUNG"));
860         if (!returnvalue)
861             log.error(" FAILED");
862         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(13), "Ergebnissdaten_Double", "double110", Constants.EF_FINANZIERUNGINVESTITIONEN_KEY));
863         if (!returnvalue)
864             log.error(" FAILED");
865         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(14), "Ergebnissdaten_Double", "double111", Constants.EF_FINANZIERUNGROHSTOFFENORMALUNDEXPRESS_KEY));
866         if (!returnvalue)
867             log.error(" FAILED");
868         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(15), "Ergebnissdaten_Double", "double112", Constants.EF_FINANZIERUNGDIVIDENDE_KEY));
869         if (!returnvalue)
870             log.error(" FAILED");
871         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(16), "Ergebnissdaten_Double", "double113", Constants.EF_FINANZIERUNGSTEUERN_KEY));
872         if (!returnvalue)
873             log.error(" FAILED");
874         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(17), "Ergebnissdaten_Double", "double114", Constants.EF_FINANZIERUNGLIQUIDITAETSWIRKSAMERERFOLG_KEY));
875         if (!returnvalue)
876             log.error(" FAILED");
877         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(18), "Ergebnissdaten_Double", "double115", Constants.EF_FINANZIERUNGLIQUIDITAETSAENDERUNG_KEY));
878         if (!returnvalue)
879             log.error(" FAILED");
880         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(19), "Ergebnissdaten_Double", "double116", Constants.EF_FINANZIERUNGLIQUIDITAETSAENDERUNGBEIGEPLANTEMABSATZ_KEY));
881         if (!returnvalue)
882             log.error(" FAILED");
883 
884         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_ENTSCHEIDUNGENVERTRIEB_KEY);
885         ergebnissdatenUntergruppierungsname = null;
886         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
887         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
888         {
889             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
890         }
891         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(1) VERTRIEB", "(1) VERTRIEB"));
892         if (!returnvalue)
893             log.error(" FAILED");
894         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double1", Constants.EF_ENTSCHEIDUNGVERKAUFSPREIS_KEY));
895         if (!returnvalue)
896             log.error(" FAILED");
897         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Integer", "integer1", Constants.EF_ENTSCHEIDUNGMARKETING_KEY));
898         if (!returnvalue)
899             log.error(" FAILED");
900         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Integer", "integer2", Constants.EF_ENTSCHEIDUNGMARKTFORSCHUNGSDIENST_KEY));
901         if (!returnvalue)
902             log.error(" FAILED");
903         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Integer", "integer3", Constants.EF_ENTSCHEIDUNGABSETZBAREMENGE_KEY));
904         if (!returnvalue)
905             log.error(" FAILED");
906 
907         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_ENTSCHEIDUNGENPRODUKTION_KEY);
908         ergebnissdatenUntergruppierungsname = null;
909         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
910         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
911         {
912             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
913         }
914         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(2) PRODUKTION UND BESCHAFFUNG", "(2) PRODUKTION UND BESCHAFFUNG"));
915         if (!returnvalue)
916             log.error(" FAILED");
917         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(4), "Ergebnissdaten_Integer", "integer4", Constants.EF_ENTSCHEIDUNGPRODUKTART_KEY));
918         if (!returnvalue)
919             log.error(" FAILED");
920         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(5), "Ergebnissdaten_Integer", "integer5", Constants.EF_ENTSCHEIDUNGPRODUKTIONSMENGE_KEY));
921         if (!returnvalue)
922             log.error(" FAILED");
923         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(6), "Ergebnissdaten_Double", "double2", Constants.EF_ENTSCHEIDUNGQUALITAETSSICHERUNG_KEY));
924         if (!returnvalue)
925             log.error(" FAILED");
926         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(7), "Ergebnissdaten_Double", "double3", Constants.EF_ENTSCHEIDUNGQSKOSTENMINIMUM_KEY));
927         if (!returnvalue)
928             log.error(" FAILED");
929         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(8), "Ergebnissdaten_Double", "double4", Constants.EF_ENTSCHEIDUNGKAPAZITAETSAUSLASTUNG_KEY));
930         if (!returnvalue)
931             log.error(" FAILED");
932         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(9), "Ergebnissdaten_Integer", "integer6", Constants.EF_ENTSCHEIDUNGINVESTITIONEN_KEY));
933         if (!returnvalue)
934             log.error(" FAILED");
935         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(10), "Ergebnissdaten_Integer", "integer7", Constants.EF_ENTSCHEIDUNGROHSTOFFBESTELLUNGNORMAL_KEY));
936         if (!returnvalue)
937             log.error(" FAILED");
938         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(11), "Ergebnissdaten_Integer", "integer8", Constants.EF_ENTSCHEIDUNGROHSTOFFBESTELLUNGEXPRESS_KEY));
939         if (!returnvalue)
940             log.error(" FAILED");
941 
942         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_ENTSCHEIDUNGENFINANZIERUNG_KEY);
943         ergebnissdatenUntergruppierungsname = null;
944         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
945         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
946         {
947             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
948         }
949         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(3) FINANZIERUNG", "(3) FINANZIERUNG"));
950         if (!returnvalue)
951             log.error(" FAILED");
952         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(12), "Ergebnissdaten_Integer", "integer9", Constants.EF_ENTSCHEIDUNGDIVIDENDE_KEY));
953         if (!returnvalue)
954             log.error(" FAILED");
955         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(13), "Ergebnissdaten_Integer", "integer10", Constants.EF_ENTSCHEIDUNGAENDERUNGBANKDARLEHEN_KEY));
956         if (!returnvalue)
957             log.error(" FAILED");
958         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(14), "Ergebnissdaten_Integer", "integer11", Constants.EF_ENTSCHEIDUNGERHOEHUNGTILGUNG_KEY));
959         if (!returnvalue)
960             log.error(" FAILED");
961         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(15), "Ergebnissdaten_Integer", "integer12", Constants.EF_ENTSCHEIDUNGZINSEN_KEY));
962         if (!returnvalue)
963             log.error(" FAILED");
964         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(16), "Ergebnissdaten_Integer", "integer13", Constants.EF_ENTSCHEIDUNGLIQUIDITAETSAENDERUNG_KEY));
965         if (!returnvalue)
966             log.error(" FAILED");
967 
968         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_ENTSCHEIDUNGENSONSTIGE_KEY);
969         ergebnissdatenUntergruppierungsname = null;
970         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
971         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
972         {
973             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
974         }
975         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(4) SONSTIGE", "(4) SONSTIGE"));
976         if (!returnvalue)
977             log.error(" FAILED");
978         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(17), "Ergebnissdaten_Integer", "integer14", Constants.EF_ENTSCHEIDUNGFUNDE_KEY));
979         if (!returnvalue)
980             log.error(" FAILED");
981         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(18), "Ergebnissdaten_Integer", "integer16", Constants.EF_ENTSCHEIDUNGLIZENZVERKAUFPRODUKTART_KEY));
982         if (!returnvalue)
983             log.error(" FAILED");
984         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(19), "Ergebnissdaten_Integer", "integer15", Constants.EF_ENTSCHEIDUNGLIZENZVERKAUFUNTERNEHMEN_KEY));
985         if (!returnvalue)
986             log.error(" FAILED");
987         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(20), "Ergebnissdaten_Integer", "integer17", Constants.EF_ENTSCHEIDUNGLIZENZKAUFUNTERNEHMEN_KEY));
988         if (!returnvalue)
989             log.error(" FAILED");
990         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(21), "Ergebnissdaten_Integer", "integer18", Constants.EF_ENTSCHEIDUNGLIZENZKAUFFUER_KEY));
991         if (!returnvalue)
992             log.error(" FAILED");
993         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(22), "Ergebnissdaten_Integer", "integer19", Constants.EF_ENTSCHEIDUNGBERATUNG_KEY));
994         if (!returnvalue)
995             log.error(" FAILED");
996         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(23), "Ergebnissdaten_Double", "double5", Constants.EF_ENTSCHEIDUNGGRENZGEWINN_KEY));
997         if (!returnvalue)
998             log.error(" FAILED");
999 
1000         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_VOLLKOSTENRECHNUNGERLOES_KEY);
1001         ergebnissdatenUntergruppierungsname = null;
1002         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1003         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1004         {
1005             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1006         }
1007         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(1) ERL&Ouml;S", "(1) ERL&Ouml;S"));
1008         if (!returnvalue)
1009             log.error(" FAILED");
1010         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double117", Constants.EF_VOLLKOSTENRECHNUNGERLOES_KEY));
1011         if (!returnvalue)
1012             log.error(" FAILED");
1013 
1014         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_VOLLKOSTENRECHNUNGKOSTEN_KEY);
1015         ergebnissdatenUntergruppierungsname = null;
1016         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1017         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1018         {
1019             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1020         }
1021         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(2) KOSTEN", "(2) KOSTEN"));
1022         if (!returnvalue)
1023             log.error(" FAILED");
1024         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double118", Constants.EF_VOLLKOSTENRECHNUNGKOSTEN_KEY));
1025         if (!returnvalue)
1026             log.error(" FAILED");
1027         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double119", Constants.EF_VOLLKOSTENRECHNUNGVERTRIEBSKOSTEN_KEY));
1028         if (!returnvalue)
1029             log.error(" FAILED");
1030         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double120", Constants.EF_VOLLKOSTENRECHNUNGMARKETING_KEY));
1031         if (!returnvalue)
1032             log.error(" FAILED");
1033         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(4), "Ergebnissdaten_Double", "double121", Constants.EF_VOLLKOSTENRECHNUNGLAGERUNGVONFERTIGPRODUKTEN_KEY));
1034         if (!returnvalue)
1035             log.error(" FAILED");
1036         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(5), "Ergebnissdaten_Double", "double122", Constants.EF_VOLLKOSTENRECHNUNGBERATUNGUNDMARKTFORSCHUNG_KEY));
1037         if (!returnvalue)
1038             log.error(" FAILED");
1039         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(6), "Ergebnissdaten_Double", "double123", Constants.EF_VOLLKOSTENRECHNUNGHERSTELLEINZELKOSTEN_KEY));
1040         if (!returnvalue)
1041             log.error(" FAILED");
1042         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(7), "Ergebnissdaten_Double", "double124", Constants.EF_VOLLKOSTENRECHNUNGLOEHNEOHNEUEBERSTUNDENZUSCHLAG_KEY));
1043         if (!returnvalue)
1044             log.error(" FAILED");
1045         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(8), "Ergebnissdaten_Double", "double125", Constants.EF_VOLLKOSTENRECHNUNGUEBERSTUNDENZUSCHLAG_KEY));
1046         if (!returnvalue)
1047             log.error(" FAILED");
1048         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(9), "Ergebnissdaten_Double", "double126", Constants.EF_VOLLKOSTENRECHNUNGROHSTOFFE_KEY));
1049         if (!returnvalue)
1050             log.error(" FAILED");
1051         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(10), "Ergebnissdaten_Double", "double127", Constants.EF_VOLLKOSTENRECHNUNGHERSTELLGEMEINKOSTEN_KEY));
1052         if (!returnvalue)
1053             log.error(" FAILED");
1054         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(11), "Ergebnissdaten_Double", "double128", Constants.EF_VOLLKOSTENRECHNUNGROHSTOFFLAGERUNGUNDBESTELLUNG_KEY));
1055         if (!returnvalue)
1056             log.error(" FAILED");
1057         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(12), "Ergebnissdaten_Double", "double129", Constants.EF_VOLLKOSTENRECHNUNGABSCHREIBUNGUNDANLAGENPROJEKTIERUNG_KEY));
1058         if (!returnvalue)
1059             log.error(" FAILED");
1060         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(13), "Ergebnissdaten_Double", "double130", Constants.EF_VOLLKOSTENRECHNUNGQUALITAETSSICHERUNG_KEY));
1061         if (!returnvalue)
1062             log.error(" FAILED");
1063         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(14), "Ergebnissdaten_Double", "double131", Constants.EF_VOLLKOSTENRECHNUNGSCHICHTWECHSEL_KEY));
1064         if (!returnvalue)
1065             log.error(" FAILED");
1066         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(15), "Ergebnissdaten_Double", "double132", Constants.EF_VOLLKOSTENRECHNUNGFUNDEAUFARBEITUNGTRANSFERERTRAEGE_KEY));
1067         if (!returnvalue)
1068             log.error(" FAILED");
1069         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(16), "Ergebnissdaten_Double", "double133", Constants.EF_VOLLKOSTENRECHNUNGZINSEN_KEY));
1070         if (!returnvalue)
1071             log.error(" FAILED");
1072         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(17), "Ergebnissdaten_Double", "double134", Constants.EF_VOLLKOSTENRECHNUNGVERWALTUNG_KEY));
1073         if (!returnvalue)
1074             log.error(" FAILED");
1075 
1076         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_VOLLKOSTENRECHNUNGGEWINN_KEY);
1077         ergebnissdatenUntergruppierungsname = null;
1078         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1079         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1080         {
1081             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1082         }
1083         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(3) GEWINN", "(3) GEWINN"));
1084         if (!returnvalue)
1085             log.error(" FAILED");
1086         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(18), "Ergebnissdaten_Double", "double135", Constants.EF_VOLLKOSTENRECHNUNGGEWINN_KEY));
1087         if (!returnvalue)
1088             log.error(" FAILED");
1089 
1090         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_VOLLKOSTENRECHNUNGPRODUZIERTEMENGE_KEY);
1091         ergebnissdatenUntergruppierungsname = null;
1092         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1093         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1094         {
1095             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1096         }
1097         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(4) PRODUZIERTE MENGE", "(4) PRODUZIERTE MENGE"));
1098         if (!returnvalue)
1099             log.error(" FAILED");
1100         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(19), "Ergebnissdaten_Double", "double136", Constants.EF_VOLLKOSTENRECHNUNGPRODUZIERTEMENGE_KEY));
1101         if (!returnvalue)
1102             log.error(" FAILED");
1103 
1104         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_VOLLKOSTENRECHNUNGABGESETZTEMENGE_KEY);
1105         ergebnissdatenUntergruppierungsname = null;
1106         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1107         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1108         {
1109             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1110         }
1111         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(5) ABGESETZTE MENGE", "(5) ABGESETZTE MENGE"));
1112         if (!returnvalue)
1113             log.error(" FAILED");
1114         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(20), "Ergebnissdaten_Double", "double137", Constants.EF_VOLLKOSTENRECHNUNGABGESETZTEMENGE_KEY));
1115         if (!returnvalue)
1116             log.error(" FAILED");
1117 
1118         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_GRENZKOSTENRECHNUNGGRENZERLOES_KEY);
1119         ergebnissdatenUntergruppierungsname = null;
1120         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1121         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1122         {
1123             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1124         }
1125         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(1) GRENZERL&Ouml;S", "(1) GRENZERL&Ouml;S"));
1126         if (!returnvalue)
1127             log.error(" FAILED");
1128         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double138", Constants.EF_GRENZKOSTENRECHNUNGGRENZERLOES_KEY));
1129         if (!returnvalue)
1130             log.error(" FAILED");
1131 
1132         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_GRENZKOSTENRECHNUNGGRENZMARKETINGKOSTEN_KEY);
1133         ergebnissdatenUntergruppierungsname = null;
1134         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1135         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1136         {
1137             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1138         }
1139         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(2) GRENZMARKETINGKOSTEN", "(2) GRENZMARKETINGKOSTEN"));
1140         if (!returnvalue)
1141             log.error(" FAILED");
1142         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double139", Constants.EF_GRENZKOSTENRECHNUNGGRENZMARKETINGKOSTEN_KEY));
1143         if (!returnvalue)
1144             log.error(" FAILED");
1145 
1146         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_GRENZKOSTENRECHNUNGGRENZHERSTELLKOSTEN_KEY);
1147         ergebnissdatenUntergruppierungsname = null;
1148         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1149         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1150         {
1151             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1152         }
1153         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(3) GRENZHERSTELLKOSTEN", "(3) GRENZHERSTELLKOSTEN"));
1154         if (!returnvalue)
1155             log.error(" FAILED");
1156         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double140", Constants.EF_GRENZKOSTENRECHNUNGGRENZHERSTELLKOSTEN_KEY));
1157         if (!returnvalue)
1158             log.error(" FAILED");
1159         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double141", Constants.EF_GRENZKOSTENRECHNUNGLOEHNEOHNEUEBERSTUNDENZUSCHLAG_KEY));
1160         if (!returnvalue)
1161             log.error(" FAILED");
1162         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(4), "Ergebnissdaten_Double", "double142", Constants.EF_GRENZKOSTENRECHNUNGUEBERSTUNDENZUSCHLAG_KEY));
1163         if (!returnvalue)
1164             log.error(" FAILED");
1165         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(5), "Ergebnissdaten_Double", "double143", Constants.EF_GRENZKOSTENRECHNUNGROHSTOFFE_KEY));
1166         if (!returnvalue)
1167             log.error(" FAILED");
1168         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(6), "Ergebnissdaten_Double", "double144", Constants.EF_GRENZKOSTENRECHNUNGQUALITAETSSICHERUNG_KEY));
1169         if (!returnvalue)
1170             log.error(" FAILED");
1171         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(7), "Ergebnissdaten_Double", "double145", Constants.EF_GRENZKOSTENRECHNUNGSCHICHTWECHSEL_KEY));
1172         if (!returnvalue)
1173             log.error(" FAILED");
1174         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(8), "Ergebnissdaten_Double", "double146", Constants.EF_GRENZKOSTENRECHNUNGVERWALTUNG_KEY));
1175         if (!returnvalue)
1176             log.error(" FAILED");
1177 
1178         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_GRENZKOSTENRECHNUNGGRENZGEWINN_KEY);
1179         ergebnissdatenUntergruppierungsname = null;
1180         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1181         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1182         {
1183             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1184         }
1185         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(4) GRENZGEWINN", "(4) GRENZGEWINN"));
1186         if (!returnvalue)
1187             log.error(" FAILED");
1188         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(9), "Ergebnissdaten_Double", "double147", Constants.EF_GRENZKOSTENRECHNUNGGRENZGEWINN_KEY));
1189         if (!returnvalue)
1190             log.error(" FAILED");
1191 
1192         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_GRENZKOSTENRECHNUNGPRODUKTIONLETZTEZONE_KEY);
1193         ergebnissdatenUntergruppierungsname = null;
1194         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1195         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1196         {
1197             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1198         }
1199         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "(5) PRODUKTION IN DER LETZTEN ZONE", "(5) PRODUKTION IN DER LETZTEN ZONE"));
1200         if (!returnvalue)
1201             log.error(" FAILED");
1202         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(10), "Ergebnissdaten_Double", "double148", Constants.EF_GRENZKOSTENRECHNUNGPRODUKTIONINLETZTERZONE_KEY));
1203         if (!returnvalue)
1204             log.error(" FAILED");
1205 
1206         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_BEWERTUNGSUEBERBLICKUNTERNEHMENSBEWERTUNG_KEY);
1207         ergebnissdatenUntergruppierungsname = null;
1208         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1209         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1210         {
1211             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1212         }
1213         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "Unternehmensbewertung", "Unternehmensbewertung"));
1214         if (!returnvalue)
1215             log.error(" FAILED");
1216         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double151", Constants.EF_BEWERTUNGSUEBERBLICKERFOLGVORSTEUERN_KEY));
1217         if (!returnvalue)
1218             log.error(" FAILED");
1219         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double152", Constants.EF_BEWERTUNGSUEBERBLICKERFOLGVORSTEUERNDUR_KEY));
1220         if (!returnvalue)
1221             log.error(" FAILED");
1222         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double153", Constants.EF_BEWERTUNGSUEBERBLICKERFOLGVORSTEUERNGEW_KEY));
1223         if (!returnvalue)
1224             log.error(" FAILED");
1225         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double154", Constants.EF_BEWERTUNGSUEBERBLICKUMSATZERLOESE_KEY));
1226         if (!returnvalue)
1227             log.error(" FAILED");
1228         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(4), "Ergebnissdaten_Double", "double155", Constants.EF_BEWERTUNGSUEBERBLICKUMSATZERLOESEDUR_KEY));
1229         if (!returnvalue)
1230             log.error(" FAILED");
1231 
1232         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_BEWERTUNGSUEBERBLICKKOORDINATIONSBEWERTUNG_KEY);
1233         ergebnissdatenUntergruppierungsname = null;
1234         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1235         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1236         {
1237             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1238         }
1239         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "Koordinationsbewertung", "Koordinationsbewertung"));
1240         if (!returnvalue)
1241             log.error(" FAILED");
1242         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double156", Constants.EF_BEWERTUNGSUEBERBLICKGRENZGEWINN_KEY));
1243         if (!returnvalue)
1244             log.error(" FAILED");
1245         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double157", Constants.EF_BEWERTUNGSUEBERBLICKGRENZGEWINNDUR_KEY));
1246         if (!returnvalue)
1247             log.error(" FAILED");
1248         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double158", Constants.EF_BEWERTUNGSUEBERBLICKFORSCHUNGUNDENTWICKLUNG_KEY));
1249         if (!returnvalue)
1250             log.error(" FAILED");
1251         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double159", Constants.EF_BEWERTUNGSUEBERBLICKFORSCHUNGUNDENTWICKLUNGDUR_KEY));
1252         if (!returnvalue)
1253             log.error(" FAILED");
1254 
1255         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_BEWERTUNGSUEBERBLICKVERTRIEBSBEWERTUNG_KEY);
1256         ergebnissdatenUntergruppierungsname = null;
1257         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1258         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1259         {
1260             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1261         }
1262         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "Vertriebsbewertung", "Vertriebsbewertung"));
1263         if (!returnvalue)
1264             log.error(" FAILED");
1265         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double160", Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERABSETZBAREMENGE_KEY));
1266         if (!returnvalue)
1267             log.error(" FAILED");
1268         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double161", Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERABSETZBAREMENGEDUR_KEY));
1269         if (!returnvalue)
1270             log.error(" FAILED");
1271         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double162", Constants.EF_BEWERTUNGSUEBERBLICKDEFIZITUNDLAGERBILDUNG_KEY));
1272         if (!returnvalue)
1273             log.error(" FAILED");
1274         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double163", Constants.EF_BEWERTUNGSUEBERBLICKDEFIZITUNDLAGERBILDUNGDUR_KEY));
1275         if (!returnvalue)
1276             log.error(" FAILED");
1277 
1278         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_BEWERTUNGSUEBERBLICKPRODUKTIONSBEWERTUNG_KEY);
1279         ergebnissdatenUntergruppierungsname = null;
1280         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1281         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1282         {
1283             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1284         }
1285         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "Produktionsbewertung", "Produktionsbewertung"));
1286         if (!returnvalue)
1287             log.error(" FAILED");
1288         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double164", Constants.EF_BEWERTUNGSUEBERBLICKHERSTELLKOSTEN_KEY));
1289         if (!returnvalue)
1290             log.error(" FAILED");
1291         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double165", Constants.EF_BEWERTUNGSUEBERBLICKHERSTELLKOSTENDUR_KEY));
1292         if (!returnvalue)
1293             log.error(" FAILED");
1294         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double166", Constants.EF_BEWERTUNGSUEBERBLICKOPTIMALEQSVSQSKOSTENMINIMIERENDENOMINALEQS_KEY));
1295         if (!returnvalue)
1296             log.error(" FAILED");
1297         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double167", Constants.EF_BEWERTUNGSUEBERBLICKOPTIMALEQSVSQSKOSTENMINIMIERENDENOMINALEQSDUR_KEY));
1298         if (!returnvalue)
1299             log.error(" FAILED");
1300         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(4), "Ergebnissdaten_Double", "double168", Constants.EF_BEWERTUNGSUEBERBLICKTATSAECHLICHERVSERWARTETERGRENZGEWINN_KEY));
1301         if (!returnvalue)
1302             log.error(" FAILED");
1303         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(5), "Ergebnissdaten_Double", "double169", Constants.EF_BEWERTUNGSUEBERBLICKTATSAECHLICHERVSERWARTETERGRENZGEWINNDUR_KEY));
1304         if (!returnvalue)
1305             log.error(" FAILED");
1306         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(6), "Ergebnissdaten_Double", "double170", Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERKAPAZITAETSAUSLASTUNG_KEY));
1307         if (!returnvalue)
1308             log.error(" FAILED");
1309         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(7), "Ergebnissdaten_Double", "double171", Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERKAPAZITAETSAUSLASTUNGDUR_KEY));
1310         if (!returnvalue)
1311             log.error(" FAILED");
1312 
1313         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_BEWERTUNGSUEBERBLICKFINANZIERUNGSBEWERTUNG_KEY);
1314         ergebnissdatenUntergruppierungsname = null;
1315         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1316         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1317         {
1318             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1319         }
1320         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "Finanzierungsbewertung", "Finanzierungsbewertung"));
1321         if (!returnvalue)
1322             log.error(" FAILED");
1323         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double172", Constants.EF_BEWERTUNGSUEBERBLICKUNNOETIGEZINSBELASTUNG_KEY));
1324         if (!returnvalue)
1325             log.error(" FAILED");
1326         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(1), "Ergebnissdaten_Double", "double173", Constants.EF_BEWERTUNGSUEBERBLICKUNNOETIGEZINSBELASTUNGDUR_KEY));
1327         if (!returnvalue)
1328             log.error(" FAILED");
1329         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(2), "Ergebnissdaten_Double", "double174", Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERZAHLUNGSMITTELAENDERUNG_KEY));
1330         if (!returnvalue)
1331             log.error(" FAILED");
1332         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(3), "Ergebnissdaten_Double", "double175", Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERZAHLUNGSMITTELAENDERUNGDUR_KEY));
1333         if (!returnvalue)
1334             log.error(" FAILED");
1335 
1336         ergebnissdatenUntergruppierungsnamen = dieug.sucheUntergruppierungsname(projektnummer, Constants.EUG_NICHTZUGEORDNET_KEY);
1337         ergebnissdatenUntergruppierungsname = null;
1338         ergebnissdatenUntergruppierungsnamenIterator = ergebnissdatenUntergruppierungsnamen.iterator();
1339         if (ergebnissdatenUntergruppierungsnamenIterator.hasNext())
1340         {
1341             ergebnissdatenUntergruppierungsname = (Ergebnissdaten_Untergruppierungsnamen) ergebnissdatenUntergruppierungsnamenIterator.next();
1342         }
1343         returnvalue = dieugb.erzeugen(new Ergebnissdaten_Untergruppierungsbeschreibungen(ergebnissdatenUntergruppierungsname, sprache, "Nicht zugeordnet", "Nicht zugeordnet"));
1344         if (!returnvalue)
1345             log.error(" FAILED");
1346         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double149", Constants.EF_ALLGEMEINMARKETINGEFFEKT_KEY));
1347         if (!returnvalue)
1348             log.error(" FAILED");
1349         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double150", Constants.EF_ALLGEMEINFERTIGPRODUKTEGESAMT_KEY));
1350         if (!returnvalue)
1351             log.error(" FAILED");
1352         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double7", Constants.EF_GRUNDDATENINFLATIONSINDEX_KEY));
1353         if (!returnvalue)
1354             log.error(" FAILED");
1355         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double9", Constants.EF_GRUNDDATENLOHNERHOEHUNGSINDEX_KEY));
1356         if (!returnvalue)
1357             log.error(" FAILED");
1358         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double30", Constants.EF_GRUNDDATENREALERMARKETINGAUFWAND_KEY));
1359         if (!returnvalue)
1360             log.error(" FAILED");
1361         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double36", Constants.EF_GRUNDDATENFORSCHUNGUNDENTWICKLUNGREAL_KEY));
1362         if (!returnvalue)
1363             log.error(" FAILED");
1364         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Integer", "integer29", Constants.EF_GRUNDDATENLIZENZERWERBUNTERNEHMEN_KEY));
1365         if (!returnvalue)
1366             log.error(" FAILED");
1367         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Integer", "integer31", Constants.EF_GRUNDDATENLIZENZVERKAUFUNTERNEHMEN_KEY));
1368         if (!returnvalue)
1369             log.error(" FAILED");
1370         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double40", Constants.EF_GRUNDDATENFERTIGUNGSZEITGESAMT_KEY));
1371         if (!returnvalue)
1372             log.error(" FAILED");
1373         returnvalue = dief.erzeugen(new Ergebnissdaten_Feldnamen(null, ergebnissdatenUntergruppierungsname, new Integer(0), "Ergebnissdaten_Double", "double50", Constants.EF_GRUNDDATENROHSTOFFPREIS_KEY));
1374         if (!returnvalue)
1375             log.error(" FAILED");
1376 
1377         /* Ergebnissdaten Feldbeschreibungen */
1378         Collection ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENINFLATIONSRATE_KEY);
1379         Ergebnissdaten_Feldnamen ergebnissdatenFeldname = null;
1380         Iterator ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1381         if (ergebnissdatenFeldnamenIterator.hasNext())
1382         {
1383             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1384         }
1385         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(11) Inflationsrate", "Inflationsrate", "2"));
1386         if (!returnvalue)
1387             log.error(" FAILED");
1388 
1389         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLOHNERHOEHUNG_KEY);
1390         ergebnissdatenFeldname = null;
1391         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1392         if (ergebnissdatenFeldnamenIterator.hasNext())
1393         {
1394             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1395         }
1396         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(12) Lohnerh&ouml;hung", "Lohnerh&ouml;hung", "2"));
1397         if (!returnvalue)
1398             log.error(" FAILED");
1399 
1400         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENSAISONINDEX_KEY);
1401         ergebnissdatenFeldname = null;
1402         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1403         if (ergebnissdatenFeldnamenIterator.hasNext())
1404         {
1405             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1406         }
1407         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(13) Saisonindex", "Saisonindex", "2"));
1408         if (!returnvalue)
1409             log.error(" FAILED");
1410 
1411         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENKONJUNKTURINDEX_KEY);
1412         ergebnissdatenFeldname = null;
1413         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1414         if (ergebnissdatenFeldnamenIterator.hasNext())
1415         {
1416             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1417         }
1418         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(14) Konjunkturindex", "Konjunkturindex", "2"));
1419         if (!returnvalue)
1420             log.error(" FAILED");
1421 
1422         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENINFLATIONSRATEVORHERSAGE_KEY);
1423         ergebnissdatenFeldname = null;
1424         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1425         if (ergebnissdatenFeldnamenIterator.hasNext())
1426         {
1427             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1428         }
1429         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(11V) Inflationsrate - Vorhersage f&uuml;r das n&auml;chste Quartal", "Vorhersage f&uuml;r das n&auml;chste Quartal", "2"));
1430         if (!returnvalue)
1431             log.error(" FAILED");
1432 
1433         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLOHNERHOEHUNGVORHERSAGE_KEY);
1434         ergebnissdatenFeldname = null;
1435         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1436         if (ergebnissdatenFeldnamenIterator.hasNext())
1437         {
1438             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1439         }
1440         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(12V) Lohnerh&ouml;hung - Vorhersage f&uuml;r das n&auml;chste Quartal", "Vorhersage f&uuml;r das n&auml;chsteQuartal", "2"));
1441         if (!returnvalue)
1442             log.error(" FAILED");
1443 
1444         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENSAISONINDEXVORHERSAGE_KEY);
1445         ergebnissdatenFeldname = null;
1446         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1447         if (ergebnissdatenFeldnamenIterator.hasNext())
1448         {
1449             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1450         }
1451         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(13V) Saisonindex - Vorhersage f&uuml;r das n&auml;chste Quartal", "Vorhersage f&uuml;r das n&auml;chste Quartal", "2"));
1452         if (!returnvalue)
1453             log.error(" FAILED");
1454 
1455         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENKONJUNKURINDEXVORHERSAGE_KEY);
1456         ergebnissdatenFeldname = null;
1457         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1458         if (ergebnissdatenFeldnamenIterator.hasNext())
1459         {
1460             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1461         }
1462         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(14V) Konjunkturindex - Vorhersage f&uuml;r das n&auml;chste Quartal", "Vorhersage f&uuml;r das n&auml;chste Quartal", "2"));
1463         if (!returnvalue)
1464             log.error(" FAILED");
1465 
1466         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_UEBERSCHRIFTGRUNDDATENPREISE_KEY);
1467         ergebnissdatenFeldname = null;
1468         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1469         if (ergebnissdatenFeldnamenIterator.hasNext())
1470         {
1471             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1472         }
1473         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(21) Preise", "", "0"));
1474         if (!returnvalue)
1475             log.error(" FAILED");
1476 
1477         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENVERKAUFSPREISNOMINAL_KEY);
1478         ergebnissdatenFeldname = null;
1479         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1480         if (ergebnissdatenFeldnamenIterator.hasNext())
1481         {
1482             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1483         }
1484         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(211) Verkaufspreis nominal", "", "2"));
1485         if (!returnvalue)
1486             log.error(" FAILED");
1487 
1488         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENVERKAUFSPREISREAL_KEY);
1489         ergebnissdatenFeldname = null;
1490         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1491         if (ergebnissdatenFeldnamenIterator.hasNext())
1492         {
1493             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1494         }
1495         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(212) Verkaufspreis real", "", "2"));
1496         if (!returnvalue)
1497             log.error(" FAILED");
1498 
1499         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENVERKAUFSPREISWIRKSAM_KEY);
1500         ergebnissdatenFeldname = null;
1501         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1502         if (ergebnissdatenFeldnamenIterator.hasNext())
1503         {
1504             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1505         }
1506         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(213) Verkaufspreis wirksam", "", "2"));
1507         if (!returnvalue)
1508             log.error(" FAILED");
1509 
1510         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_UEBERSCHRIFTGRUNDDATENMENGEN_KEY);
1511         ergebnissdatenFeldname = null;
1512         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1513         if (ergebnissdatenFeldnamenIterator.hasNext())
1514         {
1515             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1516         }
1517         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(22) Mengen", "", "0"));
1518         if (!returnvalue)
1519             log.error(" FAILED");
1520 
1521         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENABSETZBAREMENGE_KEY);
1522         ergebnissdatenFeldname = null;
1523         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1524         if (ergebnissdatenFeldnamenIterator.hasNext())
1525         {
1526             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1527         }
1528         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(221) absetzbare Menge (in 1.000 St&uuml;ck)", "", "-1000"));
1529         if (!returnvalue)
1530             log.error(" FAILED");
1531 
1532         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENABSETZBAREMENGEWEGENDEFIZIT_KEY);
1533         ergebnissdatenFeldname = null;
1534         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1535         if (ergebnissdatenFeldnamenIterator.hasNext())
1536         {
1537             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1538         }
1539         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(222) von (221) wegen Defizit anderer Unternehmen (in 1.000 St&uuml;ck)", "", "-1000"));
1540         if (!returnvalue)
1541             log.error(" FAILED");
1542 
1543         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENMINDERABSATZWEGENHOHEMPREIS_KEY);
1544         ergebnissdatenFeldname = null;
1545         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1546         if (ergebnissdatenFeldnamenIterator.hasNext())
1547         {
1548             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1549         }
1550         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(223) von (221) Minderabsatz wegen zu hohem Preis (in 1.000 St&uuml;ck)", "", "-1000"));
1551         if (!returnvalue)
1552             log.error(" FAILED");
1553 
1554         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENABGESETZTEMENGE_KEY);
1555         ergebnissdatenFeldname = null;
1556         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1557         if (ergebnissdatenFeldnamenIterator.hasNext())
1558         {
1559             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1560         }
1561         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(224) abgesetzte Menge (in 1.000 St&uuml;ck)", "", "-1000"));
1562         if (!returnvalue)
1563             log.error(" FAILED");
1564 
1565         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLIEFERDEFIZIT_KEY);
1566         ergebnissdatenFeldname = null;
1567         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1568         if (ergebnissdatenFeldnamenIterator.hasNext())
1569         {
1570             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1571         }
1572         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(225) Lieferdefizit (in 1.000 St&uuml;ck)", "", "-1000"));
1573         if (!returnvalue)
1574             log.error(" FAILED");
1575 
1576         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_UEBERSCHRIFTGRUNDDATENFERTIGPRODUKTE_KEY);
1577         ergebnissdatenFeldname = null;
1578         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1579         if (ergebnissdatenFeldnamenIterator.hasNext())
1580         {
1581             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1582         }
1583         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(23) Fertigprodukte", "", "0"));
1584         if (!returnvalue)
1585             log.error(" FAILED");
1586 
1587         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLAGERZUGANGFERTIGPRODUKTE_KEY);
1588         ergebnissdatenFeldname = null;
1589         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1590         if (ergebnissdatenFeldnamenIterator.hasNext())
1591         {
1592             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1593         }
1594         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(231) Lagerzugang von Fertigprodukten (in 1000 St&uuml;ck)", "", "-1000"));
1595         if (!returnvalue)
1596             log.error(" FAILED");
1597 
1598         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLAGERABGANGFERTIGPRODUKTE_KEY);
1599         ergebnissdatenFeldname = null;
1600         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1601         if (ergebnissdatenFeldnamenIterator.hasNext())
1602         {
1603             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1604         }
1605         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(232) Lagerabgang von Fertigprodukten (in 1000 St&uuml;ck)", "", "-1000"));
1606         if (!returnvalue)
1607             log.error(" FAILED");
1608 
1609         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLAGERMENGEFERTIGPRODUKTE_KEY);
1610         ergebnissdatenFeldname = null;
1611         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1612         if (ergebnissdatenFeldnamenIterator.hasNext())
1613         {
1614             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1615         }
1616         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(233) Lagermenge an Fertigprodukten (in 1000 St&uuml;ck)", "", "-1000"));
1617         if (!returnvalue)
1618             log.error(" FAILED");
1619 
1620         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_UEBERSCHRIFTGRUNDDATENSONSTIGE_KEY);
1621         ergebnissdatenFeldname = null;
1622         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1623         if (ergebnissdatenFeldnamenIterator.hasNext())
1624         {
1625             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1626         }
1627         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(24) Sonstige", "", "0"));
1628         if (!returnvalue)
1629             log.error(" FAILED");
1630 
1631         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENMARKTANTEIL_KEY);
1632         ergebnissdatenFeldname = null;
1633         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1634         if (ergebnissdatenFeldnamenIterator.hasNext())
1635         {
1636             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1637         }
1638         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(241) Marktanteil", "", "2"));
1639         if (!returnvalue)
1640             log.error(" FAILED");
1641 
1642         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENUMSATZANTEIL_KEY);
1643         ergebnissdatenFeldname = null;
1644         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1645         if (ergebnissdatenFeldnamenIterator.hasNext())
1646         {
1647             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1648         }
1649         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(242) Umsatzanteil", "", "2"));
1650         if (!returnvalue)
1651             log.error(" FAILED");
1652 
1653         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENMARKTFORSCHUNGSDIENST_KEY);
1654         ergebnissdatenFeldname = null;
1655         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1656         if (ergebnissdatenFeldnamenIterator.hasNext())
1657         {
1658             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1659         }
1660         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(243) Marktforschungsdienst Nr.", "", "0"));
1661         if (!returnvalue)
1662             log.error(" FAILED");
1663 
1664         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENWIRKSAMEMARKETINGKOSTEN_KEY);
1665         ergebnissdatenFeldname = null;
1666         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1667         if (ergebnissdatenFeldnamenIterator.hasNext())
1668         {
1669             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1670         }
1671         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(244) wirksame Marketingkosten (in 1000 EUR)", "", "-1000"));
1672         if (!returnvalue)
1673             log.error(" FAILED");
1674 
1675         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_UEBERSCHRIFTGRUNDDATENPRODUKTIONSMENGEN_KEY);
1676         ergebnissdatenFeldname = null;
1677         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1678         if (ergebnissdatenFeldnamenIterator.hasNext())
1679         {
1680             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1681         }
1682         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(31) Produktionsmengen", "", "0"));
1683         if (!returnvalue)
1684             log.error(" FAILED");
1685 
1686         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENNOMINALEPRODUKTIONSMENGE_KEY);
1687         ergebnissdatenFeldname = null;
1688         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1689         if (ergebnissdatenFeldnamenIterator.hasNext())
1690         {
1691             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1692         }
1693         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(311) nominale Produktionsmenge (in 1000 Stk.)", "", "-1000"));
1694         if (!returnvalue)
1695             log.error(" FAILED");
1696 
1697         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENFEHLERHAFTEPRODUKTIONSMENGE_KEY);
1698         ergebnissdatenFeldname = null;
1699         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1700         if (ergebnissdatenFeldnamenIterator.hasNext())
1701         {
1702             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1703         }
1704         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(312) - fehlerhafte Produktionsmenge (in 1000 Stk.)", "", "-1000"));
1705         if (!returnvalue)
1706             log.error(" FAILED");
1707 
1708         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENNACHBEARBEITETEPRODUKTIONSMENGE_KEY);
1709         ergebnissdatenFeldname = null;
1710         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1711         if (ergebnissdatenFeldnamenIterator.hasNext())
1712         {
1713             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1714         }
1715         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(313) + nachbearbeitete Produktionsmenge (in 1000 Stk.)", "", "-1000"));
1716         if (!returnvalue)
1717             log.error(" FAILED");
1718 
1719         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENGUTEPRODUKTIONSMENGE_KEY);
1720         ergebnissdatenFeldname = null;
1721         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1722         if (ergebnissdatenFeldnamenIterator.hasNext())
1723         {
1724             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1725         }
1726         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(314) = gute Produktionsmenge (in 1000 Stk.)", "", "-1000"));
1727         if (!returnvalue)
1728             log.error(" FAILED");
1729 
1730         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_UEBERSCHRIFTGRUNDDATENPRODUKTART_KEY);
1731         ergebnissdatenFeldname = null;
1732         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1733         if (ergebnissdatenFeldnamenIterator.hasNext())
1734         {
1735             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1736         }
1737         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(32) Produktart", "", "0"));
1738         if (!returnvalue)
1739             log.error(" FAILED");
1740 
1741         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENPRODUZIERTEPRODUKTART_KEY);
1742         ergebnissdatenFeldname = null;
1743         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1744         if (ergebnissdatenFeldnamenIterator.hasNext())
1745         {
1746             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1747         }
1748         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(321) produzierte Produktart im laufenden Quartal", "", "0"));
1749         if (!returnvalue)
1750             log.error(" FAILED");
1751 
1752         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENFORSCHUNGUNDENTWICKLUNGWIRKSAM_KEY);
1753         ergebnissdatenFeldname = null;
1754         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1755         if (ergebnissdatenFeldnamenIterator.hasNext())
1756         {
1757             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1758         }
1759         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(322) Forschung und Entwicklung wirksam (in 1000 EUR)", "", "-1000"));
1760         if (!returnvalue)
1761             log.error(" FAILED");
1762 
1763         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLIZENZERWERBPRODUKTART_KEY);
1764         ergebnissdatenFeldname = null;
1765         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1766         if (ergebnissdatenFeldnamenIterator.hasNext())
1767         {
1768             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1769         }
1770         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(323) Lizenzerwerb f&uuml;r Produktart", "", "0"));
1771         if (!returnvalue)
1772             log.error(" FAILED");
1773 
1774         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLIZENZERWERBSKOSTEN_KEY);
1775         ergebnissdatenFeldname = null;
1776         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1777         if (ergebnissdatenFeldnamenIterator.hasNext())
1778         {
1779             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1780         }
1781         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "Lizenzerwerbskosten (in 1000 EUR)", "", "-1000"));
1782 
1783         if (!returnvalue)
1784             log.error(" FAILED");
1785 
1786         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLIZENZVERKAUFPRODUKTART_KEY);
1787         ergebnissdatenFeldname = null;
1788         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1789         if (ergebnissdatenFeldnamenIterator.hasNext())
1790         {
1791             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1792         }
1793         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(324) Lizenzverkauf f&uuml;r Produktart", "", "0"));
1794         if (!returnvalue)
1795             log.error(" FAILED");
1796 
1797         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLIZENZVERKAUFSERLOESE_KEY);
1798         ergebnissdatenFeldname = null;
1799         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1800         if (ergebnissdatenFeldnamenIterator.hasNext())
1801         {
1802             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1803         }
1804         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "Lizenzverkaufserl&ouml;se (in 1000 EUR)", "", "-1000"));
1805         if (!returnvalue)
1806             log.error(" FAILED");
1807 
1808         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENMAXIMALMOEGLICHEPRODUKTARTFOLGEQUARTAL_KEY);
1809         ergebnissdatenFeldname = null;
1810         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1811         if (ergebnissdatenFeldnamenIterator.hasNext())
1812         {
1813             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1814         }
1815         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(325) maximal m&ouml;gliche Produktart im Folgequartal", "", "0"));
1816         if (!returnvalue)
1817             log.error(" FAILED");
1818 
1819         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_UEBERSCHRIFTGRUNDDATENZEITWIRTSCHAFT_KEY);
1820         ergebnissdatenFeldname = null;
1821         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1822         if (ergebnissdatenFeldnamenIterator.hasNext())
1823         {
1824             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1825         }
1826         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(33) Zeitwirtschaft", "", "0"));
1827         if (!returnvalue)
1828             log.error(" FAILED");
1829 
1830         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENFERTIGUNGSZEITPROSTUECK_KEY);
1831         ergebnissdatenFeldname = null;
1832         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1833         if (ergebnissdatenFeldnamenIterator.hasNext())
1834         {
1835             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1836         }
1837         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "Min./Stk.", "(331) Fertigungszeit pro \"gutes\" St&uuml;ck (in Minuten pro St&uuml;ck)", "", "2"));
1838         if (!returnvalue)
1839             log.error(" FAILED");
1840 
1841         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENKAPAZITAETSAUSLASTUNG_KEY);
1842         ergebnissdatenFeldname = null;
1843         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1844         if (ergebnissdatenFeldnamenIterator.hasNext())
1845         {
1846             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1847         }
1848         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(332) Kapazit&auml;tsauslastung", "", "2"));
1849         if (!returnvalue)
1850             log.error(" FAILED");
1851 
1852         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENKAPAZITAETSBESTANDFOLGEQUARTAL_KEY);
1853         ergebnissdatenFeldname = null;
1854         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1855         if (ergebnissdatenFeldnamenIterator.hasNext())
1856         {
1857             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1858         }
1859         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "Std.", "(333) Kapazit&auml;tsbestand im Folgequartal (in Stunden)", "", "0"));
1860         if (!returnvalue)
1861             log.error(" FAILED");
1862 
1863         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_UEBERSCHRIFTGRUNDDATENKOSTEN_KEY);
1864         ergebnissdatenFeldname = null;
1865         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1866         if (ergebnissdatenFeldnamenIterator.hasNext())
1867         {
1868             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1869         }
1870         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(34) Kosten", "", "0"));
1871         if (!returnvalue)
1872             log.error(" FAILED");
1873 
1874         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENQUALITAETSKOSTEN_KEY);
1875         ergebnissdatenFeldname = null;
1876         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1877         if (ergebnissdatenFeldnamenIterator.hasNext())
1878         {
1879             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1880         }
1881         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(341) Qualit&auml;tskosten (in 1000 EUR)", "", "-1000"));
1882         if (!returnvalue)
1883             log.error(" FAILED");
1884 
1885         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENQUALITAETSKOSTENNACHARBEITSLOHNKOSTEN_KEY);
1886         ergebnissdatenFeldname = null;
1887         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1888         if (ergebnissdatenFeldnamenIterator.hasNext())
1889         {
1890             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1891         }
1892         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(342) davon Nacharbeitslohnkosten (in 1000 EUR)", "", "-1000"));
1893         if (!returnvalue)
1894             log.error(" FAILED");
1895 //
1896 //        ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_UEBERSCHRIFTGRUNDDATENROHSTOFFE_KEY);
1897 //        ergebnissdatenFeldname = null;
1898 //        ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1899 //        if (ergebnissdatenFeldnamenIterator.hasNext())
1900 //        {
1901 //            ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1902 //        }
1903 //        returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(41) Rohstoffe", "", "0"));
1904 //        if (!returnvalue)
1905 //            log.error(" FAILED");
1906 
1907         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENROHSTOFFKAUFNORMALUNDEXPRESS_KEY);
1908         ergebnissdatenFeldname = null;
1909         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1910         if (ergebnissdatenFeldnamenIterator.hasNext())
1911         {
1912             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1913         }
1914         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(41) Rohstoffkauf [normal und express] (in 1000 St&uuml;ck)", "", "-1000"));
1915         if (!returnvalue)
1916             log.error(" FAILED");
1917 
1918         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENROHSTOFFVERBRAUCHQUARTAL_KEY);
1919         ergebnissdatenFeldname = null;
1920         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1921         if (ergebnissdatenFeldnamenIterator.hasNext())
1922         {
1923             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1924         }
1925         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(42) Rohstoffverbrauch im Quartal (in 1000 St&uuml;ck)", "", "-1000"));
1926         if (!returnvalue)
1927             log.error(" FAILED");
1928 
1929         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENROHSTOFFLAGERBESTANDQUARTALSENDE_KEY);
1930         ergebnissdatenFeldname = null;
1931         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1932         if (ergebnissdatenFeldnamenIterator.hasNext())
1933         {
1934             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1935         }
1936         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(43) Rohstofflagerbestand am Quartalsende (in 1000 St&uuml;ck)", "", "-1000"));
1937         if (!returnvalue)
1938             log.error(" FAILED");
1939 
1940         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENROHSTOFFWERTQUARTALSENDE_KEY);
1941         ergebnissdatenFeldname = null;
1942         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1943         if (ergebnissdatenFeldnamenIterator.hasNext())
1944         {
1945             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1946         }
1947         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(44) Rohstoffwert am Quartalsende (in EUR/St&uuml;ck)", "", "2"));
1948         if (!returnvalue)
1949             log.error(" FAILED");
1950 
1951         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGVERTRIEB_KEY);
1952         ergebnissdatenFeldname = null;
1953         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1954         if (ergebnissdatenFeldnamenIterator.hasNext())
1955         {
1956             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1957         }
1958         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(1) VERTRIEB", "", "-1000"));
1959         if (!returnvalue)
1960             log.error(" FAILED");
1961 
1962         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGUMSATZERLOESE_KEY);
1963         ergebnissdatenFeldname = null;
1964         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1965         if (ergebnissdatenFeldnamenIterator.hasNext())
1966         {
1967             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1968         }
1969         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(11) Umsatzerl&ouml;se", "", "-1000"));
1970         if (!returnvalue)
1971             log.error(" FAILED");
1972 
1973         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGMARKETINGKOSTEN_KEY);
1974         ergebnissdatenFeldname = null;
1975         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1976         if (ergebnissdatenFeldnamenIterator.hasNext())
1977         {
1978             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1979         }
1980         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(12) Marketingkosten", "", "-1000"));
1981         if (!returnvalue)
1982             log.error(" FAILED");
1983 
1984         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGLAGERZUGANGFERTIGPRODUKTE_KEY);
1985         ergebnissdatenFeldname = null;
1986         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1987         if (ergebnissdatenFeldnamenIterator.hasNext())
1988         {
1989             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
1990         }
1991         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(13) Lagerzugang Fertigprodukte", "", "-1000"));
1992         if (!returnvalue)
1993             log.error(" FAILED");
1994 
1995         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGLAGERABGANGFERTIGPRODUKTE_KEY);
1996         ergebnissdatenFeldname = null;
1997         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
1998         if (ergebnissdatenFeldnamenIterator.hasNext())
1999         {
2000             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2001         }
2002         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(14) Lagerabgang Fertigprodukte", "", "-1000"));
2003         if (!returnvalue)
2004             log.error(" FAILED");
2005 
2006         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGLAGERUNGSKOSTENFERTIGPRODUKTE_KEY);
2007         ergebnissdatenFeldname = null;
2008         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2009         if (ergebnissdatenFeldnamenIterator.hasNext())
2010         {
2011             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2012         }
2013         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(15) Lagerungskosten Fertigprodukte", "", "-1000"));
2014         if (!returnvalue)
2015             log.error(" FAILED");
2016 
2017         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGMARKTFORSCHUNGSKOSTEN_KEY);
2018         ergebnissdatenFeldname = null;
2019         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2020         if (ergebnissdatenFeldnamenIterator.hasNext())
2021         {
2022             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2023         }
2024         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(16) Marktforschungskosten", "", "-1000"));
2025         if (!returnvalue)
2026             log.error(" FAILED");
2027 
2028         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGPRODUKTION_KEY);
2029         ergebnissdatenFeldname = null;
2030         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2031         if (ergebnissdatenFeldnamenIterator.hasNext())
2032         {
2033             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2034         }
2035         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(2) PRODUKTION", "", "-1000"));
2036         if (!returnvalue)
2037             log.error(" FAILED");
2038 
2039         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGFORSCHUNGSUNDENTWICKLUNGSKOSTEN_KEY);
2040         ergebnissdatenFeldname = null;
2041         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2042         if (ergebnissdatenFeldnamenIterator.hasNext())
2043         {
2044             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2045         }
2046         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(21) Forschungs- und Entwicklungskosten", "", "-1000"));
2047         if (!returnvalue)
2048             log.error(" FAILED");
2049 
2050         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGLIZENZERWERBSKOSTEN_KEY);
2051         ergebnissdatenFeldname = null;
2052         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2053         if (ergebnissdatenFeldnamenIterator.hasNext())
2054         {
2055             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2056         }
2057         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(22) Lizenzerwerbskosten", "", "-1000"));
2058         if (!returnvalue)
2059             log.error(" FAILED");
2060 
2061         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGLIZENZVERKAUFSERLOESE_KEY);
2062         ergebnissdatenFeldname = null;
2063         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2064         if (ergebnissdatenFeldnamenIterator.hasNext())
2065         {
2066             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2067         }
2068         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(23) Lizenzverkaufserl&ouml;se", "", "-1000"));
2069         if (!returnvalue)
2070             log.error(" FAILED");
2071 
2072         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGAUFARBEITUNGSKOSTEN_KEY);
2073         ergebnissdatenFeldname = null;
2074         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2075         if (ergebnissdatenFeldnamenIterator.hasNext())
2076         {
2077             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2078         }
2079         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(24) Aufarbeitungskosten", "", "-1000"));
2080         if (!returnvalue)
2081             log.error(" FAILED");
2082 
2083         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGQUALITAETSSICHERUNGSKOSTEN_KEY);
2084         ergebnissdatenFeldname = null;
2085         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2086         if (ergebnissdatenFeldnamenIterator.hasNext())
2087         {
2088             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2089         }
2090         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(25) Qualit&auml;tssicherungskosten", "", "-1000"));
2091         if (!returnvalue)
2092             log.error(" FAILED");
2093 
2094         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGFERTIGUNGSLOHNKOSTEN_KEY);
2095         ergebnissdatenFeldname = null;
2096         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2097         if (ergebnissdatenFeldnamenIterator.hasNext())
2098         {
2099             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2100         }
2101         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(26) Fertigungslohnkosten", "", "-1000"));
2102         if (!returnvalue)
2103             log.error(" FAILED");
2104 
2105         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGFLKOHNEUEBERSTUNDENUNDNACHARBEIT_KEY);
2106         ergebnissdatenFeldname = null;
2107         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2108         if (ergebnissdatenFeldnamenIterator.hasNext())
2109         {
2110             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2111         }
2112         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(261) von (26) FLK ohne &Uuml;berstunden und Nacharbeit", "", "-1000"));
2113         if (!returnvalue)
2114             log.error(" FAILED");
2115 
2116         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGUEBERSTUNDENZUSCHLAEGEFLKOHNEUEBERSTUNDENUNDNACHARBEIT_KEY);
2117         ergebnissdatenFeldname = null;
2118         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2119         if (ergebnissdatenFeldnamenIterator.hasNext())
2120         {
2121             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2122         }
2123         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(262) von (26) &Uuml;berstundenzuschl&auml;ge auf (261)", "", "-1000"));
2124         if (!returnvalue)
2125             log.error(" FAILED");
2126 
2127         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGNACHARBEITSKOSTENOHNEUEBERSTUNDEN_KEY);
2128         ergebnissdatenFeldname = null;
2129         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2130         if (ergebnissdatenFeldnamenIterator.hasNext())
2131         {
2132             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2133         }
2134         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(263) von (26) Nacharbeitskosten ohne &Uuml;berstunden", "", "-1000"));
2135         if (!returnvalue)
2136             log.error(" FAILED");
2137 
2138         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGUEBERSTUNDENZUSCHLAEGENACHARBEITSKOSTENOHNEUEBERSTUNDEN_KEY);
2139         ergebnissdatenFeldname = null;
2140         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2141         if (ergebnissdatenFeldnamenIterator.hasNext())
2142         {
2143             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2144         }
2145         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(264) von (26) &Uuml;berstundenzuschl&auml;ge auf (263)", "", "-1000"));
2146         if (!returnvalue)
2147             log.error(" FAILED");
2148 
2149         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGSCHICHTWECHSELKOSTEN_KEY);
2150         ergebnissdatenFeldname = null;
2151         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2152         if (ergebnissdatenFeldnamenIterator.hasNext())
2153         {
2154             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2155         }
2156         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(27) Schichtwechselkosten", "", "-1000"));
2157         if (!returnvalue)
2158             log.error(" FAILED");
2159 
2160         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGABSCHREIBUNGSKOSTEN_KEY);
2161         ergebnissdatenFeldname = null;
2162         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2163         if (ergebnissdatenFeldnamenIterator.hasNext())
2164         {
2165             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2166         }
2167         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(28) Abschreibungskosten", "", "-1000"));
2168         if (!returnvalue)
2169             log.error(" FAILED");
2170 
2171         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGBESCHAFFUNG_KEY);
2172         ergebnissdatenFeldname = null;
2173         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2174         if (ergebnissdatenFeldnamenIterator.hasNext())
2175         {
2176             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2177         }
2178         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(3) BESCHAFFUNG", "", "-1000"));
2179         if (!returnvalue)
2180             log.error(" FAILED");
2181 
2182         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGANLAGENPROJEKTIERUNGSKOSTEN_KEY);
2183         ergebnissdatenFeldname = null;
2184         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2185         if (ergebnissdatenFeldnamenIterator.hasNext())
2186         {
2187             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2188         }
2189         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(31) Anlagenprojektierungskosten", "", "-1000"));
2190         if (!returnvalue)
2191             log.error(" FAILED");
2192 
2193         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGROHSTOFFVERBRAUCHSKOSTEN_KEY);
2194         ergebnissdatenFeldname = null;
2195         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2196         if (ergebnissdatenFeldnamenIterator.hasNext())
2197         {
2198             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2199         }
2200         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(32) Rohstoffverbrauchskosten", "", "-1000"));
2201         if (!returnvalue)
2202             log.error(" FAILED");
2203 
2204         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGROHSTOFFBESTELLUNGSKOSTEN_KEY);
2205         ergebnissdatenFeldname = null;
2206         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2207         if (ergebnissdatenFeldnamenIterator.hasNext())
2208         {
2209             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2210         }
2211         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(33) Rohstoffbestellungskosten", "", "-1000"));
2212         if (!returnvalue)
2213             log.error(" FAILED");
2214 
2215         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGLAGERKOSTENROHSTOFFE_KEY);
2216         ergebnissdatenFeldname = null;
2217         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2218         if (ergebnissdatenFeldnamenIterator.hasNext())
2219         {
2220             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2221         }
2222         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(34) Lagerkosten Rohstoffe", "", "-1000"));
2223         if (!returnvalue)
2224             log.error(" FAILED");
2225 
2226         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGOVERHEAD_KEY);
2227         ergebnissdatenFeldname = null;
2228         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2229         if (ergebnissdatenFeldnamenIterator.hasNext())
2230         {
2231             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2232         }
2233         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(4) OVERHEAD", "", "-1000"));
2234         if (!returnvalue)
2235             log.error(" FAILED");
2236 
2237         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGVERWALTUNGSKOSTEN_KEY);
2238         ergebnissdatenFeldname = null;
2239         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2240         if (ergebnissdatenFeldnamenIterator.hasNext())
2241         {
2242             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2243         }
2244         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(41) Verwaltungskosten", "", "-1000"));
2245         if (!returnvalue)
2246             log.error(" FAILED");
2247 
2248         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGBERATUNGSKOSTEN_KEY);
2249         ergebnissdatenFeldname = null;
2250         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2251         if (ergebnissdatenFeldnamenIterator.hasNext())
2252         {
2253             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2254         }
2255         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(42) Beratungskosten", "", "-1000"));
2256         if (!returnvalue)
2257             log.error(" FAILED");
2258 
2259         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGZINSKOSTENKONTOKORRENTKREDIT_KEY);
2260         ergebnissdatenFeldname = null;
2261         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2262         if (ergebnissdatenFeldnamenIterator.hasNext())
2263         {
2264             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2265         }
2266         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(43) Zinskosten f&uuml;r Kontokorrentkredit", "", "-1000"));
2267         if (!returnvalue)
2268             log.error(" FAILED");
2269 
2270         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGZINSKOSTENBANKDARLEHEN_KEY);
2271         ergebnissdatenFeldname = null;
2272         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2273         if (ergebnissdatenFeldnamenIterator.hasNext())
2274         {
2275             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2276         }
2277         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(44) Zinskosten f&uuml;r Bankdarlehen", "", "-1000"));
2278         if (!returnvalue)
2279             log.error(" FAILED");
2280 
2281         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGERFOLGVORSTEUERN_KEY);
2282         ergebnissdatenFeldname = null;
2283         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2284         if (ergebnissdatenFeldnamenIterator.hasNext())
2285         {
2286             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2287         }
2288         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(51) Erfolg vor Steuern", "", "-1000"));
2289         if (!returnvalue)
2290             log.error(" FAILED");
2291 
2292         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGSTEUERN_KEY);
2293         ergebnissdatenFeldname = null;
2294         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2295         if (ergebnissdatenFeldnamenIterator.hasNext())
2296         {
2297             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2298         }
2299         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(52) Steuern", "", "-1000"));
2300         if (!returnvalue)
2301             log.error(" FAILED");
2302 
2303         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGERFOLGNACHSTEUERN_KEY);
2304         ergebnissdatenFeldname = null;
2305         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2306         if (ergebnissdatenFeldnamenIterator.hasNext())
2307         {
2308             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2309         }
2310         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(53) Erfolg nach Steuern", "", "-1000"));
2311         if (!returnvalue)
2312             log.error(" FAILED");
2313 
2314         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGDIVIDENDE_KEY);
2315         ergebnissdatenFeldname = null;
2316         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2317         if (ergebnissdatenFeldnamenIterator.hasNext())
2318         {
2319             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2320         }
2321         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(54) Dividende", "", "-1000"));
2322         if (!returnvalue)
2323             log.error(" FAILED");
2324 
2325         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ERFOLGSRECHNUNGRUECKLAGENZUFUEHRUNG_KEY);
2326         ergebnissdatenFeldname = null;
2327         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2328         if (ergebnissdatenFeldnamenIterator.hasNext())
2329         {
2330             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2331         }
2332         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(55) R&uuml;cklagenzuf&uuml;hrung", "", "-1000"));
2333         if (!returnvalue)
2334             log.error(" FAILED");
2335 
2336         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGAKTIVA_KEY);
2337         ergebnissdatenFeldname = null;
2338         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2339         if (ergebnissdatenFeldnamenIterator.hasNext())
2340         {
2341             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2342         }
2343         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(1) AKTIVA", "", "-1000"));
2344         if (!returnvalue)
2345             log.error(" FAILED");
2346 
2347         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGANLAGEVERMOEGEN_KEY);
2348         ergebnissdatenFeldname = null;
2349         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2350         if (ergebnissdatenFeldnamenIterator.hasNext())
2351         {
2352             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2353         }
2354         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(11) Anlageverm&ouml;gen", "", "-1000"));
2355         if (!returnvalue)
2356             log.error(" FAILED");
2357 
2358         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGROHSTOFFLAGERBESTAND_KEY);
2359         ergebnissdatenFeldname = null;
2360         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2361         if (ergebnissdatenFeldnamenIterator.hasNext())
2362         {
2363             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2364         }
2365         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(12) Rohstofflagerbestand", "", "-1000"));
2366         if (!returnvalue)
2367             log.error(" FAILED");
2368 
2369         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGLAGERBESTANDFERTIGPRODUKTE_KEY);
2370         ergebnissdatenFeldname = null;
2371         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2372         if (ergebnissdatenFeldnamenIterator.hasNext())
2373         {
2374             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2375         }
2376         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(13) Lagerbestand an Fertigprodukten", "", "-1000"));
2377         if (!returnvalue)
2378             log.error(" FAILED");
2379 
2380         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGKASSE_KEY);
2381         ergebnissdatenFeldname = null;
2382         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2383         if (ergebnissdatenFeldnamenIterator.hasNext())
2384         {
2385             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2386         }
2387         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(14) Kasse", "", "-1000"));
2388         if (!returnvalue)
2389             log.error(" FAILED");
2390 
2391         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGKAPITALERHOEHUNG_KEY);
2392         ergebnissdatenFeldname = null;
2393         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2394         if (ergebnissdatenFeldnamenIterator.hasNext())
2395         {
2396             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2397         }
2398         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(15) Kapitalerh&ouml;hung", "", "-1000"));
2399         if (!returnvalue)
2400             log.error(" FAILED");
2401 
2402         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGPASSIVA_KEY);
2403         ergebnissdatenFeldname = null;
2404         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2405         if (ergebnissdatenFeldnamenIterator.hasNext())
2406         {
2407             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2408         }
2409         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(2) PASSIVA", "", "-1000"));
2410         if (!returnvalue)
2411             log.error(" FAILED");
2412 
2413         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGEIGENKAPITAL_KEY);
2414         ergebnissdatenFeldname = null;
2415         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2416         if (ergebnissdatenFeldnamenIterator.hasNext())
2417         {
2418             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2419         }
2420         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(21) Eigenkapital (= AKTIVA - 22 - 23 - 24)", "", "-1000"));
2421         if (!returnvalue)
2422             log.error(" FAILED");
2423 
2424         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGUNVERZINSLICHEVERBINDLICHKEITEN_KEY);
2425         ergebnissdatenFeldname = null;
2426         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2427         if (ergebnissdatenFeldnamenIterator.hasNext())
2428         {
2429             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2430         }
2431         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(22) unverzinsliche Verbindlichkeiten", "", "-1000"));
2432         if (!returnvalue)
2433             log.error(" FAILED");
2434 
2435         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGKONTOKORRENTKREDIT_KEY);
2436         ergebnissdatenFeldname = null;
2437         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2438         if (ergebnissdatenFeldnamenIterator.hasNext())
2439         {
2440             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2441         }
2442         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(23) Kontokorrentkredit", "", "-1000"));
2443         if (!returnvalue)
2444             log.error(" FAILED");
2445 
2446         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VERMOEGENSRECHNUNGBANKKREDIT_KEY);
2447         ergebnissdatenFeldname = null;
2448         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2449         if (ergebnissdatenFeldnamenIterator.hasNext())
2450         {
2451             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2452         }
2453         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(24) Bankdarlehen", "", "-1000"));
2454         if (!returnvalue)
2455             log.error(" FAILED");
2456 
2457         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGBANKDARLEHEN_KEY);
2458         ergebnissdatenFeldname = null;
2459         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2460         if (ergebnissdatenFeldnamenIterator.hasNext())
2461         {
2462             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2463         }
2464         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(11) Bankdarlehen", "", "-1000"));
2465         if (!returnvalue)
2466             log.error(" FAILED");
2467 
2468         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGKONTOKORRENTKREDIT_KEY);
2469         ergebnissdatenFeldname = null;
2470         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2471         if (ergebnissdatenFeldnamenIterator.hasNext())
2472         {
2473             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2474         }
2475         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(12) Kontokorrentkredit", "", "-1000"));
2476         if (!returnvalue)
2477             log.error(" FAILED");
2478 
2479         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGKAPITALERHOEHUNG_KEY);
2480         ergebnissdatenFeldname = null;
2481         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2482         if (ergebnissdatenFeldnamenIterator.hasNext())
2483         {
2484             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2485         }
2486         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(13) Kapitalerh&ouml;hung", "", "-1000"));
2487         if (!returnvalue)
2488             log.error(" FAILED");
2489 
2490         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGKASSE_KEY);
2491         ergebnissdatenFeldname = null;
2492         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2493         if (ergebnissdatenFeldnamenIterator.hasNext())
2494         {
2495             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2496         }
2497         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(14) Kasse", "", "-1000"));
2498         if (!returnvalue)
2499             log.error(" FAILED");
2500 
2501         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGUNVERZINSLICHEVERBINDLICHKEITEN_KEY);
2502         ergebnissdatenFeldname = null;
2503         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2504         if (ergebnissdatenFeldnamenIterator.hasNext())
2505         {
2506             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2507         }
2508         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(15) unverzinsliche Verbindlichkeiten", "", "-1000"));
2509         if (!returnvalue)
2510             log.error(" FAILED");
2511 
2512         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGSALDO_KEY);
2513         ergebnissdatenFeldname = null;
2514         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2515         if (ergebnissdatenFeldnamenIterator.hasNext())
2516         {
2517             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2518         }
2519         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(16) Saldo (= 15 - 14 -13)", "", "-1000"));
2520         if (!returnvalue)
2521             log.error(" FAILED");
2522 
2523         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGLIQUIDITAETSWIRKSAMERERFOLGOHNEZINSEN_KEY);
2524         ergebnissdatenFeldname = null;
2525         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2526         if (ergebnissdatenFeldnamenIterator.hasNext())
2527         {
2528             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2529         }
2530         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(21) liquidit&auml;tswirksamer Erfolg ohne Zinsen", "", "-1000"));
2531         if (!returnvalue)
2532             log.error(" FAILED");
2533 
2534         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGKAPITALBEDARF_KEY);
2535         ergebnissdatenFeldname = null;
2536         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2537         if (ergebnissdatenFeldnamenIterator.hasNext())
2538         {
2539             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2540         }
2541         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(22) Kapitalbedarf (= 16 - 21)", "", "-1000"));
2542         if (!returnvalue)
2543             log.error(" FAILED");
2544 
2545         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGOPTIMALERKONTOKORRENTKREDIT_KEY);
2546         ergebnissdatenFeldname = null;
2547         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2548         if (ergebnissdatenFeldnamenIterator.hasNext())
2549         {
2550             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2551         }
2552         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(31) optimaler Kontokorrentkredit (GZS = 3%)", "", "-1000"));
2553         if (!returnvalue)
2554             log.error(" FAILED");
2555 
2556         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGOPTIMALEAENDERUNGKONTOKORRENTKREDIT_KEY);
2557         ergebnissdatenFeldname = null;
2558         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2559         if (ergebnissdatenFeldnamenIterator.hasNext())
2560         {
2561             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2562         }
2563         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(32) optimale &Auml;nderung Kontokorrentkredit (= 31 - 12)", "", "-1000"));
2564         if (!returnvalue)
2565             log.error(" FAILED");
2566 
2567         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGOPTIMALEAENDERUNGBANKDARLEHEN_KEY);
2568         ergebnissdatenFeldname = null;
2569         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2570         if (ergebnissdatenFeldnamenIterator.hasNext())
2571         {
2572             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2573         }
2574         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(33) optimale &Auml;nderung Bankdarlehen (= 22 - 32)", "", "-1000"));
2575         if (!returnvalue)
2576             log.error(" FAILED");
2577 
2578         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGDURCHSCHNITTLICHERZINSSATZ_KEY);
2579         ergebnissdatenFeldname = null;
2580         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2581         if (ergebnissdatenFeldnamenIterator.hasNext())
2582         {
2583             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2584         }
2585         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(41) durchschnittlicher Zinssatz", "", "2"));
2586         if (!returnvalue)
2587             log.error(" FAILED");
2588 
2589         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGZUVIELBEZAHLTEZINSEN_KEY);
2590         ergebnissdatenFeldname = null;
2591         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2592         if (ergebnissdatenFeldnamenIterator.hasNext())
2593         {
2594             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2595         }
2596         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(42) zuviel bezahlte Zinsen", "", "-1000"));
2597         if (!returnvalue)
2598             log.error(" FAILED");
2599 
2600         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGINVESTITIONEN_KEY);
2601         ergebnissdatenFeldname = null;
2602         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2603         if (ergebnissdatenFeldnamenIterator.hasNext())
2604         {
2605             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2606         }
2607         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(51) Investitionen", "", "-1000"));
2608         if (!returnvalue)
2609             log.error(" FAILED");
2610 
2611         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGROHSTOFFENORMALUNDEXPRESS_KEY);
2612         ergebnissdatenFeldname = null;
2613         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2614         if (ergebnissdatenFeldnamenIterator.hasNext())
2615         {
2616             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2617         }
2618         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(52) Rohstoffe (normal + express)", "", "-1000"));
2619         if (!returnvalue)
2620             log.error(" FAILED");
2621 
2622         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGDIVIDENDE_KEY);
2623         ergebnissdatenFeldname = null;
2624         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2625         if (ergebnissdatenFeldnamenIterator.hasNext())
2626         {
2627             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2628         }
2629         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(53) Dividende", "", "-1000"));
2630         if (!returnvalue)
2631             log.error(" FAILED");
2632 
2633         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGSTEUERN_KEY);
2634         ergebnissdatenFeldname = null;
2635         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2636         if (ergebnissdatenFeldnamenIterator.hasNext())
2637         {
2638             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2639         }
2640         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(54) Steuern", "", "-1000"));
2641         if (!returnvalue)
2642             log.error(" FAILED");
2643 
2644         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGLIQUIDITAETSWIRKSAMERERFOLG_KEY);
2645         ergebnissdatenFeldname = null;
2646         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2647         if (ergebnissdatenFeldnamenIterator.hasNext())
2648         {
2649             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2650         }
2651         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(55) liquidit&auml;tswirksamer Erfolg", "", "-1000"));
2652         if (!returnvalue)
2653             log.error(" FAILED");
2654 
2655         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGLIQUIDITAETSAENDERUNG_KEY);
2656         ergebnissdatenFeldname = null;
2657         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2658         if (ergebnissdatenFeldnamenIterator.hasNext())
2659         {
2660             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2661         }
2662         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(56) Liquidit&auml;ts&auml;nderung (= 51 + 52 + 53 + 54 + 55)  ", "", "-1000"));
2663         if (!returnvalue)
2664             log.error(" FAILED");
2665 
2666         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_FINANZIERUNGLIQUIDITAETSAENDERUNGBEIGEPLANTEMABSATZ_KEY);
2667         ergebnissdatenFeldname = null;
2668         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2669         if (ergebnissdatenFeldnamenIterator.hasNext())
2670         {
2671             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2672         }
2673         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(57) Liquidit&auml;ts&auml;nderung bei geplantem Absatz", "", "-1000"));
2674         if (!returnvalue)
2675             log.error(" FAILED");
2676 
2677         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGVERKAUFSPREIS_KEY);
2678         ergebnissdatenFeldname = null;
2679         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2680         if (ergebnissdatenFeldnamenIterator.hasNext())
2681         {
2682             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2683         }
2684         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(11) Verkaufspreis in EUR/Stk.", "Verkaufspreis", "2"));
2685         if (!returnvalue)
2686             log.error(" FAILED");
2687 
2688         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGMARKETING_KEY);
2689         ergebnissdatenFeldname = null;
2690         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2691         if (ergebnissdatenFeldnamenIterator.hasNext())
2692         {
2693             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2694         }
2695         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(12) Marketing in 1000 EUR", "Marketing", ""));
2696         if (!returnvalue)
2697             log.error(" FAILED");
2698 
2699         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGMARKTFORSCHUNGSDIENST_KEY);
2700         ergebnissdatenFeldname = null;
2701         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2702         if (ergebnissdatenFeldnamenIterator.hasNext())
2703         {
2704             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2705         }
2706         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(13) Marktforschungsdienst Nr.", "Marktforschungsdienst Nr.", ""));
2707         if (!returnvalue)
2708             log.error(" FAILED");
2709 
2710         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGABSETZBAREMENGE_KEY);
2711         ergebnissdatenFeldname = null;
2712         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2713         if (ergebnissdatenFeldnamenIterator.hasNext())
2714         {
2715             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2716         }
2717         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(14) Absetzbare Menge in 1000 Stk.", "Absetzbare Menge", ""));
2718         if (!returnvalue)
2719             log.error(" FAILED");
2720 
2721         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGPRODUKTART_KEY);
2722         ergebnissdatenFeldname = null;
2723         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2724         if (ergebnissdatenFeldnamenIterator.hasNext())
2725         {
2726             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2727         }
2728         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(21) Produktart", "Produktart", ""));
2729         if (!returnvalue)
2730             log.error(" FAILED");
2731 
2732         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGPRODUKTIONSMENGE_KEY);
2733         ergebnissdatenFeldname = null;
2734         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2735         if (ergebnissdatenFeldnamenIterator.hasNext())
2736         {
2737             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2738         }
2739         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(22) Produktionsmenge in 1000 \"guten\" Stk.", "Produktionsmenge", ""));
2740         if (!returnvalue)
2741             log.error(" FAILED");
2742 
2743         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGQUALITAETSSICHERUNG_KEY);
2744         ergebnissdatenFeldname = null;
2745         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2746         if (ergebnissdatenFeldnamenIterator.hasNext())
2747         {
2748             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2749         }
2750         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(23) Qualit&auml;tssicherung in EUR/Stk.", "Qualit&auml;tssicherung", "2"));
2751         if (!returnvalue)
2752             log.error(" FAILED");
2753 
2754         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGQSKOSTENMINIMUM_KEY);
2755         ergebnissdatenFeldname = null;
2756         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2757         if (ergebnissdatenFeldnamenIterator.hasNext())
2758         {
2759             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2760         }
2761         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(24) QSKosten minimierende Qualit&auml;tssicherung in EUR/Stk.", "Qualit&auml;tssicherung Optimum", "2"));
2762         if (!returnvalue)
2763             log.error(" FAILED");
2764 
2765         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGKAPAZITAETSAUSLASTUNG_KEY);
2766         ergebnissdatenFeldname = null;
2767         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2768         if (ergebnissdatenFeldnamenIterator.hasNext())
2769         {
2770             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2771         }
2772         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "(25) Kapazit&auml;tsauslastung in Prozent", "Kapazit&auml;tsauslastung", "3"));
2773         if (!returnvalue)
2774             log.error(" FAILED");
2775 
2776         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGINVESTITIONEN_KEY);
2777         ergebnissdatenFeldname = null;
2778         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2779         if (ergebnissdatenFeldnamenIterator.hasNext())
2780         {
2781             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2782         }
2783         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(26) Investition in 1000 EUR", "Investitionen", ""));
2784         if (!returnvalue)
2785             log.error(" FAILED");
2786 
2787         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGROHSTOFFBESTELLUNGNORMAL_KEY);
2788         ergebnissdatenFeldname = null;
2789         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2790         if (ergebnissdatenFeldnamenIterator.hasNext())
2791         {
2792             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2793         }
2794         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(27) Rohstoffbestellung normal in 1000 EUR", "Rohstoffbestellung normal", ""));
2795         if (!returnvalue)
2796             log.error(" FAILED");
2797 
2798         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGROHSTOFFBESTELLUNGEXPRESS_KEY);
2799         ergebnissdatenFeldname = null;
2800         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2801         if (ergebnissdatenFeldnamenIterator.hasNext())
2802         {
2803             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2804         }
2805         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(28) Rohstoffbestellung express in 1000 EUR", "Rohstoffbestellung express", ""));
2806         if (!returnvalue)
2807             log.error(" FAILED");
2808 
2809         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGDIVIDENDE_KEY);
2810         ergebnissdatenFeldname = null;
2811         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2812         if (ergebnissdatenFeldnamenIterator.hasNext())
2813         {
2814             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2815         }
2816         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(31) Dividende in 1000 EUR", "Dividende", ""));
2817         if (!returnvalue)
2818             log.error(" FAILED");
2819 
2820         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGAENDERUNGBANKDARLEHEN_KEY);
2821         ergebnissdatenFeldname = null;
2822         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2823         if (ergebnissdatenFeldnamenIterator.hasNext())
2824         {
2825             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2826         }
2827         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(32) &Auml;nderung des vereinbarten Kredits um 1000 EUR", "&Auml;nderung des Bankdarlehens", ""));
2828         if (!returnvalue)
2829             log.error(" FAILED");
2830 
2831         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGERHOEHUNGTILGUNG_KEY);
2832         ergebnissdatenFeldname = null;
2833         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2834         if (ergebnissdatenFeldnamenIterator.hasNext())
2835         {
2836             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2837         }
2838         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(33) 0 = Darlehenserh&ouml;hung; 1 = Darlehenstilgung", "Darlehenserh&oumlhung-Tilgung", ""));
2839         if (!returnvalue)
2840             log.error(" FAILED");
2841 
2842         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGZINSEN_KEY);
2843         ergebnissdatenFeldname = null;
2844         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2845         if (ergebnissdatenFeldnamenIterator.hasNext())
2846         {
2847             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2848         }
2849         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(34) Zinsen f&uuml;r den vereinbarten Kredit in 1000 EUR", "Zinsen f&uuml;r das Bankdarlehen", ""));
2850         if (!returnvalue)
2851             log.error(" FAILED");
2852 
2853         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGLIQUIDITAETSAENDERUNG_KEY);
2854         ergebnissdatenFeldname = null;
2855         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2856         if (ergebnissdatenFeldnamenIterator.hasNext())
2857         {
2858             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2859         }
2860         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(35) Liquidit&auml;tsaenderung in +/- 1000 EUR", "Liquidit&auml;tsaenderung", ""));
2861         if (!returnvalue)
2862             log.error(" FAILED");
2863 
2864         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGFUNDE_KEY);
2865         ergebnissdatenFeldname = null;
2866         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2867         if (ergebnissdatenFeldnamenIterator.hasNext())
2868         {
2869             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2870         }
2871         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(41) Forschung und Entwicklung in 1000 EUR", "Forschung und Entwicklung", ""));
2872         if (!returnvalue)
2873             log.error(" FAILED");
2874 
2875         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGLIZENZVERKAUFPRODUKTART_KEY);
2876         ergebnissdatenFeldname = null;
2877         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2878         if (ergebnissdatenFeldnamenIterator.hasNext())
2879         {
2880             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2881         }
2882         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(42A) Lizenzverkauf von Produktart", "Lizenzverkauf von Produktart", ""));
2883         if (!returnvalue)
2884             log.error(" FAILED");
2885 
2886         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGLIZENZVERKAUFUNTERNEHMEN_KEY);
2887         ergebnissdatenFeldname = null;
2888         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2889         if (ergebnissdatenFeldnamenIterator.hasNext())
2890         {
2891             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2892         }
2893         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(42B) Lizenzverkauf an Unternehmen", "Lizenzverkauf an Unternehmen", ""));
2894         if (!returnvalue)
2895             log.error(" FAILED");
2896 
2897         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGLIZENZKAUFUNTERNEHMEN_KEY);
2898         ergebnissdatenFeldname = null;
2899         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2900         if (ergebnissdatenFeldnamenIterator.hasNext())
2901         {
2902             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2903         }
2904         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "(43A) Lizenzerwerb von Unternehmen", "Lizenzerwerb von Unternehmen", ""));
2905         if (!returnvalue)
2906             log.error(" FAILED");
2907 
2908         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGLIZENZKAUFFUER_KEY);
2909         ergebnissdatenFeldname = null;
2910         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2911         if (ergebnissdatenFeldnamenIterator.hasNext())
2912         {
2913             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2914         }
2915         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(43B) Lizenzerwerb f&uuml;r", "Lizenzerwerb", ""));
2916         if (!returnvalue)
2917             log.error(" FAILED");
2918 
2919         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGBERATUNG_KEY);
2920         ergebnissdatenFeldname = null;
2921         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2922         if (ergebnissdatenFeldnamenIterator.hasNext())
2923         {
2924             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2925         }
2926         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "(44) Beratung", "Beratung", ""));
2927         if (!returnvalue)
2928             log.error(" FAILED");
2929 
2930         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ENTSCHEIDUNGGRENZGEWINN_KEY);
2931         ergebnissdatenFeldname = null;
2932         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2933         if (ergebnissdatenFeldnamenIterator.hasNext())
2934         {
2935             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2936         }
2937         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(45) Grenzgewinn in EUR/Stk.", "Grenzgewinn", "2"));
2938         if (!returnvalue)
2939             log.error(" FAILED");
2940 
2941         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGERLOES_KEY);
2942         ergebnissdatenFeldname = null;
2943         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2944         if (ergebnissdatenFeldnamenIterator.hasNext())
2945         {
2946             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2947         }
2948         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(1) ERL&Ouml;S", "", "2"));
2949         if (!returnvalue)
2950             log.error(" FAILED");
2951 
2952         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGKOSTEN_KEY);
2953         ergebnissdatenFeldname = null;
2954         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2955         if (ergebnissdatenFeldnamenIterator.hasNext())
2956         {
2957             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2958         }
2959         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2) KOSTEN (= 2.1 + 2.2 + 2.3)", "", "2"));
2960         if (!returnvalue)
2961             log.error(" FAILED");
2962 
2963         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGVERTRIEBSKOSTEN_KEY);
2964         ergebnissdatenFeldname = null;
2965         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2966         if (ergebnissdatenFeldnamenIterator.hasNext())
2967         {
2968             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2969         }
2970         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.1) VERTRIEBSKOSTEN (pro abgesetztes St&uuml;ck)", "", "2"));
2971         if (!returnvalue)
2972             log.error(" FAILED");
2973 
2974         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGMARKETING_KEY);
2975         ergebnissdatenFeldname = null;
2976         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2977         if (ergebnissdatenFeldnamenIterator.hasNext())
2978         {
2979             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2980         }
2981         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.11) Marketing", "", "2"));
2982         if (!returnvalue)
2983             log.error(" FAILED");
2984 
2985         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGLAGERUNGVONFERTIGPRODUKTEN_KEY);
2986         ergebnissdatenFeldname = null;
2987         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2988         if (ergebnissdatenFeldnamenIterator.hasNext())
2989         {
2990             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
2991         }
2992         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.12) Lagerung von Fertigprodukten", "", "2"));
2993         if (!returnvalue)
2994             log.error(" FAILED");
2995 
2996         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGBERATUNGUNDMARKTFORSCHUNG_KEY);
2997         ergebnissdatenFeldname = null;
2998         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
2999         if (ergebnissdatenFeldnamenIterator.hasNext())
3000         {
3001             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3002         }
3003         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.13) Beratung und Marktforschung", "", "2"));
3004         if (!returnvalue)
3005             log.error(" FAILED");
3006 
3007         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGHERSTELLEINZELKOSTEN_KEY);
3008         ergebnissdatenFeldname = null;
3009         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3010         if (ergebnissdatenFeldnamenIterator.hasNext())
3011         {
3012             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3013         }
3014         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.2) HERSTELL-EINZELKOSTEN (pro produziertem \"gutem\" St&uuml;ck)", "", "2"));
3015         if (!returnvalue)
3016             log.error(" FAILED");
3017 
3018         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGLOEHNEOHNEUEBERSTUNDENZUSCHLAG_KEY);
3019         ergebnissdatenFeldname = null;
3020         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3021         if (ergebnissdatenFeldnamenIterator.hasNext())
3022         {
3023             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3024         }
3025         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.21) L&ouml;hne ohne &Uuml;berstundenzuschlag", "", "2"));
3026         if (!returnvalue)
3027             log.error(" FAILED");
3028 
3029         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGUEBERSTUNDENZUSCHLAG_KEY);
3030         ergebnissdatenFeldname = null;
3031         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3032         if (ergebnissdatenFeldnamenIterator.hasNext())
3033         {
3034             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3035         }
3036         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.22) &Uuml;berstundenzuschlag", "", "2"));
3037         if (!returnvalue)
3038             log.error(" FAILED");
3039 
3040         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGROHSTOFFE_KEY);
3041         ergebnissdatenFeldname = null;
3042         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3043         if (ergebnissdatenFeldnamenIterator.hasNext())
3044         {
3045             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3046         }
3047         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.23) Rohstoffe", "", "2"));
3048         if (!returnvalue)
3049             log.error(" FAILED");
3050 
3051         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGHERSTELLGEMEINKOSTEN_KEY);
3052         ergebnissdatenFeldname = null;
3053         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3054         if (ergebnissdatenFeldnamenIterator.hasNext())
3055         {
3056             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3057         }
3058         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.3) HERSTELL-GEMEINKOSTEN (pro produziertem \"gutem\" St&uuml;ck)", "", "2"));
3059         if (!returnvalue)
3060             log.error(" FAILED");
3061 
3062         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGROHSTOFFLAGERUNGUNDBESTELLUNG_KEY);
3063         ergebnissdatenFeldname = null;
3064         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3065         if (ergebnissdatenFeldnamenIterator.hasNext())
3066         {
3067             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3068         }
3069         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.31) Rohstofflagerung und -bestellung", "", "2"));
3070         if (!returnvalue)
3071             log.error(" FAILED");
3072 
3073         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGABSCHREIBUNGUNDANLAGENPROJEKTIERUNG_KEY);
3074         ergebnissdatenFeldname = null;
3075         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3076         if (ergebnissdatenFeldnamenIterator.hasNext())
3077         {
3078             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3079         }
3080         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.32) Abschreibung und Anlagenprojektierung", "", "2"));
3081         if (!returnvalue)
3082             log.error(" FAILED");
3083 
3084         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGQUALITAETSSICHERUNG_KEY);
3085         ergebnissdatenFeldname = null;
3086         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3087         if (ergebnissdatenFeldnamenIterator.hasNext())
3088         {
3089             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3090         }
3091         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.33) Qualit&auml;tssicherung", "", "2"));
3092         if (!returnvalue)
3093             log.error(" FAILED");
3094 
3095         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGSCHICHTWECHSEL_KEY);
3096         ergebnissdatenFeldname = null;
3097         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3098         if (ergebnissdatenFeldnamenIterator.hasNext())
3099         {
3100             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3101         }
3102         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.34) Schichtwechsel", "", "2"));
3103         if (!returnvalue)
3104             log.error(" FAILED");
3105 
3106         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGFUNDEAUFARBEITUNGTRANSFERERTRAEGE_KEY);
3107         ergebnissdatenFeldname = null;
3108         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3109         if (ergebnissdatenFeldnamenIterator.hasNext())
3110         {
3111             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3112         }
3113         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.35) F&amp;E, Aufarbeitung - Transferertr&auml;ge", "", "2"));
3114         if (!returnvalue)
3115             log.error(" FAILED");
3116 
3117         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGZINSEN_KEY);
3118         ergebnissdatenFeldname = null;
3119         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3120         if (ergebnissdatenFeldnamenIterator.hasNext())
3121         {
3122             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3123         }
3124         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.36) Zinsen", "", "2"));
3125         if (!returnvalue)
3126             log.error(" FAILED");
3127 
3128         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGVERWALTUNG_KEY);
3129         ergebnissdatenFeldname = null;
3130         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3131         if (ergebnissdatenFeldnamenIterator.hasNext())
3132         {
3133             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3134         }
3135         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2.37) Verwaltung", "", "2"));
3136         if (!returnvalue)
3137             log.error(" FAILED");
3138 
3139         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGGEWINN_KEY);
3140         ergebnissdatenFeldname = null;
3141         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3142         if (ergebnissdatenFeldnamenIterator.hasNext())
3143         {
3144             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3145         }
3146         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(3) GEWINN (= 1 - 2)", "", "2"));
3147         if (!returnvalue)
3148             log.error(" FAILED");
3149 
3150         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGPRODUZIERTEMENGE_KEY);
3151         ergebnissdatenFeldname = null;
3152         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3153         if (ergebnissdatenFeldnamenIterator.hasNext())
3154         {
3155             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3156         }
3157         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(4) produzierte Menge (in 1.000 St&uuml;ck)", "", "-1000"));
3158         if (!returnvalue)
3159             log.error(" FAILED");
3160 
3161         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_VOLLKOSTENRECHNUNGABGESETZTEMENGE_KEY);
3162         ergebnissdatenFeldname = null;
3163         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3164         if (ergebnissdatenFeldnamenIterator.hasNext())
3165         {
3166             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3167         }
3168         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(5) abgesetzte Menge (in 1.000 St&uuml;ck)", "", "-1000"));
3169         if (!returnvalue)
3170             log.error(" FAILED");
3171 
3172         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGGRENZERLOES_KEY);
3173         ergebnissdatenFeldname = null;
3174         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3175         if (ergebnissdatenFeldnamenIterator.hasNext())
3176         {
3177             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3178         }
3179         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(1) GRENZERL&Ouml;S (EUR pro letztverkauftes St&uuml;ck)", "", "2"));
3180         if (!returnvalue)
3181             log.error(" FAILED");
3182 
3183         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGGRENZMARKETINGKOSTEN_KEY);
3184         ergebnissdatenFeldname = null;
3185         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3186         if (ergebnissdatenFeldnamenIterator.hasNext())
3187         {
3188             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3189         }
3190         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(2) GRENZMARKETINGKOSTEN (EUR pro letztverkaufte 10.000 St&uuml;ck)", "", "2"));
3191         if (!returnvalue)
3192             log.error(" FAILED");
3193 
3194         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGGRENZHERSTELLKOSTEN_KEY);
3195         ergebnissdatenFeldname = null;
3196         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3197         if (ergebnissdatenFeldnamenIterator.hasNext())
3198         {
3199             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3200         }
3201         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(3) GRENZHERSTELLKOSTEN (EUR pro letztproduziertem St&uuml;ck)", "", "2"));
3202         if (!returnvalue)
3203             log.error(" FAILED");
3204 
3205         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGLOEHNEOHNEUEBERSTUNDENZUSCHLAG_KEY);
3206         ergebnissdatenFeldname = null;
3207         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3208         if (ergebnissdatenFeldnamenIterator.hasNext())
3209         {
3210             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3211         }
3212         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(3.1) L&ouml;hne ohne &Uuml;berstundenzuschlag", "", "2"));
3213         if (!returnvalue)
3214             log.error(" FAILED");
3215 
3216         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGUEBERSTUNDENZUSCHLAG_KEY);
3217         ergebnissdatenFeldname = null;
3218         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3219         if (ergebnissdatenFeldnamenIterator.hasNext())
3220         {
3221             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3222         }
3223         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(3.2) &Uuml;berstundenzuschlag", "", "2"));
3224         if (!returnvalue)
3225             log.error(" FAILED");
3226 
3227         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGROHSTOFFE_KEY);
3228         ergebnissdatenFeldname = null;
3229         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3230         if (ergebnissdatenFeldnamenIterator.hasNext())
3231         {
3232             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3233         }
3234         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(3.3) Rohstoffe", "", "2"));
3235         if (!returnvalue)
3236             log.error(" FAILED");
3237 
3238         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGQUALITAETSSICHERUNG_KEY);
3239         ergebnissdatenFeldname = null;
3240         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3241         if (ergebnissdatenFeldnamenIterator.hasNext())
3242         {
3243             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3244         }
3245         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(3.4) Qualit&auml;tssicherung", "", "2"));
3246         if (!returnvalue)
3247             log.error(" FAILED");
3248 
3249         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGSCHICHTWECHSEL_KEY);
3250         ergebnissdatenFeldname = null;
3251         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3252         if (ergebnissdatenFeldnamenIterator.hasNext())
3253         {
3254             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3255         }
3256         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(3.5) Schichtwechsel", "", "2"));
3257         if (!returnvalue)
3258             log.error(" FAILED");
3259 
3260         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGVERWALTUNG_KEY);
3261         ergebnissdatenFeldname = null;
3262         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3263         if (ergebnissdatenFeldnamenIterator.hasNext())
3264         {
3265             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3266         }
3267         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(3.6) Verwaltung", "", "2"));
3268         if (!returnvalue)
3269             log.error(" FAILED");
3270 
3271         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGGRENZGEWINN_KEY);
3272         ergebnissdatenFeldname = null;
3273         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3274         if (ergebnissdatenFeldnamenIterator.hasNext())
3275         {
3276             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3277         }
3278         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "(4) GRENZGEWINN (= 1 - 2 - 3)", "", "2"));
3279         if (!returnvalue)
3280             log.error(" FAILED");
3281 
3282         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRENZKOSTENRECHNUNGPRODUKTIONINLETZTERZONE_KEY);
3283         ergebnissdatenFeldname = null;
3284         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3285         if (ergebnissdatenFeldnamenIterator.hasNext())
3286         {
3287             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3288         }
3289         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' Stk.", "(5) Produktion in der \"letzten\" Zone (in 1000 Stk.)", "", "-1000"));
3290         if (!returnvalue)
3291             log.error(" FAILED");
3292 
3293         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKERFOLGVORSTEUERN_KEY);
3294         ergebnissdatenFeldname = null;
3295         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3296         if (ergebnissdatenFeldnamenIterator.hasNext())
3297         {
3298             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3299         }
3300         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "", "Erfolg vor Steuern (in 1000 EUR)", "2"));
3301         if (!returnvalue)
3302             log.error(" FAILED");
3303 
3304         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKERFOLGVORSTEUERNDUR_KEY);
3305         ergebnissdatenFeldname = null;
3306         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3307         if (ergebnissdatenFeldnamenIterator.hasNext())
3308         {
3309             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3310         }
3311         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "DUR", "Erfolg vor Steuern (in 1000 EUR) Durchschnitt", "2"));
3312         if (!returnvalue)
3313             log.error(" FAILED");
3314 
3315         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKERFOLGVORSTEUERNGEW_KEY);
3316         ergebnissdatenFeldname = null;
3317         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3318         if (ergebnissdatenFeldnamenIterator.hasNext())
3319         {
3320             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3321         }
3322         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "GEW", "Erfolg vor Steuern (in 1000 EUR) Gewichteter Durchschnitt", "2"));
3323         if (!returnvalue)
3324             log.error(" FAILED");
3325 
3326         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKUMSATZERLOESE_KEY);
3327         ergebnissdatenFeldname = null;
3328         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3329         if (ergebnissdatenFeldnamenIterator.hasNext())
3330         {
3331             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3332         }
3333         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "Mio. EUR", "", "Umsatzerl&ouml;se in Mio. EUR", "2"));
3334         if (!returnvalue)
3335             log.error(" FAILED");
3336 
3337         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKUMSATZERLOESEDUR_KEY);
3338         ergebnissdatenFeldname = null;
3339         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3340         if (ergebnissdatenFeldnamenIterator.hasNext())
3341         {
3342             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3343         }
3344         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "Mio. EUR", "DUR", "Umsatzerl&ouml;se in Mio. EUR Durchschnitt", "2"));
3345         if (!returnvalue)
3346             log.error(" FAILED");
3347 
3348         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKGRENZGEWINN_KEY);
3349         ergebnissdatenFeldname = null;
3350         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3351         if (ergebnissdatenFeldnamenIterator.hasNext())
3352         {
3353             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3354         }
3355         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "", "Grenzgewinn in EUR pro St&uuml;ck", "2"));
3356         if (!returnvalue)
3357             log.error(" FAILED");
3358 
3359         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKGRENZGEWINNDUR_KEY);
3360         ergebnissdatenFeldname = null;
3361         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3362         if (ergebnissdatenFeldnamenIterator.hasNext())
3363         {
3364             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3365         }
3366         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "DUR", "Grenzgewinn in EUR pro St&uuml;ck Durchschnitt", "2"));
3367         if (!returnvalue)
3368             log.error(" FAILED");
3369 
3370         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKFORSCHUNGUNDENTWICKLUNG_KEY);
3371         ergebnissdatenFeldname = null;
3372         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3373         if (ergebnissdatenFeldnamenIterator.hasNext())
3374         {
3375             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3376         }
3377         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "", "Forschung und Entwicklung in 1.000 EUR", "2"));
3378         if (!returnvalue)
3379             log.error(" FAILED");
3380 
3381         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKFORSCHUNGUNDENTWICKLUNGDUR_KEY);
3382         ergebnissdatenFeldname = null;
3383         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3384         if (ergebnissdatenFeldnamenIterator.hasNext())
3385         {
3386             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3387         }
3388         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "DUR", "Forschung und Entwicklung in 1.000 EUR Durchschnitt", "2"));
3389         if (!returnvalue)
3390             log.error(" FAILED");
3391 
3392         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERABSETZBAREMENGE_KEY);
3393         ergebnissdatenFeldname = null;
3394         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3395         if (ergebnissdatenFeldnamenIterator.hasNext())
3396         {
3397             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3398         }
3399         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "", "Sch&auml;tzfehler absetzbare Menge in Prozent<br/>(Sch&auml;tzung AM - tats&auml;chliche AM) / tats&auml;chliche AM [AM = absetzbare Menge]", "2"));
3400         if (!returnvalue)
3401             log.error(" FAILED");
3402 
3403         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERABSETZBAREMENGEDUR_KEY);
3404         ergebnissdatenFeldname = null;
3405         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3406         if (ergebnissdatenFeldnamenIterator.hasNext())
3407         {
3408             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3409         }
3410         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "DUR", "Sch&auml;tzfehler absetzbare Menge in Prozent Durchschnitt<br/>(Sch&auml;tzung AM - tats&auml;chliche AM) / tats&auml;chliche AM [AM = absetzbare Menge]", "2"));
3411         if (!returnvalue)
3412             log.error(" FAILED");
3413 
3414         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKDEFIZITUNDLAGERBILDUNG_KEY);
3415         ergebnissdatenFeldname = null;
3416         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3417         if (ergebnissdatenFeldnamenIterator.hasNext())
3418         {
3419             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3420         }
3421         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "", "Defizit- und Lagerbildung<br/>&gt;0 : (Lagerbestand - 0,1 * abgesetzte Menge) / abgesetzte Menge<br/>&lt;= 0 : (absetzbare Menge - abgesetzte Menge) / abgesetzte Menge", "2"));
3422         if (!returnvalue)
3423             log.error(" FAILED");
3424 
3425         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKDEFIZITUNDLAGERBILDUNGDUR_KEY);
3426         ergebnissdatenFeldname = null;
3427         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3428         if (ergebnissdatenFeldnamenIterator.hasNext())
3429         {
3430             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3431         }
3432         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "DUR", "Defizit- und Lagerbildung Durchschnitt<br/>&gt;0 : (Lagerbestand - 0,1 * abgesetzte Menge) / abgesetzte Menge<br/>&lt;= 0 : (absetzbare Menge - abgesetzte Menge) / abgesetzte Menge", "2"));
3433         if (!returnvalue)
3434             log.error(" FAILED");
3435 
3436         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKHERSTELLKOSTEN_KEY);
3437         ergebnissdatenFeldname = null;
3438         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3439         if (ergebnissdatenFeldnamenIterator.hasNext())
3440         {
3441             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3442         }
3443         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "", "Herstellkosten in EUR pro \"gutes\" St&uuml;ck", "2"));
3444         if (!returnvalue)
3445             log.error(" FAILED");
3446 
3447         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKHERSTELLKOSTENDUR_KEY);
3448         ergebnissdatenFeldname = null;
3449         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3450         if (ergebnissdatenFeldnamenIterator.hasNext())
3451         {
3452             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3453         }
3454         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "DUR", "Herstellkosten in EUR pro \"gutes\" St&uuml;ck Durchschnitt", "2"));
3455         if (!returnvalue)
3456             log.error(" FAILED");
3457 
3458         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKOPTIMALEQSVSQSKOSTENMINIMIERENDENOMINALEQS_KEY);
3459         ergebnissdatenFeldname = null;
3460         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3461         if (ergebnissdatenFeldnamenIterator.hasNext())
3462         {
3463             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3464         }
3465         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "", "Optimale QS vs. die QSKosten minimierende nominale QS", "2"));
3466         if (!returnvalue)
3467             log.error(" FAILED");
3468 
3469         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKOPTIMALEQSVSQSKOSTENMINIMIERENDENOMINALEQSDUR_KEY);
3470         ergebnissdatenFeldname = null;
3471         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3472         if (ergebnissdatenFeldnamenIterator.hasNext())
3473         {
3474             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3475         }
3476         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "DUR", "Optimale QS vs. die QSKosten minimierende nominale QS Durchschnitt", "2"));
3477         if (!returnvalue)
3478             log.error(" FAILED");
3479 
3480         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKTATSAECHLICHERVSERWARTETERGRENZGEWINN_KEY);
3481         ergebnissdatenFeldname = null;
3482         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3483         if (ergebnissdatenFeldnamenIterator.hasNext())
3484         {
3485             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3486         }
3487         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "", "tats&auml;chlicher vs. erwarteter Grenzgewinn in EUR pro St&uuml;ck", "2"));
3488         if (!returnvalue)
3489             log.error(" FAILED");
3490 
3491         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKTATSAECHLICHERVSERWARTETERGRENZGEWINNDUR_KEY);
3492         ergebnissdatenFeldname = null;
3493         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3494         if (ergebnissdatenFeldnamenIterator.hasNext())
3495         {
3496             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3497         }
3498         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "DUR", "tats&auml;chlicher vs. erwarteter Grenzgewinn in EUR pro St&uuml;ck Durchschnitt", "2"));
3499         if (!returnvalue)
3500             log.error(" FAILED");
3501 
3502         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERKAPAZITAETSAUSLASTUNG_KEY);
3503         ergebnissdatenFeldname = null;
3504         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3505         if (ergebnissdatenFeldnamenIterator.hasNext())
3506         {
3507             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3508         }
3509         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "", "Sch&auml;tzfehler Kapazit&auml;tsauslastung in Prozent<br/>(Sch&auml;tzung KapA. - tats&auml;chliche KapA.) / tats&auml;chliche KapA. [KapA. = Kapazit&auml;tsauslastung]", "2"));
3510         if (!returnvalue)
3511             log.error(" FAILED");
3512 
3513         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERKAPAZITAETSAUSLASTUNGDUR_KEY);
3514         ergebnissdatenFeldname = null;
3515         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3516         if (ergebnissdatenFeldnamenIterator.hasNext())
3517         {
3518             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3519         }
3520         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "DUR", "Sch&auml;tzfehler Kapazit&auml;tsauslastung in Prozent Durchschnitt<br/>(Sch&auml;tzung KapA. - tats&auml;chliche KapA.) / tats&auml;chliche KapA. [KapA. = Kapazit&auml;tsauslastung]", "2"));
3521         if (!returnvalue)
3522             log.error(" FAILED");
3523 
3524         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKUNNOETIGEZINSBELASTUNG_KEY);
3525         ergebnissdatenFeldname = null;
3526         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3527         if (ergebnissdatenFeldnamenIterator.hasNext())
3528         {
3529             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3530         }
3531         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "", "unn&ouml;tige Zinsbelastung in Prozent", "2"));
3532         if (!returnvalue)
3533             log.error(" FAILED");
3534 
3535         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKUNNOETIGEZINSBELASTUNGDUR_KEY);
3536         ergebnissdatenFeldname = null;
3537         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3538         if (ergebnissdatenFeldnamenIterator.hasNext())
3539         {
3540             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3541         }
3542         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "%", "DUR", "unn&ouml;tige Zinsbelastung in Prozent Durchschnitt", "2"));
3543         if (!returnvalue)
3544             log.error(" FAILED");
3545 
3546         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERZAHLUNGSMITTELAENDERUNG_KEY);
3547         ergebnissdatenFeldname = null;
3548         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3549         if (ergebnissdatenFeldnamenIterator.hasNext())
3550         {
3551             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3552         }
3553         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "", "Sch&auml;tzfehler der Zahlungsmittel&auml;nderung in 1.000 EUR", "2"));
3554         if (!returnvalue)
3555             log.error(" FAILED");
3556 
3557         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_BEWERTUNGSUEBERBLICKSCHAETZFEHLERZAHLUNGSMITTELAENDERUNGDUR_KEY);
3558         ergebnissdatenFeldname = null;
3559         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3560         if (ergebnissdatenFeldnamenIterator.hasNext())
3561         {
3562             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3563         }
3564         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "DUR", "Sch&auml;tzfehler der Zahlungsmittel&auml;nderung in 1.000 EUR Durchschnitt", "2"));
3565         if (!returnvalue)
3566             log.error(" FAILED");
3567 
3568         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ALLGEMEINMARKETINGEFFEKT_KEY);
3569         ergebnissdatenFeldname = null;
3570         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3571         if (ergebnissdatenFeldnamenIterator.hasNext())
3572         {
3573             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3574         }
3575         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "Marketingeffekt", "", "2"));
3576         if (!returnvalue)
3577             log.error(" FAILED");
3578 
3579         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_ALLGEMEINFERTIGPRODUKTEGESAMT_KEY);
3580         ergebnissdatenFeldname = null;
3581         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3582         if (ergebnissdatenFeldnamenIterator.hasNext())
3583         {
3584             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3585         }
3586         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "Fertigprodukte gesamt", "", "2"));
3587         if (!returnvalue)
3588             log.error(" FAILED");
3589 
3590         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENINFLATIONSINDEX_KEY);
3591         ergebnissdatenFeldname = null;
3592         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3593         if (ergebnissdatenFeldnamenIterator.hasNext())
3594         {
3595             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3596         }
3597         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "Inflationsindex", "Inflationsindex", "2"));
3598         if (!returnvalue)
3599             log.error(" FAILED");
3600 
3601         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLOHNERHOEHUNGSINDEX_KEY);
3602         ergebnissdatenFeldname = null;
3603         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3604         if (ergebnissdatenFeldnamenIterator.hasNext())
3605         {
3606             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3607         }
3608         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "Lohnerh&ouml;hungsindex", "Lohnerh&ouml;hungsindex", "2"));
3609         if (!returnvalue)
3610             log.error(" FAILED");
3611 
3612         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENREALERMARKETINGAUFWAND_KEY);
3613         ergebnissdatenFeldname = null;
3614         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3615         if (ergebnissdatenFeldnamenIterator.hasNext())
3616         {
3617             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3618         }
3619         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "reale Marketingkosten (in 1000 EUR)", "", "-1000"));
3620         if (!returnvalue)
3621             log.error(" FAILED");
3622 
3623         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENFORSCHUNGUNDENTWICKLUNGREAL_KEY);
3624         ergebnissdatenFeldname = null;
3625         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3626         if (ergebnissdatenFeldnamenIterator.hasNext())
3627         {
3628             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3629         }
3630         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "\' EUR", "Forschung und Entwicklung real (in 1000 EUR", "Forschung und Entwicklung real (in 1000 EUR)", "-1000"));
3631         if (!returnvalue)
3632             log.error(" FAILED");
3633 
3634         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLIZENZERWERBUNTERNEHMEN_KEY);
3635         ergebnissdatenFeldname = null;
3636         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3637         if (ergebnissdatenFeldnamenIterator.hasNext())
3638         {
3639             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3640         }
3641         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "Lizenzerwerb Unternehmen", "", "0"));
3642         if (!returnvalue)
3643             log.error(" FAILED");
3644 
3645         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENLIZENZVERKAUFUNTERNEHMEN_KEY);
3646         ergebnissdatenFeldname = null;
3647         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3648         if (ergebnissdatenFeldnamenIterator.hasNext())
3649         {
3650             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3651         }
3652         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "", "Lizenzverkauf Unternehmen", "", "0"));
3653         if (!returnvalue)
3654             log.error(" FAILED");
3655 
3656         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENFERTIGUNGSZEITGESAMT_KEY);
3657         ergebnissdatenFeldname = null;
3658         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3659         if (ergebnissdatenFeldnamenIterator.hasNext())
3660         {
3661             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3662         }
3663         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "Minuten", "Fertigungszeit gesamt", "Fertigungszeit gesamt", "2"));
3664         if (!returnvalue)
3665             log.error(" FAILED");
3666 
3667         ergebnissdatenFeldnamen = dief.sucheFeldnameBenutzer(projektnummer, Constants.EF_GRUNDDATENROHSTOFFPREIS_KEY);
3668         ergebnissdatenFeldname = null;
3669         ergebnissdatenFeldnamenIterator = ergebnissdatenFeldnamen.iterator();
3670         if (ergebnissdatenFeldnamenIterator.hasNext())
3671         {
3672             ergebnissdatenFeldname = (Ergebnissdaten_Feldnamen) ergebnissdatenFeldnamenIterator.next();
3673         }
3674         returnvalue = diefb.erzeugen(new Ergebnissdaten_Feldbeschreibungen(ergebnissdatenFeldname, sprache, "EUR/Stk.", "Rohstoffpreis", "", "2"));
3675         if (!returnvalue)
3676             log.error(" FAILED");
3677     }
3678 
3679 }