/**
   * Checa a data e a hora
   *
   * @param data A data
   * @param hora A hora
   * @throws InvalidAttributeValueException
   */
  public static void checaDataHora(String data, String hora) throws InvalidAttributeValueException {
    if (data == null) throw new InvalidAttributeValueException("Data inválida");
    if (hora == null) throw new InvalidAttributeValueException("Hora inválida");
    SimpleDateFormat format = null;
    String dataHora = data + " " + hora;
    Date date = null;

    format = new SimpleDateFormat("dd/MM/yyyy");
    format.setLenient(false);
    try {
      date = format.parse(data);
    } catch (Exception e) {
      throw new InvalidAttributeValueException("Data inválida");
    }

    format = new SimpleDateFormat("HH:mm");
    format.setLenient(false);
    try {
      date = format.parse(hora);
    } catch (Exception e) {
      throw new InvalidAttributeValueException("Hora inválida");
    }

    format = new SimpleDateFormat("dd/MM/yyyy HH:mm");
    format.setLenient(false);
    try {
      date = format.parse(dataHora);
    } catch (ParseException e) {
      e.printStackTrace();
    }
    if (date.before(new Date())) throw new InvalidAttributeValueException("Data inválida");
  }
Example #2
0
  public Date bind(
      String name, Annotation[] annotations, String value, Class actualClass, Type genericType)
      throws Exception {
    if (value == null || value.trim().length() == 0) {
      return null;
    }

    Date date = AnnotationHelper.getDateAs(annotations, value);
    if (date != null) {
      return date;
    }

    try {
      SimpleDateFormat sdf = new SimpleDateFormat(I18N.getDateFormat());
      sdf.setLenient(false);
      return sdf.parse(value);
    } catch (ParseException e) {
      // Ignore
    }

    try {
      SimpleDateFormat sdf = new SimpleDateFormat(ISO8601);
      sdf.setLenient(false);
      return sdf.parse(value);
    } catch (Exception e) {
      throw new IllegalArgumentException(
          "Cannot convert [" + value + "] to a Date: " + e.toString());
    }
  }
Example #3
0
  /**
   * 计算函数
   *
   * @param dateString the dateString in the format of "yyyy-MM-dd HH:mm:ss" or HH:mm:ss".
   * @return an int from 0 to 59. null if the dateString is not a valid date string
   */
  public Integer evaluate(String dateString) {
    if (dateString == null) {
      return null;
    }

    if (formatter1 == null) {
      formatter1 = new SimpleDateFormat(UDFConstants.TIMESTAMP_FORMAT);
      formatter2 = new SimpleDateFormat(UDFConstants.TIME_FORMAT);
      calendar = Calendar.getInstance();
      /*
       * 设置时间严格匹配
       */
      formatter1.setLenient(false);
      formatter2.setLenient(false);
    }

    try {
      Date date = null;
      if (dateString.length() > UDFConstants.TIME_FORMAT.length()) {
        date = formatter1.parse(dateString);
      } else {
        date = formatter2.parse(dateString);
      }
      calendar.setTime(date);
      return calendar.get(Calendar.MINUTE);
    } catch (ParseException e) {
      LOG.warn(EVALUATE_IGNORE_MESSAGE);
      return null;
    }
  }
  static {
    formatForDate = new SimpleDateFormat(DATE_FORMAT);
    formatForTimeStamp = new SimpleDateFormat(TIMESTAMP_FORMAT);
    formatForDecimal = new DecimalFormat(NUMBER_FORMAT);

    formatForDate.setLenient(false);
    formatForTimeStamp.setLenient(false);
  }
 static {
   tempCalGMT.setLenient(false);
   sdfd.setCalendar(new GregorianCalendar(TimeZone.getTimeZone("GMT")));
   sdfd.setLenient(false);
   sdft.setCalendar(new GregorianCalendar(TimeZone.getTimeZone("GMT")));
   sdft.setLenient(false);
   sdfts.setCalendar(new GregorianCalendar(TimeZone.getTimeZone("GMT")));
   sdfts.setLenient(false);
 }
