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