@Override
public String doConvert() {
final InfoLines msgs = new InfoLines();
try {
final Processor proc = getProc();
proc.parse();
if (getGenerate()) {
proc.generateZoneinfoFiles(
Util.buildPath(true, getRootdir(), "/", "zoneinfo"), true); // doLinks
}
if (getCompare()) {
proc.compare(msgs);
}
for (final String msg : msgs) {
System.out.print(msg);
}
} catch (final Throwable t) {
t.printStackTrace();
msgs.exceptionMsg(t);
}
return msgs.toString();
}
/**
* 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;
}
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;
}
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();
*/
}