Example usage for javax.xml.datatype XMLGregorianCalendar toGregorianCalendar

List of usage examples for javax.xml.datatype XMLGregorianCalendar toGregorianCalendar

Introduction

In this page you can find the example usage for javax.xml.datatype XMLGregorianCalendar toGregorianCalendar.

Prototype

public abstract GregorianCalendar toGregorianCalendar();

Source Link

Document

Convert this XMLGregorianCalendar to a GregorianCalendar .

Usage

From source file:ddf.catalog.pubsub.PredicateTest.java

@Test
public void testTemporalNullOperation() throws Exception {
    String methodName = "testTemporalNullOperation";
    LOGGER.debug("***************  START: " + methodName + "  *****************");

    MockQuery query = new MockQuery();

    DatatypeFactory df = DatatypeFactory.newInstance();
    XMLGregorianCalendar start = df.newXMLGregorianCalendarDate(2011, 10, 25, 0);
    XMLGregorianCalendar end = df.newXMLGregorianCalendarDate(2011, 10, 27, 0);
    query.addTemporalFilter(start, end, Metacard.EFFECTIVE);

    SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
    Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
    LOGGER.debug("resulting predicate: " + pred);

    Filter filter = query.getFilter();
    FilterTransformer transform = new FilterTransformer();
    transform.setIndentation(2);//from  w ww .j ava  2  s  .  com
    String filterXml = transform.transform(filter);
    LOGGER.debug(filterXml);

    // input that passes temporal
    LOGGER.debug("\npass temporal.\n");
    MetacardImpl metacard = new MetacardImpl();
    metacard.setCreatedDate(new Date());
    metacard.setExpirationDate(new Date());
    metacard.setModifiedDate(new Date());
    metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

    XMLGregorianCalendar cal = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
    Date effectiveDate = cal.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate);

    HashMap<String, Object> properties = new HashMap<>();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, null);
    Map<String, Object> contextualMap = constructContextualMap(metacard);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);

    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    Event testEvent = new Event("topic", properties);
    boolean b = pred.matches(testEvent);
    assertTrue(b);

    LOGGER.debug("***************  END: " + methodName + "  *****************");
}

From source file:ddf.catalog.pubsub.PredicateTest.java

@Test
public void testTemporal() throws Exception {
    String methodName = "testTemporal";
    LOGGER.debug("***************  START: " + methodName + "  *****************");

    MockQuery query = new MockQuery();

    DatatypeFactory df = DatatypeFactory.newInstance();
    XMLGregorianCalendar start = df.newXMLGregorianCalendarDate(2011, 10, 25, 0);
    XMLGregorianCalendar end = df.newXMLGregorianCalendarDate(2011, 10, 27, 0);
    query.addTemporalFilter(start, end, Metacard.EFFECTIVE);

    SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
    Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
    LOGGER.debug("resulting predicate: " + pred);

    Filter filter = query.getFilter();
    FilterTransformer transform = new FilterTransformer();
    transform.setIndentation(2);/*from w  ww  . java  2 s  . c  o  m*/
    String filterXml = transform.transform(filter);
    LOGGER.debug(filterXml);

    // input that passes temporal
    LOGGER.debug("\npass temporal.\n");
    MetacardImpl metacard = new MetacardImpl();
    metacard.setCreatedDate(new Date());
    metacard.setExpirationDate(new Date());
    metacard.setModifiedDate(new Date());
    metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

    XMLGregorianCalendar cal = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
    Date effectiveDate = cal.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate);

    HashMap<String, Object> properties = new HashMap<>();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

    Map<String, Object> contextualMap = constructContextualMap(metacard);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    // Above Pulled from PubSubProviderImpl

    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    Event testEvent = new Event("topic", properties);
    boolean b = pred.matches(testEvent);
    assertTrue(b);

    // input that fails temporal
    LOGGER.debug("\nfail temporal.  fail content type.\n");
    XMLGregorianCalendar cal1 = df.newXMLGregorianCalendarDate(2012, 10, 30, 0); // time out of
    // range
    Date effectiveDate1 = cal1.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate1);
    LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

    properties.clear();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    testEvent = new Event("topic", properties);
    assertFalse(pred.matches(testEvent));

    LOGGER.debug("***************  END: " + methodName + "  *****************");
}

From source file:ddf.catalog.pubsub.PredicateTest.java

@Test
public void testMultipleCriteria() throws Exception {
    String methodName = "testMultipleCriteria";
    LOGGER.debug("***************  START: " + methodName + "  *****************");

    // test with temporal, spatial, and entry
    MockQuery query = new MockQuery();

    DatatypeFactory df = DatatypeFactory.newInstance();
    XMLGregorianCalendar start = df.newXMLGregorianCalendarDate(2011, 10, 25, 0);
    XMLGregorianCalendar end = df.newXMLGregorianCalendarDate(2011, 10, 27, 0);
    query.addTemporalFilter(start, end, Metacard.MODIFIED);

    String wkt = "POLYGON((0 10, 0 0, 10 0, 10 10, 0 10))";
    query.addSpatialFilter(wkt, 0.0, "Meter", "CONTAINS");

    // create entry criteria
    String catalogId = "ABC123";
    query.addEntryFilter(catalogId);//from  w  ww  .jav a  2 s . co  m

    MetacardImpl metacard = new MetacardImpl();
    metacard.setLocation("POINT(5 5)");
    metacard.setId(catalogId);
    metacard.setCreatedDate(new Date());
    metacard.setExpirationDate(new Date());
    metacard.setEffectiveDate(new Date());
    metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

    XMLGregorianCalendar cal = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
    Date modifiedDate = cal.toGregorianCalendar().getTime();
    metacard.setModifiedDate(modifiedDate);

    HashMap<String, Object> properties = new HashMap<>();
    properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

    Map<String, Object> contextualMap = constructContextualMap(metacard);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    // Above Pulled from PubSubProviderImpl

    Event testEvent = new Event("topic", properties);

    // input passes temporal, id, and geo
    SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
    Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
    LOGGER.debug("resulting predicate: " + pred);

    Filter filter = query.getFilter();
    FilterTransformer transform = new FilterTransformer();
    transform.setIndentation(2);
    String filterXml = transform.transform(filter);
    LOGGER.debug(filterXml);

    assertTrue(pred.matches(testEvent));

    // input passes temporal, id, but fails geo
    metacard.setLocation("POINT(5 50)"); // geo out of range
    properties.clear();
    properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

    // Below Pulled from PubSubProviderImpl
    contextualMap = constructContextualMap(metacard);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    // Above Pulled from PubSubProviderImpl

    testEvent = new Event("topic", properties);
    assertFalse(pred.matches(testEvent));

    // input passes geo, and id, but fails temporal
    metacard.setLocation("POINT(5 5)");
    XMLGregorianCalendar cal1 = df.newXMLGregorianCalendarDate(2011, 10, 28, 0);
    Date modifiedDate1 = cal1.toGregorianCalendar().getTime();
    metacard.setModifiedDate(modifiedDate1); // date out of range
    properties.clear();
    properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

    // Below Pulled from PubSubProviderImpl
    contextualMap = constructContextualMap(metacard);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    // Above Pulled from PubSubProviderImpl

    testEvent = new Event("topic", properties);
    assertFalse(pred.matches(testEvent));

    // input passes temporal, geo, but fails id
    XMLGregorianCalendar cal2 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
    Date modifiedDate2 = cal2.toGregorianCalendar().getTime();
    metacard.setModifiedDate(modifiedDate2);
    metacard.setId("invalid_id"); // bad id
    properties.clear();
    properties.put(PubSubConstants.HEADER_ID_KEY, metacard.getId());
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

    // Below Pulled from PubSubProviderImpl
    contextualMap = constructContextualMap(metacard);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    // Above Pulled from PubSubProviderImpl

    testEvent = new Event("topic", properties);
    assertFalse(pred.matches(testEvent));

    LOGGER.debug("***************  END: " + methodName + "  *****************");
}

From source file:ddf.catalog.pubsub.PredicateTest.java

