/*** elektra.CardOrder  **********************************************************

$Header: $

     In dieser Klasse werden alle Daten fuer
     einen Kartenauftrag verpackt.

     (c) ORESTES Lizenzvertreibsges. mbH 2009 - 2010

     Karsten Rolfs


     Warenkorb
      |- CardOrder
           |- CardOrderBookTicket
           |- CardOrderPG
                 |- CardOrderPGTicket
*****************************************************************************/

package elektra;

import java.util.Locale;
import java.util.Date;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.text.DateFormatSymbols;
import java.util.Vector;
import java.util.List;

public class CardOrder implements Types
{
  private int cardPosType;
  private int cardOrderType;
  private String cardPosStatus;
  private String cardEventName;
  private String cardEventNumber;
  private String location;
  private String locationZIP;
  private String locationCity;
  private String locationStreet;
  private String cardShowDate;
  private Date   showDate;
  private String cardShowWeekday;
  private String cardShowTime;
  private String cardShowNumber;
  private String cardBlock;
  private String cardBlockNumber;
  private String cardStand;                         // Tribuene
  private int    cardOrderTickets;                  // Anzahl Karten gesamt, beim direkten Buchen nicht noetig
  private double orderInsuranceCharges;
  private String orderComeFrom;
  
  // fuer direktes Buchen
  private String ordertixEbene;
  private String ordertixSeite;
  
  private int ordertixPriceGroupCount;
  private Vector<CardOrderPG> ordertixPG;
  private String ordertixPriceStr;
  private double ordertixPrice;
  private String ordertixZusammen;
  
  // fuer vorgeschlagene Tickets
  private int cardBookTickets;             // Anzahl Karten gesamt
  private Vector<CardOrderBookTicket> booktix;

  private Vector<CardOrderCharge> cardPosCharge;
  private Vector<CardOrderCharge> cardCardCharge;
  private boolean cardAutoCharges;
  private boolean cardPrintAtHome;
  /** ist bei dieser Vorstellung eine Abendkasse vorhanden? */
  private boolean abendkasse;

  private String  cardInfos;

  public final int CARDORDER_UNDEF   = 0;
  /**
   * Direkte Buchung nach Anzahl Plaetze je Preisgruppe und Ermaessigung
   */
  public final int CARDORDER_ORDER_PER_PG       = 1;
  /**
   * Buchung per Platzindex
   */
  public final int CARDORDER_BOOK_PER_INDEX    = 2;

  public CardOrder()
  {
    cardOrderType = CARDORDER_UNDEF;
    setCardPosType(ORDERTYPE_SHOWORDER);
    setCardPosStatus("XX");
    setCardEventName("0");
    setCardEventNumber("");
    setCardLocation("");
    setCardLocationZIP("");
    setCardLocationCity("");
    setCardLocationStreet("");
    setCardShowDate("0");
    setCardShowTime("0");
    setCardShowNumber("0");
    setCardBlock("0");
    setCardBlockNumber("0");
    setCardStand("");

    setOrderInsuranceCharges("0");    
    setOrderComeFrom("");    
   
    setOrdertixLevel("0");
    setOrdertixSide("0");
    setOrderTicketCount("0");
    setOrdertixPriceGroupCount("0");
    setOrdertixPrice("0");
    setOrdertixZusammen("0");

    setBookTicketCount("0");
    
    setCardAutoCharges("0");
    setCardPrintAtHome("0");
  }
  
  /**
   * Konstruktor fuer das Buchen per Preisgruppe und Ermaessigung
   */
  public CardOrder(String strEventName, String strEventNo, 
              String strLocation, String strLocationZIP, String strLocationCity, String strLocationStreet,
              String strShowDate, String strShowTime, String strShowNo, String strBlock, String strBlockNo, 
              String strEbene, String strSeite, String strOrderTicketCount, String PGCount, String strPrice, 
              String strZusammen, String strAutoGeb, String strPrintAtHome, String strInsuranceCharge)
  {
    cardOrderType = CARDORDER_ORDER_PER_PG;
    setCardPosType(ORDERTYPE_SHOWORDER);
    setCardPosStatus("XX");
    setCardEventName(strEventName);
    setCardEventNumber(strEventNo);
    setCardLocation(strLocation);
    setCardLocationZIP(strLocationZIP);
    setCardLocationCity(strLocationCity);
    setCardLocationStreet(strLocationStreet);
    setCardShowDate(strShowDate);
    setCardShowTime(strShowTime);
    setCardShowNumber(strShowNo);
    setCardBlock(strBlock);
    setCardBlockNumber(strBlockNo);
    setCardStand("");

    setOrdertixLevel(strEbene);
    setOrdertixSide(strSeite);
    setOrderTicketCount(strOrderTicketCount);
    setOrdertixPriceGroupCount(PGCount);
    setOrdertixPrice(strPrice);
    setOrdertixZusammen(strZusammen);
    
    setBookTicketCount("0");
    
    setOrderInsuranceCharges(strInsuranceCharge);    
    setOrderComeFrom("");    
    
    setCardAutoCharges(strAutoGeb);
    setCardPrintAtHome(strPrintAtHome);
  }
  /**
   * Konstruktor fuer das Buchen per Preisgruppe und Ermaessigung
   */
  public CardOrder(String strEventName, String strEventNo,
              String strLocation, String strLocationZIP, String strLocationCity, String strLocationStreet,
              String strShowDate, String strShowTime, String strShowNo, String strBlock, String strBlockNo, String strTribuene,
              String strEbene, String strSeite, String strOrderTicketCount, String PGCount, String strPrice,
              String strZusammen, String strAutoGeb, String strPrintAtHome, String strInsuranceCharge)
  {
    cardOrderType = CARDORDER_ORDER_PER_PG;
    setCardPosType(ORDERTYPE_SHOWORDER);
    setCardPosStatus("XX");
    setCardEventName(strEventName);
    setCardEventNumber(strEventNo);
    setCardLocation(strLocation);
    setCardLocationZIP(strLocationZIP);
    setCardLocationCity(strLocationCity);
    setCardLocationStreet(strLocationStreet);
    setCardShowDate(strShowDate);
    setCardShowTime(strShowTime);
    setCardShowNumber(strShowNo);
    setCardBlock(strBlock);
    setCardBlockNumber(strBlockNo);
    setCardStand(strTribuene);

    setOrdertixLevel(strEbene);
    setOrdertixSide(strSeite);
    setOrderTicketCount(strOrderTicketCount);
    setOrdertixPriceGroupCount(PGCount);
    setOrdertixPrice(strPrice);
    setOrdertixZusammen(strZusammen);

    setBookTicketCount("0");

    setOrderInsuranceCharges(strInsuranceCharge);
    setOrderComeFrom("");

    setCardAutoCharges(strAutoGeb);
    setCardPrintAtHome(strPrintAtHome);
  }
  
