| // Copyright (C) 2013 The Android Open Source Project |
| // |
| // 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.google.gerrit.client.groups; |
| |
| import com.google.gerrit.client.VoidResult; |
| import com.google.gerrit.client.account.AccountInfo; |
| import com.google.gerrit.client.rpc.NativeString; |
| import com.google.gerrit.client.rpc.Natives; |
| import com.google.gerrit.client.rpc.RestApi; |
| import com.google.gerrit.reviewdb.client.AccountGroup; |
| import com.google.gwt.core.client.JavaScriptObject; |
| import com.google.gwt.core.client.JsArray; |
| import com.google.gwt.user.client.rpc.AsyncCallback; |
| |
| import java.util.Set; |
| |
| /** |
| * A collection of static methods which work on the Gerrit REST API for specific |
| * groups. |
| */ |
| public class GroupApi { |
| /** Create a new group */ |
| public static void createGroup(String groupName, AsyncCallback<GroupInfo> cb) { |
| JavaScriptObject in = JavaScriptObject.createObject(); |
| new RestApi("/groups/").id(groupName).ifNoneMatch().put(in, cb); |
| } |
| |
| public static void getGroupDetail(String group, AsyncCallback<GroupInfo> cb) { |
| group(group).view("detail").get(cb); |
| } |
| |
| /** Get the name of a group */ |
| public static void getGroupName(AccountGroup.UUID group, |
| AsyncCallback<NativeString> cb) { |
| group(group).view("name").get(cb); |
| } |
| |
| /** Check if the current user is owner of a group */ |
| public static void isGroupOwner(String groupName, final AsyncCallback<Boolean> cb) { |
| GroupMap.myOwned(groupName, new AsyncCallback<GroupMap>() { |
| @Override |
| public void onSuccess(GroupMap result) { |
| cb.onSuccess(!result.isEmpty()); |
| } |
| @Override |
| public void onFailure(Throwable caught) { |
| cb.onFailure(caught); |
| } |
| }); |
| } |
| |
| /** Rename a group */ |
| public static void renameGroup(AccountGroup.UUID group, |
| String newName, AsyncCallback<VoidResult> cb) { |
| GroupInput in = GroupInput.create(); |
| in.name(newName); |
| group(group).view("name").put(in, cb); |
| } |
| |
| /** Set description for a group */ |
| public static void setGroupDescription(AccountGroup.UUID group, |
| String description, AsyncCallback<VoidResult> cb) { |
| RestApi call = group(group).view("description"); |
| if (description != null && !description.isEmpty()) { |
| GroupInput in = GroupInput.create(); |
| in.description(description); |
| call.put(in, cb); |
| } else { |
| call.delete(cb); |
| } |
| } |
| |
| /** Set owner for a group */ |
| public static void setGroupOwner(AccountGroup.UUID group, |
| String owner, AsyncCallback<GroupInfo> cb) { |
| GroupInput in = GroupInput.create(); |
| in.owner(owner); |
| group(group).view("owner").put(in, cb); |
| } |
| |
| /** Set the options for a group */ |
| public static void setGroupOptions(AccountGroup.UUID group, |
| boolean isVisibleToAll, AsyncCallback<VoidResult> cb) { |
| GroupOptionsInput in = GroupOptionsInput.create(); |
| in.visibleToAll(isVisibleToAll); |
| group(group).view("options").put(in, cb); |
| } |
| |
| /** Add member to a group. */ |
| public static void addMember(AccountGroup.UUID group, String member, |
| AsyncCallback<AccountInfo> cb) { |
| members(group).id(member).put(cb); |
| } |
| |
| /** Add members to a group. */ |
| public static void addMembers(AccountGroup.UUID group, |
| Set<String> members, |
| final AsyncCallback<JsArray<AccountInfo>> cb) { |
| if (members.size() == 1) { |
| addMember(group, |
| members.iterator().next(), |
| new AsyncCallback<AccountInfo>() { |
| @Override |
| public void onSuccess(AccountInfo result) { |
| cb.onSuccess(Natives.arrayOf(result)); |
| } |
| |
| @Override |
| public void onFailure(Throwable caught) { |
| cb.onFailure(caught); |
| } |
| }); |
| } else { |
| MemberInput input = MemberInput.create(); |
| for (String member : members) { |
| input.add_member(member); |
| } |
| members(group).post(input, cb); |
| } |
| } |
| |
| /** Remove members from a group. */ |
| public static void removeMembers(AccountGroup.UUID group, |
| Set<Integer> ids, final AsyncCallback<VoidResult> cb) { |
| if (ids.size() == 1) { |
| members(group).id(ids.iterator().next().toString()).delete(cb); |
| } else { |
| MemberInput in = MemberInput.create(); |
| for (Integer id : ids) { |
| in.add_member(id.toString()); |
| } |
| group(group).view("members.delete").post(in, cb); |
| } |
| } |
| |
| /** Include a group into a group. */ |
| public static void addIncludedGroup(AccountGroup.UUID group, String include, |
| AsyncCallback<GroupInfo> cb) { |
| groups(group).id(include).put(cb); |
| } |
| |
| /** Include groups into a group. */ |
| public static void addIncludedGroups(AccountGroup.UUID group, |
| Set<String> includedGroups, |
| final AsyncCallback<JsArray<GroupInfo>> cb) { |
| if (includedGroups.size() == 1) { |
| addIncludedGroup(group, |
| includedGroups.iterator().next(), |
| new AsyncCallback<GroupInfo>() { |
| @Override |
| public void onSuccess(GroupInfo result) { |
| cb.onSuccess(Natives.arrayOf(result)); |
| } |
| |
| @Override |
| public void onFailure(Throwable caught) { |
| cb.onFailure(caught); |
| } |
| }); |
| } else { |
| IncludedGroupInput input = IncludedGroupInput.create(); |
| for (String includedGroup : includedGroups) { |
| input.add_group(includedGroup); |
| } |
| groups(group).post(input, cb); |
| } |
| } |
| |
| /** Remove included groups from a group. */ |
| public static void removeIncludedGroups(AccountGroup.UUID group, |
| Set<AccountGroup.UUID> ids, final AsyncCallback<VoidResult> cb) { |
| if (ids.size() == 1) { |
| AccountGroup.UUID g = ids.iterator().next(); |
| groups(group).id(g.get()).delete(cb); |
| } else { |
| IncludedGroupInput in = IncludedGroupInput.create(); |
| for (AccountGroup.UUID g : ids) { |
| in.add_group(g.get()); |
| } |
| group(group).view("groups.delete").post(in, cb); |
| } |
| } |
| |
| private static RestApi members(AccountGroup.UUID group) { |
| return group(group).view("members"); |
| } |
| |
| private static RestApi groups(AccountGroup.UUID group) { |
| return group(group).view("groups"); |
| } |
| |
| private static RestApi group(AccountGroup.UUID group) { |
| return group(group.get()); |
| } |
| |
| private static RestApi group(String group) { |
| return new RestApi("/groups/").id(group); |
| } |
| |
| private static class GroupInput extends JavaScriptObject { |
| final native void description(String d) /*-{ if(d)this.description=d; }-*/; |
| final native void name(String n) /*-{ if(n)this.name=n; }-*/; |
| final native void owner(String o) /*-{ if(o)this.owner=o; }-*/; |
| |
| static GroupInput create() { |
| return (GroupInput) createObject(); |
| } |
| |
| protected GroupInput() { |
| } |
| } |
| |
| private static class GroupOptionsInput extends JavaScriptObject { |
| final native void visibleToAll(boolean v) /*-{ if(v)this.visible_to_all=v; }-*/; |
| |
| static GroupOptionsInput create() { |
| return (GroupOptionsInput) createObject(); |
| } |
| |
| protected GroupOptionsInput() { |
| } |
| } |
| |
| private static class MemberInput extends JavaScriptObject { |
| final native void init() /*-{ this.members = []; }-*/; |
| final native void add_member(String n) /*-{ this.members.push(n); }-*/; |
| |
| static MemberInput create() { |
| MemberInput m = (MemberInput) createObject(); |
| m.init(); |
| return m; |
| } |
| |
| protected MemberInput() { |
| } |
| } |
| |
| private static class IncludedGroupInput extends JavaScriptObject { |
| final native void init() /*-{ this.groups = []; }-*/; |
| final native void add_group(String n) /*-{ this.groups.push(n); }-*/; |
| |
| static IncludedGroupInput create() { |
| IncludedGroupInput g = (IncludedGroupInput) createObject(); |
| g.init(); |
| return g; |
| } |
| |
| protected IncludedGroupInput() { |
| } |
| } |
| } |