/*
 * $Id: VKCUserDAO.java,v 1.22 2007/10/30 13:39:25 marbobo Exp $
 *
 * Copyright (c) Siemens AG 2008 
 *           (c) Universität Paderborn 2008 
 * Licensed under EUPL 1.1. 
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
 * THIS SOFTWARE OR ITS DERIVATIVES.
 *
 * $Log: VKCUserDAO.java,v $
 * Revision 1.22  2007/10/30 13:39:25  marbobo
 * + removed unnecessary statements
 *
 * Revision 1.21  2007/07/27 11:14:33  marbobo
 * + Ungenutzte Anweisungen entfernt
 *
 * Revision 1.20  2007/02/06 08:54:33  lawern
 * Dynamische Attribute zu Delegator-Objekten gemacht + getDynaAttributes()-Methoden implementiert.
 *
 * Revision 1.19  2007/01/29 10:23:59  lawern
 * Erweiterung der External-API
 *
 * Revision 1.18  2007/01/12 15:15:42  lawern
 * Bugfixing
 *
 * Revision 1.17  2007/01/12 12:56:55  korowa
 * +neuer Konstruktor von VKCDynUserAttributeDAO
 *
 * Revision 1.16  2007/01/08 08:52:15  lawern
 * Die setPassword-Methode hasht jetzt auch das Passwort.
 *
 * Revision 1.15  2007/01/02 10:43:11  lawern
 * Bugfixing
 *
 * Revision 1.14  2006/12/15 12:17:02  lawern
 * Getter&Setter für SystemViewTypeId
 *
 * Revision 1.13  2006/11/24 10:23:53  lawern
 * Anpassungen für PWS
 *
 * Revision 1.12  2006/09/29 12:18:58  korowa
 * Javadoc-Anpassungen
 *
 * Revision 1.10  2006/09/21 14:25:29  lawern
 * Konstruktor ergänzt.
 *
 * Revision 1.9  2006/09/21 14:14:29  lawern
 * Registrierungen überarbeitet
 *
 * Revision 1.8  2006/09/20 14:21:47  lawern
 * Überarbeitung
 *
 * Revision 1.7  2006/09/15 09:08:06  korowa
 * Die Änderungen von dynamischen Attributen wie auch andere UserParameter werden erst im Objekt intUser gespeichert.
 * + save()  speichert Parameter von diesem User persistent in DB
 *
 * Revision 1.6  2006/09/13 09:32:46  lawern
 * allgemeine Überarbeitung
 *
 * Revision 1.5  2006/09/12 14:26:55  korowa
 * Funktionsnamen und Parameternamen um Konsequenzswillen  geändert
 *
 * Revision 1.4  2006/09/08 11:41:02  korowa
 * Funktionen zum setzen, löschen,ändern und hinzufügen  DynUserAttribute ausimplementiert
 *
 * Revision 1.3  2006/09/01 11:07:15  korowa
 * Dynamische Attribute und damit verbundene Funktionen hinzugefügt
 *
 * Revision 1.2  2006/08/21 13:37:02  marlin
 * Instanzierung des Strukturtemplates eingebaut
 *
 * Revision 1.1  2006/08/17 13:01:14  lawern
 * Erster unvollständiger Schnellschuss für die Externe API.
 *
 */
package vkc.external;

import vkc.db.entities.VKCDynUserAttribute;
import vkc.db.entities.VKCSearchQuery;
import vkc.db.entities.VKCUser;

import vkc.db.serializer.VKCUserSerializer;

import vkc.exception.DBException;

import vkc.util.VKCCoder;
import vkc.util.VKCStringUtils;

import vkc.view.WebShare;

import java.io.UnsupportedEncodingException;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import java.sql.Timestamp;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Vector;

import javax.servlet.http.HttpSession;

public class VKCUserDAO {
	private VKCUser intUser; // internes VKCUser-Objekt

	private boolean authorized = false;

	private HashMap registeredCategories = null;

	private HashMap registeredDocuments = null;

	private HashMap registeredQueries = null;

	private VKCUserDAO(VKCUser intUser) {
		this.intUser = intUser;
	}

	/**
	 * Erzeugt einen neuen Benutzer. Er muss, wenn alle Parameter gesetzt sind,
	 * mit der save()-Methode persistent gemacht werden.
	 */
	public VKCUserDAO() {
		this.intUser = new VKCUser();
	}

	/**
	 * Löscht eine registrierte Kategorie.
	 * 
	 * @param categoryId
	 *            ID der zu löschenden Kategorie
	 */
	public void deleteRegisteredCategory(int categoryId) {
		if (registeredCategories == null) {
			getRegisteredCategories();
		}

		Integer catId = new Integer(categoryId);

		if (registeredCategories.containsKey(catId)) {
			registeredCategories.remove(catId);
		}
	}

	/**
	 * Die Methode liefert zu einem userName / pwd Paar ein VKC-Benutzerobject
	 * zurück.
	 * 
	 * @param userName
	 *            Benutzername
	 * @param pwd
	 *            Passwort
	 * @return Das Benutzer-Objekt
	 */
	public static VKCUserDAO login(String userName, String pwd) {
		return login(userName, pwd, null);
	}

	public static VKCUserDAO login(String userName, String pwd, HttpSession ses) {
		VKCUser user = null;

		String md5Password = null;

		if ((userName.equals("")) || (pwd.equals(""))) {
			return null;
		}

		try {
			user = VKCUserSerializer.retrieveUser(userName);
		} catch (Exception ex) {
			return null;
		}

		byte[] md5Bytes = null;

		try {
			md5Bytes = (userName + pwd).getBytes("ISO-8859-1");
		} catch (UnsupportedEncodingException e) {
		}

		MessageDigest digest = null;

		try {
			digest = MessageDigest.getInstance("MD5");
		} catch (NoSuchAlgorithmException e2) {
		}

		digest.reset();
		digest.update(md5Bytes);

		byte[] fingerPrint = digest.digest();
		fingerPrint = VKCCoder.base64Encode(fingerPrint);

		try {
			md5Password = new String(fingerPrint, "ISO-8859-1");
		} catch (UnsupportedEncodingException e1) {
		}

		if ((md5Password.equals(""))
				|| (!md5Password.equals(user.getPassword().trim()))) {
			return null;
		}

		// Benutzer in die Session eintragen
		if (ses != null) {
			ses.setAttribute(WebShare.USER_KEY, user);
		}

		VKCUserDAO userDAO = new VKCUserDAO(user);
		userDAO.authorized = true;

		return userDAO;
	}

