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