Java Document类代码示例

import org.apache.abdera.model.Document; //导入依赖的package包/类
private Document<Feed> getDocument() throws IOException, ParseException {
    if (document == null) {
        if (ObjectHelper.isEmpty(endpoint.getUsername()) || ObjectHelper.isEmpty(endpoint.getPassword())) {
            document = AtomUtils.parseDocument(endpoint.getFeedUri());
        } else {
            document = AtomUtils.parseDocument(endpoint.getFeedUri(), endpoint.getUsername(), endpoint.getPassword());
        }
        Feed root = document.getRoot();
        if (endpoint.isSortEntries()) {
            sortEntries(root);
        }
        list = root.getEntries();
        entryIndex = list.size() - 1;
    }
    return document;
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
@Test
public void testFilter() throws Exception {
    Document<Feed> doc = AtomUtils.parseDocument("file:src/test/data/feed.atom");
    assertNotNull(doc);

    // timestamp from the feed to use as base
    // 2007-11-13T13:35:25.014Z
    Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT+1:00"));
    cal.set(2007, Calendar.NOVEMBER, 13, 14, 35, 0);
    EntryFilter filter = new UpdatedDateFilter(cal.getTime());

    List<Entry> entries = doc.getRoot().getEntries();

    // must reverse backwards
    for (int i = entries.size() - 1; i > 0; i--) {
        Entry entry = entries.get(i);
        boolean valid = filter.isValidEntry(null, doc, entry);
        // only the 3 last should be true
        if (i > 3) {
            assertEquals("not valid", false, valid);
        } else {
            assertEquals("valid", true, valid);
        }
    }
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
/**
 * Executes the command
 * @return the feed received from the VLER DAS system
 * @throws VlerDasException if an unsuccessful response is received from the VLER DAS webservice call
 */
public Document<Feed> fetchData() throws VlerDasException {
    String pid = getPid(query.getPatientIds());
    String url = constructUrl(pid);

    ClientResponse response = doAbderaRequest(url);
    Document<Feed> vlerData = null;

    if (response.getType() == ResponseType.SUCCESS) {
        vlerData = response.getDocument();
    } else {
        LOGGER.warn("Received failed response from VLER DAS service: " + response.getStatus() + "/"
                + response.getStatusText() + ", URI=\"" + response.getUri() + "\"");
        throw new VlerDasException("Unable to fetch patient data from VLER DAS for ICN: " + pid);
    }

    return vlerData;
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
/**
 * Retrieve DoD vital data and format it into a VistaChunk to be included into the set of data returned to the system.
 *
 * @param document the document
 * @param patientIds Patient identifier bean.
 * @return The VistaDataChunk list that contains the vital data.
 */
public static List<VistaDataChunk> getVistaDataChunks(Document<Feed> document, PatientIds patientIds) {
    LOG.debug("started VlerDasVitalsMapper.getVistaDataChunks");

    List<VistaDataChunk> oaVitalChunk = new ArrayList<VistaDataChunk>();

    List<VitalSign> oaVital = transformFeed(document, patientIds);

    if ((oaVital != null) && (oaVital.size() > 0)) {

        int iNumVitals = oaVital.size();
        int iCurVitalIdx = 1;       // One based index
        for (VitalSign oVital : oaVital) {
            VistaDataChunk oVitalChunk = transformVitalChunk(oVital, patientIds, iNumVitals, iCurVitalIdx);
            if (oVitalChunk != null) {
                oaVitalChunk.add(oVitalChunk);
                iCurVitalIdx++;
            }
        }
    }

    LOG.debug("finished VlerDasVitalsMapper.getVistaDataChunks");
    return oaVitalChunk;
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
@Test
public void testFetchDataSuccessResponse() {
    Document mockResults = Mockito.mock(Document.class);

    // create mock successful response
    AbderaClient successfulClient = Mockito.mock(AbderaClient.class);
    ClientResponse successResponse = Mockito.mock(ClientResponse.class);
    Mockito.when(successResponse.getType()).thenReturn(Response.ResponseType.SUCCESS);
    Mockito.when(successResponse.getDocument()).thenReturn(mockResults);
    Mockito.when(successfulClient.get(Mockito.anyString())).thenReturn(successResponse);

    // test successful fetch
    try {
        command.setWsClient(successfulClient);
        Assert.assertNotNull(command.fetchData());

    } catch (Throwable t) {
        t.printStackTrace();
        Assert.fail("fetchData should not have thrown an exception");
    }
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
@Test
public void testFetchDataFailureResponse() {
    Document mockResults = Mockito.mock(Document.class);

    // create mock failed response
    AbderaClient failedClient = Mockito.mock(AbderaClient.class);
    ClientResponse failureResponse = Mockito.mock(ClientResponse.class);
    Mockito.when(failureResponse.getType()).thenReturn(Response.ResponseType.SERVER_ERROR);
    Mockito.when(failureResponse.getDocument()).thenReturn(mockResults);
    Mockito.when(failedClient.get(Mockito.anyString())).thenReturn(failureResponse);

    // test failed fetch
    try {
        command.setWsClient(failedClient);
        command.fetchData();

        Assert.fail("fetchData should have thrown an exception");

    } catch (VlerDasException vde) {
        // this was expected
    }
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
@Override
protected Object createFeed() throws IOException {
    Document<Feed> document;
    if (ObjectHelper.isEmpty(endpoint.getUsername()) || ObjectHelper.isEmpty(endpoint.getPassword())) {
        document = AtomUtils.parseDocument(endpoint.getFeedUri());
    } else {
        document = AtomUtils.parseDocument(endpoint.getFeedUri(), endpoint.getUsername(), endpoint.getPassword());
    }
    return document.getRoot();
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
public static Document<Feed> parseDocument(String uri, String username, String password) throws IOException {
    URL feedUrl = new URL(uri);
    HttpURLConnection httpcon = (HttpURLConnection) feedUrl.openConnection();
    String encoding = Base64.encodeBase64String(username.concat(":").concat(password).getBytes());
    httpcon.setRequestProperty("Authorization", "Basic " + encoding);
    InputStream in = httpcon.getInputStream();
    return parseInputStream(in);
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
private static Document<Feed> parseInputStream(InputStream in) throws ParseException {
    Parser parser = getAtomParser();
    // set the thread context loader with the ParserClassLoader
    ClassLoader old = Thread.currentThread().getContextClassLoader();
    try {
        Thread.currentThread().setContextClassLoader(parser.getClass().getClassLoader());
        return parser.parse(in);
    } finally {
        Thread.currentThread().setContextClassLoader(old);
    }
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
private Entry getEntryFromFile(File f) throws FilesystemAccessException {
	long size = f.getSize();
	if (size > MAX_ENTRY_SIZE)
		throw new FilesystemAccessException("entry larger than 50kB");
	byte[] contents = f.getContents(0, (int) size);
	Document<Entry> doc = parser.parse(new ByteArrayInputStream(contents));
	return doc.getRoot();
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
/**
 * Transform feed.
 *
 * @param document the document
 * @param patientIds the patient ids
 * @return the list
 */
@SuppressWarnings("unchecked")
private static List<VitalSign> transformFeed(Document<Feed> document, PatientIds patientIds) {
    List<VitalSign> list = new ArrayList<VitalSign>();

    Feed feed = document.getRoot();
    //should only have 1 entry
    if (feed.getEntries().iterator().hasNext()) {
        Entry entry = feed.getEntries().iterator().next();
        FOMContent content = (FOMContent) entry.getContentElement();
        Iterator<OMElement> vitalsIter = content.getChildrenWithName(QNAME_VITALS);
        while (vitalsIter.hasNext()) {
            OMElement vitalsElement = vitalsIter.next();
            VitalSign vitalSign = new VitalSign();
            transformCode(vitalSign, vitalsElement);
            transformUid(vitalSign, vitalsElement, patientIds);
            transformObserved(vitalSign, vitalsElement);
            transformResult(vitalSign, vitalsElement);
            transformUnits(vitalSign, vitalsElement);
            transformTypeName(vitalSign, vitalsElement);
            mapPatientGeneratedData(vitalSign);
            list.add(vitalSign);
        }
    }


    return list;
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
private ResponseContext sendResponseWithEditLink(RequestContext request, Entry newEntry,
    int responseCode) {
  if (newEntry != null) {
    Document<Entry> newEntryDoc = newEntry.getDocument();
    String loc = newEntry.getEditLinkResolvedHref().toString();
    return sendResponse(request, newEntryDoc, responseCode).setLocation(loc);
  } else {
    return sendNotFoundResponse(request);
  }
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
protected Entry retrieveEntry(String entryId) {
  // Deserialize from a byte array
  byte[] bytes = entries.get(entryId);
  if (bytes == null) {
    // entry not found
    return null;
  }
  ByteArrayInputStream in = new ByteArrayInputStream(bytes);
  Document<Entry> entryDoc = abdera.getParser().parse(in);
  Entry entry = entryDoc.getRoot();
  return entry;
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
private Entry getEntry(final File entryFile) {
	if (!entryFile.exists() || !entryFile.isFile()) {
		throw new RuntimeException();
	}
	try {
		final FileInputStream fis = new FileInputStream(entryFile);
		final Document<Entry> doc = this.abdera.getParser().parse(fis);
		final Entry entry = doc.getRoot();
		return entry;
	} catch (final Exception e) {
		throw new RuntimeException(e);
	}
}
 

import org.apache.abdera.model.Document; //导入依赖的package包/类
/**
 * Construct a {@link CodePackageFeed} from an atom XML stream
 * 
 * @param atomStream {@link InputStream}
 */
public CodePackageFeed(InputStream atomStream) {
	LOGGER.debug("Loading Feed from " + atomStream);

	Parser parser = Abdera.getInstance().getParser();
	Document<Feed> doc = parser.parse(atomStream);
	feed = doc.getRoot();

	LOGGER.info("New Feed: " + feed.getTitle());
}