Implementacja JerseySpring

PC38-JerseySpring/pom.xml

@@ -32,6 +32,21 @@
 			<artifactId>spring-boot-starter-test</artifactId>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.glassfish.jaxb</groupId>
+			<artifactId>jaxb-runtime</artifactId>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.xmlgraphics</groupId>
+			<artifactId>fop</artifactId>
+			<version>2.7</version>
+			<exclusions>
+				<exclusion>
+					<groupId>xml-apis</groupId>
+					<artifactId>xml-apis</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
 	</dependencies>
 
 	<build>

PC38-JerseySpring/src/main/java/sklep/JerseyConfig.java

+package sklep;
+
+import org.glassfish.jersey.server.ResourceConfig;
+import org.springframework.context.annotation.Configuration;
+
+import sklep.hello.Hello;
+import sklep.hello.Time;
+import sklep.rest.RCustomers;
+import sklep.rest.RProducts;
+import sklep.rest.RProductsPDF;
+import sklep.rest.ext.PDFWriter;
+import sklep.rest.ext.RecordNotFoundMapper;
+
+@Configuration
+public class JerseyConfig extends ResourceConfig {
+
+	public JerseyConfig() {
+		register(Hello.class);
+		register(Time.class);
+		register(RProducts.class);
+		register(RCustomers.class);
+		register(RProductsPDF.class);
+		register(RecordNotFoundMapper.class);
+		register(PDFWriter.class);
+	}
+}

PC38-JerseySpring/src/main/java/sklep/db/CustomerDAO.java

+package sklep.db;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import sklep.model.Customer;
+
+public class CustomerDAO {
+	private final DBConnection db;
+
+	CustomerDAO(DBConnection db) {
+		this.db = db;
+	}
+
+	public Customer findByEmail(String email) throws DBException, RecordNotFound {
+		final String sql = "SELECT * FROM customers WHERE email = ?";
+		try (PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+			stmt.setString(1, email);
+			try (ResultSet rs = stmt.executeQuery()) {
+				if (rs.next()) {
+					return customerFromRS(rs);
+				} else {
+					throw new RecordNotFound("Cannot find customer with email " + email);
+				}
+			}
+		} catch (SQLException e) {
+			throw new DBException("SQL error in CustomerDAO.findById: " + e.getMessage(), e);
+		}
+	}
+
+	public List<Customer> readAll() throws DBException {
+		final String sql = "SELECT * FROM customers";
+		try (PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+			try (ResultSet rs = stmt.executeQuery()) {
+				return customerListFromRS(rs);
+			}
+		} catch (SQLException e) {
+			throw new DBException("SQL error in CustomerDAO.readAll: " + e.getMessage(), e);
+		}
+	}
+
+	private List<Customer> customerListFromRS(ResultSet rs) throws SQLException {
+		List<Customer> records = new ArrayList<>();
+		while (rs.next()) {
+			Customer product = customerFromRS(rs);
+			records.add(product);
+		}
+		return records;
+	}
+
+	private Customer customerFromRS(ResultSet rs) throws SQLException {
+		return new Customer(
+				rs.getString("email"),
+				rs.getString("customer_name"),
+				rs.getString("phone"),
+				rs.getString("address"),
+				rs.getString("postal_code"),
+				rs.getString("city"));
+	}
+	
+    public void insert(Customer customer) throws DBException {
+    	// używać gdy obiekt ma wpisane ID (tu: email)
+        final String sql = "INSERT INTO customers("
+                + "email, customer_name, phone, address, postal_code, city)"
+                + " VALUES (?, ?, ?, ?, ?, ?)";
+        try(PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+            stmt.setString(1, customer.getEmail());
+            stmt.setString(2, customer.getName());
+            stmt.setString(3, customer.getPhone());
+            stmt.setString(4, customer.getAddress());
+            stmt.setString(5, customer.getPostalCode());
+            stmt.setString(6, customer.getCity());
+            stmt.executeUpdate();
+        } catch (SQLException e) {
+            throw new DBException("Error during INSERT CUSTOMER", e);
+        }
+    }
+
+    public boolean update(Customer customer) throws DBException {
+        final String sql = "UPDATE customers SET "
+                + " customer_name=?, phone=?, address=?, postal_code=?, city=?"
+                + " WHERE email = ?";
+        try(PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+            stmt.setString(1, customer.getName());
+            stmt.setString(2, customer.getPhone());
+            stmt.setString(3, customer.getAddress());
+            stmt.setString(4, customer.getPostalCode());
+            stmt.setString(5, customer.getCity());
+            stmt.setString(6, customer.getEmail());
+            int count = stmt.executeUpdate();
+            return count > 0;
+        } catch (SQLException e) {
+            throw new DBException("Error during UPDATE CUSTOMER", e);
+        } 
+    }
+    
+	public void save(Customer customer) throws DBException {
+		if(customer.getEmail() == null) {
+			throw new IllegalArgumentException("Customer email cannot be null");
+		} else {
+			if(! update(customer)) {
+				insert(customer);
+			}
+		}
+	}
+	
+	public boolean delete(String email) throws DBException {
+        final String sql = "DELETE FROM customers WHERE email = ?";
+        try(PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+            stmt.setString(1, email);
+            int count = stmt.executeUpdate();
+            return count > 0;
+        } catch (SQLException e) {
+            throw new DBException("Error during DELETE CUSTOMER", e);
+        } 
+    }
+
+	public boolean delete(Customer customer) throws DBException {
+		return delete(customer.getEmail());
+    }
+	
+}

PC38-JerseySpring/src/main/java/sklep/db/DBConnection.java

