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 729 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 730 * result set. 731 * </p> 732 * 733 * @param companyId the primary key of the company 734 * @param start the lower bound of the range of groups to return 735 * @param end the upper bound of the range of groups to return (not 736 inclusive) 737 * @return the range of groups associated with the company 738 */ 739 @Override 740 public java.util.List<com.liferay.portal.model.Group> getCompanyGroups( 741 long companyId, int start, int end) { 742 return _groupLocalService.getCompanyGroups(companyId, start, end); 743 } 744 745 /** 746 * Returns the number of groups associated with the company. 747 * 748 * @param companyId the primary key of the company 749 * @return the number of groups associated with the company 750 */ 751 @Override 752 public int getCompanyGroupsCount(long companyId) { 753 return _groupLocalService.getCompanyGroupsCount(companyId); 754 } 755 756 /** 757 * Returns the group with the matching friendly URL. 758 * 759 * @param companyId the primary key of the company 760 * @param friendlyURL the group's friendlyURL 761 * @return the group with the friendly URL 762 * @throws PortalException if a matching group could not be found, or if the 763 friendly URL was invalid 764 */ 765 @Override 766 public com.liferay.portal.model.Group getFriendlyURLGroup(long companyId, 767 java.lang.String friendlyURL) 768 throws com.liferay.portal.kernel.exception.PortalException { 769 return _groupLocalService.getFriendlyURLGroup(companyId, friendlyURL); 770 } 771 772 /** 773 * Returns the group with the matching group key. 774 * 775 * @param companyId the primary key of the company 776 * @param groupKey the group key 777 * @return the group with the group key 778 * @throws PortalException if a matching group could not be found 779 */ 780 @Override 781 public com.liferay.portal.model.Group getGroup(long companyId, 782 java.lang.String groupKey) 783 throws com.liferay.portal.kernel.exception.PortalException { 784 return _groupLocalService.getGroup(companyId, groupKey); 785 } 786 787 /** 788 * Returns the group with the primary key. 789 * 790 * @param groupId the primary key of the group 791 * @return the group 792 * @throws PortalException if a group with the primary key could not be found 793 */ 794 @Override 795 public com.liferay.portal.model.Group getGroup(long groupId) 796 throws com.liferay.portal.kernel.exception.PortalException { 797 return _groupLocalService.getGroup(groupId); 798 } 799 800 /** 801 * Returns the group with the matching UUID and company. 802 * 803 * @param uuid the group's UUID 804 * @param companyId the primary key of the company 805 * @return the matching group 806 * @throws PortalException if a matching group could not be found 807 */ 808 @Override 809 public com.liferay.portal.model.Group getGroupByUuidAndCompanyId( 810 java.lang.String uuid, long companyId) 811 throws com.liferay.portal.kernel.exception.PortalException { 812 return _groupLocalService.getGroupByUuidAndCompanyId(uuid, companyId); 813 } 814 815 /** 816 * @deprecated As of 7.0.0, replaced by {@link 817 Group#getDescriptiveName(Locale)} 818 */ 819 @Deprecated 820 @Override 821 public java.lang.String getGroupDescriptiveName( 822 com.liferay.portal.model.Group group, java.util.Locale locale) 823 throws com.liferay.portal.kernel.exception.PortalException { 824 return _groupLocalService.getGroupDescriptiveName(group, locale); 825 } 826 827 /** 828 * @deprecated As of 7.0.0, replaced by {@link 829 Group#getDescriptiveName(Locale)} 830 */ 831 @Deprecated 832 @Override 833 public java.lang.String getGroupDescriptiveName(long groupId, 834 java.util.Locale locale) 835 throws com.liferay.portal.kernel.exception.PortalException { 836 return _groupLocalService.getGroupDescriptiveName(groupId, locale); 837 } 838 839 /** 840 * Returns all the groups that are direct children of the parent group with 841 * the matching className. 842 * 843 * @param companyId the primary key of the company 844 * @param className the class name of the group 845 * @param parentGroupId the primary key of the parent group 846 * @return the matching groups, or <code>null</code> if no matches were 847 found 848 */ 849 @Override 850 public java.util.List<com.liferay.portal.model.Group> getGroups( 851 long companyId, java.lang.String className, long parentGroupId) { 852 return _groupLocalService.getGroups(companyId, className, parentGroupId); 853 } 854 855 /** 856 * Returns a range of all the groups that are direct children of the parent 857 * group with the matching className. 858 * 859 * @param companyId the primary key of the company 860 * @param className the class name of the group 861 * @param parentGroupId the primary key of the parent group 862 * @param start the lower bound of the range of results 863 * @param end the upper bound of the range of results (not inclusive) 864 * @return the range of matching groups 865 */ 866 @Override 867 public java.util.List<com.liferay.portal.model.Group> getGroups( 868 long companyId, java.lang.String className, long parentGroupId, 869 int start, int end) { 870 return _groupLocalService.getGroups(companyId, className, 871 parentGroupId, start, end); 872 } 873 874 /** 875 * Returns all the groups that are direct children of the parent group. 876 * 877 * @param companyId the primary key of the company 878 * @param parentGroupId the primary key of the parent group 879 * @param site whether the group is to be associated with a main site 880 * @return the matching groups, or <code>null</code> if no matches were 881 found 882 */ 883 @Override 884 public java.util.List<com.liferay.portal.model.Group> getGroups( 885 long companyId, long parentGroupId, boolean site) { 886 return _groupLocalService.getGroups(companyId, parentGroupId, site); 887 } 888 889 @Override 890 public java.util.List<com.liferay.portal.model.Group> getGroups( 891 long companyId, long parentGroupId, boolean site, boolean inheritContent) { 892 return _groupLocalService.getGroups(companyId, parentGroupId, site, 893 inheritContent); 894 } 895 896 /** 897 * Returns the groups with the matching primary keys. 898 * 899 * @param groupIds the primary keys of the groups 900 * @return the groups with the primary keys 901 * @throws PortalException if any one of the groups could not be found 902 */ 903 @Override 904 public java.util.List<com.liferay.portal.model.Group> getGroups( 905 long[] groupIds) 906 throws com.liferay.portal.kernel.exception.PortalException { 907 return _groupLocalService.getGroups(groupIds); 908 } 909 910 /** 911 * Returns a range of all the groups. 912 * 913 * <p> 914 * 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. 915 * </p> 916 * 917 * @param start the lower bound of the range of groups 918 * @param end the upper bound of the range of groups (not inclusive) 919 * @return the range of groups 920 */ 921 @Override 922 public java.util.List<com.liferay.portal.model.Group> getGroups(int start, 923 int end) { 924 return _groupLocalService.getGroups(start, end); 925 } 926 927 /** 928 * Returns the number of groups. 929 * 930 * @return the number of groups 931 */ 932 @Override 933 public int getGroupsCount() { 934 return _groupLocalService.getGroupsCount(); 935 } 936 937 /** 938 * Returns the number of groups that are direct children of the parent group 939 * with the matching className. 940 * 941 * @param companyId the primary key of the company 942 * @param className the class name of the group 943 * @param parentGroupId the primary key of the parent group 944 * @return the number of matching groups 945 */ 946 @Override 947 public int getGroupsCount(long companyId, java.lang.String className, 948 long parentGroupId) { 949 return _groupLocalService.getGroupsCount(companyId, className, 950 parentGroupId); 951 } 952 953 /** 954 * Returns the number of groups that are direct children of the parent 955 * group. 956 * 957 * @param companyId the primary key of the company 958 * @param parentGroupId the primary key of the parent group 959 * @param site whether the group is to be associated with a main site 960 * @return the number of matching groups 961 */ 962 @Override 963 public int getGroupsCount(long companyId, long parentGroupId, boolean site) { 964 return _groupLocalService.getGroupsCount(companyId, parentGroupId, site); 965 } 966 967 /** 968 * Returns the group associated with the layout. 969 * 970 * @param companyId the primary key of the company 971 * @param plid the primary key of the layout 972 * @return the group associated with the layout 973 * @throws PortalException if a matching group could not be found 974 */ 975 @Override 976 public com.liferay.portal.model.Group getLayoutGroup(long companyId, 977 long plid) throws com.liferay.portal.kernel.exception.PortalException { 978 return _groupLocalService.getLayoutGroup(companyId, plid); 979 } 980 981 /** 982 * Returns the group associated with the layout prototype. 983 * 984 * @param companyId the primary key of the company 985 * @param layoutPrototypeId the primary key of the layout prototype 986 * @return the group associated with the layout prototype 987 * @throws PortalException if a matching group could not be found 988 */ 989 @Override 990 public com.liferay.portal.model.Group getLayoutPrototypeGroup( 991 long companyId, long layoutPrototypeId) 992 throws com.liferay.portal.kernel.exception.PortalException { 993 return _groupLocalService.getLayoutPrototypeGroup(companyId, 994 layoutPrototypeId); 995 } 996 997 /** 998 * Returns the group associated with the layout set prototype. 999 * 1000 * @param companyId the primary key of the company 1001 * @param layoutSetPrototypeId the primary key of the layout set prototype 1002 * @return the group associated with the layout set prototype 1003 * @throws PortalException if a matching group could not be found 1004 */ 1005 @Override 1006 public com.liferay.portal.model.Group getLayoutSetPrototypeGroup( 1007 long companyId, long layoutSetPrototypeId) 1008 throws com.liferay.portal.kernel.exception.PortalException { 1009 return _groupLocalService.getLayoutSetPrototypeGroup(companyId, 1010 layoutSetPrototypeId); 1011 } 1012 1013 /** 1014 * Returns a range of all groups that are children of the parent group and 1015 * that have at least one layout. 1016 * 1017 * <p> 1018 * Useful when paginating results. Returns a maximum of <code>end - 1019 * start</code> instances. <code>start</code> and <code>end</code> are not 1020 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1021 * refers to the first result in the set. Setting both <code>start</code> 1022 * and <code>end</code> to {@link 1023 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1024 * result set. 1025 * </p> 1026 * 1027 * @param companyId the primary key of the company 1028 * @param parentGroupId the primary key of the parent group 1029 * @param site whether the group is to be associated with a main site 1030 * @param start the lower bound of the range of groups to return 1031 * @param end the upper bound of the range of groups to return (not 1032 inclusive) 1033 * @return the range of matching groups 1034 * @deprecated As of 6.2.0, replaced by {@link #getLayoutsGroups(long, long, 1035 boolean, int, int, OrderByComparator)} 1036 */ 1037 @Deprecated 1038 @Override 1039 public java.util.List<com.liferay.portal.model.Group> getLayoutsGroups( 1040 long companyId, long parentGroupId, boolean site, int start, int end) { 1041 return _groupLocalService.getLayoutsGroups(companyId, parentGroupId, 1042 site, start, end); 1043 } 1044 1045 /** 1046 * Returns a range of all groups that are children of the parent group and 1047 * that have at least one layout. 1048 * 1049 * <p> 1050 * Useful when paginating results. Returns a maximum of <code>end - 1051 * start</code> instances. <code>start</code> and <code>end</code> are not 1052 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1053 * refers to the first result in the set. Setting both <code>start</code> 1054 * and <code>end</code> to {@link 1055 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1056 * result set. 1057 * </p> 1058 * 1059 * @param companyId the primary key of the company 1060 * @param parentGroupId the primary key of the parent group 1061 * @param site whether the group is to be associated with a main site 1062 * @param start the lower bound of the range of groups to return 1063 * @param end the upper bound of the range of groups to return (not 1064 inclusive) 1065 * @param obc the comparator to order the groups (optionally 1066 <code>null</code>) 1067 * @return the range of matching groups ordered by comparator 1068 <code>obc</code> 1069 */ 1070 @Override 1071 public java.util.List<com.liferay.portal.model.Group> getLayoutsGroups( 1072 long companyId, long parentGroupId, boolean site, int start, int end, 1073 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 1074 return _groupLocalService.getLayoutsGroups(companyId, parentGroupId, 1075 site, start, end, obc); 1076 } 1077 1078 /** 1079 * Returns the number of groups that are children or the parent group and 1080 * that have at least one layout 1081 * 1082 * @param companyId the primary key of the company 1083 * @param parentGroupId the primary key of the parent group 1084 * @param site whether the group is to be associated with a main site 1085 * @return the number of matching groups 1086 */ 1087 @Override 1088 public int getLayoutsGroupsCount(long companyId, long parentGroupId, 1089 boolean site) { 1090 return _groupLocalService.getLayoutsGroupsCount(companyId, 1091 parentGroupId, site); 1092 } 1093 1094 /** 1095 * Returns all live groups. 1096 * 1097 * @return all live groups 1098 */ 1099 @Override 1100 public java.util.List<com.liferay.portal.model.Group> getLiveGroups() { 1101 return _groupLocalService.getLiveGroups(); 1102 } 1103 1104 /** 1105 * Returns a range of all non-system groups of a specified type (className) 1106 * that have no layouts. 1107 * 1108 * <p> 1109 * Useful when paginating results. Returns a maximum of <code>end - 1110 * start</code> instances. <code>start</code> and <code>end</code> are not 1111 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1112 * refers to the first result in the set. Setting both <code>start</code> 1113 * and <code>end</code> to {@link 1114 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1115 * result set. 1116 * </p> 1117 * 1118 * @param className the entity's class name 1119 * @param privateLayout whether to include groups with private layout sets 1120 or non-private layout sets 1121 * @param start the lower bound of the range of groups to return 1122 * @param end the upper bound of the range of groups to return (not 1123 inclusive) 1124 * @return the range of matching groups 1125 */ 1126 @Override 1127 public java.util.List<com.liferay.portal.model.Group> getNoLayoutsGroups( 1128 java.lang.String className, boolean privateLayout, int start, int end) { 1129 return _groupLocalService.getNoLayoutsGroups(className, privateLayout, 1130 start, end); 1131 } 1132 1133 /** 1134 * Returns all non-system groups having <code>null</code> or empty friendly 1135 * URLs. 1136 * 1137 * @return the non-system groups having <code>null</code> or empty friendly 1138 URLs 1139 */ 1140 @Override 1141 public java.util.List<com.liferay.portal.model.Group> getNullFriendlyURLGroups() { 1142 return _groupLocalService.getNullFriendlyURLGroups(); 1143 } 1144 1145 /** 1146 * Returns the specified organization group. 1147 * 1148 * @param companyId the primary key of the company 1149 * @param organizationId the primary key of the organization 1150 * @return the group associated with the organization 1151 * @throws PortalException if a matching group could not be found 1152 */ 1153 @Override 1154 public com.liferay.portal.model.Group getOrganizationGroup(long companyId, 1155 long organizationId) 1156 throws com.liferay.portal.kernel.exception.PortalException { 1157 return _groupLocalService.getOrganizationGroup(companyId, organizationId); 1158 } 1159 1160 @Override 1161 public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups( 1162 long organizationId) { 1163 return _groupLocalService.getOrganizationGroups(organizationId); 1164 } 1165 1166 @Override 1167 public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups( 1168 long organizationId, int start, int end) { 1169 return _groupLocalService.getOrganizationGroups(organizationId, start, 1170 end); 1171 } 1172 1173 @Override 1174 public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups( 1175 long organizationId, int start, int end, 1176 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) { 1177 return _groupLocalService.getOrganizationGroups(organizationId, start, 1178 end, orderByComparator); 1179 } 1180 1181 @Override 1182 public int getOrganizationGroupsCount(long organizationId) { 1183 return _groupLocalService.getOrganizationGroupsCount(organizationId); 1184 } 1185 1186 /** 1187 * Returns the organizationIds of the organizations associated with the group. 1188 * 1189 * @param groupId the groupId of the group 1190 * @return long[] the organizationIds of organizations associated with the group 1191 */ 1192 @Override 1193 public long[] getOrganizationPrimaryKeys(long groupId) { 1194 return _groupLocalService.getOrganizationPrimaryKeys(groupId); 1195 } 1196 1197 /** 1198 * Returns the specified organization groups. 1199 * 1200 * @param organizations the organizations 1201 * @return the groups associated with the organizations 1202 */ 1203 @Override 1204 public java.util.List<com.liferay.portal.model.Group> getOrganizationsGroups( 1205 java.util.List<com.liferay.portal.model.Organization> organizations) { 1206 return _groupLocalService.getOrganizationsGroups(organizations); 1207 } 1208 1209 /** 1210 * Returns all the groups related to the organizations. 1211 * 1212 * @param organizations the organizations 1213 * @return the groups related to the organizations 1214 */ 1215 @Override 1216 public java.util.List<com.liferay.portal.model.Group> getOrganizationsRelatedGroups( 1217 java.util.List<com.liferay.portal.model.Organization> organizations) { 1218 return _groupLocalService.getOrganizationsRelatedGroups(organizations); 1219 } 1220 1221 /** 1222 * Returns the group followed by all its parent groups ordered by closest 1223 * ancestor. 1224 * 1225 * @param groupId the primary key of the group 1226 * @return the group followed by all its parent groups ordered by closest 1227 ancestor 1228 * @throws PortalException if a group with the primary key could not be 1229 found 1230 */ 1231 @Override 1232 public java.util.List<com.liferay.portal.model.Group> getParentGroups( 1233 long groupId) 1234 throws com.liferay.portal.kernel.exception.PortalException { 1235 return _groupLocalService.getParentGroups(groupId); 1236 } 1237 1238 @Override 1239 public com.liferay.portal.model.PersistedModel getPersistedModel( 1240 java.io.Serializable primaryKeyObj) 1241 throws com.liferay.portal.kernel.exception.PortalException { 1242 return _groupLocalService.getPersistedModel(primaryKeyObj); 1243 } 1244 1245 @Override 1246 public java.util.List<com.liferay.portal.model.Group> getRoleGroups( 1247 long roleId) { 1248 return _groupLocalService.getRoleGroups(roleId); 1249 } 1250 1251 @Override 1252 public java.util.List<com.liferay.portal.model.Group> getRoleGroups( 1253 long roleId, int start, int end) { 1254 return _groupLocalService.getRoleGroups(roleId, start, end); 1255 } 1256 1257 @Override 1258 public java.util.List<com.liferay.portal.model.Group> getRoleGroups( 1259 long roleId, int start, int end, 1260 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) { 1261 return _groupLocalService.getRoleGroups(roleId, start, end, 1262 orderByComparator); 1263 } 1264 1265 @Override 1266 public int getRoleGroupsCount(long roleId) { 1267 return _groupLocalService.getRoleGroupsCount(roleId); 1268 } 1269 1270 /** 1271 * Returns the roleIds of the roles associated with the group. 1272 * 1273 * @param groupId the groupId of the group 1274 * @return long[] the roleIds of roles associated with the group 1275 */ 1276 @Override 1277 public long[] getRolePrimaryKeys(long groupId) { 1278 return _groupLocalService.getRolePrimaryKeys(groupId); 1279 } 1280 1281 /** 1282 * Returns the staging group. 1283 * 1284 * @param liveGroupId the primary key of the live group 1285 * @return the staging group 1286 * @throws PortalException if a matching staging group could not be found 1287 */ 1288 @Override 1289 public com.liferay.portal.model.Group getStagingGroup(long liveGroupId) 1290 throws com.liferay.portal.kernel.exception.PortalException { 1291 return _groupLocalService.getStagingGroup(liveGroupId); 1292 } 1293 1294 /** 1295 * Returns the group directly associated with the user. 1296 * 1297 * @param companyId the primary key of the company 1298 * @param userId the primary key of the user 1299 * @return the group directly associated with the user 1300 * @throws PortalException if a matching group could not be found 1301 */ 1302 @Override 1303 public com.liferay.portal.model.Group getUserGroup(long companyId, 1304 long userId) throws com.liferay.portal.kernel.exception.PortalException { 1305 return _groupLocalService.getUserGroup(companyId, userId); 1306 } 1307 1308 /** 1309 * Returns the specified "user group" group. That is, the group that 1310 * represents the {@link com.liferay.portal.model.UserGroup} entity. 1311 * 1312 * @param companyId the primary key of the company 1313 * @param userGroupId the primary key of the user group 1314 * @return the group associated with the user group 1315 * @throws PortalException if a matching group could not be found 1316 */ 1317 @Override 1318 public com.liferay.portal.model.Group getUserGroupGroup(long companyId, 1319 long userGroupId) 1320 throws com.liferay.portal.kernel.exception.PortalException { 1321 return _groupLocalService.getUserGroupGroup(companyId, userGroupId); 1322 } 1323 1324 @Override 1325 public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups( 1326 long userGroupId) { 1327 return _groupLocalService.getUserGroupGroups(userGroupId); 1328 } 1329 1330 @Override 1331 public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups( 1332 long userGroupId, int start, int end) { 1333 return _groupLocalService.getUserGroupGroups(userGroupId, start, end); 1334 } 1335 1336 @Override 1337 public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups( 1338 long userGroupId, int start, int end, 1339 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) { 1340 return _groupLocalService.getUserGroupGroups(userGroupId, start, end, 1341 orderByComparator); 1342 } 1343 1344 @Override 1345 public int getUserGroupGroupsCount(long userGroupId) { 1346 return _groupLocalService.getUserGroupGroupsCount(userGroupId); 1347 } 1348 1349 /** 1350 * Returns the userGroupIds of the user groups associated with the group. 1351 * 1352 * @param groupId the groupId of the group 1353 * @return long[] the userGroupIds of user groups associated with the group 1354 */ 1355 @Override 1356 public long[] getUserGroupPrimaryKeys(long groupId) { 1357 return _groupLocalService.getUserGroupPrimaryKeys(groupId); 1358 } 1359 1360 @Override 1361 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1362 long userId) { 1363 return _groupLocalService.getUserGroups(userId); 1364 } 1365 1366 /** 1367 * Returns all the user's site groups and immediate organization groups, 1368 * optionally including the user's inherited organization groups and user 1369 * groups. System and staged groups are not included. 1370 * 1371 * @param userId the primary key of the user 1372 * @param inherit whether to include the user's inherited organization 1373 groups and user groups 1374 * @return the user's groups and immediate organization groups 1375 * @throws PortalException if a user with the primary key could not be found 1376 */ 1377 @Override 1378 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1379 long userId, boolean inherit) 1380 throws com.liferay.portal.kernel.exception.PortalException { 1381 return _groupLocalService.getUserGroups(userId, inherit); 1382 } 1383 1384 /** 1385 * Returns an ordered range of all the user's site groups and immediate 1386 * organization groups, optionally including the user's inherited 1387 * organization groups and user groups. System and staged groups are not 1388 * included. 1389 * 1390 * <p> 1391 * Useful when paginating results. Returns a maximum of <code>end - 1392 * start</code> instances. <code>start</code> and <code>end</code> are not 1393 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1394 * refers to the first result in the set. Setting both <code>start</code> 1395 * and <code>end</code> to {@link 1396 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1397 * result set. 1398 * </p> 1399 * 1400 * @param userId the primary key of the user 1401 * @param inherit whether to include the user's inherited organization 1402 groups and user groups 1403 * @param start the lower bound of the range of groups to return 1404 * @param end the upper bound of the range of groups to return (not 1405 inclusive) 1406 * @return the range of the user's groups and immediate organization groups 1407 ordered by name 1408 * @throws PortalException if a user with the primary key could not be found 1409 */ 1410 @Override 1411 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1412 long userId, boolean inherit, int start, int end) 1413 throws com.liferay.portal.kernel.exception.PortalException { 1414 return _groupLocalService.getUserGroups(userId, inherit, start, end); 1415 } 1416 1417 @Override 1418 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1419 long userId, int start, int end) { 1420 return _groupLocalService.getUserGroups(userId, start, end); 1421 } 1422 1423 /** 1424 * @throws PortalException 1425 */ 1426 @Override 1427 public java.util.List<com.liferay.portal.model.Group> getUserGroups( 1428 long userId, int start, int end, 1429 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) 1430 throws com.liferay.portal.kernel.exception.PortalException { 1431 return _groupLocalService.getUserGroups(userId, start, end, 1432 orderByComparator); 1433 } 1434 1435 @Override 1436 public int getUserGroupsCount(long userId) { 1437 return _groupLocalService.getUserGroupsCount(userId); 1438 } 1439 1440 /** 1441 * Returns the groups associated with the user groups. 1442 * 1443 * @param userGroups the user groups 1444 * @return the groups associated with the user groups 1445 * @throws PortalException if any one of the user group's group could not be 1446 found 1447 */ 1448 @Override 1449 public java.util.List<com.liferay.portal.model.Group> getUserGroupsGroups( 1450 java.util.List<com.liferay.portal.model.UserGroup> userGroups) 1451 throws com.liferay.portal.kernel.exception.PortalException { 1452 return _groupLocalService.getUserGroupsGroups(userGroups); 1453 } 1454 1455 /** 1456 * Returns all the groups related to the user groups. 1457 * 1458 * @param userGroups the user groups 1459 * @return the groups related to the user groups 1460 */ 1461 @Override 1462 public java.util.List<com.liferay.portal.model.Group> getUserGroupsRelatedGroups( 1463 java.util.List<com.liferay.portal.model.UserGroup> userGroups) { 1464 return _groupLocalService.getUserGroupsRelatedGroups(userGroups); 1465 } 1466 1467 /** 1468 * Returns the range of all groups associated with the user's organization 1469 * groups, including the ancestors of the organization groups, unless portal 1470 * property <code>organizations.membership.strict</code> is set to 1471 * <code>true</code>. 1472 * 1473 * <p> 1474 * Useful when paginating results. Returns a maximum of <code>end - 1475 * start</code> instances. <code>start</code> and <code>end</code> are not 1476 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1477 * refers to the first result in the set. Setting both <code>start</code> 1478 * and <code>end</code> to {@link 1479 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1480 * result set. 1481 * </p> 1482 * 1483 * @param userId the primary key of the user 1484 * @param start the lower bound of the range of groups to consider 1485 * @param end the upper bound of the range of groups to consider (not 1486 inclusive) 1487 * @return the range of groups associated with the user's organization 1488 groups 1489 * @throws PortalException if a user with the primary key could not be found 1490 or if another portal exception occurred 1491 */ 1492 @Override 1493 public java.util.List<com.liferay.portal.model.Group> getUserOrganizationsGroups( 1494 long userId, int start, int end) 1495 throws com.liferay.portal.kernel.exception.PortalException { 1496 return _groupLocalService.getUserOrganizationsGroups(userId, start, end); 1497 } 1498 1499 /** 1500 * Returns the default user's personal site group. 1501 * 1502 * @param companyId the primary key of the company 1503 * @return the default user's personal site group 1504 * @throws PortalException if a matching group or default user for the 1505 company could not be found 1506 */ 1507 @Override 1508 public com.liferay.portal.model.Group getUserPersonalSiteGroup( 1509 long companyId) 1510 throws com.liferay.portal.kernel.exception.PortalException { 1511 return _groupLocalService.getUserPersonalSiteGroup(companyId); 1512 } 1513 1514 /** 1515 * Returns the userIds of the users associated with the group. 1516 * 1517 * @param groupId the groupId of the group 1518 * @return long[] the userIds of users associated with the group 1519 */ 1520 @Override 1521 public long[] getUserPrimaryKeys(long groupId) { 1522 return _groupLocalService.getUserPrimaryKeys(groupId); 1523 } 1524 1525 @Override 1526 public java.util.List<com.liferay.portal.model.Group> getUserSitesGroups( 1527 long userId) throws com.liferay.portal.kernel.exception.PortalException { 1528 return _groupLocalService.getUserSitesGroups(userId); 1529 } 1530 1531 @Override 1532 public java.util.List<com.liferay.portal.model.Group> getUserSitesGroups( 1533 long userId, boolean includeAdministrative) 1534 throws com.liferay.portal.kernel.exception.PortalException { 1535 return _groupLocalService.getUserSitesGroups(userId, 1536 includeAdministrative); 1537 } 1538 1539 @Override 1540 public boolean hasOrganizationGroup(long organizationId, long groupId) { 1541 return _groupLocalService.hasOrganizationGroup(organizationId, groupId); 1542 } 1543 1544 @Override 1545 public boolean hasOrganizationGroups(long organizationId) { 1546 return _groupLocalService.hasOrganizationGroups(organizationId); 1547 } 1548 1549 @Override 1550 public boolean hasRoleGroup(long roleId, long groupId) { 1551 return _groupLocalService.hasRoleGroup(roleId, groupId); 1552 } 1553 1554 @Override 1555 public boolean hasRoleGroups(long roleId) { 1556 return _groupLocalService.hasRoleGroups(roleId); 1557 } 1558 1559 /** 1560 * Returns <code>true</code> if the live group has a staging group. 1561 * 1562 * @param liveGroupId the primary key of the live group 1563 * @return <code>true</code> if the live group has a staging group; 1564 <code>false</code> otherwise 1565 */ 1566 @Override 1567 public boolean hasStagingGroup(long liveGroupId) { 1568 return _groupLocalService.hasStagingGroup(liveGroupId); 1569 } 1570 1571 @Override 1572 public boolean hasUserGroup(long userId, long groupId) { 1573 return _groupLocalService.hasUserGroup(userId, groupId); 1574 } 1575 1576 /** 1577 * Returns <code>true</code> if the user is immediately associated with the 1578 * group, or optionally if the user is associated with the group via the 1579 * user's organizations, inherited organizations, or user groups. 1580 * 1581 * @param userId the primary key of the user 1582 * @param groupId the primary key of the group 1583 * @param inherit whether to include organization groups and user groups to 1584 which the user belongs in the determination 1585 * @return <code>true</code> if the user is associated with the group; 1586 <code>false</code> otherwise 1587 */ 1588 @Override 1589 public boolean hasUserGroup(long userId, long groupId, boolean inherit) { 1590 return _groupLocalService.hasUserGroup(userId, groupId, inherit); 1591 } 1592 1593 @Override 1594 public boolean hasUserGroupGroup(long userGroupId, long groupId) { 1595 return _groupLocalService.hasUserGroupGroup(userGroupId, groupId); 1596 } 1597 1598 @Override 1599 public boolean hasUserGroupGroups(long userGroupId) { 1600 return _groupLocalService.hasUserGroupGroups(userGroupId); 1601 } 1602 1603 @Override 1604 public boolean hasUserGroups(long userId) { 1605 return _groupLocalService.hasUserGroups(userId); 1606 } 1607 1608 /** 1609 * Returns the group with the matching group key by first searching the 1610 * system groups and then using the finder cache. 1611 * 1612 * @param companyId the primary key of the company 1613 * @param groupKey the group key 1614 * @return the group with the group key and associated company, or 1615 <code>null</code> if a matching group could not be found 1616 */ 1617 @Override 1618 public com.liferay.portal.model.Group loadFetchGroup(long companyId, 1619 java.lang.String groupKey) { 1620 return _groupLocalService.loadFetchGroup(companyId, groupKey); 1621 } 1622 1623 /** 1624 * Returns the group with the matching group key. 1625 * 1626 * @param companyId the primary key of the company 1627 * @param groupKey the group key 1628 * @return the group with the group key and associated company 1629 * @throws PortalException if a matching group could not be found 1630 */ 1631 @Override 1632 public com.liferay.portal.model.Group loadGetGroup(long companyId, 1633 java.lang.String groupKey) 1634 throws com.liferay.portal.kernel.exception.PortalException { 1635 return _groupLocalService.loadGetGroup(companyId, groupKey); 1636 } 1637 1638 /** 1639 * Rebuilds the group tree. 1640 * 1641 * <p> 1642 * Only call this method if the tree has become stale through operations 1643 * other than normal CRUD. Under normal circumstances the tree is 1644 * automatically rebuilt whenever necessary. 1645 * </p> 1646 * 1647 * @param companyId the primary key of the group's company 1648 * @throws PortalException if a group with the primary key could not be 1649 found 1650 */ 1651 @Override 1652 public void rebuildTree(long companyId) 1653 throws com.liferay.portal.kernel.exception.PortalException { 1654 _groupLocalService.rebuildTree(companyId); 1655 } 1656 1657 /** 1658 * Returns an ordered range of all the groups that match the class name IDs 1659 * and keywords, optionally including the user's inherited organization 1660 * groups and user groups. System and staged groups are not included. 1661 * 1662 * <p> 1663 * Useful when paginating results. Returns a maximum of <code>end - 1664 * start</code> instances. <code>start</code> and <code>end</code> are not 1665 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1666 * refers to the first result in the set. Setting both <code>start</code> 1667 * and <code>end</code> to {@link 1668 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1669 * result set. 1670 * </p> 1671 * 1672 * @param companyId the primary key of the company 1673 * @param classNameIds the primary keys of the class names of the entities 1674 the groups are related to (optionally <code>null</code>) 1675 * @param keywords the keywords (space separated), which may occur in the 1676 sites's name, or description (optionally <code>null</code>) 1677 * @param params the finder params (optionally <code>null</code>). To 1678 include a user's organizations, inherited organizations, and user 1679 groups in the search, add an entry with key 1680 "usersGroups" mapped to the user's ID and an entry with 1681 key "inherit" mapped to a non-<code>null</code> object. 1682 For more information see {@link 1683 com.liferay.portal.service.persistence.GroupFinder}. 1684 * @param start the lower bound of the range of groups to return 1685 * @param end the upper bound of the range of groups to return (not 1686 inclusive) 1687 * @return the matching groups ordered by name 1688 */ 1689 @Override 1690 public java.util.List<com.liferay.portal.model.Group> search( 1691 long companyId, long[] classNameIds, java.lang.String keywords, 1692 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1693 int start, int end) { 1694 return _groupLocalService.search(companyId, classNameIds, keywords, 1695 params, start, end); 1696 } 1697 1698 /** 1699 * Returns an ordered range of all the groups that match the class name IDs 1700 * and keywords, optionally including the user's inherited organization 1701 * groups and user groups. System and staged groups are not included. 1702 * 1703 * <p> 1704 * Useful when paginating results. Returns a maximum of <code>end - 1705 * start</code> instances. <code>start</code> and <code>end</code> are not 1706 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1707 * refers to the first result in the set. Setting both <code>start</code> 1708 * and <code>end</code> to {@link 1709 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1710 * result set. 1711 * </p> 1712 * 1713 * @param companyId the primary key of the company 1714 * @param classNameIds the primary keys of the class names of the entities 1715 the groups are related to (optionally <code>null</code>) 1716 * @param keywords the keywords (space separated), which may occur in the 1717 sites's name, or description (optionally <code>null</code>) 1718 * @param params the finder params (optionally <code>null</code>). To 1719 include a user's organizations, inherited organizations, and user 1720 groups in the search, add an entry with key 1721 "usersGroups" mapped to the user's ID and an entry with 1722 key "inherit" mapped to a non-<code>null</code> object. 1723 For more information see {@link 1724 com.liferay.portal.service.persistence.GroupFinder}. 1725 * @param start the lower bound of the range of groups to return 1726 * @param end the upper bound of the range of groups to return (not 1727 inclusive) 1728 * @param obc the comparator to order the groups (optionally 1729 <code>null</code>) 1730 * @return the matching groups ordered by comparator <code>obc</code> 1731 */ 1732 @Override 1733 public java.util.List<com.liferay.portal.model.Group> search( 1734 long companyId, long[] classNameIds, java.lang.String keywords, 1735 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1736 int start, int end, 1737 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 1738 return _groupLocalService.search(companyId, classNameIds, keywords, 1739 params, start, end, obc); 1740 } 1741 1742 /** 1743 * Returns an ordered range of all the groups that match the class name IDs, 1744 * name, and description, optionally including the user's inherited 1745 * organization groups and user groups. System and staged groups are not 1746 * included. 1747 * 1748 * <p> 1749 * Useful when paginating results. Returns a maximum of <code>end - 1750 * start</code> instances. <code>start</code> and <code>end</code> are not 1751 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1752 * refers to the first result in the set. Setting both <code>start</code> 1753 * and <code>end</code> to {@link 1754 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1755 * result set. 1756 * </p> 1757 * 1758 * @param companyId the primary key of the company 1759 * @param classNameIds the primary keys of the class names of the entities 1760 the groups are related to (optionally <code>null</code>) 1761 * @param name the group's name (optionally <code>null</code>) 1762 * @param description the group's description (optionally 1763 <code>null</code>) 1764 * @param params the finder params (optionally <code>null</code>). To 1765 include a user's organizations, inherited organizations, and user 1766 groups in the search, add an entry with key 1767 "usersGroups" mapped to the user's ID and an entry with 1768 key "inherit" mapped to a non-<code>null</code> object. 1769 For more information see {@link 1770 com.liferay.portal.service.persistence.GroupFinder}. 1771 * @param andOperator whether every field must match its keywords, or just 1772 one field. 1773 * @param start the lower bound of the range of groups to return 1774 * @param end the upper bound of the range of groups to return (not 1775 inclusive) 1776 * @return the matching groups ordered by name 1777 */ 1778 @Override 1779 public java.util.List<com.liferay.portal.model.Group> search( 1780 long companyId, long[] classNameIds, java.lang.String name, 1781 java.lang.String description, 1782 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1783 boolean andOperator, int start, int end) { 1784 return _groupLocalService.search(companyId, classNameIds, name, 1785 description, params, andOperator, start, end); 1786 } 1787 1788 /** 1789 * Returns an ordered range of all the groups that match the class name IDs, 1790 * name, and description, optionally including the user's inherited 1791 * organization groups and user groups. System and staged groups are not 1792 * included. 1793 * 1794 * <p> 1795 * Useful when paginating results. Returns a maximum of <code>end - 1796 * start</code> instances. <code>start</code> and <code>end</code> are not 1797 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1798 * refers to the first result in the set. Setting both <code>start</code> 1799 * and <code>end</code> to {@link 1800 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1801 * result set. 1802 * </p> 1803 * 1804 * @param companyId the primary key of the company 1805 * @param classNameIds the primary keys of the class names of the entities 1806 the groups are related to (optionally <code>null</code>) 1807 * @param name the group's name (optionally <code>null</code>) 1808 * @param description the group's description (optionally 1809 <code>null</code>) 1810 * @param params the finder params (optionally <code>null</code>). To 1811 include a user's organizations, inherited organizations, and user 1812 groups in the search, add an entry with key 1813 "usersGroups" mapped to the user's ID and an entry with 1814 key "inherit" mapped to a non-<code>null</code> object. 1815 For more information see {@link 1816 com.liferay.portal.service.persistence.GroupFinder}. 1817 * @param andOperator whether every field must match its keywords, or just 1818 one field. 1819 * @param start the lower bound of the range of groups to return 1820 * @param end the upper bound of the range of groups to return (not 1821 inclusive) 1822 * @param obc the comparator to order the groups (optionally 1823 <code>null</code>) 1824 * @return the matching groups ordered by comparator <code>obc</code> 1825 */ 1826 @Override 1827 public java.util.List<com.liferay.portal.model.Group> search( 1828 long companyId, long[] classNameIds, java.lang.String name, 1829 java.lang.String description, 1830 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1831 boolean andOperator, int start, int end, 1832 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 1833 return _groupLocalService.search(companyId, classNameIds, name, 1834 description, params, andOperator, start, end, obc); 1835 } 1836 1837 /** 1838 * Returns an ordered range of all the groups belonging to the parent group 1839 * that match the class name IDs and keywords, optionally including the 1840 * user's inherited organization groups and user groups. System and staged 1841 * groups are not included. 1842 * 1843 * <p> 1844 * Useful when paginating results. Returns a maximum of <code>end - 1845 * start</code> instances. <code>start</code> and <code>end</code> are not 1846 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1847 * refers to the first result in the set. Setting both <code>start</code> 1848 * and <code>end</code> to {@link 1849 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1850 * result set. 1851 * </p> 1852 * 1853 * @param companyId the primary key of the company 1854 * @param classNameIds the primary keys of the class names of the entities 1855 the groups are related to (optionally <code>null</code>) 1856 * @param parentGroupId the primary key of the parent group 1857 * @param keywords the keywords (space separated), which may occur in the 1858 sites's name, or description (optionally <code>null</code>) 1859 * @param params the finder params (optionally <code>null</code>). To 1860 include a user's organizations, inherited organizations, and user 1861 groups in the search, add an entry with key 1862 "usersGroups" mapped to the user's ID and an entry with 1863 key "inherit" mapped to a non-<code>null</code> object. 1864 For more information see {@link 1865 com.liferay.portal.service.persistence.GroupFinder}. 1866 * @param start the lower bound of the range of groups to return 1867 * @param end the upper bound of the range of groups to return (not 1868 inclusive) 1869 * @return the matching groups ordered by name 1870 */ 1871 @Override 1872 public java.util.List<com.liferay.portal.model.Group> search( 1873 long companyId, long[] classNameIds, long parentGroupId, 1874 java.lang.String keywords, 1875 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1876 int start, int end) { 1877 return _groupLocalService.search(companyId, classNameIds, 1878 parentGroupId, keywords, params, start, end); 1879 } 1880 1881 /** 1882 * Returns an ordered range of all the groups belonging to the parent group 1883 * that match the class name IDs and keywords, optionally including the 1884 * user's inherited organization groups and user groups. System and staged 1885 * groups are not included. 1886 * 1887 * <p> 1888 * Useful when paginating results. Returns a maximum of <code>end - 1889 * start</code> instances. <code>start</code> and <code>end</code> are not 1890 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1891 * refers to the first result in the set. Setting both <code>start</code> 1892 * and <code>end</code> to {@link 1893 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1894 * result set. 1895 * </p> 1896 * 1897 * @param companyId the primary key of the company 1898 * @param classNameIds the primary keys of the class names of the entities 1899 the groups are related to (optionally <code>null</code>) 1900 * @param parentGroupId the primary key of the parent group 1901 * @param keywords the keywords (space separated), which may occur in the 1902 sites's name, or description (optionally <code>null</code>) 1903 * @param params the finder params (optionally <code>null</code>). To 1904 include a user's organizations, inherited organizations, and user 1905 groups in the search, add an entry with key 1906 "usersGroups" mapped to the user's ID and an entry with 1907 key "inherit" mapped to a non-<code>null</code> object. 1908 For more information see {@link 1909 com.liferay.portal.service.persistence.GroupFinder}. 1910 * @param start the lower bound of the range of groups to return 1911 * @param end the upper bound of the range of groups to return (not 1912 inclusive) 1913 * @param obc the comparator to order the groups (optionally 1914 <code>null</code>) 1915 * @return the matching groups ordered by comparator <code>obc</code> 1916 */ 1917 @Override 1918 public java.util.List<com.liferay.portal.model.Group> search( 1919 long companyId, long[] classNameIds, long parentGroupId, 1920 java.lang.String keywords, 1921 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1922 int start, int end, 1923 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 1924 return _groupLocalService.search(companyId, classNameIds, 1925 parentGroupId, keywords, params, start, end, obc); 1926 } 1927 1928 /** 1929 * Returns an ordered range of all the groups belonging to the parent group 1930 * that match the class name IDs, name, and description, optionally 1931 * including the user's inherited organization groups and user groups. 1932 * System and staged groups are not included. 1933 * 1934 * <p> 1935 * Useful when paginating results. Returns a maximum of <code>end - 1936 * start</code> instances. <code>start</code> and <code>end</code> are not 1937 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1938 * refers to the first result in the set. Setting both <code>start</code> 1939 * and <code>end</code> to {@link 1940 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1941 * result set. 1942 * </p> 1943 * 1944 * @param companyId the primary key of the company 1945 * @param classNameIds the primary keys of the class names of the entities 1946 the groups are related to (optionally <code>null</code>) 1947 * @param parentGroupId the primary key of the parent group 1948 * @param name the group's name (optionally <code>null</code>) 1949 * @param description the group's description (optionally 1950 <code>null</code>) 1951 * @param params the finder params (optionally <code>null</code>). To 1952 include a user's organizations, inherited organizations, and user 1953 groups in the search, add an entry with key 1954 "usersGroups" mapped to the user's ID and an entry with 1955 key "inherit" mapped to a non-<code>null</code> object. 1956 For more information see {@link 1957 com.liferay.portal.service.persistence.GroupFinder}. 1958 * @param andOperator whether every field must match its keywords, or just 1959 one field. 1960 * @param start the lower bound of the range of groups to return 1961 * @param end the upper bound of the range of groups to return (not 1962 inclusive) 1963 * @return the matching groups ordered by name 1964 */ 1965 @Override 1966 public java.util.List<com.liferay.portal.model.Group> search( 1967 long companyId, long[] classNameIds, long parentGroupId, 1968 java.lang.String name, java.lang.String description, 1969 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1970 boolean andOperator, int start, int end) { 1971 return _groupLocalService.search(companyId, classNameIds, 1972 parentGroupId, name, description, params, andOperator, start, end); 1973 } 1974 1975 /** 1976 * Returns an ordered range of all the groups belonging to the parent group 1977 * that match the class name IDs, name, and description, optionally 1978 * including the user's inherited organization groups and user groups. 1979 * System and staged groups are not included. 1980 * 1981 * <p> 1982 * Useful when paginating results. Returns a maximum of <code>end - 1983 * start</code> instances. <code>start</code> and <code>end</code> are not 1984 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1985 * refers to the first result in the set. Setting both <code>start</code> 1986 * and <code>end</code> to {@link 1987 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1988 * result set. 1989 * </p> 1990 * 1991 * @param companyId the primary key of the company 1992 * @param classNameIds the primary keys of the class names of the entities 1993 the groups are related to (optionally <code>null</code>) 1994 * @param parentGroupId the primary key of the parent group 1995 * @param name the group's name (optionally <code>null</code>) 1996 * @param description the group's description (optionally 1997 <code>null</code>) 1998 * @param params the finder params (optionally <code>null</code>). To 1999 include a user's organizations, inherited organizations, and user 2000 groups in the search, add an entry with key 2001 "usersGroups" mapped to the user's ID and an entry with 2002 key "inherit" mapped to a non-<code>null</code> object. 2003 For more information see {@link 2004 com.liferay.portal.service.persistence.GroupFinder}. 2005 * @param andOperator whether every field must match its keywords, or just 2006 one field. 2007 * @param start the lower bound of the range of groups to return 2008 * @param end the upper bound of the range of groups to return (not 2009 inclusive) 2010 * @param obc the comparator to order the groups (optionally 2011 <code>null</code>) 2012 * @return the matching groups ordered by comparator <code>obc</code> 2013 */ 2014 @Override 2015 public java.util.List<com.liferay.portal.model.Group> search( 2016 long companyId, long[] classNameIds, long parentGroupId, 2017 java.lang.String name, java.lang.String description, 2018 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2019 boolean andOperator, int start, int end, 2020 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 2021 return _groupLocalService.search(companyId, classNameIds, 2022 parentGroupId, name, description, params, andOperator, start, end, 2023 obc); 2024 } 2025 2026 /** 2027 * Returns an ordered range of all the groups that match the keywords, 2028 * optionally including the user's inherited organization groups and user 2029 * groups. System and staged groups are not included. 2030 * 2031 * <p> 2032 * Useful when paginating results. Returns a maximum of <code>end - 2033 * start</code> instances. <code>start</code> and <code>end</code> are not 2034 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2035 * refers to the first result in the set. Setting both <code>start</code> 2036 * and <code>end</code> to {@link 2037 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2038 * result set. 2039 * </p> 2040 * 2041 * @param companyId the primary key of the company 2042 * @param keywords the keywords (space separated), which may occur in the 2043 sites's name, or description (optionally <code>null</code>) 2044 * @param params the finder params (optionally <code>null</code>). To 2045 include the user's inherited organizations and user groups in the 2046 search, add entries having "usersGroups" and 2047 "inherit" as keys mapped to the the user's ID. For more 2048 information see {@link 2049 com.liferay.portal.service.persistence.GroupFinder}. 2050 * @param start the lower bound of the range of groups to return 2051 * @param end the upper bound of the range of groups to return (not 2052 inclusive) 2053 * @return the matching groups ordered by name 2054 */ 2055 @Override 2056 public java.util.List<com.liferay.portal.model.Group> search( 2057 long companyId, java.lang.String keywords, 2058 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2059 int start, int end) { 2060 return _groupLocalService.search(companyId, keywords, params, start, end); 2061 } 2062 2063 /** 2064 * Returns an ordered range of all the groups that match the keywords, 2065 * optionally including the user's inherited organization groups and user 2066 * groups. System and staged groups are not included. 2067 * 2068 * <p> 2069 * Useful when paginating results. Returns a maximum of <code>end - 2070 * start</code> instances. <code>start</code> and <code>end</code> are not 2071 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2072 * refers to the first result in the set. Setting both <code>start</code> 2073 * and <code>end</code> to {@link 2074 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2075 * result set. 2076 * </p> 2077 * 2078 * @param companyId the primary key of the company 2079 * @param keywords the keywords (space separated), which may occur in the 2080 sites's name, or description (optionally <code>null</code>) 2081 * @param params the finder params (optionally <code>null</code>). To 2082 include the user's inherited organizations and user groups in the 2083 search, add entries having "usersGroups" and 2084 "inherit" as keys mapped to the the user's ID. For more 2085 information see {@link 2086 com.liferay.portal.service.persistence.GroupFinder}. 2087 * @param start the lower bound of the range of groups to return 2088 * @param end the upper bound of the range of groups to return (not 2089 inclusive) 2090 * @param obc the comparator to order the groups (optionally 2091 <code>null</code>) 2092 * @return the matching groups ordered by comparator <code>obc</code> 2093 */ 2094 @Override 2095 public java.util.List<com.liferay.portal.model.Group> search( 2096 long companyId, java.lang.String keywords, 2097 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2098 int start, int end, 2099 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 2100 return _groupLocalService.search(companyId, keywords, params, start, 2101 end, obc); 2102 } 2103 2104 /** 2105 * Returns an ordered range of all the site groups and organization groups 2106 * that match the name and description, optionally including the user's 2107 * inherited organization groups and user groups. System and staged groups 2108 * are not included. 2109 * 2110 * <p> 2111 * Useful when paginating results. Returns a maximum of <code>end - 2112 * start</code> instances. <code>start</code> and <code>end</code> are not 2113 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2114 * refers to the first result in the set. Setting both <code>start</code> 2115 * and <code>end</code> to {@link 2116 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2117 * result set. 2118 * </p> 2119 * 2120 * @param companyId the primary key of the company 2121 * @param name the group's name (optionally <code>null</code>) 2122 * @param description the group's description (optionally 2123 <code>null</code>) 2124 * @param params the finder params (optionally <code>null</code>). To 2125 include the user's inherited organizations and user groups in the 2126 search, add entries having "usersGroups" and 2127 "inherit" as keys mapped to the the user's ID. For more 2128 information see {@link 2129 com.liferay.portal.service.persistence.GroupFinder}. 2130 * @param andOperator whether every field must match its keywords, or just 2131 one field. 2132 * @param start the lower bound of the range of groups to return 2133 * @param end the upper bound of the range of groups to return (not 2134 inclusive) 2135 * @return the matching groups ordered by name 2136 */ 2137 @Override 2138 public java.util.List<com.liferay.portal.model.Group> search( 2139 long companyId, java.lang.String name, java.lang.String description, 2140 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2141 boolean andOperator, int start, int end) { 2142 return _groupLocalService.search(companyId, name, description, params, 2143 andOperator, start, end); 2144 } 2145 2146 /** 2147 * Returns an ordered range of all the site groups and organization groups 2148 * that match the name and description, optionally including the user's 2149 * inherited organization groups and user groups. System and staged groups 2150 * are not included. 2151 * 2152 * <p> 2153 * Useful when paginating results. Returns a maximum of <code>end - 2154 * start</code> instances. <code>start</code> and <code>end</code> are not 2155 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2156 * refers to the first result in the set. Setting both <code>start</code> 2157 * and <code>end</code> to {@link 2158 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2159 * result set. 2160 * </p> 2161 * 2162 * @param companyId the primary key of the company 2163 * @param name the group's name (optionally <code>null</code>) 2164 * @param description the group's description (optionally 2165 <code>null</code>) 2166 * @param params the finder params (optionally <code>null</code>). To 2167 include the user's inherited organizations and user groups in the 2168 search, add entries having "usersGroups" and 2169 "inherit" as keys mapped to the the user's ID. For more 2170 information see {@link 2171 com.liferay.portal.service.persistence.GroupFinder}. 2172 * @param andOperator whether every field must match its keywords, or just 2173 one field. 2174 * @param start the lower bound of the range of groups to return 2175 * @param end the upper bound of the range of groups to return (not 2176 inclusive) 2177 * @param obc the comparator to order the groups (optionally 2178 <code>null</code>) 2179 * @return the matching groups ordered by comparator <code>obc</code> 2180 */ 2181 @Override 2182 public java.util.List<com.liferay.portal.model.Group> search( 2183 long companyId, java.lang.String name, java.lang.String description, 2184 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2185 boolean andOperator, int start, int end, 2186 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 2187 return _groupLocalService.search(companyId, name, description, params, 2188 andOperator, start, end, obc); 2189 } 2190 2191 /** 2192 * Returns an ordered range of all the company's groups, optionally 2193 * including the user's inherited organization groups and user groups. 2194 * System and staged groups are not included. 2195 * 2196 * <p> 2197 * Useful when paginating results. Returns a maximum of <code>end - 2198 * start</code> instances. <code>start</code> and <code>end</code> are not 2199 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2200 * refers to the first result in the set. Setting both <code>start</code> 2201 * and <code>end</code> to {@link 2202 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2203 * result set. 2204 * </p> 2205 * 2206 * @param companyId the primary key of the company 2207 * @param params the finder params (optionally <code>null</code>). To 2208 include a user's organizations, inherited organizations, and user 2209 groups in the search, add an entry with key 2210 "usersGroups" mapped to the user's ID and an entry with 2211 key "inherit" mapped to a non-<code>null</code> object. 2212 For more information see {@link 2213 com.liferay.portal.service.persistence.GroupFinder}. 2214 * @param start the lower bound of the range of groups to return 2215 * @param end the upper bound of the range of groups to return (not 2216 inclusive) 2217 * @return the matching groups ordered by name 2218 */ 2219 @Override 2220 public java.util.List<com.liferay.portal.model.Group> search( 2221 long companyId, 2222 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2223 int start, int end) { 2224 return _groupLocalService.search(companyId, params, start, end); 2225 } 2226 2227 /** 2228 * Returns an ordered range of all the groups belonging to the parent group 2229 * that match the keywords, optionally including the user's inherited 2230 * organization groups and user groups. System and staged groups are not 2231 * included. 2232 * 2233 * <p> 2234 * Useful when paginating results. Returns a maximum of <code>end - 2235 * start</code> instances. <code>start</code> and <code>end</code> are not 2236 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2237 * refers to the first result in the set. Setting both <code>start</code> 2238 * and <code>end</code> to {@link 2239 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2240 * result set. 2241 * </p> 2242 * 2243 * @param companyId the primary key of the company 2244 * @param parentGroupId the primary key of the parent group 2245 * @param keywords the keywords (space separated), which may occur in the 2246 sites's name, or description (optionally <code>null</code>) 2247 * @param params the finder params (optionally <code>null</code>). To 2248 include the user's inherited organizations and user groups in the 2249 search, add entries having "usersGroups" and 2250 "inherit" as keys mapped to the the user's ID. For more 2251 information see {@link 2252 com.liferay.portal.service.persistence.GroupFinder}. 2253 * @param start the lower bound of the range of groups to return 2254 * @param end the upper bound of the range of groups to return (not 2255 inclusive) 2256 * @return the matching groups ordered by name 2257 */ 2258 @Override 2259 public java.util.List<com.liferay.portal.model.Group> search( 2260 long companyId, long parentGroupId, java.lang.String keywords, 2261 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2262 int start, int end) { 2263 return _groupLocalService.search(companyId, parentGroupId, keywords, 2264 params, start, end); 2265 } 2266 2267 /** 2268 * Returns an ordered range of all the groups belonging to the parent group 2269 * that match the keywords, optionally including the user's inherited 2270 * organization groups and user groups. System and staged groups are not 2271 * included. 2272 * 2273 * <p> 2274 * Useful when paginating results. Returns a maximum of <code>end - 2275 * start</code> instances. <code>start</code> and <code>end</code> are not 2276 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2277 * refers to the first result in the set. Setting both <code>start</code> 2278 * and <code>end</code> to {@link 2279 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2280 * result set. 2281 * </p> 2282 * 2283 * @param companyId the primary key of the company 2284 * @param parentGroupId the primary key of the parent group 2285 * @param keywords the keywords (space separated), which may occur in the 2286 sites's name, or description (optionally <code>null</code>) 2287 * @param params the finder params (optionally <code>null</code>). To 2288 include the user's inherited organizations and user groups in the 2289 search, add entries having "usersGroups" and 2290 "inherit" as keys mapped to the the user's ID. For more 2291 information see {@link 2292 com.liferay.portal.service.persistence.GroupFinder}. 2293 * @param start the lower bound of the range of groups to return 2294 * @param end the upper bound of the range of groups to return (not 2295 inclusive) 2296 * @param obc the comparator to order the groups (optionally 2297 <code>null</code>) 2298 * @return the matching groups ordered by comparator <code>obc</code> 2299 */ 2300 @Override 2301 public java.util.List<com.liferay.portal.model.Group> search( 2302 long companyId, long parentGroupId, java.lang.String keywords, 2303 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2304 int start, int end, 2305 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 2306 return _groupLocalService.search(companyId, parentGroupId, keywords, 2307 params, start, end, obc); 2308 } 2309 2310 /** 2311 * Returns an ordered range of all the site groups belonging to the parent 2312 * group and organization groups that match the name and description, 2313 * optionally including the user's inherited organization groups and user 2314 * groups. System and staged groups are not included. 2315 * 2316 * <p> 2317 * Useful when paginating results. Returns a maximum of <code>end - 2318 * start</code> instances. <code>start</code> and <code>end</code> are not 2319 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2320 * refers to the first result in the set. Setting both <code>start</code> 2321 * and <code>end</code> to {@link 2322 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2323 * result set. 2324 * </p> 2325 * 2326 * @param companyId the primary key of the company 2327 * @param parentGroupId the primary key of the parent group 2328 * @param name the group's name (optionally <code>null</code>) 2329 * @param description the group's description (optionally 2330 <code>null</code>) 2331 * @param params the finder params (optionally <code>null</code>). To 2332 include the user's inherited organizations and user groups in the 2333 search, add entries having "usersGroups" and 2334 "inherit" as keys mapped to the the user's ID. For more 2335 information see {@link 2336 com.liferay.portal.service.persistence.GroupFinder}. 2337 * @param andOperator whether every field must match its keywords, or just 2338 one field. 2339 * @param start the lower bound of the range of groups to return 2340 * @param end the upper bound of the range of groups to return (not 2341 inclusive) 2342 * @return the matching groups ordered by name 2343 */ 2344 @Override 2345 public java.util.List<com.liferay.portal.model.Group> search( 2346 long companyId, long parentGroupId, java.lang.String name, 2347 java.lang.String description, 2348 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2349 boolean andOperator, int start, int end) { 2350 return _groupLocalService.search(companyId, parentGroupId, name, 2351 description, params, andOperator, start, end); 2352 } 2353 2354 /** 2355 * Returns an ordered range of all the site groups belonging to the parent 2356 * group and organization groups that match the name and description, 2357 * optionally including the user's inherited organization groups and user 2358 * groups. System and staged groups are not included. 2359 * 2360 * <p> 2361 * Useful when paginating results. Returns a maximum of <code>end - 2362 * start</code> instances. <code>start</code> and <code>end</code> are not 2363 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2364 * refers to the first result in the set. Setting both <code>start</code> 2365 * and <code>end</code> to {@link 2366 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2367 * result set. 2368 * </p> 2369 * 2370 * @param companyId the primary key of the company 2371 * @param parentGroupId the primary key of the parent group 2372 * @param name the group's name (optionally <code>null</code>) 2373 * @param description the group's description (optionally 2374 <code>null</code>) 2375 * @param params the finder params (optionally <code>null</code>). To 2376 include the user's inherited organizations and user groups in the 2377 search, add entries having "usersGroups" and 2378 "inherit" as keys mapped to the the user's ID. For more 2379 information see {@link 2380 com.liferay.portal.service.persistence.GroupFinder}. 2381 * @param andOperator whether every field must match its keywords, or just 2382 one field. 2383 * @param start the lower bound of the range of groups to return 2384 * @param end the upper bound of the range of groups to return (not 2385 inclusive) 2386 * @param obc the comparator to order the groups (optionally 2387 <code>null</code>) 2388 * @return the matching groups ordered by comparator <code>obc</code> 2389 */ 2390 @Override 2391 public java.util.List<com.liferay.portal.model.Group> search( 2392 long companyId, long parentGroupId, java.lang.String name, 2393 java.lang.String description, 2394 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2395 boolean andOperator, int start, int end, 2396 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) { 2397 return _groupLocalService.search(companyId, parentGroupId, name, 2398 description, params, andOperator, start, end, obc); 2399 } 2400 2401 /** 2402 * Returns the number of groups that match the class name IDs, and keywords, 2403 * optionally including the user's inherited organization groups and user 2404 * groups. System and staged groups are not included. 2405 * 2406 * @param companyId the primary key of the company 2407 * @param classNameIds the primary keys of the class names of the entities 2408 the groups are related to (optionally <code>null</code>) 2409 * @param keywords the keywords (space separated), which may occur in the 2410 sites's name, or description (optionally <code>null</code>) 2411 * @param params the finder params (optionally <code>null</code>). To 2412 include the user's inherited organization groups and user groups 2413 in the search, add entries having "usersGroups" and 2414 "inherit" as keys mapped to the the user's ID. For more 2415 information see {@link 2416 com.liferay.portal.service.persistence.GroupFinder}. 2417 * @return the number of matching groups 2418 */ 2419 @Override 2420 public int searchCount(long companyId, long[] classNameIds, 2421 java.lang.String keywords, 2422 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2423 return _groupLocalService.searchCount(companyId, classNameIds, 2424 keywords, params); 2425 } 2426 2427 /** 2428 * Returns the number of groups that match the class name IDs, name, and 2429 * description, optionally including the user's inherited organization 2430 * groups and user groups. System and staged groups are not included. 2431 * 2432 * @param companyId the primary key of the company 2433 * @param classNameIds the primary keys of the class names of the entities 2434 the groups are related to (optionally <code>null</code>) 2435 * @param name the group's name (optionally <code>null</code>) 2436 * @param description the group's description (optionally 2437 <code>null</code>) 2438 * @param params the finder params (optionally <code>null</code>). To 2439 include the user's inherited organization groups and user groups 2440 in the search, add entries having "usersGroups" and 2441 "inherit" as keys mapped to the the user's ID. For more 2442 information see {@link 2443 com.liferay.portal.service.persistence.GroupFinder}. 2444 * @param andOperator whether every field must match its keywords, or just 2445 one field. 2446 * @return the number of matching groups 2447 */ 2448 @Override 2449 public int searchCount(long companyId, long[] classNameIds, 2450 java.lang.String name, java.lang.String description, 2451 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2452 boolean andOperator) { 2453 return _groupLocalService.searchCount(companyId, classNameIds, name, 2454 description, params, andOperator); 2455 } 2456 2457 /** 2458 * Returns the number of groups belonging to the parent group that match the 2459 * class name IDs, and keywords, optionally including the user's inherited 2460 * organization groups and user groups. System and staged groups are not 2461 * included. 2462 * 2463 * @param companyId the primary key of the company 2464 * @param classNameIds the primary keys of the class names of the entities 2465 the groups are related to (optionally <code>null</code>) 2466 * @param parentGroupId the primary key of the parent group 2467 * @param keywords the keywords (space separated), which may occur in the 2468 sites's name, or description (optionally <code>null</code>) 2469 * @param params the finder params (optionally <code>null</code>). To 2470 include the user's inherited organization groups and user groups 2471 in the search, add entries having "usersGroups" and 2472 "inherit" as keys mapped to the the user's ID. For more 2473 information see {@link 2474 com.liferay.portal.service.persistence.GroupFinder}. 2475 * @return the number of matching groups 2476 */ 2477 @Override 2478 public int searchCount(long companyId, long[] classNameIds, 2479 long parentGroupId, java.lang.String keywords, 2480 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2481 return _groupLocalService.searchCount(companyId, classNameIds, 2482 parentGroupId, keywords, params); 2483 } 2484 2485 /** 2486 * Returns the number of groups belonging to the parent group that match the 2487 * class name IDs, name, and description, optionally including the user's 2488 * inherited organization groups and user groups. System and staged groups 2489 * are not included. 2490 * 2491 * @param companyId the primary key of the company 2492 * @param classNameIds the primary keys of the class names of the entities 2493 the groups are related to (optionally <code>null</code>) 2494 * @param parentGroupId the primary key of the parent group 2495 * @param name the group's name (optionally <code>null</code>) 2496 * @param description the group's description (optionally 2497 <code>null</code>) 2498 * @param params the finder params (optionally <code>null</code>). To 2499 include the user's inherited organization groups and user groups 2500 in the search, add entries having "usersGroups" and 2501 "inherit" as keys mapped to the the user's ID. For more 2502 information see {@link 2503 com.liferay.portal.service.persistence.GroupFinder}. 2504 * @param andOperator whether every field must match its keywords, or just 2505 one field. 2506 * @return the number of matching groups 2507 */ 2508 @Override 2509 public int searchCount(long companyId, long[] classNameIds, 2510 long parentGroupId, java.lang.String name, 2511 java.lang.String description, 2512 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2513 boolean andOperator) { 2514 return _groupLocalService.searchCount(companyId, classNameIds, 2515 parentGroupId, name, description, params, andOperator); 2516 } 2517 2518 /** 2519 * Returns the number of groups that match the keywords, optionally 2520 * including the user's inherited organization groups and user groups. 2521 * System and staged groups are not included. 2522 * 2523 * @param companyId the primary key of the company 2524 * @param keywords the keywords (space separated), which may occur in the 2525 sites's name, or description (optionally <code>null</code>) 2526 * @param params the finder params (optionally <code>null</code>). To 2527 include the user's inherited organization groups and user groups 2528 in the search, add entries having "usersGroups" and 2529 "inherit" as keys mapped to the the user's ID. For more 2530 information see {@link 2531 com.liferay.portal.service.persistence.GroupFinder}. 2532 * @return the number of matching groups 2533 */ 2534 @Override 2535 public int searchCount(long companyId, java.lang.String keywords, 2536 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2537 return _groupLocalService.searchCount(companyId, keywords, params); 2538 } 2539 2540 /** 2541 * Returns the number of groups and immediate organization groups that match 2542 * the name and description, optionally including the user's inherited 2543 * organization groups and user groups. System and staged groups are not 2544 * included. 2545 * 2546 * @param companyId the primary key of the company 2547 * @param name the group's name (optionally <code>null</code>) 2548 * @param description the group's description (optionally 2549 <code>null</code>) 2550 * @param params the finder params (optionally <code>null</code>). To 2551 include the user's inherited organization groups and user groups 2552 in the search, add entries having "usersGroups" and 2553 "inherit" as keys mapped to the the user's ID. For more 2554 information see {@link 2555 com.liferay.portal.service.persistence.GroupFinder}. 2556 * @param andOperator whether every field must match its keywords, or just 2557 one field. 2558 * @return the number of matching groups 2559 */ 2560 @Override 2561 public int searchCount(long companyId, java.lang.String name, 2562 java.lang.String description, 2563 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2564 boolean andOperator) { 2565 return _groupLocalService.searchCount(companyId, name, description, 2566 params, andOperator); 2567 } 2568 2569 /** 2570 * Returns the number of groups belonging to the parent group that match the 2571 * keywords, optionally including the user's inherited organization groups 2572 * and user groups. System and staged groups are not included. 2573 * 2574 * @param companyId the primary key of the company 2575 * @param parentGroupId the primary key of the parent group 2576 * @param keywords the keywords (space separated), which may occur in the 2577 sites's name, or description (optionally <code>null</code>) 2578 * @param params the finder params (optionally <code>null</code>). To 2579 include the user's inherited organization groups and user groups 2580 in the search, add entries having "usersGroups" and 2581 "inherit" as keys mapped to the the user's ID. For more 2582 information see {@link 2583 com.liferay.portal.service.persistence.GroupFinder}. 2584 * @return the number of matching groups 2585 */ 2586 @Override 2587 public int searchCount(long companyId, long parentGroupId, 2588 java.lang.String keywords, 2589 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2590 return _groupLocalService.searchCount(companyId, parentGroupId, 2591 keywords, params); 2592 } 2593 2594 /** 2595 * Returns the number of groups belonging to the parent group and immediate 2596 * organization groups that match the name and description, optionally 2597 * including the user's inherited organization groups and user groups. 2598 * System and staged groups are not included. 2599 * 2600 * @param companyId the primary key of the company 2601 * @param parentGroupId the primary key of the parent group 2602 * @param name the group's name (optionally <code>null</code>) 2603 * @param description the group's description (optionally 2604 <code>null</code>) 2605 * @param params the finder params (optionally <code>null</code>). To 2606 include the user's inherited organization groups and user groups 2607 in the search, add entries having "usersGroups" and 2608 "inherit" as keys mapped to the the user's ID. For more 2609 information see {@link 2610 com.liferay.portal.service.persistence.GroupFinder}. 2611 * @param andOperator whether every field must match its keywords, or just 2612 one field. 2613 * @return the number of matching groups 2614 */ 2615 @Override 2616 public int searchCount(long companyId, long parentGroupId, 2617 java.lang.String name, java.lang.String description, 2618 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2619 boolean andOperator) { 2620 return _groupLocalService.searchCount(companyId, parentGroupId, name, 2621 description, params, andOperator); 2622 } 2623 2624 /** 2625 * Sets the Spring bean ID for this bean. 2626 * 2627 * @param beanIdentifier the Spring bean ID for this bean 2628 */ 2629 @Override 2630 public void setBeanIdentifier(java.lang.String beanIdentifier) { 2631 _groupLocalService.setBeanIdentifier(beanIdentifier); 2632 } 2633 2634 @Override 2635 public void setOrganizationGroups(long organizationId, long[] groupIds) { 2636 _groupLocalService.setOrganizationGroups(organizationId, groupIds); 2637 } 2638 2639 @Override 2640 public void setRoleGroups(long roleId, long[] groupIds) { 2641 _groupLocalService.setRoleGroups(roleId, groupIds); 2642 } 2643 2644 @Override 2645 public void setUserGroupGroups(long userGroupId, long[] groupIds) { 2646 _groupLocalService.setUserGroupGroups(userGroupId, groupIds); 2647 } 2648 2649 @Override 2650 public void setUserGroups(long userId, long[] groupIds) { 2651 _groupLocalService.setUserGroups(userId, groupIds); 2652 } 2653 2654 /** 2655 * Removes the groups from the role. 2656 * 2657 * @param roleId the primary key of the role 2658 * @param groupIds the primary keys of the groups 2659 */ 2660 @Override 2661 public void unsetRoleGroups(long roleId, long[] groupIds) { 2662 _groupLocalService.unsetRoleGroups(roleId, groupIds); 2663 } 2664 2665 /** 2666 * Removes the user from the groups. 2667 * 2668 * @param userId the primary key of the user 2669 * @param groupIds the primary keys of the groups 2670 */ 2671 @Override 2672 public void unsetUserGroups(long userId, long[] groupIds) { 2673 _groupLocalService.unsetUserGroups(userId, groupIds); 2674 } 2675 2676 /** 2677 * Updates the group's asset replacing categories and tag names. 2678 * 2679 * @param userId the primary key of the user 2680 * @param group the group 2681 * @param assetCategoryIds the primary keys of the asset categories 2682 (optionally <code>null</code>) 2683 * @param assetTagNames the asset tag names (optionally <code>null</code>) 2684 * @throws PortalException if a user with the primary key could not be found 2685 */ 2686 @Override 2687 public void updateAsset(long userId, com.liferay.portal.model.Group group, 2688 long[] assetCategoryIds, java.lang.String[] assetTagNames) 2689 throws com.liferay.portal.kernel.exception.PortalException { 2690 _groupLocalService.updateAsset(userId, group, assetCategoryIds, 2691 assetTagNames); 2692 } 2693 2694 /** 2695 * Updates the group's friendly URL. 2696 * 2697 * @param groupId the primary key of the group 2698 * @param friendlyURL the group's new friendlyURL (optionally 2699 <code>null</code>) 2700 * @return the group 2701 * @throws PortalException if a group with the primary key could not be 2702 found or if a valid friendly URL could not be created for the 2703 group 2704 */ 2705 @Override 2706 public com.liferay.portal.model.Group updateFriendlyURL(long groupId, 2707 java.lang.String friendlyURL) 2708 throws com.liferay.portal.kernel.exception.PortalException { 2709 return _groupLocalService.updateFriendlyURL(groupId, friendlyURL); 2710 } 2711 2712 /** 2713 * Updates the group in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 2714 * 2715 * @param group the group 2716 * @return the group that was updated 2717 */ 2718 @Override 2719 public com.liferay.portal.model.Group updateGroup( 2720 com.liferay.portal.model.Group group) { 2721 return _groupLocalService.updateGroup(group); 2722 } 2723 2724 /** 2725 * Updates the group. 2726 * 2727 * @param groupId the primary key of the group 2728 * @param parentGroupId the primary key of the parent group 2729 * @param name the name's key 2730 * @param description the group's new description (optionally 2731 <code>null</code>) 2732 * @param type the group's new type. For more information see {@link 2733 GroupConstants}. 2734 * @param manualMembership whether manual membership is allowed for the 2735 group 2736 * @param membershipRestriction the group's membership restriction. For 2737 more information see {@link GroupConstants}. 2738 * @param friendlyURL the group's new friendlyURL (optionally 2739 <code>null</code>) 2740 * @param active whether the group is active 2741 * @param serviceContext the service context to be applied (optionally 2742 <code>null</code>). Can set asset category IDs and asset tag 2743 names for the group. 2744 * @return the group 2745 * @throws PortalException if a group with the primary key could not be 2746 found or if the friendly URL was invalid or could one not be 2747 created 2748 * @deprecated As of 7.0.0, replaced by {@link #updateGroup(long, long, Map, 2749 Map, int, boolean, int, String, boolean, boolean, 2750 ServiceContext)} 2751 */ 2752 @Deprecated 2753 @Override 2754 public com.liferay.portal.model.Group updateGroup(long groupId, 2755 long parentGroupId, java.lang.String name, 2756 java.lang.String description, int type, boolean manualMembership, 2757 int membershipRestriction, java.lang.String friendlyURL, 2758 boolean inheritContent, boolean active, 2759 com.liferay.portal.service.ServiceContext serviceContext) 2760 throws com.liferay.portal.kernel.exception.PortalException { 2761 return _groupLocalService.updateGroup(groupId, parentGroupId, name, 2762 description, type, manualMembership, membershipRestriction, 2763 friendlyURL, inheritContent, active, serviceContext); 2764 } 2765 2766 @Override 2767 public com.liferay.portal.model.Group updateGroup(long groupId, 2768 long parentGroupId, 2769 java.util.Map<java.util.Locale, java.lang.String> nameMap, 2770 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 2771 int type, boolean manualMembership, int membershipRestriction, 2772 java.lang.String friendlyURL, boolean inheritContent, boolean active, 2773 com.liferay.portal.service.ServiceContext serviceContext) 2774 throws com.liferay.portal.kernel.exception.PortalException { 2775 return _groupLocalService.updateGroup(groupId, parentGroupId, nameMap, 2776 descriptionMap, type, manualMembership, membershipRestriction, 2777 friendlyURL, inheritContent, active, serviceContext); 2778 } 2779 2780 /** 2781 * Updates the group's type settings. 2782 * 2783 * @param groupId the primary key of the group 2784 * @param typeSettings the group's new type settings (optionally 2785 <code>null</code>) 2786 * @return the group 2787 * @throws PortalException if a group with the primary key could not be 2788 found 2789 */ 2790 @Override 2791 public com.liferay.portal.model.Group updateGroup(long groupId, 2792 java.lang.String typeSettings) 2793 throws com.liferay.portal.kernel.exception.PortalException { 2794 return _groupLocalService.updateGroup(groupId, typeSettings); 2795 } 2796 2797 /** 2798 * Associates the group with a main site if the group is an organization. 2799 * 2800 * @param groupId the primary key of the group 2801 * @param site whether the group is to be associated with a main site 2802 * @return the group 2803 * @throws PortalException if a group with the primary key could not be 2804 found 2805 */ 2806 @Override 2807 public com.liferay.portal.model.Group updateSite(long groupId, boolean site) 2808 throws com.liferay.portal.kernel.exception.PortalException { 2809 return _groupLocalService.updateSite(groupId, site); 2810 } 2811 2812 /** 2813 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 2814 */ 2815 @Deprecated 2816 public GroupLocalService getWrappedGroupLocalService() { 2817 return _groupLocalService; 2818 } 2819 2820 /** 2821 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 2822 */ 2823 @Deprecated 2824 public void setWrappedGroupLocalService(GroupLocalService groupLocalService) { 2825 _groupLocalService = groupLocalService; 2826 } 2827 2828 @Override 2829 public GroupLocalService getWrappedService() { 2830 return _groupLocalService; 2831 } 2832 2833 @Override 2834 public void setWrappedService(GroupLocalService groupLocalService) { 2835 _groupLocalService = groupLocalService; 2836 } 2837 2838 private GroupLocalService _groupLocalService; 2839 }