  /**
   * Konstruktor fuer Karten mit Indexen (nach Vorschlag)
   */
  public CardOrder(String strEventName, String strEventNo, 
              String strLocation, String strLocationZIP, String strLocationCity, String strLocationStreet,
              String strShowDate, String strShowTime, String strShowNo, String strBlock, String strBlockNo, 
              String strBookTickets, String strAutoGeb, String strPrintAtHome, String strInsuranceCharge, String strComeFrom)
  {
    cardOrderType = CARDORDER_BOOK_PER_INDEX;
    setCardPosType(ORDERTYPE_SHOWORDER);
    setCardPosStatus("XX");
    setCardEventName(strEventName);
    setCardEventNumber(strEventNo);
    setCardLocation(strLocation);
    setCardLocationZIP(strLocationZIP);
    setCardLocationCity(strLocationCity);
    setCardLocationStreet(strLocationStreet);
    setCardShowDate(strShowDate);
    setCardShowTime(strShowTime);
    setCardShowNumber(strShowNo);
    setCardBlock(strBlock);
    setCardBlockNumber(strBlockNo);
    setCardStand("");
    
    setOrdertixLevel("");
    setOrdertixSide("");
    setOrderTicketCount("0");
    setOrdertixPriceGroupCount("0");
    setOrdertixPrice("0");
    setOrdertixZusammen("0");
    
    setBookTicketCount(strBookTickets);
    
    setOrderInsuranceCharges(strInsuranceCharge);    
    setOrderComeFrom(strComeFrom);    
    
    setCardAutoCharges(strAutoGeb);
    setCardPrintAtHome(strPrintAtHome);
  }
/**
   * Konstruktor fuer Karten mit Indexen (nach Vorschlag)
   */
  public CardOrder(String strEventName, String strEventNo,
              String strLocation, String strLocationZIP, String strLocationCity, String strLocationStreet,
              String strShowDate, String strShowTime, String strShowNo, String strBlock, String strBlockNo, String strTribuene,
              String strBookTickets, String strAutoGeb, String strPrintAtHome, String strInsuranceCharge, String strComeFrom)
  {
    cardOrderType = CARDORDER_BOOK_PER_INDEX;
    setCardPosType(ORDERTYPE_SHOWORDER);
    setCardPosStatus("XX");
    setCardEventName(strEventName);
    setCardEventNumber(strEventNo);
    setCardLocation(strLocation);
    setCardLocationZIP(strLocationZIP);
    setCardLocationCity(strLocationCity);
    setCardLocationStreet(strLocationStreet);
    setCardShowDate(strShowDate);
    setCardShowTime(strShowTime);
    setCardShowNumber(strShowNo);
    setCardBlock(strBlock);
    setCardBlockNumber(strBlockNo);
    setCardStand(strTribuene);

    setOrdertixLevel("");
    setOrdertixSide("");
    setOrderTicketCount("0");
    setOrdertixPriceGroupCount("0");
    setOrdertixPrice("0");
    setOrdertixZusammen("0");

    setBookTicketCount(strBookTickets);

    setOrderInsuranceCharges(strInsuranceCharge);
    setOrderComeFrom(strComeFrom);

    setCardAutoCharges(strAutoGeb);
    setCardPrintAtHome(strPrintAtHome);
  }

  /**
   * Testet, ob alle notwendigen Felder sinnvoll gefuellt sind
   */
  public boolean IsOK()
  {
    if (cardOrderType == CARDORDER_ORDER_PER_PG)
    {
      for (int nAktOrder = 0; nAktOrder < this.ordertixPG.size(); nAktOrder++)
        if (! this.ordertixPG.get(nAktOrder).IsOK())
          return false;
    }
    else
    {
      if (cardBookTickets != booktix.size())
        return false;
      
      for (int nAktBook = 0; nAktBook < this.cardBookTickets; nAktBook++)
        if (! this.booktix.get(nAktBook).IsOK())
          return false;
    }
    return true;
  }
  
