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