@Test
public void testMultipleCriteriaWithContentTypes() throws Exception {
    String methodName = "testMultipleCriteriaWithContentTypes";
    LOGGER.debug("***************  START: " + methodName + "  *****************");

    MockQuery query = new MockQuery();

    DatatypeFactory df = DatatypeFactory.newInstance();
    XMLGregorianCalendar start = df.newXMLGregorianCalendarDate(2011, 10, 25, 0);
    XMLGregorianCalendar end = df.newXMLGregorianCalendarDate(2011, 10, 27, 0);
    query.addTemporalFilter(start, end, Metacard.EFFECTIVE);

    // create content type criteria
    String version1 = "version1";
    String type1 = "type1";

    List<MockTypeVersionsExtension> extensions = new ArrayList<>();
    MockTypeVersionsExtension ext1 = new MockTypeVersionsExtension();
    List<String> ext1Versions = ext1.getVersions();
    ext1Versions.add(version1);/*from w  w w  . j  ava  2s  . c om*/
    ext1.setExtensionTypeName(type1);
    extensions.add(ext1);

    query.addTypeFilter(extensions);

    SubscriptionFilterVisitor visitor = new SubscriptionFilterVisitor();
    Predicate pred = (Predicate) query.getFilter().accept(visitor, null);
    LOGGER.debug("resulting predicate: " + pred);

    Filter filter = query.getFilter();
    FilterTransformer transform = new FilterTransformer();
    transform.setIndentation(2);
    String filterXml = transform.transform(filter);
    LOGGER.debug(filterXml);

    // input that passes both temporal and content type
    LOGGER.debug("\npass temporal and pass content type.\n");
    MetacardImpl metacard = new MetacardImpl();
    metacard.setCreatedDate(new Date());
    metacard.setExpirationDate(new Date());
    metacard.setModifiedDate(new Date());
    metacard.setMetadata(TestDataLibrary.getCatAndDogEntry());

    XMLGregorianCalendar cal = df.newXMLGregorianCalendarDate(2011, 10, 26, 0);
    Date effectiveDate = cal.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate);

    HashMap<String, Object> properties = new HashMap<>();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);

    Map<String, Object> contextualMap = constructContextualMap(metacard);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    // Above Pulled from PubSubProviderImpl

    properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + version1);
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    Event testEvent = new Event("topic", properties);
    boolean b = pred.matches(testEvent);
    assertTrue(b);

    // input that fails both temporal and content type
    LOGGER.debug("\nfail temporal.  fail content type.\n");
    XMLGregorianCalendar cal1 = df.newXMLGregorianCalendarDate(2012, 10, 30, 0); // time out of
    // range
    Date effectiveDate1 = cal1.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate1);
    LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

    properties.clear();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "invalid_type" + "," + version1);
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    testEvent = new Event("topic", properties);
    assertFalse(pred.matches(testEvent));

    // input that passes temporal and fails content type
    LOGGER.debug("\npass temporal.  fail content type\n");
    XMLGregorianCalendar cal2 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
    // range
    Date effectiveDate2 = cal2.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate2);
    LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

    properties.clear();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, "invalid_type" + "," + version1);
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    testEvent = new Event("topic", properties);
    assertFalse(pred.matches(testEvent));

    // input that fails temporal and passes content type
    LOGGER.debug("\nfail temporal.  pass content type\n");
    XMLGregorianCalendar cal3 = df.newXMLGregorianCalendarDate(2012, 10, 26, 0); // time out of
    // range
    Date effectiveDate3 = cal3.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate3);
    LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

    properties.clear();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + version1);
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    testEvent = new Event("topic", properties);
    assertFalse(pred.matches(testEvent));

    // multiple content types
    LOGGER.debug("\nTesting multiple content types.\n");

    String type2 = "type2";
    String version2 = "version2";
    MockTypeVersionsExtension ext2 = new MockTypeVersionsExtension();
    List<String> ext2Versions = ext2.getVersions();
    ext2Versions.add(version2);
    ext2.setExtensionTypeName(type2);
    extensions.add(ext2);

    // No version
    String type3 = "type3";
    MockTypeVersionsExtension ext3 = new MockTypeVersionsExtension();
    ext3.setExtensionTypeName(type3);
    extensions.add(ext3);

    MockQuery query2 = new MockQuery();
    query2.addTemporalFilter(start, end, Metacard.EFFECTIVE);
    query2.addTypeFilter(extensions);
    SubscriptionFilterVisitor visitor1 = new SubscriptionFilterVisitor();
    Predicate pred1 = (Predicate) query2.getFilter().accept(visitor1, null);
    LOGGER.debug("resulting predicate: " + pred1);

    // Create metacard for input
    // time and contentType match
    XMLGregorianCalendar cal4 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
    // range
    Date effectiveDate4 = cal4.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate4);
    LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

    properties.clear();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type1 + "," + version1);
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    testEvent = new Event("topic", properties);
    assertTrue(pred1.matches(testEvent));

    // time and contentType match against content type 3 with any version
    XMLGregorianCalendar cal5 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
    // range
    Date effectiveDate5 = cal5.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate5);
    LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

    properties.clear();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type3 + "," + "random_version");
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    testEvent = new Event("topic", properties);
    assertTrue(pred1.matches(testEvent));

    // time matches and contentType matches type2
    XMLGregorianCalendar cal6 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
    // range
    Date effectiveDate6 = cal6.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate6);
    LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

    properties.clear();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type2 + "," + version2);
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    testEvent = new Event("topic", properties);
    assertTrue(pred1.matches(testEvent));

    // time matches and content type doesn't match
    XMLGregorianCalendar cal7 = df.newXMLGregorianCalendarDate(2011, 10, 26, 0); // time in
    // range
    Date effectiveDate7 = cal7.toGregorianCalendar().getTime();
    metacard.setEffectiveDate(effectiveDate7);
    LOGGER.debug("metacard date: " + metacard.getEffectiveDate());

    properties.clear();
    properties.put(PubSubConstants.HEADER_OPERATION_KEY, PubSubConstants.CREATE);
    properties.put(PubSubConstants.HEADER_CONTEXTUAL_KEY, contextualMap);
    properties.put(PubSubConstants.HEADER_CONTENT_TYPE_KEY, type2 + "," + version1);
    properties.put(PubSubConstants.HEADER_ENTRY_KEY, metacard);
    testEvent = new Event("topic", properties);
    assertFalse(pred1.matches(testEvent));

    LOGGER.debug("***************  END: " + methodName + "  *****************");
}

From source file:edu.harvard.i2b2.analysis.ui.AnalysisComposite.java

/**
 * Create the composite/*from www  . j  av a 2 s .c  o  m*/
 * 
 * @param parent
 * @param style
 */
