Example usage for javax.xml.bind JAXBException printStackTrace

List of usage examples for javax.xml.bind JAXBException printStackTrace

Introduction

In this page you can find the example usage for javax.xml.bind JAXBException printStackTrace.

Prototype

public void printStackTrace() 

Source Link

Document

Prints this JAXBException and its stack trace (including the stack trace of the linkedException if it is non-null) to System.err .

Usage

From source file:org.fcrepo.oai.service.OAIProviderService.java

public String createSet(Session session, UriInfo uriInfo, InputStream src) throws RepositoryException {
    final HttpIdentifierTranslator translator = new HttpIdentifierTranslator(session, FedoraNodes.class,
            uriInfo);//from  w  w  w .  j  a va2  s  .com
    try {
        final SetType set = this.unmarshaller.unmarshal(new StreamSource(src), SetType.class).getValue();
        final String setId = getSetId(set);
        final FedoraObject setRoot = this.objectService.getObject(session, setsRootPath);
        if (set.getSetSpec() != null) {
            /* validate that the hierarchy of sets exists */
        }

        final FedoraObject setObject = this.objectService.createObject(session, setsRootPath + "/" + setId);

        StringBuilder sparql = new StringBuilder("INSERT DATA {<" + translator.getSubject(setRoot.getPath())
                + "> <" + propertyHasSets + "> <" + translator.getSubject(setObject.getPath()) + ">}");
        setRoot.updatePropertiesDataset(translator, sparql.toString());

        sparql.setLength(0);
        sparql.append("INSERT DATA {")
                .append("<" + translator.getSubject(setObject.getPath()) + "> <" + propertySetName + "> '"
                        + set.getSetName() + "' .")
                .append("<" + translator.getSubject(setObject.getPath()) + "> <" + propertyHasSetSpec + "> '"
                        + set.getSetName() + "' .");
        for (DescriptionType desc : set.getSetDescription()) {
            // TODO: save description
        }
        sparql.append("}");
        setObject.updatePropertiesDataset(translator, sparql.toString());
        session.save();
        return setObject.getPath();
    } catch (JAXBException e) {
        e.printStackTrace();
        throw new RepositoryException(e);
    }
}

From source file:org.finra.dm.service.EmrServiceTest.java

/**
 * A test case to validate that the XSD restrictions are loose enough to allow empty elements for nested elements.
 *///from  ww w .  j  a v a  2 s .  co m
@Test
public void testUnmarshallXmlWithNestedElements() {
    String xml = "<emrClusterCreateRequest>" + "<namespace>" + NAMESPACE_CD + "</namespace>"
            + "<emrClusterDefinitionName>" + EMR_CLUSTER_DEFINITION_NAME + "</emrClusterDefinitionName>"
            + "<emrClusterName>cluster1</emrClusterName>" + "<dryRun>true</dryRun>"
            + "<emrClusterDefinitionOverride>" + "<customBootstrapActionMaster/>"
            + "<customBootstrapActionAll/>" + "<instanceDefinitions/>" + "<nodeTags/>"
            + "<daemonConfigurations/>" + "<hadoopConfigurations/>" + "</emrClusterDefinitionOverride>"
            + "</emrClusterCreateRequest>";
    try {
        xmlHelper.unmarshallXmlToObject(EmrClusterCreateRequest.class, xml);
    } catch (JAXBException e) {
        e.printStackTrace();
        fail("Failed to unmarshall XML");
    }
}

From source file:org.genericprodigy.rp.heroquest.classes.ClassMarshaller.java

/**
 * Marshals the {@link Model} object passed in to the {@code createInstance}
 * factory method into a new {@code MarshalledModel} entity object.
 *
 * @return {@link MarshalledModel} entity object with an XML representation
 * of the object state./*from   w ww.j  a v  a 2s.  c  o m*/
 */
public MarshalledModel marshal() {

    MarshalledXml xml = new MarshalledXml();
    String data = null;

    try {
        JAXBContext context = JAXBContext.newInstance(this.model.getClass());
        Marshaller marshaller = context.createMarshaller();
        StringWriter sw = new StringWriter();
        marshaller.marshal(this.model, sw);
        data = sw.toString();
        log.debug("Output Xml = " + sw.toString());
    } catch (javax.xml.bind.PropertyException propEx) {
        log.error("javax.xml.bind.PropertyException caught: " + propEx.getMessage(), propEx);
        propEx.printStackTrace();
    } catch (javax.xml.bind.JAXBException jaxbEx) {
        log.error("javax.xml.bind.JAXBException caught: " + jaxbEx.getMessage(), jaxbEx);
        jaxbEx.printStackTrace();
    } catch (Exception ex) {
        log.error("Exception caught: " + ex.getMessage(), ex);
        ex.printStackTrace();
    }

    xml.setData(data);
    return xml;
}

