/*
 * $Id: VKCProxyUserSerializer.java,v 1.11 2006/03/27 22:08:14 marbobo Exp $
 *
 * Copyright (c) Siemens AG 2008 
 *           (c) Universität Paderborn 2008 
 * Licensed under EUPL 1.1. 
 *
 * $Log: VKCProxyUserSerializer.java,v $
 * Revision 1.11  2006/03/27 22:08:14  marbobo
 * + Bugfixes und Refactoring
 *
 * Revision 1.10  2004/12/09 21:07:40  marbobo
 * + kleine Optimierungen und Bugfixes
 * +an einigen Stellen Rreihenfolge der close-Anweisungen vereinheitlicht
 *
 * Revision 1.9  2004/12/09 12:39:28  lawern
 * vergessene PreparedStatements geschlossen
 *
 * Revision 1.8  2004/12/05 22:57:46  marbobo
 * + Statement auf PreparedStatement umgestellt
 *
 * Revision 1.7  2004/11/24 09:25:54  lawern
 * Hibernate ist VKC-Geschichte!
 *
 * Revision 1.6  2004/11/18 16:05:25  lawern
 * changed order of close-stmt to resultset/connect/session  in finally-blocks
 *
 * Revision 1.5  2004/11/10 15:02:44  koppy
 * Projektweite Überarbeitung von Error-Logs, Stacktraces,..
 *
 * Revision 1.4  2004/10/21 23:49:17  marbobo
 * + CURRENT_TIMESTAMP ersetzt mit java-Anweisung
 *
 * Revision 1.3  2004/07/20 08:23:21  jonyp
 * added copyright info + cvs log
 *
 *
 */
package vkc.db.serializer;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import java.sql.Connection;

import vkc.db.entities.VKCProxyUser;
import vkc.db.helper.DBHelper;
import vkc.exception.DBException;
import vkc.misc.VKCLogManager;
import vkc.view.WebShare;

public class VKCProxyUserSerializer {
	private VKCProxyUserSerializer() {
	}

	/**
	 * Private Methode für "getProxyUsersForUser" und "getUsersForProxy".
	 *
	 * @param proxysForUser Wenn die Stellvertreter für einen User geholt werden sollen, muss dieser Parameter auf true
	 * gesetzt werden. Sonst false
	 * @param userId
	 * @param availableUsersOnly
	 * @return
	 * @throws DBException
	 */
	private static final Collection retrieveProxy(boolean proxysForUser, Integer userId, boolean availableUsersOnly) throws DBException {
		Connection conn = null;
		PreparedStatement pStmt = null;
		ResultSet rs = null;
		String dataField = "userid";

		if (proxysForUser) {
			// Es werden alle Stellvertreter zu einer UserID geholt
			dataField = "userid";
		} else {
			// Es werden alle User geholt, die als Stellvertreter 'userID' publizieren dürfen
			dataField = "proxyuserid";
		}

		try {
			conn = WebShare.database.getConnection();

			// ----
			String sqlStatement = "SELECT proxyid, userid, proxyuserid, description, validfrom, validuntil, created, creatorid "
								+ "FROM proxyusers WHERE " + dataField + " = ?";
			pStmt = conn.prepareStatement(sqlStatement);
			pStmt.setInt(1, userId.intValue());
			rs = pStmt.executeQuery();

			ArrayList proxyUsers = new ArrayList();

			while (rs.next()) {
				VKCProxyUser pu = new VKCProxyUser();
				pu.setProxyId(new Integer(rs.getInt("proxyid")));
				pu.setUserId(new Integer(rs.getInt("userid")));
				pu.setProxyUserId(new Integer(rs.getInt("proxyuserid")));
				pu.setDescription(rs.getString("description"));
				pu.setValidFrom(rs.getTimestamp("validfrom"));
				pu.setValidUntil(rs.getTimestamp("validuntil"));
				pu.setCreated(rs.getTimestamp("created"));
				pu.setCreatorId(new Integer(rs.getInt("creatorid")));

				// falls 'availableUsersOnly':
				// Prüfen, ob der ProxyUser im gültigen Zeitfenster liegt
				boolean proxyUserValid = true;

				if (availableUsersOnly) {
					Timestamp ts = new Timestamp(System.currentTimeMillis());

					if (pu.getValidFrom() != null) {
						if (pu.getValidFrom().after(ts)) {
							proxyUserValid = false;
						}
					}

					if (pu.getValidUntil() != null) {
						if (pu.getValidUntil().before(ts)) {
							proxyUserValid = false;
						}
					}
				}

				if (proxyUserValid) {
					proxyUsers.add(pu);
				}
			}

			return proxyUsers;
		} catch (Exception e) {
			VKCLogManager.errorLog(VKCProxyUserSerializer.class, "1", "Error occured while retrieving databaseentries for " + dataField + " " + userId, e);
			throw new DBException(e);
		} finally {
			DBHelper.close(rs);
			DBHelper.close(pStmt);
			DBHelper.close(conn);
		}
	}

