예제 #1
0
  public static Date addMilliSeconds(Date baseDate, Long milliseconds) {
    Date resultDate = null;
    Long ms = milliseconds;

    if (baseDate != null && ms != null) {
      resultDate = new Date(baseDate.getTime() + ms);

      // if the dates are not in the same timezone (e.g. CET and CEST), add the difference
      GregorianCalendar baseDateCal = new GregorianCalendar();
      baseDateCal.setTime(baseDate);
      int baseDateOffset =
          baseDateCal.get(Calendar.ZONE_OFFSET) + baseDateCal.get(Calendar.DST_OFFSET);

      GregorianCalendar resultDateCal = new GregorianCalendar();
      resultDateCal.setTime(resultDate);
      int resultTimeOffset =
          resultDateCal.get(Calendar.ZONE_OFFSET) + resultDateCal.get(Calendar.DST_OFFSET);

      if (baseDateOffset != resultTimeOffset) {
        ms = ms - (resultTimeOffset - baseDateOffset);
      }

      resultDate = new Date(baseDate.getTime() + ms);
    }
    return resultDate;
  }
예제 #2
0
  public static Long getDateDifferenceInMilliSeconds(Date zeroTime, Date overallTime) {
    Long timeDiff = null;

    if (overallTime != null && zeroTime != null) {

      timeDiff = (overallTime.getTime() - zeroTime.getTime());

      // if the dates are not in the same timezone (e.g. CET and CEST),
      // subtract the difference
      GregorianCalendar zeroTimeCal = new GregorianCalendar();
      zeroTimeCal.setTime(zeroTime);
      int zeroTimeOffset =
          zeroTimeCal.get(Calendar.ZONE_OFFSET) + zeroTimeCal.get(Calendar.DST_OFFSET);

      GregorianCalendar overallTimeCal = new GregorianCalendar();
      overallTimeCal.setTime(overallTime);
      int overallTimeOffset =
          overallTimeCal.get(Calendar.ZONE_OFFSET) + overallTimeCal.get(Calendar.DST_OFFSET);

      if (zeroTimeOffset != overallTimeOffset) {
        timeDiff = timeDiff + (overallTimeOffset - zeroTimeOffset);
      }
    }

    return timeDiff;
  }