+package sklep.db;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+
+public class DBConnection implements AutoCloseable {
+	private Connection sqlConnection;
+
+	private DBConnection(Connection sqlConnection) {
+		this.sqlConnection = sqlConnection;
+	}
+
+	public static DBConnection open() throws DBException {
+		return open(false);
+	}
+	
+	public static DBConnection open(boolean autoCommit) throws DBException {
+		try {
+			Properties props = DBSettings.load();
+			if(props.containsKey("driver_class")) {
+				Class.forName(props.getProperty("driver_class"));
+			}
+			Connection c = DriverManager.getConnection(props.getProperty("url") , props);
+			c.setAutoCommit(autoCommit);
+			return new DBConnection(c);
+		} catch (ClassNotFoundException | SQLException e) {
+			throw new DBException("Cannot connect to postgresql: " + e, e);
+		}
+	}
+
+	public static DBConnection openLocalhost() throws DBException {
+		try {
+			Connection c = DriverManager.getConnection("jdbc:postgresql://localhost/sklep", "kurs", "abc123");
+			c.setAutoCommit(false);
+			return new DBConnection(c);
+		} catch (SQLException e) {
+			throw new DBException("Cannot connect to postgresql: " + e, e);
+		}
+	}
+
+	@Override
+	public void close() {
+		try {
+			if (sqlConnection != null) {
+				sqlConnection.close();
+				sqlConnection = null;
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public Connection getSqlConnection() {
+		return sqlConnection;
+	}
+	
+	public void commit() throws DBException {
+		try {
+			sqlConnection.commit();
+		} catch (SQLException e) {
+			throw new DBException("Error during commit: " + e.getMessage(), e);
+		}
+	}
+
+	public void rollback() throws DBException {
+		try {
+			sqlConnection.rollback();
+		} catch (SQLException e) {
+			throw new DBException("Error during rollback: " + e.getMessage(), e);
+		}
+	}
+
+	public ProductDAO productDAO() {
+		return new ProductDAO(this);
+	}
+
+	public CustomerDAO customerDAO() {
+		return new CustomerDAO(this);
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/db/DBException.java

+package sklep.db;
+
+public class DBException extends SklepException {
+
+	public DBException() {
+		super();
+	}
+
+	public DBException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+	public DBException(String message) {
+		super(message);
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/db/DBSettings.java

+package sklep.db;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+public class DBSettings {
+	public static final String DB_SETTINGS_SYSTEM_PROPERTY = "sklep.db_settings_location";
+	private static final String INTERNAL_DEFAULT_PROPERTIES = "/sklep.properties";
+
+	private static DBSettings dbSettings; // singleton
+	
+	private final Properties props;
+
+	private DBSettings() throws DBException {
+		props = new Properties();
+		String systemProperty = System.getProperty(DB_SETTINGS_SYSTEM_PROPERTY);
+		try(InputStream input = systemProperty != null
+					? new FileInputStream(new File(systemProperty))
+					: DBSettings.class.getResourceAsStream(INTERNAL_DEFAULT_PROPERTIES) ) {
+			props.load(input);
+		} catch (IOException e) {
+			//e.printStackTrace();
+			throw new DBException("Cannot read settings. " + e, e);
+		}
+	}
+	
+	public static synchronized DBSettings getInstance() throws DBException {
+		if(dbSettings == null) {
+			dbSettings = new DBSettings();
+		}
+		return dbSettings;
+	}
+	
+	public Properties getProperties() {
+		return props;
+	}
+	
+	public static Properties load() throws DBException {
+		return getInstance().getProperties();
+	}
+	
+}

PC38-JerseySpring/src/main/java/sklep/db/PhotoUtil.java

+package sklep.db;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+public class PhotoUtil {
+	
+	public static byte[] readBytes(int productId) throws DBException, RecordNotFound {
+		String dir = DBSettings.load().getProperty("photo_dir");
+		String fileName = productId + ".jpg";
+		
+		try {
+			return Files.readAllBytes(Paths.get(dir, fileName));
+		} catch (IOException e) {
+			throw new RecordNotFound("Cannot read photo for product id = " + productId);
+		}
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/db/ProductDAO.java

+package sklep.db;
+
+import java.math.BigDecimal;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import sklep.model.Product;
+
+public class ProductDAO {
+	private static final BigDecimal MAX_PRICE = new BigDecimal(1_000_000_000);
+	private static final String[] ID_COLUMNS = {"product_id"};
+	
+	private final DBConnection db;
+
+	ProductDAO(DBConnection db) {
+		this.db = db;
+	}
+
+	public Product findById(int productId) throws DBException, RecordNotFound {
+		final String sql = "SELECT * FROM products WHERE product_id = ?";
+		try (PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+			stmt.setInt(1, productId);
+			try (ResultSet rs = stmt.executeQuery()) {
+				if (rs.next()) {
+					return productFromRS(rs);
+				} else {
+					throw new RecordNotFound("Cannot find product with id " + productId);
+				}
+			}
+		} catch (SQLException e) {
+			throw new DBException("SQL error in ProductDAO.findById: " + e.getMessage(), e);
+		}
+	}
+
+	public List<Product> readAll() throws DBException {
+		final String sql = "SELECT * FROM products";
+		try (PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+			try (ResultSet rs = stmt.executeQuery()) {
+				return productListFromRS(rs);
+			}
+		} catch (SQLException e) {
+			throw new DBException("SQL error in ProductDAO.readAll: " + e.getMessage(), e);
+		}
+	}
+
+	public List<Product> findByPrice(BigDecimal minPrice, BigDecimal maxPrice) throws DBException {
+		final String sql = "SELECT * FROM products WHERE price BETWEEN ? AND ?";
+		if(minPrice == null)
+			minPrice = BigDecimal.ZERO;
+		
+		if(maxPrice == null)
+			maxPrice = MAX_PRICE;
+
+		try (PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+			stmt.setBigDecimal(1, minPrice);
+			stmt.setBigDecimal(2, maxPrice);
+			try (ResultSet rs = stmt.executeQuery()) {
+				return productListFromRS(rs);
+			}
+		} catch (SQLException e) {
+			throw new DBException("SQL error in ProductDAO.findByPrice: " + e.getMessage(), e);
+		}
+	}
+
+	private List<Product> productListFromRS(ResultSet rs) throws SQLException {
+		List<Product> products = new ArrayList<>();
+		while (rs.next()) {
+			Product product = productFromRS(rs);
+			products.add(product);
+		}
+		return products;
+	}
+
+	private Product productFromRS(ResultSet rs) throws SQLException {
+		return new Product(
+				rs.getInt("product_id"),
+				rs.getString("product_name"),
+				rs.getBigDecimal("price"),
+				rs.getString("description"));
+	}
+	
+    public void insert(Product product) throws DBException {
+    	// używać gdy obiekt ma wpisane ID
+        final String sql = "INSERT INTO products("
+                + " product_id, product_name, price, description)"
+                + " VALUES (?, ?, ?, ?)";
+        try(PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+            stmt.setInt(1, product.getProductId());
+            stmt.setString(2, product.getProductName());
+            stmt.setBigDecimal(3, product.getPrice());
+            stmt.setString(4, product.getDescription());
+            stmt.executeUpdate();
+        } catch (SQLException e) {
+            throw new DBException("Error during INSERT PRODUCT", e);
+        }
+    }
+
+    public void insertNew(Product product) throws DBException {
+    	// używać gdy obiekt nie ma wpisanego ID (productID == null)
+        final String sql = "INSERT INTO products("
+                + " product_name, price, description)"
+                + " VALUES (?, ?, ?)";
+        try(PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql, ID_COLUMNS)) {
+            stmt.setString(1, product.getProductName());
+            stmt.setBigDecimal(2, product.getPrice());
+            stmt.setString(3, product.getDescription());
+            stmt.executeUpdate();
+
+    		try (ResultSet rs = stmt.getGeneratedKeys()) {
+    			if(rs.next()) {
+    				// w obiekcie, który mamy w pamięci, uzupełniamy brakujące ID na podstawie tego, co wygenerowała baza
+    				product.setProductId(rs.getInt(1));
+    			}
+    		};
+
+        } catch (SQLException e) {
+            throw new DBException("Error during INSERT PRODUCT", e);
+        }
+    }
+
+    public boolean update(Product product) throws DBException {
+        final String sql = "UPDATE products SET "
+                + " product_name = ?, price = ?, description = ?"
+                + " WHERE product_id = ?";
+        try(PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+            stmt.setString(1, product.getProductName());
+            stmt.setBigDecimal(2, product.getPrice());
+            stmt.setString(3, product.getDescription());
+            stmt.setInt(4, product.getProductId());
+            int count = stmt.executeUpdate();
+            return count > 0;
+        } catch (SQLException e) {
+            throw new DBException("Error during UPDATE PRODUCT", e);
+        } 
+    }
+    
+	public void save(Product product) throws DBException {
+		if(product.getProductId() == null) {
+			// wstawiamy nowy rekord korzystajac z sekwecji
+			insertNew(product);
+		} else {
+			if(! update(product)) {
+				insert(product);
+			}
+		}
+	}
+	
+	public boolean delete(int productId) throws DBException {
+        final String sql = "DELETE FROM products WHERE product_id = ?";
+        try(PreparedStatement stmt = db.getSqlConnection().prepareStatement(sql)) {
+            stmt.setInt(1, productId);
+            int count = stmt.executeUpdate();
+            return count > 0;
+        } catch (SQLException e) {
+            throw new DBException("Error during DELETE PRODUCT", e);
+        } 
+    }
+
+	public boolean delete(Product product) throws DBException {
+		return delete(product.getProductId());
+    }
+	
+}

PC38-JerseySpring/src/main/java/sklep/db/RecordNotFound.java

+package sklep.db;
+
+public class RecordNotFound extends SklepException {
+
+	public RecordNotFound() {
+		super();
+	}
+
+	public RecordNotFound(String message) {
+		super(message);
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/db/SklepException.java

+package sklep.db;
+
+public class SklepException extends Exception {
+
+	public SklepException() {
+		super();
+	}
+
+	public SklepException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+	public SklepException(String message) {
+		super(message);
+	}
+
+	public SklepException(Throwable cause) {
+		super(cause);
+	}
+	
+}

PC38-JerseySpring/src/main/java/sklep/hello/Hello.java

+package sklep.hello;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+
+@Path("/hello")
+public class Hello {
+	
+	@GET
+	public String hello() {
+		return "Hello world";
+	}
+	
+}
+
+// to jest "klasa zasobu" / "resource class"
+// "Pod adresem /hello znajduje się zasób.".
+// Metoda GET pozwala go odczytać.
+// Tym zasobem jest napis "Hello world" ;)

PC38-JerseySpring/src/main/java/sklep/hello/Time.java

+package sklep.hello;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+
+@Path("/dt")
+@Produces("text/plain")
+public class Time {
+	// Jeśli aplikacja działa z domyślnymi ustawieniami (czyli nie definiuje metody getSingletons),
+	// to obiekt tej klasy, a co za tym idzie pole dt, jest tworzony za każdym razem gdy przychodzi nowy request (polityka "per request")
+	private LocalDateTime dt = LocalDateTime.now();
+
+	@GET
+	public LocalDateTime getFullInfo() {
+		return dt;
+	}
+	
+	@Path("/date")
+	@GET
+	public LocalDate getDate() {
+		return dt.toLocalDate();
+	}
+	
+	@Path("/dow")
+	@GET
+	public int getDOW() {
+		return dt.getDayOfWeek().getValue();
+	}
+	
+	@Path("/doy")
+	@GET
+	public int getDOY() {
+		return dt.getDayOfYear();
+	}
+	
+	@Path("/time")
+	@GET
+	public LocalTime getTime() {
+		return dt.toLocalTime();
+	}
+
+	@Path("/time/hour")
+	@GET
+	public int getHour() {
+		return dt.getHour();
+	}
+
+	@Path("/time/minute")
+	@GET
+	public int getMinute() {
+		return dt.getMinute();
+	}
+
+	@Path("/time/second")
+	@GET
+	public int getSecond() {
+		return dt.getSecond();
+	}
+	
+	@Path("/time/nano")
+	@GET
+	public int getNano() {
+		return dt.getNano();
+	}
+}

PC38-JerseySpring/src/main/java/sklep/model/Customer.java

+package sklep.model;
+
+import java.util.Objects;
+
+import javax.xml.bind.annotation.XmlRootElement;
+
+@XmlRootElement
+public class Customer {
+	private String email;
+	private String name;
+	private String phone;
+	private String address;
+	private String postalCode;
+	private String city;
+	
+	public Customer() {
+	}
+	
+	public Customer(String email, String name, String phone, String address, String postalCode, String city) {
+		this.email = email;
+		this.name = name;
+		this.phone = phone;
+		this.address = address;
+		this.postalCode = postalCode;
+		this.city = city;
+	}
+
+	public String getEmail() {
+		return email;
+	}
+
+	public void setEmail(String email) {
+		this.email = email;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public String getPhone() {
+		return phone;
+	}
+
+	public void setPhone(String phone) {
+		this.phone = phone;
+	}
+
+	public String getAddress() {
+		return address;
+	}
+
+	public void setAddress(String address) {
+		this.address = address;
+	}
+
+	public String getPostalCode() {
+		return postalCode;
+	}
+
+	public void setPostalCode(String postalCode) {
+		this.postalCode = postalCode;
+	}
+
+	public String getCity() {
+		return city;
+	}
+
+	public void setCity(String city) {
+		this.city = city;
+	}
+
+	@Override
+	public String toString() {
+		return "Customer [email=" + email + ", name=" + name + ", phone=" + phone + ", address=" + address
+				+ ", postalCode=" + postalCode + ", city=" + city + "]";
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(email, name, address, city, phone, postalCode);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Customer other = (Customer) obj;
+		return Objects.equals(email, other.email) && Objects.equals(name, other.name)
+				&& Objects.equals(address, other.address) && Objects.equals(city, other.city)
+				&& Objects.equals(phone, other.phone) && Objects.equals(postalCode, other.postalCode);
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/model/Order.java

+package sklep.model;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public class Order {
+	private Integer orderId;
+	private String customerEmail;
+	private LocalDateTime orderDate;
+	private Status orderStatus;
+	private final List<OrderProduct> products = new ArrayList<>();
+	
+	public Order() {
+	}
+
+	public Order(Integer orderId, String customerEmail, LocalDateTime orderDate, Status orderStatus) {
+		this.orderId = orderId;
+		this.customerEmail = customerEmail;
+		this.orderDate = orderDate;
+		this.orderStatus = orderStatus;
+	}
+
+	public static Order ofDbFields(int orderId, String customerEmail, java.sql.Timestamp orderDate, String orderStatus) {
+		return new Order(orderId, customerEmail,
+				orderDate.toLocalDateTime(),
+				Status.valueOf(orderStatus));
+	}
+
+	public Integer getOrderId() {
+		return orderId;
+	}
+
+	public void setOrderId(Integer orderId) {
+		this.orderId = orderId;
+	}
+
+	public String getCustomerEmail() {
+		return customerEmail;
+	}
+
+	public void setCustomerEmail(String customerEmail) {
+		this.customerEmail = customerEmail;
+	}
+
+	public LocalDateTime getOrderDate() {
+		return orderDate;
+	}
+
+	public void setOrderDate(LocalDateTime orderDate) {
+		this.orderDate = orderDate;
+	}
+
+	public Status getOrderStatus() {
+		return orderStatus;
+	}
+
+	public void setOrderStatus(Status orderStatus) {
+		this.orderStatus = orderStatus;
+	}
+	
+	public List<OrderProduct> getProducts() {
+		return Collections.unmodifiableList(products);
+	}
+
+	public void addProduct(OrderProduct product) {
+		products.add(product);
+	}
+
+	public void addProducts(Collection<OrderProduct> products) {
+		products.addAll(products);
+	}
+
+	public void setProducts(Collection<OrderProduct> products) {
+		products.clear();
+		products.addAll(products);
+	}
+
+	
+	@Override
+	public String toString() {
+		return "Order [orderId=" + orderId + ", customerEmail=" + customerEmail + ", orderDate=" + orderDate
+				+ ", orderStatus=" + orderStatus + "]";
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(customerEmail, orderDate, orderId, orderStatus);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Order other = (Order) obj;
+		return Objects.equals(customerEmail, other.customerEmail) && Objects.equals(orderDate, other.orderDate)
+				&& Objects.equals(orderId, other.orderId) && orderStatus == other.orderStatus;
+	}
+
+
+	public enum Status {
+		unpaid,
+		paid,
+		shipped,
+		closed;
+	}
+}

PC38-JerseySpring/src/main/java/sklep/model/OrderProduct.java

+package sklep.model;
+
+import java.math.BigDecimal;
+import java.util.Objects;
+
+public class OrderProduct {
+	private Integer orderId;
+	private Integer productId;
+	private int quantity;
+	private BigDecimal actualPrice;
+
+	public OrderProduct() {
+	}
+
+	public OrderProduct(Integer orderId, Integer productId, int quantity, BigDecimal actualPrice) {
+		this.orderId = orderId;
+		this.productId = productId;
+		this.quantity = quantity;
+		this.actualPrice = actualPrice;
+	}
+	
+	public static OrderProduct of(Integer orderId, Product product, int quantity) {
+		return new OrderProduct(orderId, product.getProductId(), quantity, product.getPrice());
+	}
+
+	public Integer getOrderId() {
+		return orderId;
+	}
+
+	public void setOrderId(Integer orderId) {
+		this.orderId = orderId;
+	}
+
+	public Integer getProductId() {
+		return productId;
+	}
+
+	public void setProductId(Integer productId) {
+		this.productId = productId;
+	}
+
+	public int getQuantity() {
+		return quantity;
+	}
+
+	public void setQuantity(int quantity) {
+		this.quantity = quantity;
+	}
+
+	public BigDecimal getActualPrice() {
+		return actualPrice;
+	}
+
+	public void setActualPrice(BigDecimal actualPrice) {
+		this.actualPrice = actualPrice;
+	}
+
+	@Override
+	public String toString() {
+		return "OrderProduct [orderId=" + orderId + ", productId=" + productId + ", quantity=" + quantity
+				+ ", actualPrice=" + actualPrice+ "]";
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(orderId, productId, quantity, actualPrice);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		OrderProduct other = (OrderProduct) obj;
+		return Objects.equals(orderId, other.orderId) && Objects.equals(productId, other.productId)
+				&& quantity == other.quantity
+				&& Objects.equals(actualPrice, other.actualPrice);
+	}
+	
+}

PC38-JerseySpring/src/main/java/sklep/model/Product.java

+package sklep.model;
+
+import java.math.BigDecimal;
+import java.util.Objects;
+
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+
+@XmlRootElement
+public class Product {
+	@XmlAttribute(name="id")
+	private Integer productId;
+	
+	@XmlElement(name="product-name")
+	private String productName;
+	
+	private BigDecimal price;
+	
+	private String description;
+	
+	public Product() {
+	}
+	
+	public Product(Integer productId, String productName, BigDecimal price, String description) {
+		this.productId = productId;
+		this.productName = productName;
+		this.price = price;
+		this.description = description;
+	}
+
+	public Integer getProductId() {
+		return productId;
+	}
+
+	public void setProductId(Integer productId) {
+		this.productId = productId;
+	}
+
+	public String getProductName() {
+		return productName;
+	}
+
+	public void setProductName(String productName) {
+		this.productName = productName;
+	}
+
+	public BigDecimal getPrice() {
+		return price;
+	}
+
+	public void setPrice(BigDecimal price) {
+		this.price = price;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+
+	public void setDescription(String description) {
+		this.description = description;
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(description, price, productId, productName);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Product other = (Product) obj;
+		return Objects.equals(productId, other.productId) && Objects.equals(productName, other.productName)
+				&& Objects.equals(price, other.price)
+				&& Objects.equals(description, other.description);
+	}
+
+	@Override
+	public String toString() {
+		return "Product [productId=" + productId + ", productName=" + productName + ", price=" + price
+				+ ", description=" + description + "]";
+	}
+
+	public String getHtml() {
+        return String.format("<div class='product'>"
+                + "<h2>%s</h2>"
+                + "<p>(nr %d)</p>"
+                + "<p>Cena: <strong>%,.2f PLN</strong></p>"
+                + "<p>%s</p>"
+                + "</div>",
+                getProductName(),
+                getProductId(),
+                getPrice(),
+                getDescription());
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/model/ProductList.java

+package sklep.model;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+
+@XmlRootElement(name="products")
+public class ProductList {
+	@XmlElement(name="product") // każdy element listy
+	private final List<Product> products = new ArrayList<>();
+	
+	public ProductList() {
+		// zostawia pustą listę
+	}
+	
+	public ProductList(Collection<Product> products) {
+		this.products.addAll(products);
+	}
+	
+	public List<Product> getProducts() {
+		return Collections.unmodifiableList(this.products);
+	}
+	
+	public void setProducts(Collection<Product> products) {
+		this.products.clear();
+		this.products.addAll(products);
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/model/package-info.java

+/**
+ * Dokumentacja pakietu.
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+package sklep.model;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;

PC38-JerseySpring/src/main/java/sklep/rest/RCustomers.java

+package sklep.rest;
+
+import java.util.List;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+
+import sklep.db.CustomerDAO;
+import sklep.db.DBConnection;
+import sklep.db.DBException;
+import sklep.db.RecordNotFound;
+import sklep.model.Customer;
+
+import javax.ws.rs.core.UriBuilder;
+
+@Path("/customers")
+@Produces({ "application/xml", "application/json", "text/plain"})
+@Consumes({ "application/xml", "application/json" })
+public class RCustomers {
+
+	@POST
+	public Response create(final Customer customer) throws DBException {
+		try(DBConnection db = DBConnection.open()) {
+			CustomerDAO customerDAO = db.customerDAO();
+			customerDAO.insert(customer);
+			db.commit();
+			return Response.created(UriBuilder.fromResource(RCustomers.class).path(customer.getEmail()).build()).build();
+		}
+	}
+
+	@GET
+	@Path("/{email}")
+	public Response findByEmail(@PathParam("email") final String email) throws DBException {
+		try(DBConnection db = DBConnection.open()) {
+			CustomerDAO customerDAO = db.customerDAO();
+			Customer customer = customerDAO.findByEmail(email);
+			return Response.ok(customer).build();
+		} catch (RecordNotFound e) {
+			return Response.status(Status.NOT_FOUND).build();
+		}	
+	}
+
+	@GET
+	public List<Customer> listAll() throws DBException {
+		try(DBConnection db = DBConnection.open()) {
+			CustomerDAO customerDAO = db.customerDAO();
+			return customerDAO.readAll();
+		}
+	}
+
+//	public List<Customer> listAll(@QueryParam("start") final Integer startPosition,
+//			@QueryParam("max") final Integer maxResult) {}
+
+	
+	@PUT
+	@Path("/{email}")
+	public Response update(@PathParam("email") final String email, final Customer customer) throws DBException {
+		try(DBConnection db = DBConnection.open()) {
+			CustomerDAO customerDAO = db.customerDAO();
+			customerDAO.update(customer);
+			db.commit();
+		}
+		return Response.noContent().build();
+	}
+
+	@DELETE
+	@Path("/{email}")
+	public Response deleteById(@PathParam("email") final String email) throws DBException {
+		try(DBConnection db = DBConnection.open()) {
+			CustomerDAO customerDAO = db.customerDAO();
+			customerDAO.delete(email);
+			db.commit();
+		}
+		return Response.noContent().build();
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/rest/RProducts.java

+package sklep.rest;
+
+import java.math.BigDecimal;
+import java.net.URI;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.PUT;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+
+import sklep.db.DBConnection;
+import sklep.db.DBException;
+import sklep.db.ProductDAO;
+import sklep.db.RecordNotFound;
+import sklep.model.Product;
+
+@Path("/products")
+@Produces({"application/xml", "application/json;charset=utf-8", "text/plain;charset=utf-8"})
+@Consumes({"application/xml", "application/json"})
+public class RProducts {
+	
+	@GET
+	public List<Product> readAll() throws DBException {
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			return productDAO.readAll();
+		}
+	}
+	
+	@GET
+	@Produces("text/html;charset=utf-8")
+	public String readAllHtml() throws DBException {
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			List<Product> products = productDAO.readAll();
+			
+			return products.stream()
+					.map(Product::getHtml)
+					.collect(Collectors.joining("", "<html><body>", "</body></html>"));
+		}
+	}
+	
+	@Path("/{id}")
+	@GET
+	public Product readOne(@PathParam("id") int productId) throws DBException, RecordNotFound {
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			return productDAO.findById(productId);
+		}
+	}
+	
+	@Path("/{id}")
+	@GET
+	@Produces("text/html;charset=utf-8")
+	public String readOneHtml(@PathParam("id") int productId) throws DBException, RecordNotFound {
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			Product product = productDAO.findById(productId);
+			return "<html><body>" + product.getHtml() + "</body></html>";
+		}
+	}
+	
+	@Path("/{id}/description")
+	@GET
+	@Produces({"text/plain", "application/json"})
+	public String getDescr(@PathParam("id") int productId) throws DBException, RecordNotFound {
+		return readOne(productId).getDescription();
+	}
+	
+	@Path("/{id}/price")
+	@GET
+	@Produces({"text/plain", "application/json"})
+	public BigDecimal getPrice(@PathParam("id") int productId) throws DBException, RecordNotFound {
+		return readOne(productId).getPrice();
+	}
+	
+	// metoda pozwalająca zmienić cenę
+	@Path("/{id}/price")
+	@PUT
+	@Consumes({"text/plain", "application/json"})
+	public void setPrice(@PathParam("id") int productId,
+			BigDecimal nowaCena) throws DBException, RecordNotFound {
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			Product product = productDAO.findById(productId);
+			product.setPrice(nowaCena);
+			productDAO.update(product);
+			db.commit();
+		}
+	}
+	
+	// W REST obowiązuje taka konwencja, że
+	// 1) istniejące dane nadpisuje się metodą PUT i wtedy w adresie podaje się adres tego zasobu, który aktualizujemy
+	@Path("/{id}")
+	@PUT
+	public void update(@PathParam("id") int productId,
+			Product product) throws DBException, RecordNotFound {
+		// Aby uniknąć niejednoznaczności, ustawiam w obiekcie product takie ID
+		// jakie wynika ze ścieżki
+		product.setProductId(productId);
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			productDAO.save(product);
+			db.commit();
+		}
+	}
+	
+	// 2) gdy rekord z danymi wyśle się metodą POST pod adres
+	// całej kolekcji, czyli np. /products , to oznacza to dodanie nowego rekordu do tej kolekcji
+	// z automatycznie nadanym nowym ID
+	@POST
+	public Response insert(Product product,
+			@Context UriInfo uriInfo) throws DBException, RecordNotFound {
+		// Aby uniknąć niejednoznaczności, kasuję ID, nawet jeśli jest podane w produkcie
+		// i zawsze zapisuję pod nowym adresem.
+		product.setProductId(null);
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			productDAO.insertNew(product);
+			db.commit();
+			
+			URI location = uriInfo.getRequestUriBuilder().path("/{id}").build(product.getProductId());
+			return Response.created(location).build();
+		}
+	}
+	
+	@DELETE
+	@Path("/{id}")
+	public void delete(@PathParam("id") int productId) throws DBException {
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			productDAO.delete(productId);
+			db.commit();
+		}
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/rest/RProductsPDF.java

+package sklep.rest;
+
+import java.util.List;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+
+import sklep.db.DBConnection;
+import sklep.db.DBException;
+import sklep.db.ProductDAO;
+import sklep.db.RecordNotFound;
+import sklep.model.Product;
+import sklep.model.ProductList;
+
+@Path("/products.pdf")
+@Produces("application/pdf")
+public class RProductsPDF {
+	@GET
+	public ProductList readAll() throws DBException {
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			return new ProductList(productDAO.readAll());
+		}
+	}
+	
+	@Path("/{id}")
+	@GET
+	public Product readOne(@PathParam("id") int productId) throws DBException, RecordNotFound {
+		try(DBConnection db = DBConnection.open()) {
+			ProductDAO productDAO = db.productDAO();
+			return productDAO.findById(productId);
+		}
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

PC38-JerseySpring/src/main/java/sklep/rest/ext/DefaultExceptionMapper.java

+package sklep.rest.ext;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+@Provider
+public class DefaultExceptionMapper implements ExceptionMapper<Exception> {
+
+	@Override
+	public Response toResponse(Exception e) {
+		String tresc = String.format("<html><body>"
+				+ "<h1>Błąd</h1>"
+				+ "<div>Błąd typu <code>%s</code></div>"
+				+ "<div style='color:red'>%s</div>"
+				+ "</body></html>",
+				e.getClass().getName(),
+				e.getMessage());
+		
+		return Response.status(Status.INTERNAL_SERVER_ERROR)
+				.type("text/html;charset=utf-8")
+				.entity(tresc)
+				.build();
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/rest/ext/ObslugaXSL.java

+package sklep.rest.ext;
+
+import java.io.BufferedOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URI;
+
+import javax.ws.rs.WebApplicationException;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.util.JAXBSource;
+import javax.xml.transform.Result;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.sax.SAXResult;
+import javax.xml.transform.stream.StreamSource;
+
+import org.apache.fop.apps.Fop;
+import org.apache.fop.apps.FopFactory;
+import org.apache.xmlgraphics.util.MimeConstants;
+
+public class ObslugaXSL {
+	// obiekt -(za pomocą JAXB)-> XML -(za pomocą transformera)-> XML(XSL-FO)
+	// --(za pomocą Apache FOP)-> PDF -> output
+	public void wypiszPDF(Object obj, OutputStream output) {
+		try(InputStream configStream = ObslugaXSL.class.getResourceAsStream("fop-conf.xml")) {
+
+			JAXBContext ctx = JAXBContext.newInstance(obj.getClass());
+			JAXBSource src = new JAXBSource(ctx, obj);
+
+			FopFactory fopFactory = FopFactory.newInstance(new URI(""), configStream);
+
+			try(BufferedOutputStream pdfOut = new BufferedOutputStream(output)) {
+				Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, pdfOut);
+				TransformerFactory tf = TransformerFactory.newInstance();
+				StreamSource xsl = new StreamSource(ObslugaXSL.class.getResourceAsStream("sklep-fo.xsl"));
+	
+				Transformer tr = tf.newTransformer(xsl);
+				Result res = new SAXResult(fop.getDefaultHandler());
+				tr.transform(src, res);
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+			throw new WebApplicationException("Problem FOP " + e.getMessage(), 500);
+		}
+	}
+
+}
+
+
+
+
+

PC38-JerseySpring/src/main/java/sklep/rest/ext/PDFWriter.java

+package sklep.rest.ext;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+
+import sklep.model.Product;
+import sklep.model.ProductList;
+
+@Provider
+public class PDFWriter implements MessageBodyWriter<Object> {
+	private static final MediaType PDF_TYPE = new MediaType("application", "pdf");
+	
+	@Override
+	public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
+		return (type == Product.class || type == ProductList.class) && PDF_TYPE.isCompatible(mediaType);
+	}
+
+	@Override
+	public void writeTo(Object obj, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
+			MultivaluedMap<String, Object> httpHeaders, OutputStream output)
+			throws IOException, WebApplicationException {
+		
+		String fileName = "products.pdf";
+		if(obj instanceof Product) {
+			Product product = (Product) obj;
+			fileName = product.getProductName().replace(' ', '_') + ".pdf";
+		}
+		//httpHeaders.add("Content-Disposition", "attachment;filename=" + fileName);
+		httpHeaders.add("Content-Disposition", "inline;filename=" + fileName);
+		
+		ObslugaXSL obslugaXSL = new ObslugaXSL();
+		obslugaXSL.wypiszPDF(obj, output);
+	}
+
+}

PC38-JerseySpring/src/main/java/sklep/rest/ext/RecordNotFoundMapper.java

+package sklep.rest.ext;
+
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.ext.ExceptionMapper;
+import javax.ws.rs.ext.Provider;
+
+import sklep.db.RecordNotFound;
+
+@Provider
+public class RecordNotFoundMapper implements ExceptionMapper<RecordNotFound> {
+
+	@Override
+	public Response toResponse(RecordNotFound e) {
+		String tresc = String.format("<html><body>"
+				+ "<h1>Nie znaleziono</h1>"
+				+ "<div style='color:red'>%s</div>"
+				+ "</body></html>",
+				e.getMessage());
+		
+		return Response.status(Status.NOT_FOUND)
+				.type("text/html;charset=utf-8")
+				.entity(tresc)
+				.build();
+	}
+
+}

PC38-JerseySpring/src/main/resources/sklep.properties

+url=jdbc:postgresql://localhost:5432/sklep
+driver_class=org.postgresql.Driver
+user=kurs
+password=abc123
+photo_dir=/home/patryk/sklep/foto

PC38-JerseySpring/src/main/resources/sklep/rest/ext/fop-conf.xml

+<?xml version="1.0"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!-- $Id: fop.xconf 447325 2006-09-18 08:55:33Z jeremias $ -->
+
+<!--
+
+This is an example configuration file for FOP.
+This file contains the same settings as the default values
+and will have no effect if used unchanged.
+
+Relative config url's will be resolved relative to
+the location of this file.
+
+-->
+
+<!-- NOTE: This is the version of the configuration -->
+<fop version="1.0">
+
+  <!-- Base URL for resolving relative URLs -->
+  <base>.</base>
+  
+  <!-- Source resolution in dpi (dots/pixels per inch) for determining the size of pixels in SVG and bitmap images, default: 72dpi -->
+  <source-resolution>72</source-resolution>
+  <!-- Target resolution in dpi (dots/pixels per inch) for specifying the target resolution for generated bitmaps, default: 72dpi -->
+  <target-resolution>72</target-resolution>
+  
+  <!-- Default page-height and page-width, in case
+       value is specified as auto -->
+  <default-page-settings height="11in" width="8.26in"/>
+  
+  <!-- Information for specific renderers -->
+  <!-- Uses renderer mime type for renderers -->
+  <renderers>
+    <renderer mime="application/pdf">
+      <filterList>
+        <!-- provides compression using zlib flate (default is on) -->
+        <value>flate</value>
+  
+        <!-- encodes binary data into printable ascii characters (default off)
+             This provides about a 4:5 expansion of data size -->
+        <!-- <value>ascii-85</value> -->
+  
+        <!-- encodes binary data with hex representation (default off)
+             This filter is not recommended as it doubles the data size -->
+        <!-- <value>ascii-hex</value> -->
+      </filterList>
+
+      <fonts>
+        <!-- embedded fonts -->
+        <!--
+        This information must exactly match the font specified
+        in the fo file. Otherwise it will use a default font.
+
+        For example,
+        <fo:inline font-family="Arial" font-weight="bold" font-style="normal">
+            Arial-normal-normal font
+        </fo:inline>
+        for the font triplet specified by:
+        <font-triplet name="Arial" style="normal" weight="bold"/>
+
+        If you do not want to embed the font in the pdf document
+        then do not include the "embed-url" attribute.
+        The font will be needed where the document is viewed
+        for it to be displayed properly.
+
+        possible styles: normal | italic | oblique | backslant
+        possible weights: normal | bold | 100 | 200 | 300 | 400
+                          | 500 | 600 | 700 | 800 | 900
+        (normal = 400, bold = 700)
+        -->
+
+        <!--
+        <font kerning="yes" embed-url="/usr/share/fonts/truetype/msttcorefonts/arial.ttf">
+          <font-triplet name="Arial" style="normal" weight="normal"/>
+          <font-triplet name="ArialMT" style="normal" weight="normal"/>
+        </font>
+        <font kerning="yes" embed-url="/usr/share/fonts/truetype/msttcorefonts/arial.ttf">
+          <font-triplet name="Arial" style="normal" weight="normal"/>
+          <font-triplet name="ArialMT" style="normal" weight="normal"/>
+        </font>
+        -->
+        
+        <!-- PC -->
+        <directory recursive="true">/usr/share/fonts/truetype/</directory>
+        <directory recursive="true">C:\Windows\Fonts</directory>
+        
+      </fonts>
+
+      <!-- This option lets you specify additional options on an XML handler -->
+      <!--xml-handler namespace="http://www.w3.org/2000/svg">
+        <stroke-text>false</stroke-text>
+      </xml-handler-->
+
+    </renderer>
+
+    <renderer mime="application/postscript">
+      <!-- This option forces the PS renderer to rotate landscape pages -->
+      <!--auto-rotate-landscape>true</auto-rotate-landscape-->
+      
+      <!-- This option lets you specify additional options on an XML handler -->
+      <!--xml-handler namespace="http://www.w3.org/2000/svg">
+        <stroke-text>false</stroke-text>
+      </xml-handler-->
+    </renderer>
+
+    <renderer mime="application/vnd.hp-PCL">
+    </renderer>
+
+    <!-- MIF does not have a renderer
+    <renderer mime="application/vnd.mif">
+    </renderer>
+    -->
+
+    <renderer mime="image/svg+xml">
+      <format type="paginated"/>
+      <link value="true"/>
+      <strokeText value="false"/>
+    </renderer>
+
+    <renderer mime="application/awt">
+    </renderer>
+
+    <renderer mime="image/png">
+      <!--transparent-page-background>true</transparent-page-background-->
+    </renderer>
+
+    <renderer mime="image/tiff">
+      <!--transparent-page-background>true</transparent-page-background-->
+      <!--compression>CCITT T.6</compression-->
+    </renderer>
+
+    <renderer mime="text/xml">
+    </renderer>
+
+    <!-- RTF does not have a renderer
+    <renderer mime="text/rtf">
+    </renderer>
+    -->
+
+    <renderer mime="text/plain">
+      <pageSize columns="80"/>
+    </renderer>
+
+  </renderers>
+
+</fop>
+

PC38-JerseySpring/src/main/resources/sklep/rest/ext/sklep-fo.xsl

+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0"
+	xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+	xmlns:fo="http://www.w3.org/1999/XSL/Format">
+
+	<xsl:output method="xml" encoding="utf-8" />
+
+	<xsl:template match="/">
+		<fo:root font-family="Arial">
+			<fo:layout-master-set>
+				<fo:simple-page-master master-name="A4"
+					page-width="210mm" page-height="297mm" margin-top="1cm"
+					margin-bottom="1cm" margin-left="1.5cm" margin-right="1.5cm">
+					<fo:region-body margin="2cm" />
+				</fo:simple-page-master>
+			</fo:layout-master-set>
+
+			<fo:page-sequence master-reference="A4">
+				<fo:flow flow-name="xsl-region-body">
+					<xsl:apply-templates />
+					<fo:block/>
+				</fo:flow>
+			</fo:page-sequence>
+		</fo:root>
+	</xsl:template>
+
+	<xsl:template match="product">
+		<fo:block-container space-before.minimum="0.5em"
+			page-break-inside="avoid">
+			<fo:block>
+				<xsl:text>Produkt nr </xsl:text>
+				<xsl:value-of select="@id" />
+				<xsl:text>.</xsl:text>
+			</fo:block>
+			<fo:block-container margin="1em"
+				border-style="solid" border-width="2.5pt" padding="3pt"
+				border-color="#2233AA">
+				<fo:block font-weight="bold" font-size="14pt"
+					margin-bottom="1em" color="#FF2244">
+					<xsl:apply-templates select="product-name" />
+				</fo:block>
+				<fo:block font-weight="bold" color="green">
+					<xsl:text>Cena: </xsl:text>
+					<xsl:apply-templates select="price" />
+				</fo:block>
+				<fo:block font-weight="bold" font-size="12pt" margin-bottom="1em">
+					<xsl:apply-templates select="description" />
+				</fo:block>
+			</fo:block-container>
+		</fo:block-container>
+	</xsl:template>
+
+</xsl:stylesheet>