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