/**
 * 用戶信息
 * @author daify
 **/
@Data
@Entity
@Table(name = "cascade_user")
public class User {

    @Id
    @GeneratedValue
    private Long id;
    
    private String name;
    
    private Integer age;
    
    private Double point;
    /**
     * CascadeType包含的類別  級聯(lián)：給當(dāng)前設(shè)置的實(shí)體操作另一個(gè)實(shí)體的權(quán)限
     *      CascadeType.ALL 級聯(lián)所有操作
     *      CascadeType.PERSIST 級聯(lián)持久化（保存）操作
     *      CascadeType.MERGE   級聯(lián)更新（合并）操作
     *      CascadeType.REMOVE  級聯(lián)刪除操作
     *      CascadeType.REFRESH 級聯(lián)刷新操作
     *      CascadeType.DETACH 級聯(lián)分離操作,如果你要?jiǎng)h除一個(gè)實(shí)體，但是它有外鍵無法刪除，這個(gè)級聯(lián)權(quán)限會撤銷所有相關(guān)的外鍵關(guān)聯(lián)。
     */
    @OneToOne(targetEntity = UserCart.class,
            cascade = CascadeType.ALL,
            mappedBy = "user")
    private UserCart userCart;

    @OneToOne(targetEntity = UserInfo.class,
            cascade = CascadeType.ALL)
    @JoinTable(name = "user_info_table",
            joinColumns = @JoinColumn(name="user_id"),
            inverseJoinColumns = @JoinColumn(name = "info_id"))
    private UserInfo userInfo;

}

@Data
@Entity
@Table(name = "cascade_user_cart")
public class UserCart {

    @Id
    @GeneratedValue
    private Long id;
    
    private Integer count;
    
    private Double totalMoney;
    
    private Date updateTime;

    /**
     * CascadeType包含的類別  級聯(lián)：給當(dāng)前設(shè)置的實(shí)體操作另一個(gè)實(shí)體的權(quán)限
     *      CascadeType.ALL 級聯(lián)所有操作
     *      CascadeType.PERSIST 級聯(lián)持久化（保存）操作
     *      CascadeType.MERGE   級聯(lián)更新（合并）操作
     *      CascadeType.REMOVE  級聯(lián)刪除操作
     *      CascadeType.REFRESH 級聯(lián)刷新操作
     *      CascadeType.DETACH 級聯(lián)分離操作,如果你要?jiǎng)h除一個(gè)實(shí)體，但是它有外鍵無法刪除，這個(gè)級聯(lián)權(quán)限會撤銷所有相關(guān)的外鍵關(guān)聯(lián)。
     */
    @OneToOne(targetEntity = User.class,
            cascade = {},
            fetch = FetchType.LAZY)
    private User user;
}

@Data
@Entity
@Table(name = "cascade_user_info")
public class UserInfo {

    @Id
    @GeneratedValue
    private Long id;
    
    private String userInfo;
    
    private String config;
}

    @Test
    public void testUserSave() {
        User defUser1 = UserMock.getDefUser1();
        UserCart defUserCart1 = UserCartMock.getDefUserCart1();
        defUser1.setUserCart(defUserCart1);
        defUserCart1.setUser(defUser1);
        // 此時(shí)保存用戶，用戶購物車應(yīng)該也被保存
        userRepository.save(defUser1);
        List <UserCart> all = userCartRepository.findAll();
        Assert.assertNotNull(all);
        Assert.assertTrue(all.size() == 1);
    }

    @Test
    public void testUserCartDelete() {
        User defUser1 = UserMock.getDefUser1();
        UserCart defUserCart1 = UserCartMock.getDefUserCart1();
        defUser1.setUserCart(defUserCart1);
        // 此時(shí)保存用戶，用戶購物車應(yīng)該也被保存
        userRepository.save(defUser1);
        // 此時(shí)刪除用戶購物車并不會刪除用戶
        userCartRepository.deleteAll();
        List <User> all1 = userRepository.findAll();
        Assert.assertNotNull(all1);
        Assert.assertTrue(all1.size() == 1);
    }

    @Test
    public void testUserDelete() {
        User defUser1 = UserMock.getDefUser1();
        UserCart defUserCart1 = UserCartMock.getDefUserCart1();
        defUser1.setUserCart(defUserCart1);
        // 此時(shí)保存用戶，用戶購物車應(yīng)該也被保存
        userRepository.save(defUser1);
        // 此時(shí)刪除用戶購物車并不會刪除用戶
        userRepository.delete(defUser1);
        List <UserCart> all = userCartRepository.findAll();
        Assert.assertTrue(all.size() == 0);
    }

