src/main/java/com/ruesga/gerrit/plugins/fcm/handlers/EventHandler.java - plugins/cloud-notifications - Git at Google

 /*
  * Copyright (C) 2016 Jorge Ruesga
  *
  * 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.ruesga.gerrit.plugins.fcm.handlers;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import com.google.common.collect.ImmutableSet;
 import com.google.gerrit.common.data.GroupDescription;
 import com.google.gerrit.common.data.GroupReference;
 import com.google.gerrit.extensions.annotations.PluginName;
 import com.google.gerrit.extensions.api.changes.NotifyHandling;
 import com.google.gerrit.extensions.client.ReviewerState;
 import com.google.gerrit.extensions.common.AccountInfo;
 import com.google.gerrit.extensions.common.ChangeInfo;
 import com.google.gerrit.extensions.events.ChangeEvent;
 import com.google.gerrit.extensions.events.RevisionEvent;
 import com.google.gerrit.index.query.Predicate;
 import com.google.gerrit.index.query.QueryParseException;
 import com.google.gerrit.index.query.QueryResult;
 import com.google.gerrit.reviewdb.client.Account;
 import com.google.gerrit.reviewdb.client.AccountGroup;
 import com.google.gerrit.server.AnonymousUser;
 import com.google.gerrit.server.CurrentUser;
 import com.google.gerrit.server.IdentifiedUser;
 import com.google.gerrit.server.IdentifiedUser.GenericFactory;
 import com.google.gerrit.server.account.AccountState;
 import com.google.gerrit.server.account.GroupBackend;
 import com.google.gerrit.server.account.ProjectWatches.NotifyType;
 import com.google.gerrit.server.account.ProjectWatches.ProjectWatchKey;
 import com.google.gerrit.server.config.AllProjectsName;
 import com.google.gerrit.server.git.NotifyConfig;
 import com.google.gerrit.server.project.ProjectCache;
 import com.google.gerrit.server.project.ProjectState;
 import com.google.gerrit.server.query.account.InternalAccountQuery;
 import com.google.gerrit.server.query.change.ChangeData;
 import com.google.gerrit.server.query.change.ChangeQueryBuilder;
 import com.google.gerrit.server.query.change.ChangeQueryProcessor;
 import com.google.gerrit.server.query.change.SingleGroupUser;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gwtorm.server.OrmException;
 import com.google.inject.Provider;
 import com.ruesga.gerrit.plugins.fcm.messaging.Notification;
 import com.ruesga.gerrit.plugins.fcm.workers.FcmUploaderWorker;

 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 public abstract class EventHandler {

     private static final Logger log =
             LoggerFactory.getLogger(EventHandler.class);

     private final String pluginName;
     private final FcmUploaderWorker uploader;
     private final AllProjectsName allProjectsName;
     private final ChangeQueryBuilder cqb;
     private final ChangeQueryProcessor cqp;
     private final ProjectCache projectCache;
     private final GroupBackend groupBackend;
     private final Provider<InternalAccountQuery> accountQueryProvider;
     private final GenericFactory identifiedUserFactory;
     private final Provider<AnonymousUser> anonymousProvider;
     private final Gson gson;

     public EventHandler(
             @PluginName String pluginName,
             FcmUploaderWorker uploader,
             AllProjectsName allProjectsName,
             ChangeQueryBuilder cqb,
             ChangeQueryProcessor cqp,
             ProjectCache projectCache,
             GroupBackend groupBackend,
             Provider<InternalAccountQuery> accountQueryProvider,
             GenericFactory identifiedUserFactory,
             Provider<AnonymousUser> anonymousProvider) {
         super();
         this.pluginName = pluginName;
         this.uploader = uploader;
         this.allProjectsName = allProjectsName;
         this.cqb = cqb;
         this.cqp = cqp;
         this.projectCache = projectCache;
         this.groupBackend = groupBackend;
         this.accountQueryProvider = accountQueryProvider;
         this.identifiedUserFactory = identifiedUserFactory;
         this.anonymousProvider = anonymousProvider;
         this.gson = new GsonBuilder().create();
     }

     protected abstract int getEventType();

     protected abstract NotifyType getNotifyType();

     Gson getSerializer() {
         return this.gson;
     }

     protected Notification createNotification(ChangeEvent event) {
         Notification notification = new Notification();
         notification.event = getEventType();
         notification.when = event.getWhen().getTime() / 1000L;
         notification.who = event.getWho();
         notification.change = event.getChange().changeId;
         notification.legacyChangeId = event.getChange()._number;
         notification.project = event.getChange().project;
         notification.branch = event.getChange().branch;
         notification.topic = event.getChange().topic;
         notification.subject = StringUtils.abbreviate(
                 event.getChange().subject, 100);
         if (event instanceof RevisionEvent) {
             notification.revision =
                     ((RevisionEvent) event).getRevision().commit.commit;
         }
         return notification;
     }

     protected void notify(Notification notification, ChangeEvent event) {
         // Check if this event should be notified
         if (event.getNotify().equals(NotifyHandling.NONE)) {
             if (log.isDebugEnabled()) {
                 log.debug(
                     String.format("[%s] Notify event %d is not enabled: %s",
                         pluginName, getEventType(), gson.toJson(notification)));
             }
             return;
         }

         // Obtain information about the accounts that need to be
         // notified related to this event
         List<Integer> notifiedUsers = obtainNotifiedAccounts(event);
         if (notifiedUsers.isEmpty()) {
             // Nobody to notify about this event
             return;
         }

         // Perform notification
         if (log.isDebugEnabled()) {
             log.debug(String.format("[%s] Sending notification %s to %s",
                     pluginName, gson.toJson(notification),
                     gson.toJson(notifiedUsers)));
         }
         this.uploader.notifyTo(notifiedUsers, notification);
     }

     private List<Integer> obtainNotifiedAccounts(ChangeEvent event) {
         Set<Integer> notifiedUsers = new HashSet<>();
         ChangeInfo change = event.getChange();
         NotifyHandling notifyTo = event.getNotify();

         // 1.- Owner of the change
         notifiedUsers.add(change.owner._accountId);

         // 2.- Reviewers
         if (notifyTo.equals(NotifyHandling.OWNER_REVIEWERS) ||
                 notifyTo.equals(NotifyHandling.ALL)) {
             if (change.reviewers != null) {
                 for (ReviewerState state : change.reviewers.keySet()) {
                     Collection<AccountInfo> accounts =
                             change.reviewers.get(state);
                     for (AccountInfo account : accounts) {
                         notifiedUsers.add(account._accountId);
                     }
                 }
             }
         }

         // 3.- Watchers
         ChangeData changeData = obtainChangeData(change);
         if (changeData != null) {
             notifiedUsers.addAll(getWatchers(getNotifyType(), changeData,
                     !safeBoolean(change.workInProgress) && !safeBoolean(change.isPrivate)));
         }

         // 4.- Remove the author of this event (he doesn't need to get
         // the notification)
         notifiedUsers.remove(event.getWho()._accountId);

         return new ArrayList<>(notifiedUsers);
     }

     private Set<Integer> getWatchers(NotifyType type, ChangeData change, boolean includeWatchersFromNotifyConfig) {
         Set<Integer> watchers = new HashSet<>();
         try {
             Set<Account.Id> projectWatchers = new HashSet<>();
             for (AccountState a : accountQueryProvider.get().byWatchedProject(
                     change.project())) {
                 Account.Id accountId = a.getAccount().getId();
                 for (Map.Entry<ProjectWatchKey, ImmutableSet<NotifyType>> e : a.getProjectWatches().entrySet()) {
                     if (change.project().equals(e.getKey().project())
                             && add(watchers, accountId, e.getKey(), e.getValue(), type, change)) {
                         // We only want to prevent matching All-Projects if this filter hits
                         projectWatchers.add(accountId);
                     }
                 }
             }

             for (AccountState a : accountQueryProvider.get().byWatchedProject(allProjectsName)) {
               for (Map.Entry<ProjectWatchKey, ImmutableSet<NotifyType>> e : a.getProjectWatches().entrySet()) {
                     if (allProjectsName.equals(e.getKey().project())) {
                         Account.Id accountId = a.getAccount().getId();
                         if (!projectWatchers.contains(accountId)) {
                             add(watchers, accountId, e.getKey(), e.getValue(), type, change);
                         }
                     }
                 }
             }

             if (includeWatchersFromNotifyConfig) {
                 ProjectState projectState = projectCache.get(change.project());
                 if (projectState != null) {
                     for (ProjectState state : projectState.tree()) {
                         for (NotifyConfig nc : state.getConfig().getNotifyConfigs()) {
                             if (nc.isNotify(type)) {
                                 try {
                                     add(watchers, nc, change);
                                 } catch (QueryParseException e) {
                                     log.warn(
                                         "Project {} has invalid notify {} filter \"{}\": {}",
                                         state.getName(),
                                         nc.getName(),
                                         nc.getFilter(),
                                         e.getMessage());
                                 }
                             }
                         }
                     }
                 }
             }

         } catch (OrmException ex) {
             log.error(String.format(
                     "[%s] Failed to obtain watchers", pluginName), ex);
         }
         return watchers;
     }

     private boolean add(Set<Integer> watchers, Account.Id accountId,
             ProjectWatchKey key, Set<NotifyType> watchedTypes, NotifyType type,
             ChangeData change) throws OrmException {
         IdentifiedUser user = identifiedUserFactory.create(accountId);

         try {
             if (filterMatch(user, key.filter(), change)) {
                 // If we are set to notify on this type, add the user.
                 // Otherwise, still return true to stop notifications for this user.
                 if (watchedTypes.contains(type)) {
                     watchers.add(accountId.get());
                 }
                 return true;
             }
         } catch (QueryParseException e) {
             // Ignore broken filter expressions.
         }
         return false;
     }

     private void add(Set<Integer> watchers, NotifyConfig nc, ChangeData change)
             throws OrmException, QueryParseException {
         for (GroupReference ref : nc.getGroups()) {
             CurrentUser user = new SingleGroupUser(ref.getUUID());
             if (filterMatch(user, nc.getFilter(), change)) {
                 deliverToMembers(watchers, ref.getUUID());
             }
         }
     }

     private boolean filterMatch(
             CurrentUser user, String filter, ChangeData change)
             throws OrmException, QueryParseException {
         ChangeQueryBuilder qb;
         Predicate<ChangeData> p = null;
         if (user == null) {
             qb = cqb.asUser(anonymousProvider.get());
         } else {
             qb = cqb.asUser(user);
             p = qb.is_visible();
         }

         if (filter != null) {
             Predicate<ChangeData> filterPredicate = qb.parse(filter);
             if (p == null) {
                 p = filterPredicate;
             } else {
                 p = Predicate.and(filterPredicate, p);
             }
         }
         return p == null || p.asMatchable().match(change);
     }

     private ChangeData obtainChangeData(ChangeInfo change) {
         try {
             QueryResult<ChangeData> changeQuery =
                     cqp.query(cqb.parse("change:" + change._number));
             List<ChangeData> changeQueryResults = changeQuery.entities();
             if (changeQueryResults == null || changeQueryResults.isEmpty()) {
                 log.warn(String.format("[%s] No change found for %s",
                         pluginName, change._number));
                 return null;
             }
             return changeQueryResults.get(0);

         } catch (Exception ex) {
             log.error(String.format("[%s] Failed to obtain change data: %d",
                     pluginName, change._number), ex);
         }
         return null;
     }

     private void deliverToMembers(Set<Integer> watchers, AccountGroup.UUID startUUID) {
         Set<AccountGroup.UUID> seen = new HashSet<>();
         List<AccountGroup.UUID> q = new ArrayList<>();

         seen.add(startUUID);
         q.add(startUUID);

         while (!q.isEmpty()) {
             AccountGroup.UUID uuid = q.remove(q.size() - 1);
             GroupDescription.Basic group = groupBackend.get(uuid);
             if (group == null) {
                 continue;
             }

             if (!(group instanceof GroupDescription.Internal)) {
                 // Non-internal groups cannot be expanded by the server.
                 continue;
             }

             GroupDescription.Internal ig = (GroupDescription.Internal) group;
             for (Account.Id id : ig.getMembers()) {
                 watchers.add(id.get());
             }
             for (AccountGroup.UUID m : ig.getSubgroups()) {
                 if (seen.add(m)) {
                     q.add(m);
                 }
             }
         }
     }

     protected String formatAccount(AccountInfo account) {
         if (account.name != null) {
             return account.name;
         }
         if (account.username != null) {
             return account.username;
         }
         return account.email;
     }

     boolean safeBoolean(Boolean value) {
         return value != null && value;
     }
 }
	/*
	* Copyright (C) 2016 Jorge Ruesga
	*
	* 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.ruesga.gerrit.plugins.fcm.handlers;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import com.google.common.collect.ImmutableSet;
	import com.google.gerrit.common.data.GroupDescription;
	import com.google.gerrit.common.data.GroupReference;
	import com.google.gerrit.extensions.annotations.PluginName;
	import com.google.gerrit.extensions.api.changes.NotifyHandling;
	import com.google.gerrit.extensions.client.ReviewerState;
	import com.google.gerrit.extensions.common.AccountInfo;
	import com.google.gerrit.extensions.common.ChangeInfo;
	import com.google.gerrit.extensions.events.ChangeEvent;
	import com.google.gerrit.extensions.events.RevisionEvent;
	import com.google.gerrit.index.query.Predicate;
	import com.google.gerrit.index.query.QueryParseException;
	import com.google.gerrit.index.query.QueryResult;
	import com.google.gerrit.reviewdb.client.Account;
	import com.google.gerrit.reviewdb.client.AccountGroup;
	import com.google.gerrit.server.AnonymousUser;
	import com.google.gerrit.server.CurrentUser;
	import com.google.gerrit.server.IdentifiedUser;
	import com.google.gerrit.server.IdentifiedUser.GenericFactory;
	import com.google.gerrit.server.account.AccountState;
	import com.google.gerrit.server.account.GroupBackend;
	import com.google.gerrit.server.account.ProjectWatches.NotifyType;
	import com.google.gerrit.server.account.ProjectWatches.ProjectWatchKey;
	import com.google.gerrit.server.config.AllProjectsName;
	import com.google.gerrit.server.git.NotifyConfig;
	import com.google.gerrit.server.project.ProjectCache;
	import com.google.gerrit.server.project.ProjectState;
	import com.google.gerrit.server.query.account.InternalAccountQuery;
	import com.google.gerrit.server.query.change.ChangeData;
	import com.google.gerrit.server.query.change.ChangeQueryBuilder;
	import com.google.gerrit.server.query.change.ChangeQueryProcessor;
	import com.google.gerrit.server.query.change.SingleGroupUser;
	import com.google.gson.Gson;
	import com.google.gson.GsonBuilder;
	import com.google.gwtorm.server.OrmException;
	import com.google.inject.Provider;
	import com.ruesga.gerrit.plugins.fcm.messaging.Notification;
	import com.ruesga.gerrit.plugins.fcm.workers.FcmUploaderWorker;

	import org.apache.commons.lang.StringUtils;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	public abstract class EventHandler {

	private static final Logger log =
	LoggerFactory.getLogger(EventHandler.class);

	private final String pluginName;
	private final FcmUploaderWorker uploader;
	private final AllProjectsName allProjectsName;
	private final ChangeQueryBuilder cqb;
	private final ChangeQueryProcessor cqp;
	private final ProjectCache projectCache;
	private final GroupBackend groupBackend;
	private final Provider<InternalAccountQuery> accountQueryProvider;
	private final GenericFactory identifiedUserFactory;
	private final Provider<AnonymousUser> anonymousProvider;
	private final Gson gson;

	public EventHandler(
	@PluginName String pluginName,
	FcmUploaderWorker uploader,
	AllProjectsName allProjectsName,
	ChangeQueryBuilder cqb,
	ChangeQueryProcessor cqp,
	ProjectCache projectCache,
	GroupBackend groupBackend,
	Provider<InternalAccountQuery> accountQueryProvider,
	GenericFactory identifiedUserFactory,
	Provider<AnonymousUser> anonymousProvider) {
	super();
	this.pluginName = pluginName;
	this.uploader = uploader;
	this.allProjectsName = allProjectsName;
	this.cqb = cqb;
	this.cqp = cqp;
	this.projectCache = projectCache;
	this.groupBackend = groupBackend;
	this.accountQueryProvider = accountQueryProvider;
	this.identifiedUserFactory = identifiedUserFactory;
	this.anonymousProvider = anonymousProvider;
	this.gson = new GsonBuilder().create();
	}

	protected abstract int getEventType();

	protected abstract NotifyType getNotifyType();

	Gson getSerializer() {
	return this.gson;
	}

	protected Notification createNotification(ChangeEvent event) {
	Notification notification = new Notification();
	notification.event = getEventType();
	notification.when = event.getWhen().getTime() / 1000L;
	notification.who = event.getWho();
	notification.change = event.getChange().changeId;
	notification.legacyChangeId = event.getChange()._number;
	notification.project = event.getChange().project;
	notification.branch = event.getChange().branch;
	notification.topic = event.getChange().topic;
	notification.subject = StringUtils.abbreviate(
	event.getChange().subject, 100);
	if (event instanceof RevisionEvent) {
	notification.revision =
	((RevisionEvent) event).getRevision().commit.commit;
	}
	return notification;
	}

	protected void notify(Notification notification, ChangeEvent event) {
	// Check if this event should be notified
	if (event.getNotify().equals(NotifyHandling.NONE)) {
	if (log.isDebugEnabled()) {
	log.debug(
	String.format("[%s] Notify event %d is not enabled: %s",
	pluginName, getEventType(), gson.toJson(notification)));
	}
	return;
	}

	// Obtain information about the accounts that need to be
	// notified related to this event
	List<Integer> notifiedUsers = obtainNotifiedAccounts(event);
	if (notifiedUsers.isEmpty()) {
	// Nobody to notify about this event
	return;
	}

	// Perform notification
	if (log.isDebugEnabled()) {
	log.debug(String.format("[%s] Sending notification %s to %s",
	pluginName, gson.toJson(notification),
	gson.toJson(notifiedUsers)));
	}
	this.uploader.notifyTo(notifiedUsers, notification);
	}

	private List<Integer> obtainNotifiedAccounts(ChangeEvent event) {
	Set<Integer> notifiedUsers = new HashSet<>();
	ChangeInfo change = event.getChange();
	NotifyHandling notifyTo = event.getNotify();

	// 1.- Owner of the change
	notifiedUsers.add(change.owner._accountId);

	// 2.- Reviewers
	if (notifyTo.equals(NotifyHandling.OWNER_REVIEWERS) \|\|
	notifyTo.equals(NotifyHandling.ALL)) {
	if (change.reviewers != null) {
	for (ReviewerState state : change.reviewers.keySet()) {
	Collection<AccountInfo> accounts =
	change.reviewers.get(state);
	for (AccountInfo account : accounts) {
	notifiedUsers.add(account._accountId);
	}
	}
	}
	}

	// 3.- Watchers
	ChangeData changeData = obtainChangeData(change);
	if (changeData != null) {
	notifiedUsers.addAll(getWatchers(getNotifyType(), changeData,
	!safeBoolean(change.workInProgress) && !safeBoolean(change.isPrivate)));
	}

	// 4.- Remove the author of this event (he doesn't need to get
	// the notification)
	notifiedUsers.remove(event.getWho()._accountId);

	return new ArrayList<>(notifiedUsers);
	}

	private Set<Integer> getWatchers(NotifyType type, ChangeData change, boolean includeWatchersFromNotifyConfig) {
	Set<Integer> watchers = new HashSet<>();
	try {
	Set<Account.Id> projectWatchers = new HashSet<>();
	for (AccountState a : accountQueryProvider.get().byWatchedProject(
	change.project())) {
	Account.Id accountId = a.getAccount().getId();
	for (Map.Entry<ProjectWatchKey, ImmutableSet<NotifyType>> e : a.getProjectWatches().entrySet()) {
	if (change.project().equals(e.getKey().project())
	&& add(watchers, accountId, e.getKey(), e.getValue(), type, change)) {
	// We only want to prevent matching All-Projects if this filter hits
	projectWatchers.add(accountId);
	}
	}
	}

	for (AccountState a : accountQueryProvider.get().byWatchedProject(allProjectsName)) {
	for (Map.Entry<ProjectWatchKey, ImmutableSet<NotifyType>> e : a.getProjectWatches().entrySet()) {
	if (allProjectsName.equals(e.getKey().project())) {
	Account.Id accountId = a.getAccount().getId();
	if (!projectWatchers.contains(accountId)) {
	add(watchers, accountId, e.getKey(), e.getValue(), type, change);
	}
	}
	}
	}

	if (includeWatchersFromNotifyConfig) {
	ProjectState projectState = projectCache.get(change.project());
	if (projectState != null) {
	for (ProjectState state : projectState.tree()) {
	for (NotifyConfig nc : state.getConfig().getNotifyConfigs()) {
	if (nc.isNotify(type)) {
	try {
	add(watchers, nc, change);
	} catch (QueryParseException e) {
	log.warn(
	"Project {} has invalid notify {} filter \"{}\": {}",
	state.getName(),
	nc.getName(),
	nc.getFilter(),
	e.getMessage());
	}
	}
	}
	}
	}
	}

	} catch (OrmException ex) {
	log.error(String.format(
	"[%s] Failed to obtain watchers", pluginName), ex);
	}
	return watchers;
	}

	private boolean add(Set<Integer> watchers, Account.Id accountId,
	ProjectWatchKey key, Set<NotifyType> watchedTypes, NotifyType type,
	ChangeData change) throws OrmException {
	IdentifiedUser user = identifiedUserFactory.create(accountId);

	try {
	if (filterMatch(user, key.filter(), change)) {
	// If we are set to notify on this type, add the user.
	// Otherwise, still return true to stop notifications for this user.
	if (watchedTypes.contains(type)) {
	watchers.add(accountId.get());
	}
	return true;
	}
	} catch (QueryParseException e) {
	// Ignore broken filter expressions.
	}
	return false;
	}

	private void add(Set<Integer> watchers, NotifyConfig nc, ChangeData change)
	throws OrmException, QueryParseException {
	for (GroupReference ref : nc.getGroups()) {
	CurrentUser user = new SingleGroupUser(ref.getUUID());
	if (filterMatch(user, nc.getFilter(), change)) {
	deliverToMembers(watchers, ref.getUUID());
	}
	}
	}

	private boolean filterMatch(
	CurrentUser user, String filter, ChangeData change)
	throws OrmException, QueryParseException {
	ChangeQueryBuilder qb;
	Predicate<ChangeData> p = null;
	if (user == null) {
	qb = cqb.asUser(anonymousProvider.get());
	} else {
	qb = cqb.asUser(user);
	p = qb.is_visible();
	}

	if (filter != null) {
	Predicate<ChangeData> filterPredicate = qb.parse(filter);
	if (p == null) {
	p = filterPredicate;
	} else {
	p = Predicate.and(filterPredicate, p);
	}
	}
	return p == null \|\| p.asMatchable().match(change);
	}

	private ChangeData obtainChangeData(ChangeInfo change) {
	try {
	QueryResult<ChangeData> changeQuery =
	cqp.query(cqb.parse("change:" + change._number));
	List<ChangeData> changeQueryResults = changeQuery.entities();
	if (changeQueryResults == null \|\| changeQueryResults.isEmpty()) {
	log.warn(String.format("[%s] No change found for %s",
	pluginName, change._number));
	return null;
	}
	return changeQueryResults.get(0);

	} catch (Exception ex) {
	log.error(String.format("[%s] Failed to obtain change data: %d",
	pluginName, change._number), ex);
	}
	return null;
	}

	private void deliverToMembers(Set<Integer> watchers, AccountGroup.UUID startUUID) {
	Set<AccountGroup.UUID> seen = new HashSet<>();
	List<AccountGroup.UUID> q = new ArrayList<>();

	seen.add(startUUID);
	q.add(startUUID);

	while (!q.isEmpty()) {
	AccountGroup.UUID uuid = q.remove(q.size() - 1);
	GroupDescription.Basic group = groupBackend.get(uuid);
	if (group == null) {
	continue;
	}

	if (!(group instanceof GroupDescription.Internal)) {
	// Non-internal groups cannot be expanded by the server.
	continue;
	}

	GroupDescription.Internal ig = (GroupDescription.Internal) group;
	for (Account.Id id : ig.getMembers()) {
	watchers.add(id.get());
	}
	for (AccountGroup.UUID m : ig.getSubgroups()) {
	if (seen.add(m)) {
	q.add(m);
	}
	}
	}
	}

	protected String formatAccount(AccountInfo account) {
	if (account.name != null) {
	return account.name;
	}
	if (account.username != null) {
	return account.username;
	}
	return account.email;
	}

	boolean safeBoolean(Boolean value) {
	return value != null && value;
	}
	}