Example #6
0
 public static String date2UTC(Date dateTime, TimeZone timeZone) throws UtilitiesException {
   try {
     DecimalFormat twoDigits;
     String utc;
     String sign;
     int hours;
     int minutes;
     SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");
     dateFormatter.setLenient(false);
     dateFormatter.setTimeZone(timeZone);
     twoDigits = new DecimalFormat("00");
     utc = dateFormatter.format(dateTime);
     int tzOffset = timeZone.getOffset(dateTime.getTime());
     sign = "+";
     if (tzOffset < 0) {
       sign = "-";
       tzOffset = -tzOffset;
     }
     hours = tzOffset / 0x36ee80;
     minutes = (tzOffset % 0x36ee80) / 60000;
     return (new StringBuffer(utc.length() + 7))
         .append(utc)
         .append(sign)
         .append(twoDigits.format(hours))
         .append(":")
         .append(twoDigits.format(minutes))
         .toString();
   } catch (Exception ex) {
     throw new hk.hku.cecid.piazza.commons.util.UtilitiesException(ex);
   }
 }
  /**
   * Checks if the field is a valid date.
   *
   * <p>The pattern is used with {@code java.text.SimpleDateFormat}. If strict is true, then the
   * length will be checked so '2/12/1999' will not pass validation with the format 'MM/dd/yyyy'
   * because the month isn't two digits. The {@link java.text.SimpleDateFormat#setLenient(boolean)}
   * method is set to {@code false} for all.
   *
   * @param value The value validation is being performed on.
   * @param datePattern The pattern passed to {@code SimpleDateFormat}.
   * @param strict Whether or not to have an exact match of the datePattern.
   * @return the converted Date value.
   */
  public static Date formatDate(String value, String datePattern, boolean strict) {
    Date date = null;

    if (value == null || datePattern == null || datePattern.length() == 0) {
      return null;
    }

    try {
      SimpleDateFormat formatter = new SimpleDateFormat(datePattern);
      formatter.setLenient(false);

      date = formatter.parse(value);

      if (strict && datePattern.length() != value.length()) {
        date = null;
      }
    } catch (ParseException e) {
      // Bad date so return null
      if (LOG.isDebugEnabled()) {
        LOG.debug(
            "Date parse failed value=["
                + value
                + "], "
                + "pattern=["
                + datePattern
                + "], "
                + "strict=["
                + strict
                + "] "
                + e);
      }
    }

    return date;
  }
  private static String getRelativeTimeAgo(String rawJsonDate) {
    String twitterFormat = "EEE MMM dd HH:mm:ss ZZZZZ yyyy";
    SimpleDateFormat sf = new SimpleDateFormat(twitterFormat, Locale.ENGLISH);
    sf.setLenient(true);

    String relativeDate = "";
    try {
      long dateMillis = sf.parse(rawJsonDate).getTime();
      relativeDate =
          DateUtils.getRelativeTimeSpanString(
                  dateMillis, System.currentTimeMillis(), DateUtils.SECOND_IN_MILLIS)
              .toString();
    } catch (java.text.ParseException e) {
      e.printStackTrace();
    }

    String h1 = relativeDate.replaceAll("hours", "h");
    String h2 = h1.replaceAll("hour", "h");
    String m1 = h2.replaceAll("minutes", "m");
    String m2 = m1.replaceAll("minute", "m");
    String s1 = m2.replaceAll("seconds", "s");
    String s2 = s1.replaceAll("second", "s");
    String f = s2.replaceAll("ago", "");

    return f; // relativeDate;
  }
