/** * 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; }