Metacat

		/*suite.addTest(new CrudServiceTest("initialize"));

		suite.addTest(new CrudServiceTest("testGetSystemMetadata"));*/

		suite.addTest(new CrudServiceTest("testUpdate"));

	 * public Identifier update(AuthToken token, Identifier guid, 

     *       InputStream object, Identifier obsoletedGuid, SystemMetadata sysmeta) 

     *         throws InvalidToken, ServiceFailure, NotAuthorized, IdentifierNotUnique, 

     *           UnsupportedType, InsufficientResources, NotFound, InvalidSystemMetadata, 

     *           NotImplemented

	 */

	public void testUpdate()

	{

	    printTestHeader("testUpdate");

	    try

	    {

	        CrudService cs = CrudService.getInstance();

	        AuthToken token = getToken();

            //create a doc

            System.out.println("CST: creating document");

            Identifier id = createDoc(token, getTestDoc());

            System.out.println("CST: document created.  Id: " + id.getValue());

            //get the doc and sysmetadata

            System.out.println("CST: getting document with id " + id.getValue());

            String gotDoc = getDoc(token, id);

            System.out.println("CST: getting sysmeta for doc with id " + id.getValue());

            SystemMetadata sm = getSystemMetadata(token, id);

            //update the doc

            System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ doing the update now $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");

            gotDoc = gotDoc.replaceAll("XXX", "YYY");

            System.out.println("CST: Changed test doc to " + gotDoc);

            Identifier newid = new Identifier();

            newid.setValue(generateDocumentId());

            System.out.println("CST: Generated newid " + newid);

            StringBufferInputStream sbis = new StringBufferInputStream(gotDoc);

            SystemMetadata newsm = createSystemMetadata(newid, gotDoc);

            System.out.println("CST: Created system metadata for new doc...updating.");

            Identifier updatedid = cs.update(token, newid, sbis, id, newsm);

            System.out.println("CST: Called update. Returned id " + id);

            //get doc - check that it matches update

            String newdoc = getDoc(token, newid);

            assertTrue(gotDoc.equals(newdoc));

            //get sysmeta - check that ids and other fields are updated

            SystemMetadata newnewsm = getSystemMetadata(token, id);

            List obsoletedByList = newnewsm.getObsoletedByList();

            assertTrue(obsoletedByList.size() == 1);

            String obsBy = ((Identifier)obsoletedByList.get(0)).getValue();

            assertTrue(obsBy.equals(id.getValue()));

        }

        catch(Exception e)

        {

            e.printStackTrace();

            fail("Error in testUpdate: " + e.getMessage());

        }

	}

	/**

	    return "<?xml version=\"1.0\"?><test><somecontent>This is some content XXX</somecontent></test>\n";

        SystemMetadata sm = createSystemMetadata(id, testDoc);

        //create the doc

        cs.create(token, id, sbis, sm);

        System.out.println("document with id " + id.getValue() + " created.");

        return id;

	}

	/**

	 * create a generic SystemMetadata object for testing

	 */

	private SystemMetadata createSystemMetadata(Identifier id, String testDoc)

	  throws Exception

	{

	    SystemMetadata sm = new SystemMetadata();

        return sm;

        System.out.println("creating new accnum: " + accnum + " for action " + action);

                 ("Next revision number can't be less than or equal to "

import java.util.List;

                this.insertDocument(object, guid, sessionData);

    /**

     * update an existing object with a new object.  Change the system metadata

     * to reflect the changes and update it as well.

     */

        try

        {

            SessionData sessionData = getSessionData(token);

            //find the old systemmetadata (sm.old) document id (the one linked to obsoletedGuid)

            SystemMetadata sm = getSystemMetadata(token, obsoletedGuid);

            System.out.println("CS: got sm for obsoleteGuid: " + obsoletedGuid.getValue());

            //change sm.old's obsoletedBy field 

            List l = sm.getObsoletedByList();

            l.add(guid);

            sm.setObsoletedByList(l);

            System.out.println("CS: set obsoletedBy to id: " + ((Identifier)l.get(0)).getValue());

            //update sm.old

            System.out.println("CS: updating system metadata...");

            updateSystemMetadata(sm, sessionData);

            System.out.println("CS: updated system metadata.");

            //change the obsoletes field of the new systemMetadata (sm.new) to point to the id of the old one

            System.out.println("CS: Adding obsoleteGuid to new sysmeta");

            sysmeta.addObsolete(obsoletedGuid);

            //insert sm.new

            System.out.println("CS: inserting new sysmeta");

            insertSystemMetadata(sysmeta, sessionData);

            //call update with sm.new.object.id for object

            //System.out.println("CS: updating old sm");

            //updateSystemMetadata(sm, sessionData);

            System.out.println("CS: updating doc");

            updateDocument(object, obsoletedGuid, guid, sessionData);

            System.out.println("CS: Done updating document.");

            return guid;

        }

        catch(Exception e)

        {

            throw new ServiceFailure(1030, "Error updating document in CrudService: " + e.getMessage());

        }

    /**

     * insert a systemMetadata doc

     */

     * update a systemMetadata doc

     */

    private void updateSystemMetadata(SystemMetadata sm, SessionData sessionData)

      throws ServiceFailure

    {

        try

        {

            System.out.println("Updating SystemMetadata with id " + sm.getIdentifier().getValue());

            String smId = IdentifierManager.getInstance().getSystemMetadataId(sm.getIdentifier().getValue());

            System.out.println("smId: " + smId);

            sm.setDateSysMetadataModified(new Date());

            String xml = new String(serializeSystemMetadata(sm).toByteArray());

            Identifier id = new Identifier();

            id.setValue(smId);

            System.out.println("updating sysmeta doc with new id " + id.getValue());

            String localId = updateDocument(xml, id, null, sessionData);

            System.out.println("new updated localId: " + localId);

            System.out.println("CS: updateDocument returned localId: " + localId);

            IdentifierManager.getInstance().updateSystemMetadataMapping(sm.getIdentifier().getValue(), localId);

        }

        catch(Exception e)

        {

            throw new ServiceFailure(1030, "Error updating system metadata: " + e.getMessage());

        }

    }

    /**

     * insert a document

     * NOTE: this method shouldn't be used from the update or create() methods.  

     * we shouldn't be putting the science metadata or data objects into memory.

     */

    private String insertDocument(String xml, Identifier guid, SessionData sessionData)

        throws ServiceFailure

    {

        return insertOrUpdateDocument(xml, guid, sessionData, "insert");

    }

    /**

     * insert a document from a stream

     */

    private String insertDocument(InputStream is, Identifier guid, SessionData sessionData)

      throws IOException, ServiceFailure

    {

        //HACK: change this eventually.  we should not be converting the stream to a string

        String xml = IOUtils.toString(is);

        return insertDocument(xml, guid, sessionData);

    }

    /**

     * update a document

     * NOTE: this method shouldn't be used from the update or create() methods.  

     * we shouldn't be putting the science metadata or data objects into memory.

     */

    private String updateDocument(String xml, Identifier obsoleteGuid, Identifier guid, SessionData sessionData)

        throws ServiceFailure

    {

        return insertOrUpdateDocument(xml, obsoleteGuid, sessionData, "update");

    }

    /**

     * update a document from a stream

     */

    private String updateDocument(InputStream is, Identifier obsoleteGuid, Identifier guid, SessionData sessionData)

      throws IOException, ServiceFailure

    {

        //HACK: change this eventually.  we should not be converting the stream to a string

        String xml = IOUtils.toString(is);

        String localId = updateDocument(xml, obsoleteGuid, guid, sessionData);

        IdentifierManager im = IdentifierManager.getInstance();

        if(guid != null)

        {

          im.createMapping(guid.getValue(), localId);

        }

        return localId;

    }

    /**

    private String insertOrUpdateDocument(String xml, Identifier guid, SessionData sessionData, String insertOrUpdate) 

        String localId = null;

        if(insertOrUpdate.equals("insert"))

        {

            localId = im.generateLocalId(guid.getValue(), 1);

        }

        else

        {

            //localid should already exist in the identifier table, so just find it

            try

            {

                localId = im.getLocalId(guid.getValue());

                //increment the revision

                String docid = localId.substring(0, localId.lastIndexOf("."));

                String revS = localId.substring(localId.lastIndexOf(".") + 1, localId.length());

                int rev = new Integer(revS).intValue();

                rev++;

                docid = docid + "." + rev;

                localId = docid;

            }

            catch(McdbDocNotFoundException e)

            {

                throw new ServiceFailure(1030, "CrudService.insertOrUpdateDocument(): " +

                    "guid " + guid.getValue() + " should have been in the identifier table, but it wasn't: " + e.getMessage());

            }

        }

        action[0] = insertOrUpdate;

        System.out.println(insertOrUpdate + "ing with localId " + localId);

    public void updateSystemMetadataMapping(String guid, String localId)

    {

        int serialNumber = -1;

        DBConnection dbConn = null;

        try {

            // Parse the localId into scope and rev parts

            AccessionNumber acc = new AccessionNumber(localId, "NOACTION");

            String docid = acc.getDocid();

            int rev = 1;

            if(acc.getRev() != null)

            {

              rev = (new Integer(acc.getRev()).intValue());

            }

            // Get a database connection from the pool

            dbConn = 

                DBConnectionPool.getDBConnection("Identifier.createMapping");

            serialNumber = dbConn.getCheckOutSerialNumber();

            // Execute the insert statement

            String query = "update systemmetadata set (docid, rev) = (?, ?) where guid='" + guid + "'";

            System.out.println("query: " + query + " for params: (guid:" + guid + ", docid=" + docid + ", rev=" + rev + ")");

            PreparedStatement stmt = dbConn.prepareStatement(query);

            stmt.setString(1, docid);

            stmt.setInt(2, rev);

            int rows = stmt.executeUpdate();

            stmt.close();

        } catch (SQLException e) {

            e.printStackTrace();

            logMetacat.error("SQL error while updating a mapping to the system metadata identifier: " 

                    + e.getMessage());

        } catch (NumberFormatException e) {

            e.printStackTrace();

            logMetacat.error("NumberFormat error while updating a mapping to the system metadata identifier: " 

                    + e.getMessage());

        } catch (AccessionNumberException e) {

            e.printStackTrace();

            logMetacat.error("AccessionNumber error while updating a mapping to the system metadata identifier: " 

                    + e.getMessage());

        } finally {

            // Return database connection to the pool

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

        }

    }