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.calculation.timer;
21  
22  import java.sql.Time;
23  import java.sql.Date;
24  import java.text.SimpleDateFormat;
25  import java.util.ArrayList;
26  import java.util.Collection;
27  import java.util.Iterator;
28  import java.util.Timer;
29  import java.util.TimerTask;
30  
31  import java.io.IOException;
32  import java.util.Properties;
33  
34  import javax.mail.AuthenticationFailedException;
35  import javax.mail.MessagingException;
36  import javax.mail.SendFailedException;
37  import javax.mail.internet.AddressException;
38  
39  import org.apache.commons.logging.Log;
40  import org.apache.commons.logging.LogFactory;
41  import org.apache.struts.util.MessageResources;
42  
43  import org.fhw.cabaweb.calculation.ErstelleIndices;
44  import org.fhw.cabaweb.calculation.Startwerte;
45  import org.fhw.cabaweb.calculation.common.CommonCalculation;
46  import org.fhw.cabaweb.calculation.threads.BerechneBewertung;
47  import org.fhw.cabaweb.calculation.threads.BerechneHauptwerte;
48  import org.fhw.cabaweb.calculation.threads.BerechneVollUndGrenzkosten;
49  import org.fhw.cabaweb.calculation.threads.CheckEntscheidungen;
50  import org.fhw.cabaweb.calculation.threads.Lock;
51  import org.fhw.cabaweb.data.DataInterfaceBerechnungsauftraege;
52  import org.fhw.cabaweb.data.DataInterfaceErgebnissdaten;
53  import org.fhw.cabaweb.data.DataInterfaceErgebnissdatenDouble;
54  import org.fhw.cabaweb.data.DataInterfaceErgebnissdatenInteger;
55  import org.fhw.cabaweb.data.DataInterfaceGruppenmitglieder;
56  import org.fhw.cabaweb.data.DataInterfaceProjekte;
57  import org.fhw.cabaweb.data.DataInterfaceProjektgruppen;
58  import org.fhw.cabaweb.data.constants.Constants;
59  import org.fhw.cabaweb.data.dataobjects.Ergebniss;
60  import org.fhw.cabaweb.ojb.dataobjects.Berechnungsauftraege;
61  import org.fhw.cabaweb.ojb.dataobjects.Gruppenmitglieder;
62  import org.fhw.cabaweb.ojb.dataobjects.Projekte;
63  import org.fhw.cabaweb.ojb.dataobjects.Projektgruppen;
64  import org.fhw.cabaweb.tools.MailUtilities;
65  import org.fhw.cabaweb.tools.StringUtilities;
66  
67  public final class BerechnungsTimer extends TimerTask
68  {
69      /*** Commons Logging Instanz */
70      private static Log log = LogFactory.getLog("org.fhw.cabaweb.calculation.timer.BerechnungsTimer");
71  
72      // PRIVATE ////
73  
74      //expressed in milliseconds
75      private final static long fPERIOD = 300000;
76  
77      /***
78      * Construct and use a TimerTask and Timer.
79      */
80      public static void main(String[] args)
81      {
82          TimerTask berechnungen = new BerechnungsTimer();
83  
84          long delay = System.currentTimeMillis();
85          delay = delay - (delay % 300000) + 300000;
86          Date datum = new Date(delay);
87          delay = System.currentTimeMillis();
88          delay = (delay - (delay % 300000) + 300000) - delay;
89  
90          if (log.isDebugEnabled())
91          {
92              delay = 0;
93          }
94  
95          Timer timer = new Timer();
96  
97          SimpleDateFormat df = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss.S");
98  
99          if (log.isDebugEnabled())
100         {
101             log.debug(" Starte Timer");
102             log.debug(" Pruefe alle " + (fPERIOD / 1000) + " Sekunden");
103             log.debug(" Naechster Start : " + df.format(datum));
104         }
105 
106         timer.scheduleAtFixedRate(berechnungen, delay, fPERIOD);
107     }
108 
109     /***
110     * Implements TimerTask's abstract run method.
111     */
112     public void run()
113     {
114         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
115         DataInterfaceBerechnungsauftraege diba = new DataInterfaceBerechnungsauftraege();
116         boolean rueckgabewert = false;
117 
118         Date now = new Date(System.currentTimeMillis());
119         SimpleDateFormat df = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss.S");
120 
121         if (log.isDebugEnabled())
122         {
123             log.debug(" Starte Timer : " + df.format(now));
124         }
125 
126         Collection berechnungsauftraege = diba.sucheDatumUhrzeit(new Date(System.currentTimeMillis()), new Time(System.currentTimeMillis()));
127         Iterator berechnungsauftragsiterator = berechnungsauftraege.iterator();
128 
129         while (berechnungsauftragsiterator.hasNext())
130         {
131             Berechnungsauftraege berechnungsauftrag = (Berechnungsauftraege) berechnungsauftragsiterator.next();
132             Integer projektnummer = berechnungsauftrag.getProjekte().getProjektnummer();
133             Date datum = berechnungsauftrag.getDatum();
134             Short wiederholung = berechnungsauftrag.getWiederholung();
135             Integer artDerBerechnung = berechnungsauftrag.getArtDerBerechnung();
136 
137             switch (artDerBerechnung.intValue())
138             {
139                 case -99 :
140                     ResetQuartalStart(projektnummer);
141                     break;
142                 case -1 :
143                     ResetQuartal(projektnummer);
144                     break;
145                 case 0 :
146                     log.info(" DO NOTHING : " + projektnummer);
147                     break;
148                 case 1 :
149                     BerechneQuartal(projektnummer);
150                     break;
151             }
152 
153             berechnungsauftrag.setDatum(new Date(datum.getTime() + (86400000 * wiederholung.longValue())));
154 
155             switch (wiederholung.intValue())
156             {
157                 case 0 :
158                     rueckgabewert = diba.loeschen(berechnungsauftrag);
159 
160                     if (rueckgabewert == false)
161                     {
162                         log.error(" Loeschen des Berechnungsauftrags fehlgeschlagen");
163                     }
164                     break;
165                 case 1 :
166                     rueckgabewert = diba.editieren(berechnungsauftrag);
167 
168                     if (rueckgabewert == false)
169                     {
170                         log.error(" Weiterschaltung des Datums auf morgen fehlgeschlagen");
171                     }
172                     break;
173                 case 7 :
174                     rueckgabewert = diba.editieren(berechnungsauftrag);
175 
176                     if (rueckgabewert == false)
177                     {
178                         log.error(" Weiterschaltung des Datums auf naechste Woche fehlgeschlagen");
179                     }
180                     break;
181             }
182         }
183 
184         if (log.isDebugEnabled())
185         {
186             log.debug(" Finished Calculation");
187         }
188     }
189 
190     /***
191      * Berechnet ein Quartal f&uuml;r die &uuml;bergebene Projektnummer
192      *
193      * @param projektnummer Die Projektnummer
194      */
195     public synchronized void BerechneQuartal(Integer projektnummer)
196     {
197         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
198         DataInterfaceProjekte dip = new DataInterfaceProjekte();
199         boolean rueckgabewert = false;
200         Projekte projekt = (Projekte) dip.sucheProjektnummer(projektnummer);
201         Integer quartal = projekt.getAktuellesQuartal();
202 
203         if (log.isDebugEnabled())
204         {
205             log.debug(" Berechne Quartal " + (quartal.intValue() + 1));
206         }
207 
208         if (quartal.intValue() == -1)
209         {
210             Startwerte.StartwerteEintragen(projektnummer);
211         }
212         else
213         {
214             CheckEntscheidungen(projektnummer, new Integer(quartal.intValue() + 1));
215         }
216 
217         ErstelleIndices(projektnummer, new Integer(quartal.intValue() + 1));
218 
219         BerechneWerte(projektnummer, quartal);
220 
221         projekt.setAktuellesQuartal(new Integer(quartal.intValue() + 1));
222 
223         rueckgabewert = dip.editieren(projekt);
224 
225         if (rueckgabewert == false)
226         {
227             SendStatusMail(projektnummer, new Integer(quartal.intValue() + 1), 1, false);
228             log.error(" Weiterschaltung des Quartals fehlgeschlagen");
229         }
230         else
231         {
232             SendStatusMail(projektnummer, new Integer(quartal.intValue() + 1), 1, true);
233         }
234     }
235 
236     /***
237      * Setzt um ein Quartal f&uuml;r die &uuml;bergebene Projektnummer zur&uuml;ck
238      *
239      * @param projektnummer Die Projektnummer
240      */
241     private synchronized void ResetQuartal(Integer projektnummer)
242     {
243         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
244         DataInterfaceProjekte dip = new DataInterfaceProjekte();
245         boolean rueckgabewert = false;
246         Projekte projekt = (Projekte) dip.sucheProjektnummer(projektnummer);
247         Integer quartal = projekt.getAktuellesQuartal();
248 
249         if (log.isDebugEnabled())
250         {
251             log.debug(" Reset Quartal nach " + (quartal.intValue() - 1));
252         }
253 
254         if (quartal.intValue() >= -1)
255         {
256             quartal = new Integer(quartal.intValue() - 1);
257         }
258 
259         projekt.setAktuellesQuartal(quartal);
260 
261         rueckgabewert = dip.editieren(projekt);
262 
263         if (rueckgabewert == false)
264         {
265             SendStatusMail(projektnummer, new Integer(quartal.intValue() + 1), -1, false);
266             log.error(" Reset des Quartals fehlgeschlagen");
267         }
268         else
269         {
270             SendStatusMail(projektnummer, new Integer(quartal.intValue() + 1), -1, true);
271         }
272     }
273 
274     /***
275      * Setzt auf das Quartal -1 f&uuml;r die &uuml;bergebene Projektnummer zur&uuml;ck
276      *
277      * @param projektnummer Die Projektnummer
278      */
279     private synchronized void ResetQuartalStart(Integer projektnummer)
280     {
281         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
282         DataInterfaceProjekte dip = new DataInterfaceProjekte();
283         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
284         DataInterfaceErgebnissdatenDouble died = new DataInterfaceErgebnissdatenDouble();
285         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
286         DataInterfaceErgebnissdatenInteger diei = new DataInterfaceErgebnissdatenInteger();
287         boolean rueckgabewert = false;
288         Projekte projekt = (Projekte) dip.sucheProjektnummer(projektnummer);
289 
290         if (log.isDebugEnabled())
291         {
292             log.debug(" Reset Quartal nach -1");
293         }
294 
295         projekt.setAktuellesQuartal(new Integer(-1));
296 
297         rueckgabewert = dip.editieren(projekt);
298 
299         if (rueckgabewert == false)
300         {
301             log.error(" Reset des Quartals fehlgeschlagen");
302         }
303 
304         if (log.isDebugEnabled())
305         {
306             log.debug(" Loeschen der DOUBLE Ergebnisse");
307         }
308 
309         Collection ergebnisse = died.sucheKombination(projektnummer, null, null);
310         Iterator ergebnisiterator = ergebnisse.iterator();
311 
312         while (ergebnisiterator.hasNext())
313         {
314             rueckgabewert = died.loeschen(ergebnisiterator.next());
315 
316             if (rueckgabewert == false)
317             {
318                 log.error(" Loeschen DOUBLE Ergebnis fehlgeschlagen");
319             }
320         }
321 
322         if (log.isDebugEnabled())
323         {
324             log.debug(" Loeschen der INTEGER Ergebnisse");
325         }
326 
327         ergebnisse = diei.sucheKombination(projektnummer, null, null);
328         ergebnisiterator = ergebnisse.iterator();
329 
330         while (ergebnisiterator.hasNext())
331         {
332             rueckgabewert = diei.loeschen(ergebnisiterator.next());
333 
334             if (rueckgabewert == false)
335             {
336                 log.error(" Loeschen INTEGER Ergebnis fehlgeschlagen");
337             }
338         }
339 
340         Startwerte.StartwerteEintragen(projektnummer);
341 
342         SendStatusMail(projektnummer, new Integer(-1), -99, true);
343     }
344 
345     /***
346      * Checkt die Entscheidungen des Unterenehmens und übernimmt sie im Zweifelsfall aus dem VorQuartal.
347      *
348      * @param projektnummer Die Projektnummer
349      */
350     private synchronized void CheckEntscheidungen(Integer projektnummer, Integer quartal)
351     {
352         if (log.isDebugEnabled())
353         {
354             log.debug(" CheckEntscheidungen");
355         }
356 
357         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
358         DataInterfaceProjektgruppen dipg = new DataInterfaceProjektgruppen();
359 
360         Collection projektgruppen = dipg.sucheProjektnummer(projektnummer);
361         Iterator projektgruppeniterator = projektgruppen.iterator();
362 
363         while (projektgruppeniterator.hasNext())
364         {
365             Projektgruppen projektgruppe = (Projektgruppen) projektgruppeniterator.next();
366 
367             if (projektgruppe.getAktiv().booleanValue() == false || projektgruppe.getGruppenname().compareTo("Default") == 0 || projektgruppe.getGruppenname().compareTo("Projektleiter") == 0 || projektgruppe.getGruppenname().compareTo("Administratorgruppe") == 0)
368                 projektgruppeniterator.remove();
369         }
370 
371         projektgruppeniterator = projektgruppen.iterator();
372 
373         Lock lock = new Lock(projektgruppen.size());
374 
375         while (projektgruppeniterator.hasNext())
376         {
377             Projektgruppen projektgruppe = (Projektgruppen) projektgruppeniterator.next();
378             Integer gruppennummer = projektgruppe.getGruppennummer();
379 
380             CheckEntscheidungen mt = new CheckEntscheidungen(lock, projektnummer, gruppennummer, quartal);
381             mt.setName("P " + projektnummer + " - G " + gruppennummer + " - Q " + quartal);
382             mt.setPriority(3);
383             mt.start();
384         }
385 
386         while (lock.getFinishSemaphore() > 0)
387         {
388             synchronized (lock)
389             {
390                 try
391                 {
392                     Thread.sleep(25);
393 
394                     if (lock.getSemaphore() == projektgruppen.size())
395                     {
396                         lock.notifyAll();
397                     }
398                 }
399                 catch (Exception e)
400                 {
401                     log.error(e.getMessage(), e);
402                 }
403             }
404         }
405     }
406 
407     /***
408      * Berechnet die Werte f&uuml;r das Projekt und das angegebene Quartal
409      *
410      * @param projektnummer Die Projektnummer
411      * @param quartal Das Quartal
412      */
413     private synchronized void BerechneWerte(Integer projektnummer, Integer quartal)
414     {
415         if (log.isDebugEnabled())
416         {
417             log.debug(" BerechneHauptwerte");
418         }
419 
420         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
421         DataInterfaceProjektgruppen dipg = new DataInterfaceProjektgruppen();
422 
423         Collection projektgruppen = dipg.sucheProjektnummer(projektnummer);
424         Iterator projektgruppeniterator = projektgruppen.iterator();
425 
426         while (projektgruppeniterator.hasNext())
427         {
428             Projektgruppen projektgruppe = (Projektgruppen) projektgruppeniterator.next();
429 
430             if (projektgruppe.getAktiv().booleanValue() == false || projektgruppe.getGruppenname().compareTo("Default") == 0 || projektgruppe.getGruppenname().compareTo("Projektleiter") == 0 || projektgruppe.getGruppenname().compareTo("Administratorgruppe") == 0)
431                 projektgruppeniterator.remove();
432         }
433 
434         projektgruppeniterator = projektgruppen.iterator();
435 
436         Lock lock = new Lock(projektgruppen.size());
437 
438         while (projektgruppeniterator.hasNext())
439         {
440             Projektgruppen projektgruppe = (Projektgruppen) projektgruppeniterator.next();
441             Integer gruppennummer = projektgruppe.getGruppennummer();
442 
443             BerechneHauptwerte mt = new BerechneHauptwerte(lock, projektnummer, gruppennummer, quartal);
444             mt.setName("P " + projektnummer + " - G " + gruppennummer + " - Q " + quartal);
445             mt.setPriority(3);
446             mt.start();
447         }
448 
449         while (lock.getFinishSemaphore() > 0)
450         {
451             synchronized (lock)
452             {
453                 try
454                 {
455                     Thread.sleep(25);
456 
457                     if (lock.getSemaphore() == projektgruppen.size())
458                     {
459                         lock.notifyAll();
460                     }
461                 }
462                 catch (Exception e)
463                 {
464                     log.error(e.getMessage(), e);
465                 }
466             }
467         }
468 
469         if (log.isDebugEnabled())
470         {
471             log.debug("BerechneVollUndGrenzkosten");
472         }
473 
474         projektgruppeniterator = projektgruppen.iterator();
475         lock.setFinishSemaphore(projektgruppen.size());
476 
477         while (projektgruppeniterator.hasNext())
478         {
479             Projektgruppen projektgruppe = (Projektgruppen) projektgruppeniterator.next();
480             Integer gruppennummer = projektgruppe.getGruppennummer();
481 
482             BerechneVollUndGrenzkosten mt = new BerechneVollUndGrenzkosten(lock, projektnummer, gruppennummer, quartal);
483             mt.setName("P " + projektnummer + " - G " + gruppennummer + " - Q " + quartal);
484             mt.setPriority(3);
485             mt.start();
486         }
487 
488         while (lock.getFinishSemaphore() > 0)
489         {
490             synchronized (lock)
491             {
492                 try
493                 {
494 
495                     Thread.sleep(25);
496 
497                     if (lock.getSemaphore() == projektgruppen.size())
498                     {
499                         lock.notifyAll();
500                     }
501                 }
502                 catch (Exception e)
503                 {
504                     log.error(e.getMessage(), e);
505                 }
506             }
507         }
508 
509         if (log.isDebugEnabled())
510         {
511             log.debug("BerechneBewertung");
512         }
513 
514         projektgruppeniterator = projektgruppen.iterator();
515         lock.setFinishSemaphore(projektgruppen.size());
516 
517         while (projektgruppeniterator.hasNext())
518         {
519             Projektgruppen projektgruppe = (Projektgruppen) projektgruppeniterator.next();
520             Integer gruppennummer = projektgruppe.getGruppennummer();
521 
522             BerechneBewertung mt = new BerechneBewertung(lock, projektnummer, gruppennummer, quartal);
523             mt.setName("P " + projektnummer + " - G " + gruppennummer + " - Q " + quartal);
524             mt.setPriority(3);
525             mt.start();
526         }
527 
528         while (lock.getFinishSemaphore() > 0)
529         {
530             synchronized (lock)
531             {
532                 try
533                 {
534 
535                     Thread.sleep(25);
536 
537                     if (lock.getSemaphore() == projektgruppen.size())
538                     {
539                         lock.notifyAll();
540                     }
541                 }
542                 catch (Exception e)
543                 {
544                     log.error(e.getMessage(), e);
545                 }
546             }
547         }
548     }
549 
550     /***
551      * Berechnet die Indices f&uuml;r das Projekt und das angegebene Quartal
552      *
553      * @param projektnummer Die Projektnummer
554      * @param quartal Das Quartal
555      */
556     private synchronized void ErstelleIndices(Integer projektnummer, Integer quartal)
557     {
558         if (log.isDebugEnabled())
559         {
560             log.debug("ErstelleIndices");
561         }
562 
563         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
564         DataInterfaceProjektgruppen dipg = new DataInterfaceProjektgruppen();
565         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
566         DataInterfaceErgebnissdaten die = new DataInterfaceErgebnissdaten();
567 
568         Collection projektgruppen = dipg.sucheProjektnummer(projektnummer);
569         Iterator projektgruppeniterator = projektgruppen.iterator();
570 
571         Double inflation = new Double(0.0);
572         Double inflationVorhersage = new Double(0.0);
573         Double lohnerhoehung = new Double(0.0);
574         Double lohnerhoehungVorhersage = new Double(0.0);
575         Double saison = new Double(0.0);
576         Double saisonVorhersage = new Double(0.0);
577         Double konjunktur = new Double(0.0);
578         Double konjunkturVorhersage = new Double(0.0);
579 
580         while (projektgruppeniterator.hasNext())
581         {
582             Projektgruppen projektgruppe = (Projektgruppen) projektgruppeniterator.next();
583 
584             if (projektgruppe.getAktiv().booleanValue() == false || projektgruppe.getGruppenname().compareTo("Default") == 0 || projektgruppe.getGruppenname().compareTo("Projektleiter") == 0 || projektgruppe.getGruppenname().compareTo("Administratorgruppe") == 0)
585                 projektgruppeniterator.remove();
586         }
587 
588         projektgruppeniterator = projektgruppen.iterator();
589 
590         if (projektgruppeniterator.hasNext())
591         {
592             Projektgruppen projektgruppe = (Projektgruppen) projektgruppeniterator.next();
593             Integer gruppennummer = projektgruppe.getGruppennummer();
594 
595             inflation = ErstelleIndices.Inflation(projektnummer, gruppennummer, quartal);
596             inflationVorhersage = ErstelleIndices.InflationVorhersage(projektnummer, gruppennummer, quartal);
597             lohnerhoehung = ErstelleIndices.Lohnerhoehung(projektnummer, gruppennummer, quartal);
598             lohnerhoehungVorhersage = ErstelleIndices.LohnerhoehungVorhersage(projektnummer, gruppennummer, quartal);
599             saison = ErstelleIndices.Saison(projektnummer, gruppennummer, quartal);
600             saisonVorhersage = ErstelleIndices.SaisonVorhersage(projektnummer, gruppennummer, quartal);
601             konjunktur = ErstelleIndices.Konjunktur(projektnummer, gruppennummer, quartal);
602             konjunkturVorhersage = ErstelleIndices.KonjunkturVorhersage(projektnummer, gruppennummer, quartal);
603         }
604 
605         projektgruppeniterator = projektgruppen.iterator();
606 
607         while (projektgruppeniterator.hasNext())
608         {
609             Projektgruppen projektgruppe = (Projektgruppen) projektgruppeniterator.next();
610             Integer gruppennummer = projektgruppe.getGruppennummer();
611 
612             ArrayList aktuellesQuartal = (ArrayList) die.sucheQuartal(projektnummer, gruppennummer, quartal);
613             Ergebniss ergebnis = null;
614 
615             //          Tab. 20 (11)
616             /* Setze Inflationsrate */
617             ergebnis = CommonCalculation.SucheErgebnissFeldname(aktuellesQuartal, Constants.EF_GRUNDDATENINFLATIONSRATE_KEY);
618             ergebnis.setObjectWert(inflation);
619             CommonCalculation.WertEintragen(ergebnis, gruppennummer, quartal);
620 
621             //          Tab. 20 (11V)
622             /* Setze Vorhersage Inflationsrate */
623             ergebnis = CommonCalculation.SucheErgebnissFeldname(aktuellesQuartal, Constants.EF_GRUNDDATENINFLATIONSRATEVORHERSAGE_KEY);
624             ergebnis.setObjectWert(inflationVorhersage);
625             CommonCalculation.WertEintragen(ergebnis, gruppennummer, quartal);
626 
627             //          Tab. 20 (12)
628             /* Setze Lohnerhoehungsrate */
629             ergebnis = CommonCalculation.SucheErgebnissFeldname(aktuellesQuartal, Constants.EF_GRUNDDATENLOHNERHOEHUNG_KEY);
630             ergebnis.setObjectWert(lohnerhoehung);
631             CommonCalculation.WertEintragen(ergebnis, gruppennummer, quartal);
632 
633             //          Tab. 20 (12V)
634             /* Setze Vorhersage Lohnerhoehung */
635             ergebnis = CommonCalculation.SucheErgebnissFeldname(aktuellesQuartal, Constants.EF_GRUNDDATENLOHNERHOEHUNGVORHERSAGE_KEY);
636             ergebnis.setObjectWert(lohnerhoehungVorhersage);
637             CommonCalculation.WertEintragen(ergebnis, gruppennummer, quartal);
638 
639             //          Tab. 20 (13)
640             /* Setze Saisonindex */
641             ergebnis = CommonCalculation.SucheErgebnissFeldname(aktuellesQuartal, Constants.EF_GRUNDDATENSAISONINDEX_KEY);
642             ergebnis.setObjectWert(saison);
643             CommonCalculation.WertEintragen(ergebnis, gruppennummer, quartal);
644 
645             //          Tab. 20 (13V)
646             /* Setze Vorhersage Saisonindex */
647             ergebnis = CommonCalculation.SucheErgebnissFeldname(aktuellesQuartal, Constants.EF_GRUNDDATENSAISONINDEXVORHERSAGE_KEY);
648             ergebnis.setObjectWert(saisonVorhersage);
649             CommonCalculation.WertEintragen(ergebnis, gruppennummer, quartal);
650 
651             //          Tab. 20 (14)
652             /* Setze Konjunkturindex */
653             ergebnis = CommonCalculation.SucheErgebnissFeldname(aktuellesQuartal, Constants.EF_GRUNDDATENKONJUNKTURINDEX_KEY);
654             ergebnis.setObjectWert(konjunktur);
655             CommonCalculation.WertEintragen(ergebnis, gruppennummer, quartal);
656 
657             //          Tab. 20 (14V)
658             /* Setze Vorhersage Konjunkturindex */
659             ergebnis = CommonCalculation.SucheErgebnissFeldname(aktuellesQuartal, Constants.EF_GRUNDDATENKONJUNKURINDEXVORHERSAGE_KEY);
660             ergebnis.setObjectWert(konjunkturVorhersage);
661             CommonCalculation.WertEintragen(ergebnis, gruppennummer, quartal);
662         }
663     }
664 
665     /***
666      * Verschickt eMails mit Information über die erfolgte Berechnung.
667      *
668      * @param projektnummer Die Projektnummer
669      * @param quartal Das Quartal
670      * @param artDerBerechnung Die Art der Berechnung (-99, -1, 0, 1)
671      * @param success War der Vorgang erfolgreich (true/false)
672      */
673     private synchronized void SendStatusMail(Integer projektnummer, Integer quartal, int artDerBerechnung, boolean success)
674     {
675         if (log.isDebugEnabled())
676         {
677             log.debug("Email");
678         }
679         
680         Properties properties = StringUtilities.getPropertiesFromFile("cabaweb.properties");
681 
682         String smtphost = properties.getProperty("SMTPHost");
683         String smtpport = properties.getProperty("SMTPPort");
684         String smtpuser = properties.getProperty("SMTPUser");
685         String smtppassword = properties.getProperty("SMTPPassword");
686         String absenderadresse = properties.getProperty("AbsenderAdresse");
687         String absoluteURL = properties.getProperty("AbsoluteURL");
688 
689         /*** Data Interface (indirekter Zugriff auf die OJB Ebene) initialisieren */
690         DataInterfaceGruppenmitglieder dig = new DataInterfaceGruppenmitglieder();
691 
692         Collection gruppenmitglieder = dig.sucheProjektnummer(projektnummer);
693         Iterator gruppenmitgliederiterator = gruppenmitglieder.iterator();
694 
695         while (gruppenmitgliederiterator.hasNext())
696         {
697             Gruppenmitglieder gruppenmitglied = (Gruppenmitglieder) gruppenmitgliederiterator.next();
698 
699             if (gruppenmitglied.getAktiv().booleanValue() == false || gruppenmitglied.getProjektgruppe().getAktiv().booleanValue() == false || gruppenmitglied.getProjektgruppe().getProjekte().getAktiv().booleanValue() == false || gruppenmitglied.getProjektgruppe().getGruppenname().compareTo("Default") == 0)
700                 gruppenmitgliederiterator.remove();
701         }
702 
703         gruppenmitgliederiterator = gruppenmitglieder.iterator();
704 
705         MessageResources grpmessages = MessageResources.getMessageResources("org.fhw.cabaweb.webfrontend.resources.CalculationResources");
706 
707         String subject = null;
708         String mailbody = null;
709         String successString = null;
710 
711         while (gruppenmitgliederiterator.hasNext())
712         {
713             Gruppenmitglieder gruppenmitglied = (Gruppenmitglieder) gruppenmitgliederiterator.next();
714 
715             try
716             {
717                 if (success)
718                     successString = grpmessages.getMessage("description.successful");
719                 else
720                     successString = grpmessages.getMessage("description.failure");
721 
722                 switch (artDerBerechnung)
723                 {
724                     case -99 :
725                         subject = grpmessages.getMessage("message.de.emailsubject.reset", gruppenmitglied.getProjektgruppe().getProjekte().getProjektname(), quartal, successString);
726                         mailbody = grpmessages.getMessage("message.de.emailtext.reset", gruppenmitglied.getProjektgruppe().getProjekte().getProjektname(), quartal, successString) + "\n\n";
727                         mailbody += "\n-----------------------------------------------------------------\n";
728                         mailbody += grpmessages.getMessage("message.en.emailtext.reset", gruppenmitglied.getProjektgruppe().getProjekte().getProjektname(), quartal, successString) + "\n\n";
729                         MailUtilities.sendMail(smtphost, smtpport, smtpuser, smtppassword, absenderadresse, gruppenmitglied.getMitgliedsemailadresse(), null, subject, mailbody);
730                         break;
731                     case -1 :
732                         subject = grpmessages.getMessage("message.de.emailsubject.reset", gruppenmitglied.getProjektgruppe().getProjekte().getProjektname(), quartal, successString);
733                         mailbody = grpmessages.getMessage("message.de.emailtext.reset", gruppenmitglied.getProjektgruppe().getProjekte().getProjektname(), quartal, successString) + "\n\n";
734                         mailbody += "\n-----------------------------------------------------------------\n";
735                         mailbody += grpmessages.getMessage("message.en.emailtext.reset", gruppenmitglied.getProjektgruppe().getProjekte().getProjektname(), quartal, successString) + "\n\n";
736                         MailUtilities.sendMail(smtphost, smtpport, smtpuser, smtppassword, absenderadresse, gruppenmitglied.getMitgliedsemailadresse(), null, subject, mailbody);
737                         break;
738                     case 0 :
739                         subject = "";
740                         break;
741                     case 1 :
742                         subject = grpmessages.getMessage("message.de.emailsubject.calc", gruppenmitglied.getProjektgruppe().getProjekte().getProjektname(), quartal, successString);
743                         mailbody = grpmessages.getMessage("message.de.emailtext.calc", gruppenmitglied.getProjektgruppe().getProjekte().getProjektname(), quartal, successString, absoluteURL) + "\n\n";
744                         mailbody += "\n-----------------------------------------------------------------\n";
745                         mailbody += grpmessages.getMessage("message.en.emailtext.calc", gruppenmitglied.getProjektgruppe().getProjekte().getProjektname(), quartal, successString, absoluteURL) + "\n\n";
746                         MailUtilities.sendMail(smtphost, smtpport, smtpuser, smtppassword, absenderadresse, gruppenmitglied.getMitgliedsemailadresse(), null, subject, mailbody);
747                         break;
748                 }
749             }
750             catch (IOException ex)
751             {
752                 log.error(MailUtilities.SendErrorMailToAdmin("IOException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex.getLocalizedMessage()));
753                 log.error(" IOException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex);
754             }
755             catch (AuthenticationFailedException ex)
756             {
757                 log.error(MailUtilities.SendErrorMailToAdmin("AuthenticationFailedException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex.getLocalizedMessage()));
758                 log.error(" AuthenticationFailedException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex);
759             }
760             catch (SendFailedException ex)
761             {
762                 log.error(MailUtilities.SendErrorMailToAdmin("SendFailedException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex.getLocalizedMessage()));
763                 log.error(" SendFailedException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex);
764             }
765             catch (AddressException ex)
766             {
767                 log.error(MailUtilities.SendErrorMailToAdmin("AddressException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex.getLocalizedMessage()));
768                 log.error(" AddressException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex);
769             }
770             catch (MessagingException ex)
771             {
772                 log.error(MailUtilities.SendErrorMailToAdmin("MessagingException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex.getLocalizedMessage()));
773                 log.error(" MessagingException - Failure sending mail to " + gruppenmitglied.getMitgliedsemailadresse(), ex);
774             }
775         }
776     }
777 }