public class AccountTest {
   private AccountId srcAccountId;
   private AccountId targetAccountId;
   @before
     void setup(){
         srcAccountId = AccountId.of("123456");        //用于演示
         target AccountId = AccountId.of("654321");    //用于演示
   }
   @Test
   void should_transfer_from_src_account_to_target_account_given_correct_transfer_amount() {
      
     // given
      Money balanceOfSrc = new Money(100_000L, Currency.RMB);
      SourceAccount src = new Account(srcAccountId, balanceOfSrc);
      Money balanceOfDes = new Money(0L, Currency.RMB);
      TargetAccount target = new Account(targetAccountId, balanceOfDes);
      Money trasferAmount = new Money(10_000L, Currency.RMB);
     
     // when
      src.transferTo(target, transferAmount);
     
     // then
      assertThat(src.getBalance()).isEqualTo(MoCurrency.RMB));
      assertThat(target.getBalance()).isEqualTo(Money.of(10_000L, Currency.RMB));
   }
}

PaymentAppService.pay() {
    PaymentService.pay() {
        PayDayService.isPayday(today) {
            Calendar.isFriday(today);
            WorkdayService.isLastWorkday(today) {
                HolidayRepository.ofMonth(month);
                Calendar.isLastWorkday(holidays);
            }        
            WorkdayService.isIntervalFriday(today) {
                PaymentRepository.lastPayday(today);
                Calendar.isFriday(today);
            }
        }
        EmployeeRepository.allOf(employeeType);
        PayrollCalculator.calculate(employees) {
            HourlyEmployeePayrollCalculator.calculate() {
                HourlyEmployeeRepository.all();
                while (employee -> List<HourlyEmployee>) {
                    employee.payroll(PayPeriod);
                }
            }
            SalariedEmployeePayrollCalculator.calculate() {
                SalariedEmployeeRepository.all();
                while (employee -> List<SalariedEmployee>) {
                    employee.payroll();
                }
            }
            CommissionedEmployeePayrollCalculator.calculate() {
                CommissionedEmployeeRepository.all();
                while (employee -> List<CommissionedEmployee>) {
                    employee.payroll(payPeriod);
                }
            }
        }
        PayingPayrollService.execute(employees) {
            TransferClient.transfer(account);
            PaymentRepository.add(payment);
        }
    }
}

public class HourlyEmployeeTest {
   
  @Test
   public void should_calculate_payroll_by_work_hours_in_a_week() {
      //given
      TimeCard timeCard1 = new TimeCard(LocalDate.of(2019, 9, 2), 8);
      TimeCard timeCard2 = new TimeCard(LocalDate.of(2019, 9, 3), 8);
      TimeCard timeCard3 = new TimeCard(LocalDate.of(2019, 9, 4), 8);
      TimeCard timeCard4 = new TimeCard(LocalDate.of(2019, 9, 5), 8);
      TimeCard timeCard5 = new TimeCard(LocalDate.of(2019, 9, 6), 8);
      List<TimeCard> timeCards = new ArrayList<>();
      timeCards.add(timeCard1);
      timeCards.add(timeCard2);
      timeCards.add(timeCard3);
      timeCards.add(timeCard4);
      timeCards.add(timeCard5);
      HourlyEmployee hourlyEmployee = new HourlyEmployee(timeCards, 
                                                         Money.of(10000, Currency.RMB));
      //when
      Payroll payroll = hourlyEmployee.payroll();
     
     //then
      assertThat(payroll).isNotNull();
      assertThat(payroll.beginDate()).isEqualTo(LocalDate.of(2019, 9, 2));
      assertThat(payroll.endDate()).isEqualTo(LocalDate.of(2019, 9, 6));
      assertThat(payroll.amount()).isEqualTo(Money.of(400000, Currency.RMB));
   }
}

public class HourlyEmployee {
  
   private List<TimeCard> timeCards;
   private Money salaryOfHour;
  
   public HourlyEmployee(List<TimeCard> timeCards, Money salaryOfHour) {
      this.timeCards = timeCards;
      this.salaryOfHour = salaryOfHour;
   }
  
   public Payroll payroll() {
   int totalHours = timeCards.stream()
          .map(tc -> tc.workHours())
          .reduce(0, (hours, total) -> hours + total);
   Collections.sort(timeCards);
   LocalDate beginDate = timeCards.get(0).workDay();
   LocalDate endDate = timeCards.get(timeCards.size() - 1).workDay();
   Period settlementPeriod = new Period(beginDate, endDate);
   return new Payroll(settlementPeriod.beginDate, settlementPeriod.endDate,
                      salaryOfHour.multiply(totalHours));
	}
 
}



private class Period {
   private LocalDate beginDate;
   private LocalDate endDate;
   Period(LocalDate beginDate, LocalDate endDate) {
      this.beginDate = beginDate;
      this.endDate = endDate;
   }
}

