// 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() {
}
}
}