	/**
	 * Die Methode liefert zu einer Benutzer-ID ein VKC-Benutzerobject zurück.
	 * 
	 * @param id
	 *            ID des Benutzers
	 * @return Das Benutzer-Objekt
	 */
	public static VKCUserDAO retrieveVKCUserDAO(int id) {
		try {
			return new VKCUserDAO(VKCUserSerializer
					.retrieveUser(new Integer(id)));
		} catch (DBException e) {
			// TODO Auto-generated catch block
			return null;
		}
	}

	/**
	 * Die Methode liefert zu einem Benutzernamen ein VKC-Benutzerobject zurück.
	 * 
	 * @param userName
	 *            Benutzername des Benutzers
	 * @return Das Benutzer-Objekt
	 */
	public static VKCUserDAO retrieveVKCUserDAO(String userName) {
		try {
			return new VKCUserDAO(VKCUserSerializer.retrieveUser(userName));
		} catch (DBException e) {
			// TODO Auto-generated catch block
			return null;
		}
	}

	/**
	 * Prüft ob ein Benutzerkonto bereits existiert
	 * 
	 * @param userName
	 *            Benutzername
	 * @return true falls Benutzer bereits existiert, false sonst
	 */
	public static boolean isUserExistent(String userName) {
		try {
			return VKCUserSerializer.isUserExistent(userName);
		} catch (DBException e) {
			// TODO Auto-generated catch block
			return false;
		}
	}

	boolean isAuthorized() {
		return authorized;
	}

	void setAuthorized(boolean authorized) {
		this.authorized = authorized;
	}

	/**
	 * Liefert gekapselten VKCUser
	 * 
	 * @return VKCUser
	 */
	VKCUser getIntUser() {
		return intUser;
	}

	/**
	 * Setzt internen VKCUser auf übergebenen Parameter
	 * 
	 * @param intUser
	 */
	void setIntUser(VKCUser intUser) {
		this.intUser = intUser;
	}

	/**
	 * Fügt diesem User ein dynamisches Attribut hinzu
	 * 
	 * @param dynUserAttribute
	 *            Hinzufügendes Attribut
	 */
	public void addDynUserAttribute(VKCDynUserAttributeDAO dynUserAttribute) {
		VKCDynUserAttribute attr = new VKCDynUserAttribute();
		attr.setName(VKCStringUtils.filterUnicodeChars(dynUserAttribute
				.getName()));
		attr.setValue(VKCStringUtils.filterUnicodeChars(dynUserAttribute
				.getValue()));
		attr.setAutorization(dynUserAttribute.getAutorization());
		attr.setUserId(intUser.getUserId());
		intUser.addDynaAttribute(attr);
	}

	/**
	 * Gibt das dynamische Attribute zurück
	 * 
	 * @param name
	 *            Der Name des Attributes
	 * @return Falls vorhanden das dynamische Attribut, sonst null
	 */
	public VKCDynUserAttributeDAO getDynUserAttribute(String name) {

		VKCDynUserAttribute attrInt = intUser.getDynUserAttribute(name);

		if (attrInt != null) {
			VKCDynUserAttributeDAO attr = new VKCDynUserAttributeDAO(attrInt);
			return attr;
		}

		return null;
	}

	/**
     * Gibt eine Liste von dynamischen Attributen eines Users zurück
     * 
     * @return Falls vorhanden eine Collection mit dynamischen Attributen
     *         (VKCDynUserAttributeDAO) von diesem User, sonst null.
     */
    public Collection getDynUserAttributes() {
        Collection attributes = intUser.getDynaAttributes();

        if (attributes != null) {
            ArrayList extAttributes = new ArrayList(attributes.size());
            for (Iterator iter = attributes.iterator(); iter.hasNext();) {
                VKCDynUserAttribute da = (VKCDynUserAttribute) iter.next();

                extAttributes.add(new VKCDynUserAttributeDAO(da));
            }

            return extAttributes;
        } else {
            return null;
        }
    }

	/**
     * Löscht den dynamischen Attribute mit dem angegebenen Namen beim Benutzer
     * 
     * @param name
     *            Der Name des Attributes
     * 
     */
	public void deleteDynUserAttribute(String name) {
		VKCDynUserAttribute attr = null;

		for (Iterator iter = intUser.getDynaAttributes().iterator(); iter
				.hasNext();) {
			attr = (VKCDynUserAttribute) iter.next();

			if (attr.getName().equals(VKCStringUtils.filterUnicodeChars(name))) {
				break;
			}
		}

		if (attr != null) {
			intUser.getDynaAttributes().remove(attr);
		}
	}

	/**
	 * Ändert den Wert des angegebenen dynamischen Attributes dieses Users
	 * 
	 * @param name
	 *            Zu änderndes Attribute
	 * @param newValue
	 *            Der neue Wert
	 */
	public void setDynUserAttributeValue(String name, String newValue) {
		for (Iterator iter = intUser.getDynaAttributes().iterator(); iter
				.hasNext();) {
			VKCDynUserAttribute da = (VKCDynUserAttribute) iter.next();

			if (da.getName().equals(name)) {
				da.setValue(newValue);
			}
		}
	}

	/**
	 * Fügt den VKCUserDAO zu der übergebenen VKCGruppeDAO
	 * 
	 * @param g
	 *            VKCGruppeDAO
	 * @return true falls erfolgreich, false sonst
	 */
	public boolean addGroup(VKCGroupDAO g) {
		return intUser.addGroup(g.getIntGroup());
	}

	/**
	 * Fügt dem Benutzer eine registrierte Kategorie hinzu
	 * 
	 * @param category
	 *            die zu registrierende Kategorie
	 */
	public void addRegisteredCategory(RegisteredCategory category) {
		if (registeredCategories == null) {
			getRegisteredCategories();
		}

		Integer catId = new Integer(category.getCategoryId());

		if (!registeredCategories.containsKey(catId)) {
			registeredCategories.put(catId, category);
		}
	}

	/**
	 * Fügt dem Benutzer ein registrierter Dokument hinzu
	 * 
	 * @param document
	 *            der zu registrierende Dokument
	 */
	public void addRegisteredDocument(RegisteredDocument document) {
		if (registeredDocuments == null) {
			getRegisteredDocuments();
		}

		Integer docId = new Integer(document.getDocumentId());

		if (!registeredDocuments.containsKey(docId)) {
			registeredDocuments.put(docId, document);
		}
	}

	/**
	 * Fügt dem Benutzer eine registrierte Suchanfrage
	 * 
	 * @param query
	 *            Suchanfrage
	 */
	public void addRegisteredQuery(VKCSearchQueryDAO query) {
		if (registeredQueries == null) {
			getRegisteredQueries();
		}

		String queryString = query.intSearchQuery.getSearchQuery();

		if (!registeredQueries.containsKey(queryString)) {
			registeredQueries.put(queryString, query);
		}
	}