public AnalysisComposite(Composite parent, int style) {
    super(parent, style);
    setLayout(new GridLayout());
    this.setSize(557, 224);

    // Create the types
    Transfer[] types = new Transfer[] { TextTransfer.getInstance() };

    final Composite composite_2 = new Composite(this, SWT.NONE);
    composite_2.setLayout(new FillLayout());
    final GridData gd_composite_2 = new GridData(SWT.FILL, SWT.FILL, true, true);
    gd_composite_2.heightHint = 263;
    gd_composite_2.widthHint = 540;
    composite_2.setLayoutData(gd_composite_2);

    final SashForm sashForm = new SashForm(composite_2, SWT.HORIZONTAL);
    sashForm.setOrientation(SWT.HORIZONTAL);
    {
        composite2 = new FramedComposite(sashForm, SWT.SHADOW_NONE);
        GridLayout composite2Layout = new GridLayout();
        composite2Layout.horizontalSpacing = 1;
        composite2.setLayout(composite2Layout);
        {
            composite3 = new FramedComposite(composite2, SWT.SHADOW_NONE);
            GridLayout composite3Layout = new GridLayout();
            composite3Layout.numColumns = 2;
            composite3Layout.marginHeight = 3;
            GridData composite3LData = new GridData();
            composite3LData.grabExcessHorizontalSpace = true;
            composite3LData.horizontalAlignment = GridData.FILL;
            composite3LData.heightHint = 25;
            composite3.setLayoutData(composite3LData);
            composite3.setLayout(composite3Layout);
            {
                label2 = new Label(composite3, SWT.NONE);
                label2.setText("Graphic Analyses");
                GridData label2LData = new GridData();
                label2LData.horizontalAlignment = GridData.FILL;
                label2LData.heightHint = 14;
                label2LData.grabExcessHorizontalSpace = true;
                label2.setLayoutData(label2LData);
                label2.setAlignment(SWT.CENTER);
            }
            {
                clearButton = new Button(composite3, SWT.PUSH | SWT.CENTER);
                GridData button1LData = new GridData();
                button1LData.horizontalAlignment = GridData.CENTER;
                button1LData.widthHint = 19;
                button1LData.verticalAlignment = GridData.BEGINNING;
                button1LData.heightHint = 18;
                clearButton.setLayoutData(button1LData);
                clearButton.setText("x");
                clearButton.setToolTipText("Remove all nodes in analysis tree panel below");
                clearButton.setFont(SWTResourceManager.getFont("Tahoma", 10, 1, false, false));
                clearButton.addSelectionListener(new SelectionAdapter() {
                    public void widgetSelected(SelectionEvent evt) {
                        clearButtonWidgetSelected(evt);
                    }
                });
            }
        }
        {
            tree1 = new Tree(composite2, SWT.BORDER);
            tree1.addSelectionListener(new SelectionAdapter() {
                public void widgetSelected(final SelectionEvent e) {
                    final TreeItem item = tree1.getSelection()[0];
                    if (item.getText().equalsIgnoreCase("No results to display")) {
                        return;
                    }
                    getDisplay().syncExec(new Runnable() {
                        public void run() {
                            queryName = item.getParentItem().getText();
                            label1.setText(item.getParentItem().getText());
                        }
                    });
                    setSelection((QueryResultData) item.getData());
                }
            });
            GridData tree1LData = new GridData();
            tree1LData.verticalAlignment = GridData.FILL;
            tree1LData.horizontalAlignment = GridData.FILL;
            tree1LData.grabExcessHorizontalSpace = true;
            tree1LData.grabExcessVerticalSpace = true;
            tree1.setLayoutData(tree1LData);
            {
                /*
                 * analyses = new TreeItem(tree1, SWT.NONE);
                 * analyses.setText("Analyses"); analyses
                 * .setImage(SWTResourceManager
                 * .getImage("edu/harvard/i2b2/analysis/ui/openFolder.jpg"
                 * )); analyses.setExpanded(true);
                 */
            }
        }
    }
    {
        final FramedComposite right_composite = new FramedComposite(sashForm, SWT.SHADOW_NONE);
        GridLayout right_compositeLayout = new GridLayout();
        right_composite.setLayout(right_compositeLayout);
        {
            final FramedComposite top_composite = new FramedComposite(right_composite, SWT.SHADOW_NONE);
            GridLayout top_compositeLayout = new GridLayout();
            top_compositeLayout.makeColumnsEqualWidth = true;
            top_composite.setLayout(top_compositeLayout);
            GridData top_compositeLData = new GridData();
            top_compositeLData.horizontalAlignment = GridData.FILL;
            top_compositeLData.grabExcessHorizontalSpace = true;
            top_composite.setLayoutData(top_compositeLData);
            {
                label1 = new Label(top_composite, SWT.NO_TRIM);
                GridData gd_top_composite = new GridData();
                gd_top_composite.grabExcessHorizontalSpace = true;
                gd_top_composite.horizontalAlignment = GridData.FILL;
                label1.setLayoutData(gd_top_composite);
                queryName = "Query Name: ";
                label1.setText("Query Name: ");
                label1.addListener(SWT.Resize, new Listener() {
                    public void handleEvent(Event event) {
                        int width = label1.getBounds().width;
                        GC gc = new GC(Display.getCurrent().getActiveShell());

                        if (gc != null) {

                            gc.setFont(label1.getFont());
                            Point pt = gc.stringExtent(queryName);

                            if (pt.x <= width) {
                                label1.setText(queryName);
                                gc.dispose();
                                return;
                            }

                            int charWidth = pt.x / queryName.length();
                            int charNum = width / charWidth;
                            label1.setText(queryName.substring(0, charNum - 6) + "...");
                            // System.out.println("size: "+label1.getSize()
                            // + "; width"+width+
                            // " font width: "+pt.x+"char width: "+pt.x/
                            // queryName.length());

                            gc.dispose();
                        }
                    }
                });
                label1.addMouseTrackListener(new MouseTrackListener() {

                    public void mouseEnter(MouseEvent arg0) {
                        top_composite.setForeground(getDisplay().getSystemColor(SWT.COLOR_YELLOW));
                    }

                    public void mouseExit(MouseEvent arg0) {
                        top_composite.setForeground(getDisplay().getSystemColor(SWT.COLOR_BLACK));
                    }

                    public void mouseHover(MouseEvent arg0) {
                        top_composite.setForeground(getDisplay().getSystemColor(SWT.COLOR_YELLOW));
                    }

                });
            }
            {
                DropTarget target1 = new DropTarget(top_composite, DND.DROP_COPY);
                // RowData target1LData = new RowData();
                // target1.setLayoutData(target1LData);
                target1.setTransfer(types);
                target1.addDropListener(new DropTargetAdapter() {
                    @SuppressWarnings("unchecked")
                    public void drop(DropTargetEvent event) {
                        if (event.data == null) {
                            event.detail = DND.DROP_NONE;
                            return;
                        }

                        try {
                            SAXBuilder parser = new SAXBuilder();
                            String xmlContent = (String) event.data;
                            java.io.StringReader xmlStringReader = new java.io.StringReader(xmlContent);
                            org.jdom.Document tableDoc = parser.build(xmlStringReader);
                            org.jdom.Element tableXml = tableDoc.getRootElement().getChild("query_master",
                                    Namespace.getNamespace("http://www.i2b2.org/xsd/cell/crc/psm/1.1/"));

                            if (tableXml == null) {
                                tableXml = tableDoc.getRootElement().getChild("query_instance",
                                        Namespace.getNamespace("http://www.i2b2.org/xsd/cell/crc/psm/1.1/"));
                                if (tableXml == null) {

                                    MessageBox mBox = new MessageBox(top_composite.getShell(),
                                            SWT.ICON_INFORMATION | SWT.OK);
                                    mBox.setText("Please Note ...");
                                    mBox.setMessage("You can not drop this item here.");
                                    mBox.open();
                                    event.detail = DND.DROP_NONE;
                                    return;
                                } else {
                                    try {
                                        QueryInstanceData ndata = new QueryInstanceData();
                                        // ndata.name(tableXml.getChildText(
                                        // "name"));
                                        // label1.setText("Query Name: " +
                                        // ndata.name());
                                        ndata.xmlContent(null);
                                        ndata.id(tableXml.getChildTextTrim("query_instance_id"));
                                        ndata.userId(tableXml.getChildTextTrim("user_id"));
                                        ndata.name(tableXml.getChildTextTrim("name"));

                                        insertNodes(ndata);
                                        setSelection(tree1.getItemCount() - 1);

                                    } catch (Exception e) {
                                        e.printStackTrace();
                                        return;
                                    }

                                    event.detail = DND.DROP_NONE;
                                    return;
                                }
                            }
                            try {
                                JAXBUtil jaxbUtil = AnalysisJAXBUtil.getJAXBUtil();
                                QueryMasterData ndata = new QueryMasterData();
                                ndata.name(tableXml.getChildText("name"));
                                // label1.setText("Query Name: " +
                                // ndata.name());
                                ndata.xmlContent(null);
                                ndata.id(tableXml.getChildTextTrim("query_master_id"));
                                ndata.userId(tableXml.getChildTextTrim("user_id"));

                                // get query instance
                                String xmlRequest = ndata.writeContentQueryXML();
                                // lastRequestMessage(xmlRequest);
                                String xmlResponse = QueryClient.sendQueryRequestREST(xmlRequest);
                                // lastResponseMessage(xmlResponse);

                                JAXBElement jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
                                ResponseMessageType messageType = (ResponseMessageType) jaxbElement.getValue();
                                BodyType bt = messageType.getMessageBody();
                                InstanceResponseType instanceResponseType = (InstanceResponseType) new JAXBUnWrapHelper()
                                        .getObjectByClass(bt.getAny(), InstanceResponseType.class);

                                QueryInstanceData instanceData = null;
                                XMLGregorianCalendar startDate = null;
                                for (QueryInstanceType queryInstanceType : instanceResponseType
                                        .getQueryInstance()) {
                                    QueryInstanceData runData = new QueryInstanceData();

                                    runData.visualAttribute("FA");
                                    runData.tooltip("The results of the query run");
                                    runData.id(new Integer(queryInstanceType.getQueryInstanceId()).toString());
                                    XMLGregorianCalendar cldr = queryInstanceType.getStartDate();
                                    runData.name(ndata.name());

                                    if (instanceData == null) {
                                        startDate = cldr;
                                        instanceData = runData;
                                    } else {
                                        if (cldr.toGregorianCalendar()
                                                .compareTo(startDate.toGregorianCalendar()) > 0) {
                                            startDate = cldr;
                                            instanceData = runData;
                                        }
                                    }
                                }

                                insertNodes(instanceData);
                                if (treeItem.getItemCount() == 0) {
                                    getDisplay().syncExec(new Runnable() {
                                        public void run() {
                                            TreeItem treeItem1 = new TreeItem(treeItem, SWT.NONE);
                                            treeItem1.setText("No results to display");
                                            treeItem1.setForeground(getDisplay().getSystemColor(SWT.COLOR_RED));
                                            treeItem1.setExpanded(true);
                                            treeItem1.setImage(SWTResourceManager
                                                    .getImage("edu/harvard/i2b2/analysis/ui/leaf.jpg"));

                                            JFreeChart chart = createNoDataChart(createEmptyDataset());
                                            composite1.getChildren()[0].dispose();
                                            ChartComposite frame = new ChartComposite(composite1, SWT.NONE,
                                                    chart, true, true, false, true, true);
                                            frame.pack();
                                            composite1.layout();

                                            tree1.select(treeItem1);
                                            return;
                                        }
                                    });

                                } else {
                                    setSelection(tree1.getItemCount() - 1);
                                }

                            } catch (Exception e) {
                                e.printStackTrace();
                                return;
                            }

                            event.detail = DND.DROP_NONE;
                        } catch (Exception e) {
                            e.printStackTrace();
                            event.detail = DND.DROP_NONE;
                            return;
                        }
                    }

                    @Override
                    public void dragLeave(DropTargetEvent event) {
                        super.dragLeave(event);
                        top_composite.setForeground(getDisplay().getSystemColor(SWT.COLOR_BLACK));
                    }

                    public void dragEnter(DropTargetEvent event) {
                        event.detail = DND.DROP_COPY;
                        top_composite.setForeground(getDisplay().getSystemColor(SWT.COLOR_YELLOW));
                    }
                });
            }
            top_composite.addMouseTrackListener(new MouseTrackListener() {

                public void mouseEnter(MouseEvent arg0) {
                    top_composite.setForeground(getDisplay().getSystemColor(SWT.COLOR_YELLOW));
                }

                public void mouseExit(MouseEvent arg0) {
                    top_composite.setForeground(getDisplay().getSystemColor(SWT.COLOR_BLACK));
                }

                public void mouseHover(MouseEvent arg0) {
                    top_composite.setForeground(getDisplay().getSystemColor(SWT.COLOR_YELLOW));
                }

            });
        }
        {
            composite1 = new Composite(right_composite, SWT.BORDER);
            FillLayout composite1Layout = new FillLayout(org.eclipse.swt.SWT.HORIZONTAL);
            GridData composite1LData = new GridData();
            composite1LData.grabExcessHorizontalSpace = true;
            composite1LData.grabExcessVerticalSpace = true;
            composite1LData.horizontalAlignment = GridData.FILL;
            composite1LData.verticalAlignment = GridData.FILL;
            composite1.setLayoutData(composite1LData);
            composite1.setLayout(composite1Layout);
            // composite1.setBackground(SWTResourceManager.getColor(255,
            // 255,
            // 0));

            getDisplay().syncExec(new Runnable() {
                public void run() {
                    JFreeChart chart = createEmptyChart(createEmptyDataset());
                    /* final ChartComposite frame = */new ChartComposite(composite1, SWT.NONE, chart, true,
                            true, false, true, true);
                }
            });
        }

    }

    {
        // label2 = new Label(top_composite, SWT.NONE);
        // label2.setText("2512+3 patients");
        // label2.setBounds(254, 7, 108, 19);
    }
    {
        DropTarget target2 = new DropTarget(tree1, DND.DROP_COPY);
        target2.setTransfer(types);
        target2.addDropListener(new DropTargetAdapter() {
            public void dragEnter(DropTargetEvent event) {
                event.detail = DND.DROP_COPY;
            }

            @SuppressWarnings("unchecked")
            public void drop(DropTargetEvent event) {
                if (event.data == null) {
                    event.detail = DND.DROP_NONE;
                    return;
                }

                try {
                    SAXBuilder parser = new SAXBuilder();
                    String xmlContent = (String) event.data;
                    java.io.StringReader xmlStringReader = new java.io.StringReader(xmlContent);
                    org.jdom.Document tableDoc = parser.build(xmlStringReader);
                    org.jdom.Element tableXml = tableDoc.getRootElement().getChild("query_master",
                            Namespace.getNamespace("http://www.i2b2.org/xsd/cell/crc/psm/1.1/"));

                    if (tableXml == null) {
                        tableXml = tableDoc.getRootElement().getChild("query_instance",
                                Namespace.getNamespace("http://www.i2b2.org/xsd/cell/crc/psm/1.1/"));
                        if (tableXml == null) {

                            MessageBox mBox = new MessageBox(tree1.getShell(), SWT.ICON_INFORMATION | SWT.OK);
                            mBox.setText("Please Note ...");
                            mBox.setMessage("You can not drop this item here.");
                            mBox.open();
                            event.detail = DND.DROP_NONE;
                            return;
                        } else {
                            try {
                                // JAXBUtil jaxbUtil =
                                // AnalysisJAXBUtil.getJAXBUtil();
                                QueryInstanceData ndata = new QueryInstanceData();
                                // ndata.name(tableXml.getChildText("name"));
                                // label1.setText("Query Name: " +
                                // ndata.name());
                                ndata.xmlContent(null);
                                ndata.id(tableXml.getChildTextTrim("query_instance_id"));
                                ndata.userId(tableXml.getChildTextTrim("user_id"));
                                ndata.name(tableXml.getChildTextTrim("name"));

                                // clearTree();
                                insertNodes(ndata);
                                setSelection(tree1.getItemCount() - 1);

                            } catch (Exception e) {
                                e.printStackTrace();
                                return;
                            }

                            event.detail = DND.DROP_NONE;
                            return;
                        }
                    }
                    try {
                        JAXBUtil jaxbUtil = AnalysisJAXBUtil.getJAXBUtil();
                        QueryMasterData ndata = new QueryMasterData();
                        ndata.name(tableXml.getChildText("name"));
                        // label1.setText("Query Name: " + ndata.name());
                        ndata.xmlContent(null);
                        ndata.id(tableXml.getChildTextTrim("query_master_id"));
                        ndata.userId(tableXml.getChildTextTrim("user_id"));

                        // get query instance
                        String xmlRequest = ndata.writeContentQueryXML();
                        // lastRequestMessage(xmlRequest);
                        String xmlResponse = QueryClient.sendQueryRequestREST(xmlRequest);
                        // lastResponseMessage(xmlResponse);

                        JAXBElement jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
                        ResponseMessageType messageType = (ResponseMessageType) jaxbElement.getValue();
                        BodyType bt = messageType.getMessageBody();
                        InstanceResponseType instanceResponseType = (InstanceResponseType) new JAXBUnWrapHelper()
                                .getObjectByClass(bt.getAny(), InstanceResponseType.class);

                        QueryInstanceData instanceData = null;
                        XMLGregorianCalendar startDate = null;
                        for (QueryInstanceType queryInstanceType : instanceResponseType.getQueryInstance()) {
                            QueryInstanceData runData = new QueryInstanceData();

                            runData.visualAttribute("FA");
                            runData.tooltip("The results of the query run");
                            runData.id(new Integer(queryInstanceType.getQueryInstanceId()).toString());
                            XMLGregorianCalendar cldr = queryInstanceType.getStartDate();
                            runData.name(ndata.name());

                            if (instanceData == null) {
                                startDate = cldr;
                                instanceData = runData;
                            } else {
                                if (cldr.toGregorianCalendar().compareTo(startDate.toGregorianCalendar()) > 0) {
                                    startDate = cldr;
                                    instanceData = runData;
                                }
                            }
                        }
                        // clearTree();
                        insertNodes(instanceData);
                        setSelection(tree1.getItemCount() - 1);

                    } catch (Exception e) {
                        e.printStackTrace();
                        return;
                    }

                    event.detail = DND.DROP_NONE;
                } catch (Exception e) {
                    e.printStackTrace();
                    event.detail = DND.DROP_NONE;
                    return;
                }
            }
        });
    }

    sashForm.setWeights(new int[] { 30, 70 });
    sashForm.setSashWidth(1);
}

