Example usage for java.util Calendar clear

List of usage examples for java.util Calendar clear

Introduction

In this page you can find the example usage for java.util Calendar clear.

Prototype

public final void clear() 

Source Link

Document

Sets all the calendar field values and the time value (millisecond offset from the Epoch) of this Calendar undefined.

Usage

From source file:org.apache.jena.graph.test.TestTypedLiterals.java

public void testDateTime_7() {
    Calendar testCal3 = new GregorianCalendar(TimeZone.getTimeZone("GMT"));
    testCal3.clear();
    testCal3.set(1999, Calendar.JANUARY, 30, 15, 9, 32);
    Literal lc = m.createTypedLiteral(testCal3);
    assertEquals("1999-01-30T15:09:32Z", lc.getLexicalForm());
    String urib = "rdf://test.com#";
    String uri1 = urib + "1";
    String urip = urib + "prop";
    String testN3 = "<" + uri1 + "> <" + urip + "> \"" + lc.getLexicalForm() + "\"^^<" + lc.getDatatypeURI()
            + "> .";
    java.io.StringReader sr = new java.io.StringReader(testN3);
    m.read(sr, urib, "N3");
    assertTrue(m.contains(m.getResource(uri1), m.getProperty(urip)));
    Resource r1 = m.getResource(uri1);
    Property p = m.getProperty(urip);/*from  www . j  av a2s.c  om*/
    XSDDateTime returnedDateTime = (XSDDateTime) r1.getProperty(p).getLiteral().getValue();
    assertEquals("deserialized calendar value", testCal3, returnedDateTime.asCalendar());
}

From source file:org.apache.flume.sink.hdfs.TestHDFSEventSink.java

/**
 * Ensure that when a write throws an IOException we are
 * able to continue to progress in the next process() call.
 * This relies on Transactional rollback semantics for durability and
 * the behavior of the BucketWriter class of close()ing upon IOException.
 *///from   w w  w.ja  va2 s.co  m
@Test
public void testCloseReopen()
        throws InterruptedException, LifecycleException, EventDeliveryException, IOException {

    LOG.debug("Starting...");
    final int numBatches = 4;
    final String fileName = "FlumeData";
    final long rollCount = 5;
    final long batchSize = 2;
    String newPath = testPath + "/singleBucket";
    int i = 1, j = 1;

    HDFSBadWriterFactory badWriterFactory = new HDFSBadWriterFactory();
    sink = new HDFSEventSink(badWriterFactory);

    // clear the test directory
    Configuration conf = new Configuration();
    FileSystem fs = FileSystem.get(conf);
    Path dirPath = new Path(newPath);
    fs.delete(dirPath, true);
    fs.mkdirs(dirPath);

    Context context = new Context();

    context.put("hdfs.path", newPath);
    context.put("hdfs.filePrefix", fileName);
    context.put("hdfs.rollCount", String.valueOf(rollCount));
    context.put("hdfs.batchSize", String.valueOf(batchSize));
    context.put("hdfs.fileType", HDFSBadWriterFactory.BadSequenceFileType);

    Configurables.configure(sink, context);

    MemoryChannel channel = new MemoryChannel();
    Configurables.configure(channel, new Context());

    sink.setChannel(channel);
    sink.start();

    Calendar eventDate = Calendar.getInstance();
    List<String> bodies = Lists.newArrayList();
    // push the event batches into channel
    for (i = 1; i < numBatches; i++) {
        channel.getTransaction().begin();
        try {
            for (j = 1; j <= batchSize; j++) {
                Event event = new SimpleEvent();
                eventDate.clear();
                eventDate.set(2011, i, i, i, 0); // yy mm dd
                event.getHeaders().put("timestamp", String.valueOf(eventDate.getTimeInMillis()));
                event.getHeaders().put("hostname", "Host" + i);
                String body = "Test." + i + "." + j;
                event.setBody(body.getBytes());
                bodies.add(body);
                // inject fault
                event.getHeaders().put("fault-until-reopen", "");
                channel.put(event);
            }
            channel.getTransaction().commit();
        } finally {
            channel.getTransaction().close();
        }
        LOG.info("execute sink to process the events: " + sink.process());
    }
    LOG.info("clear any events pending due to errors: " + sink.process());
    sink.stop();

    verifyOutputSequenceFiles(fs, conf, dirPath.toUri().getPath(), fileName, bodies);
}

From source file:org.apache.flume.sink.hdfs.TestHDFSEventSink.java