  public void setCardOrderTypeOrder()
  {
    cardOrderType = CARDORDER_ORDER_PER_PG;
  }
  public void setCardOrderTypeBook()
  {
    cardOrderType = CARDORDER_BOOK_PER_INDEX;
  }

  public void setCardPosType(int a)
  {
    this.cardPosType =  a;
  }
  
  public void setCardPosStatus(String a)
  {
    this.cardPosStatus = a;
  }
  
  public void setCardEventName(String a)
  {
    this.cardEventName = a;
  }
  
  public void setCardEventNumber(String a)
  {
    this.cardEventNumber = a;
  }
  
  public void setCardLocation(String a)
  {
    this.location = a;
  }
  
  public void setCardLocationZIP(String a)
  {
    this.locationZIP = a;
  }
  
  public void setCardLocationCity(String a)
  {
    this.locationCity = a;
  }
  
  public void setCardLocationStreet(String a)
  {
    this.locationStreet = a;
  }
  
  public void setCardShowDate(String a)
  {
    this.cardShowDate = a;
    String strDate = getCardShowDate();
    SimpleDateFormat sdf = new SimpleDateFormat( "dd.MM.yyyy" );
    try {
      this.showDate = sdf.parse(strDate);
    } catch (ParseException e) {
       System.out.println("Invalid Date Parser Exception ");
       e.printStackTrace();
    }

  }
  public void setShowDate(Date showDate)
  {
    this.showDate = showDate;
  }
  
  public void setCardShowTime(String a)
  {
    this.cardShowTime = a;
  }
  
  public void setCardShowNumber(String a)
  {
    this.cardShowNumber = a;
  }
  
  public void setCardBlock(String a)
  {
    this.cardBlock = a;
  }
  
  public void setCardBlockNumber(String a)
  {
    this.cardBlockNumber = a;
  }

  public void setCardStand(String a)
  {
    this.cardStand = a;
  }

  /**
   * Sezen der Versicherung (Positionsgebuehr) fuer eine Kartenauftrag
   * 
   * 
   * 
   * @param Gebuehrenpreis als String
  */
  public void setOrderInsuranceCharges(String a)
  {    
    NumberFormat nf = NumberFormat.getInstance();
    try {
        this.orderInsuranceCharges = nf.parse(a).doubleValue();
      }
      catch (NumberFormatException ex)
      { this.orderInsuranceCharges = 0.0; }
      catch (ParseException ex)
      { this.orderInsuranceCharges = 0.0; }
  }
  
  public void setOrderInsuranceCharges(double a)
  {
    this.orderInsuranceCharges = a;        
  }  

  public void setOrderComeFrom(String a)
  {    
     this.orderComeFrom = a;  
  }
  
  //*************************************** nun fuer direktes Buchen
  /**
   * Setzt beim direkten Buchen die zu buchenden ordertixEbene
   * 
   * 
   * 
   * @param a
   */
  public void setOrdertixLevel(String a)
  {
    this.ordertixEbene = a;
  }
  
  /**
   * Setzt beim direkten Buchen die zu buchenden ordertixSeite
   * 
   * 
   * 
   * @param a
   */
  public void setOrdertixSide(String a)
  {
    this.ordertixSeite = a;
  }
  /**
   * Setzt beim direkten Buchen die Anzahl der betroffenen Preisgruppen
   * @param a
   */
  public void setOrdertixPriceGroupCount(String a)
  {
    try {
      this.ordertixPriceGroupCount = new Integer(a).intValue();
    }
    catch (Exception ex)
    {
      this.ordertixPriceGroupCount = 1;
    }
    ordertixPG = new Vector<CardOrderPG>();
    for (int i = 0; i < ordertixPriceGroupCount; i++)
    {
      ordertixPG.add(new CardOrderPG());
      setOrdertixReductionCount("2", i);
    }
  }
  
  /**
   * Setzt beim direkten Buchen den Preisgruppeindex
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   */
  public void setOrdertixPriceGroup(String a, int nPG)
  {
    ordertixPG.get(nPG).setPriceGroup( a );
  }
  
  /**
   * Setzt beim direkten Buchen den Preisgruppennamen
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   */
  public void setOrdertixPriceGroupName(String a, int nPG)
  {
    ordertixPG.get(nPG).setPriceGroupName( a );
  }
  
  /**
   * Setzt beim direkten Buchen die Farbe der Preisgruppe
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   */
  public void setOrdertixPriceGroupColor(String a, int nPG)
  {
    ordertixPG.get(nPG).setPriceGroupColor( a );
  }
  
  /**
   * Setzt beim direkten Buchen die zu buchenden ordertixEbene
   * 
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   */
  public void setOrdertixLevel(String a, int nPG)
  {
    ordertixPG.get(nPG).setLevel( a );
  }
  
  /**
   * Setzt beim direkten Buchen die zu buchenden ordertixSeite
   * 
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   */
  public void setOrdertixSide(String a, int nPG)
  {
    ordertixPG.get(nPG).setSide( a );
  }

