public boolean addPrivilege(Privilege aPrivilege) { boolean wasAdded = false; if (privileges.contains(aPrivilege)) { return false; } if (privileges.contains(aPrivilege)) { return false; } if (privileges.contains(aPrivilege)) { return false; } Employee existingEmployee = aPrivilege.getEmployee(); boolean isNewEmployee = existingEmployee != null && !this.equals(existingEmployee); if (isNewEmployee && existingEmployee.numberOfPrivileges() <= minimumNumberOfPrivileges()) { return wasAdded; } if (isNewEmployee) { aPrivilege.setEmployee(this); } else { privileges.add(aPrivilege); } wasAdded = true; return wasAdded; }
public static void main(String[] args) { try { String fn = args[0]; String ln = args[1]; // Double sal = Double.parseDouble(args[2]); Double sal = parseSalary(args[2]); Employee empl = new Employee(fn, ln, sal); System.out.println(empl.concatName() + " " + empl.salary); } catch (NumberFormatException e) { System.out.println( "Invalid Argument: " + args[2] + " \n Please provide a numeric value input for salary"); System.exit(0); } catch (ArrayIndexOutOfBoundsException e) { System.out.println( "No Arguments Given: " + "\n Usage: TestEmployee Firstname Lastname Salary "); System.exit(0); } catch (NegativeSalaryException e) { System.out.println( "An error was found in the input data: " + "Details are: " + e.getMessage()); } catch (Exception e) { System.out.println("Exception: " + e.getMessage()); e.printStackTrace(); } }
public void test() { // test readAll getSession().readAllObjects(Employee.class); getSession().getIdentityMapAccessor().initializeIdentityMap(Employee.class); // test readObject Employee employee = (Employee) getSession().readObject(Employee.class, new ExpressionBuilder().get("id").equal(99)); // test delete with an employee read from the database employee = (Employee) getSession().readObject(Employee.class); try { getAbstractSession().deleteObject(employee); } catch (DatabaseException exc) { // if we get an integrity exception here, the query went to the DB and was not redirected redirectedDeleteObject = false; } UnitOfWork uow = getSession().acquireUnitOfWork(); // test update with an employee read from the database employee = (Employee) uow.readObject(Employee.class); employee.setFirstName(employee.getFirstName() + "-changed"); // insert an employee to test the insert behavior employee = new Employee(); employee.setFirstName("Paul"); employee.setLastName("Sheldon"); uow.registerObject(employee); uow.commit(); }
@Override public String toString() { String result = "Department " + this.name + ": \nManager: " + this.manager.getName() + "\nEmployees:"; for (Employee e : this.employees) result += "\n" + e.getName(); return result; }
private void createControlObject() { HashMap addresses = new HashMap(); Address address = new Address(); address.id = CONTROL_ADD_ID_1; address.street = CONTROL_ADD_STREET_1; address.city = CONTROL_ADD_CITY_1; address.country = CONTROL_ADD_COUNTRY_1; address.zip = CONTROL_ADD_ZIP_1; addresses.put(address.getKey(), address); address = new Address(); address.id = CONTROL_ADD_ID_2; address.street = CONTROL_ADD_STREET_2; address.city = CONTROL_ADD_CITY_2; address.country = CONTROL_ADD_COUNTRY_2; address.zip = CONTROL_ADD_ZIP_2; addresses.put(address.getKey(), address); address = new Address(); address.id = CONTROL_ADD_ID_3; address.street = CONTROL_ADD_STREET_3; address.city = CONTROL_ADD_CITY_3; address.country = CONTROL_ADD_COUNTRY_3; address.zip = CONTROL_ADD_ZIP_3; addresses.put(address.getKey(), address); Employee employee = new Employee(); employee.id = CONTROL_ID; employee.name = CONTROL_NAME; employee.addresses = addresses; controlObj = new Root(); controlObj.employee = employee; }
public boolean addShift(Shift aShift) { boolean wasAdded = false; if (shifts.contains(aShift)) { return false; } if (shifts.contains(aShift)) { return false; } if (shifts.contains(aShift)) { return false; } Employee existingEmployee = aShift.getEmployee(); boolean isNewEmployee = existingEmployee != null && !this.equals(existingEmployee); if (isNewEmployee && existingEmployee.numberOfShifts() <= minimumNumberOfShifts()) { return wasAdded; } if (isNewEmployee) { aShift.setEmployee(this); } else { shifts.add(aShift); } wasAdded = true; return wasAdded; }
public void setup() { Vector employees = getSomeEmployees(); // Bug 223005: Verify that we have at least 1 employee with the required field length otherwise // an EclipseLinkException will be thrown Employee emp = getEmployeeWithRequiredNameLength(employees, MIN_FIRSTNAME_LENGTH, getName()); String partialFirstName = "%" + emp.getFirstName().substring(0, 3) + "%"; ReadAllQuery raq = new ReadAllQuery(); raq.setReferenceClass(Employee.class); Vector parameters = new Vector(); parameters.add(partialFirstName); ExpressionBuilder eb = new ExpressionBuilder(); Expression whereClause = eb.get("firstName").like(partialFirstName); raq.setSelectionCriteria(whereClause); employees = (Vector) getSession().executeQuery(raq); String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.firstName LIKE ?1"; setEjbqlString(ejbqlString); setOriginalOject(employees); setArguments(parameters); Vector myArgumentNames = new Vector(); myArgumentNames.add("1"); setArgumentNames(myArgumentNames); super.setup(); }
@Override public ArrayList<Employee> getMembers(String uid) { SQLiteDatabase db = null; ArrayList<Employee> employees = new ArrayList<>(); String query = "SELECT * FROM " + TasKingDBNames.MemberEntry.TABLE_NAME + " WHERE manager_id = '" + uid + "'"; try { db = DBHelper.getReadableDatabase(); Cursor cursor = db.rawQuery(query, null); if (cursor.moveToFirst()) { do { Employee employee = new Employee(); employee.setUsername(cursor.getString(0)); employee.setUid(cursor.getString(1)); employee.setManagerId(cursor.getString(2)); employees.add(employee); } while (cursor.moveToNext()); cursor.close(); } return employees; } finally { if (db != null) { db.close(); } } }
public static ProjectParams fromStdIn() throws IOException { BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); int numTeams = Integer.parseInt(in.readLine()); // System.out.println("Reading in " + numTeams + " teams..."); List<Team> teams = new ArrayList<Team>(numTeams); List<Set<Employee>> employees = new ArrayList<Set<Employee>>(NUM_LOCATIONS); employees.add(new HashSet<Employee>()); employees.add(new HashSet<Employee>()); String currLine = in.readLine(); // Could use while on readLine(), but this handles empty lines at the end better for (int currTeam = 0; currTeam < numTeams; currTeam++) { String[] idStrings = currLine.split(" "); assert (idStrings.length == 2); Employee e1 = Employee.getEmployeeFromId(Integer.parseInt(idStrings[0])); Employee e2 = Employee.getEmployeeFromId(Integer.parseInt(idStrings[1])); assert (e1 != e2 && !e1.equals(e2)); employees.get(0).add(e1); employees.get(1).add(e2); teams.add(new Team(e1, e2)); currLine = in.readLine(); } in.close(); assert (teams.size() == uniqueTeams(teams)); return new ProjectParams(teams, employees); }
/** * Tests XmlAnyObjectMapping configuration via eclipselink-oxm.xml. Here an unmarshal operation is * performed. In this case, the 'any' is marked write-only, and should not be read in. * * <p>Positive test. */ public void testAnyObjectWriteOnlyUnmarshal() { // load instance doc String src = PATH + "write-only-employee.xml"; InputStream iDocStream = loader.getResourceAsStream(src); if (iDocStream == null) { fail("Couldn't load instance doc [" + src + "]"); } JAXBContext jCtx = null; try { jCtx = createContext( new Class[] {Employee.class}, CONTEXT_PATH, PATH + "write-only-employee-oxm.xml"); } catch (JAXBException e1) { fail("JAXBContext creation failed: " + e1.getMessage()); } // unmarshal Employee ctrlEmp = getControlObject(); ctrlEmp.stuff = null; Employee eObj = null; Unmarshaller unmarshaller = jCtx.createUnmarshaller(); try { eObj = (Employee) unmarshaller.unmarshal(iDocStream); assertNotNull("Unmarshalled object is null.", eObj); assertTrue("Unmarshal failed: Employee objects are not equal", ctrlEmp.equals(eObj)); } catch (JAXBException e) { e.printStackTrace(); fail("Unmarshal operation failed."); } }
public void delete() { Employee placeholderEmployee = employee; this.employee = null; placeholderEmployee.removeAccident(this); accidentType = null; seriousnessLevel = null; }
protected void clear() { UnitOfWork uow = acquireUnitOfWork(); // use alternate way for Symfoware as it doesn't support UpdateAll/DeleteAll on multi-table // objects (see rfe 298193) if (!(JUnitTestCase.getServerSession("fieldaccess")).getPlatform().isSymfoware()) { UpdateAllQuery updateEmployees = new UpdateAllQuery(Employee.class); updateEmployees.addUpdate("manager", null); updateEmployees.addUpdate("address", null); uow.executeQuery(updateEmployees); uow.executeQuery(new DeleteAllQuery(Employee.class)); } else { Iterator<Employee> emps = uow.readAllObjects(Employee.class).iterator(); while (emps.hasNext()) { Employee emp = emps.next(); emp.setManager(null); emp.setAddress(null); uow.deleteObject(emp); } ; } UpdateAllQuery updateProjects = new UpdateAllQuery(Project.class); updateProjects.addUpdate("teamLeader", null); uow.executeQuery(updateProjects); uow.executeQuery(new DeleteAllQuery(PhoneNumber.class)); uow.executeQuery(new DeleteAllQuery(Address.class)); uow.executeQuery(new DeleteAllQuery(Project.class)); uow.commit(); dbSessionClearCache(); }
protected Object getControlObject() { Employee employee = new Employee(); employee.setIdentifier(CONTROL_ID); employee.setFirstName(CONTROL_FIRST_NAME); employee.setLastName(CONTROL_LAST_NAME); return employee; }
/** @param args */ public static void main(String[] args) throws Exception { Employee e = new HourlyEmployee(); Class c = e.getClass(); Method m = c.getMethod("print", null); m.invoke(e, null); }
protected void buildExpectedResults() { ReadAllQuery query = new ReadAllQuery(); query.setReferenceClass(Employee.class); Vector employees = (Vector) getSession().executeQuery(query); Vector distinctEmployees = new Vector(); // initialize distinctEmployees distinctEmployees.addElement(employees.elementAt(0)); // check employees with duplicate province and add only distinct employees to distinctEmployees for (int i = 1; i < employees.size(); i++) { boolean duplicateFound = false; // iterate through distinctEmployees to check for duplicate provinces, if found, employee not // added for (int j = 0; j < distinctEmployees.size(); j++) { if ((((Employee) employees.elementAt(i)).getAddress().getProvince()) .equals((((Employee) distinctEmployees.elementAt(j)).getAddress().getProvince()))) { duplicateFound = true; } } if (!duplicateFound) { distinctEmployees.addElement(employees.elementAt(i)); } } for (Enumeration e = distinctEmployees.elements(); e.hasMoreElements(); ) { Employee emp = (Employee) e.nextElement(); Object[] result = new Object[1]; result[0] = emp.getAddress().getProvince(); addResult(result, null); } }
public Object mapRow(ResultSet rs, int rowNum) throws SQLException { Employee employee = new Employee(); employee.setEmployee_id(rs.getInt("EMPLOYEE_ID")); employee.setFirst_name(rs.getString("FIRST_NAME")); employee.setJob_id(rs.getString("JOB_ID")); return employee; }
/** * Return the first employee that has a long enough name for the test. If no match is found throw * a warning exception. See bug 223005 * * @param vectorOfEmployees * @param minFirstNameLength * @param testName * @return */ public Employee getEmployeeWithRequiredNameLength( Vector vectorOfEmployees, int minFirstNameLength, String testName) { Employee empMatch = null; Vector<Employee> employees = vectorOfEmployees; String firstName; StringBuffer partialFirstName; // Loop through the collection of employees to find one that matches our test requirements for (int i = 0; i < employees.size(); i++) { empMatch = employees.get(i); firstName = empMatch.getFirstName(); // Verify length criteria if (firstName.length() >= minFirstNameLength) { // exit the for loop - return the last empMatch i = employees.size(); } } // If we could not find a proper employee for testing - throw a warning if (null == empMatch) { throw new RuntimeException( testName + " Setup Failed: unable to find an Employee with firstName size of at least " + minFirstNameLength); } else { return empMatch; } }
@Override public int compareTo(Object o) { String thisName = this.name; Employee that = (Employee) o; String thatName = that.getName(); return thisName.compareTo(thatName); }
public static SelfEmployee valueOf(Employee employee) { SelfEmployee selfEmployee = new SelfEmployee(); selfEmployee.setFirstName(employee.getFirstName()); selfEmployee.setLastName(employee.getLastName()); selfEmployee.setPhoneNumber(employee.getPhoneNumber()); return selfEmployee; }
/** * Tests XmlDirectCollectionMapping configuration via eclipselink-oxm.xml. Here an unmarshal * operation is performed. * * <p>Positive test. */ public void testDirectCollectionUnmarshal() { // load instance doc String src = PATH + "employee.xml"; InputStream iDocStream = loader.getResourceAsStream(src); if (iDocStream == null) { fail("Couldn't load instance doc [" + src + "]"); } // tweak control object Employee ctrlEmp = getControlObject(); // unmarshal null will result in "" being set in the object ctrlEmp.projectIds.remove(1); ctrlEmp.projectIds.add(1, ""); // 'privateData' is write only ctrlEmp.privateData = null; try { Employee empObj = (Employee) jaxbContext.createUnmarshaller().unmarshal(iDocStream); assertNotNull("Unmarshalled object is null.", empObj); assertTrue("Accessor method was not called as expected", empObj.wasSetCalled); assertTrue("Unmarshal failed: Employee objects are not equal", ctrlEmp.equals(empObj)); } catch (JAXBException e) { e.printStackTrace(); fail("Unmarshal operation failed."); } }
public void populate(DatabaseSession session) { Employee instance; PopulationManager manager = PopulationManager.getDefaultManager(); instance = Employee.example1(); session.writeObject(instance); manager.registerObject(instance, "example1"); manager.registerObject(instance.computer, "example1"); manager.registerObject(instance.shipments.firstElement(), "example1"); manager.registerObject( ((Shipment) instance.shipments.firstElement()).orders.firstElement(), "example1"); instance = Employee.example2(); session.writeObject(instance); manager.registerObject(instance, "example2"); manager.registerObject(instance.computer, "example2"); manager.registerObject(instance.shipments.firstElement(), "example2"); manager.registerObject( ((Shipment) instance.shipments.firstElement()).orders.firstElement(), "example2"); instance = Employee.example3(); session.writeObject(instance); manager.registerObject(instance, "example3"); manager.registerObject(instance.computer, "example3"); manager.registerObject(instance.shipments.firstElement(), "example3"); manager.registerObject( ((Shipment) instance.shipments.firstElement()).orders.firstElement(), "example3"); }
@OnEvent(NEW_HIRE_CHANNEL) public void enroll(final Employee employee) { System.out.printf( "Employee enrolled into benefits system employee %s %d\n", employee.getFirstName(), employee.getEmployeeId()); }
@OnEvent(NEW_HIRE_CHANNEL) public void invite(final Employee employee) { System.out.printf( "Employee will be invited to the community outreach program %s %d\n", employee.getFirstName(), employee.getEmployeeId()); }
/** * test for issue 635: NullPointerException occuring for Object typed version fields. Employee has * a write lock (version) field of type Integer The NullPointerException is thrown when comparing * versions in ObjectChangeSet#compareWriteLockValues */ public void testCreateEmployeeWithFlush() { EntityManager em = createEntityManager("fieldaccess"); Project project1, project2; Employee employee; try { beginTransaction(em); employee = ModelExamples.employeeExample1(); em.persist(employee); // first flush: Employee is written to the database Query query = em.createNamedQuery("findFieldAccessProjectByName"); query.setParameter("name", "Farmer effecency evaluations"); project1 = (Project) query.getSingleResult(); employee.getProjects().add(project1); // second flush: Employee is modified, but // no update to EMPLOYEE table; only join table entry is written query = em.createNamedQuery("findFieldAccessProjectByName"); query.setParameter("name", "Feline Demographics Assesment"); project2 = (Project) query.getSingleResult(); employee.getProjects().add(project2); // third flush: Employee is modified, but // no update to EMPLOYEE table; only join table entry is written // A NullPointerException in ObjectChangeSet#compareWriteLockValues commitTransaction(em); } catch (RuntimeException e) { if (isTransactionActive(em)) { rollbackTransaction(em); } closeEntityManager(em); throw e; } }
/** Creates a {@link SmallEmployee} from the given {@link Employee}. */ private synchronized SmallEmployee createSmall(Employee employee) { final SmallEmployee smallEmployee = new SmallEmployee(); smallEmployee.setStaffNo(employee.getStaffNo()); smallEmployee.setFirstname(employee.getFirstname()); smallEmployee.setLastname(employee.getLastname()); return smallEmployee; }
// saveOrUpdate or update page @RequestMapping(value = "/admin/employees", method = RequestMethod.POST) public String saveOrUpdateEmployee( @ModelAttribute("employeeForm") @Validated EmployeeForm employeeForm, BindingResult result, final RedirectAttributes redirectAttributes, Model model) { if (result.hasErrors()) { populateDefaultModel(model); return "admin/employeeForm"; } else { redirectAttributes.addFlashAttribute("css", "success"); if (employeeForm.isNew()) { redirectAttributes.addFlashAttribute("msg", "Employee added successfully!"); } else { redirectAttributes.addFlashAttribute("msg", "Employee updated successfully!"); } Employee employee; employee = convertEmployeeFormToEmployee(employeeForm); employeeServiceDao.saveOrUpdate(employee); return "redirect:/admin/employees/" + employee.getId(); } }
protected Object getControlObject() { Project project1 = new Project(); project1.setId(CONTROL_PROJECT1_ID); project1.setName(CONTROL_PROJECT1_NAME); Project project2 = new Project(); project2.setId(CONTROL_PROJECT2_ID); project2.setName(CONTROL_PROJECT2_NAME); Project project3 = new Project(); project3.setId(CONTROL_PROJECT3_ID); project3.setName(CONTROL_PROJECT3_NAME); Employee employee1 = new Employee(); employee1.setFirstName(CONTROL_EMPLOYEE1_NAME); employee1.addProject(project3); employee1.addProject(project1); ArrayList objects = new ArrayList(); objects.add(employee1); objects.add(project1); objects.add(project2); objects.add(project3); return objects; }
protected Object getControlObject() { Employee anEmployee = new Employee(); anEmployee.setId(123); // anEmployee.setFirstName(null); anEmployee.setLastName("Doe"); return anEmployee; }
@Override public AccountCommonMasterPM convert(boolean withDetail) { AccountCommonMasterPM masterPM = new AccountCommonMasterPM(); org.springframework.beans.BeanUtils.copyProperties(this, masterPM, new String[] {"details"}); BusinessUnits businessUnit = this.getBusinessUnit(); FundAccount fd = this.getFundAccount(); Employee employee = this.getEmployee(); masterPM.setBusinessUnitId(businessUnit.getId()); masterPM.setBusinessUnitName(businessUnit.getName()); masterPM.setEmployeeId(employee.getId()); masterPM.setEmployeeName(employee.getName()); if (fd != null) { masterPM.setFundAccountId(fd.getId()); masterPM.setFundAccountName(fd.getName()); } if (withDetail) { List<AccountCommonDetail> details = this.getDetails(); int size = details.size(); for (int i = 0; i < size; i++) { AccountCommonDetailPM detailpm = new AccountCommonDetailPM(); AccountCommonDetail detail = details.get(i); org.springframework.beans.BeanUtils.copyProperties(detail, detailpm); detailpm.setMasterDate(detail.getProductMaster().getBillDate()); detailpm.setMasterItem(detail.getProductMaster().getItem()); masterPM.getDetails().add(detailpm); } } return masterPM; }
@Override public void run() { Employee CEO = new Employee("John", "CEO", 30000); Employee headSales = new Employee("Robert", "Head Sales", 20000); Employee headMarketing = new Employee("Michel", "Head Marketing", 20000); Employee clerk1 = new Employee("Laura", "Marketing", 10000); Employee clerk2 = new Employee("Bob", "Marketing", 10000); Employee salesExecutive1 = new Employee("Richard", "Sales", 10000); Employee salesExecutive2 = new Employee("Rob", "Sales", 10000); CEO.add(headSales); CEO.add(headMarketing); headSales.add(salesExecutive1); headSales.add(salesExecutive2); headMarketing.add(clerk1); headMarketing.add(clerk2); for (Employee headEmployee : CEO.getSubordinates()) { System.out.println(headEmployee); for (Employee employee : headEmployee.getSubordinates()) { System.out.println("---> " + employee); } } }