예제 #3
0
  /**
   * Contract: get SheduleItems that ID equals to inSheduleItem.getId(); compare if the train
   * capacity more then current tickets count on this SheduleItem; compare if the date of departure
   * more then current date for 10 minutes
   *
   * @param inSheduleItem SheduleItem for which need checks
   * @return SheduleItem selected from database or throws exceptions
   * @throws NoAvailableSeatsException
   * @throws ExpiredTimeToBuyException
   */
  @Transactional(readOnly = false, rollbackFor = Exception.class)
  public SheduleItemEntity checkTrainSeatsAndDate(SheduleItemEntity inSheduleItem)
      throws NoAvailableSeatsException, ExpiredTimeToBuyException {

    SheduleItemEntity sheduleItem =
        (SheduleItemEntity) this.sheduleDAO.getById(SheduleItemEntity.class, inSheduleItem.getId());
    /*check available seats*/
    List<SheduleItemEntity> sheduleItemsList = new ArrayList<SheduleItemEntity>();
    sheduleItemsList.add(sheduleItem);
    sheduleItemsList = this.sheduleDAO.getBySheduleItems(sheduleItemsList);
    if (sheduleItem.getTrain().getCapacity() == sheduleItemsList.get(0).getTicketsList().size()) {
      throw new NoAvailableSeatsException();
    }

    /*check that before departure left 10 minutes*/
    GregorianCalendar currentDate = new GregorianCalendar();
    currentDate.setTime(new Date());

    GregorianCalendar departureDateMinus10 = new GregorianCalendar();
    departureDateMinus10.setTime(sheduleItem.getDepartureDate());
    departureDateMinus10.add(GregorianCalendar.MINUTE, -10);

    if (currentDate.after(departureDateMinus10)) {
      throw new ExpiredTimeToBuyException();
    }

    return sheduleItem;
  }
  public DiscCriteria getDisc4MemberDept(Connection connection, String code) throws SQLException {

    DiscCriteria result = null;

    String sql =
        " SELECT DeptID, DiscLevel, DiscRate,"
            + " StartTime, EndTime "
            + " FROM discDeptMember,price_lst where price_lst.vgno=? and price_lst.deptno=CONVERT(char(15),discDeptMember.DeptID); ";
    PreparedStatement stmt = connection.prepareStatement(sql);
    stmt.setString(1, code);
    ResultSet rs = stmt.executeQuery();
    if (rs.next()) {
      int deptID = rs.getInt("DeptID");
      int discLevel = rs.getInt("DiscLevel");
      int discRate = rs.getInt("DiscRate");
      Date starttime = rs.getDate("StartTime");
      Date endtime = rs.getDate("EndTime");

      GregorianCalendar g_start = new GregorianCalendar();
      g_start.setTime(starttime);

      GregorianCalendar g_end = new GregorianCalendar();
      g_end.setTime(endtime);

      result = new Disc4MemberDept(deptID, discLevel, discRate, g_start, g_end);
    }

    return result;
  }
  public void preencheCampos(
      JTextField txtDescricao,
      JTextField txtDataCompra,
      JTextField txtDataValidade,
      JTextField txtQuantidade,
      JTextField txtPrecoCompra,
      JTextField txtPrecoVenda,
      Composto composto)
      throws ParseException {

    txtDescricao.setText(composto.getDescricao());

    String dia, mes, ano;
    GregorianCalendar calendarCompra = new GregorianCalendar();
    calendarCompra.setTime(composto.getDataCompra());
    dia = String.valueOf(calendarCompra.get(GregorianCalendar.DAY_OF_MONTH));
    mes = String.valueOf(calendarCompra.get(GregorianCalendar.MONTH));
    ano = String.valueOf(calendarCompra.get(GregorianCalendar.YEAR));
    txtDataCompra.setText(dia + "/" + mes + "/" + ano);

    calendarCompra.setTime(composto.getDataValidade());
    dia = String.valueOf(calendarCompra.get(GregorianCalendar.DAY_OF_MONTH));
    mes = String.valueOf(calendarCompra.get(GregorianCalendar.MONTH));
    ano = String.valueOf(calendarCompra.get(GregorianCalendar.YEAR));
    txtDataValidade.setText(dia + "/" + mes + "/" + ano);

    txtQuantidade.setText(String.valueOf(composto.getQuantidadeEstoque()));
    txtPrecoCompra.setText(String.valueOf(composto.getPrecoCompra()));
    txtPrecoVenda.setText(String.valueOf(composto.getPrecoVenda()));
  }
  /**
   * 根据商品编码从表promotion_vip里查询出商品的会员价
   *
   * @param connection 到数据库的连接
   * @param code 商品编码
   * @return 普通促销信息
   * @throws SQLException
   */
  public DiscCriteria getProm4Member(Connection connection, String code) throws SQLException {

    DiscCriteria result = null;

    String sql =
        " SELECT vgno, promlevel, promprice, "
            + " startdate, enddate, starttime, endtime "
            + " FROM promotion_vip where vgno=?; ";
    PreparedStatement stmt = connection.prepareStatement(sql);
    stmt.setString(1, code);
    ResultSet rs = stmt.executeQuery();
    if (rs.next()) {
      String vgno = Formatter.mytrim(rs.getString("vgno"));
      int promlevel = rs.getInt("promlevel");
      double promprice = rs.getDouble("promprice");

      Date startdate = rs.getDate("startdate");
      Date enddate = rs.getDate("enddate");
      Date starttime = rs.getDate("starttime");
      Date endtime = rs.getDate("endtime");

      GregorianCalendar g_start = new GregorianCalendar();
      g_start.setTime(starttime);

      GregorianCalendar g_end = new GregorianCalendar();
      g_end.setTime(endtime);

      result = new Prom4Member(vgno, (int) (100 * promprice), promlevel, g_start, g_end);
    }

    return result;
  }
예제 #7
0
  /**
   * Parse Json Response from Alfresco REST API to create a process Definition Object.
   *
   * @param json : json response that contains data from the repository
   * @return ProcessDefinition Object
   */
  @SuppressWarnings("unchecked")
  public static Process parseJson(Map<String, Object> json) {
    ProcessImpl process = new ProcessImpl();

    // Public Properties
    process.identifier = JSONConverter.getString(json, OnPremiseConstant.ID_VALUE);
    String definitionIdentifier =
        JSONConverter.getString(json, OnPremiseConstant.DEFINITIONURL_VALUE);
    process.definitionIdentifier = definitionIdentifier.replace(SUFFIX_WORKFLOW_DEFINITION, "");
    process.key = JSONConverter.getString(json, OnPremiseConstant.NAME_VALUE);
    process.name = JSONConverter.getString(json, OnPremiseConstant.TITLE_VALUE);
    process.priority = JSONConverter.getInteger(json, OnPremiseConstant.PRIORITY_VALUE).intValue();
    process.description = JSONConverter.getString(json, OnPremiseConstant.MESSAGE_VALUE);

    // PARSE DATES
    String date = JSONConverter.getString(json, OnPremiseConstant.STARTDATE_VALUE);
    GregorianCalendar g = new GregorianCalendar();
    SimpleDateFormat sdf = new SimpleDateFormat(DateUtils.FORMAT_3, Locale.getDefault());
    if (date != null) {
      g.setTime(DateUtils.parseDate(date, sdf));
      process.startedAt = g;
    }

    date = JSONConverter.getString(json, OnPremiseConstant.ENDDATE_VALUE);
    if (date != null) {
      g = new GregorianCalendar();
      g.setTime(DateUtils.parseDate(date, sdf));
      process.endedAt = g;
    }

    // PARSE INITIATOR
    Map<String, Object> initiator =
        (Map<String, Object>) json.get(OnPremiseConstant.INITIATOR_VALUE);
    Person p = PersonImpl.parseJson(initiator);
    process.initiatorIdentifier = p.getIdentifier();

    // EXTRA PROPERTIES
    process.data = new HashMap<String, Serializable>();
    process.data.put(OnPremiseConstant.INITIATOR_VALUE, p);

    date = JSONConverter.getString(json, OnPremiseConstant.DUEDATE_VALUE);
    if (date != null) {
      g = new GregorianCalendar();
      g.setTime(DateUtils.parseDate(date, sdf));
      process.dueAt = g;
    }
    process.data.put(OnPremiseConstant.DUEDATE_VALUE, g);

    process.data.put(
        OnPremiseConstant.DESCRIPTION_VALUE,
        JSONConverter.getString(json, OnPremiseConstant.DESCRIPTION_VALUE));
    process.data.put(
        OnPremiseConstant.ISACTIVE_VALUE,
        JSONConverter.getBoolean(json, OnPremiseConstant.ISACTIVE_VALUE));

    process.hasAllVariables = true;

    return process;
  }
