public static void main(String[] args) {
Configuration cfg = new Configuration().configure("hibernate.cfg.xml");
SessionFactory factory = cfg.buildSessionFactory();
Session session1 = factory.openSession();
Employee emp1 = (Employee) session1.load(Employee.class, 1);
System.out.println(emp1.getId() + " " + emp1.getName() + " " + emp1.getDesignation());
session1.close();
Session session2 = factory.openSession();
Employee emp2 = (Employee) session2.load(Employee.class, 1);
System.out.println(emp2.getId() + " " + emp2.getName() + " " + emp2.getDesignation());
session2.close();
Session sess = factory.openSession();
Query query = sess.getNamedQuery("employee.select").setInteger("id", 1);
List<Employee> emp3 = query.list();
for (Employee emp : emp3) {
System.out.println(emp.getId() + " " + emp.getName() + " " + emp.getDesignation());
}
Session sess1 = factory.openSession();
Query query1 = sess.getNamedQuery("employee.select").setInteger("id", 1);
List<Employee> emp4 = query.list();
for (Employee emp : emp4) {
System.out.println(emp.getId() + " " + emp.getName() + " " + emp.getDesignation());
}
}
@Override
public ProductPlanMasterPM convert(boolean withDetail) {
ProductPlanMasterPM masterPM = new ProductPlanMasterPM();
org.springframework.beans.BeanUtils.copyProperties(this, masterPM, new String[] {"details"});
Employee executeEmployee = this.getExecuteEmployee();
Employee planEmployee = this.getPlanEmployee();
if (executeEmployee != null) {
masterPM.setExecuteEmployeeId(executeEmployee.getId());
masterPM.setExecuteEmployeeName(executeEmployee.getName());
}
if (planEmployee != null) {
masterPM.setPlanEmployeeId(planEmployee.getId());
masterPM.setPlanEmployeeName(planEmployee.getName());
}
if (withDetail) {
List<ProductPlanDetail> details = this.getDetails();
int size = details.size();
System.out.println(size);
for (int i = 0; i < size; i++) {
ProductPlanDetailPM detailpm = new ProductPlanDetailPM();
ProductPlanDetail detail = details.get(i);
org.springframework.beans.BeanUtils.copyProperties(detail, detailpm);
Product product = detail.getProduct();
detailpm.setProductId(product.getId());
detailpm.setFullName(product.getFullName());
detailpm.setSpecification(product.getSpecification());
detailpm.setColor(product.getColor());
detailpm.setUnit(product.getUnit());
masterPM.getDetails().add(detailpm);
}
}
return masterPM;
}
@Override
public void updateEmployee(Employee employee) throws SQLException {
// TODO Auto-generated method stub
try {
String sql =
"UPDATE `employees` set full_name=?, gender=?, phone=?,"
+ "address=?, dept_id=? where (id = ? );";
System.out.println(sql);
DbConnection db = new DbConnection();
Connection con = db.getConnection();
PreparedStatement ps = con.prepareStatement(sql);
ps.setString(1, employee.getFull_name());
System.out.println("full_name= " + employee.getFull_name());
ps.setString(2, employee.getGender());
System.out.println("gender= " + employee.getGender());
ps.setString(3, employee.getPhone());
System.out.println("phone= " + employee.getPhone());
ps.setString(4, employee.getAddress());
System.out.println("address= " + employee.getAddress());
ps.setInt(5, employee.getDept_id());
System.out.println("dept_id= " + employee.getDept_id());
ps.setInt(6, employee.getId());
System.out.println("id= " + employee.getId());
// System.out.println(employee.getDept_id());
ps.executeUpdate();
// ps.close();
con.close();
} catch (Exception e) {
e.printStackTrace();
}
}
int criteriaMethod(Object o1, Object o2) {
Employee e1 = (Employee) o1;
Employee e2 = (Employee) o2;
if (e1.getId() > e2.getId()) {
return 1;
} else if (e1.getId() < e2.getId()) {
return -1;
} else {
return 0;
}
}
@Test
public void should_return_values_of_property() {
List<Long> ids = new ArrayList<Long>();
ids.add(yoda.getId());
when(propertySupport.propertyValues(propertyName, Long.class, employees)).thenReturn(ids);
assertSame(ids, properties.from(employees));
}
public static void readAll(SessionFactory factory) {
Session session = factory.openSession();
Transaction transaction = session.beginTransaction();
Criterion criterion1 = Restrictions.gt("salary", 40000);
Criterion criterion2 = Restrictions.eq("dept", "GM");
Criterion criterionOr = Restrictions.or(criterion1, criterion2);
Criteria criteria = session.createCriteria(Employee.class);
criteria.add(criterionOr);
List<Employee> list = criteria.list();
for (Employee e : list) {
System.out.println(e.getId());
System.out.println(e.getName());
System.out.println(e.getSalary());
System.out.println(e.getDesig());
System.out.println(e.getDept());
System.out.println("==============");
}
transaction.commit();
session.close();
}
@Override
public List<Employee> readEmployees(String infile) {
List<Employee> emps = new ArrayList<>();
Employee emp;
try (InputStream is = new FileInputStream(infile);
JsonReader reader = Json.createReader(is)) {
JsonObject obj = reader.readObject();
JsonArray empArr = obj.getJsonArray("Employees");
for (JsonObject empObj : empArr.getValuesAs(JsonObject.class)) {
emp = new Employee();
emp.setId(empObj.getInt("ID", -1));
emp.setFirstName(empObj.getString("FirstName", null));
emp.setLastName(empObj.getString("LastName", null));
emp.setDepartmentNumber(empObj.getInt("DepartmentNumber", -1));
emp.setLocationId(empObj.getInt("LocationID", -1));
if (emp.getId() > 0 && emp.getFirstName() != null && emp.getLastName() != null)
emps.add(emp);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (JsonParsingException jpe) {
System.err.println("Json file is malformed.");
System.err.println(jpe.getMessage());
System.err.println(jpe.getStackTrace());
}
return emps;
}
// 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 void setup() {
// save current null values for later restoration
saveDefaultDefaultNullValues = ConversionManager.getDefaultManager().getDefaultNullValues();
saveDefaultNullValues =
getSession().getLogin().getPlatform().getConversionManager().getDefaultNullValues();
getSession()
.getLogin()
.getPlatform()
.getConversionManager()
.setDefaultNullValues(new Hashtable());
getSession().getLogin().setDefaultNullValue(String.class, "null");
getSession().getLogin().setDefaultNullValue(int.class, new Integer(-1));
// Reinit mappings.
for (DatabaseMapping mapping : getSession().getDescriptor(Address.class).getMappings()) {
if (mapping.isDirectToFieldMapping()) {
mapping.preInitialize(getAbstractSession());
}
}
getAbstractSession().beginTransaction();
employee = new Employee();
employee.setFirstName("Fred");
employee.setLastName("Flintstone");
employee.setSalary(22);
employee.setGender("Male");
Address address = new Address();
address.setCity(null);
employee.setAddress(address);
getAbstractSession().writeObject(employee);
// force the salary to be NULL
getSession()
.executeNonSelectingCall(
new SQLCall("update SALARY set SALARY = null where EMP_ID = " + employee.getId()));
}
@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;
}
public void updateEmployee(Employee e) {
LOGGER.info(
"Inside "
+ EmployeeDaoMemoryImpl.class.getSimpleName()
+ ".findEmployeeById() business method. Fetching an employees.");
database.put(e.getId(), e);
}
public void saveEmployee(Employee e) {
LOGGER.info(
"Inside "
+ EmployeeDaoMemoryImpl.class.getSimpleName()
+ ".saveEmployee() business method. Saving employee.");
database.put(e.getId(), e);
}
@Test
public void testOrphanedWhileManaged() {
createData();
Session session = openSession();
session.beginTransaction();
List results = session.createQuery("from EmployeeInfo").list();
assertEquals(1, results.size());
results = session.createQuery("from Employee").list();
assertEquals(1, results.size());
Employee emp = (Employee) results.get(0);
assertNotNull(emp.getInfo());
emp.setInfo(null);
session.getTransaction().commit();
session.close();
session = openSession();
session.beginTransaction();
emp = (Employee) session.get(Employee.class, emp.getId());
assertNull(emp.getInfo());
results = session.createQuery("from EmployeeInfo").list();
assertEquals(0, results.size());
results = session.createQuery("from Employee").list();
assertEquals(1, results.size());
session.getTransaction().commit();
session.close();
cleanupData();
}
private void populateEmployeeForm(EmployeeForm employeeForm, Employee employee) {
employeeForm.setId(employee.getId());
employeeForm.setName(employee.getName());
employeeForm.setSurname(employee.getSurname());
employeeForm.setPhoneNumber(employee.getPhoneNumber());
employeeForm.setDateOfBirth(employee.getDateOfBirth());
employeeForm.setPosition(employee.getPosition());
employeeForm.setSalary(employee.getSalary());
}
// REQ#10
private void populateSalaryEmployee() {
ArrayList<String> empName = new ArrayList<>();
for (Employee e : employee) {
if (e instanceof SalaryEmployee) {
empName.add(e.getName() + " - " + e.getId());
}
}
ObservableList<String> list = FXCollections.observableArrayList(empName);
lvEmployees.setItems(list);
}
@RequestMapping(value = "/{id:.+}", method = RequestMethod.PUT)
@ApiOperation(value = "Updates the Employee instance associated with the given id.")
public Employee editEmployee(@PathVariable("id") Integer id, @RequestBody Employee instance)
throws EntityNotFoundException {
LOGGER.debug("Editing Employee with id: {}", instance.getId());
instance.setId(id);
instance = employeeService.update(instance);
LOGGER.debug("Employee details with id: {}", instance);
return instance;
}
long getVersion(Employee emp) {
Vector pk = new Vector(1);
pk.add(emp.getId());
return ((Long)
getSession()
.getDescriptor(Employee.class)
.getOptimisticLockingPolicy()
.getWriteLockValue(emp, pk, getAbstractSession()))
.longValue();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("Vertex ").append(e.getId());
sb.append(", h: ").append(height);
sb.append(", e: ").append(excess);
// sb.append(", currNeighbor: ").append(currNeighbor);
// sb.append("\tneighbors: ").append(neighbors).append('\n');
return sb.toString();
}
private void setArgumentsForTestUsing(Vector employees) {
setArguments(new Vector());
Enumeration names = getExpressionParameters().elements();
Enumeration employeeEnum = employees.elements();
while (names.hasMoreElements()) {
Employee emp = (Employee) employeeEnum.nextElement();
getArguments().add(emp.getId());
names.nextElement();
}
}
public static void main(String[] args) {
Employee writeEmp = new Employee(100, "田中");
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ren/8_8.txt"));
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ren/8_8.txt"))) {
oos.writeObject(writeEmp);
Employee readEmp = (Employee) ois.readObject();
System.out.println("ID :" + readEmp.getId());
System.out.println("Name :" + readEmp.getName());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
public void setup() {
Employee emp1;
Employee emp2;
Employee emp3;
emp1 = (Employee) getSomeEmployees().firstElement();
emp2 = (Employee) getSomeEmployees().elementAt(1);
emp3 = (Employee) getSomeEmployees().elementAt(2);
ExpressionBuilder builder = new ExpressionBuilder();
Vector idVector = new Vector();
idVector.add(emp1.getId());
idVector.add(emp2.getId());
idVector.add(emp3.getId());
Expression whereClause = builder.get("id").notIn(idVector);
ReadAllQuery raq = new ReadAllQuery();
raq.setReferenceClass(Employee.class);
raq.setSelectionCriteria(whereClause);
setOriginalOject(getSession().executeQuery(raq));
getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.id NOT IN (";
ejbqlString = ejbqlString + emp1.getId().toString() + ", ";
ejbqlString = ejbqlString + emp2.getId().toString() + ", ";
ejbqlString = ejbqlString + emp3.getId().toString();
ejbqlString = ejbqlString + ")";
setEjbqlString(ejbqlString);
super.setup();
}
// Give Column Value
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
Employee empObject = empList.get(rowIndex);
switch (columnIndex) {
case 0:
return empObject.getId();
case 1:
return empObject.getName();
case 2:
return empObject.getSalary();
}
return null;
}
@Override
public void insertEmployee(Employee employee) throws SQLException {
// TODO Auto-generated method stub
DbConnection db = new DbConnection();
Connection con = db.getConnection();
con.setAutoCommit(false);
try {
String sql =
"insert into employees (full_name, gender,phone,address, dept_id ) values (?,?,?,?,?);";
PreparedStatement ps = con.prepareStatement(sql);
ps.setString(1, employee.getFull_name());
ps.setString(2, employee.getGender());
ps.setString(3, employee.getPhone());
ps.setString(4, employee.getAddress());
ps.setInt(5, employee.getDept_id());
ps.executeUpdate();
ps.close();
String sql3 = "select max(id)as id from employees";
PreparedStatement ps1 = con.prepareStatement(sql3);
ResultSet r = ps1.executeQuery();
Integer emp_id = 0;
if (r != null) {
while (r.next()) {
emp_id = r.getInt("id");
}
}
r.close();
ps1.close();
String sql2 = "insert into address (id, emp_id, address) values (?,?,?);";
PreparedStatement ps2 = con.prepareStatement(sql2);
ps2.setInt(1, employee.getId());
ps2.setInt(2, emp_id);
ps2.setString(3, employee.getAddress());
ps2.executeUpdate();
ps2.close();
con.commit();
con.close();
System.out.println("committed successfully");
} catch (Exception e) {
System.out.println("rolling back");
con.rollback();
con.close();
e.printStackTrace();
}
}
/**
* Method to call when we want to apply (grant or deny) an agreement visa
*
* @param employee
* @param visaStatus
* @param comment
* @return
*/
public Request applyAgreementVisa(
Employee employee, RequestAgreementVisaStatus visaStatus, String comment) {
if (!waitsForAnAgreementVisa()) {
throw REQUEST_DOES_NOT_EXPECT_ANY_AGREEMENT_VISA.exception();
}
if (userHasAlreadyAppliedAVisa(employee.getId())) {
throw EMPLOYEE_HAS_ALREADY_APPLIED_A_VISA.exception(employee.getFullName());
}
AgreementRuleVisaAud nextExpectedVisa =
getNextExpectedAgreementVisa()
.orElseThrow(() -> COULD_NOT_FIND_NEXT_EXPECTED_AGREEMENT_VISA.exception());
Department department = employee.getDepartment();
Seniority seniority = employee.getSeniority();
if (!nextExpectedVisa.canBeAppliedBy(department, seniority)) {
throw VISA_TO_APPLY_DOESNT_MATCH_NEXT_EXPECTED_ONE.exception(
department.getName(), seniority.getValue(),
nextExpectedVisa.getDepartment().getName(), nextExpectedVisa.getSeniority().getValue());
}
LocalDateTime now = LocalDateTime.now();
RequestAgreementVisa appliedVisa =
RequestAgreementVisa.build(
this,
null,
employee,
visaStatus,
nextAgreementVisaRank,
comment,
department,
seniority,
now);
addAgreementVisa(appliedVisa);
updateUser = employee.getUid();
updateDate = now;
return this;
}
private void setupSourceSide(Set<Employee> emps) {
for (Employee e : emps) {
Vertex u = Vertex.vertexFromEmployee(e);
LV.add(u);
source.addToNeighbors(u);
u.addToNeighbors(source);
setCapacity(source, u, 1);
setFlow(source, u, 1);
u.setExcess(1);
// Prioritize friend for initial flow
if (e.getId() == ProjectParams.FRIEND_ID) {
V.addFirst(u);
} else {
V.add(u);
}
}
source.setExcess(source.getExcess() - source.getNumNeighbors());
}
/**
* test: updating the version field with value != in-memory value. This should throw an
* OptimisticLockException
*/
public void testVersionUpdateWithIncorrectValue() {
EntityManager em = createEntityManager("fieldaccess");
Employee employee;
try {
beginTransaction(em);
employee = ModelExamples.employeeExample1();
em.persist(employee);
commitTransaction(em);
beginTransaction(em);
Employee employee1 = em.find(Employee.class, employee.getId());
employee1.setVersion(2);
commitTransaction(em);
fail("updating object version with wrong value didn't throw exception");
} catch (PersistenceException pe) {
// expected behavior
} catch (Exception exception) {
Throwable persistenceException = exception;
// Remove an wrapping exceptions such as rollback, runtime, etc.
while (persistenceException != null
&& !(persistenceException instanceof OptimisticLockException)) {
// In the server this is always a rollback exception, need to get nested exception.
persistenceException = persistenceException.getCause();
}
if (persistenceException instanceof OptimisticLockException) {
return;
} else {
fail(
"updating object version with wrong value threw a wrong exception: "
+ exception.getMessage());
}
} finally {
if (isTransactionActive(em)) {
rollbackTransaction(em);
}
closeEntityManager(em);
}
}
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("<company ")
.append("id=\"")
.append(id)
.append("\"")
.append(" name=\"")
.append(name)
.append("\"")
.append(" address=\"")
.append(address)
.append("\">");
if (allEmployees != null) {
for (Employee employee : allEmployees) {
buf.append("\n\t<employee")
.append(" id=\"")
.append(employee.getId())
.append("\"")
.append(" name=\"")
.append(employee.getName())
.append("\"")
.append(" age=\"")
.append(employee.getAge())
.append("\"")
.append(" salary=")
.append(employee.getSalary())
.append("\"")
.append(" deptId=\"")
.append(employee.getDeptId())
.append("\"/>");
}
}
buf.append("\n</company>");
return buf.toString();
}
/* функция возвращает можно ли удалить планируемый отпуск в таблице заявлений на отпуск */
public Boolean isVacationDeletePermission(Vacation vacation, Employee employee) {
if (employee != null && vacation != null) {
/* проверим Админ ли текущий пользователь */
if (employeeService.isEmployeeAdmin(employee.getId())) {
return Boolean.TRUE;
} else {
/* для запланированных отпусков проверяем что это либо создатель отпуска либо сам отпускник
* либо является лин. рук. отпускника */
if (vacation.getType().getId() == VacationTypesEnum.PLANNED.getId()
&& (vacation.getEmployee().equals(employee)
|| vacation.getAuthor().equals(employee)
|| employeeService.getLinearEmployees(vacation.getEmployee()).contains(employee))) {
return Boolean.TRUE;
}
/* пользователь создатель или отпускник и статус не отклонено и не утверждено */
if ((vacation.getEmployee().equals(employee) || vacation.getAuthor().equals(employee))
&& vacation.getStatus().getId() != VacationStatusEnum.REJECTED.getId()
&& vacation.getStatus().getId() != VacationStatusEnum.APPROVED.getId()) {
return Boolean.TRUE;
}
}
}
return Boolean.FALSE;
}
public void testDirtyButNotDirty() throws Exception {
EntityManager manager = getOrCreateEntityManager();
manager.getTransaction().begin();
Employee mark = new Employee();
mark.setName("Mark");
mark.setTitle("internal sales");
mark.setSex('M');
mark.setAddress("buckhead");
mark.setZip("30305");
mark.setCountry("USA");
Customer joe = new Customer();
joe.setName("Joe");
joe.setSex('M');
joe.setAddress("San Francisco");
joe.setZip("XXXXX");
joe.setCountry("USA");
joe.setComments("Very demanding");
joe.setSalesperson(mark);
Person yomomma = new Person();
yomomma.setName("mum");
yomomma.setSex('F');
manager.persist(mark);
manager.persist(joe);
manager.persist(yomomma);
long[] ids = {mark.getId(), joe.getId(), yomomma.getId()};
manager.getTransaction().commit();
manager.getTransaction().begin();
assertEquals(
manager
.createQuery("select p.address, p.name from Person p order by p.name")
.getResultList()
.size(),
3);
assertEquals(
manager
.createQuery("select p from Person p where p.class = Customer")
.getResultList()
.size(),
1);
manager.getTransaction().commit();
manager.getTransaction().begin();
List customers =
manager
.createQuery("select c from Customer c left join fetch c.salesperson")
.getResultList();
for (Iterator iter = customers.iterator(); iter.hasNext(); ) {
Customer c = (Customer) iter.next();
assertEquals(c.getSalesperson().getName(), "Mark");
}
assertEquals(customers.size(), 1);
manager.getTransaction().commit();
manager.getTransaction().begin();
customers = manager.createQuery("select c from Customer c").getResultList();
for (Iterator iter = customers.iterator(); iter.hasNext(); ) {
Customer c = (Customer) iter.next();
assertEquals(c.getSalesperson().getName(), "Mark");
}
assertEquals(customers.size(), 1);
manager.getTransaction().commit();
manager.getTransaction().begin();
mark = manager.find(Employee.class, new Long(ids[0]));
joe = (Customer) manager.find(Customer.class, new Long(ids[1]));
yomomma = manager.find(Person.class, new Long(ids[2]));
mark.setZip("30306");
assertEquals(
1,
manager.createQuery("select p from Person p where p.zip = '30306'").getResultList().size());
manager.remove(mark);
manager.remove(joe);
manager.remove(yomomma);
assertTrue(manager.createQuery("select p from Person p").getResultList().isEmpty());
manager.getTransaction().commit();
manager.close();
}
/** Sets the Employee object */
public void setEmployee(Employee emp) {
this.empId = emp.getId();
setDirty();
}
