001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.verify;
016    
017    import com.liferay.portal.kernel.dao.jdbc.DataAccess;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.dao.orm.DynamicQueryFactoryUtil;
020    import com.liferay.portal.kernel.dao.orm.RestrictionsFactoryUtil;
021    import com.liferay.portal.kernel.exception.GroupFriendlyURLException;
022    import com.liferay.portal.kernel.log.Log;
023    import com.liferay.portal.kernel.log.LogFactoryUtil;
024    import com.liferay.portal.kernel.model.Company;
025    import com.liferay.portal.kernel.model.Group;
026    import com.liferay.portal.kernel.model.GroupConstants;
027    import com.liferay.portal.kernel.model.LayoutSet;
028    import com.liferay.portal.kernel.model.Organization;
029    import com.liferay.portal.kernel.model.Role;
030    import com.liferay.portal.kernel.model.User;
031    import com.liferay.portal.kernel.model.UserGroup;
032    import com.liferay.portal.kernel.model.UserGroupGroupRole;
033    import com.liferay.portal.kernel.model.UserGroupRole;
034    import com.liferay.portal.kernel.service.CompanyLocalServiceUtil;
035    import com.liferay.portal.kernel.service.GroupLocalServiceUtil;
036    import com.liferay.portal.kernel.service.OrganizationLocalServiceUtil;
037    import com.liferay.portal.kernel.service.RoleLocalServiceUtil;
038    import com.liferay.portal.kernel.service.UserGroupGroupRoleLocalServiceUtil;
039    import com.liferay.portal.kernel.service.UserGroupLocalServiceUtil;
040    import com.liferay.portal.kernel.service.UserGroupRoleLocalServiceUtil;
041    import com.liferay.portal.kernel.service.UserLocalServiceUtil;
042    import com.liferay.portal.kernel.util.ArrayUtil;
043    import com.liferay.portal.kernel.util.GetterUtil;
044    import com.liferay.portal.kernel.util.ListUtil;
045    import com.liferay.portal.kernel.util.PortalUtil;
046    import com.liferay.portal.kernel.util.StringBundler;
047    import com.liferay.portal.kernel.util.StringPool;
048    import com.liferay.portal.kernel.util.UnicodeProperties;
049    import com.liferay.portal.service.impl.GroupLocalServiceImpl;
050    import com.liferay.portal.util.PortalInstances;
051    import com.liferay.portal.util.RobotsUtil;
052    
053    import java.sql.PreparedStatement;
054    import java.sql.ResultSet;
055    
056    import java.util.Iterator;
057    import java.util.List;
058    import java.util.Set;
059    
060    /**
061     * @author Brian Wing Shun Chan
062     */
063    public class VerifyGroup extends VerifyProcess {
064    
065            @Override
066            protected void doVerify() throws Exception {
067                    verifyCompanyGroups();
068                    verifyNullFriendlyURLGroups();
069                    verifyOrganizationNames();
070                    verifyRobots();
071                    verifySites();
072                    verifyStagedGroups();
073                    verifyTree();
074            }
075    
076            protected String getRobots(LayoutSet layoutSet) {
077                    if (layoutSet == null) {
078                            return RobotsUtil.getDefaultRobots(null);
079                    }
080    
081                    String virtualHostname = StringPool.BLANK;
082    
083                    try {
084                            virtualHostname = layoutSet.getVirtualHostname();
085                    }
086                    catch (Exception e) {
087                    }
088    
089                    return GetterUtil.get(
090                            layoutSet.getSettingsProperty(
091                                    layoutSet.isPrivateLayout() + "-robots.txt"),
092                            RobotsUtil.getDefaultRobots(virtualHostname));
093            }
094    
095            protected void updateName(long groupId, String name) throws Exception {
096                    PreparedStatement ps = null;
097    
098                    try {
099                            ps = connection.prepareStatement(
100                                    "update Group_ set name = ? where groupId= " + groupId);
101    
102                            ps.setString(1, name);
103    
104                            ps.executeUpdate();
105                    }
106                    finally {
107                            DataAccess.cleanUp(ps);
108                    }
109            }
110    
111            protected void verifyCompanyGroups() throws Exception {
112                    List<Company> companies = CompanyLocalServiceUtil.getCompanies();
113    
114                    for (Company company : companies) {
115                            GroupLocalServiceUtil.checkCompanyGroup(company.getCompanyId());
116    
117                            GroupLocalServiceUtil.checkSystemGroups(company.getCompanyId());
118                    }
119            }
120    
121            protected void verifyNullFriendlyURLGroups() throws Exception {
122                    List<Group> groups = GroupLocalServiceUtil.getNullFriendlyURLGroups();
123    
124                    for (Group group : groups) {
125                            String friendlyURL = StringPool.SLASH + group.getGroupId();
126    
127                            User user = null;
128    
129                            if (group.isCompany() && !group.isCompanyStagingGroup()) {
130                                    friendlyURL = GroupConstants.GLOBAL_FRIENDLY_URL;
131                            }
132                            else if (group.isUser()) {
133                                    user = UserLocalServiceUtil.getUserById(group.getClassPK());
134    
135                                    friendlyURL = StringPool.SLASH + user.getScreenName();
136                            }
137                            else if (group.getClassPK() > 0) {
138                                    friendlyURL = StringPool.SLASH + group.getClassPK();
139                            }
140    
141                            try {
142                                    GroupLocalServiceUtil.updateFriendlyURL(
143                                            group.getGroupId(), friendlyURL);
144                            }
145                            catch (GroupFriendlyURLException gfurle) {
146                                    if (user != null) {
147                                            long userId = user.getUserId();
148                                            String screenName = user.getScreenName();
149    
150                                            if (_log.isWarnEnabled()) {
151                                                    _log.warn(
152                                                            "Updating user screen name " + screenName + " to " +
153                                                                    userId + " because it is generating an " +
154                                                                            "invalid friendly URL " + friendlyURL);
155                                            }
156    
157                                            UserLocalServiceUtil.updateScreenName(
158                                                    userId, String.valueOf(userId));
159                                    }
160                                    else {
161                                            _log.error("Invalid Friendly URL " + friendlyURL);
162    
163                                            throw gfurle;
164                                    }
165                            }
166                    }
167            }
168    
169            protected void verifyOrganizationNames() throws Exception {
170                    PreparedStatement ps = null;
171                    ResultSet rs = null;
172    
173                    try {
174                            StringBundler sb = new StringBundler(5);
175    
176                            sb.append("select groupId, name from Group_ where name like '%");
177                            sb.append(GroupLocalServiceImpl.ORGANIZATION_NAME_SUFFIX);
178                            sb.append("%' and name not like '%");
179                            sb.append(GroupLocalServiceImpl.ORGANIZATION_NAME_SUFFIX);
180                            sb.append("'");
181    
182                            ps = connection.prepareStatement(sb.toString());
183    
184                            rs = ps.executeQuery();
185    
186                            while (rs.next()) {
187                                    long groupId = rs.getLong("groupId");
188                                    String name = rs.getString("name");
189    
190                                    if (name.endsWith(
191                                                    GroupLocalServiceImpl.ORGANIZATION_NAME_SUFFIX) ||
192                                            name.endsWith(
193                                                    GroupLocalServiceImpl.ORGANIZATION_STAGING_SUFFIX)) {
194    
195                                            continue;
196                                    }
197    
198                                    int pos = name.indexOf(
199                                            GroupLocalServiceImpl.ORGANIZATION_NAME_SUFFIX);
200    
201                                    pos = name.indexOf(" ", pos + 1);
202    
203                                    String newName =
204                                            name.substring(pos + 1) +
205                                                    GroupLocalServiceImpl.ORGANIZATION_NAME_SUFFIX;
206    
207                                    updateName(groupId, newName);
208                            }
209                    }
210                    finally {
211                            DataAccess.cleanUp(ps, rs);
212                    }
213            }
214    
215            protected void verifyRobots() throws Exception {
216                    List<Group> groups = GroupLocalServiceUtil.getLiveGroups();
217    
218                    for (Group group : groups) {
219                            LayoutSet privateLayoutSet = group.getPrivateLayoutSet();
220                            LayoutSet publicLayoutSet = group.getPublicLayoutSet();
221    
222                            String privateLayoutSetRobots = getRobots(privateLayoutSet);
223                            String publicLayoutSetRobots = getRobots(publicLayoutSet);
224    
225                            UnicodeProperties typeSettingsProperties =
226                                    group.getTypeSettingsProperties();
227    
228                            typeSettingsProperties.setProperty(
229                                    "true-robots.txt", privateLayoutSetRobots);
230                            typeSettingsProperties.setProperty(
231                                    "false-robots.txt", publicLayoutSetRobots);
232    
233                            GroupLocalServiceUtil.updateGroup(
234                                    group.getGroupId(), typeSettingsProperties.toString());
235                    }
236            }
237    
238            protected void verifySites() throws Exception {
239                    DynamicQuery dynamicQuery = DynamicQueryFactoryUtil.forClass(
240                            Group.class);
241    
242                    dynamicQuery.add(
243                            RestrictionsFactoryUtil.eq(
244                                    "classNameId", PortalUtil.getClassNameId(Organization.class)));
245                    dynamicQuery.add(RestrictionsFactoryUtil.eq("site", false));
246    
247                    List<Group> groups = GroupLocalServiceUtil.dynamicQuery(dynamicQuery);
248    
249                    for (Group group : groups) {
250                            if ((group.getPrivateLayoutsPageCount() > 0) ||
251                                    (group.getPublicLayoutsPageCount() > 0)) {
252    
253                                    group.setSite(true);
254    
255                                    GroupLocalServiceUtil.updateGroup(group);
256                            }
257                    }
258            }
259    
260            protected void verifyStagedGroups() throws Exception {
261                    List<Group> groups = GroupLocalServiceUtil.getLiveGroups();
262    
263                    for (Group group : groups) {
264                            if (!group.hasStagingGroup()) {
265                                    continue;
266                            }
267    
268                            UnicodeProperties typeSettingsProperties =
269                                    group.getTypeSettingsProperties();
270    
271                            typeSettingsProperties.setProperty(
272                                    "staged", Boolean.TRUE.toString());
273                            typeSettingsProperties.setProperty(
274                                    "stagedRemotely", Boolean.FALSE.toString());
275    
276                            verifyStagingTypeSettingsProperties(typeSettingsProperties);
277    
278                            GroupLocalServiceUtil.updateGroup(
279                                    group.getGroupId(), typeSettingsProperties.toString());
280    
281                            Group stagingGroup = group.getStagingGroup();
282    
283                            if (group.getClassNameId() != stagingGroup.getClassNameId()) {
284                                    stagingGroup.setClassNameId(group.getClassNameId());
285    
286                                    GroupLocalServiceUtil.updateGroup(stagingGroup);
287                            }
288    
289                            if (!stagingGroup.isStagedRemotely()) {
290                                    verifyStagingGroupOrganizationMembership(stagingGroup);
291                                    verifyStagingGroupRoleMembership(stagingGroup);
292                                    verifyStagingGroupUserGroupMembership(stagingGroup);
293                                    verifyStagingGroupUserMembership(stagingGroup);
294                                    verifyStagingUserGroupRolesAssignments(stagingGroup);
295                                    verifyStagingUserGroupGroupRolesAssignments(stagingGroup);
296                            }
297                    }
298            }
299    
300            protected void verifyStagingGroupOrganizationMembership(Group stagingGroup)
301                    throws Exception {
302    
303                    List<Organization> stagingOrganizations =
304                            OrganizationLocalServiceUtil.getGroupOrganizations(
305                                    stagingGroup.getGroupId());
306    
307                    if (ListUtil.isEmpty(stagingOrganizations)) {
308                            return;
309                    }
310    
311                    List<Organization> liveOrganizations =
312                            OrganizationLocalServiceUtil.getGroupOrganizations(
313                                    stagingGroup.getLiveGroupId());
314    
315                    for (Organization stagingGroupOrganization : stagingOrganizations) {
316                            if (!liveOrganizations.contains(stagingGroupOrganization)) {
317                                    OrganizationLocalServiceUtil.addGroupOrganization(
318                                            stagingGroup.getLiveGroupId(), stagingGroupOrganization);
319                            }
320                    }
321    
322                    OrganizationLocalServiceUtil.clearGroupOrganizations(
323                            stagingGroup.getGroupId());
324            }
325    
326            protected void verifyStagingGroupRoleMembership(Group stagingGroup) {
327                    List<Role> stagingRoles = RoleLocalServiceUtil.getGroupRoles(
328                            stagingGroup.getGroupId());
329    
330                    if (ListUtil.isEmpty(stagingRoles)) {
331                            return;
332                    }
333    
334                    List<Role> liveRoles = RoleLocalServiceUtil.getGroupRoles(
335                            stagingGroup.getLiveGroupId());
336    
337                    for (Role stagingRole : stagingRoles) {
338                            if (!liveRoles.contains(stagingRole)) {
339                                    RoleLocalServiceUtil.addGroupRole(
340                                            stagingGroup.getLiveGroupId(), stagingRole);
341                            }
342                    }
343    
344                    RoleLocalServiceUtil.clearGroupRoles(stagingGroup.getGroupId());
345            }
346    
347            protected void verifyStagingGroupUserGroupMembership(Group stagingGroup) {
348                    List<UserGroup> stagingUserGroups =
349                            UserGroupLocalServiceUtil.getGroupUserGroups(
350                                    stagingGroup.getGroupId());
351    
352                    if (ListUtil.isEmpty(stagingUserGroups)) {
353                            return;
354                    }
355    
356                    List<UserGroup> liveUserGroups =
357                            UserGroupLocalServiceUtil.getGroupUserGroups(
358                                    stagingGroup.getLiveGroupId());
359    
360                    for (UserGroup stagingUserGroup : stagingUserGroups) {
361                            if (!liveUserGroups.contains(stagingUserGroup)) {
362                                    UserGroupLocalServiceUtil.addGroupUserGroup(
363                                            stagingGroup.getLiveGroupId(), stagingUserGroup);
364                            }
365                    }
366    
367                    UserGroupLocalServiceUtil.clearGroupUserGroups(
368                            stagingGroup.getGroupId());
369            }
370    
371            protected void verifyStagingGroupUserMembership(Group stagingGroup) {
372                    List<User> stagingGroupUsers = UserLocalServiceUtil.getGroupUsers(
373                            stagingGroup.getGroupId());
374    
375                    if (ListUtil.isEmpty(stagingGroupUsers)) {
376                            return;
377                    }
378    
379                    List<User> liveGroupUsers = UserLocalServiceUtil.getGroupUsers(
380                            stagingGroup.getLiveGroupId());
381    
382                    for (User stagingGroupUser : stagingGroupUsers) {
383                            if (!liveGroupUsers.contains(stagingGroupUser)) {
384                                    UserLocalServiceUtil.addGroupUser(
385                                            stagingGroup.getLiveGroupId(), stagingGroupUser);
386                            }
387                    }
388    
389                    UserLocalServiceUtil.clearGroupUsers(stagingGroup.getGroupId());
390            }
391    
392            protected void verifyStagingTypeSettingsProperties(
393                    UnicodeProperties typeSettingsProperties) {
394    
395                    Set<String> keys = typeSettingsProperties.keySet();
396    
397                    Iterator<String> iterator = keys.iterator();
398    
399                    while (iterator.hasNext()) {
400                            String key = iterator.next();
401    
402                            if (ArrayUtil.contains(
403                                            _LEGACY_STAGED_PORTLET_TYPE_SETTINGS_KEYS, key)) {
404    
405                                    if (_log.isInfoEnabled()) {
406                                            _log.info("Removing type settings property " + key);
407                                    }
408    
409                                    iterator.remove();
410                            }
411                    }
412            }
413    
414            protected void verifyStagingUserGroupGroupRolesAssignments(
415                    Group stagingGroup) {
416    
417                    DynamicQuery dynamicQuery =
418                            UserGroupGroupRoleLocalServiceUtil.dynamicQuery();
419    
420                    dynamicQuery.add(
421                            RestrictionsFactoryUtil.eq(
422                                    "id.groupId", stagingGroup.getGroupId()));
423    
424                    List<UserGroupGroupRole> stagingUserGroupGroupRoles =
425                            UserGroupGroupRoleLocalServiceUtil.dynamicQuery(dynamicQuery);
426    
427                    if (stagingUserGroupGroupRoles.isEmpty()) {
428                            return;
429                    }
430    
431                    dynamicQuery = UserGroupGroupRoleLocalServiceUtil.dynamicQuery();
432    
433                    dynamicQuery.add(
434                            RestrictionsFactoryUtil.eq(
435                                    "id.groupId", stagingGroup.getLiveGroupId()));
436    
437                    List<UserGroupGroupRole> liveUserGroupGroupRoles =
438                            UserGroupGroupRoleLocalServiceUtil.dynamicQuery(dynamicQuery);
439    
440                    for (UserGroupGroupRole userGroupGroupRole :
441                                    stagingUserGroupGroupRoles) {
442    
443                            userGroupGroupRole.setGroupId(stagingGroup.getLiveGroupId());
444    
445                            if (!liveUserGroupGroupRoles.contains(userGroupGroupRole)) {
446                                    UserGroupGroupRoleLocalServiceUtil.updateUserGroupGroupRole(
447                                            userGroupGroupRole);
448                            }
449                    }
450    
451                    UserGroupGroupRoleLocalServiceUtil.deleteUserGroupGroupRolesByGroupId(
452                            stagingGroup.getGroupId());
453            }
454    
455            protected void verifyStagingUserGroupRolesAssignments(Group stagingGroup) {
456                    List<UserGroupRole> stagingUserGroupRoles =
457                            UserGroupRoleLocalServiceUtil.getUserGroupRolesByGroup(
458                                    stagingGroup.getGroupId());
459    
460                    if (ListUtil.isEmpty(stagingUserGroupRoles)) {
461                            return;
462                    }
463    
464                    List<UserGroupRole> liveUserGroupRoles =
465                            UserGroupRoleLocalServiceUtil.getUserGroupRolesByGroup(
466                                    stagingGroup.getLiveGroupId());
467    
468                    for (UserGroupRole stagingUserGroupRole : stagingUserGroupRoles) {
469                            stagingUserGroupRole.setGroupId(stagingGroup.getLiveGroupId());
470    
471                            if (!liveUserGroupRoles.contains(stagingUserGroupRole)) {
472                                    UserGroupRoleLocalServiceUtil.updateUserGroupRole(
473                                            stagingUserGroupRole);
474                            }
475                    }
476    
477                    UserGroupRoleLocalServiceUtil.deleteUserGroupRolesByGroupId(
478                            stagingGroup.getGroupId());
479            }
480    
481            protected void verifyTree() throws Exception {
482                    long[] companyIds = PortalInstances.getCompanyIdsBySQL();
483    
484                    for (long companyId : companyIds) {
485                            GroupLocalServiceUtil.rebuildTree(companyId);
486                    }
487            }
488    
489            private static final String[] _LEGACY_STAGED_PORTLET_TYPE_SETTINGS_KEYS = {
490                    "staged-portlet_39", "staged-portlet_54", "staged-portlet_56",
491                    "staged-portlet_59", "staged-portlet_107", "staged-portlet_108",
492                    "staged-portlet_110", "staged-portlet_166", "staged-portlet_169"
493            };
494    
495            private static final Log _log = LogFactoryUtil.getLog(VerifyGroup.class);
496    
497    }