Event.java
/*
* Licensed to The Apereo Foundation under one or more contributor license
* agreements. See the NOTICE file distributed with this work for additional
* information regarding copyright ownership.
*
*
* The Apereo Foundation licenses this file to you under the Educational
* Community 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://opensource.org/licenses/ecl2.txt
*
* 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 org.opencastproject.elasticsearch.index.objects.event;
import org.opencastproject.elasticsearch.index.objects.IndexObject;
import org.opencastproject.mediapackage.Publication;
import org.opencastproject.scheduler.api.RecordingState;
import org.opencastproject.util.IoSupport;
import org.opencastproject.util.XmlSafeParser;
import org.opencastproject.util.jaxb.ExtendedMetadataAdapter;
import org.opencastproject.workflow.api.WorkflowInstance.WorkflowState;
import org.apache.commons.lang3.StringUtils;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
import org.codehaus.jettison.mapped.Configuration;
import org.codehaus.jettison.mapped.MappedNamespaceConvention;
import org.codehaus.jettison.mapped.MappedXMLStreamReader;
import org.codehaus.jettison.mapped.MappedXMLStreamWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
/**
* Object wrapper for a recording event.
*/
@XmlType(
name = "event",
namespace = IndexObject.INDEX_XML_NAMESPACE,
propOrder = {
"identifier", "organization", "title", "description", "subject", "location", "presenters",
"contributors", "seriesId", "seriesName", "language", "source", "created", "creator",
"publisher", "license", "rights", "extendedMetadata", "accessPolicy", "managedAcl", "workflowState",
"workflowId", "workflowDefinitionId", "recordingStartTime", "recordingEndTime", "duration",
"hasComments", "hasOpenComments", "comments", "hasPreview", "needsCutting", "publications",
"archiveVersion", "recordingStatus", "eventStatus", "agentId", "agentConfigurations",
"technicalStartTime", "technicalEndTime", "technicalPresenters"
}
)
@XmlRootElement(name = "event", namespace = IndexObject.INDEX_XML_NAMESPACE)
@XmlAccessorType(XmlAccessType.NONE)
public class Event implements IndexObject {
/** The logger */
private static final Logger logger = LoggerFactory.getLogger(Event.class);
/** The document type */
public static final String DOCUMENT_TYPE = "event";
/** The name of the surrounding XML tag to wrap a result of multiple events */
public static final String XML_SURROUNDING_TAG = "events";
/** The mapping of recording and workflow states */
private static final Map<String, String> workflowStatusMapping = new HashMap<>();
private static final Map<String, String> recordingStatusMapping = new HashMap<>();
static {
recordingStatusMapping.put(RecordingState.CAPTURING, "EVENTS.EVENTS.STATUS.RECORDING");
recordingStatusMapping.put(RecordingState.CAPTURE_FINISHED, "EVENTS.EVENTS.STATUS.RECORDING");
recordingStatusMapping.put(RecordingState.MANIFEST, "EVENTS.EVENTS.STATUS.INGESTING");
recordingStatusMapping.put(RecordingState.MANIFEST_FINISHED, "EVENTS.EVENTS.STATUS.INGESTING");
recordingStatusMapping.put(RecordingState.COMPRESSING, "EVENTS.EVENTS.STATUS.INGESTING");
recordingStatusMapping.put(RecordingState.UPLOADING, "EVENTS.EVENTS.STATUS.INGESTING");
recordingStatusMapping.put(RecordingState.UPLOAD_FINISHED, "EVENTS.EVENTS.STATUS.INGESTING");
recordingStatusMapping.put(RecordingState.CAPTURE_ERROR, "EVENTS.EVENTS.STATUS.RECORDING_FAILURE");
recordingStatusMapping.put(RecordingState.MANIFEST_ERROR, "EVENTS.EVENTS.STATUS.RECORDING_FAILURE");
recordingStatusMapping.put(RecordingState.COMPRESSING_ERROR, "EVENTS.EVENTS.STATUS.RECORDING_FAILURE");
recordingStatusMapping.put(RecordingState.UPLOAD_ERROR, "EVENTS.EVENTS.STATUS.RECORDING_FAILURE");
workflowStatusMapping.put(WorkflowState.INSTANTIATED.toString(), "EVENTS.EVENTS.STATUS.PENDING");
workflowStatusMapping.put(WorkflowState.RUNNING.toString(), "EVENTS.EVENTS.STATUS.PROCESSING");
workflowStatusMapping.put(WorkflowState.FAILING.toString(), "EVENTS.EVENTS.STATUS.PROCESSING");
workflowStatusMapping.put(WorkflowState.PAUSED.toString(), "EVENTS.EVENTS.STATUS.PAUSED");
workflowStatusMapping.put(WorkflowState.SUCCEEDED.toString(), "EVENTS.EVENTS.STATUS.PROCESSED");
workflowStatusMapping.put(WorkflowState.FAILED.toString(), "EVENTS.EVENTS.STATUS.PROCESSING_FAILURE");
workflowStatusMapping.put(WorkflowState.STOPPED.toString(), "EVENTS.EVENTS.STATUS.PROCESSING_CANCELLED");
}
/** The identifier */
@XmlElement(name = "identifier")
private String identifier = null;
/** The organization identifier */
@XmlElement(name = "organization")
private String organization = null;
/** The title */
@XmlElement(name = "title")
private String title = null;
/** The description */
@XmlElement(name = "description")
private String description = null;
/** The subject */
@XmlElement(name = "subject")
private String subject = null;
/** The location */
@XmlElement(name = "location")
private String location = null;
@XmlElementWrapper(name = "presenters")
@XmlElement(name = "presenter")
private List<String> presenters = null;
@XmlElementWrapper(name = "contributors")
@XmlElement(name = "contributor")
private List<String> contributors = null;
/** The series identifier */
@XmlElement(name = "series_id")
private String seriesId = null;
/** The series name */
@XmlElement(name = "series_name")
private String seriesName = null;
/** The language for the event */
@XmlElement(name = "language")
private String language = null;
/** The source for the event */
@XmlElement(name = "source")
private String source = null;
/** The creation date of the event */
@XmlElement(name = "created")
private String created = null;
/** The creator of the event */
@XmlElement(name = "creator")
private String creator = null;
/** The publisher of the event */
@XmlElement(name = "publisher")
private String publisher = null;
/** The license of the event */
@XmlElement(name = "license")
private String license = null;
/** The rights of the event */
@XmlElement(name = "rights")
private String rights = null;
@XmlElement(name = "extendedMetadata")
@XmlJavaTypeAdapter(ExtendedMetadataAdapter.class)
private Map<String, Map<String, List<String>>> extendedMetadata = new HashMap();
/** The access policy of the event */
@XmlElement(name = "access_policy")
private String accessPolicy = null;
/** The name of the managed ACL used by the series (if set) */
@XmlElement(name = "managed_acl")
private String managedAcl = null;
/** The current state of the workflow related to this event */
@XmlElement(name = "workflow_state")
private String workflowState = null;
/** The workflow id related to this event */
@XmlElement(name = "workflow_id")
private Long workflowId = null;
/** The workflow definition id related to this event */
@XmlElement(name = "workflow_definition_id")
private String workflowDefinitionId = null;
/** The recording start date from this event */
@XmlElement(name = "recording_start_time")
private String recordingStartTime = null;
/** The recording end date from this event */
@XmlElement(name = "recording_end_time")
private String recordingEndTime = null;
/** The recording duration from this event */
@XmlElement(name = "duration")
private Long duration = null;
/** The status of the event */
@XmlElement(name = "event_status")
private String eventStatus = null;
/** Whether the event has comments */
@XmlElement(name = "has_comments")
private Boolean hasComments = false;
/** Whether the event has open comments */
@XmlElement(name = "has_open_comments")
private Boolean hasOpenComments = false;
/** Comments on the event */
@XmlElement(name = "comments")
private List<Comment> comments = new ArrayList<>();
/** Whether the event has preview files */
@XmlElement(name = "has_preview")
private Boolean hasPreview = false;
/** Whether the event has open needs cutting comment */
@XmlElement(name = "needs_cutting")
private Boolean needsCutting = false;
/** The list of publications from this event */
@XmlElementWrapper(name = "publications")
@XmlElement(name = "publication")
private List<Publication> publications = new ArrayList<>();
/** The recording status of the event */
@XmlElement(name = "recording_status")
private String recordingStatus = null;
/** The archive version of the event */
@XmlElement(name = "archive_version")
private Long archiveVersion = null;
/** The id of the capture agent */
@XmlElement(name = "agent_id")
private String agentId = null;
/** The configuration of the capture agent */
@XmlElementWrapper(name = "agent_configuration")
private Map<String, String> agentConfigurations = new HashMap<String, String>();
/** The technical end time of the recording */
@XmlElement(name = "technical_end_time")
private String technicalEndTime = null;
/** The technical start time of the recording */
@XmlElement(name = "technical_start_time")
private String technicalStartTime = null;
@XmlElementWrapper(name = "technical_presenters")
@XmlElement(name = "technical_presenter")
private List<String> technicalPresenters = null;
/** Context for serializing and deserializing */
private static JAXBContext context = null;
/**
* Required default no arg constructor for JAXB.
*/
public Event() {
}
/**
* The recording identifier.
*
* @param identifier
* the object identifier
* @param organization
* the organization
*/
public Event(String identifier, String organization) {
this.identifier = identifier;
this.organization = organization;
updateEventStatus();
}
/**
* Returns the recording event identifier.
*
* @return the identifier
*/
public String getIdentifier() {
return identifier;
}
/**
* Returns the organization of the recording.
*
* @return the organization
*/
public String getOrganization() {
return organization;
}
/**
* Sets the recording title.
*
* @param title
* the title
*/
public void setTitle(String title) {
this.title = title;
}
/**
* Returns the recording title.
*
* @return the title
*/
public String getTitle() {
return title;
}
/**
* Sets the recording description.
*
* @param description
* the description
*/
public void setDescription(String description) {
this.description = description;
}
/**
* Returns the recording description.
*
* @return the description
*/
public String getDescription() {
return description;
}
/**
* Sets the recording subject
*
* @param subject
* the subject to set
*/
public void setSubject(String subject) {
this.subject = subject;
}
/**
* Returns the recording subject.
*
* @return the subject
*/
public String getSubject() {
return subject;
}
/**
* Sets the recording location.
*
* @param location
* the location
*/
public void setLocation(String location) {
this.location = location;
}
/**
* Returns the recording location.
*
* @return the location
*/
public String getLocation() {
return location;
}
/**
* Sets the series identifier
*
* @param seriesId
* the series identifier
*/
public void setSeriesId(String seriesId) {
this.seriesId = seriesId;
}
/**
* Returns the series identifier
*
* @return the series identifier
*/
public String getSeriesId() {
return seriesId;
}
/**
* Sets the series name
*
* @param seriesName
* the series name
*/
public void setSeriesName(String seriesName) {
this.seriesName = seriesName;
}
/**
* Returns the series name
*
* @return the series name
*/
public String getSeriesName() {
return seriesName;
}
/**
* Sets the language
*
* @param language
* the language
*/
public void setLanguage(String language) {
this.language = language;
}
/**
* Returns the language
*
* @return the language
*/
public String getLanguage() {
return language;
}
/**
* Sets the source of this event
*
* @param source
* the source
*/
public void setSource(String source) {
this.source = source;
}
/**
* Returns the source of this event
*
* @return the source
*/
public String getSource() {
return source;
}
/**
* Sets the creation date
*
* @param created
* the creation date
*/
public void setCreated(String created) {
this.created = created;
}
/**
* Returns the creation date
*
* @return the creation date
*/
public String getCreated() {
return created;
}
/**
* Sets the creator
*
* @param creator
* the language
*/
public void setCreator(String creator) {
this.creator = creator;
}
/**
* Returns the creator
*
* @return the language
*/
public String getCreator() {
return creator;
}
/**
* Sets the publisher
*
* @param publisher
* the publisher
*/
public void setPublisher(String publisher) {
this.publisher = publisher;
}
/**
* Returns the publisher
*
* @return the publisher
*/
public String getPublisher() {
return publisher;
}
/**
* Sets the license
*
* @param license
* the language
*/
public void setLicense(String license) {
this.license = license;
}
/**
* Returns the license
*
* @return the license
*/
public String getLicense() {
return license;
}
/**
* Sets the rights
*
* @param rights
* the rights
*/
public void setRights(String rights) {
this.rights = rights;
}
/**
* Returns the rights
*
* @return the rights
*/
public String getRights() {
return rights;
}
/**
* Sets the access policy
*
* @param accessPolicy
* the access policy
*/
public void setAccessPolicy(String accessPolicy) {
this.accessPolicy = accessPolicy;
}
/**
* Returns the access policy
*
* @return the access policy
*/
public String getAccessPolicy() {
return accessPolicy;
}
/**
* Sets the name of the managed ACL used by the event.
*
* @param managedAcl
* the managed ACL name
*/
public void setManagedAcl(String managedAcl) {
this.managedAcl = managedAcl;
}
/**
* Returns the name of the managed ACL, if the event does not have a custom ACL.
*
* @return the managed ACL name
*/
public String getManagedAcl() {
return managedAcl;
}
/**
* Sets the current workflow state related to this event
*
* @param workflowState
* the current workflow state
*/
public void setWorkflowState(WorkflowState workflowState) {
this.workflowState = workflowState == null ? null : workflowState.toString();
updateEventStatus();
}
/**
* Returns the current workflow state related to this event
*
* @return the workflow state
*/
public String getWorkflowState() {
return workflowState;
}
/**
* Sets the current workflow id related to this event
*
* @param workflowId
* the current workflow id
*/
public void setWorkflowId(Long workflowId) {
this.workflowId = workflowId;
}
/**
* Returns the current workflow id related to this event
*
* @return the workflow id
*/
public Long getWorkflowId() {
return workflowId;
}
/**
* Sets the current workflow definition id related to this event
*
* @param workflowDefinitionId
* the current workflow definition id
*/
public void setWorkflowDefinitionId(String workflowDefinitionId) {
this.workflowDefinitionId = workflowDefinitionId;
}
/**
* Returns the current workflow definition id related to this event
*
* @return the workflow definition id
*/
public String getWorkflowDefinitionId() {
return workflowDefinitionId;
}
/**
* Sets the start date
*
* @param recordingStartTime
* the start date
*/
public void setRecordingStartDate(String recordingStartTime) {
this.recordingStartTime = recordingStartTime;
}
/**
* Returns the start date
*
* @return the start date
*/
public String getRecordingStartDate() {
return recordingStartTime;
}
/**
* Sets the recording end date
*
* @param recordingEndTime
* the end date
*/
public void setRecordingEndDate(String recordingEndTime) {
this.recordingEndTime = recordingEndTime;
}
/**
* Returns the recording end date
*
* @return the end date
*/
public String getRecordingEndDate() {
return recordingEndTime;
}
/**
* Sets the recording duration
*
* @param duration
* the recording duration
*/
public void setDuration(long duration) {
this.duration = duration;
}
/**
* Returns the recording duration
*
* @return the recording duration
*/
public Long getDuration() {
return duration;
}
/**
* Sets the list of presenters.
*
* @param presenters
* the presenters for this event
*/
public void setPresenters(List<String> presenters) {
this.presenters = presenters;
}
/**
* Returns the recording presenters.
*
* @return the presenters
*/
public List<String> getPresenters() {
return presenters;
}
/**
* Sets the list of contributors.
*
* @param contributors
* the contributors for this event
*/
public void setContributors(List<String> contributors) {
this.contributors = contributors;
}
/**
* Returns the recording contributors.
*
* @return the contributors
*/
public List<String> getContributors() {
return contributors;
}
/**
* Sets the has comments status from this event
*
* @param hasComments
* the has comments status from this event
*/
public void setHasComments(boolean hasComments) {
this.hasComments = hasComments;
}
/**
* Returns the has comments status from this event
*
* @return the has comments status from this event
*/
public boolean hasComments() {
return hasComments;
}
/**
* Sets the has open comments status from this event
*
* @param hasOpenComments
* the has open comments status from this event
*/
public void setHasOpenComments(boolean hasOpenComments) {
this.hasOpenComments = hasOpenComments;
}
/**
* Returns the has comments status from this event
*
* @return the has comments status from this event
*/
public boolean hasOpenComments() {
return hasOpenComments;
}
/**
* Sets the list of comments.
*
* @param comments
* the comments for this event
*/
public void setComments(List<Comment> comments) {
this.comments = comments;
}
/**
* Returns the event comments.
*
* @return the comments
*/
public List<Comment> comments() {
return comments;
}
/**
* Sets the has preview status from this event
*
* @param hasPreview
* the has preview status from this event
*/
public void setHasPreview(boolean hasPreview) {
this.hasPreview = hasPreview;
}
/**
* Returns the has preview status from this event
*
* @return the has preview status from this event
*/
public boolean hasPreview() {
return hasPreview;
}
/**
* Sets the subtype of the publication element that indicates a preview element.
*
* @param previewSubtype
* the subtype
*/
public void updatePreview(String previewSubtype) {
hasPreview = EventIndexUtils.subflavorMatches(publications, previewSubtype);
}
/**
* Sets the has open needs cutting comment for this event
*
* @param needsCutting
* this event has the open comments status that it needs cutting
*/
public void setNeedsCutting(boolean needsCutting) {
this.needsCutting = needsCutting;
}
/**
* Returns the has comment needs cutting for this event
*
* @return the event has the comments status that it needs cutting
*/
public boolean needsCutting() {
return needsCutting;
}
/**
* Sets the list of publications.
*
* @param publications
* the publications for this event
*/
public void setPublications(List<Publication> publications) {
this.publications = publications;
}
/**
* Returns the event publications.
*
* @return the publications
*/
public List<Publication> getPublications() {
return publications;
}
/**
* Sets the archive version
*
* @param archiveVersion
* the archive version
*/
public void setArchiveVersion(Long archiveVersion) {
this.archiveVersion = archiveVersion;
}
/**
* Returns the archive version
*
* @return the archive version
*/
public Long getArchiveVersion() {
return archiveVersion;
}
private void updateEventStatus() {
if (getWorkflowId() != null && StringUtils.isBlank(getWorkflowState())
|| getWorkflowId() == null && StringUtils.isNotBlank(getWorkflowState())) {
logger.warn("The workflow id {} and workflow state {} are not in sync on event {} organization {}",
getWorkflowId(), getWorkflowState(), getIdentifier(), getOrganization());
}
if (getWorkflowId() != null && StringUtils.isNotBlank(getWorkflowState())) {
eventStatus = workflowStatusMapping.get(getWorkflowState());
} else if ("EVENTS.EVENTS.STATUS.PROCESSED".equals(eventStatus)
&& (RecordingState.CAPTURE_FINISHED.equals(getRecordingStatus())
|| RecordingState.UPLOAD_FINISHED.equals(getRecordingStatus()))) {
eventStatus = "EVENTS.EVENTS.STATUS.PROCESSED";
} else if ("EVENTS.EVENTS.STATUS.PROCESSING_FAILURE".equals(eventStatus)
&& RecordingState.CAPTURE_ERROR.equals(getRecordingStatus())
|| RecordingState.UPLOAD_ERROR.equals(getRecordingStatus())) {
eventStatus = recordingStatusMapping.get(getRecordingStatus());
} else if (StringUtils.isNotBlank(getRecordingStatus())) {
eventStatus = recordingStatusMapping.get(getRecordingStatus());
} else if (isScheduledEvent()) {
eventStatus = "EVENTS.EVENTS.STATUS.SCHEDULED";
} else {
/* This can be the case if all workflows of an event have been deleted */
/* It also happens to events with running workflows while rebuilding the index */
eventStatus = "EVENTS.EVENTS.STATUS.PROCESSED";
}
}
/**
* Return the displayable status of this event
*
* @param customWorkflowStatusMapping
* The mappings used to get the displayable status for the workflow state.
*
* @return the displayable status of this event
*/
public String getDisplayableStatus(Map<String, Map<String, String>> customWorkflowStatusMapping) {
if (getWorkflowId() != null && StringUtils.isNotBlank(getWorkflowState())
&& customWorkflowStatusMapping.containsKey(getWorkflowDefinitionId())
&& customWorkflowStatusMapping.get(getWorkflowDefinitionId()).containsKey(getWorkflowState())) {
return customWorkflowStatusMapping.get(getWorkflowDefinitionId()).get(getWorkflowState());
}
return getEventStatus();
}
public boolean isScheduledEvent() {
/* Only scheduled events have a capture ID assigned */
return StringUtils.isNotBlank(getAgentId());
}
/**
* Check whether the recording of the event already has started.
* Always returns false for uploaded events.
*
* @return <code>true</code> if recording of this event has started, and <code>false</code> otherwise
*/
public boolean hasRecordingStarted() {
return isScheduledEvent() && StringUtils.isNotBlank(getRecordingStatus());
}
/**
* Sets the recording status
*
* @param recordingStatus
* the recording status
*/
public void setRecordingStatus(String recordingStatus) {
this.recordingStatus = recordingStatus;
updateEventStatus();
}
/**
* Returns the recording status
*
* @return the recording status
*/
public String getRecordingStatus() {
return recordingStatus;
}
/**
* Returns the event status
*
* @return the event status
*/
public String getEventStatus() {
updateEventStatus();
return eventStatus;
}
/**
* Returns the agent id
*
* @return the agent id
*/
public String getAgentId() {
return agentId;
}
/**
* Sets the agent id
*
* @param agentId
* the agent id
*/
public void setAgentId(String agentId) {
this.agentId = agentId;
}
/**
* Returns the agent configuration
*
* @return the agent configuration
*/
public Map<String, String> getAgentConfiguration() {
return agentConfigurations;
}
/**
* Sets the agent configuration
*
* @param agentConfigurations
* the agent configuration
*/
public void setAgentConfiguration(Map<String, String> agentConfigurations) {
this.agentConfigurations = agentConfigurations;
}
/**
* Returns the technical end time
*
* @return the technical end time
*/
public String getTechnicalEndTime() {
return technicalEndTime;
}
/**
* Sets the technical end time
*
* @param technicalEndTime
* the technical end time
*/
public void setTechnicalEndTime(String technicalEndTime) {
this.technicalEndTime = technicalEndTime;
}
/**
* Returns the technical start time
*
* @return the technical start time
*/
public String getTechnicalStartTime() {
return technicalStartTime;
}
/**
* Sets the technical start time
*
* @param technicalStartTime
* the technical start time
*/
public void setTechnicalStartTime(String technicalStartTime) {
this.technicalStartTime = technicalStartTime;
}
/**
* Returns the technical presenters
*
* @return the technical presenters
*/
public List<String> getTechnicalPresenters() {
return technicalPresenters;
}
/**
* Sets the technical presenters
*
* @param technicalPresenters
* the technical presenters
*/
public void setTechnicalPresenters(List<String> technicalPresenters) {
this.technicalPresenters = technicalPresenters;
}
/**
* Sets the external metadata for a catalog flavor.
*
* @param type
* The catalog type
* @param metadata
* The metadata
*/
public void setExtendedMetadata(String type, Map<String, List<String>> metadata) {
extendedMetadata.put(type, metadata);
}
/**
* Removes all external metadata.
*/
public void resetExtendedMetadata() {
extendedMetadata.clear();
}
/**
* Returns the extended metadata
*
* @return the extended metadata in a map by catalog type
*/
public Map<String, Map<String, List<String>>> getExtendedMetadata() {
return extendedMetadata;
}
/**
* Reads the recording event from the input stream.
*
* @param xml
* the input stream
* @param unmarshaller the unmarshaller to use
* @return the deserialized recording event
* @throws IOException
*/
public static Event valueOf(InputStream xml, Unmarshaller unmarshaller) throws IOException {
try {
if (context == null) {
createJAXBContext();
}
return unmarshaller.unmarshal(XmlSafeParser.parse(xml), Event.class).getValue();
} catch (JAXBException e) {
throw new IOException(e.getLinkedException() != null ? e.getLinkedException() : e);
} catch (SAXException e) {
throw new IOException(e);
} finally {
IoSupport.closeQuietly(xml);
}
}
/**
* Reads the recording event from the input stream.
*
* @param json
* the input stream
* @return the deserialized recording event
* @throws JSONException
* @throws XMLStreamException
* @throws JAXBException
*/
public static Event valueOfJson(InputStream json)
throws IOException, JSONException, XMLStreamException, JAXBException {
// TODO Get this to work, it is currently returning null properties for all properties.
if (context == null) {
createJAXBContext();
}
BufferedReader streamReader = new BufferedReader(new InputStreamReader(json, "UTF-8"));
StringBuilder jsonStringBuilder = new StringBuilder();
String inputStr;
while ((inputStr = streamReader.readLine()) != null) {
jsonStringBuilder.append(inputStr);
}
JSONObject obj = new JSONObject(jsonStringBuilder.toString());
Configuration config = new Configuration();
config.setSupressAtAttributes(true);
Map<String, String> xmlToJsonNamespaces = new HashMap<String, String>(1);
xmlToJsonNamespaces.put(IndexObject.INDEX_XML_NAMESPACE, "");
config.setXmlToJsonNamespaces(xmlToJsonNamespaces);
MappedNamespaceConvention con = new MappedNamespaceConvention(config);
Unmarshaller unmarshaller = context.createUnmarshaller();
// CHECKSTYLE:OFF
// the xml is parsed from json and should be safe
XMLStreamReader xmlStreamReader = new MappedXMLStreamReader(obj, con);
Event event = (Event) unmarshaller.unmarshal(xmlStreamReader);
// CHECKSTYLE:ON
return event;
}
/**
* Initialize the JAXBContext.
*/
private static void createJAXBContext() throws JAXBException {
context = JAXBContext.newInstance(Event.class);
}
/**
* Serializes the recording event.
*
* @return the serialized recording event
*/
public String toJSON() {
try {
if (context == null) {
createJAXBContext();
}
Marshaller marshaller = Event.context.createMarshaller();
Configuration config = new Configuration();
config.setSupressAtAttributes(true);
MappedNamespaceConvention con = new MappedNamespaceConvention(config);
StringWriter writer = new StringWriter();
XMLStreamWriter xmlStreamWriter = new MappedXMLStreamWriter(con, writer) {
@Override
public void writeStartElement(String prefix, String local, String uri) throws XMLStreamException {
super.writeStartElement("", local, "");
}
@Override
public void writeStartElement(String uri, String local) throws XMLStreamException {
super.writeStartElement("", local, "");
}
@Override
public void setPrefix(String pfx, String uri) throws XMLStreamException {
}
@Override
public void setDefaultNamespace(String uri) throws XMLStreamException {
}
};
marshaller.marshal(this, xmlStreamWriter);
return writer.toString();
} catch (JAXBException e) {
throw new IllegalStateException(e.getLinkedException() != null ? e.getLinkedException() : e);
}
}
/**
* Serializes the recording event to an XML format.
*
* @return A String with this event's content as XML.
*/
public String toXML() {
try {
if (context == null) {
createJAXBContext();
}
StringWriter writer = new StringWriter();
Marshaller marshaller = Event.context.createMarshaller();
marshaller.marshal(this, writer);
return writer.toString();
} catch (JAXBException e) {
throw new IllegalStateException(e.getLinkedException() != null ? e.getLinkedException() : e);
}
}
/**
* Create an unmarshaller for events
* @return an unmarshaller for events
* @throws IOException
*/
public static Unmarshaller createUnmarshaller() throws IOException {
try {
if (context == null) {
createJAXBContext();
}
return context.createUnmarshaller();
} catch (JAXBException e) {
throw new IOException(e.getLinkedException() != null ? e.getLinkedException() : e);
}
}
}