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);
}
}
}
