Beispiel #1
0
  /**
   * Make a BaseComponentType component from an ical4j object. This may produce a VEvent, VTodo or
   * VJournal.
   *
   * @param val
   * @param pattern - if non-null limit returned components and values to those supplied in the
   *     pattern.
   * @return JAXBElement<? extends BaseComponentType>
   * @throws Throwable
   */
  public static JAXBElement toComponent(
      final Component val, final BaseComponentType pattern, final boolean wrapXprops)
      throws Throwable {
    if (val == null) {
      return null;
    }

    final PropertyList icprops = val.getProperties();
    ComponentList icComps = null;

    if (icprops == null) {
      // Empty component
      return null;
    }

    final JAXBElement el;

    if (val instanceof VEvent) {
      el = of.createVevent(new VeventType());
      icComps = ((VEvent) val).getAlarms();
    } else if (val instanceof VToDo) {
      el = of.createVtodo(new VtodoType());
      icComps = ((VToDo) val).getAlarms();
    } else if (val instanceof VJournal) {
      el = of.createVjournal(new VjournalType());
    } else if (val instanceof VFreeBusy) {
      el = of.createVfreebusy(new VfreebusyType());
    } else if (val instanceof VAlarm) {
      el = of.createValarm(new ValarmType());
    } else if (val instanceof VTimeZone) {
      el = of.createVtimezone(new VtimezoneType());
      icComps = ((VTimeZone) val).getObservances();
    } else if (val instanceof Daylight) {
      el = of.createDaylight(new DaylightType());
    } else if (val instanceof Standard) {
      el = of.createStandard(new StandardType());
    } else {
      throw new Exception("org.bedework.invalid.entity.type" + val.getClass().getName());
    }

    final BaseComponentType comp = (BaseComponentType) el.getValue();

    processProperties(val.getProperties(), comp, pattern, wrapXprops);

    if (Util.isEmpty(icComps)) {
      return el;
    }

    /* Process any sub-components */
    final ArrayOfComponents aoc = new ArrayOfComponents();
    comp.setComponents(aoc);

    for (final Object o : icComps) {
      @SuppressWarnings("unchecked")
      final JAXBElement<? extends BaseComponentType> subel =
          toComponent((Component) o, pattern, wrapXprops);
      aoc.getBaseComponent().add(subel);
    }

    return el;
  }