From source file:org.genericprodigy.rp.heroquest.classes.ClassMarshaller.java

/**
 * Unmarshals the {@link MarshalledModel} entity object from XML to a
 * {@link Model} object complete with existing state.
 *
 * @param data Marshalled entity representation of the object.
 * @return Unmarshalled entity object complete with state.
 *//*from  ww w . j  a v a  2  s.co  m*/
public T unmarshal(MarshalledModel data) {

    MarshalledXml xml = (MarshalledXml) data;
    T response = null;

    try {
        JAXBContext context = JAXBContext.newInstance(this.model.getClass());
        Unmarshaller unmarshaller = context.createUnmarshaller();
        StringReader sr = new StringReader(xml.getData());
        this.model = (T) unmarshaller.unmarshal(sr);
    } catch (javax.xml.bind.PropertyException propEx) {
        log.error("javax.xml.bind.PropertyException caught: " + propEx.getMessage(), propEx);
        propEx.printStackTrace();
    } catch (javax.xml.bind.JAXBException jaxbEx) {
        log.error("javax.xml.bind.JAXBException caught: " + jaxbEx.getMessage(), jaxbEx);
        jaxbEx.printStackTrace();
    } catch (Exception ex) {
        log.error("Exception caught: " + ex.getMessage(), ex);
        ex.printStackTrace();
    }

    return this.model;

}

From source file:org.genericprodigy.rp.heroquest.XmlMarshaller.java

/**
 * Marshals the {@link Model} object passed in to the {@code createInstance}
 * factory method into a new {@code MarshalledModel} entity object.
 *
 * @return {@link MarshalledModel} entity object with an XML representation
 * of the object state./*from  w w  w .j  a v  a  2  s  . c  o  m*/
 */
@Override
public MarshalledModel marshal() {
    MarshalledXml response = new MarshalledXml();

    String data = null;

    try {
        JAXBContext context = JAXBContext.newInstance(this.model.getClass());
        Marshaller marshaller = context.createMarshaller();
        StringWriter sw = new StringWriter();
        marshaller.marshal(this.model, sw);
        data = sw.toString();
        response.setData(data);
        log.debug("Output Xml = " + sw.toString());
    } catch (javax.xml.bind.PropertyException propEx) {
        log.error("javax.xml.bind.PropertyException caught: " + propEx.getMessage(), propEx);
        propEx.printStackTrace();
    } catch (javax.xml.bind.JAXBException jaxbEx) {
        log.error("javax.xml.bind.JAXBException caught: " + jaxbEx.getMessage(), jaxbEx);
        jaxbEx.printStackTrace();
    } catch (Exception ex) {
        log.error("Exception caught: " + ex.getMessage(), ex);
        ex.printStackTrace();
    }

    return (MarshalledModel) response;
}

From source file:org.genericprodigy.rp.heroquest.XmlMarshaller.java

/**
 * Unmarshals the {@link MarshalledModel} entity object from XML to a
 * {@link Model} object complete with existing state.
 *
 * @param data Marshalled entity representation of the object.
 * @return Unmarshalled entity object complete with state.
 *//*from  w  ww  .j a v a  2 s. com*/
@Override
public T unmarshal(MarshalledModel data) {

    MarshalledXml xml = (MarshalledXml) data;
    T response = null;

    try {
        JAXBContext context = JAXBContext.newInstance(this.model.getClass());
        Unmarshaller unmarshaller = context.createUnmarshaller();
        StringReader sr = new StringReader(xml.getData());
        this.model = (T) unmarshaller.unmarshal(sr);
    } catch (javax.xml.bind.PropertyException propEx) {
        log.error("javax.xml.bind.PropertyException caught: " + propEx.getMessage(), propEx);
        propEx.printStackTrace();
    } catch (javax.xml.bind.JAXBException jaxbEx) {
        log.error("javax.xml.bind.JAXBException caught: " + jaxbEx.getMessage(), jaxbEx);
        jaxbEx.printStackTrace();
    } catch (Exception ex) {
        log.error("Exception caught: " + ex.getMessage(), ex);
        ex.printStackTrace();
    }

    return this.model;

}

From source file:org.geon.XMLToADN.java

