Metacat

            String formatId = null;

            if(sysmeta.getFormatId() != null)  {

                formatId = sysmeta.getFormatId().getValue();

            }

	        localId = insertOrUpdateDocument(object,"UTF-8", pid, session, "insert", formatId);

      logMetacat.warn("There was a problem determining if the object identified by" + 

  public String insertOrUpdateDocument(InputStream xmlStream, String encoding,  Identifier pid, 

    Session session, String insertOrUpdate, String formatId) 

    byte[] xmlBytes  = IOUtils.toByteArray(xmlStream);

    IOUtils.closeQuietly(xmlStream);

                        null, params, username, groupnames, false, false, xmlBytes, formatId);

   * @param object
-   * @param pid
-   * @param sessionData
-   * @throws ServiceFailure
-   * @returns localId of the data object inserted
-   */
-  public String insertDataObject(InputStream object, Identifier pid, 
-          Session session) throws ServiceFailure {
-      
+   * @param object

    	Set<Subject> otherSubjects = AuthUtils.authorizedClientSubjects(session);

    	if (otherSubjects != null) {    		

			groupnames = new String[otherSubjects.size()];

			int i = 0;

			Iterator<Subject> iter = otherSubjects.iterator();

			while (iter.hasNext()) {

				groupnames[i] = iter.next().getValue();

				i++;

			}

  
-    // generate pid/localId pair for object
-    logMetacat.debug("Generating a pid/localId mapping");
-    IdentifierManager im = IdentifierManager.getInstance();
-    String localId = im.generateLocalId(pid.getValue(), 1);
   

	}
+	}

