Page History

public class GeoLocation {

// Slettet gettere og settere etc.

// Kode for 1b
 public double distance(final GeoLocation other) {
  return distance(latitude, longitude, other.latitude, other.longitude);
 }


// Under følger kode for metoden dere kunne forvente at eksisterte.
 /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
 /*::                                                                         :*/
 /*::  This routine calculates the distance between two points (given the     :*/
 /*::  latitude/longitude of those points). It is being used to calculate     :*/
 /*::  the distance between two locations using GeoDataSource (TM) prodducts  :*/
 /*::                                                                         :*/
 /*::  Definitions:                                                           :*/
 /*::    South latitudes are negative, east longitudes are positive           :*/
 /*::                                                                         :*/
 /*::  Passed to function:                                                    :*/
 /*::    lat1, lon1 = Latitude and Longitude of point 1 (in decimal degrees)  :*/
 /*::    lat2, lon2 = Latitude and Longitude of point 2 (in decimal degrees)  :*/
 /*::  Worldwide cities and other features databases with latitude longitude  :*/
 /*::  are available at http://www.geodatasource.com                          :*/
 /*::                                                                         :*/
 /*::  For enquiries, please contact sales@geodatasource.com                  :*/
 /*::                                                                         :*/
 /*::  Official Web site: http://www.geodatasource.com                        :*/
 /*::                                                                         :*/
 /*::           GeoDataSource.com (C) All Rights Reserved 2015                :*/
 /*::                                                                         :*/
 /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
 public static double distance(final double lat1, final double lon1, final double lat2, final double lon2) {
  final double theta = lon1 - lon2;
  double dist = Math.sin(deg2rad(lat1)) * Math.sin(deg2rad(lat2)) + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * Math.cos(deg2rad(theta));
  dist = Math.acos(dist);
  // convert to degrees
  dist = rad2deg(dist);
  dist = dist * 60 * 1.1515;
  // convert to meters
  dist = dist * 1609.344;
  return dist;
 }
 /*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
 /*:: This function converts decimal degrees to radians       :*/
 /*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
 private static double deg2rad(final double deg) {
  return (deg * Math.PI / 180.0);
 }
 /*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
 /*:: This function converts radians to decimal degrees       :*/
 /*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
 private static double rad2deg(final double rad) {
  return (rad * 180 / Math.PI);
 }
}

public class Bike {

 @Override

  private GeoLocation location;
   private Person renter;

   public GeoLocation getLocation() {
      return location;
   }

   public void setLocation(final GeoLocation location) {
     this.location = location;
   }

   public Person getRenter() {
      return renter;
   }

   public void setRenter(final Person renter) {
      this.renter = renter;
   }

public class BikeRental {

	private final Collection<GeoLocation> places = new ArrayList<GeoLocation>();
    private final Collection<Bike> allBikes = new ArrayList<Bike>();

	// Forventede metoder metoder vi senere antar finnes:

	void addPlace(final GeoLocation location) {
		places.add(location);
	}

	void addBike(final Bike bike, final GeoLocation location) {
		if (location != null) {
			bike.setLocation(location);
		}
		allBikes.add(bike);
	}

    private int countAvailableBikesNearby(final GeoLocation location, final double distance) {
        int count = 0;
        for (final Bike bike : allBikes) {
            if (bike.getRenter() == null && bike.getLocation().distance(location) <= distance) {
                count++;
            }
        }
        return count;
        //        return allBikes.stream().filter(bike -> bike.getRenter() == null && bike.getLocation().distance(location) <= distance).count();
    }
    private GeoLocation getStationNearby(final Bike bike, final double maxDistance) {
        GeoLocation closestPlace = null;
        double minDistance = maxDistance;
        for (final GeoLocation place : places) {
            final double distance = bike.getLocation().distance(place);
            if (distance < minDistance) {
                closestPlace = place;
                minDistance = distance;
            }
        }
        return closestPlace;
    }

    private Collection<Bike> getRentedBikes() {
        final Collection<Bike> result = new ArrayList<Bike>();
        for (final Bike bike : allBikes) {
            if (bike.getRenter() != null) {
                result.add(bike);
            }
        }
        return result;
        //    return allBikes.stream().filter(bike -> bike.getRenter() != null).collect(Collectors.toList());
    }

    //    Kan dere skrive den siste uten Streams? 😊
    private Collection<Bike> getUnreturnedBikes() {
        return getRentedBikes().stream().filter(bike -> getStationNearby(bike, 30.0) != null).collect(Collectors.toList());
    }

    public void rentBike(final Person person, final Bike bike, final LocalDateTime now, final LocalDateTime returnTime) {

        checkNowIsBeforeReturnTime(now, returnTime);

        if (bike.getRenter() != null) {

            throw new IllegalArgumentException(bike + " is currently being rented");

        }

        bike.setRenter(person);

    }

    private void checkNowIsBeforeReturnTime(final LocalDateTime now, final LocalDateTime returnTime) {

        if (now.compareTo(returnTime) >= 0) {

            throw new IllegalArgumentException("The start time, " + now + " is the same as or after the return time, " + returnTime);

        }

    }

    public void returnBike(final Person person, final Bike bike, final LocalDateTime now) {

        if (bike.getRenter() != person) {

            throw new IllegalArgumentException(bike + " isn't currently being rented by " + person);

        }

        final GeoLocation place = getStationNearby(bike, 30.0);

        if (place == null) {

            throw new IllegalArgumentException(bike + " isn't near (enough) a bike place");

        }

// part 2        person.withdraw(computePrice(person, bike, now)); // We didn't focus on the implementation of withdrawing money.

// part 2        this.printReceipt(person, bike, now);

        bike.setRenter(null);

// part 2        bike.clearRentalInfos();

    }

public class RentalInfo {

	private final LocalDateTime startTime;
	private final LocalDateTime endTime;

	public RentalInfo(final LocalDateTime startTime, final LocalDateTime endTime) {
  		this.startTime = startTime;
		this.endTime = endTime;
	}

	public LocalDateTime getStartTime() {
		return startTime;
	}

	public LocalDateTime getEndTime() {
		return endTime;
	}
}

public class Bike {

	// [part 1 stuff not shown here]

	// for computing rental price

	private final List<RentalInfo> rentals = new ArrayList<RentalInfo>();

	void addRentalInfo(final RentalInfo rentalInfo) {
	   rentals.add(rentalInfo);
	}

	List<RentalInfo> getRentalInfos() {
	   return new ArrayList<RentalInfo>(rentals);
	}

	void clearRentalInfos() {
	   rentals.clear();
	}
}

    // Hjelpefunksjon for å beregne pris. 
    public int computePrice(final Person person, final Bike bike, final LocalDateTime returnTime) {
        final List<RentalInfo> rentalInfos = bike.getRentalInfos();
        int price = 0;
        LocalDateTime lastEndTime = null;

        for (final RentalInfo info : rentalInfos) {
            if (lastEndTime == null) {
                int timer = computeHours(info.getStartTime(), returnTime);
                price = 10 * timer;
            } else if (info.getEndTime().compareTo(lastEndTime) > 0) {
                price += 5;
                if (info.getStartTime().compareTo(lastEndTime) > 0) {
                    price += 10;
                }
            }
            lastEndTime = info.getEndTime();
        }
        if (returnTime.compareTo(lastEndTime) > 0) {
            price += 10;
        }
        return price;
    }

    // Find full hours of rent. Get full hours, add one.
    private int computeHours(final LocalDateTime startTime, final LocalDateTime endTime) {
        return (int) Duration.between(startTime, endTime).toHours() + 1;
    }


    public void rentBike(final Person person, final Bike bike, final LocalDateTime now, final LocalDateTime returnTime) {
        checkNowIsBeforeReturnTime(now, returnTime);
        if (bike.getRenter() != null) {
            throw new IllegalArgumentException(bike + " is currently being rented");
        }
        bike.setRenter(person);
        bike.addRentalInfo(new RentalInfo(now, returnTime)); // NEW
    }


    public void returnBike(final Person person, final Bike bike, final LocalDateTime now) {
        if (bike.getRenter() != person) {
            throw new IllegalArgumentException(bike + " isn't currently being rented by " + person);
        }
        final GeoLocation place = getStationNearby(bike, 30.0);
        if (place == null) {
            throw new IllegalArgumentException(bike + " isn't near (enough) a bike place");
        }
        // We have not specified how money is withdrawn from
// Persons. Next line is example.
        person.withdraw(computePrice(person, bike, now)); // NEW
        bike.setRenter(null);
        bike.clearRentalInfos(); // NEW
    }

    public void extendRental(final Person person, final Bike bike, final LocalDateTime now, final LocalDateTime returnTime) {
        checkNowIsBeforeReturnTime(now, returnTime);
        if (bike.getRenter() != person) {
            throw new IllegalArgumentException(bike + " isn't currently being rented by " + person);
        }
        bike.addRentalInfo(new RentalInfo(now, returnTime));
    }

	private void printReceipt(Person person, Bike bike, LocalDateTime returnTime) {
        final List<RentalInfo> rentalInfos = bike.getRentalInfos();
        System.out.println("Initial Rental from "+formatRentalInfoTime(rentalInfos.get(0)));
        rentalInfos.remove(0); // Fjerner den første
        for (int i = 0; i < rentalInfos.size(); i++) {
            RentalInfo re = rentalInfos.get(i);
            System.out.println("Extension "+(i+1)+" from "+formatRentalInfoTime(re));
        }
        System.out.println("Bike returned at "+
                returnTime.format(DateTimeFormatter.ofPattern("HH:mm")));
        System.out.println("Total cost: "+computePrice(person, bike, returnTime));
    }

    PricePolicy pricePolicy = new DefaultPricePolicy();

    private int computePrice(final Person person, final Bike bike, final LocalDateTime returnTime) {
//    PricePolicy pricePolicy = person.getPricePolicy(); // Gammel
        PricePolicy pricePolicy = new DefaultPricePolicy();
        final int price = pricePolicy return pricePolicy.computePrice(person, bike, returnTime);
        return price;
    }



public interface PricePolicy {
    public int computePrice(Person person, Bike bike, LocalDateTime returnTime);
}


public class DefaultPricePolicy implements PricePolicy {

    protected int pricePrRental = 0, pricePrHour = 10, pricePrExtension = 5, pricePrLate = 10;

    protected void setPricePrRental(final int pricePrRental) {
        this.pricePrRental = pricePrRental;
    }

    protected void setPricePrHour(final int pricePrHour) {
        this.pricePrHour = pricePrHour;
    }

    protected void setPricePrExtension(final int pricePrExtension) {
        this.pricePrExtension = pricePrExtension;
    }

    protected void setPricePrLate(final int pricePrLate) {
        this.pricePrLate = pricePrLate;
    }

    @Override
    public int computePrice(final Person person, final Bike bike, final LocalDateTime returnTime) {
        // Implementation similar to before...
    }

    private int computeHours(final LocalDateTime startTime, final LocalDateTime endTime) {
        // Implementation similar to before...
    }
}

public class Person {

    // Rest similar to before...

    private PricePolicy pricePolicy;

    public PricePolicy getPricePolicy() {
        return pricePolicy;
    }

    public void setPricePolicy(final PricePolicy pricePolicy) {
        this.pricePolicy = pricePolicy;
    }
}


public class BikeRental {

    // Rest similar to before...

    private PricePolicy pricePolicy = new DefaultPricePolicy();

    private int computePrice(final Person person, final Bike bike, final LocalDateTime returnTime) {
        PricePolicy pricePolicy = person.getPricePolicy();
        if (pricePolicy == null) { // If so, default
            pricePolicy = this.pricePolicy;
        }
        final int price = return pricePolicy.computePrice(person, bike, returnTime);
        return price;
    }
}

public class BikeRentalController {

    private final BikeRental bikeRental;
    private final Person me;
    private final Bike bike;

    public BikeRentalController() {
        bikeRental = new BikeRental();
        final GeoLocation here = new GeoLocation(63, 10);
        bikeRental.addPlace(here);
        bike = new Bike();
        bikeRental.addBike(bike, here);
        me = new Person("Hallvard");
    }

    private final LocalTimeStringConverter localTimeStringConverter = new LocalTimeStringConverter();

    @FXML
    public void initialize() {
        setFromTime(LocalTime.now());
        setToTime(LocalTime.now().plus(1, ChronoUnit.HOURS));
        Platform.runLater(() -> toInput.requestFocus());
    }

    @FXML
    private TextField fromInput;

    @FXML
    private TextField toInput;

    /**
     * @return a LocalDataTime object corresponding to the from input field value
     */
    private LocalTime getFromTime() {
        return localTimeStringConverter.fromString(fromInput.getText());
    }
    /**
     * Updates the from input field value according to the LocalDateTime argument
     * @param time
     */
    private void setFromTime(final LocalTime time) {
        fromInput.setText(localTimeStringConverter.toString(time));
    }