public class Money {
   private final long value;
   private final Currency currency;
   public static Money of(long value, Currency currency) {
      return new Money(value, currency);
   }
   private Money(long value, Currency currency) {
      this.value = value;
      this.currency = currency;
   }
   public Money multiply(int factor) {
      return new Money(value * factor, currency);
   }
  
  // 实现 `Money`时，还重载了`equals()` 和 `hashcode()` 方法，这是遵循领域驱动设计值对象的要求提供的，不能算作过度设计     
   @Override
   public boolean equals(Object o) {
      if (this == o) return true;
      if (o == null || getClass() != o.getClass()) return false;
      Money money = (Money) o;
      return value == money.value &&
            currency == money.currency;
   }
   @Override
   public int hashCode() {
      return Objects.hash(value, currency);
   }
}

Test
public void should_calculate_payroll_by_work_hours_with_overtime_in_a_week() {
   //given
   List timeCards = createTimeCards(9, 7, 10, 10, 8);
   Money salaryOfHour = Money.of(10000, Currency.RMB);
   HourlyEmployee hourlyEmployee = new HourlyEmployee(timeCards, salaryOfHour);
  
  //when
   Payroll payroll = hourlyEmployee.payroll();
   
  //then
   assertThat(payroll).isNotNull();
   assertThat(payroll.beginDate()).isEqualTo(LocalDate.of(2019, 9, 2));
   assertThat(payroll.endDate()).isEqualTo(LocalDate.of(2019, 9, 6));
   assertThat(payroll.amount()).isEqualTo(Money.of(465000, Currency.RMB));
}

public Payroll payroll() {
   int regularHours = timeCards.stream()
          .map(tc -> tc.workHours() > 8 ? 8 : tc.workHours())
          .reduce(0, (hours, total) -> hours + total);
   int overtimeHours = timeCards.stream()
          .filter(tc -> tc.workHours() > 8)
          .map(tc -> tc.workHours() - 8)
          .reduce(0, (hours, total) -> hours + total);
   Money regularSalary = salaryOfHour.multiply(regularHours);
   
  // 修改了multiply()方法的定义，支持double类型
   Money overtimeSalary = salaryOfHour.multiply(1.5).multiply(overtimeHours);
   Money totalSalary = regularSalary.add(overtimeSalary);
   return new Payroll(
          settlementPeriod().beginDate,
          settlementPeriod().endDate,
          totalSalary);


  private Period settlementPeriod() {
   Collections.sort(timeCards);
   LocalDate beginDate = timeCards.get(0).workDay();
   LocalDate endDate = timeCards.get(timeCards.size() - 1).workDay();
   return new Period(beginDate, endDate);
}


}

public class TimeCard implements Comparable {
   private static final int MAXIMUM_REGULAR_HOURS = 8;
   private LocalDate workDay;
   private int workHours;
   
  public TimeCard(LocalDate workDay, int workHours) {
      this.workDay = workDay;
      this.workHours = workHours;
   }
   public int workHours() {
      return this.workHours;
   }
   public LocalDate workDay() {
      return this.workDay;
   }
   public boolean isOvertime() {
      return workHours() > MAXIMUM_REGULAR_HOURS;
   }
   public int getOvertimeWorkHours() {
      return workHours() - MAXIMUM_REGULAR_HOURS;
   }
   public int getRegularWorkHours() {
      return isOvertime() ? MAXIMUM_REGULAR_HOURS : workHours();
   }
}

public Payroll payroll() {
   int regularHours = timeCards.stream()
          .map(TimeCard::getRegularWorkHours)
          .reduce(0, (hours, total) -> hours + total);
   int overtimeHours = timeCards.stream()
          .filter(TimeCard::isOvertime)
          .map(TimeCard::getOvertimeWorkHours)
          .reduce(0, (hours, total) -> hours + total);
   Money regularSalary = salaryOfHour.multiply(regularHours);
   Money overtimeSalary = salaryOfHour.multiply(OVERTIME_FACTOR).multiply(overtimeHours);
   Money totalSalary = regularSalary.add(overtimeSalary);
   return new Payroll(
          settlementPeriod().beginDate,
          settlementPeriod().endDate,
          totalSalary);
}

public Payroll payroll() {
   Money regularSalary = calculateRegularSalary();
   Money overtimeSalary = calculateOvertimeSalary();
   Money totalSalary = regularSalary.add(overtimeSalary);
   
  return new Payroll(
         settlementPeriod().beginDate,
         settlementPeriod().endDate,
         totalSalary);
}

public Payroll payroll(Period settlementPeriod) {
   Money regularSalary = calculateRegularSalary(settlementPeriod);
   Money overtimeSalary = calculateOvertimeSalary(settlementPeriod);
   Money totalSalary = regularSalary.add(overtimeSalary);
   return new Payroll(
          settlementPeriod.beginDate(),
          settlementPeriod.endDate(),
          totalSalary);
}