  /**
   * Setzt beim direkten Buchen die Anzahl der in dieser Preisgruppe noetigen Ermaessigung
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   */
  public void setOrdertixReductionCount(String a, int nPG)
  {
    try {
      ordertixPG.get(nPG).setReductionCount( a );
    } catch (Exception ex)
    {
      ex.printStackTrace();
    }
  }
  
  /**
   * Setzt beim direkten Buchen die Ermaessigung in dieser Preisgruppe
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   * @param nRed; x.te zu buchende Ermaessigung
   */
  public void setOrdertixReduction(String a, int nPG, int nRed)
  {
    ordertixPG.get(nPG).setReduction( a, nRed );
  }
  
  /**
   * Setzt beim direkten Buchen den Ermaessigungsnamen in dieser Preisgruppe
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   * @param nRed; x.te zu buchende Ermaessigung
   */
  public void setOrdertixReductionName(String a, int nPG, int nRed)
  {
    ordertixPG.get(nPG).setReductionName( a, nRed );
  }
  
  /**
   * Setzt beim direkten Buchen den Preis fuer diese Ermaessigung in dieser Preisgruppe
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   * @param nRed; x.te zu buchende Ermaessigung
   */
  public void setOrdertixReductionPrice(String a, int nPG, int nRed)
  {
    ordertixPG.get(nPG).setReductionPrice( a, nRed );
  }
  
  /**
   * Setzt beim direkten Buchen die Anzahl der zu buchenden Plaetzen in dieser Preisgruppe und Ermaessigung
   * @param a
   * @param nPG: x.te zu buchende Preisgruppe
   * @param nRed; x.te zu buchende Ermaessigung
   */
  public void setOrdertixTicketCount(String a, int nPG, int nRed)
  {
    ordertixPG.get(nPG).setTicketCount(a, nRed );
  }
  
  public void setOrdertixZusammen(String a)
  {
    this.ordertixZusammen = a;
  }

  /**
   * Setzt den Gesamtpreis sowohl als String als auch konvertiert als double
   */
  public void setOrdertixPrice(String a)
  {
    if (null == a)
      ordertixPrice = 0.0;
    else
    {
      try 
      {
        Double temp = new Double(a);
        ordertixPrice = temp.doubleValue();
      } 
      catch (NumberFormatException ex)
      { ordertixPrice = 0.0; }
    }
    this.ordertixPriceStr = a;
  }
  
  public void setOrderTicketCount(String a)
  {
    try {
      this.cardOrderTickets = new Integer(a).intValue();
    }
    catch (Exception ex)
    {
      this.cardOrderTickets = 0;
    }
  }
  
  //********************************* nun fuer vorgeschlagene Tickets
  
  /**
   * erzeugt n leere Tickets um Daten aus Vorschlag oder Saalplanbuchung eintragen zu koennen
   */ 
  public void setBookTicketCount(String a)
  {
    try {
      cardBookTickets = new Integer(a).intValue();
    }
    catch (Exception ex)
    {
      cardBookTickets = 0;
    }
    booktix = new Vector<CardOrderBookTicket>();
    for (int i = 0; i < cardBookTickets; i++)
      booktix.add(new CardOrderBookTicket());
  }

  /**
   * fuellt das Ticket mit den Daten (aus Vorschlag oder Saalplanbuchung)
   * 
   * @param nTix: x.te Karte in der Liste
   * @param strIndex: Sitzindex im Saalplan
   * @param strRed: Ermaessigungsindex
   */
  public void setTicket(int nTix, String strIndex, String strRed)
  {
    booktix.elementAt(nTix).setTicket(strIndex, strRed );
  }
  
  /**
   * fuellt das Ticket mit den Daten (aus Vorschlag oder Saalplanbuchung)
   * 
   * @param nTix: x.te Karte in der Liste
   * @param index: Sitzindex im Saalplan
   * @param nRed: Ermaessigungsindex
   */
  public void setTicket(int nTix, Integer nIndex, Integer nRed)
  {
    booktix.elementAt(nTix).setTicket(nIndex, nRed );
  }
  
  /**
   * fuellt das Ticket mit den Daten (aus Vorschlag oder Saalplanbuchung)
   * 
   * @param nTix: x.te Karte in der Liste
   * @param index: Sitzindex im Saalplan
   * @param nRed: Ermaessigungsindex
   * @param strAttribute zusaetzliches Felder
   */
  public void setTicket(int nTix, Integer nIndex, Integer nRed, String strAttribute)
  {
    booktix.elementAt(nTix).setTicket(nIndex, nRed, strAttribute );
  }
  
  /**
   * fuellt das Ticket mit den Daten (aus Vorschlag oder Saalplanbuchung)
   * 
   * @param nTix: x.te Karte in der Liste
   * @param index: Sitzindex im Saalplan
   * @param nRed: Ermaessigungsindex
   * @param strAttribute zusaetzliches Felder
   * @param dtBlockedDate blockiert per Undertaker bis zu diesem Termin
   * @param strPrice Preis der Karte
   */
  public void setTicket(int nTix, Integer nIndex, Integer nRed, String strAttribute, Date dtBlockedDate, String strPrice)
  {
    orderInsuranceCharges = addInsurance(InsuranceStringToDouble(strPrice)) + orderInsuranceCharges;
    booktix.elementAt(nTix).setTicket(nIndex, nRed, strAttribute, dtBlockedDate, strPrice );
  }
  
