Tilman
1547 lines
49 KiB
Java
1547 lines
49 KiB
Java
/* Copyright (c) 2008 Google Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
|
|
package sample.contacts;
|
|
|
|
import com.google.gdata.data.DateTime;
|
|
import com.google.gdata.data.PlainTextConstruct;
|
|
import com.google.gdata.data.contacts.BillingInformation;
|
|
import com.google.gdata.data.contacts.Birthday;
|
|
import com.google.gdata.data.contacts.CalendarLink;
|
|
import com.google.gdata.data.contacts.ContactEntry;
|
|
import com.google.gdata.data.contacts.ContactGroupEntry;
|
|
import com.google.gdata.data.contacts.DirectoryServer;
|
|
import com.google.gdata.data.contacts.Event;
|
|
import com.google.gdata.data.contacts.ExternalId;
|
|
import com.google.gdata.data.contacts.Gender;
|
|
import com.google.gdata.data.contacts.GroupMembershipInfo;
|
|
import com.google.gdata.data.contacts.Hobby;
|
|
import com.google.gdata.data.contacts.Initials;
|
|
import com.google.gdata.data.contacts.Jot;
|
|
import com.google.gdata.data.contacts.Language;
|
|
import com.google.gdata.data.contacts.MaidenName;
|
|
import com.google.gdata.data.contacts.Mileage;
|
|
import com.google.gdata.data.contacts.Nickname;
|
|
import com.google.gdata.data.contacts.Occupation;
|
|
import com.google.gdata.data.contacts.Priority;
|
|
import com.google.gdata.data.contacts.Relation;
|
|
import com.google.gdata.data.contacts.Sensitivity;
|
|
import com.google.gdata.data.contacts.ShortName;
|
|
import com.google.gdata.data.contacts.Subject;
|
|
import com.google.gdata.data.contacts.UserDefinedField;
|
|
import com.google.gdata.data.contacts.Website;
|
|
import com.google.gdata.data.extensions.AdditionalName;
|
|
import com.google.gdata.data.extensions.City;
|
|
import com.google.gdata.data.extensions.Country;
|
|
import com.google.gdata.data.extensions.Email;
|
|
import com.google.gdata.data.extensions.ExtendedProperty;
|
|
import com.google.gdata.data.extensions.FamilyName;
|
|
import com.google.gdata.data.extensions.FormattedAddress;
|
|
import com.google.gdata.data.extensions.FullName;
|
|
import com.google.gdata.data.extensions.GivenName;
|
|
import com.google.gdata.data.extensions.Im;
|
|
import com.google.gdata.data.extensions.Name;
|
|
import com.google.gdata.data.extensions.NamePrefix;
|
|
import com.google.gdata.data.extensions.NameSuffix;
|
|
import com.google.gdata.data.extensions.Neighborhood;
|
|
import com.google.gdata.data.extensions.OrgDepartment;
|
|
import com.google.gdata.data.extensions.OrgJobDescription;
|
|
import com.google.gdata.data.extensions.OrgName;
|
|
import com.google.gdata.data.extensions.OrgSymbol;
|
|
import com.google.gdata.data.extensions.OrgTitle;
|
|
import com.google.gdata.data.extensions.Organization;
|
|
import com.google.gdata.data.extensions.PhoneNumber;
|
|
import com.google.gdata.data.extensions.PoBox;
|
|
import com.google.gdata.data.extensions.PostCode;
|
|
import com.google.gdata.data.extensions.Region;
|
|
import com.google.gdata.data.extensions.Street;
|
|
import com.google.gdata.data.extensions.StructuredPostalAddress;
|
|
import com.google.gdata.data.extensions.When;
|
|
import com.google.gdata.data.extensions.Where;
|
|
import com.google.gdata.util.XmlBlob;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.FileReader;
|
|
import java.io.IOException;
|
|
import java.io.PrintStream;
|
|
import java.util.List;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
|
|
/**
|
|
* Helper class to parse, update and display a contact.
|
|
* It uses a bunch of anonymous inner classes for every kind of element to
|
|
* perform the actual job. It is defined as an enum to take advantage of the
|
|
* automatic instantiation and constant-specific methods.
|
|
*
|
|
*
|
|
*/
|
|
public enum ElementHelper implements ElementHelperInterface {
|
|
|
|
BILLING_INFORMATION {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
BillingInformation billingInformation = new BillingInformation();
|
|
billingInformation.setValue(parser.get(PropertyName.VALUE));
|
|
contact.setBillingInformation(billingInformation);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasBillingInformation()) {
|
|
out.println("billing information: "
|
|
+ contact.getBillingInformation().getValue());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasBillingInformation()) {
|
|
dest.setBillingInformation(src.getBillingInformation());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<billing_information>";
|
|
}
|
|
},
|
|
|
|
BIRTHDAY {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Birthday birthday = new Birthday();
|
|
birthday.setWhen(parser.get(PropertyName.VALUE));
|
|
contact.setBirthday(birthday);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasBirthday()) {
|
|
out.println("birthday: " + contact.getBirthday().getWhen());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasBirthday()) {
|
|
dest.setBirthday(src.getBirthday());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "YYYY-MM-DD|--MM-DD";
|
|
}
|
|
},
|
|
|
|
CALENDAR_LINK(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
CalendarLink calendarLink = new CalendarLink();
|
|
calendarLink.setHref(parser.get(PropertyName.VALUE));
|
|
if (parser.has(PropertyName.REL)) {
|
|
calendarLink.setRel(
|
|
CalendarLink.Rel.valueOf(
|
|
parser.get(PropertyName.REL).toUpperCase()));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
calendarLink.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
if (parser.has(PropertyName.PRIMARY)) {
|
|
calendarLink.setPrimary(parser.is(PropertyName.PRIMARY));
|
|
}
|
|
contact.addCalendarLink(calendarLink);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasCalendarLinks()) {
|
|
out.println("calendar links:");
|
|
for (CalendarLink calendarLink : contact.getCalendarLinks()) {
|
|
out.print(" " + calendarLink.getHref());
|
|
if (calendarLink.hasRel()) {
|
|
out.print(" rel:" + calendarLink.getRel());
|
|
} else if (calendarLink.hasLabel()) {
|
|
out.print(" label:" + calendarLink.getLabel());
|
|
}
|
|
if (calendarLink.hasPrimary() && calendarLink.getPrimary()) {
|
|
out.print(" (primary)");
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasCalendarLinks()) {
|
|
List<CalendarLink> calendarLinks = dest.getCalendarLinks();
|
|
calendarLinks.clear();
|
|
calendarLinks.addAll(src.getCalendarLinks());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<href>"
|
|
+ "[,rel:<rel>]"
|
|
+ "[,label:<label>]"
|
|
+ "[,primary:true|false]";
|
|
}
|
|
},
|
|
|
|
DIRECTORY_SERVER {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
DirectoryServer directoryServer = new DirectoryServer();
|
|
directoryServer.setValue(parser.get(PropertyName.VALUE));
|
|
contact.setDirectoryServer(directoryServer);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasDirectoryServer()) {
|
|
out.println("directory server: "
|
|
+ contact.getDirectoryServer().getValue());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasDirectoryServer()) {
|
|
dest.setDirectoryServer(src.getDirectoryServer());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<directory_server>";
|
|
}
|
|
},
|
|
|
|
EMAIL(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Email email = new Email();
|
|
email.setAddress(parser.get(PropertyName.VALUE));
|
|
if (parser.has(PropertyName.REL)) {
|
|
email.setRel(parser.get(PropertyName.REL));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
email.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
if (parser.has(PropertyName.PRIMARY)) {
|
|
email.setPrimary(parser.is(PropertyName.PRIMARY));
|
|
}
|
|
contact.addEmailAddress(email);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasEmailAddresses()) {
|
|
out.println("email addresses:");
|
|
for (Email email : contact.getEmailAddresses()) {
|
|
out.print(" " + email.getAddress());
|
|
if (email.getRel() != null) {
|
|
out.print(" rel:" + email.getRel());
|
|
}
|
|
if (email.getLabel() != null) {
|
|
out.print(" label:" + email.getLabel());
|
|
}
|
|
if (email.getPrimary()) {
|
|
out.print(" (primary)");
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasEmailAddresses()) {
|
|
List<Email> emailAddresses = dest.getEmailAddresses();
|
|
emailAddresses.clear();
|
|
emailAddresses.addAll(src.getEmailAddresses());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<email>"
|
|
+ "[,rel:<rel>]"
|
|
+ "[,label:<label>]"
|
|
+ "[,primary:true|false]";
|
|
}
|
|
},
|
|
|
|
EVENT(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Event event = new Event();
|
|
When when = new When();
|
|
when.setStartTime(DateTime.parseDate(parser.get(PropertyName.VALUE)));
|
|
event.setWhen(when);
|
|
if (parser.has(PropertyName.REL)) {
|
|
event.setRel(parser.get(PropertyName.REL));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
event.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
contact.addEvent(event);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasEvents()) {
|
|
out.println("events:");
|
|
for (Event event : contact.getEvents()) {
|
|
out.print(" " + event.getWhen().getStartTime().toString());
|
|
if (event.hasRel()) {
|
|
out.print(" rel:" + event.getRel());
|
|
}
|
|
if (event.hasLabel()) {
|
|
out.print(" label:" + event.getLabel());
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasEvents()) {
|
|
List<Event> events = dest.getEvents();
|
|
events.clear();
|
|
events.addAll(src.getEvents());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<YYYY-MM-DD>"
|
|
+ "[,rel:<rel>]"
|
|
+ "[,label:<label>]";
|
|
}
|
|
},
|
|
|
|
EXTENDED_PROPERTY(true) {
|
|
/**
|
|
* Reads an XmlBlob from a file.
|
|
*
|
|
* @param f the file to be readed.
|
|
* @return the readed XmlBlog.
|
|
*
|
|
* @throws IOException in case of any IO error.
|
|
*/
|
|
private XmlBlob readFromFile(File f) throws IOException {
|
|
StringBuffer xmlBuffer = new StringBuffer();
|
|
BufferedReader reader = null;
|
|
try {
|
|
reader = new BufferedReader(new FileReader(f));
|
|
String line;
|
|
while ((line = reader.readLine()) != null) {
|
|
xmlBuffer.append(line);
|
|
}
|
|
} finally {
|
|
if (reader != null) {
|
|
reader.close();
|
|
}
|
|
}
|
|
XmlBlob xmlBlob = new XmlBlob();
|
|
xmlBlob.setBlob(new String(xmlBuffer));
|
|
return xmlBlob;
|
|
}
|
|
|
|
/**
|
|
* Parses an ExtendedProperty.
|
|
*
|
|
* @param parser the parser used for the parsing of the description.
|
|
* @return the parsed in ExtendedProperty.
|
|
*/
|
|
private ExtendedProperty parse(ElementParser parser) {
|
|
ExtendedProperty extendedProperty = new ExtendedProperty();
|
|
extendedProperty.setName(parser.get(PropertyName.VALUE));
|
|
if (parser.has(PropertyName.FILE)) {
|
|
File f = new File(parser.get(PropertyName.FILE));
|
|
if (!f.exists()) {
|
|
throw new RuntimeException("No Such File:" +
|
|
parser.get(PropertyName.FILE));
|
|
}
|
|
try {
|
|
extendedProperty.setXmlBlob(readFromFile(f));
|
|
} catch (IOException ex) {
|
|
throw new RuntimeException("Failed to read file "
|
|
+ parser.get(PropertyName.FILE));
|
|
}
|
|
} else if (parser.has(PropertyName.TEXT)) {
|
|
extendedProperty.setValue(parser.get(PropertyName.TEXT));
|
|
}
|
|
return extendedProperty;
|
|
}
|
|
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
ExtendedProperty extendedProperty = parse(parser);
|
|
contact.addExtendedProperty(extendedProperty);
|
|
}
|
|
|
|
public void parseGroup(ContactGroupEntry group, ElementParser parser) {
|
|
ExtendedProperty extendedProperty = parse(parser);
|
|
group.addExtendedProperty(extendedProperty);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasExtendedProperties()) {
|
|
out.println("extended properties:");
|
|
for (ExtendedProperty property : contact.getExtendedProperties()) {
|
|
out.print(" " + property.getName());
|
|
if (property.hasValue()) {
|
|
out.print(" value:" + property.getValue());
|
|
} else {
|
|
out.print(" xmlBlob:" + property.getXmlBlob());
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasExtendedProperties()) {
|
|
List<ExtendedProperty> extendedProps = dest.getExtendedProperties();
|
|
extendedProps.clear();
|
|
extendedProps.addAll(src.getExtendedProperties());
|
|
}
|
|
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<name>,text:<value>|file:<XmlFilePath>";
|
|
}
|
|
},
|
|
|
|
EXTERNAL_ID(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
ExternalId externalId = new ExternalId();
|
|
externalId.setValue(parser.get(PropertyName.VALUE));
|
|
if (parser.has(PropertyName.REL)) {
|
|
externalId.setRel(parser.get(PropertyName.REL));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
externalId.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
contact.addExternalId(externalId);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasExternalIds()) {
|
|
out.println("external ids:");
|
|
for (ExternalId externalId : contact.getExternalIds()) {
|
|
out.print(" " + externalId.getValue());
|
|
if (externalId.hasRel()) {
|
|
out.print(" rel:" + externalId.getRel());
|
|
}
|
|
if (externalId.hasLabel()) {
|
|
out.print(" label:" + externalId.getLabel());
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasExternalIds()) {
|
|
List<ExternalId> externalIds = dest.getExternalIds();
|
|
externalIds.clear();
|
|
externalIds.addAll(src.getExternalIds());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<external_id>,rel:<rel>|label:<label>";
|
|
}
|
|
},
|
|
|
|
GENDER {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Gender gender = new Gender();
|
|
String value = parser.get(PropertyName.VALUE);
|
|
if (value.equals("male")) {
|
|
gender.setValue(Gender.Value.MALE);
|
|
} else if (value.equals("female")) {
|
|
gender.setValue(Gender.Value.FEMALE);
|
|
} else {
|
|
throw new IllegalArgumentException("gender should be male or female");
|
|
}
|
|
contact.setGender(gender);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasGender()) {
|
|
out.println("gender: "
|
|
+ contact.getGender().getValue().toString().toLowerCase());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasGender()) {
|
|
dest.setGender(src.getGender());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "male|female";
|
|
}
|
|
},
|
|
|
|
GROUP_MEMBERSHIP_INFO(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
GroupMembershipInfo groupMembershipInfo = new GroupMembershipInfo();
|
|
groupMembershipInfo.setHref(parser.get(PropertyName.VALUE));
|
|
contact.addGroupMembershipInfo(groupMembershipInfo);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasGroupMembershipInfos()) {
|
|
out.println("group membership info:");
|
|
for (GroupMembershipInfo group : contact.getGroupMembershipInfos()) {
|
|
out.print(" " + group.getHref());
|
|
if (group.getDeleted()) {
|
|
out.print(" (deleted)");
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasGroupMembershipInfos()) {
|
|
List<GroupMembershipInfo> groupMembershipInfos
|
|
= dest.getGroupMembershipInfos();
|
|
groupMembershipInfos.clear();
|
|
groupMembershipInfos.addAll(src.getGroupMembershipInfos());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<url>";
|
|
}
|
|
},
|
|
|
|
HOBBY(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Hobby hobby = new Hobby();
|
|
hobby.setValue(parser.get(PropertyName.VALUE));
|
|
contact.addHobby(hobby);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasHobbies()) {
|
|
out.println("hobbies:");
|
|
for (Hobby hobby : contact.getHobbies()) {
|
|
out.println(" " + hobby.getValue());
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasHobbies()) {
|
|
List<Hobby> hobbies = dest.getHobbies();
|
|
hobbies.clear();
|
|
hobbies.addAll(src.getHobbies());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<hobby>";
|
|
}
|
|
},
|
|
|
|
IM(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Im im = new Im();
|
|
im.setAddress(parser.get(PropertyName.VALUE));
|
|
if (parser.has(PropertyName.REL)) {
|
|
im.setRel(parser.get(PropertyName.REL));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
im.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
if (parser.has(PropertyName.PROTOCOL)) {
|
|
im.setProtocol(parser.get(PropertyName.PROTOCOL));
|
|
}
|
|
if (parser.has(PropertyName.PRIMARY)) {
|
|
im.setPrimary(parser.is(PropertyName.PRIMARY));
|
|
}
|
|
contact.addImAddress(im);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasImAddresses()) {
|
|
out.println("im addresses:");
|
|
for (Im im : contact.getImAddresses()) {
|
|
out.print(" " + im.getAddress());
|
|
if (im.hasRel()) {
|
|
out.print(" rel:" + im.getRel());
|
|
} else if (im.hasLabel()) {
|
|
out.print(" label:" + im.getLabel());
|
|
}
|
|
if (im.hasProtocol()) {
|
|
out.print(" protocol:" + im.getProtocol());
|
|
}
|
|
if (im.getPrimary()) {
|
|
out.print(" (primary)");
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasImAddresses()) {
|
|
List<Im> ims = dest.getImAddresses();
|
|
ims.clear();
|
|
ims.addAll(src.getImAddresses());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<im>"
|
|
+ "[,rel:<rel>]"
|
|
+ "[,label:<label>]"
|
|
+ "[,protocol:<protocol>]"
|
|
+ "[,primary:true|false]";
|
|
}
|
|
},
|
|
|
|
INITIALS {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Initials initials = new Initials();
|
|
initials.setValue(parser.get(PropertyName.VALUE));
|
|
contact.setInitials(initials);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasInitials()) {
|
|
out.println("initials: " + contact.getInitials().getValue());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasInitials()) {
|
|
dest.setInitials(src.getInitials());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<initials>";
|
|
}
|
|
},
|
|
|
|
JOT(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Jot jot = new Jot();
|
|
jot.setValue(parser.get(PropertyName.VALUE));
|
|
if (parser.has(PropertyName.REL)) {
|
|
jot.setRel(Jot.Rel.valueOf(parser.get(PropertyName.REL).toUpperCase()));
|
|
}
|
|
contact.addJot(jot);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasJots()) {
|
|
out.println("jots:");
|
|
for (Jot jot : contact.getJots()) {
|
|
out.print(" " + jot.getValue());
|
|
if (jot.hasRel()) {
|
|
out.print(" rel:" + jot.getRel().toString().toLowerCase());
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasJots()) {
|
|
List<Jot> jots = dest.getJots();
|
|
jots.clear();
|
|
jots.addAll(src.getJots());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<jot>"
|
|
+ "[,rel:home|work|other|keywords|user]";
|
|
}
|
|
},
|
|
|
|
LANGUAGE(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Language language = new Language();
|
|
language.setLabel(parser.get(PropertyName.VALUE));
|
|
contact.addLanguage(language);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasLanguages()) {
|
|
out.println("languages:");
|
|
for (Language language : contact.getLanguages()) {
|
|
out.println(" " + language.getLabel());
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasLanguages()) {
|
|
List<Language> languages = dest.getLanguages();
|
|
languages.clear();
|
|
languages.addAll(src.getLanguages());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<language>";
|
|
}
|
|
},
|
|
|
|
WHERE {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
contact.setWhere(new Where(null, null, parser.get(PropertyName.VALUE)));
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasWhere()) {
|
|
out.println("where: " + contact.getWhere().getValueString());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasWhere()) {
|
|
dest.setWhere(src.getWhere());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<where>";
|
|
}
|
|
},
|
|
|
|
|
|
MAIDEN_NAME {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
MaidenName maidenName = new MaidenName();
|
|
maidenName.setValue(parser.get(PropertyName.VALUE));
|
|
contact.setMaidenName(maidenName);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasMaidenName()) {
|
|
out.println("maiden name: " + contact.getMaidenName().getValue());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasMaidenName()) {
|
|
dest.setMaidenName(src.getMaidenName());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<maiden_name>";
|
|
}
|
|
},
|
|
|
|
MILEAGE {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Mileage mileage = new Mileage();
|
|
mileage.setValue(parser.get(PropertyName.VALUE));
|
|
contact.setMileage(mileage);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasMileage()) {
|
|
out.println("mileage: " + contact.getMileage().getValue());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasMileage()) {
|
|
dest.setMileage(src.getMileage());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<mileage>";
|
|
}
|
|
},
|
|
|
|
NAME {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Name name = new Name();
|
|
name.setFullName(new FullName(parser.get(PropertyName.VALUE), null));
|
|
if (parser.has(PropertyName.GIVEN)) {
|
|
name.setGivenName(new GivenName(parser.get(PropertyName.GIVEN), null));
|
|
}
|
|
if (parser.has(PropertyName.FAMILY)) {
|
|
name.setFamilyName(
|
|
new FamilyName(parser.get(PropertyName.FAMILY), null));
|
|
}
|
|
if (parser.has(PropertyName.ADDITIONAL)) {
|
|
name.setAdditionalName(
|
|
new AdditionalName(parser.get(PropertyName.ADDITIONAL), null));
|
|
}
|
|
if (parser.has(PropertyName.PREFIX)) {
|
|
name.setNamePrefix(new NamePrefix(parser.get(PropertyName.PREFIX)));
|
|
}
|
|
if (parser.has(PropertyName.SUFFIX)) {
|
|
name.setNameSuffix(new NameSuffix(parser.get(PropertyName.SUFFIX)));
|
|
}
|
|
contact.setName(name);
|
|
}
|
|
|
|
public void parseGroup(ContactGroupEntry group, ElementParser parser) {
|
|
group.setTitle(new PlainTextConstruct(parser.get(PropertyName.VALUE)));
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasName()) {
|
|
out.println("structured name: ");
|
|
Name name = contact.getName();
|
|
if (name.hasFullName()) {
|
|
out.print(" full name: " + name.getFullName().getValue());
|
|
}
|
|
if (name.hasGivenName()) {
|
|
out.print(" given name: " + name.getGivenName().getValue());
|
|
}
|
|
if (name.hasFamilyName()) {
|
|
out.print(" family name: " + name.getFamilyName().getValue());
|
|
}
|
|
if (name.hasAdditionalName()) {
|
|
out.print(" additional name: " + name.getAdditionalName().getValue());
|
|
}
|
|
if (name.hasNamePrefix()) {
|
|
out.print(" prefix: " + name.getNamePrefix().getValue());
|
|
}
|
|
if (name.hasNameSuffix()) {
|
|
out.print(" suffix: " + name.getNameSuffix().getValue());
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasName()) {
|
|
dest.setName(src.getName());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<name>"
|
|
+ "[,given:<givenName]"
|
|
+ "[,family:<familyName>]"
|
|
+ "[,additional:additionalName]"
|
|
+ "[,prefix:<prefix>]"
|
|
+ "[,suffix:<suffix>]";
|
|
}
|
|
},
|
|
|
|
NICKNAME {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Nickname nickname = new Nickname();
|
|
nickname.setValue(parser.get(PropertyName.VALUE));
|
|
contact.setNickname(nickname);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasNickname()) {
|
|
out.println("nickname: " + contact.getNickname().getValue());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasNickname()) {
|
|
dest.setNickname(src.getNickname());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<nickname>";
|
|
}
|
|
},
|
|
|
|
NOTES {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
contact.setContent(
|
|
new PlainTextConstruct(parser.get(PropertyName.VALUE)));
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.getContent() != null) {
|
|
out.println("notes: "
|
|
+ contact.getTextContent().getContent().getPlainText());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.getContent() != null) {
|
|
dest.setContent(src.getContent());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<notes>";
|
|
}
|
|
},
|
|
|
|
OCCUPATION {
|
|
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Occupation occupation = new Occupation();
|
|
occupation.setValue(parser.get(PropertyName.VALUE));
|
|
contact.setOccupation(occupation);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasOccupation()) {
|
|
out.println("occupation: " + contact.getOccupation().getValue());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasOccupation()) {
|
|
dest.setOccupation(src.getOccupation());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<occupation>";
|
|
}
|
|
},
|
|
|
|
ORGANIZATION(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Organization org = new Organization();
|
|
org.setOrgName(new OrgName(parser.get(PropertyName.VALUE)));
|
|
if (parser.has(PropertyName.DEPARTMENT)) {
|
|
org.setOrgDepartment(
|
|
new OrgDepartment(parser.get(PropertyName.DEPARTMENT)));
|
|
}
|
|
if (parser.has(PropertyName.REL)) {
|
|
org.setRel(parser.get(PropertyName.REL));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
org.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
if (parser.has(PropertyName.TITLE)) {
|
|
org.setOrgTitle(new OrgTitle(parser.get(PropertyName.TITLE)));
|
|
}
|
|
if (parser.has(PropertyName.SYMBOL)) {
|
|
org.setOrgSymbol(new OrgSymbol(parser.get(PropertyName.SYMBOL)));
|
|
}
|
|
if (parser.has(PropertyName.DESCRIPTION)) {
|
|
org.setOrgJobDescription(
|
|
new OrgJobDescription(parser.get(PropertyName.DESCRIPTION)));
|
|
}
|
|
if (parser.has(PropertyName.WHERE)) {
|
|
Where where = new Where();
|
|
where.setValueString(parser.get(PropertyName.WHERE));
|
|
org.setWhere(where);
|
|
}
|
|
contact.addOrganization(org);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasOrganizations()) {
|
|
out.println("organizations:");
|
|
for (Organization organization : contact.getOrganizations()) {
|
|
out.print(" " + organization.getOrgName().getValue());
|
|
if (organization.hasRel()) {
|
|
out.print(" rel:" + organization.getRel());
|
|
}
|
|
if (organization.hasLabel()) {
|
|
out.print(" label:" + organization.getLabel());
|
|
}
|
|
if (organization.hasOrgDepartment()) {
|
|
out.print(" department:"
|
|
+ organization.getOrgDepartment().getValue());
|
|
}
|
|
if (organization.hasOrgTitle()) {
|
|
out.print(" title:" + organization.getOrgTitle().getValue());
|
|
}
|
|
if (organization.hasOrgSymbol()) {
|
|
out.print(" symbol:" + organization.getOrgSymbol().getValue());
|
|
}
|
|
if (organization.hasWhere()) {
|
|
out.print(" where:" + organization.getWhere().getValueString());
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasOrganizations()) {
|
|
List<Organization> organizations = dest.getOrganizations();
|
|
organizations.clear();
|
|
organizations.addAll(src.getOrganizations());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<name>"
|
|
+ "[,rel:<rel>]"
|
|
+ "[,label<label>]"
|
|
+ "[,primary:true|false]"
|
|
+ "[,department:<department>]"
|
|
+ "[,description:<description>]"
|
|
+ "[,symbol:<symbol>]"
|
|
+ "[,title:<title>]"
|
|
+ "[,where:<where>]";
|
|
}
|
|
},
|
|
|
|
PHONE(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
PhoneNumber phone = new PhoneNumber();
|
|
phone.setPhoneNumber(parser.get(PropertyName.VALUE));
|
|
if (parser.has(PropertyName.REL)) {
|
|
phone.setRel(parser.get(PropertyName.REL));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
phone.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
if (parser.has(PropertyName.URI)) {
|
|
phone.setUri(parser.get(PropertyName.URI));
|
|
}
|
|
if (parser.has(PropertyName.PRIMARY)) {
|
|
phone.setPrimary(parser.is(PropertyName.PRIMARY));
|
|
}
|
|
contact.addPhoneNumber(phone);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasPhoneNumbers()) {
|
|
out.println("phone numbers:");
|
|
for (PhoneNumber phone : contact.getPhoneNumbers()) {
|
|
out.print(" " + phone.getPhoneNumber());
|
|
if (phone.getRel() != null) {
|
|
out.print(" rel:" + phone.getRel());
|
|
}
|
|
if (phone.getLabel() != null) {
|
|
out.print(" label:" + phone.getLabel());
|
|
}
|
|
if (phone.getUri() != null) {
|
|
out.print(" uri:" + phone.getUri());
|
|
}
|
|
if (phone.getPrimary()) {
|
|
out.print(" (primary)");
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasPhoneNumbers()) {
|
|
List<PhoneNumber> phoneNumbers = dest.getPhoneNumbers();
|
|
phoneNumbers.clear();
|
|
phoneNumbers.addAll(src.getPhoneNumbers());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<phone>"
|
|
+ "[,rel:<rel>]"
|
|
+ "[,label:<label>]"
|
|
+ "[,uri:<uri>]"
|
|
+ "[,primary:true|false]";
|
|
}
|
|
},
|
|
|
|
PRIORITY {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Priority priority = new Priority();
|
|
priority.setRel(
|
|
Priority.Rel.valueOf(parser.get(PropertyName.VALUE).toUpperCase()));
|
|
contact.setPriority(priority);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasPriority()) {
|
|
out.println("priority: "
|
|
+ contact.getPriority().getRel().toString().toLowerCase());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasPriority()) {
|
|
dest.setPriority(src.getPriority());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "low|normal|high";
|
|
}
|
|
},
|
|
|
|
RELATION(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Relation relation = new Relation();
|
|
relation.setValue(parser.get(PropertyName.VALUE));
|
|
if (parser.has(PropertyName.REL)) {
|
|
relation.setRel(
|
|
Relation.Rel.valueOf(parser.get(PropertyName.REL).toUpperCase()));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
relation.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
contact.addRelation(relation);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasRelations()) {
|
|
out.println("relations:");
|
|
for (Relation relation : contact.getRelations()) {
|
|
out.print(" " + relation.getValue());
|
|
if (relation.hasLabel()) {
|
|
out.print(" label:" + relation.getLabel());
|
|
} else if (relation.hasRel()) {
|
|
out.print(" rel:" + relation.getRel().toString().toLowerCase());
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasRelations()) {
|
|
List<Relation> relations = dest.getRelations();
|
|
relations.clear();
|
|
relations.addAll(src.getRelations());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<relation>"
|
|
+ "[,label:<label>]"
|
|
+ "[,rel:<rel>]";
|
|
}
|
|
},
|
|
|
|
SENSITIVITY {
|
|
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Sensitivity sensitivity = new Sensitivity();
|
|
sensitivity.setRel(
|
|
Sensitivity.Rel.valueOf(
|
|
parser.get(PropertyName.VALUE).toUpperCase()));
|
|
contact.setSensitivity(sensitivity);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasSensitivity()) {
|
|
out.println("sensitivity:"
|
|
+ contact.getSensitivity().getRel().toString().toLowerCase());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasSensitivity()) {
|
|
dest.setSensitivity(src.getSensitivity());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "confidental|normal|personal|private";
|
|
}
|
|
},
|
|
|
|
SHORT_NAME {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
ShortName shortName = new ShortName();
|
|
shortName.setValue(parser.get(PropertyName.VALUE));
|
|
contact.setShortName(shortName);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasShortName()) {
|
|
out.println("short name:" + contact.getShortName().getValue());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasShortName()) {
|
|
dest.setShortName(src.getShortName());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<short_name>";
|
|
}
|
|
},
|
|
|
|
POSTAL(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
StructuredPostalAddress address = new StructuredPostalAddress();
|
|
if (parser.has(PropertyName.REL)) {
|
|
address.setRel(parser.get(PropertyName.REL));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
address.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
if (parser.has(PropertyName.PRIMARY)) {
|
|
address.setPrimary(parser.is(PropertyName.PRIMARY));
|
|
}
|
|
if (parser.has(PropertyName.CITY)) {
|
|
address.setCity(new City(parser.get(PropertyName.CITY)));
|
|
}
|
|
if (parser.has(PropertyName.COUNTRY)) {
|
|
// Don't care about country code
|
|
address.setCountry(new Country(null, parser.get(PropertyName.COUNTRY)));
|
|
}
|
|
if (parser.has(PropertyName.FORMATTED)) {
|
|
address.setFormattedAddress(
|
|
new FormattedAddress(parser.get(PropertyName.FORMATTED)));
|
|
}
|
|
if (parser.has(PropertyName.NEIGHBORHOOD)) {
|
|
address.setNeighborhood(
|
|
new Neighborhood(parser.get(PropertyName.NEIGHBORHOOD)));
|
|
}
|
|
if (parser.has(PropertyName.POBOX)) {
|
|
address.setPobox(new PoBox(parser.get(PropertyName.POBOX)));
|
|
}
|
|
if (parser.has(PropertyName.POSTCODE)) {
|
|
address.setPostcode(new PostCode(parser.get(PropertyName.POSTCODE)));
|
|
}
|
|
if (parser.has(PropertyName.REGION)) {
|
|
address.setRegion(new Region(parser.get(PropertyName.REGION)));
|
|
}
|
|
if (parser.has(PropertyName.STREET)) {
|
|
address.setStreet(new Street(parser.get(PropertyName.STREET)));
|
|
}
|
|
contact.addStructuredPostalAddress(address);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasStructuredPostalAddresses()) {
|
|
out.println("addresses:");
|
|
for (StructuredPostalAddress address
|
|
: contact.getStructuredPostalAddresses()) {
|
|
out.print(" ");
|
|
if (address.hasRel()) {
|
|
out.print(" rel:" + address.getRel());
|
|
}
|
|
if (address.hasLabel()) {
|
|
out.print(" label:" + address.getLabel());
|
|
}
|
|
if (address.hasCity()) {
|
|
out.print(" city:" + address.getCity().getValue());
|
|
}
|
|
if (address.hasCountry()) {
|
|
out.print(" country:" + address.getCountry().getValue());
|
|
}
|
|
if (address.hasFormattedAddress()) {
|
|
out.print(" formatted:" + address.getFormattedAddress().getValue());
|
|
}
|
|
if (address.hasNeighborhood()) {
|
|
out.print(" neighborhood:" + address.getNeighborhood().getValue());
|
|
}
|
|
if (address.hasPobox()) {
|
|
out.print(" pobox:" + address.getPobox().getValue());
|
|
}
|
|
if (address.hasPostcode()) {
|
|
out.print(" postcode:" + address.getPostcode().getValue());
|
|
}
|
|
if (address.hasRegion()) {
|
|
out.print(" region:" + address.getRegion().getValue());
|
|
}
|
|
if (address.hasStreet()) {
|
|
out.print(" street:" + address.getStreet().getValue());
|
|
}
|
|
if (address.getPrimary()) {
|
|
out.print(" (primary)");
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasStructuredPostalAddresses()) {
|
|
List<StructuredPostalAddress> structuredPostalAddresses =
|
|
dest.getStructuredPostalAddresses();
|
|
structuredPostalAddresses.clear();
|
|
structuredPostalAddresses.addAll(src.getStructuredPostalAddresses());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "[rel:<rel>]"
|
|
+ "[,label:<label>]"
|
|
+ "[,primary:true|false]"
|
|
+ "[,city:<city>]"
|
|
+ "[,country:<country>]"
|
|
+ "[,formatted:<formattedAddress>]"
|
|
+ "[,neighborhood:<neighborhood>]"
|
|
+ "[,pobox:<poBox>]"
|
|
+ "[,postcode:<postCode>]"
|
|
+ "[,region:<region>]"
|
|
+ "[,street:<street>]";
|
|
}
|
|
},
|
|
|
|
SUBJECT {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Subject subject = new Subject();
|
|
subject.setValue(parser.get(PropertyName.VALUE));
|
|
contact.setSubject(subject);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasSubject()) {
|
|
out.println("subject:" + contact.getSubject().getValue());
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasSubject()) {
|
|
dest.setSubject(src.getSubject());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<subject>";
|
|
}
|
|
},
|
|
|
|
USER_DEFINED_FIELD(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
UserDefinedField userDefinedField = new UserDefinedField();
|
|
userDefinedField.setValue(parser.get(PropertyName.VALUE));
|
|
userDefinedField.setKey(parser.get(PropertyName.KEY));
|
|
contact.addUserDefinedField(userDefinedField);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasUserDefinedFields()) {
|
|
out.println("user defined fields:");
|
|
for (UserDefinedField field : contact.getUserDefinedFields()) {
|
|
out.println(" " + field.getValue() + " key: " + field.getKey());
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasUserDefinedFields()) {
|
|
List<UserDefinedField> userDefinedFields = dest.getUserDefinedFields();
|
|
userDefinedFields.clear();
|
|
userDefinedFields.addAll(src.getUserDefinedFields());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<value>,key:<key>";
|
|
}
|
|
},
|
|
|
|
WEBSITE(true) {
|
|
public void parse(ContactEntry contact, ElementParser parser) {
|
|
Website website = new Website();
|
|
website.setHref(parser.get(PropertyName.VALUE));
|
|
if (parser.has(PropertyName.REL)) {
|
|
website.setRel(
|
|
Website.Rel.valueOf(parser.get(PropertyName.REL).toLowerCase()));
|
|
}
|
|
if (parser.has(PropertyName.LABEL)) {
|
|
website.setLabel(parser.get(PropertyName.LABEL));
|
|
}
|
|
if (parser.has(PropertyName.PRIMARY)) {
|
|
website.setPrimary(parser.is(PropertyName.PRIMARY));
|
|
}
|
|
contact.addWebsite(website);
|
|
}
|
|
|
|
public void print(PrintStream out, ContactEntry contact) {
|
|
if (contact.hasWebsites()) {
|
|
out.println("websites:");
|
|
for (Website website : contact.getWebsites()) {
|
|
out.print(" " + website.getHref());
|
|
if (website.hasRel()) {
|
|
out.print(" ref:" + website.getRel().toString().toLowerCase());
|
|
}
|
|
if (website.hasLabel()) {
|
|
out.print(" label:" + website.getLabel());
|
|
}
|
|
if (website.getPrimary()) {
|
|
out.print(" (primary)");
|
|
}
|
|
out.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void update(ContactEntry dest, ContactEntry src) {
|
|
if (src.hasWebsites()) {
|
|
List<Website> websites = dest.getWebsites();
|
|
websites.clear();
|
|
websites.addAll(src.getWebsites());
|
|
}
|
|
}
|
|
|
|
public String getUsage() {
|
|
return "<url>"
|
|
+ "[,rel:<rel>]"
|
|
+ "[label:<label>]"
|
|
+ "[,primary:true|false]";
|
|
}
|
|
};
|
|
|
|
// Flag to indicate if the element can be repeated.
|
|
private final boolean repetable;
|
|
|
|
// some regexp for parameter parsing/checking
|
|
private final static Pattern REPEATED_ARG_PATTERN
|
|
= Pattern.compile("^(\\D+)\\d*$");
|
|
|
|
// Constructors.
|
|
private ElementHelper(boolean repetable) { this.repetable = repetable; }
|
|
private ElementHelper() { this(false); }
|
|
|
|
/**
|
|
* The default implementation just throws an UnsuportedOperationException, and
|
|
* only those helpers override it, what are used in parsing groups elements.
|
|
*
|
|
* @param group the group the parsed element should be added or set.
|
|
* @param parser the parser used for the parsing of the description.
|
|
*
|
|
* @throws UnsupportedOperationException in case the specific element can not
|
|
* be set on a ContactGroupEntry.
|
|
*
|
|
* @see ElementParser
|
|
*/
|
|
public void parseGroup(ContactGroupEntry group, ElementParser parser) {
|
|
throw new UnsupportedOperationException("parseGroup not supported for"
|
|
+ this.toString().toLowerCase() + " element");
|
|
}
|
|
|
|
private static ElementHelper find(String name)
|
|
throws IllegalArgumentException {
|
|
Matcher m = REPEATED_ARG_PATTERN.matcher(name);
|
|
if (!m.matches()) {
|
|
throw new IllegalArgumentException("badly formated parameter: " + name);
|
|
}
|
|
try {
|
|
return valueOf(m.group(1).toUpperCase());
|
|
} catch (IllegalArgumentException ex) {
|
|
throw new IllegalArgumentException("unknown parameter: " + name);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Builds a contact from the list of element descriptions.
|
|
* It delegates the element specific parsing to the appropriate helper
|
|
* instances. The actual element type is matched by the name of the enum
|
|
* instance, so the element names specified in the parameters should (almost)
|
|
* match the name of enum instances. The exceptions are those elements what
|
|
* can be repeated, when the parameter format is "name<n>".* Due to this
|
|
* formating convention we cannot use directly the valueOf() facility of the
|
|
* enum.
|
|
*
|
|
* @param contact the contact to build.
|
|
* @param parameters list of element descriptions.
|
|
*
|
|
*/
|
|
public static void buildContact(ContactEntry contact,
|
|
List<String> parameters) {
|
|
for (String string : parameters) {
|
|
if (!string.startsWith("--")) {
|
|
throw new IllegalArgumentException("unknown argument: " + string);
|
|
}
|
|
String param = string.substring(2);
|
|
String params[] = param.split("=", 2);
|
|
if (params.length != 2) {
|
|
throw new IllegalArgumentException("badly formated argument: "
|
|
+ string);
|
|
}
|
|
ElementHelper helper = find(params[0]);
|
|
if (helper == null) {
|
|
throw new IllegalArgumentException("unknown argument: " + string);
|
|
}
|
|
helper.parse(contact, new ElementParser(params[1]));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Builds a group from the list of element descriptions.
|
|
* It delegates the element specific parsing to the appropriate helper
|
|
* instances. The actual element type is matched by the name of the enum
|
|
* instance, so the element names specified in the parameters should (almost)
|
|
* match the name of enum instances. The exceptions are those elements what
|
|
* can be repeated, when the parameter format is "name<n>".* Due to this
|
|
* formating convention we cannot use directly the valueOf() facility of the
|
|
* enum.
|
|
*
|
|
* @param group the group to build.
|
|
* @param parameters list of element descriptions.
|
|
*
|
|
*/
|
|
public static void buildGroup(ContactGroupEntry group,
|
|
List<String> parameters) {
|
|
for (String string : parameters) {
|
|
if (!string.startsWith("--")) {
|
|
throw new IllegalArgumentException("unknown argument: " + string);
|
|
}
|
|
String param = string.substring(2);
|
|
String params[] = param.split("=", 2);
|
|
if (params.length != 2) {
|
|
throw new IllegalArgumentException("badly formated argument: "
|
|
+ string);
|
|
}
|
|
ElementHelper helper = find(params[0]);
|
|
if (helper == null) {
|
|
throw new IllegalArgumentException("unknown argument: " + string);
|
|
}
|
|
helper.parseGroup(group, new ElementParser(params[1]));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates the elements of a contact entry based on the elements of another
|
|
* contact entry.
|
|
* Those elements are replaced in the destination contact entry what are
|
|
* exists in the source contact. Those elements not contained by the source
|
|
* contact are left unchanged on the destination contact.
|
|
*
|
|
* @param dest the destination contact to be updated.
|
|
* @param src the source contact
|
|
*/
|
|
public static void updateContact(ContactEntry dest, ContactEntry src) {
|
|
for (ElementHelper helper : values()) {
|
|
helper.update(dest, src);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints the content of the contact in a human readable form.
|
|
*
|
|
* @param out the stream to print to.
|
|
* @param contact the contact to be printed out.
|
|
*/
|
|
public static void printContact(PrintStream out, ContactEntry contact) {
|
|
for (ElementHelper helper : values()) {
|
|
helper.print(out, contact);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gives the usage help text of all elements.
|
|
*
|
|
* @return the usage help text for all elements.
|
|
*/
|
|
public static String getUsageString() {
|
|
StringBuffer buffer = new StringBuffer();
|
|
for (ElementHelper helper : values()) {
|
|
buffer.append(" --" + helper.toString().toLowerCase());
|
|
if (helper.repetable) {
|
|
buffer.append("<n>");
|
|
}
|
|
buffer.append("=" + helper.getUsage() + "\n");
|
|
}
|
|
buffer.append(
|
|
"Notes! <n> is a unique number for the field - several fields\n"
|
|
+ " of the same type can be present (example: im1, im2, im3).\n"
|
|
+ " Available rels and protocols can be looked up in the \n"
|
|
+ " feed documentation.\n");
|
|
return buffer.toString();
|
|
}
|
|
}
|