	/**
	 * @return true fals der übergebene Object gleich dem VKCUserDAO Object ist,
	 *         sonst false
	 */
	public boolean equals(Object obj) {
		return intUser.equals(obj);
	}

	// /**
	// *
	// * @return liefert Id der Gruppe, die bei einer Zugriffskontroltabelle
	// * verwendet wird
	// */
	// public int getAccessorId() {
	// return intUser.getAccessorId().intValue();
	// }

	// /**
	// *
	// * @return liefert Name der Gruppe, der bei einer Zugriffskontroltabelle
	// * verwendet wird
	// */
	// public String getAccessorName() {
	// return intGroup.getAccessorName();
	// }

	/**
	 * @return true falls der Useraccount aktiv ist, sonst false
	 */
	public boolean getAccountValid() {
		return intUser.getAccountValid();
	}

	/**
	 * Liefert dynamische Attribute von dem User
	 * 
	 * @return Vector mit
	 */
	public Vector getAddAttributes() {
		return intUser.getAddAttributes();
	}

	/**
	 * 
	 * @return true falls Benutzer Administratorrechte besitzt, sonst false
	 */
	public boolean getAdminPrivileges() {
		return intUser.getAdminPrivileges();
	}

	/**
	 * 
	 * @return true falls Benutzer ein Mitglied einer Gruppe mit Adminrechten
	 *         ist, sonst false
	 */
	public boolean getAdminPrivilegesByGroup() {
		return intUser.getAdminPrivilegesByGroup();
	}

	/**
	 * Liefert ein Wert, der eine Sortiermethode bei den Bestseller representiert
	 * DOCUMENT_SORT_PUBLISHING_DATE_UP = 1;
	 * DOCUMENT_SORT_PUBLISHING_DATE_DOWN = 2;
	 * DOCUMENT_SORT_TITLE_UP = 3; 
	 * DOCUMENT_SORT_TITLE_DOWN = 4;
	 * DOCUMENT_SORT_AUTHOR_UP = 5;
	 * DOCUMENT_SORT_AUTHOR_DOWN = 6;
	 * DOCUMENT_SORT_SIZE_UP = 7;
	 * DOCUMENT_SORT_SIZE_DOWN = 8;
	 * DOCUMENT_SORT_TYPE_UP = 9;
	 * DOCUMENT_SORT_TYPE_DOWN = 10;
	 * DOCUMENT_SORT_ACCESSCOUNT_UP = 11;
	 * DOCUMENT_SORT_ACCESSCOUNT_DOWN = 12;
	 * DOCUMENT_SORT_PUBLISHER_UP = 13;
	 * DOCUMENT_SORT_PUBLISHER_DOWN = 14;
	 * DOCUMENT_SORT_CREATION_DATE_UP = 15;
	 * DOCUMENT_SORT_CREATION_DATE_DOWN = 16;
	 * 
	 * @return Bestsellersortiermethode
	 */
	public int getBestsellerDocumentSortMode() {
		return intUser.getBestsellerDocumentSortMode().intValue();
	}

	/**
	 * DOCUMENT_SORT_PUBLISHING_DATE_UP = 1;
	 * DOCUMENT_SORT_PUBLISHING_DATE_DOWN =2;
	 * DOCUMENT_SORT_TITLE_UP = 3; 
	 * DOCUMENT_SORT_TITLE_DOWN = 4;
	 * DOCUMENT_SORT_AUTHOR_UP = 5; 
	 * DOCUMENT_SORT_AUTHOR_DOWN = 6;
	 * DOCUMENT_SORT_SIZE_UP = 7; 
	 * DOCUMENT_SORT_SIZE_DOWN = 8;
	 * DOCUMENT_SORT_TYPE_UP = 9; 
	 * DOCUMENT_SORT_TYPE_DOWN = 10;
	 * DOCUMENT_SORT_PUBLISHER_UP = 13; 
	 * DOCUMENT_SORT_PUBLISHER_DOWN = 14;
	 * DOCUMENT_SORT_CREATION_DATE_UP = 15; 
	 * DOCUMENT_SORT_CREATION_DATE_DOWN = 16;
	 * 
	 * @return ein Intwert, der eine Sortiermethode bei der Kategorieansicht representiert
	 */
	public int getCategoryViewDocumentSortMode() {
		return intUser.getCategoryViewDocumentSortMode().intValue();
	}

	/**
	 * Liefert den von Benutzer angegebenen Stadt
	 * @return Satdt
	 */
	public String getCity() {
		return intUser.getCity();
	}

	/**
	 * Liefert vom Benutzer angegebene Firma
	 * @return Firma
	 */
	public String getCompany() {
		return intUser.getCompany();
	}

	/**
	 * Liefert KontaktURL des Benutzers
	 * @return KontaktURL
	 */
	public String getContactURL() {
		return intUser.getContactURL();
	}

	/**
	 * Liefert Datum an dem der Benutzer erzeugt wurde
	 * @return Erstellungsdatum
	 */
	public Date getCreated() {
		return intUser.getCreated();
	}

	/**
	 * Liefert die BenutzerID des Administrators der diesen Benutzer erstellt hat
	 * @return Benutzer Id des Administrator
	 */
	public int getCreatorId() {
		return intUser.getCreatorId().intValue();
	}

	/**
	 * Liefert von Benutzer angegebene Abteilung
	 * @return Abteilung
	 */
	public String getDepartment() {
		return intUser.getDepartment();
	}

	/**
	 * Lifert das Email des Benutzers
	 * @return Benutzeremail
	 */
	public String getEmail() {
		return intUser.getEmail();
	}

	/**
	 * Liefert den Fax des Benutzer
	 * @return Benutzerfax
	 */
	public String getFax() {
		return intUser.getFax();
	}

	/**
	 * Liefert den Vornamen des Benutzers
	 * @return Benutzervorname
	 */
	public String getFirstname() {
		return intUser.getFirstname();
	}

	/**
	 * Liefert Vor-, Nach- und Loginname des Benutzer
	 * @return volständige Name des Benutzers
	 */
	public String getFullName() {
		return intUser.getFullName();
	}

	/**
	 * Liefert eine Liste aller GruppenID, in dennen der Benutzer vorhanden ist
	 * @return Liste von GruppenID
	 */
	public List getGroupIds() {
		return intUser.getGroupIds();
	}

	/**
	 * 
	 * @return true falls Benutzer Adminrechte selbst oder per
	 *         Gruppenmitglidschaft erworben hat, sonst false
	 */
	public boolean getHasAdminPrivileges() {
		return intUser.getHasAdminPrivileges();
	}

