James Moger
2012-10-10 5d7545652a6529c9076f67acd75f7a977c8a44a6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
/*
 * Copyright 2011 gitblit.com.
 *
 * Licensed 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.
 */
package com.gitblit.models;
 
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
import com.gitblit.Constants.AccessPermission;
import com.gitblit.Constants.AccessRestrictionType;
import com.gitblit.Constants.Unused;
 
/**
 * TeamModel is a serializable model class that represents a group of users and
 * a list of accessible repositories.
 * 
 * @author James Moger
 * 
 */
public class TeamModel implements Serializable, Comparable<TeamModel> {
 
    private static final long serialVersionUID = 1L;
 
    // field names are reflectively mapped in EditTeam page
    public String name;
    public final Set<String> users = new HashSet<String>();
    // retained for backwards-compatibility with RPC clients
    @Deprecated
    public final Set<String> repositories = new HashSet<String>();
    public final Map<String, AccessPermission> permissions = new HashMap<String, AccessPermission>();
    public final Set<String> mailingLists = new HashSet<String>();
    public final List<String> preReceiveScripts = new ArrayList<String>();
    public final List<String> postReceiveScripts = new ArrayList<String>();
 
    public TeamModel(String name) {
        this.name = name;
    }
 
    /**
     * @use hasRepositoryPermission
     * @param name
     * @return
     */
    @Deprecated
    @Unused
    public boolean hasRepository(String name) {
        return hasRepositoryPermission(name);
    }
 
    @Deprecated
    @Unused
    public void addRepository(String name) {
        addRepositoryPermission(name);
    }
    
    @Deprecated
    @Unused
    public void addRepositories(Collection<String> names) {
        addRepositoryPermissions(names);
    }
 
    @Deprecated
    @Unused
    public void removeRepository(String name) {
        removeRepositoryPermission(name);
    }
    
    /**
     * Returns true if the team has any type of specified access permission for
     * this repository.
     * 
     * @param name
     * @return true if team has a specified access permission for the repository
     */
    public boolean hasRepositoryPermission(String name) {
        String repository = AccessPermission.repositoryFromRole(name).toLowerCase();
        return permissions.containsKey(repository) || repositories.contains(repository);
    }
    
    /**
     * Adds a repository permission to the team.
     * <p>
     * Role may be formatted as:
     * <ul>
     * <li> myrepo.git <i>(this is implicitly RW+)</i>
     * <li> RW+:myrepo.git
     * </ul>
     * @param role
     */
    public void addRepositoryPermission(String role) {
        AccessPermission permission = AccessPermission.permissionFromRole(role);
        String repository = AccessPermission.repositoryFromRole(role).toLowerCase();
        repositories.add(repository);
        permissions.put(repository, permission);
    }
 
    public void addRepositoryPermissions(Collection<String> roles) {
        for (String role:roles) {
            addRepositoryPermission(role);
        }
    }
    
    public AccessPermission removeRepositoryPermission(String name) {
        String repository = AccessPermission.repositoryFromRole(name).toLowerCase();
        repositories.remove(repository);
        return permissions.remove(repository);
    }
    
    public void setRepositoryPermission(String repository, AccessPermission permission) {
        permissions.put(repository.toLowerCase(), permission);
        repositories.add(repository.toLowerCase());
    }
    
    public AccessPermission getRepositoryPermission(RepositoryModel repository) {
        AccessPermission permission = AccessPermission.NONE;
        if (permissions.containsKey(repository.name.toLowerCase())) {
            // exact repository permission specified
            AccessPermission p = permissions.get(repository.name.toLowerCase());
            if (p != null) {
                permission = p;
            }
        } else {
            // search for regex permission match
            for (String key : permissions.keySet()) {
                if (repository.name.matches(key)) {
                    AccessPermission p = permissions.get(key);
                    if (p != null) {
                        permission = p;
                    }
                }
            }
        }
        return permission;
    }
    
    private boolean canAccess(RepositoryModel repository, AccessRestrictionType ifRestriction, AccessPermission requirePermission) {
        if (repository.accessRestriction.atLeast(ifRestriction)) {
            AccessPermission permission = getRepositoryPermission(repository);
            return permission.atLeast(requirePermission);
        }
        return true;
    }
    
    public boolean canView(RepositoryModel repository) {
        return canAccess(repository, AccessRestrictionType.VIEW, AccessPermission.VIEW);
    }
 
    public boolean canClone(RepositoryModel repository) {
        return canAccess(repository, AccessRestrictionType.CLONE, AccessPermission.CLONE);
    }
 
    public boolean canPush(RepositoryModel repository) {
        if (repository.isFrozen) {
            return false;
        }
        return canAccess(repository, AccessRestrictionType.PUSH, AccessPermission.PUSH);
    }
 
    public boolean canCreateRef(RepositoryModel repository) {
        if (repository.isFrozen) {
            return false;
        }
        return canAccess(repository, AccessRestrictionType.PUSH, AccessPermission.CREATE);
    }
 
    public boolean canDeleteRef(RepositoryModel repository) {
        if (repository.isFrozen) {
            return false;
        }
        return canAccess(repository, AccessRestrictionType.PUSH, AccessPermission.DELETE);
    }
 
    public boolean canRewindRef(RepositoryModel repository) {
        if (repository.isFrozen) {
            return false;
        }
        return canAccess(repository, AccessRestrictionType.PUSH, AccessPermission.REWIND);
    }
 
    public boolean hasUser(String name) {
        return users.contains(name.toLowerCase());
    }
 
    public void addUser(String name) {
        users.add(name.toLowerCase());
    }
 
    public void addUsers(Collection<String> names) {
        for (String name:names) {
            users.add(name.toLowerCase());
        }
    }
 
    public void removeUser(String name) {
        users.remove(name.toLowerCase());
    }
 
    public void addMailingLists(Collection<String> addresses) {
        for (String address:addresses) {
            mailingLists.add(address.toLowerCase());
        }
    }
 
    @Override
    public String toString() {
        return name;
    }
 
    @Override
    public int compareTo(TeamModel o) {
        return name.compareTo(o.name);
    }
}