@Test
public void testBadSimpleAppend()
        throws InterruptedException, LifecycleException, EventDeliveryException, IOException {

    LOG.debug("Starting...");
    final String fileName = "FlumeData";
    final long rollCount = 5;
    final long batchSize = 2;
    final int numBatches = 4;
    String newPath = testPath + "/singleBucket";
    int totalEvents = 0;
    int i = 1, j = 1;

    HDFSBadWriterFactory badWriterFactory = new HDFSBadWriterFactory();
    sink = new HDFSEventSink(badWriterFactory);

    // clear the test directory
    Configuration conf = new Configuration();
    FileSystem fs = FileSystem.get(conf);
    Path dirPath = new Path(newPath);
    fs.delete(dirPath, true);//from   ww w  .ja  v  a2 s.  c  o  m
    fs.mkdirs(dirPath);

    Context context = new Context();

    context.put("hdfs.path", newPath);
    context.put("hdfs.filePrefix", fileName);
    context.put("hdfs.rollCount", String.valueOf(rollCount));
    context.put("hdfs.batchSize", String.valueOf(batchSize));
    context.put("hdfs.fileType", HDFSBadWriterFactory.BadSequenceFileType);

    Configurables.configure(sink, context);

    Channel channel = new MemoryChannel();
    Configurables.configure(channel, context);

    sink.setChannel(channel);
    sink.start();

    Calendar eventDate = Calendar.getInstance();

    List<String> bodies = Lists.newArrayList();
    // push the event batches into channel
    for (i = 1; i < numBatches; i++) {
        Transaction txn = channel.getTransaction();
        txn.begin();
        for (j = 1; j <= batchSize; j++) {
            Event event = new SimpleEvent();
            eventDate.clear();
            eventDate.set(2011, i, i, i, 0); // yy mm dd
            event.getHeaders().put("timestamp", String.valueOf(eventDate.getTimeInMillis()));
            event.getHeaders().put("hostname", "Host" + i);

            String body = "Test." + i + "." + j;
            event.setBody(body.getBytes());
            bodies.add(body);
            // inject fault
            if ((totalEvents % 30) == 1) {
                event.getHeaders().put("fault-once", "");
            }
            channel.put(event);
            totalEvents++;
        }
        txn.commit();
        txn.close();

        LOG.info("Process events: " + sink.process());
    }
    LOG.info("Process events to end of transaction max: " + sink.process());
    LOG.info("Process events to injected fault: " + sink.process());
    LOG.info("Process events remaining events: " + sink.process());
    sink.stop();
    verifyOutputSequenceFiles(fs, conf, dirPath.toUri().getPath(), fileName, bodies);

}

From source file:org.apache.flume.sink.hdfs.TestHDFSEventSink.java

private void slowAppendTestHelper(long appendTimeout)
        throws InterruptedException, IOException, LifecycleException, EventDeliveryException, IOException {
    final String fileName = "FlumeData";
    final long rollCount = 5;
    final long batchSize = 2;
    final int numBatches = 2;
    String newPath = testPath + "/singleBucket";
    int totalEvents = 0;
    int i = 1, j = 1;

    // clear the test directory
    Configuration conf = new Configuration();
    FileSystem fs = FileSystem.get(conf);
    Path dirPath = new Path(newPath);
    fs.delete(dirPath, true);/*from   w w w. j  a va2s .  c  o  m*/
    fs.mkdirs(dirPath);

    // create HDFS sink with slow writer
    HDFSBadWriterFactory badWriterFactory = new HDFSBadWriterFactory();
    sink = new HDFSEventSink(badWriterFactory);

    Context context = new Context();
    context.put("hdfs.path", newPath);
    context.put("hdfs.filePrefix", fileName);
    context.put("hdfs.rollCount", String.valueOf(rollCount));
    context.put("hdfs.batchSize", String.valueOf(batchSize));
    context.put("hdfs.fileType", HDFSBadWriterFactory.BadSequenceFileType);
    context.put("hdfs.appendTimeout", String.valueOf(appendTimeout));
    Configurables.configure(sink, context);

    Channel channel = new MemoryChannel();
    Configurables.configure(channel, context);

    sink.setChannel(channel);
    sink.start();

    Calendar eventDate = Calendar.getInstance();
    List<String> bodies = Lists.newArrayList();
    // push the event batches into channel
    for (i = 0; i < numBatches; i++) {
        Transaction txn = channel.getTransaction();
        txn.begin();
        for (j = 1; j <= batchSize; j++) {
            Event event = new SimpleEvent();
            eventDate.clear();
            eventDate.set(2011, i, i, i, 0); // yy mm dd
            event.getHeaders().put("timestamp", String.valueOf(eventDate.getTimeInMillis()));
            event.getHeaders().put("hostname", "Host" + i);
            event.getHeaders().put("slow", "1500");
            String body = "Test." + i + "." + j;
            event.setBody(body.getBytes());
            bodies.add(body);
            channel.put(event);
            totalEvents++;
        }
        txn.commit();
        txn.close();

        // execute sink to process the events
        sink.process();
    }

    sink.stop();

    // loop through all the files generated and check their contains
    FileStatus[] dirStat = fs.listStatus(dirPath);
    Path fList[] = FileUtil.stat2Paths(dirStat);

    // check that the roll happened correctly for the given data
    // Note that we'll end up with two files with only a head
    long expectedFiles = totalEvents / rollCount;
    if (totalEvents % rollCount > 0)
        expectedFiles++;
    Assert.assertEquals("num files wrong, found: " + Lists.newArrayList(fList), expectedFiles, fList.length);
    verifyOutputSequenceFiles(fs, conf, dirPath.toUri().getPath(), fileName, bodies);
}