	/**
	 * Liefert die KategorieID, die beim anmelden in VKC gestartet wird
	 * @return StartkategorieID
	 */
	public int getHomeCategoryId() {
		return intUser.getHomeCategoryId().intValue();
	}

	/**
	 * Liefert die HomepageUrl des Benutzers
	 * @return HomepageURL
	 */
	public String getHomepageURL() {
		return intUser.getHomepageURL();
	}

	/**
	 * vkc.language.german = 0
	 * vkc.language.english =1
	 * vkc.language.russian =2
	 * 
	 * @return Zahl, die die vom Benutzer ausgewählte Sprache für VKC representiert
	 */
	public int getLanguageId() {
		return intUser.getLanguageId().intValue();
	}

	/**
	 * Liefert das Datum zu dem der User zuletzt geändert wurde
	 * @return Datum der letzten Anderung
	 */
	public Date getLastChanged() {
		return intUser.getLastChanged();
	}

	/**
	 * Liefert die BenutzerId, des Administrators der an diesem Benutzer zuletzt Änderungen vorgenommen hat
	 * @return BenutzerId
	 */
	public int getLastChangerId() {
		return intUser.getLastChangerId().intValue();
	}

	/**
	 * Liefert Nachname von dem Benutzer
	 * @return Nachname
	 */
	public String getLastname() {
		return intUser.getLastname();
	}

	/**
	 * 
	 * @return true falls Email-Benachrichtigung aktiviert ist, sonst false
	 */
	public boolean getMessagingEnabled() {
		return intUser.getMessagingEnabled();
	}

	/**
	 * Liefert Zeitinterval für die Überprüfung von Benachrichtigungen 
	 * @return Zeitinterval für die Überprüfung von Benachrichtigungen 
	 */
	public int getMessagingTimePeriod() {
		return intUser.getMessagingTimePeriod().intValue();
	}

	/**
	 * Liefert Handynummer des Benutzers
	 * @return Handynummer
	 */
	public String getMobile() {
		return intUser.getMobile();
	}

	/**
	 * Liefert das Datum des letztes Logins des Benutzers
	 * @return Logindatum
	 */
	public Date getMostRecentLogin() {
		return intUser.getMostRecentLogin();
	}

	/**
	 * Liefert das Datum des letzten Logouts des Benutzers
	 * @return Logoutdatum
	 */
	public Date getMostRecentLogout() {
		return intUser.getMostRecentLogout();
	}

	/**
	 * Liefert das Datum der letzten Benachrichtigung des Benutzers
	 * @return Benachrichtigungsdatum
	 */
	public Date getMostRecentNews() {
		return intUser.getMostRecentNews();
	}

	/**
	 * Liefert das Password des Users
	 * @return Password
	 */
	public String getPassword() {
		return intUser.getPassword();
	}

	/**
	 * Liefert das Datum der letzten Änderung des Passworts des benutzers
	 * @return Änderungsdatum des Passwort
	 */
	public Date getPasswordChangedTs() {
		return intUser.getPasswordChangedTs();
	}

	/**
	 * Liefert die Telefonnummer des Benutzers
	 * @return Telefonnummer
	 */
	public String getPhone() {
		return intUser.getPhone();
	}

	/**
	 * Gibt eine Liste mit ProjectInfos aller vom einem Benutzer lesbaren
	 * Projekt-Kategorien zurück 
	 * @return Liste mit ProjectInfos
	 * @throws DBException
	 */
	public List getProjectInfos() throws DBException {
		return intUser.getProjectInfos();
	}

	/**
	 * Liefert aktuelle Anzahl erfolglosen Authentifizierungen
	 * @return Anzahl erfolglosen Authentifizierungen
	 */
	public int getPwdMismatchCount() {
		return intUser.getPwdMismatchCount().intValue();
	}

	/**
	 * Liefert Menge des Speichers die der Benutzer belegen darf
	 * @return Quota
	 */
	public int getQuota() {
		return intUser.getQuota().intValue();
	}

	/**
	 * Liefert eine Liste von RegisteredCategory-Objekten der vom Benutzer
	 * registrierten Kategorien
	 * 
	 * @return Liste von RegisteredCategory-Objekten
	 */
	public Collection getRegisteredCategories() {
		try {
			intUser.retrieveRegisteredCategories();

			HashMap cats = intUser.getRegisteredCategories();
			registeredCategories = new HashMap(cats.size());

			Iterator it = cats.values().iterator();

			while (it.hasNext()) {
				vkc.view.bean.RegisteredCategory currCat = (vkc.view.bean.RegisteredCategory) it
						.next();
				registeredCategories.put(currCat.getCategoryId(),
						new RegisteredCategory(currCat.getCategoryId()
								.intValue(), currCat.getIncludeSubDirs()
								.booleanValue()));
			}

			return registeredCategories.values();
		} catch (DBException e) {
			// TODO Auto-generated catch block
			return null;
		}
	}

	/**
	 * Liefert eine Liste von RegisteredDocument-Objekten der vom Benutzer
	 * registrierten Dokumente
	 * 
	 * @return Liste von RegisteredDocument-Objekten
	 */
	public Collection getRegisteredDocuments() {
		try {
			intUser.retrieveRegisteredDocuments();

			HashMap docs = intUser.getRegisteredDocuments();
			registeredDocuments = new HashMap(docs.size());

			Iterator it = docs.values().iterator();

			while (it.hasNext()) {
				vkc.view.bean.RegisteredDocument currDoc = (vkc.view.bean.RegisteredDocument) it
						.next();
				registeredDocuments.put(currDoc.getDocumentId(),
						new RegisteredDocument(currDoc.getDocumentId()
								.intValue(), (currDoc.getThreshold()
								.doubleValue() / 100.0)));
			}

			return registeredDocuments.values();
		} catch (DBException e) {
			// TODO Auto-generated catch block
			return null;
		}
	}

	/**
	 * Liefert eine Liste von VKCSearchQueryDAO-Objekten der vom Benutzer
	 * registrierten Suchanfragen
	 * 
	 * @return Liste von VKCSearchQueryDAO-Objekten
	 */
	public Collection getRegisteredQueries() {
		try {
			intUser.retrieveRegisteredQueries();

			HashMap queries = intUser.getRegisteredQueries();
			registeredQueries = new HashMap(queries.size());

			Iterator it = queries.values().iterator();

			while (it.hasNext()) {
				VKCSearchQuery currQuery = (VKCSearchQuery) it.next();
				registeredQueries.put(currQuery.getSearchQuery(),
						new VKCSearchQueryDAO(currQuery));
			}

			return registeredQueries.values();
		} catch (DBException e) {
			// TODO Auto-generated catch block
			return null;
		}
	}