From source file:edu.harvard.i2b2.previousquery.ui.PreviousQueryPanel.java

private void populateChildNodes(DefaultMutableTreeNode node) {
    if (node.getUserObject().getClass().getSimpleName().equalsIgnoreCase("QueryMasterData")) {
        QueryMasterData data = (QueryMasterData) node.getUserObject();
        try {// w  w  w  .j av a  2 s  .  c  om
            String xmlRequest = data.writeContentQueryXML();

            String xmlResponse = null;
            if (System.getProperty("webServiceMethod").equals("SOAP")) {
                xmlResponse = QueryListNamesClient.sendQueryRequestSOAP(xmlRequest);
            } else {
                xmlResponse = QueryListNamesClient.sendQueryRequestREST(xmlRequest);
            }
            if (xmlResponse.equalsIgnoreCase("CellDown")) {
                final JPanel parent = this;
                java.awt.EventQueue.invokeLater(new Runnable() {
                    public void run() {
                        JOptionPane.showMessageDialog(parent,
                                "Trouble with connection to the remote server, "
                                        + "this is often a network error, please try again",
                                "Network Error", JOptionPane.INFORMATION_MESSAGE);
                    }
                });
                return;
            }

            try {
                JAXBUtil jaxbUtil = PreviousQueryJAXBUtil.getJAXBUtil();
                JAXBElement jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
                ResponseMessageType messageType = (ResponseMessageType) jaxbElement.getValue();

                BodyType bt = messageType.getMessageBody();
                InstanceResponseType instanceResponseType = (InstanceResponseType) new JAXBUnWrapHelper()
                        .getObjectByClass(bt.getAny(), InstanceResponseType.class);

                for (QueryInstanceType queryInstanceType : instanceResponseType.getQueryInstance()) {
                    // change later for working with new xml schema
                    // RunQuery runQuery =

                    QueryInstanceData runData = new QueryInstanceData();

                    runData.visualAttribute("FA");
                    if (queryInstanceType.getQueryStatusType().getName().equalsIgnoreCase("completed")) {
                        XMLGregorianCalendar sCldr = queryInstanceType.getStartDate();
                        XMLGregorianCalendar eCldr = queryInstanceType.getEndDate();
                        long diff = eCldr.toGregorianCalendar().getTimeInMillis()
                                - sCldr.toGregorianCalendar().getTimeInMillis();
                        runData.tooltip("All results are available, run " + (diff / 1000) + " seconds");
                    }
                    runData.id(queryInstanceType.getQueryInstanceId());
                    // runData.patientRefId(new
                    // Integer(queryInstanceType.getRefId()).toString());
                    // runData.patientCount(new
                    // Long(queryInstanceType.getCount()).toString());
                    // XMLGregorianCalendar cldr =
                    // queryInstanceType.getStartDate();
                    /*
                     * runData.name("Results of "+
                     * "["+addZero(cldr.getMonth(
                     * ))+"-"+addZero(cldr.getDay())+"-"
                     * +addZero(cldr.getYear())+"
                     * "+addZero(cldr.getHour())+":"
                     * +addZero(cldr.getMinute())
                     * +":"+addZero(cldr.getSecond())+"]");
                     */
                    runData.name("Results of " + data.name().substring(0, data.name().indexOf("[")));
                    runData.queryName(data.name());
                    data.runs.add(runData);
                    if (!queryInstanceType.getQueryStatusType().getName().equalsIgnoreCase("completed")) {
                        runData.name(
                                runData.name() + " --- " + queryInstanceType.getQueryStatusType().getName());
                        runData.tooltip("The results of the query run");
                    }
                    addNode(runData, node);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            // jTree1.scrollPathToVisible(new TreePath(node.getPath()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    } else if (node.getUserObject().getClass().getSimpleName().equalsIgnoreCase("QueryInstanceData")) {
        QueryInstanceData data = (QueryInstanceData) node.getUserObject();

        try {
            String xmlRequest = data.writeContentQueryXML();

            String xmlResponse = null;
            if (System.getProperty("webServiceMethod").equals("SOAP")) {
                xmlResponse = QueryListNamesClient.sendQueryRequestSOAP(xmlRequest);
            } else {
                xmlResponse = QueryListNamesClient.sendQueryRequestREST(xmlRequest);
            }
            if (xmlResponse.equalsIgnoreCase("CellDown")) {
                final JPanel parent = this;
                java.awt.EventQueue.invokeLater(new Runnable() {
                    public void run() {
                        JOptionPane.showMessageDialog(parent,
                                "Trouble with connection to the remote server, "
                                        + "this is often a network error, please try again",
                                "Network Error", JOptionPane.INFORMATION_MESSAGE);
                    }
                });
                return;
            }

            JAXBUtil jaxbUtil = PreviousQueryJAXBUtil.getJAXBUtil();

            JAXBElement jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
            ResponseMessageType messageType = (ResponseMessageType) jaxbElement.getValue();
            BodyType bt = messageType.getMessageBody();
            ResultResponseType resultResponseType = (ResultResponseType) new JAXBUnWrapHelper()
                    .getObjectByClass(bt.getAny(), ResultResponseType.class);

            for (QueryResultInstanceType queryResultInstanceType : resultResponseType
                    .getQueryResultInstance()) {
                String status = queryResultInstanceType.getQueryStatusType().getName();

                QueryResultData resultData = new QueryResultData();
                if (queryResultInstanceType.getQueryResultType().getName().equalsIgnoreCase("PATIENTSET")
                        && UserInfoBean.getInstance().isRoleInProject("DATA_LDS")) {
                    resultData.visualAttribute("FA");
                } else {
                    resultData.visualAttribute("LAO");
                }
                // resultData.queryId(data.queryId());
                resultData.patientRefId(queryResultInstanceType.getResultInstanceId());// data.patientRefId());
                resultData.patientCount(new Integer(queryResultInstanceType.getSetSize()).toString());// data.patientCount());
                String resultname = "";
                if ((resultname = queryResultInstanceType.getQueryResultType().getDescription()) == null) {
                    resultname = queryResultInstanceType.getQueryResultType().getName();
                }
                // if (status.equalsIgnoreCase("FINISHED")) {
                if (queryResultInstanceType.getQueryResultType().getName().equals("PATIENTSET")
                /*|| queryResultInstanceType.getQueryResultType().getName()
                .equals("PATIENT_COUNT_XML")*/) {
                    // if (UserInfoBean.getInstance().isRoleInProject(
                    // "DATA_OBFSC")) {
                    // resultData.name(resultname + " - "
                    // + resultData.patientCount() + " Patients");
                    // resultData.tooltip(resultData.patientCount()
                    // + " Patients");
                    // } else {
                    if (queryResultInstanceType.getDescription() != null) {
                        resultname = queryResultInstanceType.getDescription();
                        resultData.name(queryResultInstanceType.getDescription());
                    } else {
                        resultData.name(resultname + " - " + resultData.patientCount() + " Patients");
                    }
                    resultData.tooltip(resultData.patientCount() + " Patients");
                    // }
                } else {
                    if (queryResultInstanceType.getDescription() != null) {
                        resultname = queryResultInstanceType.getDescription();
                        resultData.name(queryResultInstanceType.getDescription());
                    } else {
                        resultData.name(resultname);// + " - " + status);
                        resultData.tooltip(status);
                    }

                }

                resultData.xmlContent(xmlResponse);
                resultData.queryName(data.queryName());
                resultData.type(queryResultInstanceType.getQueryResultType().getName());
                if (!status.equalsIgnoreCase("FINISHED")) {
                    resultData.name(resultData.name() + " --- " + status);
                }
                addNode(resultData, node);
            }
            // }
            // jTree1.scrollPathToVisible(new TreePath(node.getPath()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    } else if (node.getUserObject().getClass().getSimpleName().equalsIgnoreCase("QueryResultData")) {
        QueryResultData data = (QueryResultData) node.getUserObject();
        if (data.patientCount().equalsIgnoreCase("0")) {
            return;
        }
        int maxNumPatientsToDisplay = Integer.valueOf(System.getProperty("PQMaxPatientsNumber"));
        if (Integer.valueOf(data.patientCount()) > maxNumPatientsToDisplay) {
            final JPanel parent = this;
            result = JOptionPane.showConfirmDialog(parent,
                    "The patient count is greater than maximum configured to be displayed.\n"
                            + "Populating the patient list may affect performance. \n"
                            + "Do you want to continue?",
                    "Please Note ...", JOptionPane.YES_NO_OPTION);
            if (result == JOptionPane.NO_OPTION) {
                DefaultMutableTreeNode tmpnode = (DefaultMutableTreeNode) node.getChildAt(0);
                QueryData tmpdata = (QueryData) tmpnode.getUserObject();
                if (tmpdata.name().equalsIgnoreCase("working ......")) {
                    tmpdata.name("Over maximum number of patient nodes");
                    treeModel.reload(tmpnode);
                }
                return;
            }
        }
        try {
            String xmlRequest = data.writeContentQueryXML();

            String xmlResponse = null;
            if (System.getProperty("webServiceMethod").equals("SOAP")) {
                xmlResponse = QueryListNamesClient.sendPDORequestSOAP(xmlRequest, showName());
            } else {
                xmlResponse = QueryListNamesClient.sendPdoRequestREST(xmlRequest);
            }
            if (xmlResponse.equalsIgnoreCase("CellDown")) {
                final JPanel parent = this;
                java.awt.EventQueue.invokeLater(new Runnable() {
                    public void run() {
                        JOptionPane.showMessageDialog(parent,
                                "Trouble with connection to the remote server, "
                                        + "this is often a network error, please try again",
                                "Network Error", JOptionPane.INFORMATION_MESSAGE);
                    }
                });
                return;
            }

            // check response status here ......

            // System.out.println("Response: "+xmlResponse);
            PatientSet patientSet = new PDOResponseMessageFactory().getPatientSetFromResponseXML(xmlResponse);
            List<PatientType> patients = patientSet.getPatient();
            System.out.println("Patient set size: " + patients.size());

            for (int i = 0; i < patients.size(); i++) {
                PatientType patient = patients.get(i);

                PatientData pData = new PatientData();
                pData.patientID(patient.getPatientId().getValue());
                pData.setParamData(patient.getParam());
                pData.visualAttribute("LAO");
                pData.tooltip("Patient");
                pData.patientSetID(data.patientRefId());
                if (showName() && pData.lastName() != null && pData.firstName() != null) {
                    pData.name(pData.patientID() + " [" + pData.lastName().substring(0, 1).toUpperCase()
                            + pData.lastName().substring(1, pData.lastName().length()).toLowerCase() + ", "
                            + pData.firstName().substring(0, 1).toUpperCase()
                            + pData.firstName().substring(1, pData.firstName().length()).toLowerCase() + "]");// ["+pData.age()+"
                    // y/o
                    // "+pData.gender()+"
                    // "+pData.race()+"]");
                } else {
                    pData.name(pData.patientID() + " [" + pData.age() + " y/o " + pData.gender() + " "
                            + pData.race() + "]");
                }
                pData.queryName(data.queryName());
                addNode(pData, node);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // implement for other type of nodes later!!!
}

From source file:edu.harvard.i2b2.patientSet.ui.PatientSetJPanel.java

public String loadPatientSets() {
    System.out.println("Loading patient sets for: " + System.getProperty("user"));
    this.patientSets = new ArrayList<QueryResultData>();

    for (int i = 0; i < this.previousQueries.size(); i++) {
        QueryMasterData qdata = previousQueries.get(i);
        try {/*from w w  w .ja v  a  2 s . co m*/
            String xmlRequest = qdata.writeContentQueryXML();

            String xmlResponse = null;
            if (System.getProperty("webServiceMethod").equals("SOAP")) {
                xmlResponse = QueryListNamesClient.sendQueryRequestSOAP(xmlRequest);
            } else {
                xmlResponse = QueryListNamesClient.sendQueryRequestREST(xmlRequest, false);
            }
            if (xmlResponse.equalsIgnoreCase("CellDown")) {
                final JPanel parent = this;
                java.awt.EventQueue.invokeLater(new Runnable() {
                    public void run() {
                        JOptionPane.showMessageDialog(parent,
                                "Trouble with connection to the remote server, "
                                        + "this is often a network error, please try again",
                                "Network Error", JOptionPane.INFORMATION_MESSAGE);
                    }
                });
                return null;
            }

            try {
                JAXBUtil jaxbUtil = PatientSetJAXBUtil.getJAXBUtil();
                JAXBElement jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
                ResponseMessageType messageType = (ResponseMessageType) jaxbElement.getValue();

                BodyType bt = messageType.getMessageBody();
                InstanceResponseType instanceResponseType = (InstanceResponseType) new JAXBUnWrapHelper()
                        .getObjectByClass(bt.getAny(), InstanceResponseType.class);

                for (QueryInstanceType queryInstanceType : instanceResponseType.getQueryInstance()) {
                    // change later for working with new xml schema
                    // RunQuery runQuery =

                    QueryInstanceData runData = new QueryInstanceData();

                    runData.visualAttribute("FA");
                    if (queryInstanceType.getQueryStatusType().getName().equalsIgnoreCase("completed")) {
                        XMLGregorianCalendar sCldr = queryInstanceType.getStartDate();
                        XMLGregorianCalendar eCldr = queryInstanceType.getEndDate();
                        long diff = eCldr.toGregorianCalendar().getTimeInMillis()
                                - sCldr.toGregorianCalendar().getTimeInMillis();
                        runData.tooltip("All results are available, run " + (diff / 1000) + " seconds");
                    }
                    runData.id(queryInstanceType.getQueryInstanceId());
                    // runData.patientRefId(new
                    // Integer(queryInstanceType.getRefId()).toString());
                    // runData.patientCount(new
                    // Long(queryInstanceType.getCount()).toString());
                    // XMLGregorianCalendar cldr =
                    // queryInstanceType.getStartDate();
                    /*
                     * runData.name("Results of "+
                     * "["+addZero(cldr.getMonth(
                     * ))+"-"+addZero(cldr.getDay())+"-"
                     * +addZero(cldr.getYear())+"
                     * "+addZero(cldr.getHour())+":"
                     * +addZero(cldr.getMinute())
                     * +":"+addZero(cldr.getSecond())+"]");
                     */
                    runData.name("Results of " + qdata.name().substring(0, qdata.name().indexOf("[")));
                    runData.queryName(qdata.name());
                    qdata.runs.add(runData);
                    if (!queryInstanceType.getQueryStatusType().getName().equalsIgnoreCase("completed")) {
                        runData.name(
                                runData.name() + " --- " + queryInstanceType.getQueryStatusType().getName());
                        runData.tooltip("The results of the query run");
                    }
                    //addNode(runData, node);
                    /////////////get patient sets//////////////////////
                    try {
                        xmlRequest = runData.writeContentQueryXML();

                        xmlResponse = null;
                        if (System.getProperty("webServiceMethod").equals("SOAP")) {
                            xmlResponse = QueryListNamesClient.sendQueryRequestSOAP(xmlRequest);
                        } else {
                            xmlResponse = QueryListNamesClient.sendQueryRequestREST(xmlRequest, false);
                        }
                        if (xmlResponse.equalsIgnoreCase("CellDown")) {
                            final JPanel parent = this;
                            java.awt.EventQueue.invokeLater(new Runnable() {
                                public void run() {
                                    JOptionPane.showMessageDialog(parent,
                                            "Trouble with connection to the remote server, "
                                                    + "this is often a network error, please try again",
                                            "Network Error", JOptionPane.INFORMATION_MESSAGE);
                                }
                            });
                            return null;
                        }

                        //JAXBUtil jaxbUtil = PatientSetJAXBUtil.getJAXBUtil();

                        jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
                        messageType = (ResponseMessageType) jaxbElement.getValue();
                        bt = messageType.getMessageBody();
                        ResultResponseType resultResponseType = (ResultResponseType) new JAXBUnWrapHelper()
                                .getObjectByClass(bt.getAny(), ResultResponseType.class);

                        for (QueryResultInstanceType queryResultInstanceType : resultResponseType
                                .getQueryResultInstance()) {
                            String status = queryResultInstanceType.getQueryStatusType().getName();

                            QueryResultData resultData = new QueryResultData();
                            if (queryResultInstanceType.getQueryResultType().getName().equalsIgnoreCase(
                                    "PATIENTSET") && UserInfoBean.getInstance().isRoleInProject("DATA_LDS")) {
                                resultData.visualAttribute("FA");
                            } else {
                                resultData.visualAttribute("LAO");
                            }
                            // resultData.queryId(data.queryId());
                            resultData.patientRefId(queryResultInstanceType.getResultInstanceId());// data.patientRefId());
                            resultData
                                    .patientCount(new Integer(queryResultInstanceType.getSetSize()).toString());// data.patientCount());
                            String resultname = "";
                            if ((resultname = queryResultInstanceType.getQueryResultType()
                                    .getDescription()) == null) {
                                resultname = queryResultInstanceType.getQueryResultType().getName();
                            }
                            // if (status.equalsIgnoreCase("FINISHED")) {
                            if (queryResultInstanceType.getQueryResultType().getName().equals("PATIENTSET")
                            /*|| queryResultInstanceType.getQueryResultType().getName()
                            .equals("PATIENT_COUNT_XML")*/) {
                                // if (UserInfoBean.getInstance().isRoleInProject(
                                // "DATA_OBFSC")) {
                                // resultData.name(resultname + " - "
                                // + resultData.patientCount() + " Patients");
                                // resultData.tooltip(resultData.patientCount()
                                // + " Patients");
                                // } else {
                                if (queryResultInstanceType.getDescription() != null) {
                                    resultname = queryResultInstanceType.getDescription();
                                    resultData.name(queryResultInstanceType.getDescription());
                                } else {
                                    resultData
                                            .name(resultname + " - " + resultData.patientCount() + " Patients");
                                }
                                resultData.tooltip(resultData.patientCount() + " Patients");
                                // }

                                resultData.xmlContent(xmlResponse);
                                resultData.queryName(runData.queryName());
                                resultData.type(queryResultInstanceType.getQueryResultType().getName());
                                if (!status.equalsIgnoreCase("FINISHED")) {
                                    resultData.name(resultData.name() + " --- " + status);
                                }
                                //addNode(resultData, node);
                                this.patientSets.add(resultData);
                            }
                        }
                        // }
                        // jTree1.scrollPathToVisible(new TreePath(node.getPath()));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    /////////////get patient sets//////////////////////
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            // jTree1.scrollPathToVisible(new TreePath(node.getPath()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return "Done";
}

From source file:edu.harvard.i2b2.patientSet.ui.PatientSetJPanel.java

@SuppressWarnings("rawtypes")
private void populateChildNodes(DefaultMutableTreeNode node) {
    if (node.getUserObject().getClass().getSimpleName().equalsIgnoreCase("QueryMasterData")) {
        QueryMasterData data = (QueryMasterData) node.getUserObject();
        try {//from  w  w w.ja  va  2s . c o m
            String xmlRequest = data.writeContentQueryXML();

            String xmlResponse = null;
            if (System.getProperty("webServiceMethod").equals("SOAP")) {
                xmlResponse = QueryListNamesClient.sendQueryRequestSOAP(xmlRequest);
            } else {
                xmlResponse = QueryListNamesClient.sendQueryRequestREST(xmlRequest, true);
            }
            if (xmlResponse.equalsIgnoreCase("CellDown")) {
                final JPanel parent = this;
                java.awt.EventQueue.invokeLater(new Runnable() {
                    public void run() {
                        JOptionPane.showMessageDialog(parent,
                                "Trouble with connection to the remote server, "
                                        + "this is often a network error, please try again",
                                "Network Error", JOptionPane.INFORMATION_MESSAGE);
                    }
                });
                return;
            }

            try {
                JAXBUtil jaxbUtil = PatientSetJAXBUtil.getJAXBUtil();
                JAXBElement jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
                ResponseMessageType messageType = (ResponseMessageType) jaxbElement.getValue();

                BodyType bt = messageType.getMessageBody();
                InstanceResponseType instanceResponseType = (InstanceResponseType) new JAXBUnWrapHelper()
                        .getObjectByClass(bt.getAny(), InstanceResponseType.class);

                for (QueryInstanceType queryInstanceType : instanceResponseType.getQueryInstance()) {
                    // change later for working with new xml schema
                    // RunQuery runQuery =

                    QueryInstanceData runData = new QueryInstanceData();

                    runData.visualAttribute("FA");
                    if (queryInstanceType.getQueryStatusType().getName().equalsIgnoreCase("completed")) {
                        XMLGregorianCalendar sCldr = queryInstanceType.getStartDate();
                        XMLGregorianCalendar eCldr = queryInstanceType.getEndDate();
                        long diff = eCldr.toGregorianCalendar().getTimeInMillis()
                                - sCldr.toGregorianCalendar().getTimeInMillis();
                        runData.tooltip("All results are available, run " + (diff / 1000) + " seconds");
                    }
                    runData.id(queryInstanceType.getQueryInstanceId());
                    // runData.patientRefId(new
                    // Integer(queryInstanceType.getRefId()).toString());
                    // runData.patientCount(new
                    // Long(queryInstanceType.getCount()).toString());
                    // XMLGregorianCalendar cldr =
                    // queryInstanceType.getStartDate();
                    /*
                     * runData.name("Results of "+
                     * "["+addZero(cldr.getMonth(
                     * ))+"-"+addZero(cldr.getDay())+"-"
                     * +addZero(cldr.getYear())+"
                     * "+addZero(cldr.getHour())+":"
                     * +addZero(cldr.getMinute())
                     * +":"+addZero(cldr.getSecond())+"]");
                     */
                    runData.name("Results of " + data.name().substring(0, data.name().indexOf("[")));
                    runData.queryName(data.name());
                    data.runs.add(runData);
                    if (!queryInstanceType.getQueryStatusType().getName().equalsIgnoreCase("completed")) {
                        runData.name(
                                runData.name() + " --- " + queryInstanceType.getQueryStatusType().getName());
                        runData.tooltip("The results of the query run");
                    }
                    addNode(runData, node);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            // jTree1.scrollPathToVisible(new TreePath(node.getPath()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    } else if (node.getUserObject().getClass().getSimpleName().equalsIgnoreCase("QueryInstanceData")) {
        QueryInstanceData data = (QueryInstanceData) node.getUserObject();

        try {
            String xmlRequest = data.writeContentQueryXML();

            String xmlResponse = null;
            if (System.getProperty("webServiceMethod").equals("SOAP")) {
                xmlResponse = QueryListNamesClient.sendQueryRequestSOAP(xmlRequest);
            } else {
                xmlResponse = QueryListNamesClient.sendQueryRequestREST(xmlRequest, true);
            }
            if (xmlResponse.equalsIgnoreCase("CellDown")) {
                final JPanel parent = this;
                java.awt.EventQueue.invokeLater(new Runnable() {
                    public void run() {
                        JOptionPane.showMessageDialog(parent,
                                "Trouble with connection to the remote server, "
                                        + "this is often a network error, please try again",
                                "Network Error", JOptionPane.INFORMATION_MESSAGE);
                    }
                });
                return;
            }

            JAXBUtil jaxbUtil = PatientSetJAXBUtil.getJAXBUtil();

            JAXBElement jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
            ResponseMessageType messageType = (ResponseMessageType) jaxbElement.getValue();
            BodyType bt = messageType.getMessageBody();
            ResultResponseType resultResponseType = (ResultResponseType) new JAXBUnWrapHelper()
                    .getObjectByClass(bt.getAny(), ResultResponseType.class);

            for (QueryResultInstanceType queryResultInstanceType : resultResponseType
                    .getQueryResultInstance()) {
                String status = queryResultInstanceType.getQueryStatusType().getName();

                QueryResultData resultData = new QueryResultData();
                if (queryResultInstanceType.getQueryResultType().getName().equalsIgnoreCase("PATIENTSET")
                        && UserInfoBean.getInstance().isRoleInProject("DATA_LDS")) {
                    resultData.visualAttribute("FA");
                } else {
                    resultData.visualAttribute("LAO");
                }
                // resultData.queryId(data.queryId());
                resultData.patientRefId(queryResultInstanceType.getResultInstanceId());// data.patientRefId());
                resultData.patientCount(new Integer(queryResultInstanceType.getSetSize()).toString());// data.patientCount());
                String resultname = "";
                if ((resultname = queryResultInstanceType.getQueryResultType().getDescription()) == null) {
                    resultname = queryResultInstanceType.getQueryResultType().getName();
                }
                // if (status.equalsIgnoreCase("FINISHED")) {
                if (queryResultInstanceType.getQueryResultType().getName().equals("PATIENTSET")
                /*|| queryResultInstanceType.getQueryResultType().getName()
                .equals("PATIENT_COUNT_XML")*/) {
                    // if (UserInfoBean.getInstance().isRoleInProject(
                    // "DATA_OBFSC")) {
                    // resultData.name(resultname + " - "
                    // + resultData.patientCount() + " Patients");
                    // resultData.tooltip(resultData.patientCount()
                    // + " Patients");
                    // } else {
                    if (queryResultInstanceType.getDescription() != null) {
                        resultname = queryResultInstanceType.getDescription();
                        resultData.name(queryResultInstanceType.getDescription());
                    } else {
                        resultData.name(resultname + " - " + resultData.patientCount() + " Patients");
                    }
                    resultData.tooltip(resultData.patientCount() + " Patients");
                    // }
                } else {
                    if (queryResultInstanceType.getDescription() != null) {
                        resultname = queryResultInstanceType.getDescription();
                        resultData.name(queryResultInstanceType.getDescription());
                    } else {
                        resultData.name(resultname);// + " - " + status);
                        resultData.tooltip(status);
                    }

                }

                resultData.xmlContent(xmlResponse);
                resultData.queryName(data.queryName());
                resultData.type(queryResultInstanceType.getQueryResultType().getName());
                if (!status.equalsIgnoreCase("FINISHED")) {
                    resultData.name(resultData.name() + " --- " + status);
                }
                addNode(resultData, node);
            }
            // }
            // jTree1.scrollPathToVisible(new TreePath(node.getPath()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    } else if (node.getUserObject().getClass().getSimpleName().equalsIgnoreCase("QueryResultData")) {
        QueryResultData data = (QueryResultData) node.getUserObject();
        if (data.patientCount().equalsIgnoreCase("0")) {
            return;
        }
        int maxNumPatientsToDisplay = Integer.valueOf(System.getProperty("PQMaxPatientsNumber"));
        if (Integer.valueOf(data.patientCount()) > maxNumPatientsToDisplay) {
            final JPanel parent = this;
            result = JOptionPane.showConfirmDialog(parent,
                    "The patient count is greater than maximum configured to be displayed.\n"
                            + "Populating the patient list may affect performance. \n"
                            + "Do you want to continue?",
                    "Please Note ...", JOptionPane.YES_NO_OPTION);
            if (result == JOptionPane.NO_OPTION) {
                DefaultMutableTreeNode tmpnode = (DefaultMutableTreeNode) node.getChildAt(0);
                QueryData tmpdata = (QueryData) tmpnode.getUserObject();
                if (tmpdata.name().equalsIgnoreCase("working ......")) {
                    tmpdata.name("Over maximum number of patient nodes");
                    treeModel.reload(tmpnode);
                }
                return;
            }
        }
        try {
            String xmlRequest = data.writeContentQueryXML();

            String xmlResponse = null;
            if (System.getProperty("webServiceMethod").equals("SOAP")) {
                xmlResponse = QueryListNamesClient.sendPDORequestSOAP(xmlRequest, showName());
            } else {
                xmlResponse = QueryListNamesClient.sendPdoRequestREST(xmlRequest);
            }
            if (xmlResponse.equalsIgnoreCase("CellDown")) {
                final JPanel parent = this;
                java.awt.EventQueue.invokeLater(new Runnable() {
                    public void run() {
                        JOptionPane.showMessageDialog(parent,
                                "Trouble with connection to the remote server, "
                                        + "this is often a network error, please try again",
                                "Network Error", JOptionPane.INFORMATION_MESSAGE);
                    }
                });
                return;
            }

            // check response status here ......

            // System.out.println("Response: "+xmlResponse);
            PatientSet patientSet = new PDOResponseMessageFactory().getPatientSetFromResponseXML(xmlResponse);
            List<PatientType> patients = patientSet.getPatient();
            System.out.println("Patient set size: " + patients.size());

            for (int i = 0; i < patients.size(); i++) {
                PatientType patient = patients.get(i);

                PatientData pData = new PatientData();
                pData.patientID(patient.getPatientId().getValue());
                pData.setParamData(patient.getParam());
                pData.visualAttribute("LAO");
                pData.tooltip("Patient");
                pData.patientSetID(data.patientRefId());
                if (showName() && pData.lastName() != null && pData.firstName() != null) {
                    pData.name(pData.patientID() + " [" + pData.lastName().substring(0, 1).toUpperCase()
                            + pData.lastName().substring(1, pData.lastName().length()).toLowerCase() + ", "
                            + pData.firstName().substring(0, 1).toUpperCase()
                            + pData.firstName().substring(1, pData.firstName().length()).toLowerCase() + "]");// ["+pData.age()+"
                    // y/o
                    // "+pData.gender()+"
                    // "+pData.race()+"]");
                } else {
                    pData.name(pData.patientID() + " [" + pData.age() + " y/o " + pData.gender() + " "
                            + pData.race() + "]");
                }
                pData.queryName(data.queryName());
                addNode(pData, node);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // implement for other type of nodes later!!!
}

From source file:com.ext.portlet.epsos.EpsosHelperService.java

public TitleData generatePatientTitleData(PortletRequest req, EhrPatientClientDto patient) {
    XMLGregorianCalendar xgc = patient.getBirthdate();
    Date newDate = xgc.toGregorianCalendar().getTime();
    TitleData titleData = new TitleData();
    titleData.put("epsos.demo.search.givenName", patient.getGivenName());
    titleData.put("epsos.demo.search.familyName", patient.getFamilyName());
    titleData.put("epsos.demo.search.streetAddress", patient.getStreetAddress());
    titleData.put("epsos.demo.search.zip", patient.getZip());
    titleData.put("epsos.demo.search.city", patient.getCity());
    titleData.put("epsos.demo.search.country", patient.getCountry());
    titleData.put("epsos.demo.search.birthdate", EpsosHelperService.dateFormat.format(newDate));
    titleData.setRequest(req);/*w  w  w.  j ava 2  s. c  o  m*/
    return titleData;
}

From source file:edu.harvard.i2b2.patientMapping.ui.MainComposite.java

public void processQueryData(QueryMasterData ndata) {
    ArrayList<QueryModel> nodeXmls = new ArrayList<QueryModel>();
    try {//from w w w . j  a  va  2 s  .com
        JAXBUtil jaxbUtil = PatientMappingJAXBUtil.getJAXBUtil();
        String xmlcontent = null;
        String xmlrequest = null;

        xmlrequest = ndata.writeDefinitionQueryXML();
        lastRequestMessage(xmlrequest);

        if (System.getProperty("webServiceMethod").equals("SOAP")) {
            xmlcontent = PatientMappingQueryClient.sendPDQQueryRequestSOAP(xmlrequest);
        } else {
            xmlcontent = PatientMappingQueryClient.sendPDQQueryRequestREST(xmlrequest);
        }
        lastResponseMessage(xmlcontent);

        if (xmlcontent == null) {

            return;
        } else {
            log.debug("Query content response: " + xmlcontent);
            ndata.xmlContent(xmlcontent);
        }

        JAXBElement jaxbElement = jaxbUtil.unMashallFromString(ndata.xmlContent());
        ResponseMessageType messageType = (ResponseMessageType) jaxbElement.getValue();

        BodyType bt = messageType.getMessageBody();
        MasterResponseType masterResponseType = (MasterResponseType) new JAXBUnWrapHelper()
                .getObjectByClass(bt.getAny(), MasterResponseType.class);
        RequestXmlType requestXmlType = masterResponseType.getQueryMaster().get(0).getRequestXml();

        org.w3c.dom.Element element = (org.w3c.dom.Element) requestXmlType.getContent().get(0);
        if (element != null) {
            log.debug("query definition not null");
        } else {
            log.error("query definition is null");
        }

        String domString = edu.harvard.i2b2.common.util.xml.XMLUtil.convertDOMElementToString(element);
        log.debug("string output" + domString);

        JAXBContext jc1 = JAXBContext
                .newInstance(edu.harvard.i2b2.crcxmljaxb.datavo.psm.query.ObjectFactory.class);
        Unmarshaller unMarshaller = jc1.createUnmarshaller();
        JAXBElement queryDefinitionJaxbElement = (JAXBElement) unMarshaller
                .unmarshal(new StringReader(domString));

        QueryDefinitionType queryDefinitionType = (QueryDefinitionType) queryDefinitionJaxbElement.getValue();

        int numOfPanels = queryDefinitionType.getPanel().size();
        int conceptCount = 0;
        for (int i = 0; i < numOfPanels; i++) {
            PanelType panelType = queryDefinitionType.getPanel().get(i);

            for (int j = 0; j < panelType.getItem().size(); j++) {
                ItemType itemType = panelType.getItem().get(j);

                ///////////////////////////////////////////////
                QueryModel nodedata = null;
                ConstrainByModifier md = itemType.getConstrainByModifier();
                if (md != null) {
                    nodedata = new ModifierData();
                    nodedata.isModifier(true);
                    ((ModifierData) nodedata).modifier_key(md.getModifierKey());
                    ((ModifierData) nodedata).applied_path(md.getAppliedPath());
                    ((ModifierData) nodedata).modifier_name(md.getModifierName());
                    ((ModifierData) nodedata).setModifierValueConstraint(md.getConstrainByValue());
                } else {
                    nodedata = new QueryModel();
                }

                nodedata.name(itemType.getItemName());
                nodedata.visualAttribute("FA");
                nodedata.tooltip(itemType.getTooltip());
                nodedata.fullname(itemType.getItemKey());
                nodedata.hlevel(new Integer(itemType.getHlevel()).toString());

                if (itemType.getItemShape() != null) {
                    nodedata.tableRow().height = new String(itemType.getItemShape());
                    nodedata.tableRow().color = ((ConceptTableModel) table.getModel())
                            .getColor(itemType.getItemColor());
                    // nodedata.tableRow().rowNumber =
                    // Integer
                    // .parseInt(itemType
                    // .getItemRowNumber());
                    nodedata.tableRow().rowNumber = conceptCount + 1;
                } else {
                    nodedata.tableRow().height = "Medium";
                    nodedata.tableRow().color = new RGB(0, 0, 128);
                    nodedata.tableRow().rowNumber = conceptCount + 1;
                }

                nodedata.constrainByValue(itemType.getConstrainByValue());
                if (itemType.getConstrainByValue().size() > 0) {
                    nodedata.setValueConstrains(itemType.getConstrainByValue());

                    if (itemType.getConstrainByValue().size() > 0) {
                        nodedata.setValueConstrains(itemType.getConstrainByValue());
                        if (nodedata.valueModel().hasEnumValue()) {
                            if (nodedata.valueModel().useTextValue()) {
                                ArrayList<String> results = new ArrayList<String>();
                                results.toArray(nodedata.valueModel().value().split(","));
                                nodedata.valueModel().selectedValues = results;
                            }
                        }
                    }
                }

                // Handle Constrain By Dates
                for (int u = 0; u < itemType.getConstrainByDate().size(); u++) {
                    nodedata.setTimeConstrain(itemType.getConstrainByDate().get(u).getDateFrom(),
                            itemType.getConstrainByDate().get(u).getDateTo());
                }

                nodedata.updateNodeMetaDataXML();
                //if (status.equalsIgnoreCase("error")) {
                // MessageBox mBox = new
                // MessageBox(table
                // .getShell(),
                // SWT.ICON_INFORMATION | SWT.OK);
                // mBox.setText("Please Note ...");
                // mBox.setMessage("Response delivered from the remote server could not be understood,\n"
                // +
                // "you may wish to retry your last action.");
                // mBox.open();
                // event.detail = DND.DROP_NONE;

                //continue;
                //} else {
                nodeXmls.add(nodedata);
                conceptCount++;
                //}
            }
        }
        if (nodeXmls.size() == 0) {

            return;
        }
        populateTable(nodeXmls);

        // get query instance
        String xmlRequest = ndata.writeContentQueryXML();
        lastRequestMessage(xmlRequest);
        String xmlResponse = PatientMappingQueryClient.sendPDQQueryRequestREST(xmlRequest);
        lastResponseMessage(xmlResponse);

        jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
        messageType = (ResponseMessageType) jaxbElement.getValue();
        bt = messageType.getMessageBody();
        InstanceResponseType instanceResponseType = (InstanceResponseType) new JAXBUnWrapHelper()
                .getObjectByClass(bt.getAny(), InstanceResponseType.class);

        QueryInstanceData instanceData = null;
        XMLGregorianCalendar startDate = null;
        for (QueryInstanceType queryInstanceType : instanceResponseType.getQueryInstance()) {
            QueryInstanceData runData = new QueryInstanceData();

            runData.visualAttribute("FA");
            runData.tooltip("The results of the query run");
            runData.id(new Integer(queryInstanceType.getQueryInstanceId()).toString());
            XMLGregorianCalendar cldr = queryInstanceType.getStartDate();
            runData.name("Results of " + "[" + cldr.getMonth() + "-" + cldr.getDay() + "-" + cldr.getYear()
                    + " " + cldr.getHour() + ":" + cldr.getMinute() + ":" + cldr.getSecond() + "]");

            if (instanceData == null) {
                startDate = cldr;
                instanceData = runData;
            } else {
                if (cldr.toGregorianCalendar().compareTo(startDate.toGregorianCalendar()) > 0) {
                    startDate = cldr;
                    instanceData = runData;
                }
            }
        }
        // get patient set
        if (instanceData == null) {
            // event.detail = DND.DROP_NONE;
            return;
        }
        log.debug("Got query instance: " + instanceData.name());

        xmlRequest = instanceData.writeContentQueryXML();
        lastRequestMessage(xmlRequest);

        xmlResponse = PatientMappingQueryClient.sendPDQQueryRequestREST(xmlRequest);
        lastResponseMessage(xmlResponse);

        jaxbElement = jaxbUtil.unMashallFromString(xmlResponse);
        messageType = (ResponseMessageType) jaxbElement.getValue();
        bt = messageType.getMessageBody();
        ResultResponseType resultResponseType = (ResultResponseType) new JAXBUnWrapHelper()
                .getObjectByClass(bt.getAny(), ResultResponseType.class);

        for (QueryResultInstanceType queryResultInstanceType : resultResponseType.getQueryResultInstance()) {
            if (!(queryResultInstanceType.getQueryResultType().getName().equalsIgnoreCase("PATIENTSET"))) {
                continue;
            }

            String status = queryResultInstanceType.getQueryStatusType().getName();

            if (status.equalsIgnoreCase("FINISHED")) {

                String setId = new Integer(queryResultInstanceType.getResultInstanceId()).toString();
                String setSize = new Integer(queryResultInstanceType.getSetSize()).toString();
                String description = queryResultInstanceType.getDescription();
                if (description != null) {
                    patientSetText.setText(description);
                } else {
                    patientSetText.setText("Patient Set: " + setSize + " patients");
                }
                patientRefId = new String(setId);
                patientMinNumText.setText("1");
                leftArrowButton.setEnabled(false);

                int maxPatientNum = new Integer(patientMaxNumText.getText()).intValue();
                patientSetSize = queryResultInstanceType.getSetSize();
                if (patientSetSize > maxPatientNum) {
                    rightArrowButton.setEnabled(true);
                    patientMaxNumText.setText("10");
                } else {
                    rightArrowButton.setEnabled(false);
                    if (patientSetSize > 0) {
                        patientMaxNumText.setText(setSize);
                    }
                }

                log.debug("Dropped set of: " + setSize + " patients"/*
                                                                    * strs[0
                                                                    * ]
                                                                    */
                        + " with refId: " + setId/*
                                                 * strs[ 1 ]
                                                 */);
            } else {
                // message
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
        return;
    }
}