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