	/**
	 * Gibt eine Collection (ArrayList) mit VKCProxyUser Objekten zurück, die alle
	 * Benutzer enthält, die als Stellvertreter für den Benutzer mit der UserID 'proxyUserId'
	 * eingetragen sind.
	 * Sind keine Einträge vorhanden, wird null zurückgegeben.
	 *
	 * @param proxyUserId
	 * @param availableUsersOnly true, falls nur gültige Benutzer angezeigt werden sollen
	 * @return
	 * @throws DBException
	 */
	public static final Collection getUsersForProxy(Integer proxyUserId, boolean availableUsersOnly) throws DBException {
		return retrieveProxy(false, proxyUserId, availableUsersOnly);
	}

	/**
	 * Gibt eine Collection (ArrayList) mit VKCProxyUser Objekten zurück, falls
	 * für den über die UserID übergebenen User ProxyUsers eingetragen sind.
	 * Ansonsten wird null zurückgegeben.
	 *
	 * @param userId
	 * @param availableUsersOnly true, falls nur gültige Benutzer angezeigt werden sollen
	 * @return
	 * @throws DBException
	 */
	public static final Collection getProxyUsersForUser(Integer userId, boolean availableUsersOnly) throws DBException {
		return retrieveProxy(true, userId, availableUsersOnly);
	}

	/**
	 * Speichert eine Collection mit VKCProxyUser Objekten in der Datenbank ab.
	 *
	 * @param proxyUsers
	 */
	public static final void saveProxyUsers(Collection proxyUsers, Integer proxyUserId) throws DBException {
		Connection conn = null;
		PreparedStatement pStmt = null;
		ResultSet rs = null;

		Iterator it = proxyUsers.iterator();

		try {
			conn = WebShare.database.getConnection();
			// Löschen des Eintrages
			pStmt = conn.prepareStatement("DELETE FROM proxyusers WHERE proxyuserid = ?");
			pStmt.setInt(1, proxyUserId.intValue());
			pStmt.execute();
			DBHelper.close(pStmt);
			pStmt = conn.prepareStatement("INSERT INTO proxyusers ( proxyid, userid, proxyuserid, description, validfrom, validuntil, created, creatorid ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ? )");

			it = proxyUsers.iterator();

			while (it.hasNext()) {
				VKCProxyUser proxyUser = (VKCProxyUser) it.next();

				// Erstellen des neuen Eintrages
				pStmt.setInt(1, DBHelper.getNewId(conn, "proxyusers", "proxyid").intValue());
				pStmt.setInt(2, proxyUser.getUserId().intValue());
				pStmt.setInt(3, proxyUser.getProxyUserId().intValue());
				pStmt.setString(4, proxyUser.getDescription());

				if (proxyUser.getValidFrom() != null) {
					pStmt.setTimestamp(5, proxyUser.getValidFrom());
				} else {
					pStmt.setNull(5, Types.TIMESTAMP);
				}

				if (proxyUser.getValidUntil() != null) {
					pStmt.setTimestamp(6, proxyUser.getValidUntil());
				} else {
					pStmt.setNull(6, Types.TIMESTAMP);
				}

				pStmt.setTimestamp(7, new Timestamp(System.currentTimeMillis()));
				pStmt.setInt(8, proxyUser.getCreatorId().intValue());

				pStmt.execute();
			}

			conn.commit();
		} catch (Exception ex) {
			DBHelper.rollBack(conn);
			VKCLogManager.errorLog(VKCProxyUserSerializer.class, "", "Error saving Proxyuser Information", ex);
			throw new DBException(ex);
		} finally {
			DBHelper.close(rs);
			DBHelper.close(pStmt);
			DBHelper.close(conn);
		}
	}
}