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