Beispiel #2
0
  static JAXBElement<? extends BasePropertyType> doProperty(
      final Property prop, final PropertyInfoIndex pii, final boolean wrapXprops) throws Throwable {
    if (prop instanceof XProperty) {
      if (!wrapXprops) {
        return null;
      }

      final XBedeworkWrapperPropType wrapper = new XBedeworkWrapperPropType();

      wrapper.setText(prop.getValue());

      processParameters(prop.getParameters(), wrapper);

      final XBedeworkWrappedNameParamType wnp = new XBedeworkWrappedNameParamType();
      wnp.setText(prop.getName());
      if (wrapper.getParameters() == null) {
        wrapper.setParameters(new ArrayOfParameters());
      }
      wrapper.getParameters().getBaseParameter().add(of.createXBedeworkWrappedName(wnp));

      return of.createXBedeworkWrapper(wrapper);
    }

    switch (pii) {
      case ACTION:
        /* ------------------- Action: Alarm -------------------- */

        ActionPropType a = new ActionPropType();
        a.setText(prop.getValue());
        return of.createAction(a);

      case ATTACH:
        /* ------------------- Attachments -------------------- */
        //          pl.add(setAttachment(att));
        return null;

      case ATTENDEE:
        /* ------------------- Attendees -------------------- */

        final AttendeePropType att = new AttendeePropType();
        att.setCalAddress(prop.getValue());
        return of.createAttendee(att);

      case BUSYTYPE:
        return null;

      case CATEGORIES:
        /* ------------------- Categories -------------------- */

        // LANG - filter on language - group language in one cat list?

        CategoriesPropType c = new CategoriesPropType();
        CategoryList cats = ((Categories) prop).getCategories();

        Iterator pit = cats.iterator();
        while (pit.hasNext()) {
          c.getText().add((String) pit.next());
        }

        return of.createCategories(c);

      case CLASS:
        /* ------------------- Class -------------------- */

        ClassPropType cl = new ClassPropType();
        cl.setText(prop.getValue());
        return of.createClass(cl);

      case COMMENT:
        /* ------------------- Comments -------------------- */

        CommentPropType cm = new CommentPropType();
        cm.setText(prop.getValue());
        return of.createComment(cm);

      case COMPLETED:
        /* ------------------- Completed -------------------- */

        CompletedPropType cmp = new CompletedPropType();
        cmp.setUtcDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
        return of.createCompleted(cmp);

      case CONTACT:
        /* ------------------- Contact -------------------- */

        // LANG
        ContactPropType ct = new ContactPropType();
        ct.setText(prop.getValue());

        return of.createContact(ct);

      case CREATED:
        /* ------------------- Created -------------------- */

        CreatedPropType created = new CreatedPropType();
        created.setUtcDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
        return of.createCreated(created);

      case DESCRIPTION:
        /* ------------------- Description -------------------- */

        DescriptionPropType desc = new DescriptionPropType();
        desc.setText(prop.getValue());
        return of.createDescription(desc);

      case DTEND:
        /* ------------------- DtEnd -------------------- */

        DtendPropType dtend = (DtendPropType) makeDateDatetime(new DtendPropType(), prop);
        return of.createDtend(dtend);

      case DTSTAMP:
        /* ------------------- DtStamp -------------------- */

        DtstampPropType dtstamp = new DtstampPropType();
        dtstamp.setUtcDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
        return of.createDtstamp(dtstamp);

      case DTSTART:
        /* ------------------- DtStart -------------------- */

        DtstartPropType dtstart = (DtstartPropType) makeDateDatetime(new DtstartPropType(), prop);
        return of.createDtstart(dtstart);

      case DUE:
        /* ------------------- Due -------------------- */

        DuePropType due = (DuePropType) makeDateDatetime(new DuePropType(), prop);
        return of.createDue(due);

      case DURATION:
        /* ------------------- Duration -------------------- */

        DurationPropType dur = new DurationPropType();

        dur.setDuration(prop.getValue());
        return of.createDuration(dur);

      case EXDATE:
        /* ------------------- ExDate --below------------ */
        return null;

      case EXRULE:
        /* ------------------- ExRule --below------------- */

        ExrulePropType er = new ExrulePropType();
        er.setRecur(doRecur(((RRule) prop).getRecur()));

        return of.createExrule(er);

      case FREEBUSY:
        /* ------------------- freebusy -------------------- */

        FreeBusy icfb = (FreeBusy) prop;
        PeriodList fbps = icfb.getPeriods();

        if (Util.isEmpty(fbps)) {
          return null;
        }

        FreebusyPropType fb = new FreebusyPropType();

        String fbtype = paramVal(prop, Parameter.FBTYPE);

        if (fbtype != null) {
          ArrayOfParameters pars = getAop(fb);

          FbtypeParamType f = new FbtypeParamType();

          f.setText(fbtype);
          JAXBElement<FbtypeParamType> param = of.createFbtype(f);
          pars.getBaseParameter().add(param);
        }

        List<PeriodType> pdl = fb.getPeriod();

        for (Object o : fbps) {
          Period p = (Period) o;
          PeriodType np = new PeriodType();

          np.setStart(XcalUtil.getXMlUTCCal(p.getStart().toString()));
          np.setEnd(XcalUtil.getXMlUTCCal(p.getEnd().toString()));
          pdl.add(np);
        }

        return of.createFreebusy(fb);

      case GEO:
        /* ------------------- Geo -------------------- */

        Geo geo = (Geo) prop;
        GeoPropType g = new GeoPropType();

        g.setLatitude(geo.getLatitude().floatValue());
        g.setLatitude(geo.getLongitude().floatValue());
        return of.createGeo(g);

      case LAST_MODIFIED:
        /* ------------------- LastModified -------------------- */

        LastModifiedPropType lm = new LastModifiedPropType();
        lm.setUtcDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
        return of.createLastModified(lm);

      case LOCATION:
        /* ------------------- Location -------------------- */

        LocationPropType l = new LocationPropType();
        l.setText(prop.getValue());

        return of.createLocation(l);

      case METHOD:
        /* ------------------- Method -------------------- */

        MethodPropType m = new MethodPropType();

        m.setText(prop.getValue());
        return of.createMethod(m);

      case ORGANIZER:
        /* ------------------- Organizer -------------------- */

        OrganizerPropType org = new OrganizerPropType();
        org.setCalAddress(prop.getValue());
        return of.createOrganizer(org);

      case PERCENT_COMPLETE:
        /* ------------------- PercentComplete -------------------- */

        PercentCompletePropType p = new PercentCompletePropType();
        p.setInteger(BigInteger.valueOf(((PercentComplete) prop).getPercentage()));

        return of.createPercentComplete(p);

      case PRIORITY:
        /* ------------------- Priority -------------------- */

        PriorityPropType pr = new PriorityPropType();
        pr.setInteger(BigInteger.valueOf(((Priority) prop).getLevel()));

        return of.createPriority(pr);

      case PRODID:
        /* ------------------- Prodid -------------------- */
        ProdidPropType prod = new ProdidPropType();
        prod.setText(prop.getValue());
        return of.createProdid(prod);

      case RDATE:
        /* ------------------- RDate ------------------- */
        // XXX Todo
        return null;

      case RECURRENCE_ID:
        /* ------------------- RecurrenceID -------------------- */

        RecurrenceIdPropType ri = new RecurrenceIdPropType();
        String strval = prop.getValue();

        if (dateOnly(prop)) {
          // RECUR - fix all day recurrences sometime
          if (strval.length() > 8) {
            // Try to fix up bad all day recurrence ids. - assume a local timezone
            strval = strval.substring(0, 8);
          }

          ri.setDate(XcalUtil.fromDtval(strval));
        } else {
          XcalUtil.initDt(ri, strval, getTzid(prop));
        }

        return of.createRecurrenceId(ri);

      case RELATED_TO:
        /* ------------------- RelatedTo -------------------- */

        RelatedToPropType rt = new RelatedToPropType();

        String relType = paramVal(prop, Parameter.RELTYPE);
        String value = paramVal(prop, Parameter.VALUE);

        if ((value == null) || "uid".equalsIgnoreCase(value)) {
          rt.setUid(prop.getValue());
        } else if ("uri".equalsIgnoreCase(value)) {
          rt.setUri(prop.getValue());
        } else {
          rt.setText(prop.getValue());
        }

        if (relType != null) {
          ArrayOfParameters pars = getAop(rt);

          ReltypeParamType r = new ReltypeParamType();
          r.setText(relType);
          JAXBElement<ReltypeParamType> param = of.createReltype(r);
          pars.getBaseParameter().add(param);
        }

        return of.createRelatedTo(rt);

      case REPEAT:
        /* ------------------- Repeat Alarm -------------------- */
        Repeat rept = (Repeat) prop;
        RepeatPropType rep = new RepeatPropType();
        rep.setInteger(BigInteger.valueOf(rept.getCount()));

        return of.createRepeat(rep);

      case REQUEST_STATUS:
        /* ------------------- RequestStatus -------------------- */

        // XXX Later
        return null;

      case RESOURCES:
        /* ------------------- Resources -------------------- */

        ResourcesPropType r = new ResourcesPropType();

        List<String> rl = r.getText();
        ResourceList rlist = ((Resources) prop).getResources();

        Iterator rlit = rlist.iterator();
        while (rlit.hasNext()) {
          rl.add((String) rlit.next());
        }

        return of.createResources(r);

      case RRULE:
        /* ------------------- RRule ------------------- */

        RrulePropType rrp = new RrulePropType();
        rrp.setRecur(doRecur(((RRule) prop).getRecur()));

        return of.createRrule(rrp);

      case SEQUENCE:
        /* ------------------- Sequence -------------------- */

        SequencePropType s = new SequencePropType();
        s.setInteger(BigInteger.valueOf(((Sequence) prop).getSequenceNo()));

        return of.createSequence(s);

      case STATUS:
        /* ------------------- Status -------------------- */

        StatusPropType st = new StatusPropType();

        st.setText(prop.getValue());
        return of.createStatus(st);

      case SUMMARY:
        /* ------------------- Summary -------------------- */

        SummaryPropType sum = new SummaryPropType();
        sum.setText(prop.getValue());
        return of.createSummary(sum);

      case TRIGGER:
        /* ------------------- Trigger - alarm -------------------- */
        TriggerPropType trig = new TriggerPropType();

        String valType = paramVal(prop, Parameter.VALUE);

        if ((valType == null) || (valType.equalsIgnoreCase(Value.DURATION.getValue()))) {
          trig.setDuration(prop.getValue());
          String rel = paramVal(prop, Parameter.RELATED);
          if (rel != null) {
            ArrayOfParameters pars = getAop(trig);

            RelatedParamType rpar = new RelatedParamType();
            rpar.setText(IcalDefs.alarmTriggerRelatedEnd);
            JAXBElement<RelatedParamType> param = of.createRelated(rpar);
            pars.getBaseParameter().add(param);
          }
        } else if (valType.equalsIgnoreCase(Value.DATE_TIME.getValue())) {
          // t.setDateTime(val.getTrigger());
          trig.setDateTime(XcalUtil.getXMlUTCCal(prop.getValue()));
        }

        return of.createTrigger(trig);

      case TRANSP:
        /* ------------------- Transp -------------------- */

        TranspPropType t = new TranspPropType();
        t.setText(prop.getValue());
        return of.createTransp(t);

      case TZID:
      case TZNAME:
      case TZOFFSETFROM:
      case TZOFFSETTO:
      case TZURL:
        return null;

      case UID:
        /* ------------------- Uid -------------------- */

        final UidPropType uid = new UidPropType();
        uid.setText(prop.getValue());
        return of.createUid(uid);

      case URL:
        /* ------------------- Url -------------------- */

        final UrlPropType u = new UrlPropType();

        u.setUri(prop.getValue());
        return of.createUrl(u);

      case VERSION:
        /* ------------------- Version - vcal only -------------------- */

        final VersionPropType vers = new VersionPropType();
        vers.setText(prop.getValue());
        return of.createVersion(vers);

      case XBEDEWORK_COST:
        /* ------------------- Cost -------------------- */

        final XBedeworkCostPropType cst = new XBedeworkCostPropType();

        cst.setText(prop.getValue());
        return of.createXBedeworkCost(cst);

      case X_BEDEWORK_CATEGORIES:
        /* ------------------- Categories -------------------- */

        final XBwCategoriesPropType xpcat = new XBwCategoriesPropType();

        xpcat.getText().add(prop.getValue());
        return of.createXBedeworkCategories(xpcat);

      case X_BEDEWORK_CONTACT:
        /* ------------------- Categories -------------------- */

        final XBwContactPropType xpcon = new XBwContactPropType();

        xpcon.setText(prop.getValue());
        return of.createXBedeworkContact(xpcon);

      case X_BEDEWORK_LOCATION:
        /* ------------------- Categories -------------------- */

        final XBwLocationPropType xploc = new XBwLocationPropType();

        xploc.setText(prop.getValue());
        return of.createXBedeworkLocation(xploc);

      default:
        if (prop instanceof XProperty) {
          /* ------------------------- x-property --------------------------- */

          /*
          final PropertyInfoIndex xpii =
                  PropertyInfoIndex.fromName(prop.getName());

          if (xpii == null) {
            return null;
          }

          return null;*/

          if (!wrapXprops) {
            return null;
          }

          final XBedeworkWrapperPropType wrapper = new XBedeworkWrapperPropType();

          processParameters(prop.getParameters(), wrapper);

          return of.createXBedeworkWrapper(wrapper);
        }
    } // switch (pii)

    return null;
  }