  /**
   * fuellt das Ticket mit den Daten (aus Vorschlag oder Saalplanbuchung)
   * 
   * @param nTix: x.te Karte in der Liste
   * @param strIndex: Sitzindex im Saalplan
   * @param strRed: Ermaessigungsindex
   * @param strAttribute zusaetzliches Felder
   * @param dtBlockedDate blockiert per Undertaker bis zu diesem Termin
   * @param strPrice Preis der Karte
   */
  public void setTicket(int nTix, String strIndex, String strRed, String strAttribute, String strBlockedDate, String strPrice)
  {
    orderInsuranceCharges = addInsurance(InsuranceStringToDouble(strPrice)) + orderInsuranceCharges;
    booktix.elementAt(nTix).setTicket(strIndex, strRed, strAttribute, strBlockedDate, strPrice );
  }
  
  /**
   * fuellt das Ticket mit den Daten (aus Vorschlag oder Saalplanbuchung)
   * 
   * @param nTix: x.te Karte in der Liste
   * @param nIndex: Sitzindex im Saalplan
   * @param nRed: Ermaessigungsindex
   * @param strAttribute zusaetzliches Felder
   * @param strBlockedDate blockiert per Undertaker bis zu diesem Termin
   * @param strPrice Preis der Karte
   */
  public void setTicket(int nTix, Integer nIndex, Integer nRed, String strAttribute, String strBlockedDate, String strPrice)
  {
    orderInsuranceCharges = addInsurance(InsuranceStringToDouble(strPrice)) + orderInsuranceCharges;
    booktix.elementAt(nTix).setTicket(nIndex, nRed, strAttribute, strBlockedDate, strPrice );
  }
  
  /**
   * fuellt das Ticket mit den Daten (aus Vorschlag oder Saalplanbuchung)
   * 
   * @param nTix: x.te Karte in der Liste
   * @param nIndex: Sitzindex im Saalplan
   * @param nRed: Ermaessigungsindex
   * @param strAttribute zusaetzliches Felder
   * @param strLevel Ebene
   * @param strSide Seite
   * @param strRow Reihe
   * @param strSeat Sitz
   * @param strInPG Preisgruppe
   * @param strInPGName Preisgruppenname
   * @param strInPGColor Preisgruppenfarbe (#330000)
   * @param strInFreetext Freitext
   * @param strInSeattype Sitztyp
   * @param strInReductionName Ermaessigungsname
   * @param strBlockedDate blockiert per Undertaker bis zu diesem Termin
   * @param strInOrigPrice Originalpreis der Karte
   * @param strPrice Preis der Karte
   */
  public void setTicket(int nTix, Integer nIndex, Integer nRed, String strAttribute,
                        String strLevel, String strSide, String strRow, String strSeat,
                        String strInPG, String strInPGName, String strInPGColor, String strInFreetext, String strInSeattype,
                        String strInReductionName, String strBlockedDate, String strInOrigPrice, String strInPrice)
  {
    orderInsuranceCharges = addInsurance(InsuranceStringToDouble(strInPrice)) + orderInsuranceCharges;
    booktix.elementAt(nTix).setTicket( nIndex, nRed, strAttribute,
                                       strLevel, strSide, strRow, strSeat,
                                       strInPG, strInPGName, strInPGColor, strInFreetext, strInSeattype,
                                       strInReductionName, strBlockedDate, strInOrigPrice, strInPrice );

  }
  
  /**
   * fuellt das Ticket mit den Daten (aus Vorschlag oder Saalplanbuchung)
   * 
   * @param nTix: x.te Karte in der Liste
   * @param strIndex: Sitzindex im Saalplan
   * @param strRed: Ermaessigungsindex
   * @param strAttribute zusaetzliches Felder
   * @param strLevel Ebene
   * @param strSide Seite
   * @param strRow Reihe
   * @param strSeat Sitz
   * @param strInPG Preisgruppe
   * @param strInPGName Preisgruppenname
   * @param strInPGColor Preisgruppenfarbe (#330000)
   * @param strInFreetext Freitext
   * @param strInSeattype Sitztyp
   * @param strInReductionName Ermaessigungsname
   * @param strBlockedDate blockiert per Undertaker bis zu diesem Termin
   * @param strInOrigPrice Originalpreis der Karte
   * @param strPrice Preis der Karte
   */
  public void setTicket(int nTix, String strIndex, String strRed, String strInAttribute,
                        String strInLevel, String strInSide, String strInRow, String strInSeat,
                        String strInPG, String strInPGName, String strInPGColor, String strInFreetext, String strInSeattype,
                        String strInReductionName, String strInDate, String strInOrigPrice, String strInPrice)
  {
    Integer nInReduction = 0;
    try { nInReduction = new Integer(strRed);} catch (Exception ex) {nInReduction = 0;}
    try { Integer nInIndex = new Integer(strIndex);
      booktix.elementAt(nTix).setTicket( nInIndex, nInReduction, strInAttribute,
                                         strInLevel, strInSide, strInRow, strInSeat,
                                         strInPG, strInPGName, strInPGColor, strInFreetext, strInSeattype,
                                         strInReductionName, strInDate, strInOrigPrice, strInPrice );
    }
    catch (Exception ex)
    {
    }
    orderInsuranceCharges = addInsurance(InsuranceStringToDouble(strInPrice)) + orderInsuranceCharges;
  }

