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.portlet.dynamicdatamapping.service; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.ServiceWrapper; 020 021 /** 022 * Provides a wrapper for {@link DDMStructureLocalService}. 023 * 024 * @author Brian Wing Shun Chan 025 * @see DDMStructureLocalService 026 * @generated 027 */ 028 @ProviderType 029 public class DDMStructureLocalServiceWrapper implements DDMStructureLocalService, 030 ServiceWrapper<DDMStructureLocalService> { 031 public DDMStructureLocalServiceWrapper( 032 DDMStructureLocalService ddmStructureLocalService) { 033 _ddmStructureLocalService = ddmStructureLocalService; 034 } 035 036 /** 037 * Adds the d d m structure to the database. Also notifies the appropriate model listeners. 038 * 039 * @param ddmStructure the d d m structure 040 * @return the d d m structure that was added 041 */ 042 @Override 043 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addDDMStructure( 044 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 045 return _ddmStructureLocalService.addDDMStructure(ddmStructure); 046 } 047 048 @Override 049 public void addDLFileEntryTypeDDMStructure(long fileEntryTypeId, 050 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 051 _ddmStructureLocalService.addDLFileEntryTypeDDMStructure(fileEntryTypeId, 052 ddmStructure); 053 } 054 055 @Override 056 public void addDLFileEntryTypeDDMStructure(long fileEntryTypeId, 057 long structureId) { 058 _ddmStructureLocalService.addDLFileEntryTypeDDMStructure(fileEntryTypeId, 059 structureId); 060 } 061 062 @Override 063 public void addDLFileEntryTypeDDMStructures(long fileEntryTypeId, 064 java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) { 065 _ddmStructureLocalService.addDLFileEntryTypeDDMStructures(fileEntryTypeId, 066 DDMStructures); 067 } 068 069 @Override 070 public void addDLFileEntryTypeDDMStructures(long fileEntryTypeId, 071 long[] structureIds) { 072 _ddmStructureLocalService.addDLFileEntryTypeDDMStructures(fileEntryTypeId, 073 structureIds); 074 } 075 076 @Override 077 public void addJournalFolderDDMStructure(long folderId, 078 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 079 _ddmStructureLocalService.addJournalFolderDDMStructure(folderId, 080 ddmStructure); 081 } 082 083 @Override 084 public void addJournalFolderDDMStructure(long folderId, long structureId) { 085 _ddmStructureLocalService.addJournalFolderDDMStructure(folderId, 086 structureId); 087 } 088 089 @Override 090 public void addJournalFolderDDMStructures(long folderId, 091 java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) { 092 _ddmStructureLocalService.addJournalFolderDDMStructures(folderId, 093 DDMStructures); 094 } 095 096 @Override 097 public void addJournalFolderDDMStructures(long folderId, long[] structureIds) { 098 _ddmStructureLocalService.addJournalFolderDDMStructures(folderId, 099 structureIds); 100 } 101 102 /** 103 * Adds a structure referencing a default parent structure, using the portal 104 * property <code>dynamic.data.lists.storage.type</code> storage type and 105 * default structure type. 106 * 107 * @param userId the primary key of the structure's creator/owner 108 * @param groupId the primary key of the group 109 * @param classNameId the primary key of the class name for the structure's 110 related model 111 * @param nameMap the structure's locales and localized names 112 * @param descriptionMap the structure's locales and localized descriptions 113 * @param definition the structure's XML schema definition 114 * @param serviceContext the service context to be applied. Can set the 115 UUID, creation date, modification date, guest permissions, and 116 group permissions for the structure. 117 * @return the structure 118 * @throws PortalException if a user with the primary key could not be 119 found, if the XSD was not well-formed, or if a portal exception 120 occurred 121 */ 122 @Override 123 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure( 124 long userId, long groupId, long classNameId, 125 java.util.Map<java.util.Locale, java.lang.String> nameMap, 126 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 127 java.lang.String definition, 128 com.liferay.portal.service.ServiceContext serviceContext) 129 throws com.liferay.portal.kernel.exception.PortalException { 130 return _ddmStructureLocalService.addStructure(userId, groupId, 131 classNameId, nameMap, descriptionMap, definition, serviceContext); 132 } 133 134 /** 135 * Adds a structure referencing its parent structure. 136 * 137 * @param userId the primary key of the structure's creator/owner 138 * @param groupId the primary key of the group 139 * @param parentStructureId the primary key of the parent structure 140 (optionally {@link 141 com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants#DEFAULT_PARENT_STRUCTURE_ID}) 142 * @param classNameId the primary key of the class name for the structure's 143 related model 144 * @param structureKey the unique string identifying the structure 145 (optionally <code>null</code>) 146 * @param nameMap the structure's locales and localized names 147 * @param descriptionMap the structure's locales and localized descriptions 148 * @param definition the structure's XML schema definition 149 * @param storageType the structure's storage type. It can be "xml" or 150 "expando". For more information, see {@link 151 com.liferay.portlet.dynamicdatamapping.storage.StorageType}. 152 * @param type the structure's type. For more information, see {@link 153 com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}. 154 * @param serviceContext the service context to be applied. Can set the 155 UUID, creation date, modification date, guest permissions, and 156 group permissions for the structure. 157 * @return the structure 158 * @throws PortalException if a user with the primary key could not be 159 found, if the XSD was not well-formed, or if a portal exception 160 occurred 161 */ 162 @Override 163 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure( 164 long userId, long groupId, long parentStructureId, long classNameId, 165 java.lang.String structureKey, 166 java.util.Map<java.util.Locale, java.lang.String> nameMap, 167 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 168 java.lang.String definition, java.lang.String storageType, int type, 169 com.liferay.portal.service.ServiceContext serviceContext) 170 throws com.liferay.portal.kernel.exception.PortalException { 171 return _ddmStructureLocalService.addStructure(userId, groupId, 172 parentStructureId, classNameId, structureKey, nameMap, 173 descriptionMap, definition, storageType, type, serviceContext); 174 } 175 176 /** 177 * Adds a structure referencing a default parent structure if the parent 178 * structure is not found. 179 * 180 * @param userId the primary key of the structure's creator/owner 181 * @param groupId the primary key of the group 182 * @param parentStructureKey the unique string identifying the parent 183 structure (optionally <code>null</code>) 184 * @param classNameId the primary key of the class name for the structure's 185 related model 186 * @param structureKey the unique string identifying the structure 187 (optionally <code>null</code>) 188 * @param nameMap the structure's locales and localized names 189 * @param descriptionMap the structure's locales and localized descriptions 190 * @param definition the structure's XML schema definition 191 * @param storageType the structure's storage type. It can be "xml" or 192 "expando". For more information, see {@link 193 com.liferay.portlet.dynamicdatamapping.storage.StorageType}. 194 * @param type the structure's type. For more information, see {@link 195 com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}. 196 * @param serviceContext the service context to be applied. Can set the 197 UUID, creation date, modification date, guest permissions and 198 group permissions for the structure. 199 * @return the structure 200 * @throws PortalException if a user with the primary key could not be 201 found, if the XSD was not well-formed, or if a portal exception 202 occurred 203 */ 204 @Override 205 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure( 206 long userId, long groupId, java.lang.String parentStructureKey, 207 long classNameId, java.lang.String structureKey, 208 java.util.Map<java.util.Locale, java.lang.String> nameMap, 209 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 210 java.lang.String definition, java.lang.String storageType, int type, 211 com.liferay.portal.service.ServiceContext serviceContext) 212 throws com.liferay.portal.kernel.exception.PortalException { 213 return _ddmStructureLocalService.addStructure(userId, groupId, 214 parentStructureKey, classNameId, structureKey, nameMap, 215 descriptionMap, definition, storageType, type, serviceContext); 216 } 217 218 /** 219 * Adds the resources to the structure. 220 * 221 * @param structure the structure to add resources to 222 * @param addGroupPermissions whether to add group permissions 223 * @param addGuestPermissions whether to add guest permissions 224 * @throws PortalException if a portal exception occurred 225 */ 226 @Override 227 public void addStructureResources( 228 com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure, 229 boolean addGroupPermissions, boolean addGuestPermissions) 230 throws com.liferay.portal.kernel.exception.PortalException { 231 _ddmStructureLocalService.addStructureResources(structure, 232 addGroupPermissions, addGuestPermissions); 233 } 234 235 /** 236 * Adds the model resources with the permissions to the structure. 237 * 238 * @param structure the structure to add resources to 239 * @param groupPermissions the group permissions to be added 240 * @param guestPermissions the guest permissions to be added 241 * @throws PortalException if a portal exception occurred 242 */ 243 @Override 244 public void addStructureResources( 245 com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure, 246 java.lang.String[] groupPermissions, java.lang.String[] guestPermissions) 247 throws com.liferay.portal.kernel.exception.PortalException { 248 _ddmStructureLocalService.addStructureResources(structure, 249 groupPermissions, guestPermissions); 250 } 251 252 @Override 253 public void clearDLFileEntryTypeDDMStructures(long fileEntryTypeId) { 254 _ddmStructureLocalService.clearDLFileEntryTypeDDMStructures(fileEntryTypeId); 255 } 256 257 @Override 258 public void clearJournalFolderDDMStructures(long folderId) { 259 _ddmStructureLocalService.clearJournalFolderDDMStructures(folderId); 260 } 261 262 /** 263 * Copies a structure, creating a new structure with all the values 264 * extracted from the original one. The new structure supports a new name 265 * and description. 266 * 267 * @param userId the primary key of the structure's creator/owner 268 * @param structureId the primary key of the structure to be copied 269 * @param nameMap the new structure's locales and localized names 270 * @param descriptionMap the new structure's locales and localized 271 descriptions 272 * @param serviceContext the service context to be applied. Can set the 273 UUID, creation date, modification date, guest permissions, and 274 group permissions for the structure. 275 * @return the new structure 276 * @throws PortalException if a portal exception occurred 277 */ 278 @Override 279 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure( 280 long userId, long structureId, 281 java.util.Map<java.util.Locale, java.lang.String> nameMap, 282 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 283 com.liferay.portal.service.ServiceContext serviceContext) 284 throws com.liferay.portal.kernel.exception.PortalException { 285 return _ddmStructureLocalService.copyStructure(userId, structureId, 286 nameMap, descriptionMap, serviceContext); 287 } 288 289 @Override 290 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure( 291 long userId, long structureId, 292 com.liferay.portal.service.ServiceContext serviceContext) 293 throws com.liferay.portal.kernel.exception.PortalException { 294 return _ddmStructureLocalService.copyStructure(userId, structureId, 295 serviceContext); 296 } 297 298 /** 299 * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database. 300 * 301 * @param structureId the primary key for the new d d m structure 302 * @return the new d d m structure 303 */ 304 @Override 305 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure createDDMStructure( 306 long structureId) { 307 return _ddmStructureLocalService.createDDMStructure(structureId); 308 } 309 310 /** 311 * Deletes the d d m structure from the database. Also notifies the appropriate model listeners. 312 * 313 * @param ddmStructure the d d m structure 314 * @return the d d m structure that was removed 315 */ 316 @Override 317 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure deleteDDMStructure( 318 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 319 return _ddmStructureLocalService.deleteDDMStructure(ddmStructure); 320 } 321 322 /** 323 * Deletes the d d m structure with the primary key from the database. Also notifies the appropriate model listeners. 324 * 325 * @param structureId the primary key of the d d m structure 326 * @return the d d m structure that was removed 327 * @throws PortalException if a d d m structure with the primary key could not be found 328 */ 329 @Override 330 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure deleteDDMStructure( 331 long structureId) 332 throws com.liferay.portal.kernel.exception.PortalException { 333 return _ddmStructureLocalService.deleteDDMStructure(structureId); 334 } 335 336 @Override 337 public void deleteDLFileEntryTypeDDMStructure(long fileEntryTypeId, 338 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 339 _ddmStructureLocalService.deleteDLFileEntryTypeDDMStructure(fileEntryTypeId, 340 ddmStructure); 341 } 342 343 @Override 344 public void deleteDLFileEntryTypeDDMStructure(long fileEntryTypeId, 345 long structureId) { 346 _ddmStructureLocalService.deleteDLFileEntryTypeDDMStructure(fileEntryTypeId, 347 structureId); 348 } 349 350 @Override 351 public void deleteDLFileEntryTypeDDMStructures(long fileEntryTypeId, 352 java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) { 353 _ddmStructureLocalService.deleteDLFileEntryTypeDDMStructures(fileEntryTypeId, 354 DDMStructures); 355 } 356 357 @Override 358 public void deleteDLFileEntryTypeDDMStructures(long fileEntryTypeId, 359 long[] structureIds) { 360 _ddmStructureLocalService.deleteDLFileEntryTypeDDMStructures(fileEntryTypeId, 361 structureIds); 362 } 363 364 @Override 365 public void deleteJournalFolderDDMStructure(long folderId, 366 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 367 _ddmStructureLocalService.deleteJournalFolderDDMStructure(folderId, 368 ddmStructure); 369 } 370 371 @Override 372 public void deleteJournalFolderDDMStructure(long folderId, long structureId) { 373 _ddmStructureLocalService.deleteJournalFolderDDMStructure(folderId, 374 structureId); 375 } 376 377 @Override 378 public void deleteJournalFolderDDMStructures(long folderId, 379 java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) { 380 _ddmStructureLocalService.deleteJournalFolderDDMStructures(folderId, 381 DDMStructures); 382 } 383 384 @Override 385 public void deleteJournalFolderDDMStructures(long folderId, 386 long[] structureIds) { 387 _ddmStructureLocalService.deleteJournalFolderDDMStructures(folderId, 388 structureIds); 389 } 390 391 /** 392 * @throws PortalException 393 */ 394 @Override 395 public com.liferay.portal.model.PersistedModel deletePersistedModel( 396 com.liferay.portal.model.PersistedModel persistedModel) 397 throws com.liferay.portal.kernel.exception.PortalException { 398 return _ddmStructureLocalService.deletePersistedModel(persistedModel); 399 } 400 401 /** 402 * Deletes the matching structure and its resources. 403 * 404 * <p> 405 * Before deleting the structure, the system verifies whether the structure 406 * is required by another entity. If it is needed, an exception is thrown. 407 * </p> 408 * 409 * @param groupId the primary key of the group 410 * @param classNameId the primary key of the class name for the structure's 411 related model 412 * @param structureKey the unique string identifying the structure 413 * @throws PortalException if a portal exception occurred 414 */ 415 @Override 416 public void deleteStructure(long groupId, long classNameId, 417 java.lang.String structureKey) 418 throws com.liferay.portal.kernel.exception.PortalException { 419 _ddmStructureLocalService.deleteStructure(groupId, classNameId, 420 structureKey); 421 } 422 423 /** 424 * Deletes the structure and its resources. 425 * 426 * <p> 427 * Before deleting the structure, this method verifies whether the structure 428 * is required by another entity. If it is needed, an exception is thrown. 429 * </p> 430 * 431 * @param structure the structure to be deleted 432 * @throws PortalException if a portal exception occurred 433 */ 434 @Override 435 public void deleteStructure( 436 com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure) 437 throws com.liferay.portal.kernel.exception.PortalException { 438 _ddmStructureLocalService.deleteStructure(structure); 439 } 440 441 /** 442 * Deletes the structure and its resources. 443 * 444 * <p> 445 * Before deleting the structure, the system verifies whether the structure 446 * is required by another entity. If it is needed, an exception is thrown. 447 * </p> 448 * 449 * @param structureId the primary key of the structure to be deleted 450 * @throws PortalException if a portal exception occurred 451 */ 452 @Override 453 public void deleteStructure(long structureId) 454 throws com.liferay.portal.kernel.exception.PortalException { 455 _ddmStructureLocalService.deleteStructure(structureId); 456 } 457 458 /** 459 * Deletes all the structures of the group. 460 * 461 * <p> 462 * Before deleting the structures, the system verifies whether each 463 * structure is required by another entity. If any of the structures are 464 * needed, an exception is thrown. 465 * </p> 466 * 467 * @param groupId the primary key of the group 468 * @throws PortalException if a portal exception occurred 469 */ 470 @Override 471 public void deleteStructures(long groupId) 472 throws com.liferay.portal.kernel.exception.PortalException { 473 _ddmStructureLocalService.deleteStructures(groupId); 474 } 475 476 @Override 477 public void deleteStructures(long groupId, long classNameId) 478 throws com.liferay.portal.kernel.exception.PortalException { 479 _ddmStructureLocalService.deleteStructures(groupId, classNameId); 480 } 481 482 @Override 483 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 484 return _ddmStructureLocalService.dynamicQuery(); 485 } 486 487 /** 488 * Performs a dynamic query on the database and returns the matching rows. 489 * 490 * @param dynamicQuery the dynamic query 491 * @return the matching rows 492 */ 493 @Override 494 public <T> java.util.List<T> dynamicQuery( 495 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 496 return _ddmStructureLocalService.dynamicQuery(dynamicQuery); 497 } 498 499 /** 500 * Performs a dynamic query on the database and returns a range of the matching rows. 501 * 502 * <p> 503 * 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.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 504 * </p> 505 * 506 * @param dynamicQuery the dynamic query 507 * @param start the lower bound of the range of model instances 508 * @param end the upper bound of the range of model instances (not inclusive) 509 * @return the range of matching rows 510 */ 511 @Override 512 public <T> java.util.List<T> dynamicQuery( 513 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 514 int end) { 515 return _ddmStructureLocalService.dynamicQuery(dynamicQuery, start, end); 516 } 517 518 /** 519 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 520 * 521 * <p> 522 * 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.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 523 * </p> 524 * 525 * @param dynamicQuery the dynamic query 526 * @param start the lower bound of the range of model instances 527 * @param end the upper bound of the range of model instances (not inclusive) 528 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 529 * @return the ordered range of matching rows 530 */ 531 @Override 532 public <T> java.util.List<T> dynamicQuery( 533 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 534 int end, 535 com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) { 536 return _ddmStructureLocalService.dynamicQuery(dynamicQuery, start, end, 537 orderByComparator); 538 } 539 540 /** 541 * Returns the number of rows that match the dynamic query. 542 * 543 * @param dynamicQuery the dynamic query 544 * @return the number of rows that match the dynamic query 545 */ 546 @Override 547 public long dynamicQueryCount( 548 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 549 return _ddmStructureLocalService.dynamicQueryCount(dynamicQuery); 550 } 551 552 /** 553 * Returns the number of rows that match the dynamic query. 554 * 555 * @param dynamicQuery the dynamic query 556 * @param projection the projection to apply to the query 557 * @return the number of rows that match the dynamic query 558 */ 559 @Override 560 public long dynamicQueryCount( 561 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 562 com.liferay.portal.kernel.dao.orm.Projection projection) { 563 return _ddmStructureLocalService.dynamicQueryCount(dynamicQuery, 564 projection); 565 } 566 567 @Override 568 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchDDMStructure( 569 long structureId) { 570 return _ddmStructureLocalService.fetchDDMStructure(structureId); 571 } 572 573 /** 574 * Returns the d d m structure matching the UUID and group. 575 * 576 * @param uuid the d d m structure's UUID 577 * @param groupId the primary key of the group 578 * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 579 */ 580 @Override 581 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchDDMStructureByUuidAndGroupId( 582 java.lang.String uuid, long groupId) { 583 return _ddmStructureLocalService.fetchDDMStructureByUuidAndGroupId(uuid, 584 groupId); 585 } 586 587 /** 588 * Returns the structure matching the class name ID, structure key, and 589 * group. 590 * 591 * @param groupId the primary key of the group 592 * @param classNameId the primary key of the class name for the structure's 593 related model 594 * @param structureKey the unique string identifying the structure 595 * @return the matching structure, or <code>null</code> if a matching 596 structure could not be found 597 */ 598 @Override 599 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure( 600 long groupId, long classNameId, java.lang.String structureKey) { 601 return _ddmStructureLocalService.fetchStructure(groupId, classNameId, 602 structureKey); 603 } 604 605 /** 606 * Returns the structure matching the class name ID, structure key, and 607 * group, optionally searching ancestor sites (that have sharing enabled) 608 * and global scoped sites. 609 * 610 * <p> 611 * This method first searches in the group. If the structure is still not 612 * found and <code>includeAncestorStructures</code> is set to 613 * <code>true</code>, this method searches the group's ancestor sites (that 614 * have sharing enabled) and lastly searches global scoped sites. 615 * </p> 616 * 617 * @param groupId the primary key of the group 618 * @param classNameId the primary key of the class name for the structure's 619 related model 620 * @param structureKey the unique string identifying the structure 621 * @param includeAncestorStructures whether to include ancestor sites (that 622 have sharing enabled) and include global scoped sites in the 623 search 624 * @return the matching structure, or <code>null</code> if a matching 625 structure could not be found 626 * @throws PortalException if a portal exception occurred 627 */ 628 @Override 629 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure( 630 long groupId, long classNameId, java.lang.String structureKey, 631 boolean includeAncestorStructures) 632 throws com.liferay.portal.kernel.exception.PortalException { 633 return _ddmStructureLocalService.fetchStructure(groupId, classNameId, 634 structureKey, includeAncestorStructures); 635 } 636 637 /** 638 * Returns the structure with the ID. 639 * 640 * @param structureId the primary key of the structure 641 * @return the structure with the structure ID, or <code>null</code> if a 642 matching structure could not be found 643 */ 644 @Override 645 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure( 646 long structureId) { 647 return _ddmStructureLocalService.fetchStructure(structureId); 648 } 649 650 @Override 651 public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() { 652 return _ddmStructureLocalService.getActionableDynamicQuery(); 653 } 654 655 /** 656 * Returns the Spring bean ID for this bean. 657 * 658 * @return the Spring bean ID for this bean 659 */ 660 @Override 661 public java.lang.String getBeanIdentifier() { 662 return _ddmStructureLocalService.getBeanIdentifier(); 663 } 664 665 /** 666 * @deprecated As of 6.2.0, replaced by {@link #getClassStructures(long, 667 long)} 668 */ 669 @Deprecated 670 @Override 671 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures( 672 long classNameId) { 673 return _ddmStructureLocalService.getClassStructures(classNameId); 674 } 675 676 /** 677 * @deprecated As of 6.2.0, replaced by {@link #getClassStructures(long, 678 long, OrderByComparator)} 679 */ 680 @Deprecated 681 @Override 682 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures( 683 long classNameId, 684 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) { 685 return _ddmStructureLocalService.getClassStructures(classNameId, 686 orderByComparator); 687 } 688 689 /** 690 * @deprecated As of 6.2.0, replaced by {@link #getClassStructures(long, 691 long, int, int)} 692 */ 693 @Deprecated 694 @Override 695 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures( 696 long classNameId, int start, int end) { 697 return _ddmStructureLocalService.getClassStructures(classNameId, start, 698 end); 699 } 700 701 /** 702 * Returns all the structures matching the class name ID. 703 * 704 * @param companyId the primary key of the structure's company 705 * @param classNameId the primary key of the class name for the structure's 706 related model 707 * @return the structures matching the class name ID 708 */ 709 @Override 710 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures( 711 long companyId, long classNameId) { 712 return _ddmStructureLocalService.getClassStructures(companyId, 713 classNameId); 714 } 715 716 /** 717 * Returns all the structures matching the class name ID ordered by the 718 * comparator. 719 * 720 * @param companyId the primary key of the structure's company 721 * @param classNameId the primary key of the class name for the structure's 722 related model 723 * @param orderByComparator the comparator to order the structures 724 (optionally <code>null</code>) 725 * @return the matching structures ordered by the comparator 726 */ 727 @Override 728 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures( 729 long companyId, long classNameId, 730 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) { 731 return _ddmStructureLocalService.getClassStructures(companyId, 732 classNameId, orderByComparator); 733 } 734 735 /** 736 * Returns a range of all the structures matching the class name ID. 737 * 738 * <p> 739 * Useful when paginating results. Returns a maximum of <code>end - 740 * start</code> instances. <code>start</code> and <code>end</code> are not 741 * primary keys, they are indexes in the result set. Thus, <code>0</code> 742 * refers to the first result in the set. Setting both <code>start</code> 743 * and <code>end</code> to {@link 744 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 745 * result set. 746 * </p> 747 * 748 * @param companyId the primary key of the structure's company 749 * @param classNameId the primary key of the class name for the structure's 750 related model 751 * @param start the lower bound of the range of structures to return 752 * @param end the upper bound of the range of structures to return (not 753 inclusive) 754 * @return the range of matching structures 755 */ 756 @Override 757 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures( 758 long companyId, long classNameId, int start, int end) { 759 return _ddmStructureLocalService.getClassStructures(companyId, 760 classNameId, start, end); 761 } 762 763 /** 764 * Returns the d d m structure with the primary key. 765 * 766 * @param structureId the primary key of the d d m structure 767 * @return the d d m structure 768 * @throws PortalException if a d d m structure with the primary key could not be found 769 */ 770 @Override 771 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getDDMStructure( 772 long structureId) 773 throws com.liferay.portal.kernel.exception.PortalException { 774 return _ddmStructureLocalService.getDDMStructure(structureId); 775 } 776 777 /** 778 * Returns the d d m structure matching the UUID and group. 779 * 780 * @param uuid the d d m structure's UUID 781 * @param groupId the primary key of the group 782 * @return the matching d d m structure 783 * @throws PortalException if a matching d d m structure could not be found 784 */ 785 @Override 786 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getDDMStructureByUuidAndGroupId( 787 java.lang.String uuid, long groupId) 788 throws com.liferay.portal.kernel.exception.PortalException { 789 return _ddmStructureLocalService.getDDMStructureByUuidAndGroupId(uuid, 790 groupId); 791 } 792 793 /** 794 * Returns a range of all the d d m structures. 795 * 796 * <p> 797 * 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.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 798 * </p> 799 * 800 * @param start the lower bound of the range of d d m structures 801 * @param end the upper bound of the range of d d m structures (not inclusive) 802 * @return the range of d d m structures 803 */ 804 @Override 805 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures( 806 int start, int end) { 807 return _ddmStructureLocalService.getDDMStructures(start, end); 808 } 809 810 @Override 811 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructuresByUuidAndCompanyId( 812 java.lang.String uuid, long companyId) { 813 return _ddmStructureLocalService.getDDMStructuresByUuidAndCompanyId(uuid, 814 companyId); 815 } 816 817 @Override 818 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructuresByUuidAndCompanyId( 819 java.lang.String uuid, long companyId, int start, int end, 820 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) { 821 return _ddmStructureLocalService.getDDMStructuresByUuidAndCompanyId(uuid, 822 companyId, start, end, orderByComparator); 823 } 824 825 /** 826 * Returns the number of d d m structures. 827 * 828 * @return the number of d d m structures 829 */ 830 @Override 831 public int getDDMStructuresCount() { 832 return _ddmStructureLocalService.getDDMStructuresCount(); 833 } 834 835 @Override 836 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeDDMStructures( 837 long fileEntryTypeId) { 838 return _ddmStructureLocalService.getDLFileEntryTypeDDMStructures(fileEntryTypeId); 839 } 840 841 @Override 842 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeDDMStructures( 843 long fileEntryTypeId, int start, int end) { 844 return _ddmStructureLocalService.getDLFileEntryTypeDDMStructures(fileEntryTypeId, 845 start, end); 846 } 847 848 @Override 849 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeDDMStructures( 850 long fileEntryTypeId, int start, int end, 851 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) { 852 return _ddmStructureLocalService.getDLFileEntryTypeDDMStructures(fileEntryTypeId, 853 start, end, orderByComparator); 854 } 855 856 @Override 857 public int getDLFileEntryTypeDDMStructuresCount(long fileEntryTypeId) { 858 return _ddmStructureLocalService.getDLFileEntryTypeDDMStructuresCount(fileEntryTypeId); 859 } 860 861 /** 862 * Returns the fileEntryTypeIds of the document library file entry types associated with the d d m structure. 863 * 864 * @param structureId the structureId of the d d m structure 865 * @return long[] the fileEntryTypeIds of document library file entry types associated with the d d m structure 866 */ 867 @Override 868 public long[] getDLFileEntryTypePrimaryKeys(long structureId) { 869 return _ddmStructureLocalService.getDLFileEntryTypePrimaryKeys(structureId); 870 } 871 872 /** 873 * Returns all the structures for the document library file entry type. 874 * 875 * @param dlFileEntryTypeId the primary key of the document library file 876 entry type 877 * @return the structures for the document library file entry type 878 */ 879 @Override 880 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeStructures( 881 long dlFileEntryTypeId) { 882 return _ddmStructureLocalService.getDLFileEntryTypeStructures(dlFileEntryTypeId); 883 } 884 885 @Override 886 public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery( 887 com.liferay.portal.kernel.lar.PortletDataContext portletDataContext) { 888 return _ddmStructureLocalService.getExportActionableDynamicQuery(portletDataContext); 889 } 890 891 @Override 892 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderDDMStructures( 893 long folderId) { 894 return _ddmStructureLocalService.getJournalFolderDDMStructures(folderId); 895 } 896 897 @Override 898 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderDDMStructures( 899 long folderId, int start, int end) { 900 return _ddmStructureLocalService.getJournalFolderDDMStructures(folderId, 901 start, end); 902 } 903 904 @Override 905 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderDDMStructures( 906 long folderId, int start, int end, 907 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) { 908 return _ddmStructureLocalService.getJournalFolderDDMStructures(folderId, 909 start, end, orderByComparator); 910 } 911 912 @Override 913 public int getJournalFolderDDMStructuresCount(long folderId) { 914 return _ddmStructureLocalService.getJournalFolderDDMStructuresCount(folderId); 915 } 916 917 /** 918 * Returns the folderIds of the journal folders associated with the d d m structure. 919 * 920 * @param structureId the structureId of the d d m structure 921 * @return long[] the folderIds of journal folders associated with the d d m structure 922 */ 923 @Override 924 public long[] getJournalFolderPrimaryKeys(long structureId) { 925 return _ddmStructureLocalService.getJournalFolderPrimaryKeys(structureId); 926 } 927 928 @Override 929 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderStructures( 930 long[] groupIds, long journalFolderId, int restrictionType) 931 throws com.liferay.portal.kernel.exception.PortalException { 932 return _ddmStructureLocalService.getJournalFolderStructures(groupIds, 933 journalFolderId, restrictionType); 934 } 935 936 @Override 937 public com.liferay.portal.model.PersistedModel getPersistedModel( 938 java.io.Serializable primaryKeyObj) 939 throws com.liferay.portal.kernel.exception.PortalException { 940 return _ddmStructureLocalService.getPersistedModel(primaryKeyObj); 941 } 942 943 /** 944 * Returns the structure matching the class name ID, structure key, and 945 * group. 946 * 947 * @param groupId the primary key of the structure's group 948 * @param classNameId the primary key of the class name for the structure's 949 related model 950 * @param structureKey the unique string identifying the structure 951 * @return the matching structure 952 * @throws PortalException if a matching structure could not be found 953 */ 954 @Override 955 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure( 956 long groupId, long classNameId, java.lang.String structureKey) 957 throws com.liferay.portal.kernel.exception.PortalException { 958 return _ddmStructureLocalService.getStructure(groupId, classNameId, 959 structureKey); 960 } 961 962 /** 963 * Returns the structure matching the class name ID, structure key, and 964 * group, optionally searching ancestor sites (that have sharing enabled) 965 * and global scoped sites. 966 * 967 * <p> 968 * This method first searches in the group. If the structure is still not 969 * found and <code>includeAncestorStructures</code> is set to 970 * <code>true</code>, this method searches the group's ancestor sites (that 971 * have sharing enabled) and lastly searches global scoped sites. 972 * </p> 973 * 974 * @param groupId the primary key of the structure's group 975 * @param classNameId the primary key of the class name for the structure's 976 related model 977 * @param structureKey the unique string identifying the structure 978 * @param includeAncestorStructures whether to include ancestor sites (that 979 have sharing enabled) and include global scoped sites in the 980 search in the search 981 * @return the matching structure 982 * @throws PortalException if a matching structure could not be found 983 */ 984 @Override 985 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure( 986 long groupId, long classNameId, java.lang.String structureKey, 987 boolean includeAncestorStructures) 988 throws com.liferay.portal.kernel.exception.PortalException { 989 return _ddmStructureLocalService.getStructure(groupId, classNameId, 990 structureKey, includeAncestorStructures); 991 } 992 993 /** 994 * Returns all the structures matching the group, name, and description. 995 * 996 * @param groupId the primary key of the structure's group 997 * @param name the structure's name 998 * @param description the structure's description 999 * @return the matching structures 1000 */ 1001 @Override 1002 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructure( 1003 long groupId, java.lang.String name, java.lang.String description) { 1004 return _ddmStructureLocalService.getStructure(groupId, name, description); 1005 } 1006 1007 /** 1008 * Returns the structure with the ID. 1009 * 1010 * @param structureId the primary key of the structure 1011 * @return the structure with the ID 1012 * @throws PortalException if a structure with the ID could not be found 1013 */ 1014 @Override 1015 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure( 1016 long structureId) 1017 throws com.liferay.portal.kernel.exception.PortalException { 1018 return _ddmStructureLocalService.getStructure(structureId); 1019 } 1020 1021 /** 1022 * @deprecated As of 6.2.0, replaced by {@link #getStructures} 1023 */ 1024 @Deprecated 1025 @Override 1026 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries() { 1027 return _ddmStructureLocalService.getStructureEntries(); 1028 } 1029 1030 /** 1031 * @deprecated As of 6.2.0, replaced by {@link #getStructures(long)} 1032 */ 1033 @Deprecated 1034 @Override 1035 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries( 1036 long groupId) { 1037 return _ddmStructureLocalService.getStructureEntries(groupId); 1038 } 1039 1040 /** 1041 * @deprecated As of 6.2.0, replaced by {@link #getStructures(long, int, 1042 int)} 1043 */ 1044 @Deprecated 1045 @Override 1046 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries( 1047 long groupId, int start, int end) { 1048 return _ddmStructureLocalService.getStructureEntries(groupId, start, end); 1049 } 1050 1051 /** 1052 * Returns all the structures present in the system. 1053 * 1054 * @return the structures present in the system 1055 */ 1056 @Override 1057 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures() { 1058 return _ddmStructureLocalService.getStructures(); 1059 } 1060 1061 /** 1062 * Returns all the structures present in the group. 1063 * 1064 * @param groupId the primary key of the group 1065 * @return the structures present in the group 1066 */ 1067 @Override 1068 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures( 1069 long groupId) { 1070 return _ddmStructureLocalService.getStructures(groupId); 1071 } 1072 1073 /** 1074 * Returns all the structures matching class name ID and group. 1075 * 1076 * @param groupId the primary key of the group 1077 * @param classNameId the primary key of the class name for the structure's 1078 related model 1079 * @return the matching structures 1080 */ 1081 @Override 1082 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures( 1083 long groupId, long classNameId) { 1084 return _ddmStructureLocalService.getStructures(groupId, classNameId); 1085 } 1086 1087 /** 1088 * Returns a range of all the structures that match the class name ID and 1089 * group. 1090 * 1091 * <p> 1092 * Useful when paginating results. Returns a maximum of <code>end - 1093 * start</code> instances. <code>start</code> and <code>end</code> are not 1094 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1095 * refers to the first result in the set. Setting both <code>start</code> 1096 * and <code>end</code> to {@link 1097 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1098 * result set. 1099 * </p> 1100 * 1101 * @param groupId the primary key of the group 1102 * @param classNameId the primary key of the class name for the structure's 1103 related model 1104 * @param start the lower bound of the range of structures to return 1105 * @param end the upper bound of the range of structures to return (not 1106 inclusive) 1107 * @return the range of matching structures 1108 */ 1109 @Override 1110 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures( 1111 long groupId, long classNameId, int start, int end) { 1112 return _ddmStructureLocalService.getStructures(groupId, classNameId, 1113 start, end); 1114 } 1115 1116 /** 1117 * Returns an ordered range of all the structures matching the class name ID 1118 * and group. 1119 * 1120 * <p> 1121 * Useful when paginating results. Returns a maximum of <code>end - 1122 * start</code> instances. <code>start</code> and <code>end</code> are not 1123 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1124 * refers to the first result in the set. Setting both <code>start</code> 1125 * and <code>end</code> to {@link 1126 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1127 * result set. 1128 * </p> 1129 * 1130 * @param groupId the primary key of the group 1131 * @param classNameId the primary key of the class name for the structure's 1132 related model 1133 * @param start the lower bound of the range of structures to return 1134 * @param end the upper bound of the range of structures to return (not 1135 inclusive) 1136 * @param orderByComparator the comparator to order the structures 1137 (optionally <code>null</code>) 1138 * @return the range of matching structures ordered by the comparator 1139 */ 1140 @Override 1141 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures( 1142 long groupId, long classNameId, int start, int end, 1143 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) { 1144 return _ddmStructureLocalService.getStructures(groupId, classNameId, 1145 start, end, orderByComparator); 1146 } 1147 1148 @Override 1149 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures( 1150 long groupId, java.lang.String name, java.lang.String description) { 1151 return _ddmStructureLocalService.getStructures(groupId, name, 1152 description); 1153 } 1154 1155 /** 1156 * Returns a range of all the structures belonging to the group. 1157 * 1158 * <p> 1159 * Useful when paginating results. Returns a maximum of <code>end - 1160 * start</code> instances. <code>start</code> and <code>end</code> are not 1161 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1162 * refers to the first result in the set. Setting both <code>start</code> 1163 * and <code>end</code> to {@link 1164 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1165 * result set. 1166 * </p> 1167 * 1168 * @param groupId the primary key of the group 1169 * @param start the lower bound of the range of structures to return 1170 * @param end the upper bound of the range of structures to return (not 1171 inclusive) 1172 * @return the range of matching structures 1173 */ 1174 @Override 1175 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures( 1176 long groupId, int start, int end) { 1177 return _ddmStructureLocalService.getStructures(groupId, start, end); 1178 } 1179 1180 /** 1181 * Returns all the structures belonging to the groups. 1182 * 1183 * @param groupIds the primary keys of the groups 1184 * @return the structures belonging to the groups 1185 */ 1186 @Override 1187 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures( 1188 long[] groupIds) { 1189 return _ddmStructureLocalService.getStructures(groupIds); 1190 } 1191 1192 /** 1193 * Returns all the structures matching the class name ID and belonging to 1194 * the groups. 1195 * 1196 * @param groupIds the primary keys of the groups 1197 * @param classNameId the primary key of the class name for the structure's 1198 related model 1199 * @return the matching structures 1200 */ 1201 @Override 1202 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures( 1203 long[] groupIds, long classNameId) { 1204 return _ddmStructureLocalService.getStructures(groupIds, classNameId); 1205 } 1206 1207 /** 1208 * Returns a range of all the structures matching the class name ID and 1209 * belonging to the groups. 1210 * 1211 * <p> 1212 * Useful when paginating results. Returns a maximum of <code>end - 1213 * start</code> instances. <code>start</code> and <code>end</code> are not 1214 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1215 * refers to the first result in the set. Setting both <code>start</code> 1216 * and <code>end</code> to {@link 1217 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1218 * result set. 1219 * </p> 1220 * 1221 * @param groupIds the primary keys of the groups 1222 * @param classNameId the primary key of the class name for the structure's 1223 related model 1224 * @param start the lower bound of the range of structures to return 1225 * @param end the upper bound of the range of structures to return (not 1226 inclusive) 1227 * @return the range of matching structures 1228 */ 1229 @Override 1230 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures( 1231 long[] groupIds, long classNameId, int start, int end) { 1232 return _ddmStructureLocalService.getStructures(groupIds, classNameId, 1233 start, end); 1234 } 1235 1236 /** 1237 * Returns the number of structures belonging to the group. 1238 * 1239 * @param groupId the primary key of the group 1240 * @return the number of structures belonging to the group 1241 */ 1242 @Override 1243 public int getStructuresCount(long groupId) { 1244 return _ddmStructureLocalService.getStructuresCount(groupId); 1245 } 1246 1247 /** 1248 * Returns the number of structures matching the class name ID and group. 1249 * 1250 * @param groupId the primary key of the group 1251 * @param classNameId the primary key of the class name for the structure's 1252 related model 1253 * @return the number of matching structures 1254 */ 1255 @Override 1256 public int getStructuresCount(long groupId, long classNameId) { 1257 return _ddmStructureLocalService.getStructuresCount(groupId, classNameId); 1258 } 1259 1260 /** 1261 * Returns the number of structures matching the class name ID and belonging 1262 * to the groups. 1263 * 1264 * @param groupIds the primary keys of the groups 1265 * @param classNameId the primary key of the class name for the structure's 1266 related model 1267 * @return the number of matching structures 1268 */ 1269 @Override 1270 public int getStructuresCount(long[] groupIds, long classNameId) { 1271 return _ddmStructureLocalService.getStructuresCount(groupIds, 1272 classNameId); 1273 } 1274 1275 @Override 1276 public boolean hasDLFileEntryTypeDDMStructure(long fileEntryTypeId, 1277 long structureId) { 1278 return _ddmStructureLocalService.hasDLFileEntryTypeDDMStructure(fileEntryTypeId, 1279 structureId); 1280 } 1281 1282 @Override 1283 public boolean hasDLFileEntryTypeDDMStructures(long fileEntryTypeId) { 1284 return _ddmStructureLocalService.hasDLFileEntryTypeDDMStructures(fileEntryTypeId); 1285 } 1286 1287 @Override 1288 public boolean hasJournalFolderDDMStructure(long folderId, long structureId) { 1289 return _ddmStructureLocalService.hasJournalFolderDDMStructure(folderId, 1290 structureId); 1291 } 1292 1293 @Override 1294 public boolean hasJournalFolderDDMStructures(long folderId) { 1295 return _ddmStructureLocalService.hasJournalFolderDDMStructures(folderId); 1296 } 1297 1298 /** 1299 * Returns an ordered range of all the structures matching the groups and 1300 * class name IDs, and matching the keywords in the structure names and 1301 * descriptions. 1302 * 1303 * <p> 1304 * Useful when paginating results. Returns a maximum of <code>end - 1305 * start</code> instances. <code>start</code> and <code>end</code> are not 1306 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1307 * refers to the first result in the set. Setting both <code>start</code> 1308 * and <code>end</code> to {@link 1309 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1310 * result set. 1311 * </p> 1312 * 1313 * @param companyId the primary key of the structure's company 1314 * @param groupIds the primary keys of the groups 1315 * @param classNameIds the primary keys of the class names of the models 1316 the structures are related to 1317 * @param keywords the keywords (space separated), which may occur in the 1318 structure's name or description (optionally <code>null</code>) 1319 * @param start the lower bound of the range of structures to return 1320 * @param end the upper bound of the range of structures to return (not 1321 inclusive) 1322 * @param orderByComparator the comparator to order the structures 1323 (optionally <code>null</code>) 1324 * @return the range of matching structures ordered by the comparator 1325 */ 1326 @Override 1327 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search( 1328 long companyId, long[] groupIds, long[] classNameIds, 1329 java.lang.String keywords, int start, int end, 1330 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) { 1331 return _ddmStructureLocalService.search(companyId, groupIds, 1332 classNameIds, keywords, start, end, orderByComparator); 1333 } 1334 1335 /** 1336 * Returns an ordered range of all the structures matching the groups, class 1337 * name IDs, name keyword, description keyword, storage type, and type. 1338 * 1339 * <p> 1340 * Useful when paginating results. Returns a maximum of <code>end - 1341 * start</code> instances. <code>start</code> and <code>end</code> are not 1342 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1343 * refers to the first result in the set. Setting both <code>start</code> 1344 * and <code>end</code> to {@link 1345 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1346 * result set. 1347 * </p> 1348 * 1349 * @param companyId the primary key of the structure's company 1350 * @param groupIds the primary keys of the groups 1351 * @param classNameIds the primary keys of the class names of the models 1352 the structures are related to 1353 * @param name the name keywords 1354 * @param description the description keywords 1355 * @param storageType the structure's storage type. It can be "xml" or 1356 "expando". For more information, see {@link 1357 com.liferay.portlet.dynamicdatamapping.storage.StorageType}. 1358 * @param type the structure's type. For more information, see {@link 1359 com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}. 1360 * @param andOperator whether every field must match its keywords, or just 1361 one field 1362 * @param start the lower bound of the range of structures to return 1363 * @param end the upper bound of the range of structures to return (not 1364 inclusive) 1365 * @param orderByComparator the comparator to order the structures 1366 (optionally <code>null</code>) 1367 * @return the range of matching structures ordered by the comparator 1368 */ 1369 @Override 1370 public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search( 1371 long companyId, long[] groupIds, long[] classNameIds, 1372 java.lang.String name, java.lang.String description, 1373 java.lang.String storageType, int type, boolean andOperator, int start, 1374 int end, 1375 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) { 1376 return _ddmStructureLocalService.search(companyId, groupIds, 1377 classNameIds, name, description, storageType, type, andOperator, 1378 start, end, orderByComparator); 1379 } 1380 1381 /** 1382 * Returns the number of structures matching the groups and class name IDs, 1383 * and matching the keywords in the structure names and descriptions. 1384 * 1385 * @param companyId the primary key of the structure's company 1386 * @param groupIds the primary keys of the groups 1387 * @param classNameIds the primary keys of the class names of the models 1388 the structures are related to 1389 * @param keywords the keywords (space separated), which may occur in the 1390 structure's name or description (optionally <code>null</code>) 1391 * @return the number of matching structures 1392 */ 1393 @Override 1394 public int searchCount(long companyId, long[] groupIds, 1395 long[] classNameIds, java.lang.String keywords) { 1396 return _ddmStructureLocalService.searchCount(companyId, groupIds, 1397 classNameIds, keywords); 1398 } 1399 1400 /** 1401 * Returns the number of structures matching the groups, class name IDs, 1402 * name keyword, description keyword, storage type, and type 1403 * 1404 * @param companyId the primary key of the structure's company 1405 * @param groupIds the primary keys of the groups 1406 * @param classNameIds the primary keys of the class names of the models 1407 the structure's are related to 1408 * @param name the name keywords 1409 * @param description the description keywords 1410 * @param storageType the structure's storage type. It can be "xml" or 1411 "expando". For more information, see {@link 1412 com.liferay.portlet.dynamicdatamapping.storage.StorageType}. 1413 * @param type the structure's type. For more information, see {@link 1414 com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}. 1415 * @param andOperator whether every field must match its keywords, or just 1416 one field 1417 * @return the number of matching structures 1418 */ 1419 @Override 1420 public int searchCount(long companyId, long[] groupIds, 1421 long[] classNameIds, java.lang.String name, 1422 java.lang.String description, java.lang.String storageType, int type, 1423 boolean andOperator) { 1424 return _ddmStructureLocalService.searchCount(companyId, groupIds, 1425 classNameIds, name, description, storageType, type, andOperator); 1426 } 1427 1428 /** 1429 * Sets the Spring bean ID for this bean. 1430 * 1431 * @param beanIdentifier the Spring bean ID for this bean 1432 */ 1433 @Override 1434 public void setBeanIdentifier(java.lang.String beanIdentifier) { 1435 _ddmStructureLocalService.setBeanIdentifier(beanIdentifier); 1436 } 1437 1438 @Override 1439 public void setDLFileEntryTypeDDMStructures(long fileEntryTypeId, 1440 long[] structureIds) { 1441 _ddmStructureLocalService.setDLFileEntryTypeDDMStructures(fileEntryTypeId, 1442 structureIds); 1443 } 1444 1445 @Override 1446 public void setJournalFolderDDMStructures(long folderId, long[] structureIds) { 1447 _ddmStructureLocalService.setJournalFolderDDMStructures(folderId, 1448 structureIds); 1449 } 1450 1451 /** 1452 * Updates the d d m structure in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 1453 * 1454 * @param ddmStructure the d d m structure 1455 * @return the d d m structure that was updated 1456 */ 1457 @Override 1458 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateDDMStructure( 1459 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 1460 return _ddmStructureLocalService.updateDDMStructure(ddmStructure); 1461 } 1462 1463 /** 1464 * Updates the structure matching the structure ID, replacing its XSD with a 1465 * new one. 1466 * 1467 * @param structureId the primary key of the structure 1468 * @param definition the structure's new XML schema definition 1469 * @param serviceContext the service context to be applied. Can set the 1470 structure's modification date. 1471 * @return the updated structure 1472 * @throws PortalException if a matching structure could not be found, if 1473 the XSD was not well-formed, or if a portal exception occurred 1474 */ 1475 @Override 1476 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateDefinition( 1477 long structureId, java.lang.String definition, 1478 com.liferay.portal.service.ServiceContext serviceContext) 1479 throws com.liferay.portal.kernel.exception.PortalException { 1480 return _ddmStructureLocalService.updateDefinition(structureId, 1481 definition, serviceContext); 1482 } 1483 1484 /** 1485 * Updates the structure matching the class name ID, structure key, and 1486 * group, replacing its old parent structure, name map, description map, and 1487 * XSD with new ones. 1488 * 1489 * @param groupId the primary key of the group 1490 * @param parentStructureId the primary key of the new parent structure 1491 * @param classNameId the primary key of the class name for the structure's 1492 related model 1493 * @param structureKey the unique string identifying the structure 1494 * @param nameMap the structure's new locales and localized names 1495 * @param descriptionMap the structure's new locales and localized 1496 description 1497 * @param definition the structure's new XML schema definition 1498 * @param serviceContext the service context to be applied. Can set the 1499 structure's modification date. 1500 * @return the updated structure 1501 * @throws PortalException if a matching structure could not be found, if 1502 the XSD was not well-formed, or if a portal exception occurred 1503 */ 1504 @Override 1505 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure( 1506 long groupId, long parentStructureId, long classNameId, 1507 java.lang.String structureKey, 1508 java.util.Map<java.util.Locale, java.lang.String> nameMap, 1509 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 1510 java.lang.String definition, 1511 com.liferay.portal.service.ServiceContext serviceContext) 1512 throws com.liferay.portal.kernel.exception.PortalException { 1513 return _ddmStructureLocalService.updateStructure(groupId, 1514 parentStructureId, classNameId, structureKey, nameMap, 1515 descriptionMap, definition, serviceContext); 1516 } 1517 1518 /** 1519 * Updates the structure matching the structure ID, replacing its old parent 1520 * structure, name map, description map, and XSD with new ones. 1521 * 1522 * @param structureId the primary key of the structure 1523 * @param parentStructureId the primary key of the new parent structure 1524 * @param nameMap the structure's new locales and localized names 1525 * @param descriptionMap the structure's new locales and localized 1526 descriptions 1527 * @param definition the structure's new XML schema definition 1528 * @param serviceContext the service context to be applied. Can set the 1529 structure's modification date. 1530 * @return the updated structure 1531 * @throws PortalException if a matching structure could not be found, if 1532 the XSD was not well-formed, or if a portal exception occurred 1533 */ 1534 @Override 1535 public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure( 1536 long structureId, long parentStructureId, 1537 java.util.Map<java.util.Locale, java.lang.String> nameMap, 1538 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 1539 java.lang.String definition, 1540 com.liferay.portal.service.ServiceContext serviceContext) 1541 throws com.liferay.portal.kernel.exception.PortalException { 1542 return _ddmStructureLocalService.updateStructure(structureId, 1543 parentStructureId, nameMap, descriptionMap, definition, 1544 serviceContext); 1545 } 1546 1547 /** 1548 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 1549 */ 1550 @Deprecated 1551 public DDMStructureLocalService getWrappedDDMStructureLocalService() { 1552 return _ddmStructureLocalService; 1553 } 1554 1555 /** 1556 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 1557 */ 1558 @Deprecated 1559 public void setWrappedDDMStructureLocalService( 1560 DDMStructureLocalService ddmStructureLocalService) { 1561 _ddmStructureLocalService = ddmStructureLocalService; 1562 } 1563 1564 @Override 1565 public DDMStructureLocalService getWrappedService() { 1566 return _ddmStructureLocalService; 1567 } 1568 1569 @Override 1570 public void setWrappedService( 1571 DDMStructureLocalService ddmStructureLocalService) { 1572 _ddmStructureLocalService = ddmStructureLocalService; 1573 } 1574 1575 private DDMStructureLocalService _ddmStructureLocalService; 1576 }