@Data
@Entity
@Table(name = "cascade_order")
public class Order {

    @Id
    @GeneratedValue
    private Long id;
    
    private String orderNo;
    
    private Integer count;
    
    private Double money;

    @OneToMany(mappedBy = "order",
            cascade = CascadeType.ALL,
            fetch = FetchType.EAGER)
    private List<OrderItem> orderItems;
    
    /**
    * 重寫toString防止死循環(huán)
    * @return 
    */
    @Override 
    public String toString() {
        return "OrderItem{" + "id=" + id + ", productId='" + productId + '\'' + ", money=" + money
               + ", count=" + count + ", productName='" + productName + '\'' + ", order=" + order
               + '}';
    }
    
}

@Data
@Entity
@Table(name = "cascade_order_item")
public class OrderItem {

    @Id
    @GeneratedValue
    private Long id;

    private String productId;

    private Double money;
    
    private Integer count;
    
    private String productName;
    
    @ManyToOne(targetEntity = Order.class,
            cascade = {},
            fetch = FetchType.EAGER)
    @JoinColumn(
            // 設(shè)置在OrderItem表中的關(guān)聯(lián)字段(外鍵)
            name="order_id"
    )
    // 防止json序列化死循環(huán)問題解決
    @JsonBackReference
    private Order order;
}

    @Test
    public void testOrder() {
        Order defOrder1 = OrderMock.getDefOrder1();
        List <OrderItem> allDefOrder = OrderItemMock.getAllDefOrder();
        // order 維持orderItem關(guān)系
        defOrder1.setOrderItems(allDefOrder);
        // orderItem維持order關(guān)系
        allDefOrder.forEach(o -> o.setOrder(defOrder1));
        Order save = orderRepository.save(defOrder1);
        List <OrderItem> all = orderItemRepository.findAll();
        Assert.assertTrue(all.size() == allDefOrder.size());

        orderItemRepository.delete(all.get(0));
        Order order = orderRepository.findById(save.getId()).get();
        Assert.assertNotNull(order);

        orderRepository.deleteById(order.getId());
        List <OrderItem> all1 = orderItemRepository.findAll();
        Assert.assertTrue(all1.size() == 0);

    }

@Data
@Entity
@Table(name = "cascade_user")
public class User {

    @Id
    @GeneratedValue
    private Long id;
    
    private String name;
    
    private Integer age;
    
    private Double point;

    @ManyToMany(targetEntity = UserTag.class,
            cascade = {},
            fetch = FetchType.LAZY)
    // 假如不定義，jpa會生成“表名1”+“_”+“表名2”的中間表
    @JoinTable(
            // 定義中間表的名稱
            name = "cascade_user_tag_table",
            // 定義中間表中關(guān)聯(lián)User表的外鍵名
            joinColumns = {
                    @JoinColumn(name = "user_id",
                            referencedColumnName = "id")
            },
            // 定義中間表中關(guān)聯(lián)UserTag表的外鍵名
            inverseJoinColumns = {
                    @JoinColumn(name = "tags_id",
                            referencedColumnName = "id")
            }
    )
    private Set<UserTag> tags;

}

@Data
@Entity
@Table(name = "cascade_user_tag")
public class UserTag {

    @Id
    @GeneratedValue
    private Long id;
    
    private String tagName;

    @ManyToMany(mappedBy = "tags",
            cascade = {},
            fetch = FetchType.LAZY)
    private List<User> userList;
}

    @Test
    public void testUserTag() {
        User defUser1 = UserMock.getDefUser1();
        UserTag defTag1 = UserTagMock.getDefTag1();
        UserTag defTag2 = UserTagMock.getDefTag2();
        defUser1 = userRepository.save(defUser1);
        defTag1 = userTagRepository.save(defTag1);
        defTag2 = userTagRepository.save(defTag2);

        defUser1.getTags().add(defTag1);
        defUser1.getTags().add(defTag2);

        defUser1 = userRepository.save(defUser1);
        // 此時(shí)會報(bào)錯(cuò)，因?yàn)橹虚g表關(guān)系為User維護(hù)
        try {
            userTagRepository.delete(defTag2);
        } catch (Exception e) {
            log.info(e.getCause().getMessage());
            Assert.assertTrue(e instanceof DataIntegrityViolationException);
        }
        // 修改User表中關(guān)系
        defUser1.setTags(new HashSet <>());
        defUser1.getTags().add(defTag1);
        defUser1 = userRepository.save(defUser1);
        // 此時(shí)可以刪除
        userTagRepository.delete(defTag2);
        // 直接刪除用戶沒問題
        userRepository.delete(defUser1);
    }