예제 #8
0
  /**
   * Contract: get routes from shedule with StationInfo from filter; if in the filter exist date
   * then compare it with the date when train will be on the station for this route
   *
   * @param filter contains StationInfo fow which need SheduleItems info and date when train need on
   *     the station
   * @return SheduleItems that satisfy to conditions
   */
  @Transactional(readOnly = true)
  public List<SheduleItemEntity> searchByStation(SheduleFilter filter) {
    List<SheduleItemEntity> sheduleItemsList = new ArrayList<SheduleItemEntity>();

    List<StationInfoEntity> stationInfoList = new ArrayList<StationInfoEntity>();
    stationInfoList.add(filter.getStationInfo());
    for (SheduleItemEntity sheduleItem : this.sheduleDAO.getByStations(stationInfoList)) {

      StationEntity station = null;
      for (StationEntity stationInRoute : sheduleItem.getRoute().getStationsList()) {
        if (stationInRoute.getStationInfo().equals(filter.getStationInfo())) {
          station = stationInRoute;
        }
      }

      if (station != null) {
        GregorianCalendar dateCondition = null;
        if (filter.getDate() != null) {
          dateCondition = new GregorianCalendar();
          dateCondition.setTime(filter.getDate());
          dateCondition =
              new GregorianCalendar(
                  dateCondition.get(Calendar.YEAR),
                  dateCondition.get(Calendar.MONTH),
                  dateCondition.get(Calendar.DAY_OF_MONTH));
        }

        GregorianCalendar sheduleItemDate = null;
        if (dateCondition != null) {
          sheduleItemDate = new GregorianCalendar();
          sheduleItemDate.setTime(sheduleItem.getDepartureDate());
          sheduleItemDate.add(Calendar.MINUTE, station.getTimeOffset());
          sheduleItemDate =
              new GregorianCalendar(
                  sheduleItemDate.get(Calendar.YEAR),
                  sheduleItemDate.get(Calendar.MONTH),
                  sheduleItemDate.get(Calendar.DAY_OF_MONTH));
        }

        if ((dateCondition != null
                && sheduleItemDate != null
                && dateCondition.equals(sheduleItemDate))
            || dateCondition == null) {
          try {
            SheduleItemEntity cloneSheduleItem = (SheduleItemEntity) sheduleItem.clone();
            cloneSheduleItem.getRoute().getStationsList().clear();
            cloneSheduleItem.getRoute().getStationsList().add(station);
            sheduleItemsList.add(cloneSheduleItem);
          } catch (CloneNotSupportedException exc) {
            exc.printStackTrace();
            LOGGER.warn(exc);
          }
        }
      }
    }

    return sheduleItemsList;
  }