Example #9
0
 public static Date getTimeStamp(String date) throws ParseException {
   final String TWITTER = "EEE MMM dd HH:mm:ss z yyyy";
   SimpleDateFormat sf = new SimpleDateFormat(TWITTER);
   sf.setTimeZone(TimeZone.getTimeZone("GMT-04:00"));
   sf.setLenient(true);
   return sf.parse(date);
 }
 protected static SimpleDateFormat getDateFormatter() {
   if (c_sdfFormatter == null) {
     c_sdfFormatter = new SimpleDateFormat("MMddyyyy");
     c_sdfFormatter.setLenient(false);
   }
   return c_sdfFormatter;
 }
 private Object getValueFromField(int propertyType) throws ParseException {
   switch (nodePropertyParameters.propertyType) {
     case PropertyType.BINARY:
       return null;
     case PropertyType.BOOLEAN:
       return booleanValue.isSelected();
     case PropertyType.DATE:
       SimpleDateFormat dateFormat = new SimpleDateFormat();
       dateFormat.setLenient(true);
       String fieldText = dateValue.getText();
       dateFormat.parse(fieldText);
       return dateFormat.getCalendar();
     case PropertyType.DOUBLE:
       return Double.parseDouble(doubleValue.getText());
     case PropertyType.LONG:
       return Long.parseLong(longValue.getText());
     case PropertyType.NAME:
       return nameValue.getText();
     case PropertyType.PATH:
       return pathValue.getText();
     case PropertyType.REFERENCE:
       return referenceValue.getText();
     case PropertyType.STRING:
       return stringValue.getText();
     default:
       return null;
   }
 }
Example #12
0
  /**
   * Get (Short) Date Format. The date format must parseable by org.compiere.grid.ed.MDocDate i.e.
   * leading zero for date and month
   *
   * @return date format MM/dd/yyyy - dd.MM.yyyy
   */
  public SimpleDateFormat getDateFormat() {
    if (m_dateFormat == null) {
      m_dateFormat = (SimpleDateFormat) DateFormat.getDateInstance(DateFormat.SHORT, m_locale);
      String sFormat = m_dateFormat.toPattern();
      //	some short formats have only one M and/or d (e.g. ths US)
      if (sFormat.indexOf("MM") == -1 || sFormat.indexOf("dd") == -1) {
        sFormat = sFormat.replaceFirst("d+", "dd");
        sFormat = sFormat.replaceFirst("M+", "MM");
        //	log.finer(sFormat + " => " + nFormat);
        m_dateFormat.applyPattern(sFormat);
      }
      //	Unknown short format => use JDBC
      if (m_dateFormat.toPattern().length() != 8) m_dateFormat.applyPattern("yyyy-MM-dd");

      //	4 digit year
      if (m_dateFormat.toPattern().indexOf("yyyy") == -1) {
        sFormat = m_dateFormat.toPattern();
        String nFormat = "";
        for (int i = 0; i < sFormat.length(); i++) {
          if (sFormat.charAt(i) == 'y') nFormat += "yy";
          else nFormat += sFormat.charAt(i);
        }
        m_dateFormat.applyPattern(nFormat);
      }
      m_dateFormat.setLenient(true);
    }
    return m_dateFormat;
  } //  getDateFormat
Example #13
0
  private static Date parseDateWithLeniency(String str, String[] parsePatterns, boolean lenient)
      throws ParseException {
    if ((str == null) || (parsePatterns == null)) {
      throw new IllegalArgumentException("Date and Patterns must not be null");
    }
    SimpleDateFormat parser = new SimpleDateFormat();
    parser.setLenient(lenient);
    ParsePosition pos = new ParsePosition(0);
    for (int i = 0; i < parsePatterns.length; i++) {
      String pattern = parsePatterns[i];
      if (parsePatterns[i].endsWith("ZZ")) {
        pattern = pattern.substring(0, pattern.length() - 1);
      }
      parser.applyPattern(pattern);
      pos.setIndex(0);

      String str2 = str;
      if (parsePatterns[i].endsWith("ZZ")) {
        int signIdx = indexOfSignChars(str2, 0);
        while (signIdx >= 0) {
          str2 = reformatTimezone(str2, signIdx);
          signIdx = indexOfSignChars(str2, ++signIdx);
        }
      }
      Date date = parser.parse(str2, pos);
      if ((date != null) && (pos.getIndex() == str2.length())) {
        return date;
      }
    }
    throw new ParseException("Unable to parse the date: " + str, -1);
  }