  /**
   * fuellt das Ticket mit den Daten (aus Vorschlag oder Saalplanbuchung)
   * 
   * @param nTix: x.te Karte in der Liste
   * @param strIndex: Sitzindex im Saalplan
   * @param strRed: Ermaessigungsindex
   * @param strAttribute zusaetzliches Felder
   * @param strLevel Ebene
   * @param strSide Seite
   * @param strRow Reihe
   * @param strSeat Sitz
   * @param strInPG Preisgruppe
   * @param strInPGName Preisgruppenname
   * @param strInPGColor Preisgruppenfarbe (#330000)
   * @param strInFreetext Freitext
   * @param strInSeattype Sitztyp
   * @param strInReductionName Ermaessigungsname
   * @param strBlockedDate blockiert per Undertaker bis zu diesem Termin
   * @param strInOrigPrice Originalpreis der Karte
   * @param strPrice Preis der Karte
   * @param strXCoord X-Koordinate
   * @param strYCoord Y-Koordinate
   */
  public void setTicket(int nTix, String strIndex, String strRed, String strInAttribute,
                        String strInLevel, String strInSide, String strInRow, String strInSeat,
                        String strInPG, String strInPGName, String strInPGColor, String strInFreetext, String strInSeattype,
                        String strInReductionName, String strInDate, String strInOrigPrice, String strInPrice, String strXCoord, String strYCoord)
  {
    Integer nInReduction = 0;
    try { nInReduction = new Integer(strRed);} catch (Exception ex) {nInReduction = 0;}
    try { Integer nInIndex = new Integer(strIndex);
      booktix.elementAt(nTix).setTicket( nInIndex, nInReduction, strInAttribute,
                                         strInLevel, strInSide, strInRow, strInSeat,
                                         strInPG, strInPGName, strInPGColor, strInFreetext, strInSeattype,
                                         strInReductionName, strInDate, strInOrigPrice, strInPrice, strXCoord, strYCoord );
    }
    catch (Exception ex)
    {
    }
    orderInsuranceCharges = addInsurance(InsuranceStringToDouble(strInPrice)) + orderInsuranceCharges;
  }

  /**
   * 
   * 
   * 
   * @param Preis des Tickets
   *bis 30 EUR  	2,25 EUR pro Ticket
   *bis 60 EUR    	3,10 EUR pro Ticket
   *bis 100 EUR 	4,90 EUR pro Ticket
   *bis 150 EUR 	6,00 EUR pro Ticket
   *bis 500 EUR 	18,50 EUR pro Ticket
   *bis 1.500 EUR 	49,90 EUR pro Ticket
    */  
   public double addInsurance(double d)
   {
     double insur = 0.0;

     insur = 49.90;
     if (d <= 500.00) 
     {
       insur = 18.50;
     }
     if (d <= 150.00) 
     {
       insur = 6.00;
     }
     if (d <= 100.00) 
     {
       insur = 4.90;
     }
     if (d <= 60.00) 
     {
       insur = 3.10;
     }
     if (d <= 30.00) 
     {
       insur = 2.25;
     }         
     return insur;
   } 
      
   public double InsuranceStringToDouble(String a)
   {
     double d = 0.0;
 //    String a = strIns.replace(",","."); 
          
     NumberFormat nf = NumberFormat.getInstance();
     try {
        d = nf.parse(a).doubleValue();
      }
      catch (NumberFormatException ex)
      { d = 0.0; }
      catch (ParseException ex)
      { d = 0.0; }    
    return d;
  } 
   
  
  // und weiter normal
  public void setPosChargesCount(String a)
  {
    int nPosCharges;
    try {
      nPosCharges = new Integer(a).intValue();
    }
    catch (Exception ex)
    {
      nPosCharges = 0;
    }
    cardPosCharge = new Vector<CardOrderCharge>();
    for (int i = 0; i < nPosCharges; i++)
      cardPosCharge.add(new CardOrderCharge());
  }

  public void setPosCharge(int nPosCharge, Integer nIndex, String szCurrency)
  {
    cardPosCharge.get(cardPosType).setCardOrderCharge(nIndex, szCurrency );
  }

  public void setCardChargesCount(String a)
  {
    int nCardCharges;
    try {
      nCardCharges = new Integer(a).intValue();
    }
    catch (Exception ex)
    {
      nCardCharges = 0;
    }
    cardCardCharge = new Vector<CardOrderCharge>();
    for (int i = 0; i < nCardCharges; i++)
      cardCardCharge.add(new CardOrderCharge());
  }

  public void setCardCharge(int nCardCharge, Integer nIndex, String szCurrency)
  {
    cardCardCharge.get(cardPosType).setCardOrderCharge(nIndex, szCurrency );
  }

  public void setCardAutoCharges(String a)
  {
    try {
      Integer nX = new Integer(a);
      if (1 == nX)
        this.cardAutoCharges = true;
      else
        this.cardAutoCharges = false;
    }
    catch (Exception ex)
    {
      this.cardAutoCharges = false;
    }
  }

