@Test
  @RunAsClient
  public void testUpdateAssetFromAtomWithStateNotExist(@ArquillianResource URL baseURL)
      throws Exception {
    URL url = new URL(baseURL + "rest/packages/restPackage1/assets/model1");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty(
        "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
    connection.setRequestMethod("GET");
    connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);
    connection.connect();
    assertEquals(200, connection.getResponseCode());
    assertEquals(MediaType.APPLICATION_ATOM_XML, connection.getContentType());
    InputStream in = connection.getInputStream();
    assertNotNull(in);
    Document<Entry> doc = abdera.getParser().parse(in);
    Entry entry = doc.getRoot();

    // Update state
    ExtensibleElement metadataExtension = entry.getExtension(Translator.METADATA);
    ExtensibleElement stateExtension = metadataExtension.getExtension(Translator.STATE);
    stateExtension.<Element>getExtension(Translator.VALUE).setText("NonExistState");

    connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty(
        "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
    connection.setRequestMethod("PUT");
    connection.setRequestProperty("Content-type", MediaType.APPLICATION_ATOM_XML);
    connection.setDoOutput(true);
    entry.writeTo(connection.getOutputStream());
    assertEquals(500, connection.getResponseCode());
    connection.disconnect();
  }
  /**
   * Add an new empty feed::dasextension element with only a completed management element to the
   * given Feed. Sets the responseTime value to now. Note: A proper sites::site element must be
   * added to the new feed::dasextension element for this new feed::dasextension element to be
   * valid.
   *
   * @param feed - mandatory
   * @return
   */
  private Feed addEmptyDasExtension(Feed feed) {

    // check to make sure there's a dasextension
    QName dasextensionQname = new QName(this.dasextensionNamespace, "dasextension");
    ExtensibleElement dasExt = feed.getExtension(dasextensionQname);
    if (NullChecker.isEmpty(dasExt)) {

      dasExt = feed.addExtension(dasextensionQname);

      // add the dasextension::management element
      QName managementQname = new QName(this.dasextensionNamespace, "management");
      ExtensibleElement management = dasExt.getExtension(managementQname);
      if (NullChecker.isEmpty(management)) {
        management = dasExt.addExtension(managementQname);
      }

      QName responseTimeQname = new QName(this.dasextensionNamespace, "responseTime");
      ExtensibleElement responseTime = management.getExtension(responseTimeQname);
      if (NullChecker.isEmpty(responseTime)) {
        responseTime = management.addExtension(responseTimeQname);
      }

      // set/reset the response time to now
      XMLGregorianCalendar xmlGregCalResponseTime =
          GregorianDateUtil.getGregorianCalendarByDate(new Date());
      responseTime.setText(xmlGregCalResponseTime.toString()); // TODO: Verify date format
    }
    return feed;
  }
 /**
  * Adds a single error element into the DAS dasextension Atom Feed at
  * feed::dasextension::query::errors.
  *
  * @param feed - mandatory - must contain a valid feed::dasextension Element
  * @param errorsError - mandatory - must contain a valid dasextension::query::errors::error
  *     Element
  * @return
  */
 private Feed addError(Feed feed, final ExtensibleElement errorsError) {
   if (NullChecker.isNotEmpty(feed)) {
     // get reference to the dasextension element in feed
     ExtensibleElement dasExt =
         feed.getExtension(new QName(this.dasextensionNamespace, "dasextension"));
     if (NullChecker.isNotEmpty(dasExt)) {
       // get feed::dasextension::query::errors and add the new
       //   error into it in the feed
       ExtensibleElement errors = this.getErrors(dasExt);
       errors.addExtension(errorsError);
     }
   }
   return feed;
 }
 /**
  * Adds a single site element into the given DAS dasextension Atom Feed at
  * feed::dasextension::query::sites.
  *
  * @param feed
  * @param site - mandatory - must contain a valid dasextension::query::sites::site Element
  * @return
  */
 private Feed addSite(Feed feed, final ExtensibleElement site) {
   if (NullChecker.isNotEmpty(feed)) {
     // get reference to the dasextension element in feed
     ExtensibleElement dasExt =
         feed.getExtension(new QName(this.dasextensionNamespace, "dasextension"));
     if (NullChecker.isNotEmpty(dasExt)) {
       // get feed::dasextension::query::sites and add the new
       //	site into it in the feed
       ExtensibleElement sites = this.getSites(dasExt);
       sites.addExtension(site);
     }
   }
   return feed;
 }
  /**
   * Returns true if the the given dasExt contains a feed::dasextension::path::parameters element,
   * else false.
   *
   * @param dasExt - mandatory - must be a valid dasextension Element
   * @return
   */
  private boolean pathParametersExists(ExtensibleElement dasExt) {

    boolean pathParametersExists = false;

    if (NullChecker.isNotEmpty(dasExt)) {
      QName pathQname = new QName(this.dasextensionNamespace, "path");
      ExtensibleElement path = dasExt.getExtension(pathQname);
      if (NullChecker.isNotEmpty(path)) {
        QName parametersQname = new QName(this.dasextensionNamespace, "parameters");
        ExtensibleElement parameters = path.getExtension(parametersQname);
        if (NullChecker.isNotEmpty(parameters)) {
          pathParametersExists = true;
        }
      }
    }
    return pathParametersExists;
  }
  /**
   * Returns true if the the given dasExt contains a feed::dasextension::query::parameters element,
   * else false.
   *
   * @param dasExt - mandatory - must be a valid dasextension Element
   * @return
   */
  private boolean queryParametersExists(ExtensibleElement dasExt) {

    boolean queryParametersExists = false;

    if (NullChecker.isNotEmpty(dasExt)) {
      QName queryQname = new QName(this.dasextensionNamespace, "query");
      ExtensibleElement query = dasExt.getExtension(queryQname);
      if (NullChecker.isNotEmpty(query)) {
        QName parametersQname = new QName(this.dasextensionNamespace, "parameters");
        ExtensibleElement parameters = query.getExtension(parametersQname);
        if (NullChecker.isNotEmpty(parameters)) {
          queryParametersExists = true;
        }
      }
    }
    return queryParametersExists;
  }
  /**
   * Find the current dasextension::path::parameters element or create a new one in the proper place
   * in the given dasextension element.
   *
   * @param dasExt - mandatory - must be a valid dasextension Element
   * @return
   */
  private ExtensibleElement getPathParameters(ExtensibleElement dasExt) {

    QName parametersQname = new QName(this.dasextensionNamespace, "parameters");
    ExtensibleElement parameters = null;

    ExtensibleElement path = this.getPath(dasExt);
    ExtensibleElement pathFirstChild = path.getFirstChild();
    if (NullChecker.isNotEmpty(pathFirstChild)) {
      // already have a parameters
      parameters = pathFirstChild;
    } else {
      // no parameters, so add one
      parameters = path.addExtension(parametersQname);
    }

    return parameters;
  }
  /**
   * Find the current dasextension::query::errors element or create a new one in the proper place in
   * the given dasextension element.
   *
   * @param dasExt - mandatory - must be a valid dasextension Element
   * @return
   */
  public ExtensibleElement getErrors(ExtensibleElement dasExt) {

    // get reference to the dasextension::query element in feed
    ExtensibleElement query = this.getQuery(dasExt);

    // get reference to the dasextension::query::errors element in feed
    QName errorsQname = new QName(this.dasextensionNamespace, "errors");
    ExtensibleElement errors = query.getExtension(errorsQname);
    if (NullChecker.isEmpty(errors)) {
      List<Element> queryChildren = query.getElements();
      if (NullChecker.isEmpty(queryChildren)) {
        // no children in query, so merely add errors element
        errors = query.addExtension(errorsQname);
      } else {
        // add errors after the last child
        errors = query.addExtension(errorsQname);
      }
    }
    return errors;
  }
 /**
  * Adds the given dasextension::query::parameters Element into the given feed. Note: This method
  * will merge the given queryParameters with any existing query::parameters in the given feed.
  *
  * @param feed - mandatory - must contain a valid feed::dasextension Element
  * @param queryParameters - mandatory - must contain a valid and non-empty
  *     dasextension::query::parameters Element.
  * @return
  */
 private Feed addQueryParameters(Feed feed, final ExtensibleElement queryParameters) {
   if (NullChecker.isNotEmpty(feed)) {
     if (NullChecker.isNotEmpty(queryParameters)) {
       // get reference to the dasextension element in feed
       ExtensibleElement dasExt =
           feed.getExtension(new QName(this.dasextensionNamespace, "dasextension"));
       if (NullChecker.isNotEmpty(dasExt)) {
         List<Element> queryParametersEntries = queryParameters.getElements();
         if (NullChecker.isNotEmpty(queryParametersEntries)) {
           // get or create the new dasextension::path::parameters Element
           ExtensibleElement queryParametersFeed = this.getQueryParameters(dasExt);
           // add in the dasextension::path::parameters::entry Elements
           for (Element curQueryParameterEntry : queryParametersEntries) {
             queryParametersFeed.addExtension(curQueryParameterEntry);
           }
         }
       }
     }
   }
   return feed;
 }
  /**
   * Places the org.osehra.integration.http.uri.UriInfo uriInfo instance's query parameter values
   * into the DAS dasextension Atom Feed at feed::dasextension::query::parameters. Notes: The feed
   * parameter must contain a constructed DAS dasextension Atom Feed. This method will remove any
   * existing feed::dasextension::query::parameters::entry elements before adding the new entries
   * from uriInfo.
   *
   * @param feed -mandatory - must contain a valid feed::dasextension Element
   * @param uriInfo - mandatory
   * @return
   */
  public Feed addQueryParameters(Feed feed, final javax.ws.rs.core.UriInfo uriInfo) {
    if (NullChecker.isNotEmpty(feed)) {
      // get reference to the dasextension element in feed
      ExtensibleElement dasExt =
          feed.getExtension(new QName(this.dasextensionNamespace, "dasextension"));
      if (NullChecker.isNotEmpty(dasExt)) {
        // check for a UriInfo to input
        if (NullChecker.isNotEmpty(uriInfo) && !(uriInfo.getQueryParameters().isEmpty())) {
          // get or create reference to the dasextension::query::parameters element in feed
          ExtensibleElement parameters = this.getQueryParameters(dasExt);

          // discard any existing path dasextension::path::parameter::entry elements
          List<Element> queryParameterEntries = parameters.getElements();
          if (NullChecker.isNotEmpty(queryParameterEntries)) {
            for (Element curQueryParameterEntry : queryParameterEntries) {
              curQueryParameterEntry.discard();
            }
          }

          // add the dasextension::query::parameters::entry elements from uriInfo
          QName entryQname = new QName(this.dasextensionNamespace, "entry");
          QName keyQname = new QName(this.dasextensionNamespace, "key");
          QName valueQname = new QName(this.dasextensionNamespace, "value");

          MultivaluedMap<String, String> queryParametersExt = uriInfo.getQueryParameters();
          Set<Map.Entry<String, List<String>>> queryParamsEntries = queryParametersExt.entrySet();
          for (Map.Entry<String, List<String>> queryParameterEntry : queryParamsEntries) {
            ExtensibleElement entry = parameters.addExtension(entryQname);
            ExtensibleElement key = entry.addExtension(keyQname);
            key.setText(queryParameterEntry.getKey());
            for (String entryValue : queryParameterEntry.getValue()) {
              ExtensibleElement value = entry.addExtension(valueQname);
              value.setText(entryValue);
            }
          }
        }
      }
    }
    return feed;
  }
  /**
   * Find the current dasextension::path element or create a new one in the proper place in the
   * given dasextension element.
   *
   * @param dasExt - must be a valid dasextension Element
   * @return
   */
  private ExtensibleElement getPath(ExtensibleElement dasExt) {

    // get or create a reference to the dasextension::path element in feed
    QName pathQname = new QName(this.dasextensionNamespace, "path");
    ExtensibleElement path = null;
    ExtensibleElement firstChild = (ExtensibleElement) dasExt.getFirstChild();
    if (NullChecker.isNotEmpty(firstChild)) {
      QName fCQname = firstChild.getQName();
      if ("path".equals(fCQname.getLocalPart())) {
        // path is the firstChild
        path = firstChild;
      } else {
        // no path, so add it before firstChild
        path = dasExt.addExtension(pathQname, fCQname);
      }
    } else {
      // no children, so create a "path" element
      path = dasExt.addExtension(pathQname);
    }

    return path;
  }
  /**
   * Find the current dasextension::query::parameters element or create a new one in the proper
   * place in the given dasextension element.
   *
   * @param dasExt - mandatory - must be a valid dasextension Element
   * @return
   */
  private ExtensibleElement getQueryParameters(ExtensibleElement dasExt) {

    QName parametersQname = new QName(this.dasextensionNamespace, "parameters");
    ExtensibleElement parameters = null;

    ExtensibleElement query = this.getQuery(dasExt);
    ExtensibleElement queryFirstChild = query.getFirstChild();
    if (NullChecker.isEmpty(queryFirstChild)) {
      // no children in query, so just query::parameters
      parameters = query.addExtension(parametersQname);

    } else {

      QName fCQname = queryFirstChild.getQName();
      if ("parameters".equals(fCQname.getLocalPart())) {
        // already have a query::parameters
        parameters = queryFirstChild;
      } else {
        // firstQueryChild is not parameters, so add query::parameters before it
        parameters = query.addExtension(parametersQname, fCQname);
      }
    }
    return parameters;
  }
  /*    public static Entry ToPackageEntry(PackageItem p, UriInfo uriInfo) {
      UriBuilder base;
      if(p.isHistoricalVersion()) {
          base = uriInfo.getBaseUriBuilder().path("packages").path(p.getName()).path("versions").path(Long.toString(p.getVersionNumber()));
      } else {
          base = uriInfo.getBaseUriBuilder().path("packages").path(p.getName());
      }

      //NOTE: Entry extension is not supported in RESTEasy. We need to either use Abdera or get extension
      //supported in RESTEasy
      //PackageMetadata metadata = new PackageMetadata();
      //metadata.setUuid(p.getUUID());
      //metadata.setCreated(p.getCreatedDate().getTime());
      //metadata.setLastModified(p.getLastModified().getTime());
      //metadata.setLastContributor(p.getLastContributor());
      //c.setJAXBObject(metadata);

      Entry e =new Entry();
      e.setTitle(p.getTitle());
      e.setSummary(p.getDescription());
      e.setPublished(new Date(p.getLastModified().getTimeInMillis()));
      e.setBase(base.clone().build());

      e.setId(base.clone().build());

      Iterator<AssetItem> i = p.getAssets();
      while (i.hasNext()) {
          AssetItem item = i.next();
          Link link = new Link();
          link.setHref((base.clone().path("assets").path(item.getName())).build());
          link.setTitle(item.getTitle());
          link.setRel("asset");
          e.getLinks().add(link);
      }

      Content c = new Content();
      c.setType(MediaType.APPLICATION_OCTET_STREAM_TYPE);
      c.setSrc(base.clone().path("binary").build());
      e.setContent(c);

      return e;
  }*/
  public static Entry toAssetEntryAbdera(AssetItem a, UriInfo uriInfo) {
    URI baseURL;
    if (a.isHistoricalVersion()) {
      baseURL =
          uriInfo
              .getBaseUriBuilder()
              .path("packages/{packageName}/assets/{assetName}/versions/{version}")
              .build(a.getModuleName(), a.getName(), Long.toString(a.getVersionNumber()));
    } else {
      baseURL =
          uriInfo
              .getBaseUriBuilder()
              .path("packages/{packageName}/assets/{assetName}")
              .build(a.getModuleName(), a.getName());
    }

    Factory factory = Abdera.getNewFactory();

    org.apache.abdera.model.Entry e = factory.getAbdera().newEntry();
    e.setTitle(a.getTitle());
    e.setSummary(a.getDescription());
    e.setPublished(new Date(a.getLastModified().getTimeInMillis()));
    e.setBaseUri(baseURL.toString());
    e.addAuthor(a.getLastContributor());

    e.setId(baseURL.toString());

    // generate meta data
    ExtensibleElement extension = e.addExtension(METADATA);
    ExtensibleElement childExtension = extension.addExtension(ARCHIVED);
    // childExtension.setAttributeValue("type", ArtifactsRepository.METADATA_TYPE_STRING);
    childExtension.addSimpleExtension(VALUE, a.isArchived() ? "true" : "false");

    childExtension = extension.addExtension(UUID);
    childExtension.addSimpleExtension(VALUE, a.getUUID());

    childExtension = extension.addExtension(STATE);
    childExtension.addSimpleExtension(VALUE, a.getState() == null ? "" : a.getState().getName());

    childExtension = extension.addExtension(FORMAT);
    childExtension.addSimpleExtension(VALUE, a.getFormat());

    childExtension = extension.addExtension(VERSION_NUMBER);
    childExtension.addSimpleExtension(VALUE, String.valueOf(a.getVersionNumber()));

    childExtension = extension.addExtension(CHECKIN_COMMENT);
    childExtension.addSimpleExtension(VALUE, a.getCheckinComment());

    List<CategoryItem> categories = a.getCategories();
    childExtension = extension.addExtension(CATEGORIES);
    for (CategoryItem c : categories) {
      childExtension.addSimpleExtension(VALUE, c.getName());
    }

    org.apache.abdera.model.Content content = factory.newContent();
    content.setSrc(UriBuilder.fromUri(baseURL).path("binary").build().toString());
    content.setMimeType("application/octet-stream");
    content.setContentType(Type.MEDIA);
    e.setContentElement(content);

    return e;
  }
  public static Entry toPackageEntryAbdera(ModuleItem p, UriInfo uriInfo) {
    URI baseURL;
    if (p.isHistoricalVersion()) {
      baseURL =
          uriInfo
              .getBaseUriBuilder()
              .path("packages/{packageName}/versions/{version}")
              .build(p.getName(), Long.toString(p.getVersionNumber()));
    } else {
      baseURL = uriInfo.getBaseUriBuilder().path("packages/{packageName}").build(p.getName());
    }

    Factory factory = Abdera.getNewFactory();

    org.apache.abdera.model.Entry e = factory.getAbdera().newEntry();
    e.setTitle(p.getTitle());
    e.setSummary(p.getDescription());
    e.setPublished(new Date(p.getLastModified().getTimeInMillis()));
    e.setBaseUri(baseURL.toString());
    e.addAuthor(p.getLastContributor());

    e.setId(baseURL.toString());

    Iterator<AssetItem> i = p.getAssets();
    while (i.hasNext()) {
      AssetItem item = i.next();
      org.apache.abdera.model.Link l = factory.newLink();

      l.setHref(
          UriBuilder.fromUri(baseURL).path("assets/{assetName}").build(item.getName()).toString());
      l.setTitle(item.getTitle());
      l.setRel("asset");
      e.addLink(l);
    }

    // generate meta data
    ExtensibleElement extension = e.addExtension(METADATA);
    ExtensibleElement childExtension = extension.addExtension(ARCHIVED);
    // childExtension.setAttributeValue("type", ArtifactsRepository.METADATA_TYPE_STRING);
    childExtension.addSimpleExtension(VALUE, p.isArchived() ? "true" : "false");

    childExtension = extension.addExtension(UUID);
    childExtension.addSimpleExtension(VALUE, p.getUUID());

    childExtension = extension.addExtension(STATE);
    childExtension.addSimpleExtension(VALUE, p.getState() == null ? "" : p.getState().getName());

    childExtension = extension.addExtension(VERSION_NUMBER);
    childExtension.addSimpleExtension(VALUE, String.valueOf(p.getVersionNumber()));

    childExtension = extension.addExtension(CHECKIN_COMMENT);
    childExtension.addSimpleExtension(VALUE, p.getCheckinComment());

    org.apache.abdera.model.Content content = factory.newContent();
    content.setSrc(UriBuilder.fromUri(baseURL).path("binary").build().toString());
    content.setMimeType("application/octet-stream");
    content.setContentType(Type.MEDIA);
    e.setContentElement(content);

    return e;
  }
  /**
   * Adds a single site element into the DAS dasextension Atom Feed. i.e. adds one of the following
   * inside of feed::dasextension::query::sites: <site> <id></id> <name></name>
   * <expectedCount></expectedCount> <retrievedCount></retrievedCount> <status></status>
   * <error></error> </site> Notes: The feed parameter must contain a constructed DAS dasextension
   * Atom Feed. An existing site element with the same site::name value as the given siteName value
   * will be removed before the new site element is added.
   *
   * @param feed - mandatory - must contain a valid feed::dasextension Element
   * @param siteName - mandatory
   * @param siteId - optional
   * @param siteHttpStatus - mandatory
   * @param expectedCount - optional
   * @param retrievedCount - optional
   * @param siteErrorMessage - optional
   * @return
   */
  public Feed addSite(
      Feed feed,
      final String siteName,
      final String siteId,
      final int siteHttpStatus,
      final String expectedCount,
      final String retrievedCount,
      final String siteErrorMessage) {
    if (NullChecker.isNotEmpty(feed)) {
      // get reference to the dasextension element in feed
      ExtensibleElement dasExt =
          feed.getExtension(new QName(this.dasextensionNamespace, "dasextension"));
      if (NullChecker.isNotEmpty(dasExt)) {
        // get reference to the dasextension::query::sites element in feed
        ExtensibleElement sites = this.getSites(dasExt);

        // search for any existing site children by site::name value with
        // the new siteName, and if one is found, remove it
        List<Element> siteElements = sites.getElements();
        for (Element curSiteElement : siteElements) {
          List<Element> siteChildElements = curSiteElement.getElements();
          for (Element curSiteChildElement : siteChildElements) {
            if ("name".equals(curSiteChildElement.getQName().getLocalPart())) {
              if (siteName.equals(curSiteChildElement.getText())) {
                curSiteElement.discard();
              }
            }
          }
        }

        // add the dasextension::query::sites::site element
        QName siteQname = new QName(this.dasextensionNamespace, "site");
        ExtensibleElement site = sites.addExtension(siteQname);
        if (NullChecker.isNotEmpty(siteId)) {
          QName idQname = new QName(this.dasextensionNamespace, "id");
          ExtensibleElement idElement = site.addExtension(idQname);
          idElement.setText(siteId);
        }
        QName nameQname = new QName(this.dasextensionNamespace, "name");
        ExtensibleElement nameElement = site.addExtension(nameQname);
        nameElement.setText(siteName);
        if (NullChecker.isNotEmpty(expectedCount)) {
          QName expectedCountQname = new QName(this.dasextensionNamespace, "expectedCount");
          ExtensibleElement expectedCountElement = site.addExtension(expectedCountQname);
          expectedCountElement.setText(expectedCount);
        }
        if (NullChecker.isNotEmpty(retrievedCount)) {
          QName retrievedCountQname = new QName(this.dasextensionNamespace, "retrievedCount");
          ExtensibleElement retrievedCountElement = site.addExtension(retrievedCountQname);
          retrievedCountElement.setText(retrievedCount);
        }
        QName statusQname = new QName(this.dasextensionNamespace, "status");
        ExtensibleElement statusElement = site.addExtension(statusQname);
        String siteStatus = new Integer(siteHttpStatus).toString();
        statusElement.setText(siteStatus);
        if (NullChecker.isNotEmpty(siteErrorMessage)) {
          QName errorQname = new QName(this.dasextensionNamespace, "error");
          ExtensibleElement siteErrorElement = site.addExtension(errorQname);
          siteErrorElement.setText(siteErrorMessage);
        }
      }
    }
    return feed;
  }
  @Test
  @RunAsClient
  public void testUpdateAssetFromAtom(@ArquillianResource URL baseURL) throws Exception {
    URL url = new URL(baseURL + "rest/packages/restPackage1/assets/model1");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty(
        "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
    connection.setRequestMethod("GET");
    connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);
    connection.connect();
    assertEquals(200, connection.getResponseCode());
    assertEquals(MediaType.APPLICATION_ATOM_XML, connection.getContentType());
    // System.out.println(GetContent(connection));

    InputStream in = connection.getInputStream();
    assertNotNull(in);
    Document<Entry> doc = abdera.getParser().parse(in);
    Entry entry = doc.getRoot();
    assertEquals(
        baseURL.getPath() + "rest/packages/restPackage1/assets/model1",
        entry.getBaseUri().getPath());
    assertEquals("model1", entry.getTitle());
    assertNotNull(entry.getPublished());
    assertNotNull(entry.getAuthor().getName());
    assertEquals("desc for model1", entry.getSummary());
    // assertEquals(MediaType.APPLICATION_OCTET_STREAM_TYPE.getType(),
    // entry.getContentMimeType().getPrimaryType());
    assertEquals(
        baseURL.getPath() + "rest/packages/restPackage1/assets/model1/binary",
        entry.getContentSrc().getPath());

    ExtensibleElement metadataExtension = entry.getExtension(Translator.METADATA);
    ExtensibleElement archivedExtension = metadataExtension.getExtension(Translator.ARCHIVED);
    assertEquals("false", archivedExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement stateExtension = metadataExtension.getExtension(Translator.STATE);
    assertEquals("Draft", stateExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement formatExtension = metadataExtension.getExtension(Translator.FORMAT);
    assertEquals("model.drl", formatExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement uuidExtension = metadataExtension.getExtension(Translator.UUID);
    assertNotNull(uuidExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement categoryExtension = metadataExtension.getExtension(Translator.CATEGORIES);
    assertEquals(
        "AssetPackageResourceTestCategory", categoryExtension.getSimpleExtension(Translator.VALUE));
    connection.disconnect();

    // Update category. Add a new category tag
    categoryExtension.addSimpleExtension(Translator.VALUE, "AssetPackageResourceTestCategory2");
    // Update state
    stateExtension.<Element>getExtension(Translator.VALUE).setText("Dev");
    // Update format
    formatExtension.<Element>getExtension(Translator.VALUE).setText("anotherformat");

    connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty(
        "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
    connection.setRequestMethod("PUT");
    connection.setRequestProperty("Content-type", MediaType.APPLICATION_ATOM_XML);
    connection.setDoOutput(true);
    entry.writeTo(connection.getOutputStream());
    assertEquals(204, connection.getResponseCode());
    connection.disconnect();

    // Verify again
    connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty(
        "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
    connection.setRequestMethod("GET");
    connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);
    connection.connect();
    assertEquals(200, connection.getResponseCode());
    // System.out.println(GetContent(connection));

    in = connection.getInputStream();
    assertNotNull(in);
    doc = abdera.getParser().parse(in);
    entry = doc.getRoot();

    metadataExtension = entry.getExtension(Translator.METADATA);
    archivedExtension = metadataExtension.getExtension(Translator.ARCHIVED);
    assertEquals("false", archivedExtension.getSimpleExtension(Translator.VALUE));
    stateExtension = metadataExtension.getExtension(Translator.STATE);
    assertEquals("Dev", stateExtension.getSimpleExtension(Translator.VALUE));
    formatExtension = metadataExtension.getExtension(Translator.FORMAT);
    assertEquals("anotherformat", formatExtension.getSimpleExtension(Translator.VALUE));
    categoryExtension = metadataExtension.getExtension(Translator.CATEGORIES);
    List<Element> categoryValues = categoryExtension.getExtensions(Translator.VALUE);
    assertTrue(categoryValues.size() == 2);
    boolean foundCategory1 = false;
    boolean foundCategory2 = false;
    for (Element cat : categoryValues) {
      String catgoryValue = cat.getText();
      if ("AssetPackageResourceTestCategory".equals(catgoryValue)) {
        foundCategory1 = true;
      }
      if ("AssetPackageResourceTestCategory2".equals(catgoryValue)) {
        foundCategory2 = true;
      }
    }
    assertTrue(foundCategory1);
    assertTrue(foundCategory2);
  }
  @Test
  @RunAsClient
  public void testGetAssetAsAtom(@ArquillianResource URL baseURL) throws Exception {
    URL url = new URL(baseURL, "rest/packages/restPackage1/assets/model1");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty(
        "Authorization", "Basic " + new Base64().encodeToString(("admin:admin".getBytes())));
    connection.setRequestMethod("GET");
    connection.setRequestProperty("Accept", MediaType.APPLICATION_ATOM_XML);
    connection.connect();
    assertEquals(200, connection.getResponseCode());
    assertEquals(MediaType.APPLICATION_ATOM_XML, connection.getContentType());
    // System.out.println(getContent(connection));

    InputStream in = connection.getInputStream();
    assertNotNull(in);
    Document<Entry> doc = abdera.getParser().parse(in);
    Entry entry = doc.getRoot();
    assertEquals(
        baseURL.getPath() + "rest/packages/restPackage1/assets/model1",
        entry.getBaseUri().getPath());
    assertEquals("model1", entry.getTitle());
    assertNotNull(entry.getPublished());
    assertNotNull(entry.getAuthor().getName());
    assertEquals("desc for model1", entry.getSummary());
    // assertEquals(MediaType.APPLICATION_OCTET_STREAM_TYPE.getType(),
    // entry.getContentMimeType().getPrimaryType());
    assertEquals(
        baseURL.getPath() + "rest/packages/restPackage1/assets/model1/binary",
        entry.getContentSrc().getPath());

    ExtensibleElement metadataExtension = entry.getExtension(Translator.METADATA);
    ExtensibleElement archivedExtension = metadataExtension.getExtension(Translator.ARCHIVED);
    assertEquals("false", archivedExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement stateExtension = metadataExtension.getExtension(Translator.STATE);
    assertEquals("Draft", stateExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement formatExtension = metadataExtension.getExtension(Translator.FORMAT);
    assertEquals("model.drl", formatExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement uuidExtension = metadataExtension.getExtension(Translator.UUID);
    assertNotNull(uuidExtension.getSimpleExtension(Translator.VALUE));
    ExtensibleElement categoryExtension = metadataExtension.getExtension(Translator.CATEGORIES);
    assertEquals(
        "AssetPackageResourceTestCategory", categoryExtension.getSimpleExtension(Translator.VALUE));
  }
  /**
   * Adds a single error element into the DAS dasextension Atom Feed, i.e. adds one of the following
   * inside of feed::dasextension::query::errors: <error> <errorSeverity></errorSeverity>
   * <errorCode></errorCode> <errorValue></errorValue> <errorLocation></errorLocation> </error>
   * Note: The feed parameter must contain a constructed DAS dasextension Atom Feed.
   *
   * @param feed - mandatory - must contain a valid feed::dasextension Element
   * @param errorSeverity - optional
   * @param errorCode - optional
   * @param errorValue - optional
   * @param errorLocation - optional
   * @return
   */
  public Feed addError(
      Feed feed,
      final String errorSeverity,
      final String errorCode,
      final String errorValue,
      final String errorLocation) {
    if (NullChecker.isNotEmpty(feed)) {
      // get reference to the dasextension element in feed
      ExtensibleElement dasExt =
          feed.getExtension(new QName(this.dasextensionNamespace, "dasextension"));
      if (NullChecker.isNotEmpty(dasExt)) {
        // get reference to the dasextension::query::errors element in feed
        // -- if errors doesn't exist, this method will add it
        ExtensibleElement errors = this.getErrors(dasExt);

        // add the dasextension::query::errors::error element
        QName errorQname = new QName(this.dasextensionNamespace, "error");
        ExtensibleElement errorsError = errors.addExtension(errorQname);
        if (NullChecker.isNotEmpty(errorSeverity)) {
          QName errorSeverityQname = new QName(this.dasextensionNamespace, "errorSeverity");
          ExtensibleElement errorSeverityElement = errorsError.addExtension(errorSeverityQname);
          errorSeverityElement.setText(errorSeverity);
        }
        if (NullChecker.isNotEmpty(errorCode)) {
          QName errorCodeQname = new QName(this.dasextensionNamespace, "errorCode");
          ExtensibleElement errorCodeElement = errorsError.addExtension(errorCodeQname);
          errorCodeElement.setText(errorCode);
        }
        if (NullChecker.isNotEmpty(errorValue)) {
          QName errorValueQname = new QName(this.dasextensionNamespace, "errorValue");
          ExtensibleElement errorValueElement = errorsError.addExtension(errorValueQname);
          errorValueElement.setText(errorValue);
        }
        if (NullChecker.isNotEmpty(errorLocation)) {
          QName errorLocationQname = new QName(this.dasextensionNamespace, "errorLocation");
          ExtensibleElement errorLocationElement = errorsError.addExtension(errorLocationQname);
          errorLocationElement.setText(errorLocation);
        }
      }
    }
    return feed;
  }
  /**
   * Find the current dasextension::query::sites element or create a new one in the proper place in
   * the given dasextension element.
   *
   * @param dasExt - mandatory - must be a valid dasextension Element
   * @return
   */
  public ExtensibleElement getSites(ExtensibleElement dasExt) {

    // get reference to the dasextension::query element in feed
    ExtensibleElement query = this.getQuery(dasExt);

    // get reference to the dasextension::query::sites element in feed
    QName sitesQname = new QName(this.dasextensionNamespace, "sites");
    ExtensibleElement sites = query.getExtension(sitesQname);
    if (NullChecker.isEmpty(sites)) {
      ExtensibleElement queryFirstChild = query.getFirstChild();
      if (NullChecker.isEmpty(queryFirstChild)) {
        // no children in query, so merely add sites element
        sites = query.addExtension(sitesQname);
      } else {
        QName fCQname = queryFirstChild.getQName();
        if ("parameters".equals(fCQname.getLocalPart())) {
          ExtensibleElement querySecondChild = query.getNextSibling();
          if (NullChecker.isEmpty(querySecondChild)) {
            // no second child in query, so add sites after parameters
            sites = query.addExtension(sitesQname);
          } else {
            // add sites after parameters, and before the second child
            QName sCQname = querySecondChild.getQName();
            sites = query.addExtension(sitesQname, sCQname);
          }
        } else {
          // another element besides parameters is first child,
          //  so add sites before this
          sites = dasExt.addExtension(sitesQname, fCQname);
        }
      }
    }
    return sites;
  }
  /**
   * Merge the elements in the given dasextensionToMerge Element into the feed::dasextension element
   * in the given feed. Note: The dasextension::path::parameters and dasextension::query::parameters
   * values in the given dasextensionToMerge Element will only be merged into the given feed if the
   * given feed does not already have these Elements.
   *
   * @param feed - mandatory - must contain a valid feed::dasextension Element
   * @param extensionToMerge - mandatory - must contain a valid dasextension Element
   * @return
   */
  public Feed mergeDasExtension(Feed feed, final Element dasextensionToMerge) {

    if (NullChecker.isNotEmpty(feed)) {
      if (NullChecker.isNotEmpty(dasextensionToMerge)) {

        QName mergeExtQname = dasextensionToMerge.getQName();
        String mergeExtTagName = mergeExtQname.getLocalPart();

        // if dasextensionToMerge isn't a dasextension, ignore it
        if ("dasextension".equals(mergeExtTagName)) {
          ExtensibleElement feedDasExt =
              feed.getExtension(new QName(this.dasextensionNamespace, "dasextension"));

          if (NullChecker.isNotEmpty(feedDasExt)) {
            // feed contains an existing dasextension, so merge other dasextensionToMerge with it:

            // merge dasextension::path::parameters if none are already in feed
            boolean feedPathParametersExists = this.pathParametersExists(feedDasExt);
            boolean mergePathParametersExists =
                this.pathParametersExists((ExtensibleElement) dasextensionToMerge);
            if (false == feedPathParametersExists) {
              if (mergePathParametersExists) {
                ExtensibleElement mergePathParameters =
                    this.getPathParameters((ExtensibleElement) dasextensionToMerge);
                feed = this.addPathParameters(feed, mergePathParameters);
              }
            }

            // merge dasextension::query::parameters if none are already in feed
            boolean feedQueryParametersExists = this.queryParametersExists(feedDasExt);
            boolean mergeQueryParametersExists =
                this.queryParametersExists((ExtensibleElement) dasextensionToMerge);
            if (false == feedQueryParametersExists) {
              if (mergeQueryParametersExists) {
                ExtensibleElement mergeQueryParameters =
                    this.getQueryParameters((ExtensibleElement) dasextensionToMerge);
                feed = this.addQueryParameters(feed, mergeQueryParameters);
              }
            }

            // collect all of the current dasextension sites::site elements
            List<Element> siteElements = new ArrayList<Element>();
            ExtensibleElement mergeSites = this.getSites((ExtensibleElement) dasextensionToMerge);
            if (NullChecker.isNotEmpty(mergeSites)) {
              siteElements.addAll(mergeSites.getElements());
            }

            // add in the site elements into the feed's dasextension
            for (final Element siteElement : siteElements) {
              feed = this.addSite(feed, (ExtensibleElement) siteElement);
            }

            // collect all of the merge dasextension errors::error elements
            List<Element> errorElements = new ArrayList<Element>();
            ExtensibleElement mergeErrors = this.getErrors((ExtensibleElement) dasextensionToMerge);
            if (NullChecker.isNotEmpty(mergeErrors)) {
              errorElements.addAll(mergeErrors.getElements());
            }

            // add in the error elements into the feed's dasextension
            for (final Element errorElement : errorElements) {
              feed = this.addError(feed, (ExtensibleElement) errorElement);
            }

          } else {
            // feed has no existing dasextension element, so add in dasextensionToMerge
            feed.addExtension(dasextensionToMerge);
          }
        }
      }
    }
    return feed;
  }
  /**
   * Find the current dasextension::query element or create a new one in the proper place in the
   * given dasextension element.
   *
   * @param dasExt - mandatory - must be a valid dasextension Element
   * @return
   */
  private ExtensibleElement getQuery(ExtensibleElement dasExt) {

    QName queryQname = new QName(this.dasextensionNamespace, "query");
    // attempt to get query element
    ExtensibleElement query = dasExt.getExtension(queryQname);
    if (NullChecker.isEmpty(query)) {
      // there is no query element, so create one in the proper place
      ExtensibleElement firstChild = dasExt.getFirstChild();
      if (NullChecker.isEmpty(firstChild)) {
        // no children, so merely add query
        query = dasExt.addExtension(queryQname);
      } else {
        QName fCQname = firstChild.getQName();
        if ("path".equals(fCQname.getLocalPart())) {
          // path is the firstChild, so get the second child
          ExtensibleElement secondChild = firstChild.getNextSibling();
          if (NullChecker.isEmpty(secondChild)) {
            // no second child, so add query after path
            query = dasExt.addExtension(queryQname);
          } else {
            QName sCQname = secondChild.getQName();
            // have a second child, so add query after
            // path element and before second child
            query = dasExt.addExtension(queryQname, sCQname);
          }
        } else {
          // add query before the first child element
          query = dasExt.addExtension(queryQname, fCQname);
        }
      }
    }
    return query;
  }