예제 #9
0
    public View getView(Context context) throws UnsupportedOperationException {
      if (mType.equals("date")) {
        try {
          DateTimePicker input =
              new DateTimePicker(context, "yyyy-MM-dd", mValue, DateTimePicker.PickersState.DATE);
          input.toggleCalendar(true);
          mView = (View) input;
        } catch (UnsupportedOperationException ex) {
          // We can't use our custom version of the DatePicker widget because the sdk is too old.
          // But we can fallback on the native one.
          DatePicker input = new DatePicker(context);
          try {
            if (!TextUtils.isEmpty(mValue)) {
              GregorianCalendar calendar = new GregorianCalendar();
              calendar.setTime(new SimpleDateFormat("yyyy-MM-dd").parse(mValue));
              input.updateDate(
                  calendar.get(Calendar.YEAR),
                  calendar.get(Calendar.MONTH),
                  calendar.get(Calendar.DAY_OF_MONTH));
            }
          } catch (Exception e) {
            Log.e(LOGTAG, "error parsing format string: " + e);
          }
          mView = (View) input;
        }
      } else if (mType.equals("week")) {
        DateTimePicker input =
            new DateTimePicker(context, "yyyy-'W'ww", mValue, DateTimePicker.PickersState.WEEK);
        mView = (View) input;
      } else if (mType.equals("time")) {
        TimePicker input = new TimePicker(context);
        input.setIs24HourView(DateFormat.is24HourFormat(context));

        GregorianCalendar calendar = new GregorianCalendar();
        if (!TextUtils.isEmpty(mValue)) {
          try {
            calendar.setTime(new SimpleDateFormat("HH:mm").parse(mValue));
          } catch (Exception e) {
          }
        }
        input.setCurrentHour(calendar.get(GregorianCalendar.HOUR_OF_DAY));
        input.setCurrentMinute(calendar.get(GregorianCalendar.MINUTE));
        mView = (View) input;
      } else if (mType.equals("datetime-local") || mType.equals("datetime")) {
        DateTimePicker input =
            new DateTimePicker(
                context, "yyyy-MM-dd HH:mm", mValue, DateTimePicker.PickersState.DATETIME);
        input.toggleCalendar(true);
        mView = (View) input;
      } else if (mType.equals("month")) {
        DateTimePicker input =
            new DateTimePicker(context, "yyyy-MM", mValue, DateTimePicker.PickersState.MONTH);
        mView = (View) input;
      }
      return mView;
    }
  /**
   * Calculates overheads for user from given backlogs( projects)
   *
   * @param from
   * @param weeksAhead
   * @param items
   * @return
   */
  public HashMap<Integer, String> calculateOverheads(
      Date from, int weeksAhead, List<Backlog> items, User user) {
    GregorianCalendar cal = new GregorianCalendar();
    CalendarUtils cUtils = new CalendarUtils();
    HashMap<Integer, String> overheads = new HashMap<Integer, String>();

    Date start = from;
    Date end = cUtils.nextMonday(start);
    cal.setTime(start);
    Integer week = cal.get(GregorianCalendar.WEEK_OF_YEAR);
    List<Assignment> assignments = new ArrayList<Assignment>(user.getAssignments());

    for (int i = 1; i <= weeksAhead; i++) {
      // 1. Get Backlogs that hit for the week
      log.debug("Projects searched from :" + start);
      log.debug("Projects searched ending :" + end);
      cal.setTime(start);
      week = cal.get(GregorianCalendar.WEEK_OF_YEAR);
      log.debug("Calculating overhead for week" + week);

      // 2. Get projects that hit current week
      List<Backlog> list = this.getProjectsAndIterationsInTimeFrame(items, start, end);
      log.debug(list.size() + " projects found for given time frame");

      // 3. Calculate overhead sum from items in those projects
      AFTime overhead = new AFTime(0);
      for (Backlog blog : list) {
        // Only check assignments for Projects (overhead
        // only set for projects not iterations)
        if (blog.getClass().equals(Project.class)) {
          Project pro = (Project) blog;
          for (Assignment ass : assignments) {
            if (ass.getBacklog().equals((Backlog) pro)) {
              if (pro.getDefaultOverhead() != null) {
                overhead.add(pro.getDefaultOverhead());
                log.debug("Added overhead from project: " + pro.getDefaultOverhead());
              }
              if (ass.getDeltaOverhead() != null) {
                overhead.add(ass.getDeltaOverhead());
                log.debug("Added overhead from user: "******"Class was iteration class, overhead :" + blog.getClass());
        }
      }
      overheads.put(week, overhead.toString());
      start = cUtils.nextMonday(start);
      end = cUtils.nextMonday(start);
      cal.setTime(start);
      week = cal.get(GregorianCalendar.WEEK_OF_YEAR);
    }

    return overheads;
  }
  public static boolean haveSameDate(Date d1, Date d2) {
    GregorianCalendar gc1 = new GregorianCalendar();
    gc1.setTime(d1);

    GregorianCalendar gc2 = new GregorianCalendar();
    gc2.setTime(d2);

    return ((gc1.get(Calendar.DAY_OF_MONTH) == gc2.get(Calendar.DAY_OF_MONTH))
        && (gc1.get(Calendar.DAY_OF_MONTH) == gc2.get(Calendar.DAY_OF_MONTH))
        && (gc1.get(Calendar.YEAR) == gc2.get(Calendar.YEAR)));
  }
 /** @return (date1 == null) ? (date2 == null) : dayDate(date1).equals(dayDate(date2)); */
 public static boolean sameDay(Date date1, Date date2) {
   if ((date1 != null) && (date2 != null)) {
     GregorianCalendar cal1 = new GregorianCalendar();
     cal1.setTime(date1);
     GregorianCalendar cal2 = new GregorianCalendar();
     cal2.setTime(date2);
     return fieldEqual(cal1, cal2, Calendar.YEAR)
         && fieldEqual(cal1, cal2, Calendar.MONTH)
         && fieldEqual(cal1, cal2, Calendar.DAY_OF_MONTH);
   } else {
     return date1 == date2; // they both have to be null
   }
 }
예제 #13
0
  /**
   * Calculates the elapsed time between 2 dates. The elapsed time calculated could either be in
   * years, months or days
   *
   * @param type (int) The variable type determines the calculation of the elapsed time to be based
   *     on either years, months or days. To compute the elapsed time in year input type set to
   *     Calendar.YEAR To compute the elapsed time in month input type set to Calendar.MONTH By
   *     default the elapsed time will compute in days
   * @param startDate start date
   * @param endDate end date
   * @return the elapsed time (int)
   */
  public static int getElapsedTime(int type, Date startDate, Date endDate) {
    int elapsed = 0;

    if ((startDate == null) || (endDate == null)) {
      return -1;
    }

    if (startDate.after(endDate)) {
      return -1;
    }

    GregorianCalendar gc1 = (GregorianCalendar) GregorianCalendar.getInstance();
    GregorianCalendar gc2 = (GregorianCalendar) gc1.clone();
    gc1.setTime(startDate);
    gc2.setTime(endDate);

    gc1.clear(Calendar.MILLISECOND);
    gc1.clear(Calendar.SECOND);
    gc1.clear(Calendar.MINUTE);
    gc1.clear(Calendar.HOUR_OF_DAY);
    gc2.clear(Calendar.MILLISECOND);
    gc2.clear(Calendar.SECOND);
    gc2.clear(Calendar.MINUTE);
    gc2.clear(Calendar.HOUR_OF_DAY);

    if ((type != Calendar.MONTH) && (type != Calendar.YEAR)) {
      type = Calendar.DATE;
    }

    if (type == Calendar.MONTH) {
      gc1.clear(Calendar.DATE);
      gc2.clear(Calendar.DATE);
    }

    if (type == Calendar.YEAR) {
      gc1.clear(Calendar.DATE);
      gc2.clear(Calendar.DATE);
      gc1.clear(Calendar.MONTH);
      gc2.clear(Calendar.MONTH);
    }

    while (gc1.before(gc2)) {
      gc1.add(type, 1);
      elapsed++;
    }

    return elapsed;
  }
예제 #14
0
  private static XMLGregorianCalendar getFechaXMLGregorianCalendar(String fecha) {

    Date dob = null;
    DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
    try {
      dob = df.parse(fecha);
    } catch (ParseException e1) {
      e1.printStackTrace();
    }
    GregorianCalendar cal = new GregorianCalendar();
    cal.setTime(dob);
    XMLGregorianCalendar xmlDate = null;
    try {
      xmlDate =
          DatatypeFactory.newInstance()
              .newXMLGregorianCalendarDate(
                  cal.get(Calendar.YEAR),
                  cal.get(Calendar.MONTH) + 1,
                  cal.get(Calendar.DAY_OF_MONTH),
                  DatatypeConstants.FIELD_UNDEFINED);
    } catch (DatatypeConfigurationException e1) {
      e1.printStackTrace();
    }
    return xmlDate;
  }
예제 #15
0
파일: DateUtil.java 프로젝트: avoy/Tracker
  public long weekdays() {
    if (weekdays == -1) {
      weekdays = 0;
      NSTimeZone tz = NSTimeZone.timeZoneWithName("America/Los_Angeles", true);
      // NSTimestamp currDatePacific = new NSTimestamp(currDate.getTime(), tz);

      NSTimestamp startDate = new NSTimestamp(day1.getTime(), tz);
      GregorianCalendar cal = new GregorianCalendar();

      int num = (int) calendardays();
      for (int i = 0;
          i < num;
          i++) { // will check the start date, all days in-between and the end-date
        NSTimestamp tempDate = startDate.timestampByAddingGregorianUnits(0, 0, i, 0, 0, 0);
        cal.setTime(tempDate);
        // The day-of-week is an integer value where 1 is Sunday, 2 is Monday, ..., and 7 is
        // Saturday
        int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
        if ((dayOfWeek > 1) && (dayOfWeek < 7)) {
          weekdays++;
        }
      }
    }
    return weekdays;
  }
예제 #16
0
  public void execute() {
    // Initialize a Reminder or more than one Reminders.
    boolean booleanReminder = false;
    if (mStrReminder.compareTo(mStrReminder) == 0) booleanReminder = true;
    Reminder[] reminders = new Reminder[1];
    if (mStrMinute.compareTo("On day of event") == 0) {
      Date dateReminder = getDateTime(mStrStartTime);
      GregorianCalendar gregorianCalendarReminder = new GregorianCalendar();
      gregorianCalendarReminder.setTime(dateReminder);
      mStrMinute =
          Integer.toString(
              gregorianCalendarReminder.get(Calendar.HOUR_OF_DAY) * 60
                  + gregorianCalendarReminder.get(Calendar.MINUTE));
    }

    reminders[0] = new Reminder(mStrMinute, mStrMethod, booleanReminder);

    // Initialize a Recurrence.

    // Initialize a Where.
    Where where = new Where(mStrLocation);

    // Initialize a When.
    When when =
        new When(
            getStrDateWithTimeZone(mStrStartTime), getStrDateWithTimeZone(mStrEndTime), reminders);

    // Initialize an Event.
    Event event = new Event(mStrTitle, mStrContent, where, when);

    // Post to Calendar for adding a new event of default calendar.
    Event eventNew = null;
    try {
      eventNew = mCalendarServer.postEventEntry("", event);
    } catch (IOException e) {
      Bundle bundleSend = new Bundle();
      eventNew = new Event(false);
      bundleSend.putSerializable("Data", eventNew);
      bundleSend.putInt("ErrorCode", Integer.parseInt(e.getMessage()));

      Intent intentSend = new Intent(IntentCommand.INTENT_ACTION);
      intentSend.setFlags(IntentCommand.GOOGLE_CALENDAR_ADD_EVENT);
      intentSend.putExtras(bundleSend);

      mBaseService.sendBroadcast(intentSend);
      return;
    }

    // Get a response from Calendar, the response is a event entry, update cache.
    if (eventNew != null) {
      Bundle bundleSend = new Bundle();
      bundleSend.putSerializable("Data", eventNew);

      Intent intentSend = new Intent(IntentCommand.INTENT_ACTION);
      intentSend.setFlags(IntentCommand.GOOGLE_CALENDAR_ADD_EVENT);
      intentSend.putExtras(bundleSend);

      mBaseService.sendBroadcast(intentSend);
    }
  }
예제 #17
0
  public static java.util.Date proximoDiaMesAtual(java.util.Date data) {
    GregorianCalendar gcTmp = new GregorianCalendar();
    gcTmp.setTime(data);
    gcTmp.add(5, 1);

    return gcTmp.getTime();
  }
예제 #18
0
  private void updateCalendarLocale(Locale l) {
    int oldFirstDayOfWeek = calendar.getFirstDayOfWeek();
    setLocale(l);
    calendarComponent.setLocale(l);
    calendar = new GregorianCalendar(l);
    int newFirstDayOfWeek = calendar.getFirstDayOfWeek();

    // we are showing 1 week, and the first day of the week has changed
    // update start and end dates so that the same week is showing
    if (viewMode == Mode.WEEK && oldFirstDayOfWeek != newFirstDayOfWeek) {
      calendar.setTime(calendarComponent.getStartDate());
      calendar.add(java.util.Calendar.DAY_OF_WEEK, 2);
      // starting at the beginning of the week
      calendar.set(GregorianCalendar.DAY_OF_WEEK, newFirstDayOfWeek);
      Date start = calendar.getTime();

      // ending at the end of the week
      calendar.add(GregorianCalendar.DATE, 6);
      Date end = calendar.getTime();

      calendarComponent.setStartDate(start);
      calendarComponent.setEndDate(end);

      // Week days depend on locale so this must be refreshed
      setWeekendsHidden(hideWeekendsButton.getValue());
    }
  }
  private void showNotAccessedInNDays(Vector vector, Document document) {
    int i = getPropertyAsInteger(pNotAccessedN);
    if (i > 0) {
      Vector vector1 = new Vector();
      GregorianCalendar gregoriancalendar = new GregorianCalendar();
      gregoriancalendar.setTime(new Date());
      gregoriancalendar.add(6, -i);
      Date date = gregoriancalendar.getTime();
      for (int j = 0; j < vector.size(); j++) {
        Map map = (Map) vector.elementAt(j);
        Date date1 = (Date) map.get("JavaLastLogoffTime");
        if (date1 == null || date1.getTime() >= date.getTime()) {
          continue;
        }
        Vector vector2 = new Vector();
        vector1.addElement(vector2);
        vector2.addElement(new Pair("Mailbox", map.get("MailboxDisplayName")));
        synchronized (mDisplayDateFormat) {
          vector2.addElement(new Pair("Last Logoff Time", mDisplayDateFormat.format(date1)));
        }
      }

      addListContent(vector1, "Mailboxes Not Accessed in " + i + " Days", document);
    }
  }
예제 #20
0
 private Date getNextYearFor(Date date) {
   GregorianCalendar previousYearToDate = new GregorianCalendar();
   previousYearToDate.setTime(date);
   int prevYear = previousYearToDate.get(Calendar.YEAR) + 1;
   previousYearToDate.set(Calendar.YEAR, prevYear);
   return previousYearToDate.getTime();
 }
 private Date newestDateToDelete() {
   GregorianCalendar calendar = new GregorianCalendar();
   calendar.setTime(clock.now());
   calendar.add(Calendar.DAY_OF_YEAR, -settings.getRequestLogCleanupMaxAgeDays());
   Date newestDateToDelete = calendar.getTime();
   return newestDateToDelete;
 }
  @RequestMapping(value = "/queryVisita", method = RequestMethod.POST)
  public String queryVisita(@ModelAttribute("visita") visita c, Model m, SessionStatus session)
      throws Exception {

    SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S");
    Date datum = df.parse(c.getFechaString());
    GregorianCalendar cal = new GregorianCalendar();
    cal.setTime(datum);
    XMLGregorianCalendar xmlCal = DatatypeFactory.newInstance().newXMLGregorianCalendar(cal);

    /** ******************* Calling web service *********************** */
    List<Visita> lista = visitaService.traeVisita(xmlCal);
    Iterator<Visita> i = lista.iterator();
    Visita v = i.next();

    visita t =
        new visita(
            datum,
            v.getRecomendacion(),
            v.getComentarios(),
            v.getRfc(),
            v.getLote(),
            v.getParcela(),
            v.getProductor(),
            v.getAsesor());

    List<Maleza> malezas = malezaService.traeMalezas(xmlCal);

    Iterator<Maleza> j = malezas.iterator();
    listaMalezas.clear();
    while (j.hasNext()) {
      Maleza mal = j.next();
      maleza esta = new maleza(datum, mal.getNombre(), mal.getPoblacion());
      listaMalezas.add(esta);
    }

    List<Plaga> plagas = plagaService.traePlaga(xmlCal);
    Iterator<Plaga> k = plagas.iterator();
    listaPlagas.clear();
    while (k.hasNext()) {
      Plaga p = k.next();
      maleza dieser = new maleza(datum, p.getNombre(), p.getPoblacion());
      listaPlagas.add(dieser);
    }

    List<Enfermedad> sicks = enfermedadService.traeEnfermedades(xmlCal);
    listaSick.clear();
    Iterator<Enfermedad> l = sicks.iterator();
    while (l.hasNext()) {
      Enfermedad sick = l.next();
      listaSick.add(sick.getEnfermedad());
    }

    m.addAttribute("visitaForm", t);
    m.addAttribute("malezas", listaMalezas);
    m.addAttribute("plagas", listaPlagas);
    m.addAttribute("enfermedades", listaSick);

    return "redirect:informesDone";
  }
예제 #23
0
    public static IRubyObject prepareRubyDateTimeFromSqlTimestamp(Ruby runtime,Timestamp stamp){

       if (stamp.getTime() == 0) {
           return runtime.getNil();
       }

       gregCalendar.setTime(stamp);
       int month = gregCalendar.get(Calendar.MONTH);
       month++; // In Calendar January == 0, etc...

       int zoneOffset = gregCalendar.get(Calendar.ZONE_OFFSET)/3600000;
       RubyClass klazz = runtime.fastGetClass("DateTime");

       IRubyObject rbOffset = runtime.fastGetClass("Rational")
                .callMethod(runtime.getCurrentContext(), "new",new IRubyObject[]{
            runtime.newFixnum(zoneOffset),runtime.newFixnum(24)
        });

       return klazz.callMethod(runtime.getCurrentContext() , "civil",
                 new IRubyObject []{runtime.newFixnum(gregCalendar.get(Calendar.YEAR)),
                 runtime.newFixnum(month),
                 runtime.newFixnum(gregCalendar.get(Calendar.DAY_OF_MONTH)),
                 runtime.newFixnum(gregCalendar.get(Calendar.HOUR_OF_DAY)),
                 runtime.newFixnum(gregCalendar.get(Calendar.MINUTE)),
                 runtime.newFixnum(gregCalendar.get(Calendar.SECOND)),
                 rbOffset});
    }
예제 #24
0
  public StringBuilder format(Date date, StringBuilder buf) {
    cal.setTime(date);
    int year = cal.get(Calendar.YEAR);
    if (cal.get(Calendar.ERA) == GregorianCalendar.BC) {
      if (year > 1) {
        buf.append('-');
      }
      year = year - 1;
    }
    pad(buf, year, 4);
    buf.append('-');
    pad(buf, cal.get(Calendar.MONTH) + 1, 2);
    buf.append('-');
    pad(buf, cal.get(Calendar.DAY_OF_MONTH), 2);
    buf.append('T');
    pad(buf, cal.get(Calendar.HOUR_OF_DAY), 2);
    buf.append(':');
    pad(buf, cal.get(Calendar.MINUTE), 2);
    buf.append(':');
    pad(buf, cal.get(Calendar.SECOND), 2);
    buf.append('.');
    pad(buf, cal.get(Calendar.MILLISECOND), 3);
    buf.append('Z');

    return buf;
  }
  private void createDateEditDialog(
      int year, int month, int dayOfMonth, final Date date, final boolean isStartDate) {

    final GregorianCalendar gc = new GregorianCalendar();
    gc.setTime(date);

    DatePickerDialog dialog =
        new DatePickerDialog(
            this,
            new DatePickerDialog.OnDateSetListener() {

              @Override
              public void onDateSet(DatePicker view, int year, int monthOfYear, int dayOfMonth) {

                gc.set(Calendar.YEAR, year);
                gc.set(Calendar.MONTH, monthOfYear);
                gc.set(Calendar.DAY_OF_MONTH, dayOfMonth);

                if (isStartDate) {
                  ponto.setStartDate(gc.getTime());
                  startDate.setText(sdfDate.format(gc.getTime()));
                } else {
                  ponto.setFinishDate(gc.getTime());
                  finishDate.setText(sdfDate.format(gc.getTime()));
                }
                repository.saveOrUpdate(ponto);
              }
            },
            year,
            month,
            dayOfMonth);
    dialog.show();
  }
예제 #26
0
 /**
  * 自定义时间timer 增减 月
  *
  * @param fmtTimer
  * @param amount
  * @return
  */
 public static Long addMonthFmtTimer(Long fmtTimer, int amount) {
   Date cDate = myTimerToDate(fmtTimer);
   GregorianCalendar cal = new GregorianCalendar();
   cal.setTime(cDate);
   cal.add(GregorianCalendar.MONTH, amount);
   return dateFmtTimer(cal.getTime());
 }
예제 #27
0
 /**
  * @param days=n n为-,则取n天前,n为+,则取n天后的日期
  * @param date
  * @param days
  * @return
  */
 public Date getSomeDaysBeforeAfter(Date date, int days) {
   GregorianCalendar gc = new GregorianCalendar();
   gc.setTime(date);
   gc.add(5, days);
   gc.set(gc.get(Calendar.YEAR), gc.get(Calendar.MONTH), gc.get(Calendar.DATE));
   return gc.getTime();
 }
예제 #28
0
 public static void loadBlocks(Chunk chunk) {
   ResultSet r = null;
   try {
     r =
         (new SQLQuery(
                 "select l.world,l.x,l.y,l.z,b.dayPlaced,b.id from £.locations l, £.nonnatural b where l.id=b.location and l.chunkx="
                     + chunk.getX()
                     + " and l.chunkz="
                     + chunk.getZ()
                     + ";",
                 msqlc))
             .excecuteQuery();
   } catch (MySQLSyntaxErrorException e1) {
     e1.printStackTrace();
   }
   try {
     while (r.next()) {
       GregorianCalendar g = new GregorianCalendar();
       g.setTime(r.getDate(5));
       BlockManager.loadBlock(
           (new Location(Bukkit.getWorld(r.getString(1)), r.getInt(2), r.getInt(3), r.getInt(4)))
               .getBlock(),
           g,
           r.getInt(6));
     }
   } catch (SQLException e) {
     e.printStackTrace();
   }
 }
  private static void parseFinancialDataFromXml(
      List<FinancialDataClass> list, int xmlResource, Resources resources) {
    BufferedReader reader =
        new BufferedReader(new InputStreamReader(resources.openRawResource(xmlResource)));
    try {
      String line = reader.readLine();
      while (line != null) {
        String[] tokens = line.split("\t");
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(dateFormat.parse(tokens[0], new ParsePosition(0)));
        FinancialDataClass data =
            new FinancialDataClass(
                calendar,
                Float.parseFloat(tokens[1]),
                Float.parseFloat(tokens[2]),
                Float.parseFloat(tokens[3]),
                Float.parseFloat(tokens[4]),
                Float.parseFloat(tokens[5]));
        list.add(data);
        line = reader.readLine();
      }

      reader.close();

    } catch (IOException ex) {
      list = null;
      throw new Error("Could not read financial data from xml.");
    }
  }
예제 #30
0
  public void updateCalendar(Date date, Date fromHour, Date toHour) {
    GregorianCalendar cal = new GregorianCalendar();
    cal.setTime(date);
    int day = cal.get(Calendar.DAY_OF_WEEK);
    DayEnum dayEnum = null;
    if (Calendar.MONDAY == day) {
      dayEnum = DayEnum.MONDAY;
    }
    if (Calendar.TUESDAY == day) {
      dayEnum = DayEnum.TUESDAY;
    }
    if (Calendar.WEDNESDAY == day) {
      dayEnum = DayEnum.WEDNESDAY;
    }
    if (Calendar.THURSDAY == day) {
      dayEnum = DayEnum.THURSDAY;
    }
    if (Calendar.FRIDAY == day) {
      dayEnum = DayEnum.FRIDAY;
    }
    if (Calendar.SUNDAY == day) {
      dayEnum = DayEnum.SUNDAY;
    }
    if (Calendar.SATURDAY == day) {
      dayEnum = DayEnum.SATURDAY;
    }

    for (DayRange dayRange : calendar) {

      if (dayRange.getDayEnum().equals(dayEnum)) {
        dayRange.setRange(fromHour, toHour);
        dayRange.save();
      }
    }
  }