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