From source file:org.kuali.kfs.coa.document.validation.impl.AccountRuleTest.java

public void testGuidelinesConditionallyRequired_FarPastDate() {

    boolean result;
    Account account = new Account();
    MaintenanceDocument maintDoc = newMaintDoc(account);
    AccountRule rule = (AccountRule) setupMaintDocRule(maintDoc, AccountRule.class);

    // get an arbitrarily early date
    Calendar testDate = Calendar.getInstance();
    testDate.clear();
    testDate.set(1900, 1, 1);/*from   w  w  w  .ja  v  a2 s.  c o  m*/
    account.setAccountExpirationDate(new Date(testDate.getTimeInMillis()));
    result = rule.areGuidelinesRequired(account);
    assertEquals("Guidelines should not be required for Account with prior ExpirationDate", false, result);
}

From source file:org.kuali.kfs.coa.document.validation.impl.AccountRuleTest.java

public void testGuidelinesConditionallyRequired_FarFutureDate() {

    boolean result;
    Account account = new Account();
    MaintenanceDocument maintDoc = newMaintDoc(account);
    AccountRule rule = (AccountRule) setupMaintDocRule(maintDoc, AccountRule.class);

    // get an arbitrarily future date
    Calendar testDate = Calendar.getInstance();
    testDate.clear();
    testDate.set(2100, 1, 1);/*www.j  a va  2s . c  om*/
    account.setAccountExpirationDate(new Date(testDate.getTimeInMillis()));
    result = rule.areGuidelinesRequired(account);
    assertEquals("Guidelines should be required for Account with future ExpirationDate", true, result);

}

From source file:org.kuali.ole.coa.document.validation.impl.AccountRuleTest.java

@Test
public void testGuidelinesConditionallyRequired_FarPastDate() {

    boolean result;
    Account account = new Account();
    MaintenanceDocument maintDoc = newMaintDoc(account);
    AccountRule rule = (AccountRule) setupMaintDocRule(maintDoc, AccountRule.class);

    // get an arbitrarily early date
    Calendar testDate = Calendar.getInstance();
    testDate.clear();
    testDate.set(1900, 1, 1);/*from www .j  a  v  a2s .co m*/
    account.setAccountExpirationDate(new Date(testDate.getTimeInMillis()));
    result = rule.areGuidelinesRequired(account);
    assertEquals("Guidelines should not be required for Account with prior ExpirationDate", false, result);
}

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 w  w w  .j  a  va  2s.c  om*/
        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.kuali.ole.coa.document.validation.impl.AccountRuleTest.java

@Test
public void testGuidelinesConditionallyRequired_FarFutureDate() {

    boolean result;
    Account account = new Account();
    MaintenanceDocument maintDoc = newMaintDoc(account);
    AccountRule rule = (AccountRule) setupMaintDocRule(maintDoc, AccountRule.class);

    // get an arbitrarily future date
    Calendar testDate = Calendar.getInstance();
    testDate.clear();
    testDate.set(2100, 1, 1);//from www . j a va  2 s .  co m
    account.setAccountExpirationDate(new Date(testDate.getTimeInMillis()));
    result = rule.areGuidelinesRequired(account);
    assertEquals("Guidelines should be required for Account with future ExpirationDate", true, result);

}

From source file:org.kuali.kfs.coa.document.validation.impl.AccountRuleTest.java

public void testCheckAccountExpirationDateTodayOrEarlier_PastDate() {

    MaintenanceDocument maintDoc = newMaintDoc(newAccount);
    AccountRule rule = (AccountRule) setupMaintDocRule(maintDoc, AccountRule.class);
    boolean result;
    Calendar testCalendar;
    Date testTimestamp;/*from  ww  w.j  av a2  s  . c  om*/

    // get an arbitrarily early date
    testCalendar = Calendar.getInstance();
    testCalendar.clear();
    testCalendar.set(1900, 1, 1);
    testTimestamp = new Date(testCalendar.getTimeInMillis());

    // past expiration date - pass
    newAccount.setAccountExpirationDate(testTimestamp);
    result = rule.checkAccountExpirationDateValidTodayOrEarlier(newAccount);
    assertEquals("Arbitrarily early date should fail.", true, result);
    assertGlobalMessageMapEmpty();

}