	/**
	 * Liefert eine Zeitperiode der Inaktivität die zum Abmelden führt
	 * @return Zeitperiode
	 */
	public Integer getSessionTimeout() {
		return intUser.getSessionTimeout();
	}

	/**
	 * 
	 * @return true falls Emailanzeigen aktiviert ist, sonst false
	 */
	public boolean getShowEmail() {
		return intUser.getShowEmail();
	}

	/**
	 * 
	 * @return true falls Explorerbaum in VKC anzeigen aktiviert ist, sonst false  
	 */
	public boolean getShowTree() {
		return intUser.getShowTree();
	}

	/**
	 * Liefert die Straße die vom Benutzer angegeben wurde
	 * @return Straße
	 */
	public String getStreet() {
		return intUser.getStreet();
	}

	/**
	 * Liefert die Anrede zum Benutzer
	 * @return Anrede
	 */
	public String getTitle() {
		return intUser.getTitle();
	}
	
	/**
	 * Liefert gekapselten VKCUser-Object
	 * @return VKCUser-Object
	 */
	public String getUser() {
		return intUser.getUser();
	}

	/**
	 TODO:ist diese Funktion nötig?
	 * Gibt ein String zurück der den User beschreibt
	 * @return String="Benutzer '"+userName"'"
	 */
	public String getUserDescription() {
		return intUser.getUserDescription();
	}

	/**
	 * Liefert die BenutzerID von dem aktuellen Object
	 * @return BenutzerID
	 */
	public int getUserId() {
		return intUser.getUserId().intValue();
	}
/*
	Ist auskommentietr, da diese Methode ein Pfad aus der VKC liefert,
	 der extern nicht zu gebrauchen ist
	public String getUserTypeIcon() {
		return intUser.getUserTypeIcon();
	}
*/
	/**
	 * Liefert das Datum ab dem der Benutzer freigeschaltet ist
	 * @return Startdatum
	 */
	public Date getValidFrom() {
		return intUser.getValidFrom();
	}

	/**
	 * Liefert das Datum bis dem der Benutzeraccount aktiv bleibt
	 * @return Enddatum
	 */
	public Date getValidUntil() {
		return intUser.getValidUntil();
	}

	/**
	 * Liefert von dem Benutzer angegebene Postleitzahl
	 * @return PLZ
	 */
	public String getZip() {
		return intUser.getZip();
	}

	/**
	 * @return true falls Benutzer Adminrechte selbst oder per
	 *         Gruppenmitglidschaft erworben hat, sonst false
	 */
	public boolean hasAdminPrivileges() {
		return intUser.hasAdminPrivileges();
	}

	/**
	 * Liefert Hashcode von diesem VKCBenutzerDao-Objekt
	 * @return Hashcode
	 */
	public int hashCode() {
		return intUser.hashCode();
	}

	/**
	 * 
	 * @return true falls der Benutzer ungelesene Benachrichtigungen hat, sonst false
	 * @throws DBException
	 */
	public boolean hasUnreadNews() throws DBException {
		return intUser.hasUnreadNews();
	}

	/**
	 * 
	 * @return true falls der Benutzer die Administratorrechte besitzt
	 */
	public boolean isAdmin() {
		return intUser.isAdmin();
	}


	/**
	 * @return true falls Benutzer ein Mitglied einer Gruppe mit Adminrechten
	 *         ist, sonst false
	 */
	public boolean isAdminByGroup() {
		return intUser.isAdminByGroup();
	}

	/**
	 * 
	 * @return true falls dem Benutzer erlaubt ist eigene Systemansichten zu
	 *         verwalten, sonst false
	 */
	public boolean isAllowManageSystemViewType() {
		return intUser.isAllowManageSystemViewType();
	}

	/**
	 * 
	 * @return true false der Benutzer die Rechte eines dedizierten Admins
	 *         besitzt, sonst false
	 */
	public boolean isDedicatedAdmin() {
		return intUser.isDedicatedAdmin();
	}

	/**
	 * @return true falls Benutzer Gruppen erstellen und verwalten kann aber
	 *         keine Adminrechte besitzt, sonst false
	 */
	public boolean isDedicatedGroupsAdmin() {
		return intUser.isDedicatedGroupsAdmin();
	}

	/**
	  @return true falls Benutzer eigene Benutzer erstellen und verwalten kann aber
	 *         keine Adminrechte besitzt, sonst false
	 */
	public boolean isDedicatedUsersAdmin() {
		return intUser.isDedicatedUsersAdmin();
	}

	/**
	 * 
	 * @return true falls Benutzer sich über externes (nicht VKC)
	 *         System(z.B. LDAP) eingellogt ist, sonst false
	 */
	public boolean isExternalUser() {
		return intUser.isExternalUser();
	}

	/**
	 * 
	 * @return true falls der User ein Gastuser ist, sonst false
	 */
	public boolean isGuestUser() {
		return intUser.isGuestUser();
	}

	/**
	 * 
	 * @return true falls der Benutzer Rechte hat Systemansichten von eigenen
	 *         Benutzer zu verwalten, sonst false
	 */
	public boolean isManageOwnUsersSystemViews() {
		return intUser.isManageOwnUsersSystemViews();
	}

	/**
	 * 
	 * @return true falls der Benutzer Anfragen für virtuelle Dokumente
	 *         erstellen darf, sonst false
	 */
	public boolean isManageVirtualDocumentQueries() {
		return intUser.isManageVirtualDocumentQueries();
	}

	/**
	 * 
	 * @param groupId
	 *            ID der Gruppe
	 * @return true falls der Benutzer ein Mitglied der Gruppe mit der
	 *         übergebenen ID ist, sonst false
	 */
	public boolean isMemberOf(int groupId) {
		return intUser.isMemberOf(new Integer(groupId));
	}

	/**
	 * 
	 * @return true falls der Benutzer KEINE Administrationrechte besitzt, sonst
	 *         false
	 */
	public boolean isNormalUser() {
		return intUser.isNormalUser();
	}

	/**
	 * 
	 * @return true falls der Benutzer sein Password geändert hat, sonst false
	 */
	public boolean isPasswordChanged() {
		return intUser.isPasswordChanged();
	}

	/**
	 * 
	 * @param categoryId
	 *            ID einer Kategorie
	 * @return true falls diese Kategorie von dem Benutzer registriert wurde,
	 *         sonst false
	 */
	public boolean isRegisteredCategory(int categoryId) {
		return intUser.isRegisteredCategory(new Integer(categoryId));
	}

	/**
	 * 
	 * @param documentId
	 *            ID eines Dokumentes
	 * @return true falls der vDokument schon für den Benutzer registriert ist,
	 *         sonst false
	 */
	public boolean isRegisteredDocument(int documentId) {
		return intUser.isRegisteredDocument(new Integer(documentId));
	}