    private LocalTime getToTime() {
        return localTimeStringConverter.fromString(toInput.getText());
    }
    private void setToTime(final LocalTime time) {
        toInput.setText(localTimeStringConverter.toString(time));
    }

    @FXML
    public void plus1HourAction() {
        setToTime(getToTime().plus(1, ChronoUnit.HOURS));
    }

    @FXML
    public void minus1HourAction() {
        setToTime(getToTime().minus(1, ChronoUnit.HOURS));
    }

    private LocalDateTime toLocalDateTime(final LocalTime time) {
        return LocalDateTime.now().withHour(time.getHour()).withMinute(time.getMinute());
    }

    @FXML
    public void rentAction() {
        bikeRental.rentBike(me, bike, toLocalDateTime(getFromTime()) , toLocalDateTime(getToTime()));
    }
}

bikeRental = new BikeRental();
final GeoLocation here = new GeoLocation(63, 10);
bikeRental.addPlace(here);
bike = new Bike();
bikeRental.addBike(bike,here);
assertEquals(bikeRental.getRentedBikes().size(),0);
Person me = new Person("Børge");
LocalDateTime now = LocalDateTime.now();
bikeRental.rentBike(me, bike, now, now.plusHours(2));
assertEquals(bikeRental.getRentedBikes().get(0).getRenter().getName(),"Børge");
assertEquals(bikeRental.getRentedBikes().size(),1);