  public void setCardPrintAtHome(String a)
  {
    try {
      Integer nX = new Integer(a);
      if (1 == nX)
        this.cardPrintAtHome = true;
      else
        this.cardPrintAtHome = false;
    }
    catch (Exception ex)
    {
      this.cardPrintAtHome = false;
    }
  }
  public void setCardAbendkasse(String a)
  {
    try {
      Integer nX = new Integer(a);
      if (1 == nX)
        this.abendkasse = true;
      else
        this.abendkasse = false;
    }
    catch (Exception ex)
    {
      this.abendkasse = false;
    }

  }
  public void setCardInfos(String a)
  {
    this.cardInfos = a;
  }

  //-----------------------------------------------
  // Berechnet, die Anzahl der nicht ermaessigten Plaetze
  public void calcTickets()
  {
    int nTix = cardOrderTickets;

    for (int nAktPG = 0; nAktPG < ordertixPriceGroupCount; nAktPG++)
    {
      for (int j = 1; j < ordertixPG.get(nAktPG).getReductionCount(); j++)
      {
        nTix = nTix - ordertixPG.get(nAktPG).getTicketCount(j);
      }
    }
    if (nTix < 0)
      nTix = 0;
    ordertixPG.get(0).setTicketCount(new Integer(nTix).toString(), 0);
  }
  //---------------------------------------------------
  
  public int getCardPosType()
  {
    return this.cardPosType;
  }
  
  public int getCardOrderType()
  {
    return this.cardOrderType;
  }
  
  public String getCardPosStatus()
  {
    return this.cardPosStatus;
  }
  
  public String getCardEventName()
  {
    return this.cardEventName;
  }
  
  public String getCardEventNumber()
  {
    return this.cardEventNumber;
  } 
  
  public String getCardLocation()
  {
    return this.location;
  }
  
  public String getCardLocationZIP()
  {
    return this.locationZIP;
  }
  
  public String getCardLocationCity()
  {
    return this.locationCity;
  }
  
  public String getCardLocationStreet()
  {
    return this.locationStreet;
  }
  
  public String getCardShowDate()
  {
    return this.cardShowDate;
  }
  public Date getShowDate()
  {
    return this.showDate;
  }
  /**
   * holt den Wochentag zu der Vorstellung
   */
  public String getCardShowWeekday()
  {
      
    String lang = "de";  
    cardShowWeekday = "Error"; 
    
    String strDate = getCardShowDate();
    SimpleDateFormat sdf = new SimpleDateFormat( "dd.MM.yyyy" );
    Date myDate = null;
    try {
      myDate = sdf.parse(strDate);
    } catch (ParseException e) {
       System.out.println("Invalid Date Parser Exception ");
       e.printStackTrace();
    }
    
    Locale l = new Locale(lang);
    Calendar myCal1 = new GregorianCalendar(l);
    myCal1.setTime(myDate);
    int d = myCal1.get(Calendar.DAY_OF_WEEK);
    String[] weekdays = new DateFormatSymbols().getWeekdays();
    cardShowWeekday = weekdays[d];
    return this.cardShowWeekday;
  }

  public String getCardShowTime()
  {
    return this.cardShowTime;
  }
  
  public String getCardShowNumber()
  {
    return this.cardShowNumber;
  }
  
  public String getCardBlock()
  {
    return this.cardBlock;
  }
  
  public String getCardBlockNumber()
  {
    return this.cardBlockNumber;
  }
  /** Tribuene */
  public String getCardStand()
  {
    return this.cardStand;
  }
  
  // nun fuer errechner der Versicherung
  /**
   * Holen der Versicherungsgebuehr
   * 
   * @param a
  */
  public String getOrderInsuranceChargesStr()
  {
    return Double.toString(orderInsuranceCharges); 
  }  
  
  public double getOrderInsuranceCharges()
  {
    return this.orderInsuranceCharges;
  }     
  
  public String getOrderComeFrom()
  {
    return this.orderComeFrom;
 }      

  //-----------------------------------------------
  public List<CardOrderPG> getOrdertixPG()
  {
    if (ordertixPG.size()>0)
    {
      return ordertixPG.subList(0, ordertixPG.size());
    }
    else
      return null;
  }
  
  public String getOrdertixEbene()
  {
    return this.ordertixEbene;
  }
  
  public String getOrdertixSeite()
  {
    return this.ordertixSeite;
  }
  
  public String getOrdertixZusammen()
  {
    return this.ordertixZusammen;
  }
  
  public String getOrdertixPrice()
  {
    return this.ordertixPriceStr;
  }
  public double getOrdertixPriceVal()
  {
    return this.ordertixPrice;
  }

  public int getOrderTicketCount()
  {
    if (this.cardOrderTickets > 0)
      return this.cardOrderTickets;

    int nCount = 0;

    for (int nAktPG = 0; nAktPG < this.ordertixPriceGroupCount; nAktPG++)
    {
      nCount += ordertixPG.get(nAktPG).getTotalTickets();
    }
    return nCount;
  }
  
  public int getOrdertixPriceGroupCount()
  {
    return this.ordertixPriceGroupCount;
  }
  
  public String getOrdertixPriceGroup(int nPG)
  {
    return ordertixPG.get(nPG).getPriceGroup();
  }
  
  public String getOrdertixPriceGroupName(int nPG)
  {
    return ordertixPG.get(nPG).getPriceGroupName();
  }
  
  public String getOrdertixPriceGroupColor(int nPG)
  {
    return ordertixPG.get(nPG).getPriceGroupColor();
  }
  
  public String getOrdertixEbene(int nPG)
  {
    return ordertixPG.get(nPG).getLevel();
  }
  