	/**
	 * 
	 * @param queryId
	 *            ID einer Anfrage
	 * @return true falls die Anfrage mit angegebener ID für den Benutzer
	 *         registriert ist
	 */
	public boolean isRegisteredQuery(int queryId) {
		return intUser.isRegisteredQuery(new Integer(queryId));
	}

	/**
	 * 
	 * @return true falls der Benutzeraccount aktiv ist, sonst false
	 */
	public boolean isUserValid() {
		return intUser.isUserValid();
	}

	/**
	 * Beendet die Mitgliedschaft des Benutzers in der angegebenen Gruppe
	 * 
	 * @param g
	 *            Eine Gruppe
	 * @return true falls die Gruppe erfolgreich gelöscht wurde, sonst false
	 */
	public boolean removeGroup(VKCGroupDAO g) {
		return intUser.removeGroup(g.getIntGroup());
	}

	/**
	 * Löscht das Übergebene registrierte Dokument.
	 * 
	 * @param documentId
	 *            ID des zu löschenden Dokuments
	 */
	public void deleteRegisteredDocument(int documentId) {
		if (registeredDocuments == null) {
			getRegisteredDocuments();
		}

		Integer docId = new Integer(documentId);

		if (registeredDocuments.containsKey(docId)) {
			registeredDocuments.remove(docId);
		}
	}

	/**
	 * Löscht die Übergebene registrierte Suchanfrage.
	 * 
	 * @param query
	 *            ID der zu löschenden Anfrage
	 */
	public void deleteRegisteredQuery(VKCSearchQueryDAO query) {
		if (registeredQueries == null) {
			getRegisteredQueries();
		}

		String queryString = query.intSearchQuery.getSearchQuery();

		if (!registeredQueries.containsKey(queryString)) {
			registeredQueries.remove(queryString);
		}
	}

	/**
	 * Speichert das aktuelle Benutzerobjekt
	 * 
	 * @param session
	 *            Session-Objekt in dem der aktuelle Benutzer hinterlegt ist
	 * @throws VKCExternalException
	 */
	public void save(HttpSession session) throws VKCExternalException {
		save((VKCUser) session.getAttribute(WebShare.USER_KEY));
	}

	/**
	 * Speichert das aktuelle Benutzerobjekt
	 * 
	 * @param user
	 *            Der aktuelle Benutzer
	 * @throws VKCExternalException
	 */
	public void save(VKCUserDAO user) throws VKCExternalException {
		if (user.isAuthorized()) {
			save(user.getIntUser());
		}
	}

	/**
	 * Speichert das aktuelle Benutzerobjekt
	 * 
	 * @param user
	 *            Der aktuelle Benutzer
	 * @throws VKCExternalException
	 */
	private void save(VKCUser user) throws VKCExternalException {
		if (intUser != null) {
			if (user.isAdmin()) {
				try {
                    intUser.setLastChanged(new Timestamp(System.currentTimeMillis()));
                    intUser.setLastChangerId(user.getUserId());
                    
					VKCUserSerializer.saveUser(intUser);

					if (registeredCategories != null) {
						// Registrierte Kategorien habe sich geändert und müssen
						// gespeichert werden.
						HashMap regCats = new HashMap(registeredCategories
								.size());
						Iterator it = registeredCategories.values().iterator();

						while (it.hasNext()) {
							RegisteredCategory currCat = (RegisteredCategory) it
									.next();
							Integer currCatId = new Integer(currCat
									.getCategoryId());
							vkc.view.bean.RegisteredCategory currRegCat = new vkc.view.bean.RegisteredCategory();
							currRegCat.setCategoryId(currCatId);
							currRegCat.setIncludeSubDirs(new Boolean(currCat
									.isIncludeSubCategories()));
							regCats.put(currCatId, currRegCat);
						}

						intUser.setRegisteredCategories(regCats);
						intUser.saveRegisteredCategories();
					}

					if (registeredDocuments != null) {
						// Registrierte Dokumente habe sich geändert und müssen
						// gespeichert werden.
						HashMap regDocs = new HashMap(registeredDocuments
								.size());
						Iterator it = registeredDocuments.values().iterator();

						while (it.hasNext()) {
							RegisteredDocument currDoc = (RegisteredDocument) it
									.next();
							Integer currDocId = new Integer(currDoc
									.getDocumentId());
							vkc.view.bean.RegisteredDocument currRegDoc = new vkc.view.bean.RegisteredDocument();
							currRegDoc.setDocumentId(currDocId);
							currRegDoc.setThreshold(new Integer((int) (currDoc
									.getThreshold() * 100)));
							regDocs.put(currDocId, currRegDoc);
						}

						intUser.setRegisteredDocuments(regDocs);
						intUser.saveRegisteredDocuments();
					}

					if (registeredQueries != null) {
						// Registrierte Suchanfragen habe sich geändert und
						// müssen gespeichert werden.
						HashMap regQueries = new HashMap(registeredQueries
								.size());
						Iterator it = registeredQueries.values().iterator();

						int i = 1;
						while (it.hasNext()) {
							VKCSearchQueryDAO currQuery = (VKCSearchQueryDAO) it
									.next();

							regQueries.put(new Integer(i++),
									currQuery.intSearchQuery);
						}

						intUser.setRegisteredQueries(regQueries);
						intUser.saveRegisteredQueries();
					}
				} catch (DBException e) {
					throw new VKCExternalException(VKCExternalException.UNKNOWN);
				}
			} else {
				// TODO hier muss noch berücksichtigt werden, dass ein
				// Benutzer seine eigenen Daten teilweise ändern darf.
				throw new VKCExternalException(
						VKCExternalException.WRITE_PERMISSION_FAILED);
			}
		}
	}

	/**
	 * Löscht das aktuelle Benutzerobjekt
	 * 
	 * @param session
	 *            Session-Objekt in dem der aktuelle Benutzer hinterlegt ist
	 * @throws VKCExternalException
	 */
	public void delete(HttpSession session) throws VKCExternalException {
		delete((VKCUser) session.getAttribute(WebShare.USER_KEY));
	}

	/**
	 * Löscht das aktuelle Benutzerobjekt
	 * 
	 * @param user
	 *            Der aktuelle Benutzer
	 * @throws VKCExternalException
	 */
	public void delete(VKCUserDAO user) throws VKCExternalException {
		if (user.isAuthorized()) {
			delete(user.getIntUser());
		}
	}

