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