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