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