1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.googleapps;
16  
17  import com.liferay.portal.kernel.googleapps.GGroup;
18  import com.liferay.portal.kernel.googleapps.GGroupManager;
19  import com.liferay.portal.kernel.googleapps.GGroupMember;
20  import com.liferay.portal.kernel.googleapps.GGroupOwner;
21  import com.liferay.portal.kernel.googleapps.GUser;
22  import com.liferay.portal.kernel.googleapps.GUserManager;
23  import com.liferay.portal.kernel.googleapps.GoogleAppsException;
24  import com.liferay.portal.kernel.log.Log;
25  import com.liferay.portal.kernel.log.LogFactoryUtil;
26  import com.liferay.portal.kernel.util.GetterUtil;
27  import com.liferay.portal.kernel.util.StringBundler;
28  import com.liferay.portal.kernel.util.StringPool;
29  import com.liferay.portal.kernel.xml.Attribute;
30  import com.liferay.portal.kernel.xml.Document;
31  import com.liferay.portal.kernel.xml.Element;
32  import com.liferay.portal.kernel.xml.SAXReaderUtil;
33  
34  import java.util.ArrayList;
35  import java.util.List;
36  
37  /**
38   * <a href="GGroupManagerImpl.java.html"><b><i>View Source</i></b></a>
39   *
40   * @author Brian Wing Shun Chan
41   */
42  public class GGroupManagerImpl
43      extends GBaseManagerImpl implements GGroupManager {
44  
45      public GGroupManagerImpl(GoogleApps googleApps) {
46          super(googleApps);
47  
48          GAuthenticator gAuthenticator = googleApps.getGAuthenticator();
49  
50          groupURL = APPS_URL.concat("/group/2.0/").concat(
51              gAuthenticator.getDomain());
52      }
53  
54      public void addGGroupMember(
55              String groupEmailAddress, String memberEmailAddress)
56          throws GoogleAppsException {
57  
58          Document document = SAXReaderUtil.createDocument();
59  
60          Element atomEntryElement = addAtomEntry(document);
61  
62          addAppsProperty(atomEntryElement, "memberId", memberEmailAddress);
63  
64          StringBundler sb = new StringBundler(4);
65  
66          sb.append(groupURL);
67          sb.append(StringPool.SLASH);
68          sb.append(groupEmailAddress);
69          sb.append("/member");
70  
71          submitAdd(sb.toString(), document);
72      }
73  
74      public void addGGroupOwner(
75              String groupEmailAddress, String ownerEmailAddress)
76          throws GoogleAppsException {
77  
78          Document document = SAXReaderUtil.createDocument();
79  
80          Element atomEntryElement = addAtomEntry(document);
81  
82          addAppsProperty(atomEntryElement, "email", ownerEmailAddress);
83  
84          StringBundler sb = new StringBundler(4);
85  
86          sb.append(groupURL);
87          sb.append(StringPool.SLASH);
88          sb.append(groupEmailAddress);
89          sb.append("/owner");
90  
91          submitAdd(sb.toString(), document);
92      }
93  
94      public void deleteGGroup(String emailAddress) throws GoogleAppsException {
95          submitDelete(getGroupURL(emailAddress));
96      }
97  
98      public void deleteGGroupMember(
99              String groupEmailAddress, String memberEmailAddress)
100         throws GoogleAppsException {
101 
102         StringBundler sb = new StringBundler(5);
103 
104         sb.append(groupURL);
105         sb.append(StringPool.SLASH);
106         sb.append(groupEmailAddress);
107         sb.append("/member/");
108         sb.append(memberEmailAddress);
109 
110         submitDelete(sb.toString());
111     }
112 
113     public void deleteGGroupOwner(
114             String groupEmailAddress, String ownerEmailAddress)
115         throws GoogleAppsException {
116 
117         StringBundler sb = new StringBundler(5);
118 
119         sb.append(groupURL);
120         sb.append(StringPool.SLASH);
121         sb.append(groupEmailAddress);
122         sb.append("/owner/");
123         sb.append(ownerEmailAddress);
124 
125         submitDelete(sb.toString());
126     }
127 
128     public GGroup getGGroup(String emailAddress) throws GoogleAppsException {
129         Document document = getDocument(getGroupURL(emailAddress));
130 
131         if (hasError(document)) {
132             if (_log.isInfoEnabled()) {
133                 _log.info(getErrorMessage(document));
134             }
135 
136             return null;
137         }
138 
139         Element atomEntryElement = document.getRootElement();
140 
141         return getGGroup(atomEntryElement);
142     }
143 
144     public GGroupMember getGGroupMember(
145             String groupEmailAddress, String memberEmailAddress)
146         throws GoogleAppsException {
147 
148         StringBundler sb = new StringBundler(5);
149 
150         sb.append(groupURL);
151         sb.append(StringPool.SLASH);
152         sb.append(groupEmailAddress);
153         sb.append("/member/");
154         sb.append(memberEmailAddress);
155 
156         Document document = getDocument(sb.toString());
157 
158         if (hasError(document)) {
159             if (_log.isInfoEnabled()) {
160                 _log.info(getErrorMessage(document));
161             }
162 
163             return null;
164         }
165 
166         Element atomEntryElement = document.getRootElement();
167 
168         return getGGroupMember(atomEntryElement);
169     }
170 
171     public List<GGroupMember> getGGroupMembers(String emailAddress)
172         throws GoogleAppsException {
173 
174         List<GGroupMember> gGroupMembers = new ArrayList<GGroupMember>();
175 
176         StringBundler sb = new StringBundler(4);
177 
178         sb.append(groupURL);
179         sb.append(StringPool.SLASH);
180         sb.append(emailAddress);
181         sb.append("/member");
182 
183         getGGroupMembers(gGroupMembers, sb.toString());
184 
185         return gGroupMembers;
186     }
187 
188     public GGroupOwner getGGroupOwner(
189             String groupEmailAddress, String ownerEmailAddress)
190         throws GoogleAppsException {
191 
192         StringBundler sb = new StringBundler(5);
193 
194         sb.append(groupURL);
195         sb.append(StringPool.SLASH);
196         sb.append(groupEmailAddress);
197         sb.append("/owner/");
198         sb.append(ownerEmailAddress);
199 
200         Document document = getDocument(sb.toString());
201 
202         if (hasError(document)) {
203             if (_log.isInfoEnabled()) {
204                 _log.info(getErrorMessage(document));
205             }
206 
207             return null;
208         }
209 
210         Element atomEntryElement = document.getRootElement();
211 
212         return getGGroupOwner(atomEntryElement);
213     }
214 
215     public List<GGroupOwner> getGGroupOwners(String emailAddress)
216         throws GoogleAppsException {
217 
218         List<GGroupOwner> gGroupOwners = new ArrayList<GGroupOwner>();
219 
220         StringBundler sb = new StringBundler(4);
221 
222         sb.append(groupURL);
223         sb.append(StringPool.SLASH);
224         sb.append(emailAddress);
225         sb.append("/owner");
226 
227         getGGroupOwners(gGroupOwners, sb.toString());
228 
229         return gGroupOwners;
230     }
231 
232     public List<GGroup> getGGroups() throws GoogleAppsException {
233         List<GGroup> gGroups = new ArrayList<GGroup>();
234 
235         getGGroups(gGroups, groupURL);
236 
237         return gGroups;
238     }
239 
240     public List<GGroup> getGGroups(long userId, boolean directOnly)
241         throws GoogleAppsException {
242 
243         List<GGroup> gGroups = new ArrayList<GGroup>();
244 
245         StringBundler sb = new StringBundler(4);
246 
247         sb.append(groupURL);
248         sb.append("?member=");
249         sb.append(userId);
250         sb.append("&directOnly=");
251         sb.append(directOnly);
252 
253         getGGroups(gGroups, sb.toString());
254 
255         return gGroups;
256     }
257 
258     public void updateDescription(String emailAddress, String description)
259         throws GoogleAppsException {
260 
261         Document document = getDocument(getGroupURL(emailAddress));
262 
263         if (hasError(document)) {
264             if (_log.isInfoEnabled()) {
265                 _log.info(getErrorMessage(document));
266             }
267 
268             return;
269         }
270 
271         Element atomEntryElement = document.getRootElement();
272 
273         List<Element> appsPropertyElements = atomEntryElement.elements(
274             getAppsQName("property"));
275 
276         for (Element appsPropertyElement : appsPropertyElements) {
277             String name = appsPropertyElement.attributeValue("name");
278 
279             if (name.equals("description")) {
280                 Attribute valueAttribute = appsPropertyElement.attribute(
281                     "value");
282 
283                 valueAttribute.setValue(description);
284             }
285         }
286 
287         submitUpdate(getGroupURL(emailAddress), document);
288     }
289 
290     protected GGroup getGGroup(Element atomEntryElement) {
291         GGroup gGroup = new GGroup();
292 
293         List<Element> appsPropertyElements = atomEntryElement.elements(
294             getAppsQName("property"));
295 
296         for (Element appsPropertyElement : appsPropertyElements) {
297             String name = appsPropertyElement.attributeValue("name");
298             String value = appsPropertyElement.attributeValue("value");
299 
300             if (name.equals("description")) {
301                 gGroup.setDescription(value);
302             }
303             else if (name.equals("emailPermission")) {
304                 gGroup.setEmailPermission(value);
305             }
306             else if (name.equals("groupId")) {
307                 gGroup.setEmailAddress(value);
308             }
309             else if (name.equals("groupName")) {
310                 gGroup.setName(value);
311             }
312             else if (name.equals("permissionPreset")) {
313                 gGroup.setPermissionPreset(value);
314             }
315         }
316 
317         return gGroup;
318     }
319 
320     protected GGroupMember getGGroupMember(Element atomEntryElement)
321         throws GoogleAppsException {
322 
323         GGroupMember gGroupMember = new GGroupMember();
324 
325         List<Element> appsPropertyElements = atomEntryElement.elements(
326             getAppsQName("property"));
327 
328         for (Element appsPropertyElement : appsPropertyElements) {
329             String name = appsPropertyElement.attributeValue("name");
330             String value = appsPropertyElement.attributeValue("value");
331 
332             if (name.equals("directMember")) {
333                 gGroupMember.setDirect(GetterUtil.getBoolean(value));
334             }
335             else if (name.equals("memberId")) {
336                 gGroupMember.setEmailAddress(value);
337             }
338             else if (name.equals("memberType")) {
339                 gGroupMember.setType(value);
340             }
341         }
342 
343         String type = gGroupMember.getType();
344 
345         if (type.equals("Group")) {
346             GGroup gGroup = getGGroup(gGroupMember.getEmailAddress());
347 
348             gGroupMember.setGGroup(gGroup);
349         }
350         else if (type.equals("User")) {
351             GUserManager gUserManager = googleApps.getGUserManager();
352 
353             GUser gUser = gUserManager.getGUser(gGroupMember.getEmailAddress());
354 
355             gGroupMember.setGUser(gUser);
356         }
357 
358         return gGroupMember;
359     }
360 
361     protected void getGGroupMembers(
362             final List<GGroupMember> gGroupMembers, String url)
363         throws GoogleAppsException {
364 
365         Document document = getDocument(url);
366 
367         Element atomFeedElement = document.getRootElement();
368 
369         List<Element> atomEntryElements = atomFeedElement.elements(
370             getAtomQName("entry"));
371 
372         for (Element atomEntryElement : atomEntryElements) {
373             GGroupMember gGroupMember = getGGroupMember(atomEntryElement);
374 
375             gGroupMembers.add(gGroupMember);
376         }
377 
378         new GetNextItems(url, atomFeedElement) {
379 
380             public void getNextItems(String nextURL)
381                 throws GoogleAppsException {
382 
383                 getGGroupMembers(gGroupMembers, nextURL);
384             }
385 
386         };
387     }
388 
389     protected GGroupOwner getGGroupOwner(Element atomEntryElement)
390         throws GoogleAppsException {
391 
392         GGroupOwner gGroupOwner = new GGroupOwner();
393 
394         List<Element> appsPropertyElements = atomEntryElement.elements(
395             getAppsQName("property"));
396 
397         for (Element appsPropertyElement : appsPropertyElements) {
398             String name = appsPropertyElement.attributeValue("name");
399             String value = appsPropertyElement.attributeValue("value");
400 
401             if (name.equals("email")) {
402                 gGroupOwner.setEmailAddress(value);
403             }
404             else if (name.equals("type")) {
405                 gGroupOwner.setType(value);
406             }
407         }
408 
409         String type = gGroupOwner.getType();
410 
411         if (type.equals("Group")) {
412             GGroup gGroup = getGGroup(gGroupOwner.getEmailAddress());
413 
414             gGroupOwner.setGGroup(gGroup);
415         }
416         else if (type.equals("User")) {
417             GUserManager gUserManager = googleApps.getGUserManager();
418 
419             GUser gUser = gUserManager.getGUser(gGroupOwner.getEmailAddress());
420 
421             gGroupOwner.setGUser(gUser);
422         }
423 
424         return gGroupOwner;
425     }
426 
427     protected void getGGroupOwners(
428             final List<GGroupOwner> gGroupOwners, String url)
429         throws GoogleAppsException {
430 
431         Document document = getDocument(url);
432 
433         Element atomFeedElement = document.getRootElement();
434 
435         List<Element> atomEntryElements = atomFeedElement.elements(
436             getAtomQName("entry"));
437 
438         for (Element atomEntryElement : atomEntryElements) {
439             GGroupOwner gGroupOwner = getGGroupOwner(atomEntryElement);
440 
441             gGroupOwners.add(gGroupOwner);
442         }
443 
444         new GetNextItems(url, atomFeedElement) {
445 
446             public void getNextItems(String nextURL)
447                 throws GoogleAppsException {
448 
449                 getGGroupOwners(gGroupOwners, nextURL);
450             }
451 
452         };
453     }
454 
455     protected void getGGroups(final List<GGroup> gGroups, String url)
456         throws GoogleAppsException {
457 
458         Document document = getDocument(url);
459 
460         Element atomFeedElement = document.getRootElement();
461 
462         List<Element> atomEntryElements = atomFeedElement.elements(
463             getAtomQName("entry"));
464 
465         for (Element atomEntryElement : atomEntryElements) {
466             GGroup gGroup = getGGroup(atomEntryElement);
467 
468             gGroups.add(gGroup);
469         }
470 
471         new GetNextItems(url, atomFeedElement) {
472 
473             public void getNextItems(String nextURL)
474                 throws GoogleAppsException {
475 
476                 getGGroups(gGroups, nextURL);
477             }
478 
479         };
480     }
481 
482     protected String getGroupURL(String emailAddress) {
483         return groupURL.concat(StringPool.SLASH).concat(emailAddress);
484     }
485 
486     protected String groupURL;
487 
488     private static Log _log = LogFactoryUtil.getLog(GGroupManagerImpl.class);
489 
490 }