source/mir/entity/adapter/EntityAdapterDefinition.java

   1 /*
   2  * Copyright (C) 2001, 2002  The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with the com.oreilly.servlet library, any library
  22  * licensed under the Apache Software License, The Sun (tm) Java Advanced
  23  * Imaging library (JAI), The Sun JIMI library (or with modified versions of
  24  * the above that use the same license as the above), and distribute linked
  25  * combinations including the two.  You must obey the GNU General Public
  26  * License in all respects for all of the code used other than the above
  27  * mentioned libraries.  If you modify this file, you may extend this exception
  28  * to your version of the file, but you are not obligated to do so.  If you do
  29  * not wish to do so, delete this exception statement from your version.
  30  */
  31
  32 package mir.entity.adapter;
  33
  34 import java.util.Calendar;
  35 import java.util.Date;
  36 import java.util.GregorianCalendar;
  37 import java.util.HashMap;
  38 import java.util.Map;
  39
  40 import mir.entity.Entity;
  41 import mir.util.DateToMapAdapter;
  42
  43 public class EntityAdapterDefinition {
  44   Map calculatedFields;
  45
  46   public EntityAdapterDefinition() {
  47     calculatedFields = new HashMap();
  48   }
  49
  50   public EntityAdapter makeEntityAdapter(Entity anEntity, EntityAdapterModel aModel) {
  51     return new EntityAdapter(anEntity, this, aModel);
  52   }
  53
  54   public CalculatedField getCalculatedField(String aFieldName) {
  55     return (CalculatedField) calculatedFields.get(aFieldName);
  56   }
  57
  58   public boolean hasCalculatedField(String aFieldName) {
  59     return calculatedFields.containsKey(aFieldName);
  60   }
  61
  62   public void addCalculatedField(String aFieldName, CalculatedField aField) {
  63     calculatedFields.put(aFieldName, aField);
  64   }
  65
  66   public void addMirDateField(String aDestinationFieldName, String aSourceFieldName) {
  67     addCalculatedField(aDestinationFieldName, new MirDateField(aSourceFieldName));
  68   }
  69
  70   public void addDBDateField(String aDestinationFieldName, String aSourceFieldName) {
  71     addCalculatedField(aDestinationFieldName, new DBDateField(aSourceFieldName));
  72   }
  73
  74   public interface CalculatedField {
  75     public Object getValue(EntityAdapter anEntityAdapter);
  76   }
  77
  78   private class MirDateField implements CalculatedField {
  79     private String fieldName;
  80
  81     public MirDateField(String aFieldName) {
  82       fieldName = aFieldName;
  83     }
  84
  85     public Object getValue(EntityAdapter anEntityAdapter) {
  86
  87       Map result = new HashMap();
  88       String textValue = anEntityAdapter.getEntity().getValue(fieldName);
  89       Calendar calendar = GregorianCalendar.getInstance();
  90       int year;
  91       int month;
  92       int day;
  93       Date date;
  94
  95       if (textValue!=null) {
  96         try {
  97           year = Integer.parseInt(textValue.substring(0,4));
  98           month = Integer.parseInt(textValue.substring(4,6));
  99           day = Integer.parseInt(textValue.substring(6,8));
 100
 101           calendar.set(year, month-1, day);
 102           date = calendar.getTime();
 103           ;
 104
 105           result.put("date", date);
 106           result.put("formatted", new DateToMapAdapter(date));
 107
 108         }
 109         catch (Throwable t) {
 110           result=null;
 111         }
 112       }
 113       return result;
 114     }
 115   }
 116
 117   private class DBDateField implements CalculatedField {
 118     private String fieldName;
 119
 120     public DBDateField(String aFieldName) {
 121       fieldName = aFieldName;
 122     }
 123
 124     public Object getValue(EntityAdapter anEntityAdapter) {
 125
 126       Map result = new HashMap();
 127       String textValue = anEntityAdapter.getEntity().getValue(fieldName);
 128       Calendar calendar = GregorianCalendar.getInstance();
 129       int year;
 130       int month;
 131       int day;
 132       int hours;
 133       int minutes;
 134
 135       Date date;
 136
 137       if (textValue!=null) {
 138         try {
 139           year = Integer.parseInt(textValue.substring(0,4));
 140           month = Integer.parseInt(textValue.substring(5,7));
 141           day = Integer.parseInt(textValue.substring(8,10));
 142           hours = Integer.parseInt(textValue.substring(11,13));
 143           minutes = Integer.parseInt(textValue.substring(14,16));
 144
 145           calendar.set(year, month-1, day, hours, minutes);
 146           date = calendar.getTime();
 147
 148           result.put("date", date);
 149           result.put("formatted", new DateToMapAdapter(date));
 150           result.put("raw", textValue);
 151         }
 152         catch (Throwable t) {
 153           result=null;
 154         }
 155       }
 156
 157       return result;
 158     }
 159   }
 160 }