Beispiel #1
0
def get_work_from_dspace(handle, xmlfile):
    """
    Given DSpace handle, fetches metadata of the work and stores it to xmlfile.
    Access DSpace using direct access to Postgres DB
    """
    dspace = DSpace(separator='_')
    metadata = dspace.get_metadata_in_document_lang(handle)

    env = Environment(trim_blocks=True,
                      loader=PackageLoader('myapp', 'templates'),
                      autoescape=select_autoescape(['xml']))

    template = env.get_template('works.xml')
    #    print(metadata)
    #    print(template.render(metadata))
    xml = template.render(metadata)
    with open(xmlfile, 'wb') as outfile:
        outfile.write(xml.encode('utf-8'))
Beispiel #2
0
 def setUp(self):
     self.rest_api_path = "http://45.55.192.223:8443/rest"
     #self.rest_api_path = "https://trydspace.longsight.com/rest"
     self.dspace = DSpace(self.rest_api_path)
     pass
Beispiel #3
0
class TestDSpace(TestCase):
  #TODO Refactor in new Item tests in new TestCase

  def setUp(self):
      self.rest_api_path = "http://45.55.192.223:8443/rest"
      #self.rest_api_path = "https://trydspace.longsight.com/rest"
      self.dspace = DSpace(self.rest_api_path)
      pass

  def test_login_success(self):
      """
      Tests authentication success
      """
      #user created for testing purposes#
      expected_response_code = httplib.OK #200
      response = self.dspace.login("*****@*****.**","passw0rd_api")
      self.assertTrue(self.dspace.api_key != "","Login success test fails, API Key not assigned")

  def test_login_fail(self):
      """
      Tests authentication fails
      """
      #user created for testing purposes#
      expected_response_code = httplib.FORBIDDEN #403
      response = self.dspace.login("*****@*****.**","not_my_password")
      self.assertEqual(expected_response_code,response.status_code, "Login error test fails")

  def test_logout_previous_login(self):
      """
      Tests  Logout previous login
      """
      success_response_code = httplib.OK #200
      #login before test log out
      self.dspace.login("*****@*****.**","passw0rd_api")
      response = self.dspace.logout()
      self.assertEqual(response.status_code,success_response_code,"Logout test fails")

  def test_logout_no_login(self):
      """
      Tests Logout no previous login
      """
      bad_request_code = httplib.BAD_REQUEST #400
      #login before test log out
      response = self.dspace.logout()
      self.assertEqual(response.status_code,bad_request_code,"Logout test fails")

  #ITEM Class Test
  #TODO Refactor

  def test_get_all_items(self):
      """
      Test Retrieving all items
      """
      dspace= self.dspace
      items = Item.get_all(dspace)
      self.assertGreater(len(items),0)

  def test_get_all_items_with_limit(self):
      """
      Test Retrieving all items with limit
      """
      dspace= self.dspace
      max_items = 5
      items = Item.get_all(dspace,limit=[max_items])
      self.assertLessEqual(len(items),max_items)

  def test_get_item(self):
      """
      Test Retrieving an item by Id
      """
      dspace = self.dspace
      test_id = 5
      item = Item.get_item(dspace,test_id)
      self.assertEqual(item.id,test_id,"Get item by Id Fails")

  def test_get_item_with_metadata(self):
      """
      Test Retrieving an item by Id
      """
      dspace= self.dspace
      test_id = 5
      item = Item.get_item(dspace,test_id,expand=["metadata"])
      self.assertIsNotNone(item.metadata,"Item metadata not retrieved")

  def test_get_item_metadata(self):
      """
      Test Retrieving an item by Id
      """
      dspace= self.dspace
      test_id = 5
      metadata = Item.get_item_metadata(dspace,test_id)
      self.assertGreater(len(metadata),0)

  def test_find_by_metadata_field(self):
      """
      Test searching items by metadata field
      """
      #test using known item and field
      #TODO test with dynamic items and metadata fields
      dspace = self.dspace
      language ="en_US"
      field = "lom.general.keyword"
      value = "anatomia"
      items = Item.find_by_metadata_field(dspace,field,value,language)
      self.assertIsNotNone(items)
      self.assertGreater(len(items),0)

  def test_search_by_keywords(self):
      """
      Test searching by keywords
      """
      dspace = self.dspace
      keywords = ["anatomia","prueba"]
      items = Item.search_by_keywords(dspace,keywords)
      self.assertIsNotNone(items)
      self.assertGreaterEqual(len(items),2)

  #Collection Class Test
  #TODO Refactor

  def test_get_all_collections(self):
      """
      Test Retrieving all collections
      """
      dspace= self.dspace
      collections = Collection.get_all(dspace)
      self.assertGreater(len(collections),0)

  def test_get_all_collections_with_limit(self):
      """
      Test Retrieving all collections with limit
      """
      dspace= self.dspace
      max_collections = 5
      collections = Collection.get_all(dspace,limit=[max_collections])
      self.assertLessEqual(len(collections),max_collections)

  def test_get_community(self):
      """
      Test Retrieving an collection by Id
      """
      dspace= self.dspace
      test_id = 2
      collection = Collection.get_collection(dspace,test_id)
      self.assertEqual(collection.id,test_id,"Get collection by Id Fails")

  def test_get_collection_items(self):
      """
      Test retrieving all items from an especific collection
      """
      dspace =  self.dspace
      test_id = 2
      items = Collection.get_items(dspace,test_id,expand=["parentCollection"])
      self.assertIsNotNone(items)
      for item in items:
          item_temp = Item(dict(item))
          self.assertEqual(test_id,item_temp.parentCollection["id"])

  def test_get_not_found_collection_items(self):
      """
      Test retrieving all items from an especific not found collection
      """
      dspace =  self.dspace
      test_id = -1
      self.assertRaises(Collection.DoesNotExist,lambda:Collection.get_items(dspace,test_id,expand=["parentCollection"]))

  #Community Class Test
  #TODO Refactor

  def test_get_all_communities(self):
      """
      Test Retrieving all communities
      """
      dspace= self.dspace
      communities = Community.get_all(dspace)
      self.assertGreater(len(communities),0)

  def test_get_all_communities_with_limit(self):
      """
      Test Retrieving all communities with limit
      """
      dspace= self.dspace
      max_communities = 5
      communities = Community.get_all(dspace,limit=[max_communities])
      self.assertLessEqual(len(communities),max_communities)

  def test_get_community(self):
      """
      Test Retrieving an community by Id
      """
      dspace= self.dspace
      test_id = 2
      community = Community.get_community(dspace,test_id)
      self.assertEqual(community.id,test_id,"Get community by Id Fails")

  def test_get_top_communities(self):
      """
      Test retrieving top level communities
      """
      dspace = self.dspace
      communities = Community.get_top_communities(dspace,expand=["parentCommunity"])
      self.assertIsNotNone(communities)
      for com in communities:
          self.assertIsNone(com['parentCommunity'])

  def test_get_community_collections(self):
      """
      Test retrieving all collections from an especific community
      """
      dspace =  self.dspace
      test_id = 2
      collections = Community.get_collections(dspace,test_id,expand=["parentCommunity"])
      self.assertIsNotNone(collections)
      for collection in collections:
          collection_temp = Collection(dict(collection))
          self.assertEqual(test_id,collection_temp.parentCommunity["id"])

  def test_get_not_found_community_collections(self):
      """
      Test retrieving all collections from an especific not found community
      """
      dspace =  self.dspace
      test_id = -1
      self.assertRaises(Community.DoesNotExist,lambda:Community.get_collections(dspace,test_id,expand=["parentCommunity"]))
Beispiel #4
0
    """Given an ORCID ID, get the put codes of all works uploaded by this client app"""

    baseurl = dspace.lookup_env(orcid)
    if baseurl == 'https://api.sandbox.orcid.org':
        baseurl = 'https://pub.sandbox.orcid.org'
    else:
        baseurl = 'https://pub.orcid.org'

    url = '%s/v2.0/%s/works' % (baseurl, orcid)
    headers = {
        'Content-type': 'application/json',
    }

    response = requests.get(url, headers=headers)
    if not response.ok:
        print(response.text)
    response.raise_for_status()

    json = response.json()
    for i in json['group']:
        print("%s") % i


if __name__ == "__main__":
    orcid = '0000-0012-3456-789X'

    dspace = DSpace(separator='_')
    works = dspace.get_author_publications(orcid)
    print("%s : %i works from DSpace" % (orcid, len(works)))
    upload_all(dspace, orcid, works)  # upload a single author