NodeJS的DDD与CRUD对比案例 - Khalil Stemmler

<b>const</b> numbers = [1,2,3,4,5];
let max = -1;
<b>for</b> (let i = 0; i < numbers.length; i++) {
  <b>if</b> (numbers[i] > max) {   
    max = numbers[i] 
  }
}

<b>const</b> numbers = [1,2,3,4,5]
<b>const</b> max = numbers.reduce((a,b) => Math.max(a,b))

<b>class</b> MovieController {
  <b>public</b> async rentMovie (movieId: string, customerId: string) {
    <font><i>// Sequelize ORM models</i></font><font>
    <b>const</b> { Movie, Customer, RentedMovie, CustomerCharge } = <b>this</b>.models;

    </font><font><i>// Get the raw orm records from Sequelize</i></font><font>
    <b>const</b> movie = await Movie.findOne({ where: { movie_id: movieId }});
    <b>const</b> customer = await Customer.findOne({ where: { customer_id: customerId }});

    </font><font><i>// 401 error if not found</i></font><font>
    <b>if</b> (!!movie === false) {
      <b>return</b> <b>this</b>.notFound('Movie not found')
    }

    </font><font><i>// 401 error if not found</i></font><font>
    <b>if</b> (!!customer === false) {
      <b>return</b> <b>this</b>.notFound('Customer not found')
    }

    </font><font><i>// Create a record which signified a movie was rented</i></font><font>
    await RentedMovie.create({
      customer_id: customerId,
      movie_id: movieId
    });

    </font><font><i>// Create a charge for this customer.</i></font><font>
      await CustomerCharge.create({
      amount: movie.rentPrice
    })

    <b>return</b> <b>this</b>.ok();
  }
}
</font>

<b>class</b> MovieController <b>extends</b> BaseController {
  constructor (models) {
    <b>super</b>();
    <b>this</b>.models = models;
  }
  <b>public</b> async rentMovie () {
    <b>const</b> { req } = <b>this</b>;
    <b>const</b> { movieId } = req.params['movie'];
    <b>const</b> { customerId } = req.params['customer'];

    <font><i>// We need to pull out one more model,</i></font><font>
    </font><font><i>// CustomerPayment</i></font><font>
    <b>const</b> { 
      Movie, 
      Customer, 
      RentedMovie, 
      CustomerCharge, 
      CustomerPayment 
    } = <b>this</b>.models;

    <b>const</b> movie = await Movie.findOne({ where: { movie_id: movieId }});
    <b>const</b> customer = await Customer.findOne({ where: { customer_id: customerId }});

    <b>if</b> (!!movie === false) {
      <b>return</b> <b>this</b>.notFound('Movie not found')
    }

    <b>if</b> (!!customer === false) {
      <b>return</b> <b>this</b>.notFound('Customer not found')
    }

    </font><font><i>// Get the number of movies that this user has rented</i></font><font>
    <b>const</b> rentedMovies = await RentedMovie.findAll({ customer_id: customerId });
    <b>const</b> numberRentedMovies = rentedMovies.length;

    </font><font><i>// Enforce the rule</i></font><font>
    <b>if</b> (numberRentedMovies >= 3) {
      <b>return</b> <b>this</b>.fail('Customer already has the maxiumum number of rented movies');
    }

    </font><font><i>// Get all the charges and payments so that we can </i></font><font>
    </font><font><i>// determine if the user still owes money</i></font><font>
    <b>const</b> charges = await CustomerCharge.findAll({ customer_id: customerId });
    <b>const</b> payments = await CustomerPayment.findAll({ customer_id: customerId });

    <b>const</b> chargeDollars = charges.reduce((previousCharge, nextCharge) => {
      <b>return</b> previousCharge.amount + nextCharge.amount;
    });

    <b>const</b> paymentDollars = payments.reduce((previousPayment, nextPayment) => {
      <b>return</b> previousPayment.amount + nextPayment.amount;
    })

    </font><font><i>// Enforce the second business rule</i></font><font>
    <b>if</b> (chargeDollars > paymentDollars) {
      <b>return</b> <b>this</b>.fail('Customer has outstanding balance unpaid');
    }

    </font><font><i>// If all else is good, we can continue</i></font><font>
    await RentedMovie.create({
      customer_id: customerId,
      movie_id: movieId
    });
    
    await CustomerCharge.create({
      amount: movie.rentPrice
    })

    <b>return</b> <b>this</b>.ok();
  }
}
</font>

<b>class</b> MovieController <b>extends</b> BaseController {
  <b>private</b> movieRepo: IMovieRepo;
  <b>private</b> customerRepo: ICustomerRepo;
  
  constructor (movieRepo: IMovieRepo, customerRepo: ICustomerRepo) {
    <b>super</b>();
    <b>this</b>.movieRepo = movieRepo;
    <b>this</b>.customerRepo = customerRepo;
  }

  <b>public</b> async rentMovie () {
    <b>const</b> { req, movieRepo, customerRepo } = <b>this</b>;
    <b>const</b> { movieId } = req.params['movie'];
    <b>const</b> { customerId } = req.params['customer'];

    <b>const</b> movie: Movie = await movieRepo.findById(movieId);
    <b>const</b> customer: Customer = await customerRepo.findById(customerId);

    <b>if</b> (!!movie === false) {
      <b>return</b> <b>this</b>.fail('Movie not found')
    }

    <b>if</b> (!!customer === false) {
      <b>return</b> <b>this</b>.fail('Customer not found')
    }

    <font><i>// The declarative magic happens here.</i></font><font>
    <b>const</b> rentMovieResult: Result<Customer> = customer.rentMovie(movie);

    <b>if</b> (rentMovieResult.isFailure) {
      <b>return</b> <b>this</b>.fail(rentMovieResult.error)
    } <b>else</b> {
      </font><font><i>// if we were using the Unit of Work pattern, we wouldn't </i></font><font>
      </font><font><i>// need to manually save the customer at the end of the request.</i></font><font>
      await customerRepo.save(customer);
      <b>return</b> <b>this</b>.ok();
    }
  }
}
</font>