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