private String process(String xmlString) {

    Map metadata = new HashMap();

    // Extracting user input (name/value pairs) into a hashmap.
    int nameStartInd = xmlString.toLowerCase().indexOf("<name>");
    while (nameStartInd != -1) {
        int nameEndInd = xmlString.toLowerCase().indexOf("</name>");
        String name = xmlString.substring(nameStartInd + 6, nameEndInd);
        xmlString = xmlString.substring(nameEndInd + 7);
        int valueStartInd = xmlString.toLowerCase().indexOf("<value>");
        int valueEndInd = xmlString.toLowerCase().indexOf("</value>");
        String value = xmlString.substring(valueStartInd + 7, valueEndInd);
        xmlString = xmlString.substring(valueEndInd + 8);
        metadata.put(name, value);/*from ww w.  j a v a2s.com*/
        nameStartInd = xmlString.toLowerCase().indexOf("<name>");
    }

    String errMsg = "";

    String title = (String) metadata.get("title");
    String subjectss = (String) metadata.get("subjects");
    String keywords = (String) metadata.get("keywords");
    String permission = (String) metadata.get("permission");
    String description = (String) metadata.get("description");

    String personOrOrg1 = (String) metadata.get("person1");
    String role1 = (String) metadata.get("role1");
    String nametitle1 = (String) metadata.get("nametitle1");
    String firstname1 = (String) metadata.get("firstname1");
    String middlename1 = (String) metadata.get("middlename1");
    String lastname1 = (String) metadata.get("lastname1");
    String org1 = (String) metadata.get("org1");

    String email1 = (String) metadata.get("email1");
    String homepage1 = (String) metadata.get("homepage1");

    // handle spatial coverage
    // String min_altitude = (String) metadata.get("min_altitude");
    // String max_altitude = (String) metadata.get("max_altitude");

    String hrizontal = (String) metadata.get("hrizontal");
    String projection = (String) metadata.get("projection");
    String coordinate = (String) metadata.get("coordinate");

    // handle temporal coverage
    String time = (String) metadata.get("time");

    String geologic_time = (String) metadata.get("geologic_time");
    String begin_age = (String) metadata.get("begin_age");
    String end_age = (String) metadata.get("end_age");

    // handle present coverage
    String begin_date = (String) metadata.get("begindate");
    String end_date = (String) metadata.get("enddate");

    String t = time.trim();

    StringTokenizer stb = !time.equals("present") ? null : new StringTokenizer(begin_date, "/");

    int bm = !time.equals("present") ? 0 : Integer.parseInt(stb.nextToken());
    int bd = !time.equals("present") ? 0 : Integer.parseInt(stb.nextToken());
    int by = !time.equals("present") ? 0 : Integer.parseInt(stb.nextToken());

    StringTokenizer ste = !t.equals("present") ? null : new StringTokenizer(end_date, "/");

    int em;
    if (!t.equals("present")) {
        em = 0;
    } else {
        em = Integer.parseInt(ste.nextToken());
    }

    int ed;
    if (!t.equals("present")) {
        ed = 0;
    } else {
        ed = Integer.parseInt(ste.nextToken());
    }

    int ey;
    if (!t.equals("present")) {
        ey = 0;
    } else {
        ey = Integer.parseInt(ste.nextToken());
    }

    String begin_hour = (String) metadata.get("begin_hour");
    String end_hour = (String) metadata.get("end_hour");
    String begin_min = (String) metadata.get("begin_min");
    String end_min = (String) metadata.get("end_min");
    String begin_sec = (String) metadata.get("begin_sec");
    String end_sec = (String) metadata.get("end_sec");

    int bHour = Integer.parseInt(begin_hour);
    int bMin = Integer.parseInt(begin_min);
    int bSec = Integer.parseInt(begin_sec);

    int eHour = Integer.parseInt(end_hour);
    int eMin = Integer.parseInt(end_min);
    int eSec = Integer.parseInt(end_sec);

    String begin_month;
    String begin_day;
    String begin_year;

    String end_month;
    String end_day;
    String end_year;

    boolean earlier = true;

    if ((by < ey) || (by == ey && bm < em) || (by == ey && bm == em && bd < ed)
            || (by == ey && bm == em && bd == ed && bHour < eHour)
            || (by == ey && bm == em && bd == ed && bHour == eHour && bMin < eMin)
            || (by == ey && bm == em && bd == ed && bHour == eHour && bMin == eMin && bSec <= eSec)) {

        // begin date and time is earlier
        begin_month = Integer.toString(bm);
        begin_day = Integer.toString(bd);
        begin_year = Integer.toString(by);

        end_month = Integer.toString(em);
        end_day = Integer.toString(ed);
        end_year = Integer.toString(ey);

    } else {

        earlier = false;

        begin_month = Integer.toString(em);
        begin_day = Integer.toString(ed);
        begin_year = Integer.toString(ey);

        end_month = Integer.toString(bm);
        end_day = Integer.toString(bd);
        end_year = Integer.toString(by);

        String tmp = begin_hour;
        begin_hour = end_hour;
        end_hour = tmp;

        tmp = begin_min;
        begin_min = end_min;
        end_min = tmp;

        tmp = begin_sec;
        begin_sec = end_sec;
        end_sec = tmp;

    }

    String time_choice;
    if (by >= 0 && ey >= 0) {
        time_choice = "AD";
    } else if (by < 0 && ey < 0) {
        time_choice = "BC";
    } else {
        time_choice = "direct";
    }

    String bc_begin_year = earlier ? Integer.toString(-by) : Integer.toString(-ey);
    String bc_end_year = earlier ? Integer.toString(-ey) : Integer.toString(-by);

    String d_begin_year = earlier ? Integer.toString(-by) : Integer.toString(-ey);
    String d_end_year = earlier ? Integer.toString(ey) : Integer.toString(by);

    try {
        ObjectFactory factory = new ObjectFactory();

        ADNmetadataType itemRecord = (ADNmetadataType) factory
                .newInstance(Class.forName("org.dlese.adn.ItemRecord"));

        // //////////////////////////////////////////////////////////
        // //
        // // general
        // //
        // /////////////////////////////////////////////////////////
        GeneralType general = (GeneralType) factory.newInstance(Class.forName("org.dlese.adn.GeneralType"));
        general.setTitle(title);
        general.setDescription(description);
        general.setLanguage("en");

        // subjects
        SubjectsType subjects = (SubjectsType) factory.newInstance(Class.forName("org.dlese.adn.SubjectsType"));
        general.setSubjects(subjects);
        subjects.getSubject().add(subjectss);

        // keywords
        if (keywords != null) {
            KeywordsType keywordsType = (KeywordsType) factory
                    .newInstance(Class.forName("org.dlese.adn.KeywordsType"));

            general.setKeywords(keywordsType);
            StringTokenizer st = new StringTokenizer(keywords, ",");
            while (st.hasMoreTokens()) {
                String tmp = st.nextToken().trim();
                KeywordType keyword = (KeywordType) factory
                        .newInstance(Class.forName("org.dlese.adn.KeywordType"));
                keyword.setValue(tmp);
                keywordsType.getKeyword().add(keyword);
            }
        }
        // lifecycle
        LifecycleType lifecycle = (LifecycleType) factory
                .newInstance(Class.forName("org.dlese.adn.LifecycleType"));

        // set the first contributor
        ContributorsLifecycleType contributors = (ContributorsLifecycleType) factory
                .newInstance(Class.forName("org.dlese.adn.ContributorsLifecycleType"));
        lifecycle.setContributors(contributors);

        ContributorLifecycleType author = (ContributorLifecycleType) factory
                .newInstance(Class.forName("org.dlese.adn.ContributorLifecycleType"));
        author.setRole(role1);

        if (personOrOrg1.equals("Person")) {
            PersonType person = (PersonType) factory.newInstance(Class.forName("org.dlese.adn.PersonType"));
            person.setNameTitle(nametitle1);
            person.setNameFirst(firstname1);
            person.setNameMiddle(middlename1);
            person.setNameLast(lastname1);
            person.setInstName(org1);
            person.setEmailPrimary(email1);
            author.setPerson(person);

            contributors.getContributor().add(author);
        } else {
            OrganizationType org = (OrganizationType) factory
                    .newInstance(Class.forName("org.dlese.adn.OrganizationType"));
            org.setInstName(org1);
            contributors.getContributor().add(org);
        }

        // //////////////////////////////////////////////////////////
        // //
        // // metametadata
        // //
        // /////////////////////////////////////////////////////////
        MetaMetadataType metaMetadata = (MetaMetadataType) factory
                .newInstance(Class.forName("org.dlese.adn.MetaMetadataType"));
        CatalogEntriesType catalogEntries = (CatalogEntriesType) factory
                .newInstance(Class.forName("org.dlese.adn.CatalogEntriesType"));

        CatalogType catalog = (CatalogType) factory.newInstance(Class.forName("org.dlese.adn.CatalogType"));
        catalog.setValue("shapefile");

        // get unique id
        // UUIDGenerator ug = UUIDGenerator.getInstance();
        // UUID uuid = ug.generateTimeBasedUUID();

        UUIDGen uuidgen = new UUIDGen();
        String uuid = uuidgen.generateUUID();

        catalog.setEntry("GEON-" + uuid);
        catalogEntries.getCatalog().add(catalog);
        metaMetadata.setCatalogEntries(catalogEntries);

        DateInfoType dateInfo = (DateInfoType) factory.newInstance(Class.forName("org.dlese.adn.DateInfoType"));
        Calendar now = Calendar.getInstance();
        // dateInfo.setCreated(now.get(Calendar.YEAR)+"-"+now.get(Calendar.MONTH)+"-"+now.get(Calendar.DAY_OF_MONTH));
        dateInfo.setCreated(now);
        dateInfo.setValue("Registered");
        metaMetadata.setDateInfo(dateInfo);

        StatusOfType statusOf = (StatusOfType) factory.newInstance(Class.forName("org.dlese.adn.StatusOfType"));
        statusOf.setStatus("Submitted");
        statusOf.setValue("Submitted");
        metaMetadata.setStatusOf(statusOf);

        metaMetadata.setLanguage("en");
        metaMetadata.setCopyright("No");
        metaMetadata.setScheme("No scheme");

        TermsOfUseType termsOfUse = (TermsOfUseType) factory
                .newInstance(Class.forName("org.dlese.adn.TermsOfUseType"));
        termsOfUse.setValue("Terms of use consistent with GEON policy.");
        metaMetadata.setTermsOfUse(termsOfUse);

        // //////////////////////////////////////////////////////////
        // //
        // // technical
        // //
        // /////////////////////////////////////////////////////////
        TechnicalType technical = (TechnicalType) factory
                .newInstance(Class.forName("org.dlese.adn.TechnicalType"));
        OnlineType online = (OnlineType) factory.newInstance(Class.forName("org.dlese.adn.OnlineType"));
        online.setPrimaryURL("http://www.geongrid.org");

        RequirementsType requirements = (RequirementsType) factory
                .newInstance(Class.forName("org.dlese.adn.RequirementsType"));
        online.setRequirements(requirements);

        RequirementType requirement = (RequirementType) factory
                .newInstance(Class.forName("org.dlese.adn.RequirementType"));
        requirement.setReqType("DLESE:General:No specific technical requirements");
        requirements.getRequirement().add(requirement);

        technical.setOnline(online);

        // //////////////////////////////////////////////////////////
        // //
        // // right
        // //
        // /////////////////////////////////////////////////////////
        RightsType rights = (RightsType) factory.newInstance(Class.forName("org.dlese.adn.RightsType"));

        rights.setDescription(permission);
        rights.setCost("DLESE:No");

        // //////////////////////////////////////////////////////////
        // //
        // // relation
        // //
        // /////////////////////////////////////////////////////////
        RelationsType relations = (RelationsType) factory
                .newInstance(Class.forName("org.dlese.adn.RelationsType"));

        // //////////////////////////////////////////////////////////
        // //
        // // spatial coverage
        // //
        // /////////////////////////////////////////////////////////
        GeospatialCoveragesType geospatialCoverages = (GeospatialCoveragesType) factory
                .newInstance(Class.forName("org.dlese.adn.GeospatialCoveragesType"));

        GeospatialCoverageType geospatialCoverage = (GeospatialCoverageType) factory
                .newInstance(Class.forName("org.dlese.adn.GeospatialCoverageType"));

        BodyType body = (BodyType) factory.newInstance(Class.forName("org.dlese.adn.BodyType"));
        body.setPlanet("Earth");
        geospatialCoverage.setBody(body);

        geospatialCoverage.setGeodeticDatumGlobalOrHorz(hrizontal);

        ProjectionType proj = (ProjectionType) factory
                .newInstance(Class.forName("org.dlese.adn.ProjectionType"));
        proj.setType(projection);
        proj.setValue("Some projections here");
        geospatialCoverage.setProjection(proj);

        CoordinateSystemType coord = (CoordinateSystemType) factory
                .newInstance(Class.forName("org.dlese.adn.CoordinateSystemType"));
        coord.setType(coordinate);
        coord.setValue("Some cordinate system here");
        geospatialCoverage.setCoordinateSystem(coord);

        BoundBoxType box = (BoundBoxType) factory.newInstance(Class.forName("org.dlese.adn.BoundBoxType"));
        box.setBbSrcName("Cataloger supplied");

        /*
         * VertType vert =
         * (VertType)factory.newInstance(Class.forName("org.dlese.adn.VertType"
         * )); VertMinMaxType min =
         * (VertMinMaxType)factory.newInstance(Class
         * .forName("org.dlese.adn.VertMinMaxType"));
         * min.setUnits("centimeters (cm)"); min.setValue(new
         * BigDecimal(min_altitude[0]));
         * 
         * VertMinMaxType max =
         * (VertMinMaxType)factory.newInstance(Class.forName
         * ("org.dlese.adn.VertMinMaxType"));
         * max.setUnits("centimeters (cm)"); max.setValue(new
         * BigDecimal(max_altitude[0]));
         * 
         * vert.setVertMin(min); vert.setVertMax(max);
         * vert.setGeodeticDatumGlobalOrVert("DLESE:CGD28-CDN");
         * vert.setVertBase("Datum level");
         * 
         * box.setBbVert(vert);
         */

        geospatialCoverage.setBoundBox(box);
        // geospatialCoverage.setDetGeos();

        geospatialCoverages.getGeospatialCoverage().add(geospatialCoverage);

        // //////////////////////////////////////////////////////////
        // //
        // // temporal coverage
        // //
        // /////////////////////////////////////////////////////////
        TemporalCoveragesType temporalCoverages = (TemporalCoveragesType) factory
                .newInstance(Class.forName("org.dlese.adn.TemporalCoveragesType"));
        TimeAndPeriodType timeAndPeriod = (TimeAndPeriodType) factory
                .newInstance(Class.forName("org.dlese.adn.TimeAndPeriodType"));
        temporalCoverages.getTimeAndPeriod().add(timeAndPeriod);

        // set time directly into relativeTime
        TimeInfoType timeInfo = (TimeInfoType) factory.newInstance(Class.forName("org.dlese.adn.TimeInfoType"));

        timeAndPeriod.setTimeInfo(timeInfo);

        if (time.equals("notpresent")) {
            if (geologic_time.equals("other")) {

                TimeRelativeType timeRelative = (TimeRelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.TimeRelativeType"));
                timeInfo.setTimeRelative(timeRelative);

                RelativeType begin = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setBegin(begin);
                begin.setValue(new BigDecimal(begin_age));
                begin.setUnits("ma");

                RelativeType end = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setEnd(end);
                end.setValue(new BigDecimal(end_age));
                end.setUnits("ma");

            } else {

                TimeRelativeType timeRelative = (TimeRelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.TimeRelativeType"));
                timeInfo.setTimeRelative(timeRelative);

                RelativeType begin = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setBegin(begin);
                begin.setValue(new BigDecimal(0));
                begin.setUnits("ma");

                RelativeType end = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setEnd(end);
                end.setValue(new BigDecimal(0));
                end.setUnits("ma");

                // set time to periods
                PeriodsType periods = (PeriodsType) factory
                        .newInstance(Class.forName("org.dlese.adn.PeriodsType"));
                timeAndPeriod.setPeriods(periods);

                PeriodType period = (PeriodType) factory.newInstance(Class.forName("org.dlese.adn.PeriodType"));
                periods.getPeriod().add(period);
                period.setName(geologic_time);
                period.setSource("USGS-Geologic-Time-Scale");

            }
        } else if (time.equals("present")) {

            // set time directly into timeAD or timeBC
            if (time_choice.equals("AD")) {

                TimeADType timeAD = (TimeADType) factory.newInstance(Class.forName("org.dlese.adn.TimeADType"));
                timeInfo.setTimeAD(timeAD);

                Calendar begin = Calendar.getInstance();
                begin.clear();

                begin.add(Calendar.YEAR, Integer.parseInt(begin_year) - 1970);
                begin.add(Calendar.MONTH, Integer.parseInt(begin_month) - 1);
                begin.add(Calendar.DAY_OF_MONTH, Integer.parseInt(begin_day) - 1);

                Calendar bt = Calendar.getInstance();
                bt.clear();

                bt.add(Calendar.HOUR, Integer.parseInt(begin_hour));
                bt.add(Calendar.MINUTE, Integer.parseInt(begin_min));
                bt.add(Calendar.SECOND, Integer.parseInt(begin_sec));

                Calendar end = Calendar.getInstance();
                end.clear();
                end.add(Calendar.YEAR, Integer.parseInt(end_year) - 1970);
                end.add(Calendar.MONTH, Integer.parseInt(end_month) - 1);
                end.add(Calendar.DAY_OF_MONTH, Integer.parseInt(end_day) - 1);

                Calendar et = Calendar.getInstance();
                et.clear();

                et.add(Calendar.HOUR, Integer.parseInt(end_hour));
                et.add(Calendar.MINUTE, Integer.parseInt(end_min));
                et.add(Calendar.SECOND, Integer.parseInt(end_sec));

                ADType tmp = (ADType) factory.newInstance(Class.forName("org.dlese.adn.ADType"));
                tmp.setDate(begin);
                tmp.setTime(bt);
                tmp.setValue("");
                timeAD.setBegin(tmp);

                tmp = (ADType) factory.newInstance(Class.forName("org.dlese.adn.ADType"));
                tmp.setDate(end);
                tmp.setTime(et);
                tmp.setValue("");
                timeAD.setEnd(tmp);

            } else if (time_choice.equals("BC")) {

                TimeBCType timeBC = (TimeBCType) factory.newInstance(Class.forName("org.dlese.adn.TimeBCType"));
                timeInfo.setTimeBC(timeBC);

                timeBC.setBegin(bc_begin_year);
                timeBC.setEnd(bc_end_year);

            } else if (time_choice.equals("direct")) {

                TimeRelativeType timeRelative = (TimeRelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.TimeRelativeType"));
                timeInfo.setTimeRelative(timeRelative);

                RelativeType begin = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setBegin(begin);
                begin.setValue(new BigDecimal("-" + d_begin_year));
                begin.setUnits("year");

                RelativeType end = (RelativeType) factory
                        .newInstance(Class.forName("org.dlese.adn.RelativeType"));
                timeRelative.setEnd(end);
                end.setValue(new BigDecimal(d_end_year));
                end.setUnits("year");

            }
        }

        // handle object in space
        ObjectsInSpaceType objectsInSpace = (ObjectsInSpaceType) factory
                .newInstance(Class.forName("org.dlese.adn.ObjectsInSpaceType"));

        itemRecord.setGeneral(general);
        itemRecord.setLifecycle(lifecycle);
        itemRecord.setMetaMetadata(metaMetadata);
        itemRecord.setRights(rights);
        itemRecord.setTechnical(technical);
        // itemRecord.setRelations(relations);
        itemRecord.setGeospatialCoverages(geospatialCoverages);
        if (!time.equals("any")) {
            itemRecord.setTemporalCoverages(temporalCoverages);
        }
        itemRecord.setObjectsInSpace(objectsInSpace);

        // marshall
        JAXBContext jc = JAXBContext.newInstance("org.dlese.adn");
        Marshaller m = jc.createMarshaller();
        m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

        // create and save target

        // save into a directory
        File dir = new File("adn/" + uuid); // TODO: remove adn folder once
        // all the files have been
        // removed.
        dir.mkdirs();
        dirPath = dir.getAbsolutePath();

        // unzip the uploaded file
        String shpFile = shpURL;
        String unzipFileName = "";
        if (shpFile.trim().startsWith("http://")) {
            URL shpURL = new URL(shpFile);
            HttpURLConnection huc = (HttpURLConnection) shpURL.openConnection();
            huc.connect();
            InputStream in = huc.getInputStream();
            File zip = new File(dir, "tmp.zip");
            FileOutputStream out = new FileOutputStream(zip);
            byte[] buffer = new byte[1024];
            int count = in.read(buffer);
            while (count > 0) {
                out.write(buffer, 0, count);
                count = in.read(buffer);
            }
            huc.disconnect();
            out.close();
            unzipFileName = unzip(dir, zip); // Unzipping the ftpped file to
            // dir.
            zip.delete(); // the zip file is no longer necessary.
        } else if (shpFile.trim().startsWith("ftp://")) {
            shpFile = shpFile.substring(6);
            String username = "anonymous";
            String password = "geon@geongrid.org";
            int index = shpFile.indexOf("/");
            String hostname = shpFile.substring(0, index);
            String filename = shpFile.substring(index);
            org.apache.commons.net.ftp.FTPClient f = new org.apache.commons.net.ftp.FTPClient();
            f.connect(hostname);
            f.login(username, password);
            f.setFileType(FTP.BINARY_FILE_TYPE);
            File zip = new File(dir, "tmp.zip");
            FileOutputStream fos = new FileOutputStream(zip);
            f.retrieveFile(filename, fos);
            f.disconnect();
            fos.close();
            unzipFileName = unzip(dir, zip); // Unzipping the ftpped file to
            // dir.
            zip.delete(); // the zip file is no longer necessary.

        } else { // file is local..
            java.io.File zip = new java.io.File(shpFile);
            unzipFileName = unzip(dir, zip);
        }

        if (!unzipFileName.equals("")) {
            // calculate the binding box and set the adn schema
            shpfis = new FileInputStream(dirPath + "/" + unzipFileName + ".shp");
            Shapefile shape = new Shapefile(shpfis);
            double[] bounds = shape.getBounds();

            box.setWestCoord(new BigDecimal(bounds[0]));
            box.setNorthCoord(new BigDecimal(bounds[1]));
            box.setEastCoord(new BigDecimal(bounds[2]));
            box.setSouthCoord(new BigDecimal(bounds[3]));

            shpfis.close();
            // Object x = (Object) shape;

            // shape = new Shapefile();

            /*
             * File shp = new File(dir, unzipFileName + ".shp"); File shx =
             * new File(dir, unzipFileName + ".shx"); File dbf = new
             * File(dir, unzipFileName + ".dbf");
             * 
             * 
             * shp.delete(); shx.delete(); dbf.delete(); //dir.delete();
             */
        }
        /*
         * // calculate the schema and ask for more explanation DBase db =
         * new DBase(dirName); db.openTable(fileName); String [] columns =
         * db.getColumnNames(); ArrayList list = new ArrayList(); for (int
         * i=0; i<columns.length; i++) { list.add(columns[i]); }
         */// save its metadata
        File adn = new File(dir, uuid + ".adn");
        FileOutputStream fos = new FileOutputStream(adn);
        m.marshal(itemRecord, fos);
        fos.close();

        /*
         * } catch (Exception e) {
         * 
         * try { PrintWriter pw = new PrintWriter(new
         * FileWriter("/home/jaeger/log.txt", true)); e.printStackTrace(pw);
         * pw.flush(); } catch (Exception ex) {}
         * 
         * throw new JspException(e.getMessage()); } return SKIP_BODY; }
         * 
         * 
         * 
         * private String label(String string) { return
         * "<table width=90% cellpadding=1 cellspacing=0 border=0>\n"+
         * "<tr><td bgcolor=Gainsboro>\n"+
         * "<font face=\"arial,sans-serif\" size=-1 color=#777777>\n"+
         * "&nbsp; <b>"+string+"</b>\n"+ "</font>\n"+ "</td></tr>\n"+
         * "</table>\n"; }
         * 
         * 
         * private String message(String key, String val) { return
         * "    <tr>\n" +
         * "        <td align=right width=150><div class=label><b>"
         * +key+":</b></div></td>\n" +
         * "        <td align=left>"+val+"</td>\n" + "    </tr>\n"; }
         * 
         * 
         * private String messagePadding(String key, String val) { return
         * "    <tr>\n" +
         * "        <td align=right width=150><div class=label>&nbsp;&nbsp;&nbsp;"
         * +key+":</div></td>\n" + "        <td align=left>"+val+"</td>\n" +
         * "    </tr>\n"; }
         */
        return adn.getAbsolutePath();
    } catch (ClassNotFoundException cnfex) {
        cnfex.printStackTrace();
        _deleteFiles();
    } catch (JAXBException jex) {
        jex.printStackTrace();
        _deleteFiles();
    } catch (FileNotFoundException fnex) {
        fnex.printStackTrace();
        _deleteFiles();
    } catch (IOException ioex) {
        ioex.printStackTrace();
        _deleteFiles();
    } catch (ShapefileException shex) {
        shex.printStackTrace();
        _deleteFiles();
    } catch (Exception ex) {
        ex.printStackTrace();
        _deleteFiles();
    }
    return "";

}

From source file:org.geoserver.wfs.notification.TriggerFileWatcher.java

@Override
protected Map<QName, List<Trigger>> doLoad(URLConnection conn) {
    Triggers triggers = null;//from  w w w  . j av  a2s . c  om
    InputStream inputStream = null;
    try {
        Unmarshaller unm = CTX.createUnmarshaller();
        try {
            unm.setProperty("com.sun.xml.bind.ObjectFactory", new ObjectFactoryEx());
        } catch (PropertyException pe) {
            try {
                unm.setProperty("com.sun.xml.internal.bind.ObjectFactory", new ObjectFactoryEx());
            } catch (PropertyException pe2) {

            }
        }
        inputStream = conn.getInputStream();
        triggers = unm.unmarshal(new StreamSource(inputStream), Triggers.class).getValue();
    } catch (JAXBException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        IOUtils.closeQuietly(inputStream);
    }

    if (triggers == null)
        return Collections.EMPTY_MAP;

    final HashMap<QName, List<Trigger>> map = new HashMap<QName, List<Trigger>>(triggers.getFeature().size());
    for (Feature f : triggers.getFeature())
        map.put(f.getType(), f.getTrigger());
    return Collections.unmodifiableMap(map);
}

From source file:org.jahia.utils.migration.Migrators.java

public Migrators() {
    InputStream migrationConfigInputStream = this.getClass().getClassLoader()
            .getResourceAsStream("org/jahia/utils/migration/migrations.xml");
    try {//from   w w  w  .  jav a 2 s . c o m
        migrationsConfig = unmarshal(Migrations.class, migrationConfigInputStream);
    } catch (JAXBException e) {
        e.printStackTrace();
    } catch (XMLStreamException e) {
        e.printStackTrace();
    }
}

From source file:org.jts.docGenerator.indexFiles.AllMessageDefinitions.java

public AllMessageDefinitions() {
    try {//from   w w w . j  a v a  2s. co  m
        JAXBContext jc = JAXBContext.newInstance("org.jts.jsidl.binding");
        unmarshaller = jc.createUnmarshaller();
    } catch (JAXBException je) {
        je.printStackTrace();
    }

    factory = new ObjectFactory();
}