	/**
	 * Löscht das aktuelle Benutzerobjekt
	 * 
	 * @param user
	 *            Der aktuelle Benutzer
	 * @throws VKCExternalException
	 */
	private void delete(VKCUser user) throws VKCExternalException {
		if (intUser != null) {
			if (user.isAdmin()) {
				try {
					VKCUserSerializer.deleteUser(intUser.getUserId());
				} catch (DBException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} else {
				throw new VKCExternalException(
						VKCExternalException.WRITE_PERMISSION_FAILED);
			}
		}
	}
	/**
	 * Setzt den Benutzeraccount auf aktiv, falls true übergeben wird, oder
	 * sperrt ihn sonst
	 * 
	 * @param b
	 * 			Gültigkeit des Benutzeraccounts
	 */
	public void setAccountValid(boolean b) {
		// TODO noch anpassen (Rechtecheck)
		intUser.setAccountValid(b);
	}

	
	/**
	 * Setzt Adninistrationsrechte für den Benutzer
	 * 
	 * @param b
	 */
	public void setAdminPrivileges(boolean b) {
		// TODO noch anpassen (Rechtecheck)
		intUser.setAdminPrivileges(b);
	}

	/**
	 * Setzt die Rechte zur Verwaltung von Systemansichten für den Benutzer
	 * 
	 * @param allowManageSystemViewType
	 */
	public void setAllowManageSystemViewType(boolean allowManageSystemViewType) {
		// TODO noch anpassen (Rechtecheck)
		intUser.setAllowManageSystemViewType(allowManageSystemViewType);
	}

	/**
	 * Setzt die Name der Stadt
	 * 
	 * @param s
	 *            neue Name der Stadt
	 */
	public void setCity(String s) {
		intUser.setCity(s);
	}

	/**
	 * Setzt den Namen der Firma
	 * 
	 * @param s
	 *            Name der Firma
	 */
	public void setCompany(String s) {
		intUser.setCompany(s);
	}

	/**
	 * Setzt KontaktURL
	 * 
	 * @param s
	 *            KontaktURL
	 */
	public void setContactURL(String s) {
		intUser.setContactURL(s);
	}

	/**
	 * Setzt den Namen der Abteilung
	 * 
	 * @param s
	 *            Name der Abteilung
	 */
	public void setDepartment(String s) {
		intUser.setDepartment(s);
	}

	/**
	 * Setzt Email des Benutzers
	 * 
	 * @param s
	 *            Email-Adresse
	 */
	public void setEmail(String s) {
		intUser.setEmail(s);
	}

	/**
	 * Setzt Faxnummer des Benutzers
	 * 
	 * @param s
	 *            Faxnummer
	 */
	public void setFax(String s) {
		intUser.setFax(s);
	}

	/**
	 * Setzt die Vorname des Benutzers
	 * 
	 * @param s
	 *            Vorname des Benutzers
	 */
	public void setFirstname(String s) {
		intUser.setFirstname(s);
	}

	/**
	 * Setzt die Gruppen in denen der Benutzer Mitglied ist
	 * 
	 * @param g
	 *            Set von Gruppen
	 */
	public void setGroups(Set g) {
		// TODO noch anpassen
		intUser.setGroups(g);
	}

	/**
	 * Setzt die Startkategorie
	 * 
	 * @param id
	 *            Id einer Kategorie
	 */
	public void setHomeCategoryId(int id) {
		intUser.setHomeCategoryId(new Integer(id));
	}

	/**
	 * Setzt die HomepageURL
	 * 
	 * @param s
	 *            HomepageURL
	 */
	public void setHomepageURL(String s) {
		intUser.setHomepageURL(s);
	}

	/**
	 * Setzt die Sprache des VKCSystems 
	 * IDs: 
	 * vkc.language.german  = 0
	 * vkc.language.english = 1 
	 * vkc.language.russian = 2
	 * 
	 * @param id
	 *            Id einer Sprach
	 */
	public void setLanguageId(int id) {
		intUser.setLanguageId(new Integer(id));
	}

	/**
	 * Setzt Nachname des Benutzers
	 * 
	 * @param s
	 *            Nachname des Benutzers
	 */
	public void setLastname(String s) {
		intUser.setLastname(s);
	}

	/**
	 * Setzt Rechte zur Verwaltung eigener Gruppen
	 * 
	 * @param b
	 * 
	 */
	public void setManageOwnGroups(boolean b) {
		// TODO noch anpassen (Rechtecheck)
		intUser.setManageOwnGroups(b);
	}

	/**
	 * Setzt Rechte zur Verwaltung eigener Proxiesserver
	 * 
	 * @param b
	 */
	public void setManageOwnProxies(boolean b) {
		// TODO noch anpassen (Rechtecheck)
		intUser.setManageOwnProxies(b);
	}

	/**
	 * Setzt Rechte zur Verwaltung eigener Benutzer
	 * 
	 * @param b
	 */
	public void setManageOwnUsers(boolean b) {
		// TODO noch anpassen (Rechtecheck)
		intUser.setManageOwnUsers(b);
	}

	/**
	 * Setzt Rechte zur Verwaltung der Systemansichten eigener Benutzer
	 * 
	 * @param manageOwnUsersSystemViews
	 */
	public void setManageOwnUsersSystemViews(boolean manageOwnUsersSystemViews) {
		// TODO noch anpassen (Rechtecheck)
		intUser.setManageOwnUsersSystemViews(manageOwnUsersSystemViews);
	}

	/**
	 * Setzt Rechte zur Erstellung und Verwaltung von Anfragen zur virtaullen
	 * Dokumenten
	 * 
	 * @param manageVirtualDocumentQueries
	 */
	public void setManageVirtualDocumentQueries(
			boolean manageVirtualDocumentQueries) {
		// TODO noch anpassen (Rechtecheck)
		intUser.setManageVirtualDocumentQueries(manageVirtualDocumentQueries);
	}

	/**
	 * Aktiviert oder sperrt die Emailbenachrichtigung
	 * @param b
	 */
	public void setMessagingEnabled(boolean b) {
		intUser.setMessagingEnabled(b);
	}

	/**
	 * 
	 * Setzt den Zeitinterval für die Überprüfung von Benachrichtigungen
	 * 
	 * @param i
	 *            Zeitinterval für die Überprüfung von Benachrichtigungen
	 */
	public void setMessagingTimePeriod(int i) {
		intUser.setMessagingTimePeriod(new Integer(i));
	}

	/**
	 * Setzt Handynummer des Benutzers
	 * 
	 * @param s
	 *            Handynummer
	 */
	public void setMobile(String s) {
		intUser.setMobile(s);
	}

	/**
	 * Setzt das Datum für die letzte Benachrichtigung für den Benutzer
	 * 
	 * @param date
	 *            Datum
	 */
	public void setMostRecentNews(Date date) {
		intUser.setMostRecentNews(new Timestamp(date.getTime()));
	}

	/**
	 * Setzt das Password für den Benutzer
	 * 
	 * @param pwd
	 *            neuer Password
	 */
	public void setPassword(String pwd) {
        
        byte[] md5Bytes = null;
        String md5Password = null;

        try {
            md5Bytes = (intUser.getUser() + pwd).getBytes("ISO-8859-1");
        } catch (UnsupportedEncodingException e) {
        }

        MessageDigest digest = null;

        try {
            digest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e2) {
        }

        digest.reset();
        digest.update(md5Bytes);

        byte[] fingerPrint = digest.digest();
        fingerPrint = VKCCoder.base64Encode(fingerPrint);

        try {
            md5Password = new String(fingerPrint, "ISO-8859-1");
        } catch (UnsupportedEncodingException e1) {
        }
        
		intUser.setPassword(md5Password);
	}

	/**
	 * Setz den Telefonnummer des Benutzers
	 * 
	 * @param s
	 *            Telefonnummer
	 */
	public void setPhone(String s) {
		intUser.setPhone(s);
	}

	/**
	 * Setzt eine Quota für den Benutzer
	 * 
	 * @param i
	 *            Anzahl der MB
	 */
	public void setQuota(Integer i) {
		// TODO noch anpassen (Rechtecheck)
		intUser.setQuota(i);
	}

	/**
	 * Setzt die für den Benutzer registrierte Kategorien auf den übergebenen Hashmap
	 * @param map
	 * Hashmap mit den registrierten Kategorien(Key=ID, Object=Category)
	 */
	public void setRegisteredCategories(HashMap map) {
		// TODO noch anpassen
		intUser.setRegisteredCategories(map);
	}

	/**
	 * Setzt eine Zeitperiode der Inaktivität die zum Abmelden führt
	 * @param timeout
	 */
	public void setSessionTimeout(int timeout) {
		intUser.setSessionTimeout(new Integer(timeout));
	}

	/**
	 * Erlaubt das Anzeigen der Email-Adresse des Benutzers
	 * 
	 * @param b
	 */
	public void setShowEmail(boolean b) {
		intUser.setShowEmail(b);
	}

	/**
	 * Steuert die Anzeige des Explorer-Baums in VKC
	 * @param showTree
	 */
	public void setShowTree(boolean showTree) {
		intUser.setShowTree(showTree);
	}

	/**
	 * Setzt den Namen der Straße
	 * 
	 * @param s
	 *            Name der Straße
	 */
	public void setStreet(String s) {
		intUser.setStreet(s);
	}

	/**
	 * Setzt die Anrede
	 * 
	 * @param s
	 *            Anrede
	 */
	public void setTitle(String s) {
		intUser.setTitle(s);
	}
/*
 * wird nicht benutzt
 * 
 * public void setUrls(String s) { intUser.setUrls(s); }
 */
	/**
	 * setzt den internen VKC-Benutzer
	 */
	public void setUser(String s) {
		intUser.setUser(s);
	}

	/**
	 * Setzt BenutzerID
	 * 
	 * @param i
	 *            BenutzerID
	 */
	public void setUserId(Integer i) {
		intUser.setUserId(i);
	}
	

	/**
	 * Setzt das Datum ab dem der Benutzer freigeschaltet werden soll
	 * 
	 * @param d
	 *            Startdatum
	 */
	public void setValidFrom(Date d) {
		intUser.setValidFrom(new Timestamp(d.getTime()));
	}

	/**
	 * Setzt das Datum bis dem der Benutzer aktiv bleiben soll
	 * 
	 * @param d
	 *            Enddatum
	 */
	public void setValidUntil(Date d) {
		intUser.setValidUntil(new Timestamp(d.getTime()));
	}

	/**
	 * Setzt den Postleitzahl
	 * 
	 * @param s
	 *            PLZ
	 */
	public void setZip(String s) {
		intUser.setZip(s);
	}

	/**
	 * Gibt den Benutzer als String zurück
	 * @return lastname+firstname+username
	 */
	public String toString() {
		return intUser.toString();
	}

	
	public class RegisteredCategory {
		int categoryId = -1;

		boolean includeSubCategories = false;

		public RegisteredCategory(int categoryId, boolean includeSubCategories) {
			this.categoryId = categoryId;
			this.includeSubCategories = includeSubCategories;
		}

		/**
		 * @return the categoryId
		 */
		public int getCategoryId() {
			return categoryId;
		}

		/**
		 * @param categoryId
		 *            the categoryId to set
		 */
		public void setCategoryId(int categoryId) {
			this.categoryId = categoryId;
		}

		/**
		 * @return the includeSubCategories
		 */
		public boolean isIncludeSubCategories() {
			return includeSubCategories;
		}

		/**
		 * @param includeSubCategories
		 *            the includeSubCategories to set
		 */
		public void setIncludeSubCategories(boolean includeSubCategories) {
			this.includeSubCategories = includeSubCategories;
		}
	}

	public class RegisteredDocument {
		int documentId = -1;

		double threshold = 0.0;

		public RegisteredDocument(int documentId, double treshold) {
			this.documentId = documentId;
			this.threshold = treshold;
		}

		/**
		 * @return the documentId
		 */
		public int getDocumentId() {
			return documentId;
		}

		/**
		 * @param documentId
		 *            the documentId to set
		 */
		public void setDocumentId(int documentId) {
			this.documentId = documentId;
		}

		/**
		 * @return the treshold
		 */
		public double getThreshold() {
			return threshold;
		}

		/**
		 * @param treshold
		 *            the treshold to set
		 */
		public void setThreshold(double treshold) {
			this.threshold = treshold;
		}
	}

    /**
     * Liefert die ID der gesetzten Systemsicht
     * 0 = Projektsicht
     * 1 = Funktionssicht
     * 2 = Kategoriesicht
     * @return ID der initialen Systemsicht
     */
    public Integer getSystemViewTypeId() {
        return intUser.getSystemViewTypeId();
    }

    /**
     * Setzt die Systemsicht beim Anmeldevorgang
     * 0 = Projektsicht
     * 1 = Funktionssicht
     * 2 = Kategoriesicht
     * @param systemViewTypeId ID der initialen Systemsicht
     */
    public void setSystemViewTypeId(Integer systemViewTypeId) {
        intUser.setSystemViewTypeId(systemViewTypeId);
    }

    /**
     * Gibt an, ob das Passwort bei der ersten VKC-Anmeldung vom Benutzer
     * geändert werden muss oder nicht.
     * 
     * @param changePwd
     */
    public void setChangePassword(boolean changePwd) {
        intUser.setPasswordChanged(!changePwd);
        intUser.setPasswordChangedTs(new Timestamp(System.currentTimeMillis()));
    }

}
