/**
* Converts a primitive type value, this implementation only converts an EEnum to an Enum value.
*
* @param value the value to convert
* @param eDataType its EDataType
* @return the converted value
*/
@SuppressWarnings({"unchecked", "rawtypes"})
protected Object convertEAttributeValue(final Object value, final EDataType eDataType) {
if (value instanceof Enum<?>) {
final EDataType enumDataType = getDataTypeOrBaseType(eDataType);
Check.isInstanceOf(enumDataType, EEnum.class);
final ModelPackage modelPackage =
ModelResolver.getInstance().getModelPackage(enumDataType.getEPackage().getNsURI());
final Class<? extends Enum> enumClass =
(Class<? extends Enum>) modelPackage.getEClassifierClass(enumDataType);
return Enum.valueOf(enumClass, ((Enum<?>) value).name().toUpperCase(Locale.ENGLISH));
} else if (value instanceof EEnumLiteral) {
final EDataType enumDataType = getDataTypeOrBaseType(eDataType);
Check.isInstanceOf(enumDataType, EEnum.class);
final EEnumLiteral eeNumLiteral = (EEnumLiteral) value;
final ModelPackage modelPackage =
ModelResolver.getInstance().getModelPackage(enumDataType.getEPackage().getNsURI());
if (modelPackage == null) {
// dynamic model
return eeNumLiteral;
}
final Class<? extends Enum> enumClass =
(Class<? extends Enum>) modelPackage.getEClassifierClass(enumDataType);
return Enum.valueOf(enumClass, eeNumLiteral.getName().toUpperCase(Locale.ENGLISH));
}
// convert these to a Date always
if (value instanceof XMLGregorianCalendar) {
final XMLGregorianCalendar xmlCalendar = (XMLGregorianCalendar) value;
final Date date = xmlCalendar.toGregorianCalendar().getTime();
return date;
}
return value;
}
@Override
public String getAsString(FacesContext context, UIComponent component, Object value) {
Map<String, Object> attributes = component.getAttributes();
if (attributes.containsKey("pattern")) {
pattern = (String) attributes.get("pattern");
}
setPattern(pattern);
if (attributes.containsKey("locale")) {
locale = (Locale) attributes.get("locale");
}
setLocale(locale);
if (attributes.containsKey("timeZone")) {
timeZone = (TimeZone) attributes.get("timeZone");
}
setTimeZone(timeZone);
if (attributes.containsKey("dateStyle")) {
dateStyle = (String) attributes.get("dateStyle");
}
setDateStyle(dateStyle);
if (attributes.containsKey("timeStyle")) {
timeStyle = (String) attributes.get("timeStyle");
}
setTimeStyle(timeStyle);
if (attributes.containsKey("type")) {
type = (String) attributes.get("type");
}
setType(type);
XMLGregorianCalendar xmlGregCal = (XMLGregorianCalendar) value;
Date date = xmlGregCal.toGregorianCalendar().getTime();
return super.getAsString(context, component, date);
}
public void performIteration(Object port) throws Exception {
XMLGregorianCalendar ret = ((EndpointWrappedRPC) port).getCalendarPlusDay(testedCalendar);
if (!ret.equals(expectedCalendar)) {
throw new Exception("Unexpected result: " + ret + "\nExpected:" + expectedCalendar);
}
}
/**
* Add an new empty feed::dasextension element with only a completed management element to the
* given Feed. Sets the responseTime value to now. Note: A proper sites::site element must be
* added to the new feed::dasextension element for this new feed::dasextension element to be
* valid.
*
* @param feed - mandatory
* @return
*/
private Feed addEmptyDasExtension(Feed feed) {
// check to make sure there's a dasextension
QName dasextensionQname = new QName(this.dasextensionNamespace, "dasextension");
ExtensibleElement dasExt = feed.getExtension(dasextensionQname);
if (NullChecker.isEmpty(dasExt)) {
dasExt = feed.addExtension(dasextensionQname);
// add the dasextension::management element
QName managementQname = new QName(this.dasextensionNamespace, "management");
ExtensibleElement management = dasExt.getExtension(managementQname);
if (NullChecker.isEmpty(management)) {
management = dasExt.addExtension(managementQname);
}
QName responseTimeQname = new QName(this.dasextensionNamespace, "responseTime");
ExtensibleElement responseTime = management.getExtension(responseTimeQname);
if (NullChecker.isEmpty(responseTime)) {
responseTime = management.addExtension(responseTimeQname);
}
// set/reset the response time to now
XMLGregorianCalendar xmlGregCalResponseTime =
GregorianDateUtil.getGregorianCalendarByDate(new Date());
responseTime.setText(xmlGregCalResponseTime.toString()); // TODO: Verify date format
}
return feed;
}
private Element createUsernameToken(String usernameValue, String passwordValue)
throws SOAPException {
QName usernameTokenName =
new QName(Constants.WSSE_NS, Constants.WSSE_USERNAME_TOKEN, Constants.WSSE_PREFIX);
QName usernameName =
new QName(Constants.WSSE_NS, Constants.WSSE_USERNAME, Constants.WSSE_PREFIX);
QName passwordName =
new QName(Constants.WSSE_NS, Constants.WSSE_PASSWORD, Constants.WSSE_PREFIX);
QName createdName = new QName(Constants.WSU_NS, "Created", Constants.WSU_PREFIX);
SOAPFactory factory = SOAPFactory.newInstance();
SOAPElement usernametoken = factory.createElement(usernameTokenName);
usernametoken.addNamespaceDeclaration(Constants.WSSE_PREFIX, Constants.WSSE_NS);
usernametoken.addNamespaceDeclaration(Constants.WSU_PREFIX, Constants.WSU_NS);
SOAPElement username = factory.createElement(usernameName);
username.addTextNode(usernameValue);
SOAPElement password = factory.createElement(passwordName);
password.addAttribute(new QName("Type"), Constants.PASSWORD_TEXT_TYPE);
password.addTextNode(passwordValue);
SOAPElement created = factory.createElement(createdName);
XMLGregorianCalendar createdCal =
dataTypefactory.newXMLGregorianCalendar(new GregorianCalendar()).normalize();
created.addTextNode(createdCal.toXMLFormat());
usernametoken.addChildElement(username);
usernametoken.addChildElement(password);
usernametoken.addChildElement(created);
return usernametoken;
}
public static GregorianCalendar toGregorianCalendar(String date) {
try {
XMLGregorianCalendar xmlDate = DatatypeFactory.newInstance().newXMLGregorianCalendar(date);
return xmlDate.toGregorianCalendar();
} catch (DatatypeConfigurationException dtce) {
throw new UnsupportedOperationException(
"Nemohu prevest " + "GregorianCalendar na XMLGregorianCalendar", dtce);
}
}
private String createResetEmail(OrcidProfile orcidProfile, String baseUri) {
String userEmail =
orcidProfile.getOrcidBio().getContactDetails().retrievePrimaryEmail().getValue();
XMLGregorianCalendar date =
DateUtils.convertToXMLGregorianCalendarNoTimeZoneNoMillis(new Date());
String resetParams =
MessageFormat.format(
"email={0}&issueDate={1}", new Object[] {userEmail, date.toXMLFormat()});
return createEmailBaseUrl(resetParams, baseUri, "reset-password-email");
}
public Date getTimeStamp() {
if (flow == null) return null;
AdministrativeInformation info = flow.getAdministrativeInformation();
if (info == null) return null;
DataEntry entry = info.getDataEntry();
if (entry == null) return null;
XMLGregorianCalendar cal = entry.getTimeStamp();
if (cal == null) return null;
else return cal.toGregorianCalendar().getTime();
}
@Test
public void testToXmlDate() throws Exception {
Calendar cal = Calendar.getInstance();
cal.set(2014, Calendar.DECEMBER, 15, 0, 0, 0);
cal.set(Calendar.MILLISECOND, 0);
XMLGregorianCalendar actual = DocumentUtils.toXmlDate(cal.getTime());
assertEquals("2014-12-15", actual.toXMLFormat());
}
static {
try {
GregorianCalendar calendar = new GregorianCalendar();
calendar.setTimeInMillis((new Date()).getTime());
XMLGregorianCalendar xmlGregCal =
DatatypeFactory.newInstance().newXMLGregorianCalendar(calendar);
FEED = FEED_STR.replace("@TIME@", xmlGregCal.toXMLFormat());
} catch (DatatypeConfigurationException e) {
throw new RuntimeException(e);
}
}
/**
* Load the data in parallel using a provided number of threads.
*
* @param threads The number of threads to use.
* @param start The start range for the generated data.
* @param end The end range for the generated data.
* @param dataInterval The interval in between sensor data.
*/
public static void parallelLoad(
int threads, XMLGregorianCalendar start, XMLGregorianCalendar end, final int dataInterval) {
// Partition time period into separate threads.
List<ClientThread> clients = new ArrayList<ClientThread>();
final long begin = start.toGregorianCalendar().getTimeInMillis();
final long interval = (end.toGregorianCalendar().getTimeInMillis() - begin) / threads;
final double totalEnergyGenerated[] = {
0, 1234.0, 2345, 3456, 4567, 5678, 6789, 7890, 8901, 9012
};
for (int i = 0; i < threads; i++) {
clients.add(
new ClientThread(i) {
@Override
public void run() {
SensorData data;
int j = 0;
Properties props;
int power = 0;
XMLGregorianCalendar timestamp = Tstamp.makeTimestamp(begin + (interval * threadId));
XMLGregorianCalendar myEnd =
Tstamp.makeTimestamp(begin + (interval * (threadId + 1)));
while (Tstamp.lessThan(timestamp, myEnd)) {
for (int k = 0; k < NUM_SOURCES; k++) {
props = new Properties();
power = j * (k + 1) * 100;
// energy counter increased by power * rate, converted to Wh
totalEnergyGenerated[k] += power * dataInterval / 60.0;
props
.getProperty()
.add(new Property(SensorData.POWER_GENERATED, Integer.toString(power)));
props
.getProperty()
.add(
new Property(
SensorData.ENERGY_GENERATED_TO_DATE,
Double.toString(totalEnergyGenerated[k])));
data = new SensorData(timestamp, toolName, sourceURIs[k], props);
try {
client.storeSensorData(data);
} catch (Exception e) {
e.printStackTrace();
}
}
timestamp = Tstamp.incrementMilliseconds(timestamp, dataInterval * 1000);
// Keep ratcheting up j until we reach 100, then reset to 0
j = (j < 100) ? j + 10 : 0;
}
}
});
}
}
public Object toJavaObject(Class target) throws XPathException {
if (target == Object.class || target.isAssignableFrom(DateValue.class)) return this;
else if (target.isAssignableFrom(XMLGregorianCalendar.class)) return calendar.clone();
else if (target.isAssignableFrom(GregorianCalendar.class))
return calendar.toGregorianCalendar();
else if (target == Date.class) return calendar.toGregorianCalendar().getTime();
throw new XPathException(
"cannot convert value of type "
+ Type.getTypeName(getType())
+ " to Java object of type "
+ target.getName());
}
/**
* Add additional time in miliseconds
*
* @param value calendar whose value needs to be updated
* @param milis
* @return calendar value with the addition
* @throws ConfigurationException
*/
public static XMLGregorianCalendar add(XMLGregorianCalendar value, long milis)
throws ConfigurationException {
XMLGregorianCalendar newVal = (XMLGregorianCalendar) value.clone();
Duration duration;
try {
duration = newDatatypeFactory().newDuration(milis);
} catch (DatatypeConfigurationException e) {
throw logger.configurationError(e);
}
newVal.add(duration);
return newVal;
}
/**
* Validate that the current time falls between the two boundaries
*
* @param now
* @param notbefore
* @param notOnOrAfter
* @return
*/
public static boolean isValid(
XMLGregorianCalendar now, XMLGregorianCalendar notbefore, XMLGregorianCalendar notOnOrAfter) {
if (notbefore == null) throw logger.nullArgumentError("notbefore argument is null");
if (notOnOrAfter == null) throw logger.nullArgumentError("notOnOrAfter argument is null");
int val = notbefore.compare(now);
if (val == DatatypeConstants.INDETERMINATE || val == DatatypeConstants.GREATER) return false;
val = notOnOrAfter.compare(now);
if (val != DatatypeConstants.GREATER) return false;
return true;
}
@Override
public String marshal(Date date) throws Exception {
if (date == null) {
return null;
}
long utcMillis = date.getTime();
GregorianCalendar calendar = new GregorianCalendar(TimeZone.getDefault());
calendar.setTimeInMillis(utcMillis);
DatatypeFactory factory = DatatypeFactory.newInstance();
XMLGregorianCalendar xmlCalendar = factory.newXMLGregorianCalendar(calendar);
return xmlCalendar.toXMLFormat();
}
/**
* Return a calendar with the timezone field set, to be used for order comparison. If the original
* calendar did not specify a timezone, set the local timezone (unadjusted for daylight savings).
* The returned calendars will be totally ordered between themselves. We also set any missing
* fields to ensure that normalization doesn't discard important data! (This is probably a bug in
* the JAXP implementation, but the workaround doesn't hurt us, so it's faster to just fix it
* here.)
*
* @return the calendar represented by this object, with the timezone field filled in with an
* implicit value if necessary
*/
protected XMLGregorianCalendar getImplicitCalendar() {
if (implicitCalendar == null) {
implicitCalendar = (XMLGregorianCalendar) calendar.clone();
if (calendar.getTimezone() == DatatypeConstants.FIELD_UNDEFINED) {
implicitCalendar.setTimezone(TimeUtils.getInstance().getLocalTimezoneOffsetMinutes());
}
// fill in fields from default reference; don't have to worry about weird combinations of
// fields being set, since we control that on creation
switch (getType()) {
case Type.DATE:
implicitCalendar.setTime(0, 0, 0);
break;
case Type.TIME:
implicitCalendar.setYear(1972);
implicitCalendar.setMonth(12);
implicitCalendar.setDay(31);
break;
default:
}
implicitCalendar =
implicitCalendar
.normalize(); // the comparison routines will normalize it anyway, just do it once
// here
}
return implicitCalendar;
}
private boolean validateAssertionAge(
AssertionType assertion, Map<String, String> runtimeProperties) {
long nowInMillis = new GregorianCalendar().getTimeInMillis();
XMLGregorianCalendar issued = assertion.getIssueInstant();
long issuedInMillis = issued.toGregorianCalendar().getTimeInMillis();
long maxAgeInMillis =
Long.parseLong(getProperty(VALIDATOR_AGE_MAXAGESECONDS, runtimeProperties)) * 1000;
if (nowInMillis - issuedInMillis <= maxAgeInMillis) {
return true;
}
return false;
}
static String format(Date date) {
XMLGregorianCalendar xgCal = null;
if (date != null) {
GregorianCalendar gCal = new GregorianCalendar();
gCal.setTime(date);
try {
xgCal = DatatypeFactory.newInstance().newXMLGregorianCalendar(gCal);
} catch (DatatypeConfigurationException e) {
return "";
}
}
return (xgCal == null) ? "" : xgCal.toXMLFormat();
}
@Mapping(from = Integer.class, to = XMLGregorianCalendar.class)
public static synchronized XMLGregorianCalendar map(
BigDecimal secondsAgo, XMLGregorianCalendar template) {
GregorianCalendar calendar =
template != null
? template.toGregorianCalendar()
: new GregorianCalendar(TimeZone.getTimeZone("UTC"));
DatatypeFactory factory = getDatatypeFactory();
XMLGregorianCalendar ret = null;
if (factory != null) {
ret = factory.newXMLGregorianCalendar(calendar);
ret.add(factory.newDuration(false, 0, 0, 0, 0, 0, secondsAgo.intValue()));
}
return ret;
}
private String dateToString(Date date) {
String result = null;
if (date != null) {
try {
GregorianCalendar cal = new GregorianCalendar();
cal.setTime(date);
XMLGregorianCalendar xmlCal;
DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
xmlCal = datatypeFactory.newXMLGregorianCalendar(cal);
result = xmlCal.toString();
} catch (DatatypeConfigurationException e) {
// nothing to do
}
}
return result;
}
public static Date toDate(XMLGregorianCalendar cal) {
if (null != cal) {
return cal.toGregorianCalendar().getTime();
}
return null;
}
protected XMLGregorianCalendar getTrimmedCalendar() {
if (trimmedCalendar == null) {
trimmedCalendar = cloneXMLGregorianCalendar(calendar);
BigDecimal fract = trimmedCalendar.getFractionalSecond();
if (fract != null) {
// TODO: replace following algorithm in JDK 1.5 with fract.stripTrailingZeros();
String s = fract.toString();
int i = s.length();
while (i > 0 && s.charAt(i - 1) == '0') i--;
if (i == 0) trimmedCalendar.setFractionalSecond(null);
else if (i != s.length())
trimmedCalendar.setFractionalSecond(new BigDecimal(s.substring(0, i)));
}
}
return trimmedCalendar;
}
/**
* check if the specified XMLGregorianCalendar instance is a valid {@odf.datatype time} data type
*
* @param time the value to be tested
* @return true if the value of argument is valid for {@odf.datatype time} data type false
* otherwise
*/
public static boolean isValid(XMLGregorianCalendar time) {
if (time == null) {
return false;
} else {
return W3CSchemaType.isValid("time", time.toXMLFormat());
}
}
/**
* Class-level synchronization to avoid potential thread-safety issues with statically shared
* DatatypeFactory.
*/
@Mapping(from = Date.class, to = XMLGregorianCalendar.class)
public static synchronized XMLGregorianCalendar map(Date date, XMLGregorianCalendar template) {
GregorianCalendar calendar =
template != null ? template.toGregorianCalendar() : new GregorianCalendar();
calendar.setTime(date);
DatatypeFactory factory = getDatatypeFactory();
return factory != null ? factory.newXMLGregorianCalendar(calendar) : null;
}
public static String date2GregorianCalendarString(Date date) {
if (date == null) {
throw new java.lang.IllegalArgumentException("Date is null");
}
long tmp = date.getTime();
GregorianCalendar ca = new GregorianCalendar();
ca.setTimeInMillis(tmp);
try {
XMLGregorianCalendar t_XMLGregorianCalendar =
DatatypeFactory.newInstance().newXMLGregorianCalendar(ca);
return t_XMLGregorianCalendar.normalize().toString();
} catch (DatatypeConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
throw new java.lang.IllegalArgumentException("Date is null");
}
}
@Override
public Date unmarshal(String rawValue) throws Exception {
if (!StringUtility.hasText(rawValue)) {
return null;
}
// local time of given timezone (or default timezone if not applicable)
DatatypeFactory factory = DatatypeFactory.newInstance();
XMLGregorianCalendar xmlCalendar = factory.newXMLGregorianCalendar(rawValue);
GregorianCalendar calendar = xmlCalendar.toGregorianCalendar();
long utcMillis = calendar.getTimeInMillis();
// default time
Calendar defaultTimezoneCalendar = Calendar.getInstance();
defaultTimezoneCalendar.setTimeInMillis(utcMillis);
return defaultTimezoneCalendar.getTime();
}
protected XMLGregorianCalendar validateTerminationTime(String value)
throws UnacceptableTerminationTimeFault {
XMLGregorianCalendar tt = parseTerminationTime(value);
if (tt == null) {
UnacceptableTerminationTimeFaultType fault = new UnacceptableTerminationTimeFaultType();
throw new UnacceptableTerminationTimeFault(
"Unable to parse termination time: '" + value + "'", fault);
}
XMLGregorianCalendar ct = getCurrentTime();
int c = tt.compare(ct);
if (c == DatatypeConstants.LESSER || c == DatatypeConstants.EQUAL) {
UnacceptableTerminationTimeFaultType fault = new UnacceptableTerminationTimeFaultType();
fault.setMinimumTime(ct);
throw new UnacceptableTerminationTimeFault("Invalid termination time", fault);
}
return tt;
}
@POST
@Consumes("application/xml")
@Path("storeXML")
public Response storeXML(DataCollectionPackage dataCollectionPackage) {
String sourceID = dataCollectionPackage.getSourceID();
String eventID = dataCollectionPackage.getEventID();
if (dataCollectionPackage.getDataRecords() == null
|| dataCollectionPackage.getDataRecords().getDataCollectionRecord() == null) {
ResponseBuilder builder = Response.status(Status.INTERNAL_SERVER_ERROR);
builder.type("text/html");
builder.entity("<h3>No records included</h3>");
throw new WebApplicationException(builder.build());
}
for (DataCollectionRecord dr :
dataCollectionPackage.getDataRecords().getDataCollectionRecord()) {
// JAXB datatype for dateTime is XMLGregorianCalendar, need to convert to the
// java.sql.Timestamp
XMLGregorianCalendar cal = dr.getTimestamp();
GregorianCalendar gregorianCalendar = cal.toGregorianCalendar();
long timeAsMillis = gregorianCalendar.getTimeInMillis();
Timestamp timestamp = new Timestamp(timeAsMillis);
// persist data here
}
URI createdURI = null;
try {
// Create a relative URI
createdURI = new URI("records");
} catch (URISyntaxException e) {
throw new WebApplicationException(Response.serverError().build());
}
// For a successful POST send a 201 CREATED with the URI of where to find the records
// The relative URI will be turned into an absolute URI based on the URI used to access
// this method.
// return Response.created(createdURI).build();
ResponseBuilder builder = Response.created(createdURI);
builder.type("text/plain");
// SoapUI considers a 0 length response an error
builder.entity("storeXML");
return builder.build();
}
/**
* @param actividadxx
* @return
* @throws DatatypeConfigurationException
*/
public String sombreadoc(Actividad actividadxx) throws DatatypeConfigurationException {
if (actividadxx != null) {
WrActividad actividadx = consultarActividad(actividadxx);
if (actividadx.getActividads().get(0).getFechaCierre() != null
&& actividadx.getActividads().get(0).getFechaApertura() != null) {
XMLGregorianCalendar FC1;
XMLGregorianCalendar FA1;
FC1 = actividadx.getActividads().get(0).getFechaCierre();
FA1 = actividadx.getActividads().get(0).getFechaApertura();
long duracion = actividadx.getActividads().get(0).getDuracion().longValue();
equivalencia = actividadx.getActividads().get(0).getIdEquivalenciasTiempo().getNombre();
UT = actividadx.getActividads().get(0).getIdEquivalenciasTiempo().getMinutos();
long f = FC1.toGregorianCalendar().getTimeInMillis();
long f2 = FA1.toGregorianCalendar().getTimeInMillis();
long resta = f - f2;
if ("Minuto".equals(equivalencia)) {
long minutos = resta / (60 * 1000);
if (minutos > duracion) {
return "background-color: #FF8888;";
}
}
if ("Hora".equals(equivalencia)) {
long horas = resta / (60 * 60 * 1000);
if (horas > duracion) {
return "background-color: #FF8888;";
}
}
if ("Dia".equals(equivalencia)) {
long dias = resta / (24 * 60 * 60 * 1000);
if (dias > duracion) {
return "background-color: #FF8888;";
}
}
if ("Semana".equals(equivalencia)) {
long semanas = resta / (7 * 24 * 60 * 60 * 1000);
if (semanas > duracion) {
return "background-color: #FF8888;";
}
}
}
return " background-color: white";
}
return " background-color: white;";
}
private String toStringValue(Object value) {
if (null == value) return null;
Date date = null;
if (value instanceof XMLGregorianCalendar) {
XMLGregorianCalendar grCal = (XMLGregorianCalendar) value;
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.DAY_OF_MONTH, grCal.getDay());
calendar.set(Calendar.MONTH, grCal.getMonth() - 1);
calendar.set(Calendar.YEAR, grCal.getYear());
date = calendar.getTime();
} else if (value instanceof Date) {
date = (Date) value;
}
if (null != date) {
return DateConverter.getFormattedDate(date, DATE_PATTERN);
}
return null;
}