-    logMetacat.debug("Case DATA: starting to write to disk.");
-	if (locked) {
-
-          File dataDirectory = new File(datafilepath);
-          dataDirectory.mkdirs();
-  
-          File newFile = writeStreamToFile(dataDirectory, localId, object);
-  
-          // TODO: Check that the file size matches SystemMetadata
-          // long size = newFile.length();
-          // if (size == 0) {
-          //     throw new IOException("Uploaded file is 0 bytes!");
-          // }
-  
-          // Register the file in the database (which generates an exception
-          // if the localId is not acceptable or other untoward things happen
-          try {
-            logMetacat.debug("Registering document...");
-            DocumentImpl.registerDocument(localId, "BIN", localId,
-                    username, groupnames);
+

            
-          } catch (SQLException e) {
-            //newFile.delete();
-            logMetacat.debug("SQLE: " + e.getMessage());
-            e.printStackTrace(System.out);
+            

            
-          } catch (AccessionNumberException e) {
-            //newFile.delete();
-            logMetacat.debug("ANE: " + e.getMessage());
-            e.printStackTrace(System.out);
+            

            
-          } catch (Exception e) {
-            //newFile.delete();
-            logMetacat.debug("Exception: " + e.getMessage());
-            e.printStackTrace(System.out);
+            

            	e.getMessage());
-          }
-  
-          logMetacat.debug("Logging the creation event.");
-          EventLog.getInstance().log(request.getRemoteAddr(), request.getHeader("User-Agent"), username, localId, "create");
-  
-          // Schedule replication for this data file, the "insert" action is important here!
-          logMetacat.debug("Scheduling replication.");
-          ForceReplicationHandler frh = new ForceReplicationHandler(localId, "insert", false, null);
+            	e.getMessage());

      
+      

    
-  }

  private File writeStreamToFile(File dir, String fileName, InputStream dataStream) 

          long length = IOUtils.copyLarge(dataStream, os);

    } finally {

        IOUtils.closeQuietly(dataStream);

}
+}

            if(isReadOnlyMode()) {

                throw new ServiceFailure("1310", ReadOnlyChecker.DATAONEERROR);

            }

            //transform a sid to a pid if it is applicable

            String serviceFailureCode = "1310";

            Identifier sid = getPIDForSID(pid, serviceFailureCode);

            if(sid != null) {

                pid = sid;

            }

            String localId = null;

            boolean allowed = false;

            boolean isScienceMetadata = false;

            if (session == null) {

            	throw new InvalidToken("1210", "No session has been provided");

            }

            Subject subject = session.getSubject();

            // verify the pid is valid format

            if (!isValidIdentifier(pid)) {

            	throw new InvalidRequest("1202", "The provided identifier is invalid.");

            }

            // verify the new pid is valid format

            if (!isValidIdentifier(newPid)) {

                throw new InvalidRequest("1202", "The provided identifier is invalid.");

            // make sure that the newPid doesn't exists

            boolean idExists = true;

            try {

                idExists = IdentifierManager.getInstance().identifierExists(newPid.getValue());

            } catch (SQLException e) {

                throw new ServiceFailure("1310", 

                                        "The requested identifier " + newPid.getValue() +

                                        " couldn't be determined if it is unique since : "+e.getMessage());

            if (idExists) {

                    throw new IdentifierNotUnique("1220", 

                              "The requested identifier " + newPid.getValue() +

                              " is already used by another object and" +

                              "therefore can not be used for this object. Clients should choose" +

                              "a new identifier that is unique and retry the operation or " +

                              "use CN.reserveIdentifier() to reserve one.");

            }

            // check for the existing identifier

            try {

                localId = IdentifierManager.getInstance().getLocalId(pid.getValue());

            } catch (McdbDocNotFoundException e) {

                throw new InvalidRequest("1202", "The object with the provided " + 

                    "identifier was not found.");

            } catch (SQLException ee) {

                throw new ServiceFailure("1310", "The object with the provided " + 

                        "identifier "+pid.getValue()+" can't be identified since - "+ee.getMessage());

            }

            // set the originating node

            NodeReference originMemberNode = this.getCapabilities().getIdentifier();

            sysmeta.setOriginMemberNode(originMemberNode);

            // set the submitter to match the certificate

            sysmeta.setSubmitter(subject);

            // set the dates

            Date now = Calendar.getInstance().getTime();

            sysmeta.setDateSysMetadataModified(now);

            sysmeta.setDateUploaded(now);

            // make sure serial version is set to something

            BigInteger serialVersion = sysmeta.getSerialVersion();

            if (serialVersion == null) {

            	sysmeta.setSerialVersion(BigInteger.ZERO);

            }

            // does the subject have WRITE ( == update) priveleges on the pid?

            //allowed = isAuthorized(session, pid, Permission.WRITE);

            //CN having the permission is allowed; user with the write permission and calling on the authoritative node is allowed.

            allowed = allowUpdating(session, pid, Permission.WRITE);

            if (allowed) {

            	// check quality of SM

            	if (sysmeta.getObsoletedBy() != null) {

            		throw new InvalidSystemMetadata("1300", "Cannot include obsoletedBy when updating object");

            	}

            	if (sysmeta.getObsoletes() != null && !sysmeta.getObsoletes().getValue().equals(pid.getValue())) {

            		throw new InvalidSystemMetadata("1300", "The identifier provided in obsoletes does not match old Identifier");

            	}

                // get the existing system metadata for the object

                SystemMetadata existingSysMeta = getSystemMetadata(session, pid);

                //System.out.println("the archive is "+existingSysMeta.getArchived());

                //Base on documentation, we can't update an archived object:

                //The update operation MUST fail with Exceptions.InvalidRequest on objects that have the Types.SystemMetadata.archived property set to true.

                if(existingSysMeta.getArchived() != null && existingSysMeta.getArchived()) {

                    throw new InvalidRequest("1202","An archived object"+pid.getValue()+" can't be updated");

                // check for previous update

                // see: https://redmine.dataone.org/issues/3336

                Identifier existingObsoletedBy = existingSysMeta.getObsoletedBy();

                if (existingObsoletedBy != null) {

                	throw new InvalidRequest("1202", 

                			"The previous identifier has already been made obsolete by: " + existingObsoletedBy.getValue());

                }

                //check the sid in the system metadata. If it exists, it should be non-exist or match the old sid in the previous system metadata.

                Identifier sidInSys = sysmeta.getSeriesId();

                if(sidInSys != null) {

                    if (!isValidIdentifier(sidInSys)) {

                        throw new InvalidSystemMetadata("1300", "The provided series id in the system metadata is invalid.");

                    }

                    Identifier previousSid = existingSysMeta.getSeriesId();

                    if(previousSid != null) {

                        // there is a previous sid, if the new sid doesn't match it, the new sid should be non-existing.

                        if(!sidInSys.getValue().equals(previousSid.getValue())) {

                            try {

                                idExists = IdentifierManager.getInstance().identifierExists(sidInSys.getValue());

                            } catch (SQLException e) {

                                throw new ServiceFailure("1310", 

                                                        "The requested identifier " + sidInSys.getValue() +

                                                        " couldn't be determined if it is unique since : "+e.getMessage());

                            }

                            if(idExists) {

                                throw new InvalidSystemMetadata("1300", "The series id "+sidInSys.getValue()+" in the system metadata doesn't match the previous series id "

                                                                +previousSid.getValue()+", so it should NOT exist. However, it was used by another object.");

                            }

                        }

                    } else {

                        // there is no previous sid, the new sid should be non-existing.

                            throw new InvalidSystemMetadata("1300", "The series id "+sidInSys.getValue()+" in the system metadata should NOT exist since the previous series id is null."

                                                            +"However, it was used by another object.");

                    //the series id equals the pid (new pid hasn't been registered in the system, so IdentifierManager.getInstance().identifierExists method can't exclude this scenario)

                    if(sidInSys.getValue().equals(newPid.getValue())) {

                        throw new InvalidSystemMetadata("1300", "The series id "+sidInSys.getValue()+" in the system metadata shouldn't have the same value of the pid.");

                isScienceMetadata = isScienceMetadata(sysmeta);

                // do we have XML metadata or a data object?

                if (isScienceMetadata) {

                    // update the science metadata XML document

                    // TODO: handle non-XML metadata/data documents (like netCDF)

                    // TODO: don't put objects into memory using stream to string

                    //String objectAsXML = "";

                    try {

                        //objectAsXML = IOUtils.toString(object, "UTF-8");

                    	String formatId = null;

                    	if(sysmeta.getFormatId() != null) {

                    	    formatId = sysmeta.getFormatId().getValue();

                    	}

                        localId = insertOrUpdateDocument(object, "UTF-8", pid, session, "update", formatId);

                        // register the newPid and the generated localId

                        if (newPid != null) {

                            IdentifierManager.getInstance().createMapping(newPid.getValue(), localId);

                        }

                    } catch (IOException e) {

                        String msg = "The Node is unable to create the object. " + "There was a problem converting the object to XML";

                        logMetacat.info(msg);

                        throw new ServiceFailure("1310", msg + ": " + e.getMessage());

                } else {

                    // update the data object

                    localId = insertDataObject(object, newPid, session);

                // add the newPid to the obsoletedBy list for the existing sysmeta

                existingSysMeta.setObsoletedBy(newPid);

                //increase version

                BigInteger current = existingSysMeta.getSerialVersion();

                //System.out.println("the current version is "+current);

                current = current.add(BigInteger.ONE);

                //System.out.println("the new current version is "+current);

                existingSysMeta.setSerialVersion(current);

                // then update the existing system metadata

                updateSystemMetadata(existingSysMeta);

                // prep the new system metadata, add pid to the affected lists

                sysmeta.setObsoletes(pid);

                //sysmeta.addDerivedFrom(pid);

                // and insert the new system metadata

                insertSystemMetadata(sysmeta);

                // log the update event

                EventLog.getInstance().log(request.getRemoteAddr(), request.getHeader("User-Agent"), subject.getValue(), localId, Event.UPDATE.toString());

                // attempt to register the identifier - it checks if it is a doi

                try {

        			DOIService.getInstance().registerDOI(sysmeta);

        		} catch (Exception e) {

                    throw new ServiceFailure("1190", "Could not register DOI: " + e.getMessage());

        		}

                throw new NotAuthorized("1200", "The provided identity does not have " + "permission to UPDATE the object identified by " + pid.getValue()

                        + " on the Member Node.");

        } finally {

            IOUtils.closeQuietly(object);

        Identifier resultPid = null;

        try {

            if(isReadOnlyMode()) {

                throw new ServiceFailure("1190", ReadOnlyChecker.DATAONEERROR);

            // check for null session

            if (session == null) {

              throw new InvalidToken("1110", "Session is required to WRITE to the Node.");

            // verify the pid is valid format

            if (!isValidIdentifier(pid)) {

                throw new InvalidRequest("1102", "The provided identifier is invalid.");

            // set the submitter to match the certificate

            sysmeta.setSubmitter(session.getSubject());

            // set the originating node

            NodeReference originMemberNode = this.getCapabilities().getIdentifier();

            sysmeta.setOriginMemberNode(originMemberNode);

            // if no authoritative MN, set it to the same

            if (sysmeta.getAuthoritativeMemberNode() == null) {

            	sysmeta.setAuthoritativeMemberNode(originMemberNode);

            sysmeta.setArchived(false);

            // set the dates

            Date now = Calendar.getInstance().getTime();

            sysmeta.setDateSysMetadataModified(now);

            sysmeta.setDateUploaded(now);

            // set the serial version

            sysmeta.setSerialVersion(BigInteger.ZERO);

            // check that we are not attempting to subvert versioning

            if (sysmeta.getObsoletes() != null && sysmeta.getObsoletes().getValue() != null) {

                throw new InvalidSystemMetadata("1180", 

                  "The supplied system metadata is invalid. " +

                  "The obsoletes field cannot have a value when creating entries.");

            }

            if (sysmeta.getObsoletedBy() != null && sysmeta.getObsoletedBy().getValue() != null) {

                throw new InvalidSystemMetadata("1180", 

                  "The supplied system metadata is invalid. " +

                  "The obsoletedBy field cannot have a value when creating entries.");

            }

            // verify the sid in the system metadata

            Identifier sid = sysmeta.getSeriesId();

            boolean idExists = false;

            if(sid != null) {

                if (!isValidIdentifier(sid)) {

                    throw new InvalidSystemMetadata("1180", "The provided series id is invalid.");

                }

                try {

                    idExists = IdentifierManager.getInstance().identifierExists(sid.getValue());

                } catch (SQLException e) {

                    throw new ServiceFailure("1190", 

                                            "The series identifier " + sid.getValue() +

                                            " in the system metadata couldn't be determined if it is unique since : "+e.getMessage());

                }

                if (idExists) {

                        throw new InvalidSystemMetadata("1180", 

                                  "The series identifier " + sid.getValue() +

                                  " is already used by another object and" +

                                  "therefore can not be used for this object. Clients should choose" +

                                  "a new identifier that is unique and retry the operation or " +

                                  "use CN.reserveIdentifier() to reserve one.");

                }

                //the series id equals the pid (new pid hasn't been registered in the system, so IdentifierManager.getInstance().identifierExists method can't exclude this scenario )

                if(sid.getValue().equals(pid.getValue())) {

                    throw new InvalidSystemMetadata("1180", "The series id "+sid.getValue()+" in the system metadata shouldn't have the same value of the pid.");

                }

            }

            // call the shared impl

            resultPid = super.create(session, pid, object, sysmeta);

            // attempt to register the identifier - it checks if it is a doi

            try {

    			DOIService.getInstance().registerDOI(sysmeta);

    		} catch (Exception e) {

    			ServiceFailure sf = new ServiceFailure("1190", "Could not register DOI: " + e.getMessage());

    			sf.initCause(e);

                throw sf;

    		}

        } finally {

            IOUtils.closeQuietly(object);

					return isNodeAdmin(session);

            	if ( userHasPermission(session, pid, permission) ) {

                    allow = true;

                } else {

                    allow = false;

                }