Beispiel #3
0
  private void makePropFilterExpr(final PropFilter filter) {
    TextMatch tm = filter.getMatch();

    if (tm == null) {
      presenceCheck(filter);
      return;
    }

    int testAllAnyProps = filter.getTestAllAny();

    String name = filter.getName();

    int cpos = name.indexOf(',');

    if ((cpos < 0) && (Util.isEmpty(filter.getParamFilters()))) {
      // No group - no params - single attribute

      if (!first) {
        if (testAllAnyProps == Filter.testAllOf) {
          sb.append(" and (");
        } else {
          sb.append(" or (");
        }
      } else {
        sb.append("(");
        first = false;
      }

      makePropFilterExpr(name, tm);

      sb.append(")");
    }

    /* TODO Do this later
    if (cpos > 0) {
      if (name.endsWith(",")) {
        // Don't do that
        return;
      }

      name = name.substring(cpos + 1);
    }

    Collection<String> anames = LdapMapping.toLdapAttrNoGroup.get(name);
    if (Util.isEmpty(anames)) {
      return;
    }

    StringBuilder sb = new StringBuilder();

    boolean first = true;

    for (String attrId: anames) {
      String ptest = makePropFilterExpr(attrId, tm);

      if (ptest == null) {
        continue;
      }

      sb.append(ptest);

      if (first) {
        first = false;
        continue;
      }

      sb.append(")");

      if (testAllAnyProps == Filter.testAllOf) {
        sb.append(" and ");
      } else {
        sb.append(" or ");
      }
    }

    return sb.toString();
     */
  }