private DataForm createDefaultInitiationForm() {
final DataForm form = new DataForm(Form.TYPE_FORM);
final FormField field = new FormField(STREAM_DATA_FIELD_NAME);
field.setType(FormField.TYPE_LIST_SINGLE);
if (!IBB_ONLY) {
field.addOption(new FormField.Option(Socks5BytestreamManager.NAMESPACE));
}
field.addOption(new FormField.Option(InBandBytestreamManager.NAMESPACE));
form.addField(field);
return form;
}
/**
* Returns a new ReportedData if the packet is used for gathering data and includes an extension
* that matches the elementName and namespace "x","jabber:x:data".
*
* @param packet the packet used for gathering data.
* @return the data form parsed from the packet or <tt>null</tt> if there was not a form in the
* packet.
*/
public static Form getFormFrom(Packet packet) {
// Check if the packet includes the DataForm extension
final PacketExtension packetExtension = packet.getExtension("x", "jabber:x:data");
if (packetExtension != null) {
// Check if the existing DataForm is not a result of a search
final DataForm dataForm = (DataForm) packetExtension;
if (dataForm.getReportedData() == null) {
return new Form(dataForm);
}
}
// Otherwise return null
return null;
}
/**
* Returns a DataForm that serves to send this Form to the server. If the form is of type submit,
* it may contain fields with no value. These fields will be removed since they only exist to
* assist the user while editing/completing the form in a UI.
*
* @return the wrapped DataForm.
*/
public DataForm getDataFormToSend() {
if (isSubmitType()) {
// Create a new DataForm that contains only the answered fields
final DataForm dataFormToSend = new DataForm(getType());
for (final Iterator<FormField> it = getFields(); it.hasNext(); ) {
final FormField field = it.next();
if (field.getValues().hasNext()) {
dataFormToSend.addField(field);
}
}
return dataFormToSend;
}
return dataForm;
}
private FormField getStreamMethodField(DataForm form) {
FormField field = null;
for (final Iterator<FormField> it = form.getFields(); it.hasNext(); ) {
field = it.next();
if (field.getVariable().equals(STREAM_DATA_FIELD_NAME)) {
break;
}
field = null;
}
return field;
}
/**
* Sets instructions that explain how to fill out the form and what the form is about.
*
* @param instructions instructions that explain how to fill out the form.
*/
public void setInstructions(String instructions) {
// Split the instructions into multiple instructions for each existent
// newline
final ArrayList<String> instructionsList = new ArrayList<String>();
final StringTokenizer st = new StringTokenizer(instructions, "\n");
while (st.hasMoreTokens()) {
instructionsList.add(st.nextToken());
}
// Set the new list of instructions
dataForm.setInstructions(instructionsList);
}
/**
* Returns the instructions that explain how to fill out the form and what the form is about.
*
* @return instructions that explain how to fill out the form.
*/
public String getInstructions() {
final StringBuilder sb = new StringBuilder();
// Join the list of instructions together separated by newlines
for (final Iterator<String> it = dataForm.getInstructions(); it.hasNext(); ) {
sb.append(it.next());
// If this is not the last instruction then append a newline
if (it.hasNext()) {
sb.append("\n");
}
}
return sb.toString();
}
public void addFields(final DataForm serviceExtension) {
for (PermissionType type : PermissionType.values()) {
FormField field = new FormField(type.getSpecName());
field.setLabel(type.getLabel());
switch (type) {
case readFile:
field.setType(FormField.TYPE_LIST_MULTI);
if (null != readPermissions) {
addPermittedPaths(field, readPermissions);
}
break;
case writeFile:
field.setType(FormField.TYPE_LIST_MULTI);
if (null != writePermissions) {
addPermittedPaths(field, writePermissions);
}
break;
case deleteFile:
field.setType(FormField.TYPE_LIST_MULTI);
if (null != deletePermissions) {
addPermittedPaths(field, deletePermissions);
}
break;
case executeProgram:
field.setType(FormField.TYPE_LIST_MULTI);
if (null != execPermissions) {
addPermittedPaths(field, execPermissions);
}
break;
case createFileLink:
field.setType(FormField.TYPE_LIST_MULTI);
if (null != linkPermissions) {
addPermittedPaths(field, linkPermissions);
}
break;
default:
// Other types have no special formatting.
field.setType(FormField.TYPE_BOOLEAN);
field.addValue(permittedTypes.contains(type) ? "true" : "false");
}
serviceExtension.addField(field);
}
}
/**
* Sets the description of the data. It is similar to the title on a web page or an X window. You
* can put a <title/> on either a form to fill out, or a set of data results.
*
* @param title description of the data.
*/
public void setTitle(String title) {
dataForm.setTitle(title);
}
/**
* Returns true if the form is a form to submit.
*
* @return if the form is a form to submit.
*/
private boolean isSubmitType() {
return TYPE_SUBMIT.equals(dataForm.getType());
}
/**
* Returns true if the form is a form to fill out.
*
* @return if the form is a form to fill out.
*/
private boolean isFormType() {
return TYPE_FORM.equals(dataForm.getType());
}
/**
* Returns the meaning of the data within the context. The data could be part of a form to fill
* out, a form submission or data results.
*
* <p>Possible form types are:
*
* <ul>
* <li>form -> Indicates a form to fill out.
* <li>submit -> The form is filled out, and this is the data that is being returned from the
* form.
* <li>cancel -> The form was cancelled. Tell the asker that piece of information.
* <li>result -> Data results being returned from a search, or some other query.
* </ul>
*
* @return the form's type.
*/
public String getType() {
return dataForm.getType();
}
/**
* Returns the description of the data. It is similar to the title on a web page or an X window.
* You can put a <title/> on either a form to fill out, or a set of data results.
*
* @return description of the data.
*/
public String getTitle() {
return dataForm.getTitle();
}
/**
* Returns an Iterator for the fields that are part of the form.
*
* @return an Iterator for the fields that are part of the form.
*/
public Iterator<FormField> getFields() {
return dataForm.getFields();
}
/**
* Adds a new field to complete as part of the form.
*
* @param field the field to complete.
*/
public void addField(FormField field) {
dataForm.addField(field);
}
/**
* Calculates the <tt>String</tt> for a specific <tt>DiscoverInfo</tt> which is to be hashed in
* order to compute the ver string for that <tt>DiscoverInfo</tt>.
*
* @param discoverInfo the <tt>DiscoverInfo</tt> for which the <tt>String</tt> to be hashed in
* order to compute its ver string is to be calculated
* @return the <tt>String</tt> for <tt>discoverInfo</tt> which is to be hashed in order to compute
* its ver string
*/
private static String calculateEntityCapsString(DiscoverInfo discoverInfo) {
StringBuilder bldr = new StringBuilder();
// Add identities
{
Iterator<DiscoverInfo.Identity> identities = discoverInfo.getIdentities();
SortedSet<DiscoverInfo.Identity> is =
new TreeSet<DiscoverInfo.Identity>(
new Comparator<DiscoverInfo.Identity>() {
public int compare(DiscoverInfo.Identity i1, DiscoverInfo.Identity i2) {
int category = i1.getCategory().compareTo(i2.getCategory());
if (category != 0) return category;
int type = i1.getType().compareTo(i2.getType());
if (type != 0) return type;
/*
* TODO Sort by xml:lang.
*
* Since sort by xml:lang is currently missing,
* use the last supported sort criterion i.e.
* type.
*/
return type;
}
});
if (identities != null) while (identities.hasNext()) is.add(identities.next());
for (DiscoverInfo.Identity i : is) {
bldr.append(i.getCategory())
.append('/')
.append(i.getType())
.append("//")
.append(i.getName())
.append('<');
}
}
// Add features
{
Iterator<DiscoverInfo.Feature> features = getDiscoverInfoFeatures(discoverInfo);
SortedSet<String> fs = new TreeSet<String>();
if (features != null) while (features.hasNext()) fs.add(features.next().getVar());
for (String f : fs) bldr.append(f).append('<');
}
DataForm extendedInfo = (DataForm) discoverInfo.getExtension("x", "jabber:x:data");
if (extendedInfo != null) {
synchronized (extendedInfo) {
SortedSet<FormField> fs =
new TreeSet<FormField>(
new Comparator<FormField>() {
public int compare(FormField f1, FormField f2) {
return f1.getVariable().compareTo(f2.getVariable());
}
});
FormField formType = null;
for (Iterator<FormField> fieldsIter = extendedInfo.getFields(); fieldsIter.hasNext(); ) {
FormField f = fieldsIter.next();
if (!f.getVariable().equals("FORM_TYPE")) fs.add(f);
else formType = f;
}
// Add FORM_TYPE values
if (formType != null) formFieldValuesToCaps(formType.getValues(), bldr);
// Add the other values
for (FormField f : fs) {
bldr.append(f.getVariable()).append('<');
formFieldValuesToCaps(f.getValues(), bldr);
}
}
}
return bldr.toString();
}