Example #14
0
 public static Date parseDate(final String source, final String conversionPattern)
     throws ParseException {
   SimpleDateFormat sdf = DATE_FORMAT.get();
   sdf.applyPattern(conversionPattern);
   sdf.setLenient(false);
   return sdf.parse(source);
 }
 @SuppressWarnings("unused")
 @InitBinder({"myCommand", "date"})
 private void initBinder(WebDataBinder binder) {
   SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
   dateFormat.setLenient(false);
   binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));
 }
  public static Date getTwitterDate(String date) throws ParseException {

    final String format = "EEE MMM dd HH:mm:ss ZZZZZ yyyy";
    SimpleDateFormat sf = new SimpleDateFormat(format);
    sf.setLenient(true);
    return sf.parse(date);
  }
 private boolean isValid(String dateString, String pattern) {
   boolean valid = true;
   Date date;
   SimpleDateFormat sdf = new SimpleDateFormat(pattern);
   sdf.setLenient(false);
   try {
     dateString = dateString.trim();
     date = sdf.parse(dateString);
     Calendar calendar = Calendar.getInstance();
     calendar.setTime(date);
     int year = calendar.get(Calendar.YEAR);
     int era = calendar.get(Calendar.ERA);
     if (era == GregorianCalendar.AD) {
       if (year > 9999) {
         valid = false;
       }
     }
     //   System.out.println("pattern is "+ pattern);
     //   System.out.println("Year is "+year);
     //   System.out.println("Calendar date is "+date.toString());
     //   System.out.println("Era is "+calendar.get(Calendar.ERA));
   } catch (ParseException e) {
     valid = false;
   }
   if (dateString.length() > pattern.length()) {
     valid = false;
   }
   return valid;
 }
Example #18
0
 /**
  * SubjectUploader constructor
  *
  * @param study study identifier in context
  * @param iArkCommonService common ARK service to perform select/insert/updates to the database
  * @param iPhenotypicService study service to perform select/insert/updates to the study database
  */
 public CustomDataUploader(
     Study study, IArkCommonService iArkCommonService, IPhenotypicService iPhenotypicService) {
   this.study = study;
   this.iArkCommonService = iArkCommonService;
   this.iPhenotypicService = iPhenotypicService;
   simpleDateFormat.setLenient(false);
 }
Example #19
0
 private void b()
 {
   a = ((TextView)findViewById(2131624176));
   e = new SimpleDateFormat("HH:mm:ss");
   e.setLenient(false);
   long l = System.currentTimeMillis();
   c = (ManagerApp.n().e() + 1000L - l);
   if (c <= 1000L)
   {
     dismiss();
     return;
   }
   a.setText(com.tinder.utils.g.c(c));
   f = new CountDownTimer(c, 1000L)
   {
     public void onFinish()
     {
       dismiss();
     }
     
     public void onTick(long paramAnonymousLong)
     {
       s.a(s.this, paramAnonymousLong - 1000L);
       s.b(s.this).setText(com.tinder.utils.g.c(s.a(s.this)));
     }
   };
   f.start();
 }
  @InitBinder
  public void initBinder(WebDataBinder binder) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    sdf.setLenient(true);

    binder.registerCustomEditor(Date.class, new CustomDateEditor(sdf, true));
  }
