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