1 package de.dlr.shepard.auth.permission.model;
2
3 import de.dlr.shepard.auth.users.entities.User;
4 import de.dlr.shepard.auth.users.entities.UserGroup;
5 import de.dlr.shepard.common.neo4j.entities.BasicEntity;
6 import de.dlr.shepard.common.util.Constants;
7 import de.dlr.shepard.common.util.HasId;
8 import de.dlr.shepard.common.util.PermissionType;
9 import java.util.ArrayList;
10 import java.util.List;
11 import java.util.Objects;
12 import lombok.Data;
13 import lombok.NoArgsConstructor;
14 import lombok.ToString;
15 import org.neo4j.ogm.annotation.GeneratedValue;
16 import org.neo4j.ogm.annotation.Id;
17 import org.neo4j.ogm.annotation.NodeEntity;
18 import org.neo4j.ogm.annotation.Relationship;
19 import org.neo4j.ogm.annotation.Relationship.Direction;
20
21 @NodeEntity
22 @Data
23 @NoArgsConstructor
24 public class Permissions implements HasId {
25
26 @Id
27 @GeneratedValue
28 private Long id;
29
30 @Relationship(type = Constants.HAS_PERMISSIONS, direction = Direction.INCOMING)
31 private List<BasicEntity> entities;
32
33 @Relationship(type = Constants.OWNED_BY, direction = Direction.OUTGOING)
34 private User owner;
35
36 private PermissionType permissionType;
37
38 @ToString.Exclude
39 @Relationship(type = Constants.READABLE_BY, direction = Direction.OUTGOING)
40 private List<User> reader = new ArrayList<>();
41
42 @ToString.Exclude
43 @Relationship(type = Constants.WRITEABLE_BY, direction = Direction.OUTGOING)
44 private List<User> writer = new ArrayList<>();
45
46 @ToString.Exclude
47 @Relationship(type = Constants.READABLE_BY_GROUP, direction = Direction.OUTGOING)
48 private List<UserGroup> readerGroups = new ArrayList<>();
49
50 @ToString.Exclude
51 @Relationship(type = Constants.WRITEABLE_BY_GROUP, direction = Direction.OUTGOING)
52 private List<UserGroup> writerGroups = new ArrayList<>();
53
54 @ToString.Exclude
55 @Relationship(type = Constants.MANAGEABLE_BY, direction = Direction.OUTGOING)
56 private List<User> manager = new ArrayList<>();
57
58
59
60
61
62
63 public Permissions(long id) {
64 this.id = id;
65 }
66
67 public Permissions(BasicEntity entity, User owner, PermissionType permissionType) {
68 this.entities = List.of(entity);
69 this.owner = owner;
70 this.permissionType = permissionType;
71 }
72
73 public Permissions(
74 User owner,
75 List<User> reader,
76 List<User> writer,
77 List<UserGroup> readerGroups,
78 List<UserGroup> writerGroups,
79 List<User> manager,
80 PermissionType permissionType
81 ) {
82 this.owner = owner;
83 this.reader = reader;
84 this.writer = writer;
85 this.writerGroups = writerGroups;
86 this.readerGroups = readerGroups;
87 this.manager = manager;
88 this.permissionType = permissionType;
89 }
90
91 @Override
92 public int hashCode() {
93 final int prime = 31;
94 int result = 1;
95 result = prime * result + Objects.hash(id, permissionType, readerGroups, writerGroups);
96 result = prime * result + HasId.hashcodeHelper(entities);
97 result = prime * result + HasId.hashcodeHelper(owner);
98 result = prime * result + HasId.hashcodeHelper(reader);
99 result = prime * result + HasId.hashcodeHelper(writer);
100 result = prime * result + HasId.hashcodeHelper(manager);
101 return result;
102 }
103
104 @Override
105 public boolean equals(Object obj) {
106 if (this == obj) return true;
107 if (!(obj instanceof Permissions)) return false;
108 Permissions other = (Permissions) obj;
109 return (
110 Objects.equals(id, other.id) &&
111 Objects.equals(permissionType, other.permissionType) &&
112 Objects.equals(readerGroups, other.readerGroups) &&
113 Objects.equals(writerGroups, other.writerGroups) &&
114 HasId.areEqualSetsByUniqueId(entities, other.entities) &&
115 HasId.equalsHelper(owner, other.owner) &&
116 HasId.areEqualSetsByUniqueId(reader, other.reader) &&
117 HasId.areEqualSetsByUniqueId(writer, other.writer) &&
118 HasId.areEqualSetsByUniqueId(manager, other.manager)
119 );
120 }
121
122 @Override
123 public String getUniqueId() {
124 return id.toString();
125 }
126 }