Example #21
0
 @InitBinder
 public void dataBinding(WebDataBinder binder) {
   binder.addValidators(feriasValidation);
   SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
   dateFormat.setLenient(false);
   binder.registerCustomEditor(Date.class, "dataInicio", new CustomDateEditor(dateFormat, true));
 }
  @InitBinder
  public void initBinder(WebDataBinder binder) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    dateFormat.setLenient(false);

    binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
  }
  private Date parseDateForFormat(final String format, final String date) {
    // test date string matches format structure using regex
    // - weed out illegal characters and enforce 4-digit year
    // - create the regex based on the local format string
    String reFormat =
        Pattern.compile("d+|M+|H+|m+")
            .matcher(Matcher.quoteReplacement(format))
            .replaceAll("\\\\d{1,2}");
    reFormat = Pattern.compile("y+").matcher(reFormat).replaceAll("\\\\d{4,}");
    if (Pattern.compile(reFormat).matcher(date).matches()) {

      // date string matches format structure,
      // - now test it can be converted to a valid date
      SimpleDateFormat sdf = (SimpleDateFormat) DateFormat.getDateInstance();
      sdf.applyPattern(format);
      sdf.setTimeZone(timeZoneManager.getLoggedInUserTimeZone());
      sdf.setLenient(false);
      try {
        return sdf.parse(date);
      } catch (ParseException e) {
        return null;
      }
    }
    return null;
  }
  private long parse3339(String time) {
    if (time == null || time.length() == 0) {
      return 0;
    }

    if (timestamper != null) {
      try {
        timestamper.parse3339(time);
      } catch (TimeFormatException e) {
        parse_trace("got TimeFormatException parsing timestamp: \"" + time + '"');
        e.printStackTrace();
        return 0;
      }

      return timestamper.normalize(false);
    } else {
      Date timestamp = new Date();

      SimpleDateFormat rfc3339 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
      rfc3339.setLenient(true);

      try {
        timestamp = rfc3339.parse(time);
      } catch (ParseException e) {
        parse_trace("got ParseException parsing timestamp: \"" + time + '"');
        e.printStackTrace();
        return 0;
      }

      return timestamp.getTime();
    }
  }
  @Override
  public void initBinder(WebDataBinder binder, WebRequest request) {

    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    dateFormat.setLenient(false);
    binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));
    binder.registerCustomEditor(String.class, new StringTrimmerEditor(false));
  }
 @InitBinder
 public void initBinder(WebDataBinder binder, @PathVariable("hotel") String hotel) {
   assertEquals("Invalid path variable value", "42", hotel);
   binder.initBeanPropertyAccess();
   SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
   dateFormat.setLenient(false);
   binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));
 }
 static {
   expressaoRegularPorFormatoData = new HashMap<String, String>();
   expressaoRegularPorFormatoData.put(
       "dd/MM/yyyy", "^(0[1-9]|[12][0-9]|3[01])[/]?([0][1-9]|[1][0-2])[/]?\\d{4}$");
   expressaoRegularPorFormatoData.put("MM/yyyy", "^([0][1-9]|[1][0-2])[/]?\\d{4}$");
   dateFormat = new SimpleDateFormat();
   dateFormat.setLenient(false);
 }
Example #28
0
 public static String format(
     final Date date, final boolean lenient, final String conversionPattern) {
   SimpleDateFormat sdf = DATE_FORMAT.get();
   if (conversionPattern != null) {
     sdf.applyPattern(conversionPattern);
   }
   sdf.setLenient(lenient);
   return sdf.format(date);
 }
Example #29
0
 public Object fromString(String date) {
   try {
     SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     dateFormat.setLenient(true);
     return dateFormat.parse(date);
   } catch (Exception e) {
     return null;
   }
 }
  public URLUnwrapperWorker(String threadName) {
    super(threadName);

    log.debug("-- URLUnwrapperWorker()");

    // "Mon Jan 07 12:35:06 +0000 2013"
    dateFormatter = new SimpleDateFormat("EEE MMM d HH:mm:ss ZZZZZ yyyy", Locale.ENGLISH);
    dateFormatter.setLenient(true);
  }