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.service; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 /** 020 * Provides a wrapper for {@link GroupLocalService}. 021 * 022 * @author Brian Wing Shun Chan 023 * @see GroupLocalService 024 * @generated 025 */ 026 @ProviderType 027 public class GroupLocalServiceWrapper implements GroupLocalService, 028 ServiceWrapper<GroupLocalService> { 029 public GroupLocalServiceWrapper(GroupLocalService groupLocalService) { 030 _groupLocalService = groupLocalService; 031 } 032 033 /** 034 * Adds the group to the database. Also notifies the appropriate model listeners. 035 * 036 * @param group the group 037 * @return the group that was added 038 */ 039 @Override 040 public com.liferay.portal.model.Group addGroup( 041 com.liferay.portal.model.Group group) { 042 return _groupLocalService.addGroup(group); 043 } 044 045 /** 046 * Adds a group. 047 * 048 * @param userId the primary key of the group's creator/owner 049 * @param parentGroupId the primary key of the parent group 050 * @param className the entity's class name 051 * @param classPK the primary key of the entity's instance 052 * @param liveGroupId the primary key of the live group 053 * @param name the entity's name 054 * @param description the group's description (optionally 055 <code>null</code>) 056 * @param type the group's type. For more information see {@link 057 GroupConstants}. 058 * @param manualMembership whether manual membership is allowed for the 059 group 060 * @param membershipRestriction the group's membership restriction. For 061 more information see {@link GroupConstants}. 062 * @param friendlyURL the group's friendlyURL (optionally 063 <code>null</code>) 064 * @param site whether the group is to be associated with a main site 065 * @param active whether the group is active 066 * @param serviceContext the service context to be applied (optionally 067 <code>null</code>). Can set asset category IDs and asset tag 068 names for the group, and whether the group is for staging. 069 * @return the group 070 * @throws PortalException if a portal exception occured 071 * @deprecated As of 7.0.0, replaced by {@link #addGroup(long, long, String, 072 long, long, Map, Map, int, boolean, int, String, boolean, 073 boolean, ServiceContext)} 074 */ 075 @Deprecated 076 @Override 077 public com.liferay.portal.model.Group addGroup(long userId, 078 long parentGroupId, java.lang.String className, long classPK, 079 long liveGroupId, java.lang.String name, java.lang.String description, 080 int type, boolean manualMembership, int membershipRestriction, 081 java.lang.String friendlyURL, boolean site, boolean active, 082 com.liferay.portal.service.ServiceContext serviceContext) 083 throws com.liferay.portal.kernel.exception.PortalException { 084 return _groupLocalService.addGroup(userId, parentGroupId, className, 085 classPK, liveGroupId, name, description, type, manualMembership, 086 membershipRestriction, friendlyURL, site, active, serviceContext); 087 } 088 089 @Override 090 public com.liferay.portal.model.Group addGroup(long userId, 091 long parentGroupId, java.lang.String className, long classPK, 092 long liveGroupId, 093 java.util.Map<java.util.Locale, java.lang.String> nameMap, 094 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 095 int type, boolean manualMembership, int membershipRestriction, 096 java.lang.String friendlyURL, boolean site, boolean active, 097 com.liferay.portal.service.ServiceContext serviceContext) 098 throws com.liferay.portal.kernel.exception.PortalException { 099 return _groupLocalService.addGroup(userId, parentGroupId, className, 100 classPK, liveGroupId, nameMap, descriptionMap, type, 101 manualMembership, membershipRestriction, friendlyURL, site, active, 102 serviceContext); 103 } 104 105 @Override 106 public com.liferay.portal.model.Group addGroup(long userId, 107 long parentGroupId, java.lang.String className, long classPK, 108 long liveGroupId, 109 java.util.Map<java.util.Locale, java.lang.String> nameMap, 110 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 111 int type, boolean manualMembership, int membershipRestriction, 112 java.lang.String friendlyURL, boolean site, boolean inheritContent, 113 boolean active, com.liferay.portal.service.ServiceContext serviceContext) 114 throws com.liferay.portal.kernel.exception.PortalException { 115 return _groupLocalService.addGroup(userId, parentGroupId, className, 116 classPK, liveGroupId, nameMap, descriptionMap, type, 117 manualMembership, membershipRestriction, friendlyURL, site, 118 inheritContent, active, serviceContext); 119 } 120 121 @Override 122 public void addOrganizationGroup(long organizationId, 123 com.liferay.portal.model.Group group) { 124 _groupLocalService.addOrganizationGroup(organizationId, group); 125 } 126 127 @Override 128 public void addOrganizationGroup(long organizationId, long groupId) { 129 _groupLocalService.addOrganizationGroup(organizationId, groupId); 130 } 131 132 @Override 133 public void addOrganizationGroups(long organizationId, 134 java.util.List<com.liferay.portal.model.Group> Groups) { 135 _groupLocalService.addOrganizationGroups(organizationId, Groups); 136 } 137 138 @Override 139 public void addOrganizationGroups(long organizationId, long[] groupIds) { 140 _groupLocalService.addOrganizationGroups(organizationId, groupIds); 141 } 142 143 @Override 144 public void addRoleGroup(long roleId, com.liferay.portal.model.Group group) { 145 _groupLocalService.addRoleGroup(roleId, group); 146 } 147 148 @Override 149 public void addRoleGroup(long roleId, long groupId) { 150 _groupLocalService.addRoleGroup(roleId, groupId); 151 } 152 153 @Override 154 public void addRoleGroups(long roleId, 155 java.util.List<com.liferay.portal.model.Group> Groups) { 156 _groupLocalService.addRoleGroups(roleId, Groups); 157 } 158 159 @Override 160 public void addRoleGroups(long roleId, long[] groupIds) { 161 _groupLocalService.addRoleGroups(roleId, groupIds); 162 } 163 164 @Override 165 public void addUserGroup(long userId, com.liferay.portal.model.Group group) { 166 _groupLocalService.addUserGroup(userId, group); 167 } 168 169 @Override 170 public void addUserGroup(long userId, long groupId) { 171 _groupLocalService.addUserGroup(userId, groupId); 172 } 173 174 @Override 175 public void addUserGroupGroup(long userGroupId, 176 com.liferay.portal.model.Group group) { 177 _groupLocalService.addUserGroupGroup(userGroupId, group); 178 } 179 180 @Override 181 public void addUserGroupGroup(long userGroupId, long groupId) { 182 _groupLocalService.addUserGroupGroup(userGroupId, groupId); 183 } 184 185 @Override 186 public void addUserGroupGroups(long userGroupId, 187 java.util.List<com.liferay.portal.model.Group> Groups) { 188 _groupLocalService.addUserGroupGroups(userGroupId, Groups); 189 } 190 191 @Override 192 public void addUserGroupGroups(long userGroupId, long[] groupIds) { 193 _groupLocalService.addUserGroupGroups(userGroupId, groupIds); 194 } 195 196 @Override 197 public void addUserGroups(long userId, 198 java.util.List<com.liferay.portal.model.Group> Groups) { 199 _groupLocalService.addUserGroups(userId, Groups); 200 } 201 202 @Override 203 public void addUserGroups(long userId, long[] groupIds) { 204 _groupLocalService.addUserGroups(userId, groupIds); 205 } 206 207 /** 208 * Adds a company group if it does not exist. This method is typically used 209 * when a virtual host is added. 210 * 211 * @param companyId the primary key of the company 212 * @throws PortalException if a portal exception occurred 213 */ 214 @Override 215 public void checkCompanyGroup(long companyId) 216 throws com.liferay.portal.kernel.exception.PortalException { 217 _groupLocalService.checkCompanyGroup(companyId); 218 } 219 220 /** 221 * Creates systems groups and other related data needed by the system on the 222 * very first startup. Also takes care of creating the Control Panel groups 223 * and layouts. 224 * 225 * @param companyId the primary key of the company 226 * @throws PortalException if a portal exception occurred 227 */ 228 @Override 229 public void checkSystemGroups(long companyId) 230 throws com.liferay.portal.kernel.exception.PortalException { 231 _groupLocalService.checkSystemGroups(companyId); 232 } 233 234 @Override 235 public void clearOrganizationGroups(long organizationId) { 236 _groupLocalService.clearOrganizationGroups(organizationId); 237 } 238 239 @Override 240 public void clearRoleGroups(long roleId) { 241 _groupLocalService.clearRoleGroups(roleId); 242 } 243 244 @Override 245 public void clearUserGroupGroups(long userGroupId) { 246 _groupLocalService.clearUserGroupGroups(userGroupId); 247 } 248 249 @Override 250 public void clearUserGroups(long userId) { 251 _groupLocalService.clearUserGroups(userId); 252 } 253 254 /** 255 * Creates a new group with the primary key. Does not add the group to the database. 256 * 257 * @param groupId the primary key for the new group 258 * @return the new group 259 */ 260 @Override 261 public com.liferay.portal.model.Group createGroup(long groupId) { 262 return _groupLocalService.createGroup(groupId); 263 } 264 265 /** 266 * Deletes the group from the database. Also notifies the appropriate model listeners. 267 * 268 * @param group the group 269 * @return the group that was removed 270 * @throws PortalException 271 */ 272 @Override 273 public com.liferay.portal.model.Group deleteGroup( 274 com.liferay.portal.model.Group group) 275 throws com.liferay.portal.kernel.exception.PortalException { 276 return _groupLocalService.deleteGroup(group); 277 } 278 279 /** 280 * Deletes the group with the primary key from the database. Also notifies the appropriate model listeners. 281 * 282 * @param groupId the primary key of the group 283 * @return the group that was removed 284 * @throws PortalException if a group with the primary key could not be found 285 */ 286 @Override 287 public com.liferay.portal.model.Group deleteGroup(long groupId) 288 throws com.liferay.portal.kernel.exception.PortalException { 289 return _groupLocalService.deleteGroup(groupId); 290 } 291 292 @Override 293 public void deleteOrganizationGroup(long organizationId, 294 com.liferay.portal.model.Group group) { 295 _groupLocalService.deleteOrganizationGroup(organizationId, group); 296 } 297 298 @Override 299 public void deleteOrganizationGroup(long organizationId, long groupId) { 300 _groupLocalService.deleteOrganizationGroup(organizationId, groupId); 301 } 302 303 @Override 304 public void deleteOrganizationGroups(long organizationId, 305 java.util.List<com.liferay.portal.model.Group> Groups) { 306 _groupLocalService.deleteOrganizationGroups(organizationId, Groups); 307 } 308 309 @Override 310 public void deleteOrganizationGroups(long organizationId, long[] groupIds) { 311 _groupLocalService.deleteOrganizationGroups(organizationId, groupIds); 312 } 313 314 /** 315 * @throws PortalException 316 */ 317 @Override 318 public com.liferay.portal.model.PersistedModel deletePersistedModel( 319 com.liferay.portal.model.PersistedModel persistedModel) 320 throws com.liferay.portal.kernel.exception.PortalException { 321 return _groupLocalService.deletePersistedModel(persistedModel); 322 } 323 324 @Override 325 public void deleteRoleGroup(long roleId, 326 com.liferay.portal.model.Group group) { 327 _groupLocalService.deleteRoleGroup(roleId, group); 328 } 329 330 @Override 331 public void deleteRoleGroup(long roleId, long groupId) { 332 _groupLocalService.deleteRoleGroup(roleId, groupId); 333 } 334 335 @Override 336 public void deleteRoleGroups(long roleId, 337 java.util.List<com.liferay.portal.model.Group> Groups) { 338 _groupLocalService.deleteRoleGroups(roleId, Groups); 339 } 340 341 @Override 342 public void deleteRoleGroups(long roleId, long[] groupIds) { 343 _groupLocalService.deleteRoleGroups(roleId, groupIds); 344 } 345 346 @Override 347 public void deleteUserGroup(long userId, 348 com.liferay.portal.model.Group group) { 349 _groupLocalService.deleteUserGroup(userId, group); 350 } 351 352 @Override 353 public void deleteUserGroup(long userId, long groupId) { 354 _groupLocalService.deleteUserGroup(userId, groupId); 355 } 356 357 @Override 358 public void deleteUserGroupGroup(long userGroupId, 359 com.liferay.portal.model.Group group) { 360 _groupLocalService.deleteUserGroupGroup(userGroupId, group); 361 } 362 363 @Override 364 public void deleteUserGroupGroup(long userGroupId, long groupId) { 365 _groupLocalService.deleteUserGroupGroup(userGroupId, groupId); 366 } 367 368 @Override 369 public void deleteUserGroupGroups(long userGroupId, 370 java.util.List<com.liferay.portal.model.Group> Groups) { 371 _groupLocalService.deleteUserGroupGroups(userGroupId, Groups); 372 } 373 374 @Override 375 public void deleteUserGroupGroups(long userGroupId, long[] groupIds) { 376 _groupLocalService.deleteUserGroupGroups(userGroupId, groupIds); 377 } 378 379 @Override 380 public void deleteUserGroups(long userId, 381 java.util.List<com.liferay.portal.model.Group> Groups) { 382 _groupLocalService.deleteUserGroups(userId, Groups); 383 } 384 385 @Override 386 public void deleteUserGroups(long userId, long[] groupIds) { 387 _groupLocalService.deleteUserGroups(userId, groupIds); 388 } 389 390 @Override 391 public void disableStaging(long groupId) 392 throws com.liferay.portal.kernel.exception.PortalException { 393 _groupLocalService.disableStaging(groupId); 394 } 395 396 @Override 397 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 398 return _groupLocalService.dynamicQuery(); 399 } 400 401 /** 402 * Performs a dynamic query on the database and returns the matching rows. 403 * 404 * @param dynamicQuery the dynamic query 405 * @return the matching rows 406 */ 407 @Override 408 public <T> java.util.List<T> dynamicQuery( 409 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 410 return _groupLocalService.dynamicQuery(dynamicQuery); 411 } 412 413 /** 414 * Performs a dynamic query on the database and returns a range of the matching rows. 415 * 416 * <p> 417 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 418 * </p> 419 * 420 * @param dynamicQuery the dynamic query 421 * @param start the lower bound of the range of model instances 422 * @param end the upper bound of the range of model instances (not inclusive) 423 * @return the range of matching rows 424 */ 425 @Override 426 public <T> java.util.List<T> dynamicQuery( 427 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 428 int end) { 429 return _groupLocalService.dynamicQuery(dynamicQuery, start, end); 430 } 431 432 /** 433 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 434 * 435 * <p> 436 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 437 * </p> 438 * 439 * @param dynamicQuery the dynamic query 440 * @param start the lower bound of the range of model instances 441 * @param end the upper bound of the range of model instances (not inclusive) 442 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 443 * @return the ordered range of matching rows 444 */ 445 @Override 446 public <T> java.util.List<T> dynamicQuery( 447 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 448 int end, 449 com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) { 450 return _groupLocalService.dynamicQuery(dynamicQuery, start, end, 451 orderByComparator); 452 } 453 454 /** 455 * Returns the number of rows matching the dynamic query. 456 * 457 * @param dynamicQuery the dynamic query 458 * @return the number of rows matching the dynamic query 459 */ 460 @Override 461 public long dynamicQueryCount( 462 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 463 return _groupLocalService.dynamicQueryCount(dynamicQuery); 464 } 465 466 /** 467 * Returns the number of rows matching the dynamic query. 468 * 469 * @param dynamicQuery the dynamic query 470 * @param projection the projection to apply to the query 471 * @return the number of rows matching the dynamic query 472 */ 473 @Override 474 public long dynamicQueryCount( 475 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 476 com.liferay.portal.kernel.dao.orm.Projection projection) { 477 return _groupLocalService.dynamicQueryCount(dynamicQuery, projection); 478 } 479 480 @Override 481 public void enableStaging(long groupId) 482 throws com.liferay.portal.kernel.exception.PortalException { 483 _groupLocalService.enableStaging(groupId); 484 } 485 486 /** 487 * Returns the company's group. 488 * 489 * @param companyId the primary key of the company 490 * @return the company's group, or <code>null</code> if a matching group 491 could not be found 492 */ 493 @Override 494 public com.liferay.portal.model.Group fetchCompanyGroup(long companyId) { 495 return _groupLocalService.fetchCompanyGroup(companyId); 496 } 497 498 /** 499 * Returns the group with the matching friendly URL. 500 * 501 * @param companyId the primary key of the company 502 * @param friendlyURL the friendly URL 503 * @return the group with the friendly URL, or <code>null</code> if a 504 matching group could not be found 505 */ 506 @Override 507 public com.liferay.portal.model.Group fetchFriendlyURLGroup( 508 long companyId, java.lang.String friendlyURL) { 509 return _groupLocalService.fetchFriendlyURLGroup(companyId, friendlyURL); 510 } 511 512 /** 513 * Returns the group with the matching group key by first searching the 514 * system groups and then using the finder cache. 515 * 516 * @param companyId the primary key of the company 517 * @param groupKey the group key 518 * @return the group with the group key and associated company, or 519 <code>null</code> if a matching group could not be found 520 */ 521 @Override 522 public com.liferay.portal.model.Group fetchGroup(long companyId, 523 java.lang.String groupKey) { 524 return _groupLocalService.fetchGroup(companyId, groupKey); 525 } 526 527 @Override 528 public com.liferay.portal.model.Group fetchGroup(long groupId) { 529 return _groupLocalService.fetchGroup(groupId); 530 } 531 532 /** 533 * Returns the group with the matching UUID and company. 534 * 535 * @param uuid the group's UUID 536 * @param companyId the primary key of the company 537 * @return the matching group, or <code>null</code> if a matching group could not be found 538 */ 539 @Override 540 public com.liferay.portal.model.Group fetchGroupByUuidAndCompanyId( 541 java.lang.String uuid, long companyId) { 542 return _groupLocalService.fetchGroupByUuidAndCompanyId(uuid, companyId); 543 } 544 545 @Override 546 public com.liferay.portal.model.Group fetchUserGroup(long companyId, 547 long userId) { 548 return _groupLocalService.fetchUserGroup(companyId, userId); 549 } 550 551 /** 552 * Returns the default user's personal site group. 553 * 554 * @param companyId the primary key of the company 555 * @return the default user's personal site group, or <code>null</code> if a 556 matching group could not be found 557 * @throws PortalException if a portal exception occurred 558 */ 559 @Override 560 public com.liferay.portal.model.Group fetchUserPersonalSiteGroup( 561 long companyId) 562 throws com.liferay.portal.kernel.exception.PortalException { 563 return _groupLocalService.fetchUserPersonalSiteGroup(companyId); 564 } 565 566 @Override 567 public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() { 568 return _groupLocalService.getActionableDynamicQuery(); 569 } 570 571 /** 572 * Returns all the active or inactive groups associated with the company. 573 * 574 * @param companyId the primary key of the company 575 * @param active whether to return only active groups, or only inactive 576 groups 577 * @return the active or inactive groups associated with the company 578 */ 579 @Override 580 public java.util.List<com.liferay.portal.model.Group> getActiveGroups( 581 long companyId, boolean active) { 582 return _groupLocalService.getActiveGroups(companyId, active); 583 } 584 585 /** 586 * Returns the company group. 587 * 588 * @param companyId the primary key of the company 589 * @return the group associated with the company 590 * @throws PortalException if a portal exception occurred 591 */ 592 @Override 593 public com.liferay.portal.model.Group getCompanyGroup(long companyId) 594 throws com.liferay.portal.kernel.exception.PortalException { 595 return _groupLocalService.getCompanyGroup(companyId); 596 } 597 598 /** 599 * Returns a range of all the groups associated with the company. 600 * 601 * <p> 602 * Useful when paginating results. Returns a maximum of <code>end - 603 * start</code> instances. <code>start</code> and <code>end</code> are not 604 * primary keys, they are indexes in the result set. Thus, <code>0</code> 605 * refers to the first result in the set. Setting both <code>start</code> 606 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 607 * result set. 608 * </p> 609 * 610 * @param companyId the primary key of the company 611 * @param start the lower bound of the range of groups to return 612 * @param end the upper bound of the range of groups to return (not 613 inclusive) 614 * @return the range of groups associated with the company 615 */ 616 @Override 617 public java.util.List<com.liferay.portal.model.Group> getCompanyGroups( 618 long companyId, int start, int end) { 619 return _groupLocalService.getCompanyGroups(companyId, start, end); 620 } 621 622 /** 623 * Returns the number of groups associated with the company. 624 * 625 * @param companyId the primary key of the company 626 * @return the number of groups associated with the company 627 */ 628 @Override 629 public int getCompanyGroupsCount(long companyId) { 630 return _groupLocalService.getCompanyGroupsCount(companyId); 631 } 632 633 /** 634 * Returns the group with the matching friendly URL. 635 * 636 * @param companyId the primary key of the company 637 * @param friendlyURL the group's friendlyURL 638 * @return the group with the friendly URL 639 * @throws PortalException if a portal exception occurred 640 */ 641 @Override 642 public com.liferay.portal.model.Group getFriendlyURLGroup(long companyId, 643 java.lang.String friendlyURL) 644 throws com.liferay.portal.kernel.exception.PortalException { 645 return _groupLocalService.getFriendlyURLGroup(companyId, friendlyURL); 646 } 647 648 /** 649 * Returns the group with the matching group key. 650 * 651 * @param companyId the primary key of the company 652 * @param groupKey the group key 653 * @return the group with the group key 654 * @throws PortalException if a portal exception occurred 655 */ 656 @Override 657 public com.liferay.portal.model.Group getGroup(long companyId, 658 java.lang.String groupKey) 659 throws com.liferay.portal.kernel.exception.PortalException { 660 return _groupLocalService.getGroup(companyId, groupKey); 661 } 662 663 /** 664 * Returns the group with the primary key. 665 * 666 * @param groupId the primary key of the group 667 * @return the group 668 * @throws PortalException if a group with the primary key could not be found 669 */ 670 @Override 671 public com.liferay.portal.model.Group getGroup(long groupId) 672 throws com.liferay.portal.kernel.exception.PortalException { 673 return _groupLocalService.getGroup(groupId); 674 } 675 676 /** 677 * Returns the group with the matching UUID and company. 678 * 679 * @param uuid the group's UUID 680 * @param companyId the primary key of the company 681 * @return the matching group 682 * @throws PortalException if a matching group could not be found 683 */ 684 @Override 685 public com.liferay.portal.model.Group getGroupByUuidAndCompanyId( 686 java.lang.String uuid, long companyId) 687 throws com.liferay.portal.kernel.exception.PortalException { 688 return _groupLocalService.getGroupByUuidAndCompanyId(uuid, companyId); 689 } 690 691 /** 692 * @deprecated As of 7.0.0, replaced by {@link 693 Group#getDescriptiveName(Locale)} 694 */ 695 @Deprecated 696 @Override 697 public java.lang.String getGroupDescriptiveName( 698 com.liferay.portal.model.Group group, java.util.Locale locale) 699 throws com.liferay.portal.kernel.exception.PortalException { 700 return _groupLocalService.getGroupDescriptiveName(group, locale); 701 } 702 703 /** 704 * @deprecated As of 7.0.0, replaced by {@link 705 Group#getDescriptiveName(Locale)} 706 */ 707 @Deprecated 708 @Override 709 public java.lang.String getGroupDescriptiveName(long groupId, 710 java.util.Locale locale) 711 throws com.liferay.portal.kernel.exception.PortalException { 712 return _groupLocalService.getGroupDescriptiveName(groupId, locale); 713 } 714 715 /** 716 * Returns all the groups that are direct children of the parent group with 717 * the matching className. 718 * 719 * @param companyId the primary key of the company 720 * @param className the class name of the group 721 * @param parentGroupId the primary key of the parent group 722 * @return the matching groups, or <code>null</code> if no matches were 723 found 724 */ 725 @Override 726 public java.util.List<com.liferay.portal.model.Group> getGroups( 727 long companyId, java.lang.String className, long parentGroupId) { 728 return _groupLocalService.getGroups(companyId, className, parentGroupId); 729 } 730 731 /** 732 * Returns a range of all the groups that are direct children of the parent 733 * group with the matching className. 734 * 735 * @param companyId the primary key of the company 736 * @param className the class name of the group 737 * @param parentGroupId the primary key of the parent group 738 * @param start the lower bound of the range of results 739 * @param end the upper bound of the range of results (not inclusive) 740 * @return the range of matching groups 741 */ 742 @Override 743 public java.util.List<com.liferay.portal.model.Group> getGroups( 744 long companyId, java.lang.String className, long parentGroupId, 745 int start, int end) { 746 return _groupLocalService.getGroups(companyId, className, 747 parentGroupId, start, end); 748 } 749 750 /** 751 * Returns all the groups that are direct children of the parent group. 752 * 753 * @param companyId the primary key of the company 754 * @param parentGroupId the primary key of the parent group 755 * @param site whether the group is to be associated with a main site 756 * @return the matching groups, or <code>null</code> if no matches were 757 found 758 */ 759 @Override 760 public java.util.List<com.liferay.portal.model.Group> getGroups( 761 long companyId, long parentGroupId, boolean site) { 762 return _groupLocalService.getGroups(companyId, parentGroupId, site); 763 } 764 765 @Override 766 public java.util.List<com.liferay.portal.model.Group> getGroups( 767 long companyId, long parentGroupId, boolean site, boolean inheritContent) { 768 return _groupLocalService.getGroups(companyId, parentGroupId, site, 769 inheritContent); 770 } 771 772 /** 773 * Returns the groups with the matching primary keys. 774 * 775 * @param groupIds the primary keys of the groups 776 * @return the groups with the primary keys 777 * @throws PortalException if a portal exception occurred 778 */ 779 @Override 780 public java.util.List<com.liferay.portal.model.Group> getGroups( 781 long[] groupIds) 782 throws com.liferay.portal.kernel.exception.PortalException { 783 return _groupLocalService.getGroups(groupIds); 784 } 785 786 /** 787 * Returns a range of all the groups. 788 * 789 * <p> 790 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.GroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 791 * </p> 792 * 793 * @param start the lower bound of the range of groups 794 * @param end the upper bound of the range of groups (not inclusive) 795 * @return the range of groups 796 */ 797 @Override 798 public java.util.List<com.liferay.portal.model.Group> getGroups(int start, 799 int end) { 800 return _groupLocalService.getGroups(start, end); 801 } 802 803 /** 804 * Returns the number of groups. 805 * 806 * @return the number of groups 807 */ 808 @Override 809 public int getGroupsCount() { 810 return _groupLocalService.getGroupsCount(); 811 } 812 813 /** 814 * Returns the number of groups that are direct children of the parent group 815 * with the matching className. 816 * 817 * @param companyId the primary key of the company 818 * @param className the class name of the group 819 * @param parentGroupId the primary key of the parent group 820 * @return the number of matching groups 821 */ 822 @Override 823 public int getGroupsCount(long companyId, java.lang.String className, 824 long parentGroupId) { 825 return _groupLocalService.getGroupsCount(companyId, className, 826 parentGroupId); 827 } 828 829 /** 830 * Returns the number of groups that are direct children of the parent 831 * group. 832 * 833 * @param companyId the primary key of the company 834 * @param parentGroupId the primary key of the parent group 835 * @param site whether the group is to be associated with a main site 836 * @return the number of matching groups 837 */ 838 @Override 839 public int getGroupsCount(long companyId, long parentGroupId, boolean site) { 840 return _groupLocalService.getGroupsCount(companyId, parentGroupId, site); 841 } 842 843 @Override 844 public com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery getIndexableActionableDynamicQuery() { 845 return _groupLocalService.getIndexableActionableDynamicQuery(); 846 } 847 848 /** 849 * Returns the group associated with the layout. 850 * 851 * @param companyId the primary key of the company 852 * @param plid the primary key of the layout 853 * @return the group associated with the layout 854 * @throws PortalException if a portal exception occurred 855 */ 856 @Override 857 public com.liferay.portal.model.Group getLayoutGroup(long companyId, 858 long plid) throws com.liferay.portal.kernel.exception.PortalException { 859 return _groupLocalService.getLayoutGroup(companyId, plid); 860 } 861 862 /** 863 * Returns the group associated with the layout prototype. 864 * 865 * @param companyId the primary key of the company 866 * @param layoutPrototypeId the primary key of the layout prototype 867 * @return the group associated with the layout prototype 868 * @throws PortalException if a portal exception occurred 869 */ 870 @Override 871 public com.liferay.portal.model.Group getLayoutPrototypeGroup( 872 long companyId, long layoutPrototypeId) 873 throws com.liferay.portal.kernel.exception.PortalException { 874 return _groupLocalService.getLayoutPrototypeGroup(companyId, 875 layoutPrototypeId); 876 } 877 878 /** 879 * Returns the group associated with the layout set prototype. 880 * 881 * @param companyId the primary key of the company 882 * @param layoutSetPrototypeId the primary key of the layout set prototype 883 * @return the group associated with the layout set prototype 884 * @throws PortalException if a portal exception occurred 885 */ 886 @Override 887 public com.liferay.portal.model.Group getLayoutSetPrototypeGroup( 888 long companyId, long layoutSetPrototypeId) 889 throws com.liferay.portal.kernel.exception.PortalException { 890 return _groupLocalService.getLayoutSetPrototypeGroup(companyId, 891 layoutSetPrototypeId); 892 } 893 894 /** 895 * Returns a range of all groups that are children of the parent group and 896 * that have at least one layout. 897 * 898 * <p> 899 * Useful when paginating results. Returns a maximum of <code>end - 900 * start</code> instances. <code>start</code> and <code>end</code> are not 901 * primary keys, they are indexes in the result set. Thus, <code>0</code> 902 * refers to the first result in the set. Setting both <code>start</code> 903 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 904 * result set. 905 * </p> 906 * 907 * @param companyId the primary key of the company 908 * @param parentGroupId the primary key of the parent group 909 * @param site whether the group is to be associated with a main site 910 * @param start the lower bound of the range of groups to return 911 * @param end the upper bound of the range of groups to return (not 912 inclusive) 913 * @param obc the comparator to order the groups (optionally 914 <code>null</code>) 915 * @return the range of matching groups ordered by comparator 916 <code>obc</code> 917 */ 918 @Override 919 public java.util.List<com.liferay.portal.model.Group> getLayoutsGroups( 920 long companyId, long parentGroupId, boolean site, int start, int end, 921 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 922 return _groupLocalService.getLayoutsGroups(companyId, parentGroupId, 923 site, start, end, obc); 924 } 925 926 /** 927 * Returns the number of groups that are children or the parent group and 928 * that have at least one layout 929 * 930 * @param companyId the primary key of the company 931 * @param parentGroupId the primary key of the parent group 932 * @param site whether the group is to be associated with a main site 933 * @return the number of matching groups 934 */ 935 @Override 936 public int getLayoutsGroupsCount(long companyId, long parentGroupId, 937 boolean site) { 938 return _groupLocalService.getLayoutsGroupsCount(companyId, 939 parentGroupId, site); 940 } 941 942 /** 943 * Returns all live groups. 944 * 945 * @return all live groups 946 */ 947 @Override 948 public java.util.List<com.liferay.portal.model.Group> getLiveGroups() { 949 return _groupLocalService.getLiveGroups(); 950 } 951 952 /** 953 * Returns a range of all non-system groups of a specified type (className) 954 * that have no layouts. 955 * 956 * <p> 957 * Useful when paginating results. Returns a maximum of <code>end - 958 * start</code> instances. <code>start</code> and <code>end</code> are not 959 * primary keys, they are indexes in the result set. Thus, <code>0</code> 960 * refers to the first result in the set. Setting both <code>start</code> 961 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 962 * result set. 963 * </p> 964 * 965 * @param className the entity's class name 966 * @param privateLayout whether to include groups with private layout sets 967 or non-private layout sets 968 * @param start the lower bound of the range of groups to return 969 * @param end the upper bound of the range of groups to return (not 970 inclusive) 971 * @return the range of matching groups 972 */ 973 @Override 974 public java.util.List<com.liferay.portal.model.Group> getNoLayoutsGroups( 975 java.lang.String className, boolean privateLayout, int start, int end) { 976 return _groupLocalService.getNoLayoutsGroups(className, privateLayout, 977 start, end); 978 } 979 980 /** 981 * Returns all non-system groups having <code>null</code> or empty friendly 982 * URLs. 983 * 984 * @return the non-system groups having <code>null</code> or empty friendly 985 URLs 986 */ 987 @Override 988 public java.util.List<com.liferay.portal.model.Group> getNullFriendlyURLGroups() { 989 return _groupLocalService.getNullFriendlyURLGroups(); 990 } 991 992 /** 993 * Returns the OSGi service identifier. 994 * 995 * @return the OSGi service identifier 996 */ 997 @Override 998 public java.lang.String getOSGiServiceIdentifier() { 999 return _groupLocalService.getOSGiServiceIdentifier(); 1000 } 1001 1002 /** 1003 * Returns the specified organization group. 1004 * 1005 * @param companyId the primary key of the company 1006 * @param organizationId the primary key of the organization 1007 * @return the group associated with the organization 1008 * @throws PortalException if a portal exception occurred 1009 */ 1010 @Override 1011 public com.liferay.portal.model.Group getOrganizationGroup(long companyId, 1012 long organizationId) 1013 throws com.liferay.portal.kernel.exception.PortalException { 1014 return _groupLocalService.getOrganizationGroup(companyId, organizationId); 1015 } 1016 1017 @Override 1018 public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups( 1019 long organizationId) { 1020 return _groupLocalService.getOrganizationGroups(organizationId); 1021 } 1022 1023 @Override 1024 public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups( 1025 long organizationId, int start, int end) { 1026 return _groupLocalService.getOrganizationGroups(organizationId, start, 1027 end); 1028 } 1029 1030 @Override 1031 public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups( 1032 long organizationId, int start, int end, 1033 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) { 1034 return _groupLocalService.getOrganizationGroups(organizationId, start, 1035 end, orderByComparator); 1036 } 1037 1038 @Override 1039 public int getOrganizationGroupsCount(long organizationId) { 1040 return _groupLocalService.getOrganizationGroupsCount(organizationId); 1041 } 1042 1043 /** 1044 * Returns the organizationIds of the organizations associated with the group. 1045 * 1046 * @param groupId the groupId of the group 1047 * @return long[] the organizationIds of organizations associated with the group 1048 */ 1049 @Override 1050 public long[] getOrganizationPrimaryKeys(long groupId) { 1051 return _groupLocalService.getOrganizationPrimaryKeys(groupId); 1052 } 1053 1054 /** 1055 * Returns the specified organization groups. 1056 * 1057 * @param organizations the organizations 1058 * @return the groups associated with the organizations 1059 */ 1060 @Override 1061 public java.util.List<com.liferay.portal.model.Group> getOrganizationsGroups( 1062 java.util.List<com.liferay.portal.model.Organization> organizations) { 1063 return _groupLocalService.getOrganizationsGroups(organizations); 1064 } 1065 1066 /** 1067 * Returns all the groups related to the organizations. 1068 * 1069 * @param organizations the organizations 1070 * @return the groups related to the organizations 1071 */ 1072 @Override 1073 public java.util.List<com.liferay.portal.model.Group> getOrganizationsRelatedGroups( 1074 java.util.List<com.liferay.portal.model.Organization> organizations) { 1075 return _groupLocalService.getOrganizationsRelatedGroups(organizations); 1076 } 1077 1078 /** 1079 * Returns the group followed by all its parent groups ordered by closest 1080 * ancestor. 1081 * 1082 * @param groupId the primary key of the group 1083 * @return the group followed by all its parent groups ordered by closest 1084 ancestor 1085 * @throws PortalException if a portal exception occurred 1086 */ 1087 @Override 1088 public java.util.List<com.liferay.portal.model.Group> getParentGroups( 1089 long groupId) 1090 throws com.liferay.portal.kernel.exception.PortalException { 1091 return _groupLocalService.getParentGroups(groupId); 1092 } 1093 1094 @Override 1095 public com.liferay.portal.model.PersistedModel getPersistedModel( 1096 java.io.Serializable primaryKeyObj) 1097 throws com.liferay.portal.kernel.exception.PortalException { 1098 return _groupLocalService.getPersistedModel(primaryKeyObj); 1099 } 1100 1101 @Override 1102 public java.util.List<com.liferay.portal.model.Group> getRoleGroups( 1103 long roleId) { 1104 return _groupLocalService.getRoleGroups(roleId); 1105 } 1106 1107 @Override 1108 public java.util.List<com.liferay.portal.model.Group> getRoleGroups( 1109 long roleId, int start, int end) { 1110 return _groupLocalService.getRoleGroups(roleId, start, end); 1111 } 1112 1113 @Override 1114 public java.util.List<com.liferay.portal.model.Group> getRoleGroups( 1115 long roleId, int start, int end, 1116 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) { 1117 return _groupLocalService.getRoleGroups(roleId, start, end, 1118 orderByComparator); 1119 } 1120 1121 @Override 1122 public int getRoleGroupsCount(long roleId) { 1123 return _groupLocalService.getRoleGroupsCount(roleId); 1124 } 1125 1126 /** 1127 * Returns the roleIds of the roles associated with the group. 1128 * 1129 * @param groupId the groupId of the group 1130 * @return long[] the roleIds of roles associated with the group 1131 */ 1132 @Override 1133 public long[] getRolePrimaryKeys(long groupId) { 1134 return _groupLocalService.getRolePrimaryKeys(groupId); 1135 } 1136 1137 /** 1138 * Returns the staging group. 1139 * 1140 * @param liveGroupId the primary key of the live group 1141 * @return the staging group 1142 * @throws PortalException if a portal exception occurred 1143 */ 1144 @Override 1145 public com.liferay.portal.model.Group getStagingGroup(long liveGroupId) 1146 throws com.liferay.portal.kernel.exception.PortalException { 1147 return _groupLocalService.getStagingGroup(liveGroupId); 1148 } 1149 1150 /** 1151 * Returns the group directly associated with the user. 1152 * 1153 * @param companyId the primary key of the company 1154 * @param userId the primary key of the user 1155 * @return the group directly associated with the user 1156 * @throws PortalException if a portal exception occurred 1157 */ 1158 @Override 1159 public com.liferay.portal.model.Group getUserGroup(long companyId, 1160 long userId) throws com.liferay.portal.kernel.exception.PortalException { 1161 return _groupLocalService.getUserGroup(companyId, userId); 1162 } 1163 1164 /** 1165 * Returns the specified "user group" group. That is, the group that 1166 * represents the {@link UserGroup} entity. 1167 * 1168 * @param companyId the primary key of the company 1169 * @param userGroupId the primary key of the user group 1170 * @return the group associated with the user group 1171 * @throws PortalException if a portal exception occurred 1172 */ 1173 @Override 1174 public com.liferay.portal.model.Group getUserGroupGroup(long companyId, 1175 long userGroupId) 1176 throws com.liferay.portal.kernel.exception.PortalException { 1177 return _groupLocalService.getUserGroupGroup(companyId, userGroupId); 1178 } 1179 1180 @Override 1181 public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups( 1182 long userGroupId) { 1183 return _groupLocalService.getUserGroupGroups(userGroupId); 1184 } 1185 1186 @Override 1187 public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups( 1188 long userGroupId, int start, int end) { 1189 return _groupLocalService.getUserGroupGroups(userGroupId, start, end); 1190 } 1191 1192 @Override 1193 public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups( 1194 long userGroupId, int start, int end, 1195 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) { 1196 return _groupLocalService.getUserGroupGroups(userGroupId, start, end, 1197 orderByComparator); 1198 } 1199 1200 @Override 1201 public int getUserGroupGroupsCount(long userGroupId) { 1202 return _groupLocalService.getUserGroupGroupsCount(userGroupId); 1203 } 1204 1205 /** 1206 * Returns the userGroupIds of the user groups associated with the group. 1207 * 1208 * @param groupId the groupId of the group 1209 * @return long[] the userGroupIds of user groups associated with the group 1210 */ 1211 @Override 1212 public long[] getUserGroupPrimaryKeys(long groupId) { 1213 return _groupLocalService.getUserGroupPrimaryKeys(groupId); 1214 } 1215 1216 @Override 1217 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1218 long userId) { 1219 return _groupLocalService.getUserGroups(userId); 1220 } 1221 1222 /** 1223 * Returns all the user's site groups and immediate organization groups, 1224 * optionally including the user's inherited organization groups and user 1225 * groups. System and staged groups are not included. 1226 * 1227 * @param userId the primary key of the user 1228 * @param inherit whether to include the user's inherited organization 1229 groups and user groups 1230 * @return the user's groups and immediate organization groups 1231 * @throws PortalException if a portal exception occurred 1232 */ 1233 @Override 1234 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1235 long userId, boolean inherit) 1236 throws com.liferay.portal.kernel.exception.PortalException { 1237 return _groupLocalService.getUserGroups(userId, inherit); 1238 } 1239 1240 /** 1241 * Returns an ordered range of all the user's site groups and immediate 1242 * organization groups, optionally including the user's inherited 1243 * organization groups and user groups. System and staged groups are not 1244 * included. 1245 * 1246 * <p> 1247 * Useful when paginating results. Returns a maximum of <code>end - 1248 * start</code> instances. <code>start</code> and <code>end</code> are not 1249 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1250 * refers to the first result in the set. Setting both <code>start</code> 1251 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1252 * result set. 1253 * </p> 1254 * 1255 * @param userId the primary key of the user 1256 * @param inherit whether to include the user's inherited organization 1257 groups and user groups 1258 * @param start the lower bound of the range of groups to return 1259 * @param end the upper bound of the range of groups to return (not 1260 inclusive) 1261 * @return the range of the user's groups and immediate organization groups 1262 ordered by name 1263 * @throws PortalException if a portal exception occurred 1264 */ 1265 @Override 1266 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1267 long userId, boolean inherit, int start, int end) 1268 throws com.liferay.portal.kernel.exception.PortalException { 1269 return _groupLocalService.getUserGroups(userId, inherit, start, end); 1270 } 1271 1272 @Override 1273 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1274 long userId, int start, int end) { 1275 return _groupLocalService.getUserGroups(userId, start, end); 1276 } 1277 1278 /** 1279 * @throws PortalException 1280 */ 1281 @Override 1282 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1283 long userId, int start, int end, 1284 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) 1285 throws com.liferay.portal.kernel.exception.PortalException { 1286 return _groupLocalService.getUserGroups(userId, start, end, 1287 orderByComparator); 1288 } 1289 1290 @Override 1291 public int getUserGroupsCount(long userId) { 1292 return _groupLocalService.getUserGroupsCount(userId); 1293 } 1294 1295 /** 1296 * Returns the groups associated with the user groups. 1297 * 1298 * @param userGroups the user groups 1299 * @return the groups associated with the user groups 1300 * @throws PortalException if a portal exception occurred 1301 */ 1302 @Override 1303 public java.util.List<com.liferay.portal.model.Group> getUserGroupsGroups( 1304 java.util.List<com.liferay.portal.model.UserGroup> userGroups) 1305 throws com.liferay.portal.kernel.exception.PortalException { 1306 return _groupLocalService.getUserGroupsGroups(userGroups); 1307 } 1308 1309 /** 1310 * Returns all the groups related to the user groups. 1311 * 1312 * @param userGroups the user groups 1313 * @return the groups related to the user groups 1314 */ 1315 @Override 1316 public java.util.List<com.liferay.portal.model.Group> getUserGroupsRelatedGroups( 1317 java.util.List<com.liferay.portal.model.UserGroup> userGroups) { 1318 return _groupLocalService.getUserGroupsRelatedGroups(userGroups); 1319 } 1320 1321 /** 1322 * Returns the range of all groups associated with the user's organization 1323 * groups, including the ancestors of the organization groups, unless portal 1324 * property <code>organizations.membership.strict</code> is set to 1325 * <code>true</code>. 1326 * 1327 * <p> 1328 * Useful when paginating results. Returns a maximum of <code>end - 1329 * start</code> instances. <code>start</code> and <code>end</code> are not 1330 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1331 * refers to the first result in the set. Setting both <code>start</code> 1332 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1333 * result set. 1334 * </p> 1335 * 1336 * @param userId the primary key of the user 1337 * @param start the lower bound of the range of groups to consider 1338 * @param end the upper bound of the range of groups to consider (not 1339 inclusive) 1340 * @return the range of groups associated with the user's organization 1341 groups 1342 * @throws PortalException if a portal exception occurred 1343 */ 1344 @Override 1345 public java.util.List<com.liferay.portal.model.Group> getUserOrganizationsGroups( 1346 long userId, int start, int end) 1347 throws com.liferay.portal.kernel.exception.PortalException { 1348 return _groupLocalService.getUserOrganizationsGroups(userId, start, end); 1349 } 1350 1351 /** 1352 * Returns the default user's personal site group. 1353 * 1354 * @param companyId the primary key of the company 1355 * @return the default user's personal site group 1356 * @throws PortalException if a portal exception occurred 1357 */ 1358 @Override 1359 public com.liferay.portal.model.Group getUserPersonalSiteGroup( 1360 long companyId) 1361 throws com.liferay.portal.kernel.exception.PortalException { 1362 return _groupLocalService.getUserPersonalSiteGroup(companyId); 1363 } 1364 1365 /** 1366 * Returns the userIds of the users associated with the group. 1367 * 1368 * @param groupId the groupId of the group 1369 * @return long[] the userIds of users associated with the group 1370 */ 1371 @Override 1372 public long[] getUserPrimaryKeys(long groupId) { 1373 return _groupLocalService.getUserPrimaryKeys(groupId); 1374 } 1375 1376 @Override 1377 public java.util.List<com.liferay.portal.model.Group> getUserSitesGroups( 1378 long userId) throws com.liferay.portal.kernel.exception.PortalException { 1379 return _groupLocalService.getUserSitesGroups(userId); 1380 } 1381 1382 @Override 1383 public java.util.List<com.liferay.portal.model.Group> getUserSitesGroups( 1384 long userId, boolean includeAdministrative) 1385 throws com.liferay.portal.kernel.exception.PortalException { 1386 return _groupLocalService.getUserSitesGroups(userId, 1387 includeAdministrative); 1388 } 1389 1390 @Override 1391 public boolean hasOrganizationGroup(long organizationId, long groupId) { 1392 return _groupLocalService.hasOrganizationGroup(organizationId, groupId); 1393 } 1394 1395 @Override 1396 public boolean hasOrganizationGroups(long organizationId) { 1397 return _groupLocalService.hasOrganizationGroups(organizationId); 1398 } 1399 1400 @Override 1401 public boolean hasRoleGroup(long roleId, long groupId) { 1402 return _groupLocalService.hasRoleGroup(roleId, groupId); 1403 } 1404 1405 @Override 1406 public boolean hasRoleGroups(long roleId) { 1407 return _groupLocalService.hasRoleGroups(roleId); 1408 } 1409 1410 /** 1411 * Returns <code>true</code> if the live group has a staging group. 1412 * 1413 * @param liveGroupId the primary key of the live group 1414 * @return <code>true</code> if the live group has a staging group; 1415 <code>false</code> otherwise 1416 */ 1417 @Override 1418 public boolean hasStagingGroup(long liveGroupId) { 1419 return _groupLocalService.hasStagingGroup(liveGroupId); 1420 } 1421 1422 @Override 1423 public boolean hasUserGroup(long userId, long groupId) { 1424 return _groupLocalService.hasUserGroup(userId, groupId); 1425 } 1426 1427 /** 1428 * Returns <code>true</code> if the user is immediately associated with the 1429 * group, or optionally if the user is associated with the group via the 1430 * user's organizations, inherited organizations, or user groups. 1431 * 1432 * @param userId the primary key of the user 1433 * @param groupId the primary key of the group 1434 * @param inherit whether to include organization groups and user groups to 1435 which the user belongs in the determination 1436 * @return <code>true</code> if the user is associated with the group; 1437 <code>false</code> otherwise 1438 */ 1439 @Override 1440 public boolean hasUserGroup(long userId, long groupId, boolean inherit) { 1441 return _groupLocalService.hasUserGroup(userId, groupId, inherit); 1442 } 1443 1444 @Override 1445 public boolean hasUserGroupGroup(long userGroupId, long groupId) { 1446 return _groupLocalService.hasUserGroupGroup(userGroupId, groupId); 1447 } 1448 1449 @Override 1450 public boolean hasUserGroupGroups(long userGroupId) { 1451 return _groupLocalService.hasUserGroupGroups(userGroupId); 1452 } 1453 1454 @Override 1455 public boolean hasUserGroups(long userId) { 1456 return _groupLocalService.hasUserGroups(userId); 1457 } 1458 1459 /** 1460 * Returns the group with the matching group key by first searching the 1461 * system groups and then using the finder cache. 1462 * 1463 * @param companyId the primary key of the company 1464 * @param groupKey the group key 1465 * @return the group with the group key and associated company, or 1466 <code>null</code> if a matching group could not be found 1467 */ 1468 @Override 1469 public com.liferay.portal.model.Group loadFetchGroup(long companyId, 1470 java.lang.String groupKey) { 1471 return _groupLocalService.loadFetchGroup(companyId, groupKey); 1472 } 1473 1474 /** 1475 * Returns the group with the matching group key. 1476 * 1477 * @param companyId the primary key of the company 1478 * @param groupKey the group key 1479 * @return the group with the group key and associated company 1480 * @throws PortalException if a portal exception occurred 1481 */ 1482 @Override 1483 public com.liferay.portal.model.Group loadGetGroup(long companyId, 1484 java.lang.String groupKey) 1485 throws com.liferay.portal.kernel.exception.PortalException { 1486 return _groupLocalService.loadGetGroup(companyId, groupKey); 1487 } 1488 1489 /** 1490 * Rebuilds the group tree. 1491 * 1492 * <p> 1493 * Only call this method if the tree has become stale through operations 1494 * other than normal CRUD. Under normal circumstances the tree is 1495 * automatically rebuilt whenever necessary. 1496 * </p> 1497 * 1498 * @param companyId the primary key of the group's company 1499 * @throws PortalException if a portal exception occurred 1500 */ 1501 @Override 1502 public void rebuildTree(long companyId) 1503 throws com.liferay.portal.kernel.exception.PortalException { 1504 _groupLocalService.rebuildTree(companyId); 1505 } 1506 1507 /** 1508 * Returns an ordered range of all the groups that match the class name IDs 1509 * and keywords, optionally including the user's inherited organization 1510 * groups and user groups. System and staged groups are not included. 1511 * 1512 * <p> 1513 * Useful when paginating results. Returns a maximum of <code>end - 1514 * start</code> instances. <code>start</code> and <code>end</code> are not 1515 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1516 * refers to the first result in the set. Setting both <code>start</code> 1517 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1518 * result set. 1519 * </p> 1520 * 1521 * @param companyId the primary key of the company 1522 * @param classNameIds the primary keys of the class names of the entities 1523 the groups are related to (optionally <code>null</code>) 1524 * @param keywords the keywords (space separated), which may occur in the 1525 sites's name, or description (optionally <code>null</code>) 1526 * @param params the finder params (optionally <code>null</code>). To 1527 include a user's organizations, inherited organizations, and user 1528 groups in the search, add an entry with key 1529 "usersGroups" mapped to the user's ID and an entry with 1530 key "inherit" mapped to a non-<code>null</code> object. 1531 For more information see {@link 1532 com.liferay.portal.service.persistence.GroupFinder}. 1533 * @param start the lower bound of the range of groups to return 1534 * @param end the upper bound of the range of groups to return (not 1535 inclusive) 1536 * @return the matching groups ordered by name 1537 */ 1538 @Override 1539 public java.util.List<com.liferay.portal.model.Group> search( 1540 long companyId, long[] classNameIds, java.lang.String keywords, 1541 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1542 int start, int end) { 1543 return _groupLocalService.search(companyId, classNameIds, keywords, 1544 params, start, end); 1545 } 1546 1547 /** 1548 * Returns an ordered range of all the groups that match the class name IDs 1549 * and keywords, optionally including the user's inherited organization 1550 * groups and user groups. System and staged groups are not included. 1551 * 1552 * <p> 1553 * Useful when paginating results. Returns a maximum of <code>end - 1554 * start</code> instances. <code>start</code> and <code>end</code> are not 1555 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1556 * refers to the first result in the set. Setting both <code>start</code> 1557 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1558 * result set. 1559 * </p> 1560 * 1561 * @param companyId the primary key of the company 1562 * @param classNameIds the primary keys of the class names of the entities 1563 the groups are related to (optionally <code>null</code>) 1564 * @param keywords the keywords (space separated), which may occur in the 1565 sites's name, or description (optionally <code>null</code>) 1566 * @param params the finder params (optionally <code>null</code>). To 1567 include a user's organizations, inherited organizations, and user 1568 groups in the search, add an entry with key 1569 "usersGroups" mapped to the user's ID and an entry with 1570 key "inherit" mapped to a non-<code>null</code> object. 1571 For more information see {@link 1572 com.liferay.portal.service.persistence.GroupFinder}. 1573 * @param start the lower bound of the range of groups to return 1574 * @param end the upper bound of the range of groups to return (not 1575 inclusive) 1576 * @param obc the comparator to order the groups (optionally 1577 <code>null</code>) 1578 * @return the matching groups ordered by comparator <code>obc</code> 1579 */ 1580 @Override 1581 public java.util.List<com.liferay.portal.model.Group> search( 1582 long companyId, long[] classNameIds, java.lang.String keywords, 1583 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1584 int start, int end, 1585 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 1586 return _groupLocalService.search(companyId, classNameIds, keywords, 1587 params, start, end, obc); 1588 } 1589 1590 /** 1591 * Returns an ordered range of all the groups that match the class name IDs, 1592 * name, and description, optionally including the user's inherited 1593 * organization groups and user groups. System and staged groups are not 1594 * included. 1595 * 1596 * <p> 1597 * Useful when paginating results. Returns a maximum of <code>end - 1598 * start</code> instances. <code>start</code> and <code>end</code> are not 1599 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1600 * refers to the first result in the set. Setting both <code>start</code> 1601 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1602 * result set. 1603 * </p> 1604 * 1605 * @param companyId the primary key of the company 1606 * @param classNameIds the primary keys of the class names of the entities 1607 the groups are related to (optionally <code>null</code>) 1608 * @param name the group's name (optionally <code>null</code>) 1609 * @param description the group's description (optionally 1610 <code>null</code>) 1611 * @param params the finder params (optionally <code>null</code>). To 1612 include a user's organizations, inherited organizations, and user 1613 groups in the search, add an entry with key 1614 "usersGroups" mapped to the user's ID and an entry with 1615 key "inherit" mapped to a non-<code>null</code> object. 1616 For more information see {@link 1617 com.liferay.portal.service.persistence.GroupFinder}. 1618 * @param andOperator whether every field must match its keywords, or just 1619 one field. 1620 * @param start the lower bound of the range of groups to return 1621 * @param end the upper bound of the range of groups to return (not 1622 inclusive) 1623 * @return the matching groups ordered by name 1624 */ 1625 @Override 1626 public java.util.List<com.liferay.portal.model.Group> search( 1627 long companyId, long[] classNameIds, java.lang.String name, 1628 java.lang.String description, 1629 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1630 boolean andOperator, int start, int end) { 1631 return _groupLocalService.search(companyId, classNameIds, name, 1632 description, params, andOperator, start, end); 1633 } 1634 1635 /** 1636 * Returns an ordered range of all the groups that match the class name IDs, 1637 * name, and description, optionally including the user's inherited 1638 * organization groups and user groups. System and staged groups are not 1639 * included. 1640 * 1641 * <p> 1642 * Useful when paginating results. Returns a maximum of <code>end - 1643 * start</code> instances. <code>start</code> and <code>end</code> are not 1644 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1645 * refers to the first result in the set. Setting both <code>start</code> 1646 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1647 * result set. 1648 * </p> 1649 * 1650 * @param companyId the primary key of the company 1651 * @param classNameIds the primary keys of the class names of the entities 1652 the groups are related to (optionally <code>null</code>) 1653 * @param name the group's name (optionally <code>null</code>) 1654 * @param description the group's description (optionally 1655 <code>null</code>) 1656 * @param params the finder params (optionally <code>null</code>). To 1657 include a user's organizations, inherited organizations, and user 1658 groups in the search, add an entry with key 1659 "usersGroups" mapped to the user's ID and an entry with 1660 key "inherit" mapped to a non-<code>null</code> object. 1661 For more information see {@link 1662 com.liferay.portal.service.persistence.GroupFinder}. 1663 * @param andOperator whether every field must match its keywords, or just 1664 one field. 1665 * @param start the lower bound of the range of groups to return 1666 * @param end the upper bound of the range of groups to return (not 1667 inclusive) 1668 * @param obc the comparator to order the groups (optionally 1669 <code>null</code>) 1670 * @return the matching groups ordered by comparator <code>obc</code> 1671 */ 1672 @Override 1673 public java.util.List<com.liferay.portal.model.Group> search( 1674 long companyId, long[] classNameIds, java.lang.String name, 1675 java.lang.String description, 1676 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1677 boolean andOperator, int start, int end, 1678 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 1679 return _groupLocalService.search(companyId, classNameIds, name, 1680 description, params, andOperator, start, end, obc); 1681 } 1682 1683 /** 1684 * Returns an ordered range of all the groups belonging to the parent group 1685 * that match the class name IDs and keywords, optionally including the 1686 * user's inherited organization groups and user groups. System and staged 1687 * groups are not included. 1688 * 1689 * <p> 1690 * Useful when paginating results. Returns a maximum of <code>end - 1691 * start</code> instances. <code>start</code> and <code>end</code> are not 1692 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1693 * refers to the first result in the set. Setting both <code>start</code> 1694 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1695 * result set. 1696 * </p> 1697 * 1698 * @param companyId the primary key of the company 1699 * @param classNameIds the primary keys of the class names of the entities 1700 the groups are related to (optionally <code>null</code>) 1701 * @param parentGroupId the primary key of the parent group 1702 * @param keywords the keywords (space separated), which may occur in the 1703 sites's name, or description (optionally <code>null</code>) 1704 * @param params the finder params (optionally <code>null</code>). To 1705 include a user's organizations, inherited organizations, and user 1706 groups in the search, add an entry with key 1707 "usersGroups" mapped to the user's ID and an entry with 1708 key "inherit" mapped to a non-<code>null</code> object. 1709 For more information see {@link 1710 com.liferay.portal.service.persistence.GroupFinder}. 1711 * @param start the lower bound of the range of groups to return 1712 * @param end the upper bound of the range of groups to return (not 1713 inclusive) 1714 * @return the matching groups ordered by name 1715 */ 1716 @Override 1717 public java.util.List<com.liferay.portal.model.Group> search( 1718 long companyId, long[] classNameIds, long parentGroupId, 1719 java.lang.String keywords, 1720 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1721 int start, int end) { 1722 return _groupLocalService.search(companyId, classNameIds, 1723 parentGroupId, keywords, params, start, end); 1724 } 1725 1726 /** 1727 * Returns an ordered range of all the groups belonging to the parent group 1728 * that match the class name IDs and keywords, optionally including the 1729 * user's inherited organization groups and user groups. System and staged 1730 * groups are not included. 1731 * 1732 * <p> 1733 * Useful when paginating results. Returns a maximum of <code>end - 1734 * start</code> instances. <code>start</code> and <code>end</code> are not 1735 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1736 * refers to the first result in the set. Setting both <code>start</code> 1737 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1738 * result set. 1739 * </p> 1740 * 1741 * @param companyId the primary key of the company 1742 * @param classNameIds the primary keys of the class names of the entities 1743 the groups are related to (optionally <code>null</code>) 1744 * @param parentGroupId the primary key of the parent group 1745 * @param keywords the keywords (space separated), which may occur in the 1746 sites's name, or description (optionally <code>null</code>) 1747 * @param params the finder params (optionally <code>null</code>). To 1748 include a user's organizations, inherited organizations, and user 1749 groups in the search, add an entry with key 1750 "usersGroups" mapped to the user's ID and an entry with 1751 key "inherit" mapped to a non-<code>null</code> object. 1752 For more information see {@link 1753 com.liferay.portal.service.persistence.GroupFinder}. 1754 * @param start the lower bound of the range of groups to return 1755 * @param end the upper bound of the range of groups to return (not 1756 inclusive) 1757 * @param obc the comparator to order the groups (optionally 1758 <code>null</code>) 1759 * @return the matching groups ordered by comparator <code>obc</code> 1760 */ 1761 @Override 1762 public java.util.List<com.liferay.portal.model.Group> search( 1763 long companyId, long[] classNameIds, long parentGroupId, 1764 java.lang.String keywords, 1765 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1766 int start, int end, 1767 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 1768 return _groupLocalService.search(companyId, classNameIds, 1769 parentGroupId, keywords, params, start, end, obc); 1770 } 1771 1772 /** 1773 * Returns an ordered range of all the groups belonging to the parent group 1774 * that match the class name IDs, name, and description, optionally 1775 * including the user's inherited organization groups and user groups. 1776 * System and staged groups are not included. 1777 * 1778 * <p> 1779 * Useful when paginating results. Returns a maximum of <code>end - 1780 * start</code> instances. <code>start</code> and <code>end</code> are not 1781 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1782 * refers to the first result in the set. Setting both <code>start</code> 1783 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1784 * result set. 1785 * </p> 1786 * 1787 * @param companyId the primary key of the company 1788 * @param classNameIds the primary keys of the class names of the entities 1789 the groups are related to (optionally <code>null</code>) 1790 * @param parentGroupId the primary key of the parent group 1791 * @param name the group's name (optionally <code>null</code>) 1792 * @param description the group's description (optionally 1793 <code>null</code>) 1794 * @param params the finder params (optionally <code>null</code>). To 1795 include a user's organizations, inherited organizations, and user 1796 groups in the search, add an entry with key 1797 "usersGroups" mapped to the user's ID and an entry with 1798 key "inherit" mapped to a non-<code>null</code> object. 1799 For more information see {@link 1800 com.liferay.portal.service.persistence.GroupFinder}. 1801 * @param andOperator whether every field must match its keywords, or just 1802 one field. 1803 * @param start the lower bound of the range of groups to return 1804 * @param end the upper bound of the range of groups to return (not 1805 inclusive) 1806 * @return the matching groups ordered by name 1807 */ 1808 @Override 1809 public java.util.List<com.liferay.portal.model.Group> search( 1810 long companyId, long[] classNameIds, long parentGroupId, 1811 java.lang.String name, java.lang.String description, 1812 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1813 boolean andOperator, int start, int end) { 1814 return _groupLocalService.search(companyId, classNameIds, 1815 parentGroupId, name, description, params, andOperator, start, end); 1816 } 1817 1818 /** 1819 * Returns an ordered range of all the groups belonging to the parent group 1820 * that match the class name IDs, name, and description, optionally 1821 * including the user's inherited organization groups and user groups. 1822 * System and staged groups are not included. 1823 * 1824 * <p> 1825 * Useful when paginating results. Returns a maximum of <code>end - 1826 * start</code> instances. <code>start</code> and <code>end</code> are not 1827 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1828 * refers to the first result in the set. Setting both <code>start</code> 1829 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1830 * result set. 1831 * </p> 1832 * 1833 * @param companyId the primary key of the company 1834 * @param classNameIds the primary keys of the class names of the entities 1835 the groups are related to (optionally <code>null</code>) 1836 * @param parentGroupId the primary key of the parent group 1837 * @param name the group's name (optionally <code>null</code>) 1838 * @param description the group's description (optionally 1839 <code>null</code>) 1840 * @param params the finder params (optionally <code>null</code>). To 1841 include a user's organizations, inherited organizations, and user 1842 groups in the search, add an entry with key 1843 "usersGroups" mapped to the user's ID and an entry with 1844 key "inherit" mapped to a non-<code>null</code> object. 1845 For more information see {@link 1846 com.liferay.portal.service.persistence.GroupFinder}. 1847 * @param andOperator whether every field must match its keywords, or just 1848 one field. 1849 * @param start the lower bound of the range of groups to return 1850 * @param end the upper bound of the range of groups to return (not 1851 inclusive) 1852 * @param obc the comparator to order the groups (optionally 1853 <code>null</code>) 1854 * @return the matching groups ordered by comparator <code>obc</code> 1855 */ 1856 @Override 1857 public java.util.List<com.liferay.portal.model.Group> search( 1858 long companyId, long[] classNameIds, long parentGroupId, 1859 java.lang.String name, java.lang.String description, 1860 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1861 boolean andOperator, int start, int end, 1862 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 1863 return _groupLocalService.search(companyId, classNameIds, 1864 parentGroupId, name, description, params, andOperator, start, end, 1865 obc); 1866 } 1867 1868 /** 1869 * Returns an ordered range of all the groups that match the keywords, 1870 * optionally including the user's inherited organization groups and user 1871 * groups. System and staged groups are not included. 1872 * 1873 * <p> 1874 * Useful when paginating results. Returns a maximum of <code>end - 1875 * start</code> instances. <code>start</code> and <code>end</code> are not 1876 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1877 * refers to the first result in the set. Setting both <code>start</code> 1878 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1879 * result set. 1880 * </p> 1881 * 1882 * @param companyId the primary key of the company 1883 * @param keywords the keywords (space separated), which may occur in the 1884 sites's name, or description (optionally <code>null</code>) 1885 * @param params the finder params (optionally <code>null</code>). To 1886 include the user's inherited organizations and user groups in the 1887 search, add entries having "usersGroups" and 1888 "inherit" as keys mapped to the the user's ID. For more 1889 information see {@link 1890 com.liferay.portal.service.persistence.GroupFinder}. 1891 * @param start the lower bound of the range of groups to return 1892 * @param end the upper bound of the range of groups to return (not 1893 inclusive) 1894 * @return the matching groups ordered by name 1895 */ 1896 @Override 1897 public java.util.List<com.liferay.portal.model.Group> search( 1898 long companyId, java.lang.String keywords, 1899 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1900 int start, int end) { 1901 return _groupLocalService.search(companyId, keywords, params, start, end); 1902 } 1903 1904 /** 1905 * Returns an ordered range of all the groups that match the keywords, 1906 * optionally including the user's inherited organization groups and user 1907 * groups. System and staged groups are not included. 1908 * 1909 * <p> 1910 * Useful when paginating results. Returns a maximum of <code>end - 1911 * start</code> instances. <code>start</code> and <code>end</code> are not 1912 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1913 * refers to the first result in the set. Setting both <code>start</code> 1914 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1915 * result set. 1916 * </p> 1917 * 1918 * @param companyId the primary key of the company 1919 * @param keywords the keywords (space separated), which may occur in the 1920 sites's name, or description (optionally <code>null</code>) 1921 * @param params the finder params (optionally <code>null</code>). To 1922 include the user's inherited organizations and user groups in the 1923 search, add entries having "usersGroups" and 1924 "inherit" as keys mapped to the the user's ID. For more 1925 information see {@link 1926 com.liferay.portal.service.persistence.GroupFinder}. 1927 * @param start the lower bound of the range of groups to return 1928 * @param end the upper bound of the range of groups to return (not 1929 inclusive) 1930 * @param obc the comparator to order the groups (optionally 1931 <code>null</code>) 1932 * @return the matching groups ordered by comparator <code>obc</code> 1933 */ 1934 @Override 1935 public java.util.List<com.liferay.portal.model.Group> search( 1936 long companyId, java.lang.String keywords, 1937 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1938 int start, int end, 1939 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 1940 return _groupLocalService.search(companyId, keywords, params, start, 1941 end, obc); 1942 } 1943 1944 /** 1945 * Returns an ordered range of all the site groups and organization groups 1946 * that match the name and description, optionally including the user's 1947 * inherited organization groups and user groups. System and staged groups 1948 * are not included. 1949 * 1950 * <p> 1951 * Useful when paginating results. Returns a maximum of <code>end - 1952 * start</code> instances. <code>start</code> and <code>end</code> are not 1953 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1954 * refers to the first result in the set. Setting both <code>start</code> 1955 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1956 * result set. 1957 * </p> 1958 * 1959 * @param companyId the primary key of the company 1960 * @param name the group's name (optionally <code>null</code>) 1961 * @param description the group's description (optionally 1962 <code>null</code>) 1963 * @param params the finder params (optionally <code>null</code>). To 1964 include the user's inherited organizations and user groups in the 1965 search, add entries having "usersGroups" and 1966 "inherit" as keys mapped to the the user's ID. For more 1967 information see {@link 1968 com.liferay.portal.service.persistence.GroupFinder}. 1969 * @param andOperator whether every field must match its keywords, or just 1970 one field. 1971 * @param start the lower bound of the range of groups to return 1972 * @param end the upper bound of the range of groups to return (not 1973 inclusive) 1974 * @return the matching groups ordered by name 1975 */ 1976 @Override 1977 public java.util.List<com.liferay.portal.model.Group> search( 1978 long companyId, java.lang.String name, java.lang.String description, 1979 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1980 boolean andOperator, int start, int end) { 1981 return _groupLocalService.search(companyId, name, description, params, 1982 andOperator, start, end); 1983 } 1984 1985 /** 1986 * Returns an ordered range of all the site groups and organization groups 1987 * that match the name and description, optionally including the user's 1988 * inherited organization groups and user groups. System and staged groups 1989 * are not included. 1990 * 1991 * <p> 1992 * Useful when paginating results. Returns a maximum of <code>end - 1993 * start</code> instances. <code>start</code> and <code>end</code> are not 1994 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1995 * refers to the first result in the set. Setting both <code>start</code> 1996 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1997 * result set. 1998 * </p> 1999 * 2000 * @param companyId the primary key of the company 2001 * @param name the group's name (optionally <code>null</code>) 2002 * @param description the group's description (optionally 2003 <code>null</code>) 2004 * @param params the finder params (optionally <code>null</code>). To 2005 include the user's inherited organizations and user groups in the 2006 search, add entries having "usersGroups" and 2007 "inherit" as keys mapped to the the user's ID. For more 2008 information see {@link 2009 com.liferay.portal.service.persistence.GroupFinder}. 2010 * @param andOperator whether every field must match its keywords, or just 2011 one field. 2012 * @param start the lower bound of the range of groups to return 2013 * @param end the upper bound of the range of groups to return (not 2014 inclusive) 2015 * @param obc the comparator to order the groups (optionally 2016 <code>null</code>) 2017 * @return the matching groups ordered by comparator <code>obc</code> 2018 */ 2019 @Override 2020 public java.util.List<com.liferay.portal.model.Group> search( 2021 long companyId, java.lang.String name, java.lang.String description, 2022 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2023 boolean andOperator, int start, int end, 2024 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 2025 return _groupLocalService.search(companyId, name, description, params, 2026 andOperator, start, end, obc); 2027 } 2028 2029 /** 2030 * Returns an ordered range of all the company's groups, optionally 2031 * including the user's inherited organization groups and user groups. 2032 * System and staged groups are not included. 2033 * 2034 * <p> 2035 * Useful when paginating results. Returns a maximum of <code>end - 2036 * start</code> instances. <code>start</code> and <code>end</code> are not 2037 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2038 * refers to the first result in the set. Setting both <code>start</code> 2039 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 2040 * result set. 2041 * </p> 2042 * 2043 * @param companyId the primary key of the company 2044 * @param params the finder params (optionally <code>null</code>). To 2045 include a user's organizations, inherited organizations, and user 2046 groups in the search, add an entry with key 2047 "usersGroups" mapped to the user's ID and an entry with 2048 key "inherit" mapped to a non-<code>null</code> object. 2049 For more information see {@link 2050 com.liferay.portal.service.persistence.GroupFinder}. 2051 * @param start the lower bound of the range of groups to return 2052 * @param end the upper bound of the range of groups to return (not 2053 inclusive) 2054 * @return the matching groups ordered by name 2055 */ 2056 @Override 2057 public java.util.List<com.liferay.portal.model.Group> search( 2058 long companyId, 2059 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2060 int start, int end) { 2061 return _groupLocalService.search(companyId, params, start, end); 2062 } 2063 2064 /** 2065 * Returns an ordered range of all the groups belonging to the parent group 2066 * that match the keywords, optionally including the user's inherited 2067 * organization groups and user groups. System and staged groups are not 2068 * included. 2069 * 2070 * <p> 2071 * Useful when paginating results. Returns a maximum of <code>end - 2072 * start</code> instances. <code>start</code> and <code>end</code> are not 2073 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2074 * refers to the first result in the set. Setting both <code>start</code> 2075 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 2076 * result set. 2077 * </p> 2078 * 2079 * @param companyId the primary key of the company 2080 * @param parentGroupId the primary key of the parent group 2081 * @param keywords the keywords (space separated), which may occur in the 2082 sites's name, or description (optionally <code>null</code>) 2083 * @param params the finder params (optionally <code>null</code>). To 2084 include the user's inherited organizations and user groups in the 2085 search, add entries having "usersGroups" and 2086 "inherit" as keys mapped to the the user's ID. For more 2087 information see {@link 2088 com.liferay.portal.service.persistence.GroupFinder}. 2089 * @param start the lower bound of the range of groups to return 2090 * @param end the upper bound of the range of groups to return (not 2091 inclusive) 2092 * @return the matching groups ordered by name 2093 */ 2094 @Override 2095 public java.util.List<com.liferay.portal.model.Group> search( 2096 long companyId, long parentGroupId, java.lang.String keywords, 2097 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2098 int start, int end) { 2099 return _groupLocalService.search(companyId, parentGroupId, keywords, 2100 params, start, end); 2101 } 2102 2103 /** 2104 * Returns an ordered range of all the groups belonging to the parent group 2105 * that match the keywords, optionally including the user's inherited 2106 * organization groups and user groups. System and staged groups are not 2107 * included. 2108 * 2109 * <p> 2110 * Useful when paginating results. Returns a maximum of <code>end - 2111 * start</code> instances. <code>start</code> and <code>end</code> are not 2112 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2113 * refers to the first result in the set. Setting both <code>start</code> 2114 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 2115 * result set. 2116 * </p> 2117 * 2118 * @param companyId the primary key of the company 2119 * @param parentGroupId the primary key of the parent group 2120 * @param keywords the keywords (space separated), which may occur in the 2121 sites's name, or description (optionally <code>null</code>) 2122 * @param params the finder params (optionally <code>null</code>). To 2123 include the user's inherited organizations and user groups in the 2124 search, add entries having "usersGroups" and 2125 "inherit" as keys mapped to the the user's ID. For more 2126 information see {@link 2127 com.liferay.portal.service.persistence.GroupFinder}. 2128 * @param start the lower bound of the range of groups to return 2129 * @param end the upper bound of the range of groups to return (not 2130 inclusive) 2131 * @param obc the comparator to order the groups (optionally 2132 <code>null</code>) 2133 * @return the matching groups ordered by comparator <code>obc</code> 2134 */ 2135 @Override 2136 public java.util.List<com.liferay.portal.model.Group> search( 2137 long companyId, long parentGroupId, java.lang.String keywords, 2138 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2139 int start, int end, 2140 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 2141 return _groupLocalService.search(companyId, parentGroupId, keywords, 2142 params, start, end, obc); 2143 } 2144 2145 /** 2146 * Returns an ordered range of all the site groups belonging to the parent 2147 * group and organization groups that match the name and description, 2148 * optionally including the user's inherited organization groups and user 2149 * groups. System and staged groups are not included. 2150 * 2151 * <p> 2152 * Useful when paginating results. Returns a maximum of <code>end - 2153 * start</code> instances. <code>start</code> and <code>end</code> are not 2154 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2155 * refers to the first result in the set. Setting both <code>start</code> 2156 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 2157 * result set. 2158 * </p> 2159 * 2160 * @param companyId the primary key of the company 2161 * @param parentGroupId the primary key of the parent group 2162 * @param name the group's name (optionally <code>null</code>) 2163 * @param description the group's description (optionally 2164 <code>null</code>) 2165 * @param params the finder params (optionally <code>null</code>). To 2166 include the user's inherited organizations and user groups in the 2167 search, add entries having "usersGroups" and 2168 "inherit" as keys mapped to the the user's ID. For more 2169 information see {@link 2170 com.liferay.portal.service.persistence.GroupFinder}. 2171 * @param andOperator whether every field must match its keywords, or just 2172 one field. 2173 * @param start the lower bound of the range of groups to return 2174 * @param end the upper bound of the range of groups to return (not 2175 inclusive) 2176 * @return the matching groups ordered by name 2177 */ 2178 @Override 2179 public java.util.List<com.liferay.portal.model.Group> search( 2180 long companyId, long parentGroupId, java.lang.String name, 2181 java.lang.String description, 2182 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2183 boolean andOperator, int start, int end) { 2184 return _groupLocalService.search(companyId, parentGroupId, name, 2185 description, params, andOperator, start, end); 2186 } 2187 2188 /** 2189 * Returns an ordered range of all the site groups belonging to the parent 2190 * group and organization groups that match the name and description, 2191 * optionally including the user's inherited organization groups and user 2192 * groups. System and staged groups are not included. 2193 * 2194 * <p> 2195 * Useful when paginating results. Returns a maximum of <code>end - 2196 * start</code> instances. <code>start</code> and <code>end</code> are not 2197 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2198 * refers to the first result in the set. Setting both <code>start</code> 2199 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 2200 * result set. 2201 * </p> 2202 * 2203 * @param companyId the primary key of the company 2204 * @param parentGroupId the primary key of the parent group 2205 * @param name the group's name (optionally <code>null</code>) 2206 * @param description the group's description (optionally 2207 <code>null</code>) 2208 * @param params the finder params (optionally <code>null</code>). To 2209 include the user's inherited organizations and user groups in the 2210 search, add entries having "usersGroups" and 2211 "inherit" as keys mapped to the the user's ID. For more 2212 information see {@link 2213 com.liferay.portal.service.persistence.GroupFinder}. 2214 * @param andOperator whether every field must match its keywords, or just 2215 one field. 2216 * @param start the lower bound of the range of groups to return 2217 * @param end the upper bound of the range of groups to return (not 2218 inclusive) 2219 * @param obc the comparator to order the groups (optionally 2220 <code>null</code>) 2221 * @return the matching groups ordered by comparator <code>obc</code> 2222 */ 2223 @Override 2224 public java.util.List<com.liferay.portal.model.Group> search( 2225 long companyId, long parentGroupId, java.lang.String name, 2226 java.lang.String description, 2227 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2228 boolean andOperator, int start, int end, 2229 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 2230 return _groupLocalService.search(companyId, parentGroupId, name, 2231 description, params, andOperator, start, end, obc); 2232 } 2233 2234 /** 2235 * Returns the number of groups that match the class name IDs, and keywords, 2236 * optionally including the user's inherited organization groups and user 2237 * groups. System and staged groups are not included. 2238 * 2239 * @param companyId the primary key of the company 2240 * @param classNameIds the primary keys of the class names of the entities 2241 the groups are related to (optionally <code>null</code>) 2242 * @param keywords the keywords (space separated), which may occur in the 2243 sites's name, or description (optionally <code>null</code>) 2244 * @param params the finder params (optionally <code>null</code>). To 2245 include the user's inherited organization groups and user groups 2246 in the search, add entries having "usersGroups" and 2247 "inherit" as keys mapped to the the user's ID. For more 2248 information see {@link 2249 com.liferay.portal.service.persistence.GroupFinder}. 2250 * @return the number of matching groups 2251 */ 2252 @Override 2253 public int searchCount(long companyId, long[] classNameIds, 2254 java.lang.String keywords, 2255 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2256 return _groupLocalService.searchCount(companyId, classNameIds, 2257 keywords, params); 2258 } 2259 2260 /** 2261 * Returns the number of groups that match the class name IDs, name, and 2262 * description, optionally including the user's inherited organization 2263 * groups and user groups. System and staged groups are not included. 2264 * 2265 * @param companyId the primary key of the company 2266 * @param classNameIds the primary keys of the class names of the entities 2267 the groups are related to (optionally <code>null</code>) 2268 * @param name the group's name (optionally <code>null</code>) 2269 * @param description the group's description (optionally 2270 <code>null</code>) 2271 * @param params the finder params (optionally <code>null</code>). To 2272 include the user's inherited organization groups and user groups 2273 in the search, add entries having "usersGroups" and 2274 "inherit" as keys mapped to the the user's ID. For more 2275 information see {@link 2276 com.liferay.portal.service.persistence.GroupFinder}. 2277 * @param andOperator whether every field must match its keywords, or just 2278 one field. 2279 * @return the number of matching groups 2280 */ 2281 @Override 2282 public int searchCount(long companyId, long[] classNameIds, 2283 java.lang.String name, java.lang.String description, 2284 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2285 boolean andOperator) { 2286 return _groupLocalService.searchCount(companyId, classNameIds, name, 2287 description, params, andOperator); 2288 } 2289 2290 /** 2291 * Returns the number of groups belonging to the parent group that match the 2292 * class name IDs, and keywords, optionally including the user's inherited 2293 * organization groups and user groups. System and staged groups are not 2294 * included. 2295 * 2296 * @param companyId the primary key of the company 2297 * @param classNameIds the primary keys of the class names of the entities 2298 the groups are related to (optionally <code>null</code>) 2299 * @param parentGroupId the primary key of the parent group 2300 * @param keywords the keywords (space separated), which may occur in the 2301 sites's name, or description (optionally <code>null</code>) 2302 * @param params the finder params (optionally <code>null</code>). To 2303 include the user's inherited organization groups and user groups 2304 in the search, add entries having "usersGroups" and 2305 "inherit" as keys mapped to the the user's ID. For more 2306 information see {@link 2307 com.liferay.portal.service.persistence.GroupFinder}. 2308 * @return the number of matching groups 2309 */ 2310 @Override 2311 public int searchCount(long companyId, long[] classNameIds, 2312 long parentGroupId, java.lang.String keywords, 2313 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2314 return _groupLocalService.searchCount(companyId, classNameIds, 2315 parentGroupId, keywords, params); 2316 } 2317 2318 /** 2319 * Returns the number of groups belonging to the parent group that match the 2320 * class name IDs, name, and description, optionally including the user's 2321 * inherited organization groups and user groups. System and staged groups 2322 * are not included. 2323 * 2324 * @param companyId the primary key of the company 2325 * @param classNameIds the primary keys of the class names of the entities 2326 the groups are related to (optionally <code>null</code>) 2327 * @param parentGroupId the primary key of the parent group 2328 * @param name the group's name (optionally <code>null</code>) 2329 * @param description the group's description (optionally 2330 <code>null</code>) 2331 * @param params the finder params (optionally <code>null</code>). To 2332 include the user's inherited organization groups and user groups 2333 in the search, add entries having "usersGroups" and 2334 "inherit" as keys mapped to the the user's ID. For more 2335 information see {@link 2336 com.liferay.portal.service.persistence.GroupFinder}. 2337 * @param andOperator whether every field must match its keywords, or just 2338 one field. 2339 * @return the number of matching groups 2340 */ 2341 @Override 2342 public int searchCount(long companyId, long[] classNameIds, 2343 long parentGroupId, java.lang.String name, 2344 java.lang.String description, 2345 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2346 boolean andOperator) { 2347 return _groupLocalService.searchCount(companyId, classNameIds, 2348 parentGroupId, name, description, params, andOperator); 2349 } 2350 2351 /** 2352 * Returns the number of groups that match the keywords, optionally 2353 * including the user's inherited organization groups and user groups. 2354 * System and staged groups are not included. 2355 * 2356 * @param companyId the primary key of the company 2357 * @param keywords the keywords (space separated), which may occur in the 2358 sites's name, or description (optionally <code>null</code>) 2359 * @param params the finder params (optionally <code>null</code>). To 2360 include the user's inherited organization groups and user groups 2361 in the search, add entries having "usersGroups" and 2362 "inherit" as keys mapped to the the user's ID. For more 2363 information see {@link 2364 com.liferay.portal.service.persistence.GroupFinder}. 2365 * @return the number of matching groups 2366 */ 2367 @Override 2368 public int searchCount(long companyId, java.lang.String keywords, 2369 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2370 return _groupLocalService.searchCount(companyId, keywords, params); 2371 } 2372 2373 /** 2374 * Returns the number of groups and immediate organization groups that match 2375 * the name and description, optionally including the user's inherited 2376 * organization groups and user groups. System and staged groups are not 2377 * included. 2378 * 2379 * @param companyId the primary key of the company 2380 * @param name the group's name (optionally <code>null</code>) 2381 * @param description the group's description (optionally 2382 <code>null</code>) 2383 * @param params the finder params (optionally <code>null</code>). To 2384 include the user's inherited organization groups and user groups 2385 in the search, add entries having "usersGroups" and 2386 "inherit" as keys mapped to the the user's ID. For more 2387 information see {@link 2388 com.liferay.portal.service.persistence.GroupFinder}. 2389 * @param andOperator whether every field must match its keywords, or just 2390 one field. 2391 * @return the number of matching groups 2392 */ 2393 @Override 2394 public int searchCount(long companyId, java.lang.String name, 2395 java.lang.String description, 2396 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2397 boolean andOperator) { 2398 return _groupLocalService.searchCount(companyId, name, description, 2399 params, andOperator); 2400 } 2401 2402 /** 2403 * Returns the number of groups belonging to the parent group that match the 2404 * keywords, optionally including the user's inherited organization groups 2405 * and user groups. System and staged groups are not included. 2406 * 2407 * @param companyId the primary key of the company 2408 * @param parentGroupId the primary key of the parent group 2409 * @param keywords the keywords (space separated), which may occur in the 2410 sites's name, or description (optionally <code>null</code>) 2411 * @param params the finder params (optionally <code>null</code>). To 2412 include the user's inherited organization groups and user groups 2413 in the search, add entries having "usersGroups" and 2414 "inherit" as keys mapped to the the user's ID. For more 2415 information see {@link 2416 com.liferay.portal.service.persistence.GroupFinder}. 2417 * @return the number of matching groups 2418 */ 2419 @Override 2420 public int searchCount(long companyId, long parentGroupId, 2421 java.lang.String keywords, 2422 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2423 return _groupLocalService.searchCount(companyId, parentGroupId, 2424 keywords, params); 2425 } 2426 2427 /** 2428 * Returns the number of groups belonging to the parent group and immediate 2429 * organization groups that match the name and description, optionally 2430 * including the user's inherited organization groups and user groups. 2431 * System and staged groups are not included. 2432 * 2433 * @param companyId the primary key of the company 2434 * @param parentGroupId the primary key of the parent group 2435 * @param name the group's name (optionally <code>null</code>) 2436 * @param description the group's description (optionally 2437 <code>null</code>) 2438 * @param params the finder params (optionally <code>null</code>). To 2439 include the user's inherited organization groups and user groups 2440 in the search, add entries having "usersGroups" and 2441 "inherit" as keys mapped to the the user's ID. For more 2442 information see {@link 2443 com.liferay.portal.service.persistence.GroupFinder}. 2444 * @param andOperator whether every field must match its keywords, or just 2445 one field. 2446 * @return the number of matching groups 2447 */ 2448 @Override 2449 public int searchCount(long companyId, long parentGroupId, 2450 java.lang.String name, java.lang.String description, 2451 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2452 boolean andOperator) { 2453 return _groupLocalService.searchCount(companyId, parentGroupId, name, 2454 description, params, andOperator); 2455 } 2456 2457 @Override 2458 public void setOrganizationGroups(long organizationId, long[] groupIds) { 2459 _groupLocalService.setOrganizationGroups(organizationId, groupIds); 2460 } 2461 2462 @Override 2463 public void setRoleGroups(long roleId, long[] groupIds) { 2464 _groupLocalService.setRoleGroups(roleId, groupIds); 2465 } 2466 2467 @Override 2468 public void setUserGroupGroups(long userGroupId, long[] groupIds) { 2469 _groupLocalService.setUserGroupGroups(userGroupId, groupIds); 2470 } 2471 2472 @Override 2473 public void setUserGroups(long userId, long[] groupIds) { 2474 _groupLocalService.setUserGroups(userId, groupIds); 2475 } 2476 2477 /** 2478 * Removes the groups from the role. 2479 * 2480 * @param roleId the primary key of the role 2481 * @param groupIds the primary keys of the groups 2482 */ 2483 @Override 2484 public void unsetRoleGroups(long roleId, long[] groupIds) { 2485 _groupLocalService.unsetRoleGroups(roleId, groupIds); 2486 } 2487 2488 /** 2489 * Removes the user from the groups. 2490 * 2491 * @param userId the primary key of the user 2492 * @param groupIds the primary keys of the groups 2493 */ 2494 @Override 2495 public void unsetUserGroups(long userId, long[] groupIds) { 2496 _groupLocalService.unsetUserGroups(userId, groupIds); 2497 } 2498 2499 /** 2500 * Updates the group's asset replacing categories and tag names. 2501 * 2502 * @param userId the primary key of the user 2503 * @param group the group 2504 * @param assetCategoryIds the primary keys of the asset categories 2505 (optionally <code>null</code>) 2506 * @param assetTagNames the asset tag names (optionally <code>null</code>) 2507 * @throws PortalException if a portal exception occurred 2508 */ 2509 @Override 2510 public void updateAsset(long userId, com.liferay.portal.model.Group group, 2511 long[] assetCategoryIds, java.lang.String[] assetTagNames) 2512 throws com.liferay.portal.kernel.exception.PortalException { 2513 _groupLocalService.updateAsset(userId, group, assetCategoryIds, 2514 assetTagNames); 2515 } 2516 2517 /** 2518 * Updates the group's friendly URL. 2519 * 2520 * @param groupId the primary key of the group 2521 * @param friendlyURL the group's new friendlyURL (optionally 2522 <code>null</code>) 2523 * @return the group 2524 * @throws PortalException if a portal exception occurred 2525 */ 2526 @Override 2527 public com.liferay.portal.model.Group updateFriendlyURL(long groupId, 2528 java.lang.String friendlyURL) 2529 throws com.liferay.portal.kernel.exception.PortalException { 2530 return _groupLocalService.updateFriendlyURL(groupId, friendlyURL); 2531 } 2532 2533 /** 2534 * Updates the group in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 2535 * 2536 * @param group the group 2537 * @return the group that was updated 2538 */ 2539 @Override 2540 public com.liferay.portal.model.Group updateGroup( 2541 com.liferay.portal.model.Group group) { 2542 return _groupLocalService.updateGroup(group); 2543 } 2544 2545 /** 2546 * Updates the group. 2547 * 2548 * @param groupId the primary key of the group 2549 * @param parentGroupId the primary key of the parent group 2550 * @param name the name's key 2551 * @param description the group's new description (optionally 2552 <code>null</code>) 2553 * @param type the group's new type. For more information see {@link 2554 GroupConstants}. 2555 * @param manualMembership whether manual membership is allowed for the 2556 group 2557 * @param membershipRestriction the group's membership restriction. For 2558 more information see {@link GroupConstants}. 2559 * @param friendlyURL the group's new friendlyURL (optionally 2560 <code>null</code>) 2561 * @param inheritContent whether to inherit content from the parent 2562 group 2563 * @param active whether the group is active 2564 * @param serviceContext the service context to be applied (optionally 2565 <code>null</code>). Can set asset category IDs and asset tag 2566 names for the group. 2567 * @return the group 2568 * @throws PortalException if a portal exception occurred 2569 * @deprecated As of 7.0.0, replaced by {@link #updateGroup(long, long, Map, 2570 Map, int, boolean, int, String, boolean, boolean, 2571 ServiceContext)} 2572 */ 2573 @Deprecated 2574 @Override 2575 public com.liferay.portal.model.Group updateGroup(long groupId, 2576 long parentGroupId, java.lang.String name, 2577 java.lang.String description, int type, boolean manualMembership, 2578 int membershipRestriction, java.lang.String friendlyURL, 2579 boolean inheritContent, boolean active, 2580 com.liferay.portal.service.ServiceContext serviceContext) 2581 throws com.liferay.portal.kernel.exception.PortalException { 2582 return _groupLocalService.updateGroup(groupId, parentGroupId, name, 2583 description, type, manualMembership, membershipRestriction, 2584 friendlyURL, inheritContent, active, serviceContext); 2585 } 2586 2587 @Override 2588 public com.liferay.portal.model.Group updateGroup(long groupId, 2589 long parentGroupId, 2590 java.util.Map<java.util.Locale, java.lang.String> nameMap, 2591 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 2592 int type, boolean manualMembership, int membershipRestriction, 2593 java.lang.String friendlyURL, boolean inheritContent, boolean active, 2594 com.liferay.portal.service.ServiceContext serviceContext) 2595 throws com.liferay.portal.kernel.exception.PortalException { 2596 return _groupLocalService.updateGroup(groupId, parentGroupId, nameMap, 2597 descriptionMap, type, manualMembership, membershipRestriction, 2598 friendlyURL, inheritContent, active, serviceContext); 2599 } 2600 2601 /** 2602 * Updates the group's type settings. 2603 * 2604 * @param groupId the primary key of the group 2605 * @param typeSettings the group's new type settings (optionally 2606 <code>null</code>) 2607 * @return the group 2608 * @throws PortalException if a portal exception occurred 2609 */ 2610 @Override 2611 public com.liferay.portal.model.Group updateGroup(long groupId, 2612 java.lang.String typeSettings) 2613 throws com.liferay.portal.kernel.exception.PortalException { 2614 return _groupLocalService.updateGroup(groupId, typeSettings); 2615 } 2616 2617 /** 2618 * Associates the group with a main site if the group is an organization. 2619 * 2620 * @param groupId the primary key of the group 2621 * @param site whether the group is to be associated with a main site 2622 * @return the group 2623 * @throws PortalException if a portal exception occurred 2624 */ 2625 @Override 2626 public com.liferay.portal.model.Group updateSite(long groupId, boolean site) 2627 throws com.liferay.portal.kernel.exception.PortalException { 2628 return _groupLocalService.updateSite(groupId, site); 2629 } 2630 2631 @Override 2632 public GroupLocalService getWrappedService() { 2633 return _groupLocalService; 2634 } 2635 2636 @Override 2637 public void setWrappedService(GroupLocalService groupLocalService) { 2638 _groupLocalService = groupLocalService; 2639 } 2640 2641 private GroupLocalService _groupLocalService; 2642 }