Java tutorial
/* * #%L * Alfresco Repository * %% * Copyright (C) 2005 - 2016 Alfresco Software Limited * %% * This file is part of the Alfresco software. * If the software was purchased under a paid Alfresco license, the terms of * the paid license agreement will prevail. Otherwise, the software is * provided under the following open source license terms: * * Alfresco is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Alfresco is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * #L% */ package org.alfresco.filesys; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.PrintWriter; import java.io.Reader; import java.io.StringWriter; import junit.framework.TestCase; import org.alfresco.jlan.ftp.FTPConfigSection; import org.alfresco.jlan.server.config.ServerConfigurationAccessor; import org.alfresco.model.ContentModel; import org.alfresco.repo.model.Repository; import org.alfresco.repo.security.authentication.AuthenticationComponent; import org.alfresco.repo.transaction.RetryingTransactionHelper; import org.alfresco.repo.transaction.RetryingTransactionHelper.RetryingTransactionCallback; import org.alfresco.repo.usage.ContentUsageImpl; import org.alfresco.repo.usage.UserUsageTrackingComponent; import org.alfresco.service.cmr.repository.NodeRef; import org.alfresco.service.cmr.repository.NodeService; import org.alfresco.service.cmr.security.MutableAuthenticationService; import org.alfresco.service.cmr.security.PermissionService; import org.alfresco.service.cmr.security.PersonService; import org.alfresco.service.transaction.TransactionService; import org.alfresco.test_category.BaseSpringTestsCategory; import org.alfresco.util.ApplicationContextHelper; import org.alfresco.util.PropertyMap; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.commons.net.PrintCommandListener; import org.apache.commons.net.ftp.FTPClient; import org.apache.commons.net.ftp.FTPFile; import org.apache.commons.net.ftp.FTPReply; import org.junit.experimental.categories.Category; import org.springframework.context.ApplicationContext; /** * End to end JUNIT test of the FTP server * * Uses the commons-net ftp client library to connect to the * Alfresco FTP server. */ @Category(BaseSpringTestsCategory.class) public class FTPServerTest extends TestCase { private static Log logger = LogFactory.getLog(FTPServerTest.class); private ApplicationContext applicationContext; private final String USER_ADMIN = "admin"; private final String PASSWORD_ADMIN = "admin"; private final String USER_ONE = "FTPServerTestOne"; private final String USER_TWO = "FTPServerTestTwo"; private final String USER_THREE = "FTPServerTestThree"; private final String PASSWORD_ONE = "Password01"; private final String PASSWORD_TWO = "Password02"; private final String PASSWORD_THREE = "Password03"; private final String HOSTNAME = "localhost"; private NodeService nodeService; private PersonService personService; private MutableAuthenticationService authenticationService; private AuthenticationComponent authenticationComponent; private TransactionService transactionService; private Repository repositoryHelper; private PermissionService permissionService; private FTPConfigSection ftpConfigSection; @Override protected void setUp() throws Exception { applicationContext = ApplicationContextHelper.getApplicationContext(); nodeService = (NodeService) applicationContext.getBean("nodeService"); personService = (PersonService) applicationContext.getBean("personService"); authenticationService = (MutableAuthenticationService) applicationContext.getBean("AuthenticationService"); authenticationComponent = (AuthenticationComponent) applicationContext.getBean("authenticationComponent"); transactionService = (TransactionService) applicationContext.getBean("transactionService"); repositoryHelper = (Repository) applicationContext.getBean("repositoryHelper"); permissionService = (PermissionService) applicationContext.getBean("permissionService"); ServerConfigurationAccessor fileServerConfiguration = (ServerConfigurationAccessor) applicationContext .getBean("fileServerConfiguration"); ftpConfigSection = (FTPConfigSection) fileServerConfiguration .getConfigSection(FTPConfigSection.SectionName); assertNotNull("nodeService is null", nodeService); assertNotNull("reporitoryHelper is null", repositoryHelper); assertNotNull("personService is null", personService); assertNotNull("authenticationService is null", authenticationService); assertNotNull("authenticationComponent is null", authenticationComponent); authenticationComponent.setSystemUserAsCurrentUser(); final RetryingTransactionHelper tran = transactionService.getRetryingTransactionHelper(); RetryingTransactionCallback<Void> createUsersCB = new RetryingTransactionCallback<Void>() { @Override public Void execute() throws Throwable { createUser(USER_ONE, PASSWORD_ONE, -1); createUser(USER_TWO, PASSWORD_TWO, -1); createUser(USER_THREE, PASSWORD_THREE, 30); return null; } }; tran.doInTransaction(createUsersCB); RetryingTransactionCallback<Void> createTestDirCB = new RetryingTransactionCallback<Void>() { @Override public Void execute() throws Throwable { { NodeRef userOneHome = repositoryHelper.getUserHome(personService.getPerson(USER_ONE)); permissionService.setPermission(userOneHome, USER_TWO, PermissionService.CONTRIBUTOR, true); permissionService.setPermission(userOneHome, USER_TWO, PermissionService.WRITE, true); } return null; } }; tran.doInTransaction(createTestDirCB, false, true); } protected void tearDown() throws Exception { // UserTransaction txn = transactionService.getUserTransaction(); // assertNotNull("transaction leaked", txn); // txn.getStatus(); // txn.rollback(); } /** * Simple test that connects to the inbuilt ftp server and logs on * * @throws Exception */ public void testFTPConnect() throws Exception { logger.debug("Start testFTPConnect"); FTPClient ftp = connectClient(); try { int reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } boolean login = ftp.login(USER_ADMIN, PASSWORD_ADMIN); assertTrue("admin login not successful", login); } finally { ftp.disconnect(); } } /** * Simple negative test that connects to the inbuilt ftp server and attempts to * log on with the wrong password. * * @throws Exception */ public void testFTPConnectNegative() throws Exception { logger.debug("Start testFTPConnectNegative"); FTPClient ftp = connectClient(); try { int reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } boolean login = ftp.login(USER_ADMIN, "garbage"); assertFalse("admin login successful", login); // now attempt to list the files and check that the command does not // succeed FTPFile[] files = ftp.listFiles(); assertNotNull(files); assertTrue(files.length == 0); reply = ftp.getReplyCode(); assertTrue(FTPReply.isNegativePermanent(reply)); } finally { ftp.disconnect(); } } /** * Test CWD for FTP server * * @throws Exception */ public void testCWD() throws Exception { logger.debug("Start testCWD"); FTPClient ftp = connectClient(); try { int reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } boolean login = ftp.login(USER_ADMIN, PASSWORD_ADMIN); assertTrue("admin login successful", login); FTPFile[] files = ftp.listFiles(); reply = ftp.getReplyCode(); assertTrue(FTPReply.isPositiveCompletion(reply)); assertTrue(files.length == 1); boolean foundAlfresco = false; for (FTPFile file : files) { logger.debug("file name=" + file.getName()); assertTrue(file.isDirectory()); if (file.getName().equalsIgnoreCase("Alfresco")) { foundAlfresco = true; } } assertTrue(foundAlfresco); // Change to Alfresco Dir that we know exists reply = ftp.cwd("/Alfresco"); assertTrue(FTPReply.isPositiveCompletion(reply)); // relative path with space char reply = ftp.cwd("Data Dictionary"); assertTrue(FTPReply.isPositiveCompletion(reply)); // non existant absolute reply = ftp.cwd("/Garbage"); assertTrue(FTPReply.isNegativePermanent(reply)); reply = ftp.cwd("/Alfresco/User Homes"); assertTrue(FTPReply.isPositiveCompletion(reply)); // Wild card reply = ftp.cwd("/Alfresco/User*Homes"); assertTrue("unable to change to /Alfresco User*Homes/", FTPReply.isPositiveCompletion(reply)); // // Single char pattern match // reply = ftp.cwd("/Alfre?co"); // assertTrue("Unable to match single char /Alfre?co", FTPReply.isPositiveCompletion(reply)); // two level folder reply = ftp.cwd("/Alfresco/Data Dictionary"); assertTrue("unable to change to /Alfresco/Data Dictionary", FTPReply.isPositiveCompletion(reply)); // go up one reply = ftp.cwd(".."); assertTrue("unable to change to ..", FTPReply.isPositiveCompletion(reply)); reply = ftp.pwd(); ftp.getStatus(); assertTrue("unable to get status", FTPReply.isPositiveCompletion(reply)); // check we are at the correct point in the tree reply = ftp.cwd("Data Dictionary"); assertTrue(FTPReply.isPositiveCompletion(reply)); } finally { ftp.disconnect(); } } /** * Test CRUD for FTP server * * @throws Exception */ public void testCRUD() throws Exception { final String PATH1 = "FTPServerTest"; final String PATH2 = "Second part"; logger.debug("Start testFTPCRUD"); FTPClient ftp = connectClient(); try { int reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } boolean login = ftp.login(USER_ADMIN, PASSWORD_ADMIN); assertTrue("admin login successful", login); reply = ftp.cwd("/Alfresco/User Homes"); assertTrue(FTPReply.isPositiveCompletion(reply)); // Delete the root directory in case it was left over from a previous test run try { ftp.removeDirectory(PATH1); } catch (IOException e) { // ignore this error } // make root directory ftp.makeDirectory(PATH1); ftp.cwd(PATH1); // make sub-directory in new directory ftp.makeDirectory(PATH2); ftp.cwd(PATH2); // List the files in the new directory FTPFile[] files = ftp.listFiles(); assertTrue("files not empty", files.length == 0); // Create a file String FILE1_CONTENT_1 = "test file 1 content"; String FILE1_NAME = "testFile1.txt"; ftp.appendFile(FILE1_NAME, new ByteArrayInputStream(FILE1_CONTENT_1.getBytes("UTF-8"))); // Get the new file FTPFile[] files2 = ftp.listFiles(); assertTrue("files not one", files2.length == 1); InputStream is = ftp.retrieveFileStream(FILE1_NAME); String content = inputStreamToString(is); assertEquals("Content is not as expected", content, FILE1_CONTENT_1); ftp.completePendingCommand(); // Update the file contents String FILE1_CONTENT_2 = "That's how it is says Pooh!"; ftp.storeFile(FILE1_NAME, new ByteArrayInputStream(FILE1_CONTENT_2.getBytes("UTF-8"))); InputStream is2 = ftp.retrieveFileStream(FILE1_NAME); String content2 = inputStreamToString(is2); assertEquals("Content is not as expected", FILE1_CONTENT_2, content2); ftp.completePendingCommand(); // now delete the file we have been using. assertTrue(ftp.deleteFile(FILE1_NAME)); // negative test - file should have gone now. assertFalse(ftp.deleteFile(FILE1_NAME)); } finally { // clean up tree if left over from previous run ftp.disconnect(); } } /** * Test of obscure path names in the FTP server * * RFC959 states that paths are constructed thus... * <string> ::= <char> | <char><string> * <pathname> ::= <string> * <char> ::= any of the 128 ASCII characters except <CR> and <LF> * * So we need to check how high characters and problematic are encoded */ public void testPathNames() throws Exception { logger.debug("Start testPathNames"); FTPClient ftp = connectClient(); String PATH1 = "testPathNames"; try { int reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } boolean login = ftp.login(USER_ADMIN, PASSWORD_ADMIN); assertTrue("admin login successful", login); reply = ftp.cwd("/Alfresco/User*Homes"); assertTrue(FTPReply.isPositiveCompletion(reply)); // Delete the root directory in case it was left over from a previous test run try { ftp.removeDirectory(PATH1); } catch (IOException e) { // ignore this error } // make root directory for this test boolean success = ftp.makeDirectory(PATH1); assertTrue("unable to make directory:" + PATH1, success); success = ftp.changeWorkingDirectory(PATH1); assertTrue("unable to change to working directory:" + PATH1, success); assertTrue("with a space", ftp.makeDirectory("test space")); assertTrue("with exclamation", ftp.makeDirectory("space!")); assertTrue("with dollar", ftp.makeDirectory("space$")); assertTrue("with brackets", ftp.makeDirectory("space()")); assertTrue("with hash curley brackets", ftp.makeDirectory("space{}")); //Pound sign U+00A3 //Yen Sign U+00A5 //Capital Omega U+03A9 assertTrue("with pound sign", ftp.makeDirectory("pound \u00A3.world")); assertTrue("with yen sign", ftp.makeDirectory("yen \u00A5.world")); // Test steps that do not work // assertTrue("with omega", ftp.makeDirectory("omega \u03A9.world")); // assertTrue("with obscure ASCII chars", ftp.makeDirectory("?/.,<>")); } finally { // clean up tree if left over from previous run ftp.disconnect(); } } /** * Test of rename case ALF-20584 * */ public void testRenameCase() throws Exception { logger.debug("Start testRenameCase"); FTPClient ftp = connectClient(); String PATH1 = "testRenameCase"; try { int reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } boolean login = ftp.login(USER_ADMIN, PASSWORD_ADMIN); assertTrue("admin login successful", login); reply = ftp.cwd("/Alfresco/User*Homes"); assertTrue(FTPReply.isPositiveCompletion(reply)); // Delete the root directory in case it was left over from a previous test run try { ftp.removeDirectory(PATH1); } catch (IOException e) { // ignore this error } // make root directory for this test boolean success = ftp.makeDirectory(PATH1); assertTrue("unable to make directory:" + PATH1, success); ftp.cwd(PATH1); String FILE1_CONTENT_2 = "That's how it is says Pooh!"; ftp.storeFile("FileA.txt", new ByteArrayInputStream(FILE1_CONTENT_2.getBytes("UTF-8"))); assertTrue("unable to rename", ftp.rename("FileA.txt", "FILEA.TXT")); } finally { // clean up tree if left over from previous run ftp.disconnect(); } } // test Rename Case /** * Create a user other than "admin" who has access to a set of files. * * Create a folder containing test.docx as user one * Update that file as user two. * Check user one can see user two's changes. * * @throws Exception */ public void testTwoUserUpdate() throws Exception { logger.debug("Start testFTPConnect"); final String TEST_DIR = "/Alfresco/User Homes/" + USER_ONE; FTPClient ftpOne = connectClient(); FTPClient ftpTwo = connectClient(); try { int reply = ftpOne.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } reply = ftpTwo.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } boolean login = ftpOne.login(USER_ONE, PASSWORD_ONE); assertTrue("user one login not successful", login); login = ftpTwo.login(USER_TWO, PASSWORD_TWO); assertTrue("user two login not successful", login); boolean success = ftpOne.changeWorkingDirectory("Alfresco"); assertTrue("user one unable to cd to Alfreco", success); success = ftpOne.changeWorkingDirectory("User*Homes"); assertTrue("user one unable to cd to User*Homes", success); success = ftpOne.changeWorkingDirectory(USER_ONE); assertTrue("user one unable to cd to " + USER_ONE, success); success = ftpTwo.changeWorkingDirectory("Alfresco"); assertTrue("user two unable to cd to Alfreco", success); success = ftpTwo.changeWorkingDirectory("User*Homes"); assertTrue("user two unable to cd to User*Homes", success); success = ftpTwo.changeWorkingDirectory(USER_ONE); assertTrue("user two unable to cd " + USER_ONE, success); // Create a file as user one String FILE1_CONTENT_1 = "test file 1 content"; String FILE1_NAME = "test.docx"; success = ftpOne.appendFile(FILE1_NAME, new ByteArrayInputStream(FILE1_CONTENT_1.getBytes("UTF-8"))); assertTrue("user one unable to append file", success); // Update the file as user two String FILE1_CONTENT_2 = "test file content updated"; success = ftpTwo.storeFile(FILE1_NAME, new ByteArrayInputStream(FILE1_CONTENT_2.getBytes("UTF-8"))); assertTrue("user two unable to append file", success); // User one should read user2's content InputStream is1 = ftpOne.retrieveFileStream(FILE1_NAME); assertNotNull("is1 is null", is1); String content1 = inputStreamToString(is1); assertEquals("Content is not as expected", FILE1_CONTENT_2, content1); ftpOne.completePendingCommand(); // User two should read user2's content InputStream is2 = ftpTwo.retrieveFileStream(FILE1_NAME); assertNotNull("is2 is null", is2); String content2 = inputStreamToString(is2); assertEquals("Content is not as expected", FILE1_CONTENT_2, content2); ftpTwo.completePendingCommand(); logger.debug("Test finished"); } finally { ftpOne.dele(TEST_DIR); if (ftpOne != null) { ftpOne.disconnect(); } if (ftpTwo != null) { ftpTwo.disconnect(); } } } /** * Test a quota failue exception over FTP. * A file should not exist after a create and quota exception. */ public void testFtpQuotaAndFtp() throws Exception { // Enable usages ContentUsageImpl contentUsage = (ContentUsageImpl) applicationContext.getBean("contentUsageImpl"); contentUsage.setEnabled(true); contentUsage.init(); UserUsageTrackingComponent userUsageTrackingComponent = (UserUsageTrackingComponent) applicationContext .getBean("userUsageTrackingComponent"); userUsageTrackingComponent.setEnabled(true); userUsageTrackingComponent.bootstrapInternal(); final String TEST_DIR = "/Alfresco/User Homes/" + USER_THREE; FTPClient ftpOne = connectClient(); try { int reply = ftpOne.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } boolean login = ftpOne.login(USER_THREE, PASSWORD_THREE); assertTrue("user three login not successful", login); boolean success = ftpOne.changeWorkingDirectory("Alfresco"); assertTrue("user three unable to cd to Alfreco", success); success = ftpOne.changeWorkingDirectory("User*Homes"); assertTrue("user one unable to cd to User*Homes", success); success = ftpOne.changeWorkingDirectory(USER_THREE); assertTrue("user one unable to cd to " + USER_THREE, success); /** * Create a file as user three which is bigger than the quota */ String FILE3_CONTENT_3 = "test file 3 content that needs to be greater than 100 bytes to result in a quota exception being thrown"; String FILE1_NAME = "test.docx"; // Should not be success success = ftpOne.appendFile(FILE1_NAME, new ByteArrayInputStream(FILE3_CONTENT_3.getBytes("UTF-8"))); assertFalse("user one can ignore quota", success); boolean deleted = ftpOne.deleteFile(FILE1_NAME); assertFalse("quota exception expected", deleted); logger.debug("test done"); } finally { // Disable usages contentUsage.setEnabled(false); contentUsage.init(); userUsageTrackingComponent.setEnabled(false); userUsageTrackingComponent.bootstrapInternal(); ftpOne.dele(TEST_DIR); if (ftpOne != null) { ftpOne.disconnect(); } } } /** * Test Setting the modification time FTP server * * @throws Exception */ public void testModificationTime() throws Exception { final String PATH1 = "FTPServerTest"; final String PATH2 = "ModificationTime"; logger.debug("Start testModificationTime"); FTPClient ftp = connectClient(); try { int reply = ftp.getReplyCode(); if (!FTPReply.isPositiveCompletion(reply)) { fail("FTP server refused connection."); } boolean login = ftp.login(USER_ADMIN, PASSWORD_ADMIN); assertTrue("admin login successful", login); reply = ftp.cwd("/Alfresco/User Homes"); assertTrue(FTPReply.isPositiveCompletion(reply)); // Delete the root directory in case it was left over from a previous test run try { ftp.removeDirectory(PATH1); } catch (IOException e) { // ignore this error } // make root directory ftp.makeDirectory(PATH1); ftp.cwd(PATH1); // make sub-directory in new directory ftp.makeDirectory(PATH2); ftp.cwd(PATH2); // List the files in the new directory FTPFile[] files = ftp.listFiles(); assertTrue("files not empty", files.length == 0); // Create a file String FILE1_CONTENT_1 = "test file 1 content"; String FILE1_NAME = "testFile1.txt"; ftp.appendFile(FILE1_NAME, new ByteArrayInputStream(FILE1_CONTENT_1.getBytes("UTF-8"))); String pathname = "/Alfresco/User Homes" + "/" + PATH1 + "/" + PATH2 + "/" + FILE1_NAME; logger.debug("set modification time"); // YYYYMMDDhhmmss Time set to 2012 August 30 12:39:05 String olympicTime = "20120830123905"; ftp.setModificationTime(pathname, olympicTime); String extractedTime = ftp.getModificationTime(pathname); // Feature of the commons ftp library ExtractedTime has a "status code" first and is followed by newline chars assertTrue("time not set correctly by explicit set time", extractedTime.contains(olympicTime)); // Get the new file FTPFile[] files2 = ftp.listFiles(); assertTrue("files not one", files2.length == 1); InputStream is = ftp.retrieveFileStream(FILE1_NAME); String content = inputStreamToString(is); assertEquals("Content is not as expected", content, FILE1_CONTENT_1); ftp.completePendingCommand(); // Update the file contents without setting time directly String FILE1_CONTENT_2 = "That's how it is says Pooh!"; ftp.storeFile(FILE1_NAME, new ByteArrayInputStream(FILE1_CONTENT_2.getBytes("UTF-8"))); InputStream is2 = ftp.retrieveFileStream(FILE1_NAME); String content2 = inputStreamToString(is2); assertEquals("Content is not as expected", FILE1_CONTENT_2, content2); ftp.completePendingCommand(); extractedTime = ftp.getModificationTime(pathname); assertFalse("time not moved on if time not explicitly set", extractedTime.contains(olympicTime)); // now delete the file we have been using. assertTrue(ftp.deleteFile(FILE1_NAME)); // negative test - file should have gone now. assertFalse(ftp.deleteFile(FILE1_NAME)); } finally { // clean up tree if left over from previous run ftp.disconnect(); } } // test set time /** * Create a user with a small quota. * * Upload a file less than the quota. * * Upload a file greater than the quota. * * @throws Exception */ public void DISABLED_testQuota() throws Exception { fail("not yet implemented"); } private FTPClient connectClient() throws IOException { FTPClient ftp = new FTPClient(); if (logger.isDebugEnabled()) { ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out))); } ftp.connect(HOSTNAME, ftpConfigSection.getFTPPort()); return ftp; } /** * Test quality utility to read an input stream into a string. * @param is * @return the content of the stream in a string. * @throws IOException */ private String inputStreamToString(InputStream is) throws IOException { if (is != null) { StringWriter writer = new StringWriter(); char[] buffer = new char[1024]; try { Reader reader = new BufferedReader(new InputStreamReader(is, "UTF-8")); int n; while ((n = reader.read(buffer)) != -1) { writer.write(buffer, 0, n); } } finally { is.close(); } is.close(); return writer.getBuffer().toString(); } return ""; } /** * create a test user * @param userName * @param password * @param quota */ private void createUser(String userName, String password, long quota) { if (this.authenticationService.authenticationExists(userName) == false) { this.authenticationService.createAuthentication(userName, password.toCharArray()); PropertyMap ppOne = new PropertyMap(4); ppOne.put(ContentModel.PROP_USERNAME, userName); ppOne.put(ContentModel.PROP_FIRSTNAME, "firstName"); ppOne.put(ContentModel.PROP_LASTNAME, "lastName"); ppOne.put(ContentModel.PROP_EMAIL, "email@email.com"); ppOne.put(ContentModel.PROP_JOBTITLE, "jobTitle"); if (quota > 0) { ppOne.put(ContentModel.PROP_SIZE_QUOTA, quota); } this.personService.createPerson(ppOne); } } }