0001: package com.teamkonzept.field;
0002:
0003: import java.io.*;
0004: import java.sql.SQLException;
0005: import java.text.CharacterIterator;
0006: import java.text.StringCharacterIterator;
0007: import java.util.*;
0008:
0009: import com.teamkonzept.lib.*;
0010: import com.teamkonzept.publishing.markups.*;
0011: import com.teamkonzept.webman.mainint.db.MediaManager;
0012: import com.teamkonzept.webman.mainint.db.MediaInterface;
0013: import de.webman.content.eventhandler.TemplateConstants;
0014: import com.teamkonzept.web.*;
0015: import com.teamkonzept.field.db.*;
0016: import com.teamkonzept.international.LanguageManager;
0017: import org.w3c.dom.*;
0018: import org.apache.log4j.Category;
0019:
0020: /**
0021: * The upload field control.
0022: * <PRE>
0023: * Die Klasse TKUploadfield stellt Methoden zur Verfuegung, Uploads zu ermoeglichen und
0024: * die hochgeladenen Dateien (Bilder) darzustellen, sowie die Daten in der Datenbank zu speichern.
0025: * Das Verzeichnis, in dem die Bilder gespeichert werden sollen, wird mit dem Parameterhash
0026: * uebergeben. Der Key ist mit UPBASE banannt.
0027: *
0028: * 1. Upload von Dateien
0029: * Die im UPBASE liegenden Dateien werden ausgelesen und in einem Pulldown-
0030: * menue zur Auswahl gestellt.
0031: *
0032: * 2 Upload von Dateien vom lokalen Rechner auf den Server
0033: * Dateien koennen vom lokalen Rechner in das UPBASE-Verzeichnis auf den Server
0034: * kopiert werden. Es besteht die Moeglichkeit, Dateinamen zu aendern.
0035: *
0036: * Das Upload benoetigt 2 Templates.
0037: * 1. Datei-Auswahl
0038: * Das erste (ce_upload.tmpl und ct_upload.tmpl)
0039: * stellt Funktionalitaeten zur Verfuegung, die die Auswahl der Dateien ermoeglicht.
0040: *
0041: * 2. Darstellung der Datei
0042: * Das 2. Template (field_option.tmpl) stellt das Bild da und enthaelt einen Button "Modify".
0043: * Wird dieser Event ausgeloest, wird das Template zur Datei-Auswahl wieder generiert.
0044: *
0045: * Die Events fuer das Modify werden im Hauptprogramm (CTGenerator) abgearbeitet.
0046: * </PRE>
0047: *
0048: * @author $Author: alex $
0049: * @version $Revision: 1.52.2.1 $
0050: */
0051: public class TKUploadField extends TKBaseField implements
0052: TemplateConstants {
0053: // $Id: TKUploadField.java,v 1.52.2.1 2002/05/16 15:02:52 alex Exp $
0054:
0055: /**
0056: * The logging category.
0057: */
0058: private static final Category CATEGORY = Category
0059: .getInstance(TKUploadField.class);
0060:
0061: /** werden Bilder gleich angezeigt ?*/
0062: protected boolean showPics = true;
0063:
0064: /** ist es ueberhaupt erlaubt, Bilder ins Filesystem zu speichern ? */
0065: private static boolean fileSystemAllowed = false;
0066:
0067: /** werden Uploads in der DB oder im Filesystem gespeichert ? */
0068: protected boolean saveInDB = true;
0069:
0070: /** Konstante fuer Buffer */
0071: public final static int ONE_KB = 1024;
0072:
0073: /** Standard File fuer die erlaubten Mime Typen */
0074: public static final String DEFAULT_INI_FILE = "/TKUploadField.ini";
0075:
0076: /**
0077: * The class identifier.
0078: */
0079: public static final String CLASS_ID = "UPLOAD";
0080:
0081: /** Parameter Name fuer UPBASE */
0082: private static final String BASEPATH_PAR = "UPBASE";
0083: private static final String FILENAME_PAR = "FILENAME";
0084: private static final String GETFILENAME = "GETFILENAME";
0085: private static final String GETEXTENSION = "GETEXTENSION";
0086: private static final String TEMPPATH = System
0087: .getProperty("java.io.tmpdir");
0088: public static final String GETFILENAMESTREAM = "GETFILENAMESTREAM";
0089: private static final String TARGET = "TARGET";
0090: public static final String NEW_FILENAME = "NEW_FILENAME";
0091: private static final String MIME_KEY = "MIME";
0092: private static final String SELECTLIST_SIZE = "SELECTLIST_SIZE";
0093: private static final String IMAGE = "IMAGE";
0094: private static final String APPLICATION = "APPLICATION";
0095: private static final String VAL_SEP = "|";
0096: private static final String URL_SEP = "/";
0097: public static final String CONTENT_TYPE = "content-type";
0098: private static final String PIC_KEY = "PICS";
0099: private static final String DB_KEY = "IN_DB";
0100: private static final String YES_VALUE = "YES";
0101: private static final String NO_VALUE = "NO";
0102: public static final String NEW_MEDIA_ID = "NEW_MEDIA_ID";
0103:
0104: public static String documentRoot = "";
0105: public static String iniFile = "";
0106:
0107: protected int size;
0108: protected int length;
0109:
0110: /**
0111: * The selection list.
0112: */
0113: protected TKVector selectList = null;
0114:
0115: String getExtension = "";
0116:
0117: //private MediaInterface media;
0118: static {
0119: try {
0120: PropertyManager back = PropertyManager
0121: .getPropertyManager("UPLOAD");
0122: String value = back.getValue("ALLOW_FILESYSTEM", "");
0123: fileSystemAllowed = value.equalsIgnoreCase("TRUE");
0124: } catch (Throwable t) {
0125: CATEGORY.debug("Error during reading UPLOAD group", t);
0126: }
0127: }
0128:
0129: /**
0130: * Konstruktor 1
0131: */
0132: public TKUploadField() {
0133: };
0134:
0135: /**
0136: * Konstruktor 2
0137: *
0138: * @param String Name, ein beliebiger Name
0139: */
0140: public TKUploadField(String name) {
0141: this (name, null);
0142: }
0143:
0144: /**
0145: * Konstruktor 3
0146: *
0147: * @param String Name, ein beliebiger Name
0148: * @param String showName, Name, den der Benuzer fuer das Feld gewaehlt hat
0149: */
0150: public TKUploadField(String name, String showName) {
0151: //initUploadField( CLASS_ID, name, showName );
0152: this (name, showName, null);
0153: }
0154:
0155: /**
0156: * Konstruktor 4
0157: */
0158: public TKUploadField(String name, String showName,
0159: TKVector selectList) {
0160: initUploadField(CLASS_ID, name, showName, selectList);
0161: }
0162:
0163: /**
0164: * Funktionalitaet eines Konstruktors
0165: *
0166: * @param String type, CLASS_ID
0167: * @param String Name, ein beliebiger Name
0168: * @param String showName, Name, den der Benuzer fuer das Feld gewaehlt hat
0169: * @param TKVector selectList, vector enthaelt die ausgewaehlten Elemente (multiple Switch)
0170: */
0171: public final void initUploadField(String type, String name,
0172: String showName, TKVector selectList) {
0173: initBaseField(type, name, showName);
0174: this .selectList = selectList;
0175: }
0176:
0177: /*
0178: * Eine Liste mit den ausgewaehlten Mime-Types wird global zur Verfuegung gestellt
0179: *
0180: * @param String fieldType, CLASS_ID
0181: * @param Object initData, Strukturparameter
0182: */
0183: public void init(String fieldClass, Object data)
0184: throws TKUnregisteredClassException,
0185: ClassNotFoundException, InstantiationException,
0186: IllegalAccessException {
0187: TKHashtable selectData = (TKHashtable) data;
0188: super .init(fieldClass, data);
0189:
0190: //---- multiple Auswahl ----/
0191: if (selectData.containsKey(MIME_KEY)) {
0192: if (selectData.get(MIME_KEY) instanceof TKVector) {
0193: selectList = (TKVector) selectData.get(MIME_KEY);
0194: } else {
0195: //---- keine Auswahl ----/
0196: if (selectData.get(MIME_KEY).equals("")) {
0197: selectList = new TKVector();
0198: }
0199: //---- eine Auswahl ----//
0200: else {
0201: selectList = new TKVector(1);
0202: selectList.addElement(selectData.get(MIME_KEY));
0203: }
0204: }
0205: }
0206: if (selectData.containsKey(PIC_KEY))
0207: showPics = ((String) selectData.get(PIC_KEY))
0208: .equals(YES_VALUE);
0209: //
0210: if (selectData.containsKey(DB_KEY)) {
0211: String dbData = (String) selectData.get(DB_KEY);
0212: saveInDB = dbData.equals("")
0213: || (selectData.get(DB_KEY).equals(YES_VALUE));
0214: }
0215: }
0216:
0217: /*
0218: */
0219: public static void initStaticsForUpload(String root, String ini) {
0220: documentRoot = root;
0221: iniFile = ini;
0222: }
0223:
0224: /*
0225: * der name des inifiles wurde bisher von TKWebmanInit gesetzt
0226: */
0227: public static void initStaticsForUpload(String root) {
0228: documentRoot = root;
0229: iniFile = DEFAULT_INI_FILE;
0230: }
0231:
0232: /**
0233: * Methode zur Definition eines Uploadfeldes
0234: * Die Struktur eines Upload-Feldes besteht aus einer Gruppe von zwei Inputfeldern, mit
0235: * denen Name und Beschreibung festgelegt werden und eines Selectfeldes, welches die
0236: * aus dem Inifile gelesenen mimetypes enthaelt
0237: *
0238: * @param allSwitch, wird hier nicht benoetigt
0239: * @param allSwitchList, wird hier nicht benoetigt
0240: *
0241: * @return eine Gruppe die die Definition des Uploadfeldes enthaelt
0242: */
0243: public TKFieldGroup getDefGroup(TKFieldSwitch allSwitch,
0244: TKFieldSwitchList allSwitchList) {
0245: //---- Liste der Mimetypes fertigstellen ----//
0246: TKUploadFieldIni.readIniFile();
0247: TKVector mimeOptions = new TKVector();
0248:
0249: mimeOptions.addElement(new TKOptionFieldEntry("Alle", "ALL"));
0250:
0251: Enumeration sectionEnum = TKUploadFieldIni.iniHash.keys();
0252: while (sectionEnum.hasMoreElements()) {
0253: String key = (String) sectionEnum.nextElement();
0254: mimeOptions.addElement(new TKOptionFieldEntry(key, key));
0255:
0256: TKHashtable contentHash = (TKHashtable) TKUploadFieldIni.iniHash
0257: .get(key);
0258:
0259: Enumeration contentEnum = contentHash.keys();
0260: while (contentEnum.hasMoreElements()) {
0261: String contentKey = (String) contentEnum.nextElement();
0262: // String contentVal = (String) contentHash.get(contentKey);
0263: mimeOptions.addElement(new TKOptionFieldEntry("---"
0264: + contentKey, contentKey));
0265: }
0266: }
0267:
0268: TKVector multipleOptions = new TKVector(2);
0269: multipleOptions
0270: .addElement(new TKOptionFieldEntry(LanguageManager
0271: .getText(LanguageManager.GENERAL, "YES"),
0272: YES_VALUE));
0273: multipleOptions.addElement(new TKOptionFieldEntry(
0274: LanguageManager.getText(LanguageManager.GENERAL, "NO"),
0275: NO_VALUE));
0276:
0277: TKInputField nameField = new TKInputField(
0278: TKUploadField.NAME_KEY,
0279: TKInputField.SMALL_DEFAULT_SIZE,
0280: TKInputField.SMALL_DEFAULT_LENGTH, LanguageManager
0281: .getText(LANGUAGE_CONTEXT, "UPLOAD_NAME"),
0282: TKInputField.CHECK_STRING);
0283: TKInputField shortNameField = new TKInputField(
0284: TKUploadField.SHOW_NAME_KEY,
0285: TKInputField.LARGE_DEFAULT_SIZE,
0286: TKInputField.LARGE_DEFAULT_LENGTH, LanguageManager
0287: .getText(LANGUAGE_CONTEXT, "UPLOAD_SHOWNAME"),
0288: TKInputField.CHECK_STRING);
0289: TKCheckField picField = new TKCheckField(PIC_KEY,
0290: LanguageManager.getText(LANGUAGE_CONTEXT,
0291: "UPLOAD_DISPLAY_IMAGES"), multipleOptions,
0292: false);
0293: TKCheckField dbField = new TKCheckField(DB_KEY, LanguageManager
0294: .getText(LANGUAGE_CONTEXT, "UPLOAD_IN_DB"),
0295: multipleOptions, false);
0296: TKSelectField mimeField = new TKSelectField(MIME_KEY,
0297: LanguageManager
0298: .getText(LANGUAGE_CONTEXT, "UPLOAD_MIME"),
0299: mimeOptions, 5, true);
0300: TKBaseField[] uploadArray = null;
0301: if (fileSystemAllowed)
0302: uploadArray = new TKBaseField[] { nameField,
0303: shortNameField, picField, dbField, mimeField };
0304: else
0305: uploadArray = new TKBaseField[] { nameField,
0306: shortNameField, picField, mimeField };
0307: TKFieldGroup uploadGroup = new TKFieldGroup(
0308: TKUploadField.CLASS_ID, new TKVector(uploadArray),
0309: LanguageManager.getText(LANGUAGE_CONTEXT,
0310: TKUploadField.CLASS_ID));
0311: return uploadGroup;
0312: }
0313:
0314: /**
0315: * Die realen Daten (interne Repraesentation) fuer ein Uploadfeld bestehen
0316: * aus einem Filenamen und dem Ablageverzeichnis
0317: *
0318: * @return result, die Values sind der leere String
0319: */
0320: public Object getDefault() {
0321: TKHashtable result = new TKHashtable(2);
0322: result.put(FILENAME_PAR, "");
0323: result.put(BASEPATH_PAR, "");
0324: return result;
0325:
0326: }
0327:
0328: /**
0329: * Interne Repraesentation der realen Daten eines Uploadfeldes durch eine
0330: * Hashtable mit den Keys BASEPATH_PAR und FILENAME_PAR
0331: *
0332: * @param prefix, der prefix
0333: * @param data, die realen Daten fuer das Upload
0334: *
0335: * @return result,FILENAME= Name der Datei, UPBASE= Ablageverzeichnis}
0336: */
0337: public Object compileData(String prefix, TKHashtable data,
0338: TKHashtable context) {
0339:
0340: TKHashtable result = new TKHashtable();
0341:
0342: String _mediaID = (String) data.get(prefix + fieldName + "."
0343: + MEDIA_ID_PARNAME);
0344: String _newMediaID = (String) data.get(prefix + fieldName + "."
0345: + NEW_MEDIA_ID);
0346: if (_newMediaID != null) {
0347: result.put(MEDIA_ID_PARNAME, _newMediaID);
0348: } else if (_mediaID != null && !_mediaID.equals("")) {
0349: result.put(MEDIA_ID_PARNAME, _mediaID);
0350: } else {
0351:
0352: if (data.get(BASEPATH_PAR) instanceof TKVector) {
0353: TKVector baseVector = (TKVector) data.get(BASEPATH_PAR);
0354: data.put(BASEPATH_PAR, baseVector.firstElement());
0355: result.put(BASEPATH_PAR, baseVector.firstElement());
0356: } else {
0357: result.put(BASEPATH_PAR, data.get(BASEPATH_PAR));
0358: }
0359:
0360: result.put(FILENAME_PAR, data.get(prefix + fieldName));
0361: }
0362:
0363: return result;
0364: }
0365:
0366: /** nicht mehr benutzt */
0367: public Object compileData(String prefix, TKMarkupNode data,
0368: TKHashtable context) {
0369: return null;
0370: }
0371:
0372: /**
0373: * Der ausgewaehlte Mimetype in der Struktur wird in einem Hash gespeichert.
0374: *
0375: * @return result, enhaelt die uebergabe aus der Struktur
0376: */
0377: public Object toData() {
0378: TKHashtable result = (TKHashtable) super .toData();
0379: result.put(MIME_KEY, selectList);
0380: result.put(PIC_KEY, (showPics ? YES_VALUE : NO_VALUE));
0381: result.put(DB_KEY, (saveInDB ? YES_VALUE : NO_VALUE));
0382: return result;
0383: }
0384:
0385: /*
0386: * Das hochgeladene File wird im Template angezeigt
0387: *
0388: * @param t, field_upload.tmpl, anzeigen eines Bildes
0389: * @param value, Hasch mit Filename und Upbaseverzeichnis
0390: * @param prefix, der aktuelle Prefix
0391: */
0392: public void fillIntoTemplate(TKHTMLTemplate t, Object value,
0393: String prefix) {
0394: super .fillIntoTemplate(t, value, prefix);
0395:
0396: TKHashtable realData = (TKHashtable) value;
0397:
0398: String fileName;
0399: Integer mediaID = null;
0400:
0401: /* mediaID in value */
0402: if (realData.get(MEDIA_ID_PARNAME) != null) {
0403:
0404: mediaID = new Integer((String) realData
0405: .get(MEDIA_ID_PARNAME));
0406: fileName = MediaManager.getMediaName(mediaID.intValue());
0407: t.set(MEDIA_ID_PARNAME, mediaID);
0408: }
0409: /* maybe there is a filename in realData */
0410: else {
0411: fileName = (String) realData.get(FILENAME_PAR);
0412: }
0413:
0414: t.set(FILENAME_PAR, fileName);
0415:
0416: if (!fileName.equals(""))
0417: t.set("DO_UPLOAD", Boolean.TRUE);
0418:
0419: if (isMimeImage(fileName, TKUploadFieldIni.iniHash)) {
0420: t.set(IMAGE, Boolean.TRUE);
0421: } else {
0422: if (isMimeApplication(fileName, TKUploadFieldIni.iniHash))
0423: t.set(APPLICATION, Boolean.TRUE);
0424: }
0425:
0426: if (realData.containsKey("ERROR")) {
0427: if (realData.get("ERROR").equals("ERROR"))
0428: t.set("ERROR", Boolean.TRUE);
0429: }
0430:
0431: t.set(GETEXTENSION, getExtension);
0432:
0433: /* display settings */
0434:
0435: if (!saveInDB || mediaID == null) // Media ID = null -> vielleicht umgeschaltet von Files. auf DB?
0436: {
0437: if (mediaID == null) // vielleicht umgeschaltet von DB auf Filesystem ?
0438: {
0439: t.set(DOCUMENTS_FROM_FILESYSTEM, Boolean.TRUE);
0440: }
0441: }
0442: if (showPics) {
0443: t.set(IMAGES_INLINE, Boolean.TRUE);
0444: } else {
0445: t.set(IMAGES_FETCH, Boolean.TRUE);
0446: }
0447: }
0448:
0449: /** MUSS DRINGEND AN fillIntoTemplate ANGEPASST WERDEN */
0450: public void fillIntoDOM(Document doc, Element node, Object data)
0451: throws DOMException {
0452: Element me = doc.createElement(getInternationalName());
0453: node.appendChild(me);
0454: TKHashtable dataHash = (TKHashtable) data;
0455: String mediaIDstr = (String) dataHash.get(MEDIA_ID_PARNAME);
0456: if (mediaIDstr != null && !mediaIDstr.equals("")) {
0457: int mediaID = new Integer(mediaIDstr).intValue();
0458: MediaManager media = new MediaManager(mediaID);
0459: String contentID = (String) dataHash.get(CONTENT_ID);
0460: if (contentID != null && !contentID.equals("")) {
0461: media.setContentID(new Integer(contentID).intValue());
0462: }
0463: Text txt = doc.createTextNode(media.toString());
0464: me.appendChild(txt);
0465: fillAttributesIntoNode(me, media);
0466: } else {
0467: // for downwards compatibility
0468: String fileName = (String) dataHash.get(FILENAME_PAR);
0469: if (fileName.length() > 0) {
0470: Text txt = doc.createTextNode(MediaManager
0471: .getRelativePath(((String) dataHash
0472: .get(BASEPATH_PAR))
0473: + fileName));
0474: me.appendChild(txt);
0475: super .fillAttributesIntoNode(me, data);
0476:
0477: }
0478: }
0479: }
0480:
0481: public void fillAttributesIntoNode(Element node, Object data)
0482: throws DOMException {
0483: super .fillAttributesIntoNode(node, data);
0484: MediaManager media = (MediaManager) data;
0485: try {
0486: Integer size = media.getMediaSize();
0487: // in Bytes
0488: if (size != null) {
0489: node.setAttribute(FILE_SIZE, size.toString());
0490: }
0491: // in KBytes
0492: if (size != null) {
0493: node.setAttribute(FILE_SIZE_KB, (new Integer(size
0494: .intValue()
0495: / ONE_KB)).toString());
0496: }
0497:
0498: String path = media.getPath();
0499: if (path != null) {
0500: node.setAttribute(FILE_PATH, path);
0501: }
0502: String ext = media.getFilenameExtension();
0503: if (ext != null) {
0504: node.setAttribute(FILE_EXT, ext);
0505: }
0506: String noExt = media.getFilenameWithoutExt();
0507: if (noExt != null) {
0508: node.setAttribute(FILE_NAME_NOEXT, noExt);
0509: }
0510: } catch (SQLException e) {
0511: throw new Error(e.getMessage());
0512: }
0513: }
0514:
0515: /*
0516: * Der Scope wird in das Template eingesetzt
0517: *
0518: * @param t, field_upload.tmpl, anzeigen eines Bildes
0519: * @param data, Hasch mit Filename und Upbaseverzeichnis
0520: * @param scope, der aktuelle Scope
0521: */
0522: public void fillIntoPresentation(TKHTMLTemplate t, Object data,
0523: String scope) {
0524: TKHashtable dataHash = (TKHashtable) data;
0525:
0526: String mediaIDstr = (String) dataHash.get(MEDIA_ID_PARNAME);
0527:
0528: if (mediaIDstr != null && !mediaIDstr.equals("")) {
0529: int mediaID = new Integer(mediaIDstr).intValue();
0530: MediaManager media = new MediaManager(mediaID);
0531: String contentID = (String) dataHash.get(CONTENT_ID);
0532: if (contentID != null && !contentID.equals("")) {
0533: media.setContentID(new Integer(contentID).intValue());
0534: }
0535:
0536: //t.set(FILE_EXT, media);
0537: t.set(scope + "." + getName(), media);
0538:
0539: try {
0540: Integer size = media.getMediaSize();
0541: // in Bytes
0542: if (size != null) {
0543: t.set(scope + "." + getName() + "." + FILE_SIZE,
0544: size);
0545: }
0546: // in KBytes
0547: if (size != null) {
0548: t.set(scope + "." + getName() + "." + FILE_SIZE_KB,
0549: new Integer(size.intValue() / ONE_KB));
0550: }
0551:
0552: String path = media.getPath();
0553: if (path != null) {
0554: t.set(scope + "." + getName() + "." + FILE_PATH,
0555: path);
0556: }
0557: String ext = media.getFilenameExtension();
0558: if (ext != null) {
0559: t
0560: .set(scope + "." + getName() + "."
0561: + FILE_EXT, ext);
0562: }
0563: String noExt = media.getFilenameWithoutExt();
0564: if (noExt != null) {
0565: t.set(scope + "." + getName() + "."
0566: + FILE_NAME_NOEXT, noExt);
0567: }
0568: } catch (SQLException e) {
0569: throw new Error(e.getMessage());
0570: }
0571: } else {
0572: // Upload ist im Filesystem
0573: CATEGORY.debug("Legacy im Filesystem");
0574: // Pfade relativ machen
0575: String fileName = (String) dataHash.get(FILENAME_PAR);
0576: if (fileName != null && fileName.length() > 0) {
0577: t.set(scope + "." + getName(), MediaManager
0578: .getRelativePath(((String) dataHash
0579: .get(BASEPATH_PAR))
0580: + fileName));
0581: }
0582: }
0583: }
0584:
0585: public int realInsertIntoDB(TKFormDBData db, int formId) {
0586: if (super .realInsertIntoDB(db, formId) == -1)
0587: return -1;
0588: insertNewFieldAttribute(db, formId, PIC_KEY, 0, String
0589: .valueOf(showPics));
0590: insertNewFieldAttribute(db, formId, DB_KEY, 0, String
0591: .valueOf(saveInDB));
0592: if (selectList != null) {
0593:
0594: int selectedSize = selectList.size();
0595: insertNewFieldAttribute(db, formId, SELECTLIST_SIZE, 0,
0596: String.valueOf(selectedSize));
0597:
0598: for (int i = 0; i < selectedSize; i++) {
0599: insertNewFieldAttribute(db, formId, MIME_KEY, i,
0600: selectList.elementAt(i).toString());
0601: }
0602:
0603: }
0604: return fieldId;
0605: }
0606:
0607: public void initFromDB(String classId, TKFormDBData db,
0608: TKVector otherFields) throws TKUnregisteredClassException,
0609: ClassNotFoundException, InstantiationException,
0610: IllegalAccessException {
0611:
0612: super .initFromDB(classId, db, otherFields);
0613:
0614: //---- inifile einlesen ----//
0615: TKUploadFieldIni.readIniFile();
0616: showPics = true;
0617: saveInDB = true;
0618:
0619: if (hasFieldAttribute(db, PIC_KEY, 0)) {
0620: showPics = Boolean.valueOf(
0621: getFieldAttribute(db, PIC_KEY, 0)).booleanValue();
0622: }
0623: if (hasFieldAttribute(db, DB_KEY, 0)) {
0624: saveInDB = Boolean
0625: .valueOf(getFieldAttribute(db, DB_KEY, 0))
0626: .booleanValue();
0627: }
0628: if (hasFieldAttribute(db, SELECTLIST_SIZE, 0)) {
0629: String sizeString = getFieldAttribute(db, SELECTLIST_SIZE,
0630: 0);
0631: int size = Integer.parseInt(sizeString);
0632:
0633: if (size == 0) {
0634: selectList = new TKVector();
0635: } else {
0636: selectList = new TKVector(size);
0637: for (int i = 0; i < size; i++) {
0638: String selectedValue = getFieldAttribute(db,
0639: MIME_KEY, i);
0640: selectList.addElement(selectedValue);
0641: }
0642: }
0643: } else {
0644: selectList = new TKVector();
0645: }
0646: }
0647:
0648: /**
0649: * Getter fuer saveInDB
0650: * @return werden die Uploads in die Datenbank gespeichert
0651: */
0652: public boolean isSaveInDB() {
0653: return saveInDB;
0654: }
0655:
0656: /*
0657: * Die realen Daten (Filename und Ablageverzeichnis) werden in der
0658: * datenbank gespeichert.
0659: *
0660: * @param db
0661: * @param data, Hasch mit den realen Daten Filename und Ablageverzeichnis
0662: * @param contetnID, interne ID
0663: * @param leftNr, aktuelle Knotennummer links
0664: *
0665: * @return leftNr+1, letzt Knotennummer links wird um 1 erhoeht
0666: *
0667: * @author Marwan (Erweiterung mediaID)
0668: */
0669: public int insertDataIntoDB(TKContentDBData db, Object data,
0670: int contentId, int leftNr) {
0671: TKContentNodeTableData node = insertNewContentNode(db,
0672: contentId, leftNr);
0673: int newNodeId = node.content_node_id;
0674: TKHashtable dataHash = (TKHashtable) data;
0675: String mediaIDstr = (String) dataHash.get(MEDIA_ID_PARNAME);
0676: if (mediaIDstr != null && !mediaIDstr.equals("")) {
0677: Integer _mediaID = new Integer(mediaIDstr);
0678: insertNewContentValue(db, contentId, newNodeId, 0, "",
0679: _mediaID);
0680:
0681: } else {// for downwards compatibility
0682: insertNewContentValue(db, contentId, newNodeId, 0,
0683: ((String) dataHash.get(BASEPATH_PAR))
0684: + (String) dataHash.get(FILENAME_PAR));
0685: }
0686: return leftNr + 1;
0687: }
0688:
0689: /*
0690: * Die in der Datenbank gespeicherten realen Daten (Filename und Ablageverzeichnis)
0691: * werden aus der DB geholt und un eine Hashtable abgelegt, die die interne
0692: * Repraesentation des Uploadfeldes bildet.
0693: * Desweiteren wird die Knotenstruktur wieder hergestellt.
0694: *
0695: * @param db
0696: *
0697: * @return result, haelt die realen Daten
0698: */
0699: public Object getDataFromDB(TKContentDBData db) {
0700: TKContentNodeTableData node = getContentNodeFromDB(db);
0701: TKHashtable result = new TKHashtable(1);
0702: TKContentValueTableData contentValueDat = getContentNodeValueFromDB(
0703: db, node);
0704:
0705: String path = contentValueDat.value;
0706: Integer _mediaID = contentValueDat.mediaID;
0707: // uploaded media is in the database
0708: if (_mediaID != null) {
0709: result.put(MEDIA_ID_PARNAME, _mediaID.toString());
0710: result.put(CONTENT_ID, String.valueOf(node.content_id));
0711: }
0712: // uploaded media is in the filesystem
0713: else {
0714:
0715: int idx = path.lastIndexOf("/");
0716: if (idx > 0) {
0717: result.put(FILENAME_PAR, path.substring(idx + 1));
0718: result.put(BASEPATH_PAR, path.substring(0, idx + 1));
0719: } else {
0720: result.put(FILENAME_PAR, path);
0721: }
0722: }
0723: return result;
0724: }
0725:
0726: /**
0727: * Diese Methode wird fuer die Bearbeitung des Events "EXT_MODIFY" fuer
0728: * ein Upload benoetigt.
0729: *
0730: * Diese Methode ermoeglicht es die Field-Hierachie zu durchlaufen.
0731: * Komplexe Fields enthalten Sub-Fields, die entweder Atomfields sind oder
0732: * wiederum Sub-Fields enthalten. Ist die Hierachie durchlaufen, wird das letzte
0733: * Basefield zurueckgegeben.
0734: * Siehe auch: doCTExtModify() in CTGenerator.java
0735: *
0736: * @param fieldPath
0737: * @param prefix
0738: * @param data
0739: *
0740: * @return das Objekt selbst
0741: */
0742: public TKBaseField getTarget(String fieldPath, String prefix,
0743: Object data) {
0744: prefix = prefix + fieldName;
0745: return this ;
0746: }
0747:
0748: /**
0749: * Wird das Upload aktiviert stehen zwei Funktionalitaeten zur Verfuegung:
0750: * 1. Hochladen eines Files vom Server. Auswahl ueber ein Pulldoenmenue.
0751: * Es existiert ein Verzeichnis, in dem Files zum hochladen liegen muessen.
0752: * Der Key UPBASE im Parameterhash gibt dieses an. Zuerst wird dieses Ver-
0753: * zeichnis eingelesen und die darinliegenden Dateien in das Pulldownmenue
0754: * eingetragen.
0755: *
0756: * 2. Hochladen eines Files vom lokalen Rechner
0757: *
0758: * Da zuerst ein Template (ce_upload.tmpl bzw ct_upload.tmpl) zur Auswahl der
0759: * Files angezeigt wird und erst nach abschicken der Auswahl das Template (field_upload.tmpl)
0760: * geladen wird, welches das UploadField anzeigt, werden die Parameter als Hidden-Liste
0761: * weitergegeben.
0762: *
0763: * @param action, die aktuelle Aktion, MODIFY
0764: * @param t, ct_upload.tmpl bzw. ce_upload.tmpl, Fileauseahlmoeglichkeiten
0765: * @param params, der Parameterhash
0766: * @param fieldPath, sas zuletzt ausgewaehlte File im Pulldownmenue
0767: */
0768: public File extModify(String action, TKHTMLTemplate t,
0769: TKHashtable params, String fieldPath) {
0770: File file = null; /* the File object representing an uploaded file */
0771:
0772: //if(action.equalsIgnoreCase("MODIFY")) {
0773:
0774: //------------------------------------------//
0775: //---- Es wurde nichts gespeichert ----//
0776: //------------------------------------------//
0777: if (action.equalsIgnoreCase("NOSAVE")
0778: || action.equalsIgnoreCase("BACK")) {
0779: params.remove(NEW_FILENAME);
0780: params.remove(GETFILENAMESTREAM);
0781: }
0782: if (!params.get(fieldPath).equals(""))
0783: t.set("GETFILENAME", params.get(fieldPath));
0784:
0785: //---- CLEAR PARAMS ----
0786: params = clearParams(params);
0787:
0788: //---- Basepath (UPBASE) ----//
0789: Object basePath = params.get(BASEPATH_PAR);
0790: if (basePath instanceof TKVector) {
0791: basePath = (String) ((TKVector) basePath).get(0);
0792: }
0793:
0794: //----- Physikalish: Seperator serten ----//
0795: String dir = setFileSep(documentRoot + basePath);
0796:
0797: //---- ausgewaehltes Bild wieder setzen ----//
0798: if (params.containsKey(GETFILENAME))
0799: t.set(GETFILENAME, params.get(GETFILENAME).toString());
0800: if (params.containsKey(GETEXTENSION))
0801: t.set(GETEXTENSION, params.get(GETEXTENSION).toString());
0802:
0803: //----- Inputfeld fuer Dateiangabe -----//
0804: t.set(BASEPATH_PAR, basePath);
0805:
0806: //---- TARGET kein Vector => params korrigieren ---//
0807: params.put(TARGET, fieldPath);
0808: t.set(TARGET, fieldPath);
0809:
0810: //---- ext und sel ----//
0811: TKVector extensionVector = new TKVector();
0812: TKVector selectedSections = new TKVector();
0813:
0814: //------------------------------------------//
0815: //---- ACTION = DELETE ----//
0816: //------------------------------------------//
0817: /*
0818: if(action.equalsIgnoreCase("DELETE")) {
0819: String fileName = getFilenameAndPath( params, dir);
0820: File deleteFile = new File(fileName);
0821: deleteFile.delete();
0822: }
0823: */
0824: //------------------------------------------//
0825: //---- ACTION = SHOWFILE ----//
0826: //------------------------------------------//
0827: if (action.equalsIgnoreCase("SHOWFILE")) {
0828: String fileName = getFilename(params);
0829: boolean isImage = isMimeImage(fileName,
0830: TKUploadFieldIni.iniHash);
0831: boolean isApplication = isMimeApplication(fileName,
0832: TKUploadFieldIni.iniHash);
0833:
0834: t.set("SHOWFILE", Boolean.TRUE);
0835: t.set("FILENAME", basePath + fileName);
0836:
0837: if (isImage)
0838: t.set(IMAGE, Boolean.TRUE);
0839: else {
0840: if (isApplication)
0841: t.set(APPLICATION, Boolean.TRUE);
0842:
0843: }
0844: }
0845: if (action.equalsIgnoreCase("UPLOAD")) {
0846:
0847: /* the old MEDIA_ID must not be set into the template */
0848:
0849: //Object oldMediaID = params.remove( fieldPath+"."+MEDIA_ID_PARNAME);
0850: params.remove(fieldPath + "." + MEDIA_ID_PARNAME);
0851:
0852: handleUpload(t, params, dir, action);
0853: }
0854: if (params.containsKey(GETEXTENSION)) {
0855: String content = params.get(GETEXTENSION).toString();
0856: extensionVector = getSpecialExt(content);
0857: } else {
0858: extensionVector = getFilesOfBeginning(selectList);
0859: }
0860: //----- Zusatzmimeliste ----//
0861: //TKVector mimeList = new TKVector();
0862: TKVector mimeListArray[] = null;
0863:
0864: if (selectList.isEmpty() || selectList.contains("ALL")) {
0865: mimeListArray = getMimeAuswahlListeAll("ALL");
0866: } else {
0867: mimeListArray = getMimeAuswahlListe(selectList);
0868: }
0869:
0870: //----- Files im Directory auslesen ----//
0871: String fileList[] = getFileList(dir, extensionVector);
0872:
0873: //---- Ueberschrift ----//
0874: TKVector chosedSections = new TKVector();
0875: chosedSections = selectedSections;
0876:
0877: //---- ERROR - keine files auf server gefunden ----//
0878: if (fileList.length == 0)
0879: setErrorCase(t, "EXTENSION_ERROR");
0880:
0881: //---- Parameter Hidden) in key-Value-Vector speichern ----//
0882: TKVector keyVector = new TKVector();
0883: TKVector valVector = new TKVector();
0884: saveParamsInVector(params, valVector, keyVector);
0885:
0886: //------------------------------------------//
0887: //---- ITERATOR ----//
0888: //------------------------------------------//
0889: t.setListIterator(new TKUploadIterator(extensionVector,
0890: mimeListArray, fileList, keyVector, valVector, t
0891: .getListIterator(), "PARAMLIST", "FILELIST",
0892: "MIMELIST", "EXT_ERROR_LIST"));
0893: return file;
0894: }//end extModify
0895:
0896: /**
0897: */
0898: public void handleUpload(TKHTMLTemplate t, TKHashtable params,
0899: String dir, String action) {
0900: /*
0901: t.set( "IS_SAVE",Boolean.TRUE );
0902: TKUploadFileInputStream fileInputStr = ((TKUploadFileInputStream)params.get( GETFILENAMESTREAM ));
0903: TKHashtable header = fileInputStr.getUploadHeader();
0904: String contentType = (String) header.get(CONTENT_TYPE);
0905:
0906: //---- ein neuer dateiname wurde eingegeben ----//
0907: String newFileName = "";
0908: if(!params.get("NEW_FILENAME").toString().equals("")) {
0909: newFileName = params.get("NEW_FILENAME").toString();
0910:
0911: //TKHashtable header = fileInputStr.getUploadHeader();
0912: //String contentType = (String) header.get(CONTENT_TYPE);
0913: String[] fileArray = getNameAndExt(newFileName, contentType);
0914: String onlyName = fileArray[0];
0915: String fileExt = fileArray[1];
0916: newFileName = onlyName+"."+fileExt;
0917:
0918: newFileName = checkFileName(newFileName);
0919: params.put(NEW_FILENAME, newFileName);
0920: }
0921:
0922: if( !fileInputStr.getUploadFileName().equals("") ){
0923: TKHashtable checkHash = checkUpload(params, dir, action);
0924: if(checkHash.get("SAVE").equals("TRUE") ) {
0925: t.set( "NOERROR",Boolean.TRUE );
0926: t.set("UPLOADED_FILENAME", fileInputStr.getUploadFileName() );
0927: t.set( "FILENAME", params.get("NEW_FILENAME"));
0928:
0929:
0930: }
0931: else {
0932: t.set( "FILENAME", checkHash.get("FILENAME"));
0933: }
0934: }
0935: else {
0936: t.set( "NO_SELECTION", Boolean.TRUE);
0937:
0938: }
0939:
0940: return;
0941: */
0942: }
0943:
0944: /**
0945: * UPLOAD => korrektheit mime und dateiende pruefen
0946: */
0947: public TKHashtable checkUpload(TKHashtable params, String dir,
0948: String action) {
0949: TKHashtable ergebnisHash = new TKHashtable();
0950:
0951: TKUploadFileInputStream fileInputStr = ((TKUploadFileInputStream) params
0952: .get(GETFILENAMESTREAM));
0953:
0954: //---- falls Dir noch nicht da => anlegen ----//
0955: createDir(dir);
0956:
0957: //---- uploadpath dose. C:\..\x.y oder neuer dateiname ----//
0958: String fileName;
0959: if (params.get(NEW_FILENAME).equals("")) {
0960: fileName = fileInputStr.getUploadFileName();
0961: fileName = splitBrowserFileName(fileName);
0962: } else {
0963: fileName = params.get(NEW_FILENAME).toString();
0964: }
0965:
0966: //---- mimetype pruefen ----//
0967: TKHashtable header = fileInputStr.getUploadHeader();
0968: String contentType = (String) header.get(CONTENT_TYPE);
0969:
0970: String[] fileArray = getNameAndExt(fileName, contentType);
0971:
0972: String onlyName = fileArray[0];
0973: String fileExt = fileArray[1];
0974: fileName = onlyName + "." + fileExt;
0975:
0976: //---- get section von contentType ----//
0977: String section = "";
0978: if (contentType != null) {
0979: int idx = contentType.indexOf("/");
0980: section = contentType.substring(0, idx);
0981: }
0982:
0983: //---- selected mime ueberpruefen ----//
0984: boolean mimeOk = false;
0985: boolean save = false;
0986:
0987: //----------------------------------------------------------//
0988: //---- stimmt der mimetype des hochgeladenen mit dem ----//
0989: //---- ausgewaehlten ueberein ???? ----//
0990: //----------------------------------------------------------//
0991: boolean isExt = isExtension(fileExt);
0992: mimeOk = compareMimes(contentType);
0993:
0994: if (mimeOk && isExt) {
0995: params.put("NEW_FILENAME", fileName);
0996: save = true;
0997: }
0998:
0999: else if (mimeOk && !isExt) {
1000: fileName = changeExtension(fileName, contentType);
1001: params.put("NEW_FILENAME", fileName);
1002: save = true;
1003:
1004: } else if (!mimeOk && isExt) {
1005: fileName = getNewFileName(fileName);
1006: params.put("NEW_FILENAME", fileName);
1007: save = true;
1008:
1009: }
1010:
1011: //----------------------------------------------------------//
1012: //---- Ergebnis fuer das Template in einen Hash setzen ----//
1013: //----------------------------------------------------------//
1014: if (save)
1015: ergebnisHash.put("SAVE", "TRUE");
1016: else
1017: ergebnisHash.put("SAVE", "FALSE");
1018:
1019: ergebnisHash.put("FILENAME", toFilename(fileName));
1020: return ergebnisHash;
1021: }
1022:
1023: /**
1024: */
1025: public TKVector getSpecialExt(String content) {
1026: TKVector selList = new TKVector();
1027: selList.addElement(content);
1028: TKVector extensionVector = null;
1029:
1030: extensionVector = getFilesOfBeginning(selList);
1031:
1032: return extensionVector;
1033:
1034: }
1035:
1036: /**
1037: */
1038: public TKVector getFilesOfBeginning(TKVector selectList) {
1039: TKVector extensionVector = new TKVector();
1040:
1041: if (selectList.isEmpty() || selectList.contains("ALL")) {
1042: TKVector sectionVector = getAllSections(TKUploadFieldIni.iniHash);
1043: for (int i = 0; i < sectionVector.size(); i++) {
1044: TKVector valVector = getSectionVals(sectionVector
1045: .elementAt(i).toString(),
1046: TKUploadFieldIni.iniHash);
1047: //TKVector keyVector = getSectionKeys(sectionVector.elementAt(i).toString(), TKUploadFieldIni.iniHash);
1048: for (int j = 0; j < valVector.size(); j++) {
1049: extensionVector.concat(splitSectionVals(valVector,
1050: VAL_SEP));
1051: }
1052: }
1053: } else {
1054: for (int i = 0; i < selectList.size(); i++) {
1055: String element = selectList.elementAt(i).toString();
1056:
1057: int sepIdx = element.indexOf("/");
1058: if (sepIdx == -1) {
1059: TKVector valVector = getSectionVals(element,
1060: TKUploadFieldIni.iniHash);
1061: extensionVector.concat(splitSectionVals(valVector,
1062: VAL_SEP));
1063: } else {
1064: String section = element.substring(0, sepIdx)
1065: .toUpperCase();
1066:
1067: TKVector keyVector = getSectionKeys(section,
1068: TKUploadFieldIni.iniHash);
1069: TKVector valVector = getSectionVals(section,
1070: TKUploadFieldIni.iniHash);
1071:
1072: for (int j = 0; j < keyVector.size(); j++) {
1073: if (keyVector.elementAt(j).equals(element))
1074: extensionVector.concat((getExtensions(
1075: valVector.elementAt(j).toString(),
1076: VAL_SEP)));
1077: }
1078: }
1079: }
1080: }
1081: return extensionVector;
1082: }
1083:
1084: /**
1085: */
1086: public TKVector[] getMimeAuswahlListe(TKVector selectList) {
1087: TKVector mimeOptions = new TKVector();
1088: TKVector mimeOptionKey = new TKVector();
1089:
1090: for (int i = 0; i < selectList.size(); i++) {
1091: if ((selectList.elementAt(i).toString()).indexOf("/") == -1) {
1092:
1093: mimeOptions.addElement(selectList.elementAt(i));
1094: mimeOptions.concat(getSectionKeys(selectList.elementAt(
1095: i).toString(), TKUploadFieldIni.iniHash));
1096: mimeOptionKey.addElement(selectList.elementAt(i));
1097: TKVector help = getSectionKeys(selectList.elementAt(i)
1098: .toString(), TKUploadFieldIni.iniHash);
1099: for (int x = 0; x < help.size(); x++) {
1100: mimeOptionKey.addElement("---" + help.elementAt(x));
1101: }
1102: } else {
1103: mimeOptions.addElement(selectList.elementAt(i));
1104: mimeOptionKey.addElement(selectList.elementAt(i));
1105: }
1106:
1107: }
1108:
1109: //return mimeOptions;
1110: TKVector mime[] = { mimeOptionKey, mimeOptions };
1111: return mime;
1112:
1113: }
1114:
1115: //***************************************************************************
1116: /**
1117: */
1118: public TKVector[] getMimeAuswahlListeAll(String section) {
1119:
1120: TKVector mimeOptions = new TKVector();
1121: TKVector mimeOptionKey = new TKVector();
1122:
1123: if (section.equals("ALL")) {
1124: mimeOptions.addElement("ALL");
1125: mimeOptionKey.addElement("ALL");
1126:
1127: Enumeration sectionEnum = TKUploadFieldIni.iniHash.keys();
1128: while (sectionEnum.hasMoreElements()) {
1129: String key = (String) sectionEnum.nextElement();
1130: mimeOptions.addElement(key);
1131: mimeOptionKey.addElement(key);
1132:
1133: TKHashtable contentHash = (TKHashtable) TKUploadFieldIni.iniHash
1134: .get(key);
1135:
1136: Enumeration contentEnum = contentHash.keys();
1137: while (contentEnum.hasMoreElements()) {
1138: String contentKey = (String) contentEnum
1139: .nextElement();
1140: //String contentVal = (String) contentHash.get(contentKey);
1141: mimeOptions.addElement(contentKey);
1142: mimeOptionKey.addElement("---" + contentKey);
1143: }
1144: }
1145: }
1146:
1147: TKVector mime[] = { mimeOptionKey, mimeOptions };
1148: return mime;
1149:
1150: }
1151:
1152: /**
1153: * Bsp filename vom browser: C:\..\x.y
1154: */
1155: public String splitBrowserFileName(String fileName) {
1156: int lastDosenIdx = fileName.lastIndexOf("\\");
1157: int lastUnixIdx = fileName.lastIndexOf("/");
1158: if (lastDosenIdx > -1) {
1159: fileName = fileName.substring(lastDosenIdx + 1);
1160: } else {
1161: fileName = fileName.substring(lastUnixIdx + 1);
1162: }
1163:
1164: return fileName;
1165: }
1166:
1167: /**
1168: */
1169: public void createDir(String dir) {
1170: File uploadDir = new File(dir);
1171: if (!uploadDir.exists())
1172: uploadDir.mkdirs();
1173:
1174: }
1175:
1176: /**
1177: */
1178: public TKHashtable clearParams(TKHashtable params) {
1179:
1180: if ((params.containsKey(GETFILENAME))
1181: && (!params.get(GETFILENAME).equals(""))) {
1182: if (params.get(GETFILENAME) instanceof TKVector) {
1183: TKVector getFiles = (TKVector) params.get(GETFILENAME);
1184: params.put(GETFILENAME, getFiles.elementAt(0));
1185: }
1186: }
1187:
1188: if ((params.containsKey(NEW_FILENAME))
1189: && (!params.get(NEW_FILENAME).equals(""))) {
1190: if (params.get(NEW_FILENAME) instanceof TKVector) {
1191: TKVector getFiles = (TKVector) params.get(NEW_FILENAME);
1192: params.put(NEW_FILENAME, getFiles.elementAt(0));
1193: }
1194: }
1195:
1196: if ((params.containsKey(GETFILENAMESTREAM))
1197: && (!params.get(GETFILENAMESTREAM).equals(""))) {
1198: if (params.get(GETFILENAMESTREAM) instanceof TKVector) {
1199: TKVector getFiles = (TKVector) params
1200: .get(GETFILENAMESTREAM);
1201: params.put(GETFILENAMESTREAM, getFiles.elementAt(0));
1202: }
1203: }
1204:
1205: if ((params.containsKey(GETEXTENSION))
1206: && (!params.get(GETEXTENSION).equals(""))) {
1207: if (params.get(GETEXTENSION) instanceof TKVector) {
1208: TKVector getFiles = (TKVector) params.get(GETEXTENSION);
1209: params.put(GETEXTENSION, getFiles.elementAt(0));
1210: }
1211: }
1212:
1213: Object basePath = params.get(BASEPATH_PAR);
1214: if (basePath instanceof TKVector) {
1215: //basePath = (String) ((TKVector) basePath).get(0);
1216: params.put(BASEPATH_PAR, (String) ((TKVector) basePath)
1217: .get(0));
1218:
1219: }
1220:
1221: return params;
1222: }
1223:
1224: /**
1225: */
1226: public String getFilenameAndPath(TKHashtable params, String dir) {
1227: String fileName = "";
1228: if (!params.get("GETFILENAME").toString().equals("")) {
1229: fileName = dir + params.get("GETFILENAME").toString();
1230: }
1231:
1232: return fileName;
1233: }
1234:
1235: /**
1236: */
1237: public String getFilename(TKHashtable params) {
1238: String fileName = "";
1239:
1240: if (!params.get("GETFILENAME").toString().equals("")) {
1241: fileName = params.get("GETFILENAME").toString();
1242: }
1243:
1244: return fileName;
1245: }
1246:
1247: /**
1248: * ERROR - keine files auf server gefunden
1249: */
1250: public void setErrorCase(TKHTMLTemplate t, String name) {
1251: t.set(name, Boolean.TRUE);
1252: }
1253:
1254: /**
1255: * Dateien auf de server
1256: */
1257: public String[] getFileList(String dir, TKVector extensionVector) {
1258: String fileList[] = {};
1259:
1260: File readDir = new File(dir);
1261: if ((readDir.exists()) && (readDir.isDirectory())) {
1262: fileList = readDir.list(new TKUploadFilenameFilter(
1263: extensionVector));
1264:
1265: }
1266: return fileList;
1267: }
1268:
1269: /**
1270: * Zusatzauswahlliste
1271: */
1272: public TKVector getMimeList(TKVector selectedSections) {
1273: TKVector mimeList = new TKVector();
1274:
1275: for (int i = 0; i < selectedSections.size(); i++) {
1276: String element = (String) selectedSections.elementAt(i);
1277: TKVector allToOneMime = getAllFromMime(element);
1278: mimeList.concat(allToOneMime);
1279: }
1280:
1281: return mimeList;
1282: }
1283:
1284: /**
1285: * Paraeter werden in einer liste als Hidden weitergegeben
1286: */
1287: public void saveParamsInVector( TKHashtable params, TKVector valVector, TKVector keyVector)
1288: {
1289: Enumeration enum = params.keys();
1290: while(enum.hasMoreElements()) {
1291: String key = (String) enum.nextElement();
1292: Object val = params.get(key);
1293:
1294: // we ignore the CHECKER parameter here, since it should always
1295: // appear as _last_ parameter of a request.
1296: // Must be set explictily in the template!
1297: if (key.equals("CHECKER")) {
1298: continue;
1299: }
1300:
1301: if (val instanceof TKVector) {
1302:
1303: Enumeration ee = ((TKVector) val).elements();
1304: while(ee.hasMoreElements()) {
1305: keyVector.addElement(key);
1306: valVector.addElement(ee.nextElement());
1307: }
1308:
1309: } else {
1310: keyVector.addElement(key);
1311: valVector.addElement(val);
1312: }
1313: }
1314: }
1315:
1316: public String setFileSep(String dir) {
1317: String fileSep = File.separator;
1318:
1319: //---- "/" wird durch "\" ersetzt falls noetig ----//
1320: if (!fileSep.equals(URL_SEP)) {
1321: TKVector tokenVector = new TKVector();
1322:
1323: StringTokenizer getToken = new StringTokenizer(dir, URL_SEP);
1324: while (getToken.hasMoreElements()) {
1325: String aToken = (String) getToken.nextElement();
1326: tokenVector.addElement(aToken);
1327: }
1328:
1329: String newDir = fileSep;
1330: for (int i = 0; i < tokenVector.size(); i++) {
1331: String token = (String) tokenVector.elementAt(i);
1332: newDir = newDir + token + fileSep;
1333:
1334: }
1335: return newDir;
1336: } else {
1337: return dir;
1338: }
1339: }
1340:
1341: public boolean isMimeImage(String fileName, TKHashtable iniHash) {
1342:
1343: String sep = ".";
1344: int sepIdx = fileName.lastIndexOf(sep);
1345: String fileExt = fileName.substring(sepIdx + 1,
1346: fileName.length()).toLowerCase();
1347:
1348: //---- alle vals von der Section IMAGE ----//
1349: TKVector valVector = getSectionVals(IMAGE, iniHash);
1350: TKVector extensionVector = splitSectionVals(valVector, VAL_SEP);
1351:
1352: return extensionVector.contains(fileExt);
1353: }
1354:
1355: public boolean isMimeApplication(String fileName,
1356: TKHashtable iniHash) {
1357:
1358: String sep = ".";
1359: int sepIdx = fileName.lastIndexOf(sep);
1360: String fileExt = fileName.substring(sepIdx + 1, fileName
1361: .length());
1362:
1363: //---- alle vals von der Section IMAGE ----//
1364: TKVector valVector = getSectionVals(APPLICATION, iniHash);
1365: TKVector extensionVector = splitSectionVals(valVector, VAL_SEP);
1366:
1367: return extensionVector.contains(fileExt);
1368: }
1369:
1370: //***************************************************************************
1371: public TKVector splitSectionVals(TKVector valVector, String sep) {
1372: TKVector extensionVector = new TKVector();
1373:
1374: for (int i = 0; i < valVector.size(); i++) {
1375: String element = (String) valVector.elementAt(i);
1376:
1377: int sepIdx = element.indexOf(sep);
1378:
1379: //---- mehrere Dateiendung ----//
1380: if (sepIdx > -1)
1381: //extensionVector.concat( getExtensions(element,sep , sepIdx) );
1382: extensionVector.concat(getExtensions(element, sep));
1383: else
1384: extensionVector.addElement(element);
1385: }
1386: return extensionVector;
1387:
1388: }
1389:
1390: public TKVector getSectionVals(String section, TKHashtable iniHash) {
1391:
1392: TKVector valVector = new TKVector();
1393: TKHashtable contentHash = (TKHashtable) iniHash.get(section
1394: .toUpperCase());
1395: Enumeration contentEnum = contentHash.keys();
1396: while (contentEnum.hasMoreElements()) {
1397: String contentKey = (String) contentEnum.nextElement();
1398: String contentVal = (String) contentHash.get(contentKey);
1399: valVector.addElement(contentVal);
1400: }
1401:
1402: return valVector;
1403: }
1404:
1405: public TKVector getSectionKeys(String section, TKHashtable iniHash) {
1406:
1407: TKVector keyVector = new TKVector();
1408: TKHashtable contentHash = (TKHashtable) iniHash.get(section
1409: .toUpperCase());
1410:
1411: if (contentHash != null) {
1412: Enumeration contentEnum = contentHash.keys();
1413: while (contentEnum.hasMoreElements()) {
1414: String contentKey = (String) contentEnum.nextElement();
1415: keyVector.addElement(contentKey);
1416: }
1417: }
1418: return keyVector;
1419: }
1420:
1421: public TKVector getAllSections(TKHashtable iniHash) {
1422:
1423: TKVector sectionVector = new TKVector();
1424: Enumeration sectionEnum = iniHash.keys();
1425: while (sectionEnum.hasMoreElements()) {
1426: String sectionKey = (String) sectionEnum.nextElement();
1427: sectionVector.addElement(sectionKey);
1428: }
1429:
1430: return sectionVector;
1431: }
1432:
1433: public TKVector getExtensions(String extensions, String valSep) {
1434: TKVector extensionVector = new TKVector();
1435:
1436: //---- Liste mit extendions (htm,html) ----//
1437: if (extensions.indexOf(valSep) > -1) {
1438: StringTokenizer getToken = new StringTokenizer(extensions,
1439: valSep);
1440: while (getToken.hasMoreElements()) {
1441: extensionVector.addElement(getToken.nextElement());
1442: }
1443: }
1444: //---- genau eine extension ----//
1445: else {
1446: extensionVector.addElement(extensions);
1447: }
1448: return extensionVector;
1449: }
1450:
1451: public TKVector getAllFromMime(String section) {
1452: //---- eine Section filern ----//
1453: TKVector mimeVector = new TKVector();
1454:
1455: //Enumeration sectionEnum = TKUploadFieldIni.iniHash.keys();
1456: TKHashtable contentHash = (TKHashtable) TKUploadFieldIni.iniHash
1457: .get(section);
1458:
1459: Enumeration contentEnum = contentHash.keys();
1460: while (contentEnum.hasMoreElements()) {
1461: String contentKey = (String) contentEnum.nextElement();
1462: String contentVal = (String) contentHash.get(contentKey);
1463: mimeVector.addElement(contentVal);
1464: }
1465: TKVector extensionVector = new TKVector();
1466: for (int i = 0; i < mimeVector.size(); i++) {
1467: String element = (String) mimeVector.elementAt(i);
1468:
1469: //int sepIdx = element.indexOf(VAL_SEP);
1470: extensionVector.concat(getExtensions(element, VAL_SEP));
1471: }
1472:
1473: return extensionVector;
1474: }
1475:
1476: /**
1477: * Ein ausgewaehltes File vom server werden so in den Parameterhash aufgenommen,
1478: * so dass sie (siehe compileData) angezeigt werden.
1479: * Wurde ein File vom Server ausgewaehlt, so enthaelt der Parameter GETFILENAME
1480: * den hochzuladenden Dateinamen und kann direkt angezeigt werden.
1481: *
1482: * Win hochgeladenes File vom lokalen Rechner wird zuerst in einem temporaeren
1483: * Verzeichnis gespeichert und danach in das altuelle UPBASE-Verzeichnis.
1484: * Wurde ein File vom lokalen Rechner hochgeladen, so enthaelt der Parameter ein
1485: * Objekt vom Typ TKUploadFileInputStream (abgeleitet von TKFileInputStream). Die
1486: * Methode getUploadFileName() gibt Laufwerksname-Pfad-Dateiname zurueck, so dass
1487: * der Dateiname ermittelt werden kann. Der Parameter NEW_FILENAME enthaelt, falls
1488: * eingegeben, den neuern Dateinamen.
1489: *
1490: * @param action, die aktuelle Aktion, UPLOAD oder GETFILE
1491: * @param params, der Parameterhash
1492: *
1493: * @return den Parameterhash
1494: */
1495: public TKHashtable finishExtModify(String action, TKHashtable params) {
1496: params = clearParams(params);
1497:
1498: //----------------------------------------------------------//
1499: //---- Kein File laden (anfangszustand) ----//
1500: //----------------------------------------------------------//
1501: if (action.equalsIgnoreCase("NOUPLOAD")) {
1502: String fileName = "";
1503: params = setFileName(fileName, params);
1504:
1505: }
1506:
1507: //----------------------------------------------------------//
1508: //---- File wird vom Server geladen ACTION = GETFILE ----//
1509: //----------------------------------------------------------//
1510: if (action.equalsIgnoreCase("GETFILE")) {
1511:
1512: String fileName = ((String) params.get(GETFILENAME));
1513: params = setFileName(fileName, params);
1514: getExtension = ((String) params.get(GETEXTENSION));
1515:
1516: }
1517:
1518: //------------------------------------------------------------------//
1519: //---- File wird vom lokalen Rechner auf dem Server gespeichert ----//
1520: //---- ACTION = SAVE ----//
1521: //------------------------------------------------------------------//
1522: if (action.equals("SAVE")) {
1523:
1524: //---- filename ----//
1525: String fileName = params.get("NEW_FILENAME").toString();
1526: //****************
1527: params = setFileName(fileName, params);
1528: //****************
1529:
1530: //---- Basepath (UPBASE) ----//
1531: Object basePath = params.get(BASEPATH_PAR);
1532: if (basePath instanceof TKVector) {
1533: basePath = (String) ((TKVector) basePath).get(0);
1534: }
1535:
1536: //----- Physikalish: Seperator setzen ----//
1537: //String dir = setFileSep( documentRoot+basePath);
1538:
1539: //marwan
1540: /*
1541: File tempFile = new File( TEMPPATH+fileName );
1542: try {
1543:
1544: TKUploadFileInputStream fileInputStr = new TKUploadFileInputStream( tempFile, fileName, new TKHashtable() );
1545: fileInputStr.saveAs( new File( dir+fileName ) );
1546: }
1547: catch (IOException e) {
1548: TKHttp.out().println("<br><b>ERROR: </b>" + e);
1549: }
1550:
1551: tempFile.delete();
1552: */
1553: }
1554:
1555: return params;
1556: }
1557:
1558: public void saveToFilesystem(TKHashtable params, File tempFile,
1559: String fileName) throws IOException {
1560: // params = clearParams(params);
1561: //---- filename ----//
1562: params = setFileName(fileName, params);
1563:
1564: //---- Basepath (UPBASE) ----//
1565: Object basePath = params.get(BASEPATH_PAR);
1566: if (basePath instanceof TKVector) {
1567: basePath = (String) ((TKVector) basePath).get(0);
1568: }
1569:
1570: //----- Physikalisch: Separator setzen ----//
1571: String dir = setFileSep(documentRoot + basePath);
1572:
1573: File baseDir = new File(dir);
1574: if (!baseDir.exists())
1575: baseDir.mkdirs();
1576:
1577: TKUploadFileInputStream fileInputStr = new TKUploadFileInputStream(
1578: tempFile, fileName, new TKHashtable());
1579: fileInputStr.saveAs(new File(dir + fileName));
1580: tempFile.delete();
1581:
1582: }
1583:
1584: public String[] getNameAndExt(String fileName, String contentType) {
1585:
1586: String fileArray[] = { "", "" };
1587: if (!fileName.equals("")) {
1588: //---- filename mit extension ----//
1589: if (fileName.lastIndexOf(".") >= 1) {
1590: int sepIdx = fileName.lastIndexOf(".");
1591: String fileExt = fileName.substring(sepIdx + 1,
1592: fileName.length());
1593: String name = fileName.substring(0, sepIdx);
1594: fileArray[0] = name;
1595: fileArray[1] = fileExt;
1596: }
1597: //---- filename ohne extension ----//
1598: else {
1599: String newName = addExtension(fileName, contentType);
1600: return (getNameAndExt(newName, contentType));
1601: }
1602: }
1603: return (fileArray);
1604:
1605: }
1606:
1607: public boolean isExtension(String extension) {
1608: boolean isExt = false;
1609:
1610: //----------------------------------------------------------------//
1611: //---- ALL ----//
1612: //----------------------------------------------------------------//
1613: if (selectList.isEmpty() || selectList.contains("ALL")) {
1614: TKVector sectionVector = getAllSections(TKUploadFieldIni.iniHash);
1615:
1616: for (int i = 0; i < sectionVector.size(); i++) {
1617: TKVector valVector = getSectionVals(sectionVector
1618: .elementAt(i).toString(),
1619: TKUploadFieldIni.iniHash);
1620:
1621: for (int j = 0; j < valVector.size(); j++) {
1622: TKVector extVector = splitSectionVals(valVector,
1623: VAL_SEP);
1624: if (extVector.contains(extension))
1625: isExt = true;
1626: }
1627: }
1628: return isExt;
1629: }
1630: //----------------------------------------------------------------//
1631: //---- ist die extension ok? ----//
1632: //----------------------------------------------------------------//
1633: for (int x = 0; x < selectList.size(); x++) {
1634: String selectElement = selectList.elementAt(x).toString();
1635:
1636: int splitSelectIdx = selectElement.indexOf("/");
1637:
1638: //---- Allgemeiner mimetype Selected ----//
1639: if (splitSelectIdx == -1) {
1640: TKVector valVector = getSectionVals(selectElement,
1641: TKUploadFieldIni.iniHash);
1642:
1643: TKVector extVector = splitSectionVals(valVector,
1644: VAL_SEP);
1645: if (extVector.contains(extension))
1646: isExt = true;
1647: }
1648: //---- Spezieller mimetype selected ----//
1649: else {
1650: String section = selectElement.substring(0,
1651: splitSelectIdx);
1652: TKVector valVector = getSectionVals(section,
1653: TKUploadFieldIni.iniHash);
1654: TKVector keyVector = getSectionKeys(section,
1655: TKUploadFieldIni.iniHash);
1656: if (keyVector.contains(selectElement)) {
1657: int idx = keyVector.indexOf(selectElement);
1658: TKVector extVector = getExtensions(valVector
1659: .elementAt(idx).toString(), VAL_SEP);
1660:
1661: if (extVector.contains(extension))
1662: isExt = true;
1663: }
1664: }
1665: }
1666:
1667: return isExt;
1668: }
1669:
1670: //***************************************************************************
1671: public boolean compareMimes(String contentType) {
1672: if (contentType == null)
1673: return false;
1674: boolean isCompareOk = false;
1675: contentType = contentType.toLowerCase();
1676:
1677: //----------------------------------------------------------------//
1678: //---- ALL ----//
1679: //----------------------------------------------------------------//
1680: if (selectList.isEmpty() || selectList.contains("ALL")) {
1681: TKVector sectionVector = getAllSections(TKUploadFieldIni.iniHash);
1682:
1683: for (int i = 0; i < sectionVector.size(); i++) {
1684: TKVector keyVector = getSectionKeys(sectionVector
1685: .elementAt(i).toString(),
1686: TKUploadFieldIni.iniHash);
1687:
1688: for (int j = 0; j < keyVector.size(); j++) {
1689: String selectedMime = keyVector.elementAt(j)
1690: .toString().toLowerCase();
1691: if (selectedMime.equals(contentType))
1692: isCompareOk = true;
1693: }
1694: }
1695: return isCompareOk;
1696: }
1697:
1698: //----------------------------------------------------------------//
1699: //---- ist der mime des hochgeladenen files in der selectList? ----//
1700: //----------------------------------------------------------------//
1701: for (int x = 0; x < selectList.size(); x++) {
1702: String selectElement = selectList.elementAt(x).toString()
1703: .toLowerCase();
1704:
1705: int splitSelectIdx = selectElement.indexOf("/");
1706: //---- Allgemeiner mimetype Selected ----//
1707: if (splitSelectIdx == -1) {
1708: TKVector keyVector = getSectionKeys(selectElement,
1709: TKUploadFieldIni.iniHash);
1710: if (keyVector.contains(contentType)) {
1711: isCompareOk = true;
1712: }
1713: }
1714: //---- Spezieller mimetype selected ----//
1715: else {
1716: if (selectElement.equals(contentType))
1717: isCompareOk = true;
1718: }
1719: }
1720: return isCompareOk;
1721: }
1722:
1723: public String addExtension(String name, String contentType) {
1724: String newExt = "";
1725: TKVector sectionVector = getAllSections(TKUploadFieldIni.iniHash);
1726:
1727: for (int i = 0; i < sectionVector.size(); i++) {
1728: TKVector valVector = getSectionVals(sectionVector
1729: .elementAt(i).toString(), TKUploadFieldIni.iniHash);
1730: TKVector keyVector = getSectionKeys(sectionVector
1731: .elementAt(i).toString(), TKUploadFieldIni.iniHash);
1732:
1733: for (int j = 0; j < keyVector.size(); j++) {
1734: if (keyVector.elementAt(j).equals(contentType)) {
1735: TKVector extensionVector = getExtensions(valVector
1736: .elementAt(j).toString(), VAL_SEP);
1737: newExt = (String) extensionVector.elementAt(0);
1738: }
1739: }
1740: }
1741:
1742: return (name + "." + newExt);
1743: }
1744:
1745: public String changeExtension(String fileName, String contentType) {
1746: String newExt = "";
1747: contentType = contentType.toLowerCase();
1748:
1749: int sepIdx = fileName.lastIndexOf(".");
1750: //String fileExt = fileName.substring( sepIdx+1, fileName.length() );
1751: String name = fileName.substring(0, sepIdx);
1752:
1753: TKVector sectionVector = getAllSections(TKUploadFieldIni.iniHash);
1754:
1755: for (int i = 0; i < sectionVector.size(); i++) {
1756: TKVector valVector = getSectionVals(sectionVector
1757: .elementAt(i).toString(), TKUploadFieldIni.iniHash);
1758: TKVector keyVector = getSectionKeys(sectionVector
1759: .elementAt(i).toString(), TKUploadFieldIni.iniHash);
1760:
1761: for (int j = 0; j < keyVector.size(); j++) {
1762: if (keyVector.contains(contentType)) {
1763: int idx = keyVector.indexOf(contentType);
1764: TKVector extVector = getExtensions(valVector
1765: .elementAt(idx).toString(), VAL_SEP);
1766: newExt = extVector.elementAt(0).toString();
1767:
1768: }
1769: }
1770:
1771: }
1772: return (name + "." + newExt);
1773: }
1774:
1775: //***************************************************************************
1776: public String getNewFileName(String fileName) {
1777: String newExt = "";
1778:
1779: int sepIdx = fileName.lastIndexOf(".");
1780: String fileExt = fileName.substring(sepIdx + 1, fileName
1781: .length());
1782: String name = fileName.substring(0, sepIdx);
1783:
1784: TKVector sectionVector = getAllSections(TKUploadFieldIni.iniHash);
1785: for (int i = 0; i < sectionVector.size(); i++) {
1786: TKVector valVector = getSectionVals(sectionVector
1787: .elementAt(i).toString(), TKUploadFieldIni.iniHash);
1788:
1789: for (int j = 0; j < valVector.size(); j++) {
1790: TKVector extVector = getExtensions(valVector.elementAt(
1791: j).toString(), VAL_SEP);
1792: if (extVector.contains(fileExt))
1793: newExt = extVector.elementAt(0).toString();
1794:
1795: }
1796: }
1797: return (name + "." + newExt);
1798: }
1799:
1800: //***************************************************************************
1801:
1802: public static String checkFileName(String fileName) {
1803: fileName = toFilename(fileName);
1804: //String newFileName = "";
1805: char[] theChars = fileName.toCharArray();
1806:
1807: for (int i = 0; i < theChars.length; i++) {
1808:
1809: if (!(((theChars[i] >= 'A') && (theChars[i] <= 'Z'))
1810: || ((theChars[i] >= 'a') && (theChars[i] <= 'z')) || ((theChars[i] >= '0') && (theChars[i] <= '9')))
1811: && theChars[i] != '.') {
1812: theChars[i] = '_';
1813: }
1814: }
1815:
1816: return new String(theChars);
1817: }
1818:
1819: /**
1820: * Fixes the specified content type.
1821: * <P>
1822: * Opera browsers report the content type as follows:
1823: * <CODE>image/jpeg; name="image.jpeg"</CODE>. This
1824: * method simply cuts off these extensions.
1825: *
1826: * @param contentType the content type to be fixed.
1827: * @return the fixed content type.
1828: */
1829: public static String fixContentType(String contentType) {
1830: if (contentType != null) {
1831: int index = contentType.indexOf(';');
1832:
1833: if (index > -1) {
1834: return contentType.substring(0, index);
1835: }
1836: }
1837:
1838: return contentType;
1839: }
1840:
1841: /**
1842: * Überführt den String <name> in einen brauchbaren Dateinamen, d.h.
1843: * es werde spaces, Umlaute etc. ersetzt.
1844: */
1845: public static String toFilename(final String name) {
1846: final StringBuffer fname = new StringBuffer(name.length());
1847: final StringCharacterIterator iter = new StringCharacterIterator(
1848: name);
1849: for (char ch = iter.current(); ch != CharacterIterator.DONE; ch = iter
1850: .next()) {
1851: switch (ch) {
1852: case 'ä':
1853: fname.append("ae");
1854: break;
1855: case 'Ä':
1856: fname.append("Ae");
1857: break;
1858: case 'ö':
1859: fname.append("oe");
1860: break;
1861: case 'Ö':
1862: fname.append("Oe");
1863: break;
1864: case 'ü':
1865: fname.append("ue");
1866: break;
1867: case 'Ü':
1868: fname.append("Ue");
1869: break;
1870: case 'ß':
1871: fname.append("ss");
1872: break;
1873: case '_':
1874: default:
1875: if (Character.isWhitespace(ch)
1876: || Character.isISOControl(ch)
1877: || ch == File.separatorChar) {
1878: fname.append('_');
1879: } else {
1880: fname.append(ch);
1881: }
1882: break;
1883: }
1884: }
1885: return fname.toString();
1886: }
1887:
1888: /**
1889: * Hilfsmethode fuer finishExtModify
1890: *
1891: * @param fileName, das Upload-File
1892: * @param params, der Parameterhash
1893: *
1894: * @return den Parameterhash
1895: */
1896: public TKHashtable setFileName(String fileName, TKHashtable params) {
1897: //---- Bild auf der Seite anzeigen ----//
1898: params.put(FILENAME_PAR, fileName);
1899: Object prefix = (String) params.get(TARGET);
1900:
1901: if (prefix instanceof TKVector) {
1902: params.put(prefix, fileName);
1903: } else {
1904: params.put((String) prefix, fileName);
1905: }
1906:
1907: return params;
1908: }
1909:
1910: /*
1911: public void setMediaInterface(MediaInterface media){
1912: this.media = media;
1913: }
1914: */
1915:
1916: {
1917: // Check, if the temp-directory exists (might be missing for
1918: // MS-Windows), create it otherwise:
1919: File tempDir = new File(TEMPPATH);
1920: if (!tempDir.exists()) {
1921: tempDir.mkdirs();
1922: }
1923: }
1924:
1925: /**
1926: * Checks wether this object and the specified object
1927: * may be treated as equal.
1928: *
1929: * @param object the object to checked for equality.
1930: * @return <CODE>true</CODE> if this object and the
1931: * specified object may be treated as equal, otherwise
1932: * <CODE>false</CODE>.
1933: */
1934: public boolean equals(Object object) {
1935: if (!super .equals(object)) {
1936: return false;
1937: }
1938:
1939: TKUploadField field = (TKUploadField) object;
1940:
1941: return (this .length == field.length)
1942: && (this .size == field.size)
1943: && (this .showPics == field.showPics)
1944: && (this .selectList == null ? field.selectList == null
1945: : this .selectList.equals(field.selectList));
1946: }
1947:
1948: /**
1949: * Returns the hash code for this object.
1950: *
1951: * @return the hash code for this object.
1952: */
1953: public int hashCode() {
1954: // Implementation for JTest only ;-(
1955: return super.hashCode();
1956: }
1957:
1958: }
|