  public String getOrdertixSeite(int nPG)
  {
    return ordertixPG.get(nPG).getSide();
  }
  
  public Integer getOrdertixReductionCount(int nPG)
  {
    return ordertixPG.get(nPG).getReductionCount();
  }
  
  public int getOrdertixReduction(int nPG, int nRed)
  {
    return ordertixPG.get(nPG).getReduction( nRed );
  }
  
  public String getOrdertixReductionString(int nPG, int nRed)
  {
    Integer Temp = ordertixPG.get(nPG).getReduction( nRed );
    return Temp.toString();
  }
  
  public String getOrdertixReductionName(int nPG, int nRed)
  {
    return ordertixPG.get(nPG).getReductionName( nRed );
  }
  
  public Integer getOrdertixTickets( int nPG, int nRed)
  {
    return ordertixPG.get(nPG).getTicketCount( nRed );
  }
  
  //-----------------------------------------------
  public List<CardOrderBookTicket> getBooktix()
  {
    if (booktix.size()>0)
    {
      return booktix.subList(0, booktix.size());
    }
    else
      return null;
  }
  
  public Integer getBookTicketCount()
  {
    return booktix.size();
  }
  
  public Double getBookTicketSum()
  {
    Double Temp = 0.0;
    
    for (int i = 0; i < booktix.size(); i++)
    {
      Temp += booktix.get(i).getPrice();
    }
    Temp += orderInsuranceCharges;
    return Temp;
  }
  
  /* Ermitteln der Ticket Ruecktrittsversicherungssumme
   * Ausgabe der Summe als Double
  */
  public Double getInsuranceSum()
  {
    Double Temp = 0.0;
    
    for (int i = 0; i < booktix.size(); i++)
    {
                
      Temp += addInsurance(booktix.get(i).getPrice());
    }
    return Temp;
  }
  
  
  
  public Integer getBooktixTicketIndex( int nTix)
  {
    return booktix.get(nTix).getIndex();
  }
  
  public Integer getBooktixTicketReduction(int nTix)
  {
    return booktix.get(nTix).getReduction();
  }
  
  public String getBooktixTicketAttribute(int nTix)
  {
    return booktix.get(nTix).getAttribute();
  }
  
  //-----------------------------------------------
  public List<CardOrderCharge> getCardPosCharge()
  {
    if (cardPosCharge.size()>0)
    {
      return cardPosCharge.subList(0, cardPosCharge.size());
    }
    else
      return null;
  }

  public int getCardPosChargesCount()
  {
    return this.cardPosCharge.size();
  }
  
  public Integer getCardPosChargeIndex( int nPosCharge)
  {
    return cardPosCharge.get(nPosCharge).getIndex();
  }

  //-----------------------------------------------
  public List<CardOrderCharge> getCardCardCharge()
  {
    if (cardCardCharge.size()>0)
    {
      return cardCardCharge.subList(0, cardCardCharge.size());
    }
    else
      return null;
  }

  public int getCardCardChargesCount()
  {
    return this.cardCardCharge.size();
  }
  
  public Integer getCardCardChargeIndex( int nCardCharge)
  {
    return cardCardCharge.get(nCardCharge).getIndex();
  }
  
  public boolean getCardAutoCharges()
  {
    return this.cardAutoCharges;
  }
  
  public boolean getPrintAtHome()
  {
    return this.cardPrintAtHome;
  }
  /** zur Kompatibilität, nun getPrintAtHome() */
  @Deprecated
  public boolean getCardPrintAtHome()
  {
    return this.cardPrintAtHome;
  }
  public boolean hasAbendkasse()
  {
    return this.abendkasse;
  }
  
  public String getCardInfos()
  {
    return this.cardInfos;
  }
  
  public double getOrdertixSum()
  {
    Double Temp = 0.0;
    for (int nAktPG = 0; nAktPG < ordertixPriceGroupCount; nAktPG++)
    {
      Temp += ordertixPG.get(nAktPG).getTotalPrice();
    }
    Temp += orderInsuranceCharges;
    return Temp;
//    return this.ordertixPrice;
  }
  
  /**
   * gibt unabhaengig vom Typ die Gesamtanzahl der Karten zurueck
   */
  public Integer getTicketCount()
  {
    if (CARDORDER_ORDER_PER_PG == cardOrderType)
    {
      return this.getOrderTicketCount();
    }
    else
    {
      if (CARDORDER_BOOK_PER_INDEX == cardOrderType)
        return this.getBookTicketCount();
      else
        return 0;
    }
  }
  
  public Double getCardorderSum()
  {
    if (cardOrderType == CARDORDER_ORDER_PER_PG)
      return getOrdertixSum();
    if (cardOrderType == CARDORDER_BOOK_PER_INDEX)
      return getBookTicketSum();
    return 0.0;
  }

  /**
   * loescht eine der vorgeschlagenen Karten
   */
  public void deleteBookTicket(int nTix)
  {
    booktix.remove(nTix);
    this.cardBookTickets = booktix.size();
  }
  
  /**
   * loescht die n.te Preisgruppen/Ermaessigungskombination
   */
  public void deleteOrderTicket(int nPGTix)
  {
    ordertixPG.remove(nPGTix);
    this.cardOrderTickets = ordertixPG.size();
  }
}



  

