001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.tools.servicebuilder; 016 017 import com.liferay.portal.freemarker.FreeMarkerUtil; 018 import com.liferay.portal.kernel.dao.db.IndexMetadata; 019 import com.liferay.portal.kernel.dao.db.IndexMetadataFactoryUtil; 020 import com.liferay.portal.kernel.exception.PortalException; 021 import com.liferay.portal.kernel.exception.SystemException; 022 import com.liferay.portal.kernel.io.unsync.UnsyncBufferedReader; 023 import com.liferay.portal.kernel.io.unsync.UnsyncStringReader; 024 import com.liferay.portal.kernel.util.ArrayUtil; 025 import com.liferay.portal.kernel.util.ArrayUtil_IW; 026 import com.liferay.portal.kernel.util.CharPool; 027 import com.liferay.portal.kernel.util.ClearThreadLocalUtil; 028 import com.liferay.portal.kernel.util.FileUtil; 029 import com.liferay.portal.kernel.util.GetterUtil; 030 import com.liferay.portal.kernel.util.ListUtil; 031 import com.liferay.portal.kernel.util.PropertiesUtil; 032 import com.liferay.portal.kernel.util.StringBundler; 033 import com.liferay.portal.kernel.util.StringPool; 034 import com.liferay.portal.kernel.util.StringUtil; 035 import com.liferay.portal.kernel.util.StringUtil_IW; 036 import com.liferay.portal.kernel.util.TextFormatter; 037 import com.liferay.portal.kernel.util.Time; 038 import com.liferay.portal.kernel.util.Validator; 039 import com.liferay.portal.kernel.util.Validator_IW; 040 import com.liferay.portal.kernel.xml.Document; 041 import com.liferay.portal.kernel.xml.Element; 042 import com.liferay.portal.kernel.xml.SAXReaderUtil; 043 import com.liferay.portal.model.CacheField; 044 import com.liferay.portal.model.ModelHintsUtil; 045 import com.liferay.portal.security.permission.ResourceActionsUtil; 046 import com.liferay.portal.tools.ArgumentsUtil; 047 import com.liferay.portal.tools.sourceformatter.JavaSourceProcessor; 048 import com.liferay.portal.util.InitUtil; 049 import com.liferay.portal.util.PropsValues; 050 import com.liferay.util.xml.XMLFormatter; 051 052 import com.thoughtworks.qdox.JavaDocBuilder; 053 import com.thoughtworks.qdox.model.Annotation; 054 import com.thoughtworks.qdox.model.ClassLibrary; 055 import com.thoughtworks.qdox.model.DocletTag; 056 import com.thoughtworks.qdox.model.JavaClass; 057 import com.thoughtworks.qdox.model.JavaField; 058 import com.thoughtworks.qdox.model.JavaMethod; 059 import com.thoughtworks.qdox.model.JavaParameter; 060 import com.thoughtworks.qdox.model.Type; 061 062 import de.hunsicker.io.FileFormat; 063 import de.hunsicker.jalopy.Jalopy; 064 import de.hunsicker.jalopy.storage.Convention; 065 import de.hunsicker.jalopy.storage.ConventionKeys; 066 import de.hunsicker.jalopy.storage.Environment; 067 068 import freemarker.ext.beans.BeansWrapper; 069 070 import freemarker.log.Logger; 071 072 import freemarker.template.TemplateHashModel; 073 import freemarker.template.TemplateModelException; 074 075 import java.beans.Introspector; 076 077 import java.io.File; 078 import java.io.FileInputStream; 079 import java.io.FileNotFoundException; 080 import java.io.FileReader; 081 import java.io.IOException; 082 import java.io.InputStream; 083 084 import java.util.ArrayList; 085 import java.util.Arrays; 086 import java.util.Collections; 087 import java.util.Comparator; 088 import java.util.HashMap; 089 import java.util.HashSet; 090 import java.util.Iterator; 091 import java.util.List; 092 import java.util.Locale; 093 import java.util.Map; 094 import java.util.Properties; 095 import java.util.Set; 096 import java.util.TreeMap; 097 import java.util.TreeSet; 098 import java.util.regex.Matcher; 099 import java.util.regex.Pattern; 100 101 import org.dom4j.DocumentException; 102 103 /** 104 * @author Brian Wing Shun Chan 105 * @author Charles May 106 * @author Alexander Chow 107 * @author Harry Mark 108 * @author Tariq Dweik 109 * @author Glenn Powell 110 * @author Raymond Aug?? 111 * @author Prashant Dighe 112 * @author Shuyang Zhou 113 * @author James Lefeu 114 */ 115 public class ServiceBuilder { 116 117 public static final String AUTHOR = "Brian Wing Shun Chan"; 118 119 public static String getContent(String fileName) throws Exception { 120 Document document = _getContentDocument(fileName); 121 122 Element rootElement = document.getRootElement(); 123 124 Element authorElement = null; 125 Element namespaceElement = null; 126 Map<String, Element> entityElements = new TreeMap<String, Element>(); 127 Map<String, Element> exceptionElements = new TreeMap<String, Element>(); 128 129 for (Element element : rootElement.elements()) { 130 String elementName = element.getName(); 131 132 if (elementName.equals("author")) { 133 element.detach(); 134 135 if (authorElement != null) { 136 throw new IllegalArgumentException( 137 "There can only be one author element"); 138 } 139 140 authorElement = element; 141 } 142 else if (elementName.equals("namespace")) { 143 element.detach(); 144 145 if (namespaceElement != null) { 146 throw new IllegalArgumentException( 147 "There can only be one namespace element"); 148 } 149 150 namespaceElement = element; 151 } 152 else if (elementName.equals("entity")) { 153 element.detach(); 154 155 String name = element.attributeValue("name"); 156 157 entityElements.put(StringUtil.toLowerCase(name), element); 158 } 159 else if (elementName.equals("exceptions")) { 160 element.detach(); 161 162 for (Element exceptionElement : element.elements("exception")) { 163 exceptionElement.detach(); 164 165 exceptionElements.put( 166 exceptionElement.getText(), exceptionElement); 167 } 168 } 169 } 170 171 if (authorElement != null) { 172 rootElement.add(authorElement); 173 } 174 175 if (namespaceElement == null) { 176 throw new IllegalArgumentException( 177 "The namespace element is required"); 178 } 179 else { 180 rootElement.add(namespaceElement); 181 } 182 183 _addElements(rootElement, entityElements); 184 185 if (!exceptionElements.isEmpty()) { 186 Element exceptionsElement = rootElement.addElement("exceptions"); 187 188 _addElements(exceptionsElement, exceptionElements); 189 } 190 191 return document.asXML(); 192 } 193 194 public static void main(String[] args) { 195 Map<String, String> arguments = ArgumentsUtil.parseArguments(args); 196 197 InitUtil.initWithSpring(true); 198 199 String fileName = arguments.get("service.input.file"); 200 String hbmFileName = arguments.get("service.hbm.file"); 201 String ormFileName = arguments.get("service.orm.file"); 202 String modelHintsFileName = arguments.get("service.model.hints.file"); 203 String springFileName = arguments.get("service.spring.file"); 204 String springBaseFileName = arguments.get("service.spring.base.file"); 205 String springClusterFileName = arguments.get("service.spring.cluster.file"); 206 String springDynamicDataSourceFileName = arguments.get("service.spring.dynamic.data.source.file"); 207 String springHibernateFileName = arguments.get("service.spring.hibernate.file"); 208 String springInfrastructureFileName = arguments.get("service.spring.infrastructure.file"); 209 String springShardDataSourceFileName = arguments.get("service.spring.shard.data.source.file"); 210 String apiDir = arguments.get("service.api.dir"); 211 String implDir = arguments.get("service.impl.dir"); 212 String remotingFileName = arguments.get("service.remoting.file"); 213 String sqlDir = arguments.get("service.sql.dir"); 214 String sqlFileName = arguments.get("service.sql.file"); 215 String sqlIndexesFileName = arguments.get("service.sql.indexes.file"); 216 String sqlIndexesPropertiesFileName = arguments.get("service.sql.indexes.properties.file"); 217 String sqlSequencesFileName = arguments.get("service.sql.sequences.file"); 218 boolean autoNamespaceTables = GetterUtil.getBoolean(arguments.get("service.auto.namespace.tables")); 219 String beanLocatorUtil = arguments.get("service.bean.locator.util"); 220 String propsUtil = arguments.get("service.props.util"); 221 String pluginName = arguments.get("service.plugin.name"); 222 String targetEntityName = arguments.get("service.target.entity.name"); 223 String testDir = arguments.get("service.test.dir"); 224 long buildNumber = GetterUtil.getLong(arguments.get("service.build.number"), 1); 225 boolean buildNumberIncrement = GetterUtil.getBoolean(arguments.get("service.build.number.increment"), true); 226 227 try { 228 new ServiceBuilder( 229 fileName, hbmFileName, ormFileName, modelHintsFileName, 230 springFileName, springBaseFileName, springClusterFileName, 231 springDynamicDataSourceFileName, springHibernateFileName, 232 springInfrastructureFileName, springShardDataSourceFileName, 233 apiDir, implDir, remotingFileName, sqlDir, sqlFileName, 234 sqlIndexesFileName, sqlIndexesPropertiesFileName, 235 sqlSequencesFileName, autoNamespaceTables, beanLocatorUtil, 236 propsUtil, pluginName, targetEntityName, testDir, true, 237 buildNumber, buildNumberIncrement); 238 } 239 catch (RuntimeException re) { 240 System.out.println( 241 "Please set these required arguments. Sample values are:\n" + 242 "\n" + 243 "\tservice.input.file=${service.file}\n" + 244 "\tservice.hbm.file=${basedir}/src/META-INF/portal-hbm.xml\n" + 245 "\tservice.orm.file=${basedir}/src/META-INF/portal-orm.xml\n" + 246 "\tservice.model.hints.file=${basedir}/src/META-INF/portal-model-hints.xml\n" + 247 "\tservice.spring.file=${basedir}/src/META-INF/portal-spring.xml\n" + 248 "\tservice.api.dir=${basedir}/../portal-service/src\n" + 249 "\tservice.impl.dir=${basedir}/src\n" + 250 "\tservice.remoting.file=${basedir}/../portal-web/docroot/WEB-INF/remoting-servlet.xml\n" + 251 "\tservice.sql.dir=${basedir}/../sql\n" + 252 "\tservice.sql.file=portal-tables.sql\n" + 253 "\tservice.sql.indexes.file=indexes.sql\n" + 254 "\tservice.sql.indexes.properties.file=indexes.properties\n" + 255 "\tservice.sql.sequences.file=sequences.sql\n" + 256 "\tservice.bean.locator.util=com.liferay.portal.kernel.bean.PortalBeanLocatorUtil\n" + 257 "\tservice.props.util=com.liferay.portal.util.PropsUtil\n" + 258 "\tservice.target.entity.name=${service.target.entity.name}\n" + 259 "\tservice.test.dir=${basedir}/test/integration\n" + 260 "\tservice.build.number=1\n" + 261 "\tservice.build.number.increment=true\n" + 262 "\n" + 263 "You can also customize the generated code by overriding the default templates with these optional system properties:\n" + 264 "\n" + 265 "\t-Dservice.tpl.bad_alias_names=" + _TPL_ROOT + "bad_alias_names.txt\n"+ 266 "\t-Dservice.tpl.bad_column_names=" + _TPL_ROOT + "bad_column_names.txt\n"+ 267 "\t-Dservice.tpl.bad_json_types=" + _TPL_ROOT + "bad_json_types.txt\n"+ 268 "\t-Dservice.tpl.bad_table_names=" + _TPL_ROOT + "bad_table_names.txt\n"+ 269 "\t-Dservice.tpl.base_mode_impl=" + _TPL_ROOT + "base_mode_impl.ftl\n"+ 270 "\t-Dservice.tpl.blob_model=" + _TPL_ROOT + "blob_model.ftl\n"+ 271 "\t-Dservice.tpl.copyright.txt=copyright.txt\n"+ 272 "\t-Dservice.tpl.ejb_pk=" + _TPL_ROOT + "ejb_pk.ftl\n"+ 273 "\t-Dservice.tpl.exception=" + _TPL_ROOT + "exception.ftl\n"+ 274 "\t-Dservice.tpl.export_actionable_dynamic_query=" + _TPL_ROOT + "export_actionable_dynamic_query.ftl\n"+ 275 "\t-Dservice.tpl.extended_model=" + _TPL_ROOT + "extended_model.ftl\n"+ 276 "\t-Dservice.tpl.extended_model_base_impl=" + _TPL_ROOT + "extended_model_base_impl.ftl\n"+ 277 "\t-Dservice.tpl.extended_model_impl=" + _TPL_ROOT + "extended_model_impl.ftl\n"+ 278 "\t-Dservice.tpl.finder=" + _TPL_ROOT + "finder.ftl\n"+ 279 "\t-Dservice.tpl.finder_util=" + _TPL_ROOT + "finder_util.ftl\n"+ 280 "\t-Dservice.tpl.hbm_xml=" + _TPL_ROOT + "hbm_xml.ftl\n"+ 281 "\t-Dservice.tpl.orm_xml=" + _TPL_ROOT + "orm_xml.ftl\n"+ 282 "\t-Dservice.tpl.json_js=" + _TPL_ROOT + "json_js.ftl\n"+ 283 "\t-Dservice.tpl.json_js_method=" + _TPL_ROOT + "json_js_method.ftl\n"+ 284 "\t-Dservice.tpl.model=" + _TPL_ROOT + "model.ftl\n"+ 285 "\t-Dservice.tpl.model_cache=" + _TPL_ROOT + "model_cache.ftl\n"+ 286 "\t-Dservice.tpl.model_hints_xml=" + _TPL_ROOT + "model_hints_xml.ftl\n"+ 287 "\t-Dservice.tpl.model_impl=" + _TPL_ROOT + "model_impl.ftl\n"+ 288 "\t-Dservice.tpl.model_soap=" + _TPL_ROOT + "model_soap.ftl\n"+ 289 "\t-Dservice.tpl.model_wrapper=" + _TPL_ROOT + "model_wrapper.ftl\n"+ 290 "\t-Dservice.tpl.persistence=" + _TPL_ROOT + "persistence.ftl\n"+ 291 "\t-Dservice.tpl.persistence_impl=" + _TPL_ROOT + "persistence_impl.ftl\n"+ 292 "\t-Dservice.tpl.persistence_util=" + _TPL_ROOT + "persistence_util.ftl\n"+ 293 "\t-Dservice.tpl.props=" + _TPL_ROOT + "props.ftl\n"+ 294 "\t-Dservice.tpl.remoting_xml=" + _TPL_ROOT + "remoting_xml.ftl\n"+ 295 "\t-Dservice.tpl.service=" + _TPL_ROOT + "service.ftl\n"+ 296 "\t-Dservice.tpl.service_base_impl=" + _TPL_ROOT + "service_base_impl.ftl\n"+ 297 "\t-Dservice.tpl.service_clp=" + _TPL_ROOT + "service_clp.ftl\n"+ 298 "\t-Dservice.tpl.service_clp_invoker=" + _TPL_ROOT + "service_clp_invoker.ftl\n"+ 299 "\t-Dservice.tpl.service_clp_message_listener=" + _TPL_ROOT + "service_clp_message_listener.ftl\n"+ 300 "\t-Dservice.tpl.service_clp_serializer=" + _TPL_ROOT + "service_clp_serializer.ftl\n"+ 301 "\t-Dservice.tpl.service_http=" + _TPL_ROOT + "service_http.ftl\n"+ 302 "\t-Dservice.tpl.service_impl=" + _TPL_ROOT + "service_impl.ftl\n"+ 303 "\t-Dservice.tpl.service_soap=" + _TPL_ROOT + "service_soap.ftl\n"+ 304 "\t-Dservice.tpl.service_util=" + _TPL_ROOT + "service_util.ftl\n"+ 305 "\t-Dservice.tpl.service_wrapper=" + _TPL_ROOT + "service_wrapper.ftl\n"+ 306 "\t-Dservice.tpl.spring_base_xml=" + _TPL_ROOT + "spring_base_xml.ftl\n"+ 307 "\t-Dservice.tpl.spring_hibernate_xml=" + _TPL_ROOT + "spring_hibernate_xml.ftl\n"+ 308 "\t-Dservice.tpl.spring_infrastructure_xml=" + _TPL_ROOT + "spring_infrastructure_xml.ftl\n"+ 309 "\t-Dservice.tpl.spring_xml=" + _TPL_ROOT + "spring_xml.ftl\n"+ 310 "\t-Dservice.tpl.spring_xml_session=" + _TPL_ROOT + "spring_xml_session.ftl"); 311 312 throw re; 313 } 314 315 try { 316 ClearThreadLocalUtil.clearThreadLocal(); 317 } 318 catch (Exception e) { 319 e.printStackTrace(); 320 } 321 322 Introspector.flushCaches(); 323 } 324 325 public static String toHumanName(String name) { 326 if (name == null) { 327 return null; 328 } 329 330 String humanName = TextFormatter.format(name, TextFormatter.H); 331 332 if (humanName.equals("id")) { 333 humanName = "ID"; 334 } 335 else if (humanName.equals("ids")) { 336 humanName = "IDs"; 337 } 338 339 if (humanName.endsWith(" id")) { 340 humanName = humanName.substring(0, humanName.length() - 3) + " ID"; 341 } 342 else if (humanName.endsWith(" ids")) { 343 humanName = humanName.substring(0, humanName.length() - 4) + " IDs"; 344 } 345 346 if (humanName.contains(" id ")) { 347 humanName = StringUtil.replace(humanName, " id ", " ID "); 348 } 349 else if (humanName.contains(" ids ")) { 350 humanName = StringUtil.replace(humanName, " ids ", " IDs "); 351 } 352 353 return humanName; 354 } 355 356 public static void writeFile(File file, String content) 357 throws IOException { 358 359 writeFile(file, content, AUTHOR); 360 } 361 362 public static void writeFile(File file, String content, String author) 363 throws IOException { 364 365 writeFile(file, content, author, null); 366 } 367 368 public static void writeFile( 369 File file, String content, String author, 370 Map<String, Object> jalopySettings) 371 throws IOException { 372 373 String packagePath = _getPackagePath(file); 374 375 String className = file.getName(); 376 377 className = className.substring(0, className.length() - 5); 378 379 content = JavaSourceProcessor.stripJavaImports( 380 content, packagePath, className); 381 382 File tempFile = new File("ServiceBuilder.temp"); 383 384 FileUtil.write(tempFile, content); 385 386 // Beautify 387 388 StringBuffer sb = new StringBuffer(); 389 390 Jalopy jalopy = new Jalopy(); 391 392 jalopy.setFileFormat(FileFormat.UNIX); 393 jalopy.setInput(tempFile); 394 jalopy.setOutput(sb); 395 396 File jalopyXmlFile = new File("tools/jalopy.xml"); 397 398 if (!jalopyXmlFile.exists()) { 399 jalopyXmlFile = new File("../tools/jalopy.xml"); 400 } 401 402 if (!jalopyXmlFile.exists()) { 403 jalopyXmlFile = new File("misc/jalopy.xml"); 404 } 405 406 if (!jalopyXmlFile.exists()) { 407 jalopyXmlFile = new File("../misc/jalopy.xml"); 408 } 409 410 if (!jalopyXmlFile.exists()) { 411 jalopyXmlFile = new File("../../misc/jalopy.xml"); 412 } 413 414 try { 415 Jalopy.setConvention(jalopyXmlFile); 416 } 417 catch (FileNotFoundException fnfe) { 418 } 419 420 if (jalopySettings == null) { 421 jalopySettings = new HashMap<String, Object>(); 422 } 423 424 Environment env = Environment.getInstance(); 425 426 // Author 427 428 author = GetterUtil.getString( 429 (String)jalopySettings.get("author"), author); 430 431 env.set("author", author); 432 433 // File name 434 435 env.set("fileName", file.getName()); 436 437 Convention convention = Convention.getInstance(); 438 439 String classMask = "/**\n * @author $author$\n*/"; 440 441 convention.put( 442 ConventionKeys.COMMENT_JAVADOC_TEMPLATE_CLASS, 443 env.interpolate(classMask)); 444 445 convention.put( 446 ConventionKeys.COMMENT_JAVADOC_TEMPLATE_INTERFACE, 447 env.interpolate(classMask)); 448 449 jalopy.format(); 450 451 String newContent = sb.toString(); 452 453 // Remove double blank lines after the package or last import 454 455 newContent = newContent.replaceFirst( 456 "(?m)^[ \t]*((?:package|import) .*;)\\s*^[ \t]*/\\*\\*", 457 "$1\n\n/**"); 458 459 /* 460 // Remove blank lines after try { 461 462 newContent = StringUtil.replace(newContent, "try {\n\n", "try {\n"); 463 464 // Remove blank lines after ) { 465 466 newContent = StringUtil.replace(newContent, ") {\n\n", ") {\n"); 467 468 // Remove blank lines empty braces { } 469 470 newContent = StringUtil.replace(newContent, "\n\n\t}", "\n\t}"); 471 472 // Add space to last } 473 474 newContent = newContent.substring(0, newContent.length() - 2) + "\n\n}"; 475 */ 476 477 writeFileRaw(file, newContent); 478 479 tempFile.deleteOnExit(); 480 } 481 482 public static void writeFileRaw(File file, String content) 483 throws IOException { 484 485 // Write file if and only if the file has changed 486 487 if (!file.exists() || !FileUtil.isSameContent(file, content)) { 488 FileUtil.write(file, content); 489 490 System.out.println("Writing " + file); 491 } 492 } 493 494 public ServiceBuilder( 495 String fileName, String hbmFileName, String ormFileName, 496 String modelHintsFileName, String springFileName, 497 String springBaseFileName, String springClusterFileName, 498 String springDynamicDataSourceFileName, String springHibernateFileName, 499 String springInfrastructureFileName, 500 String springShardDataSourceFileName, String apiDir, String implDir, 501 String remotingFileName, String sqlDir, String sqlFileName, 502 String sqlIndexesFileName, String sqlIndexesPropertiesFileName, 503 String sqlSequencesFileName, boolean autoNamespaceTables, 504 String beanLocatorUtil, String propsUtil, String pluginName, 505 String targetEntityName, String testDir) { 506 507 this( 508 fileName, hbmFileName, ormFileName, modelHintsFileName, 509 springFileName, springBaseFileName, springClusterFileName, 510 springDynamicDataSourceFileName, springHibernateFileName, 511 springInfrastructureFileName, springShardDataSourceFileName, apiDir, 512 implDir, remotingFileName, sqlDir, sqlFileName, sqlIndexesFileName, 513 sqlIndexesPropertiesFileName, sqlSequencesFileName, 514 autoNamespaceTables, beanLocatorUtil, propsUtil, pluginName, 515 targetEntityName, testDir, true, 1, true); 516 } 517 518 public ServiceBuilder( 519 String fileName, String hbmFileName, String ormFileName, 520 String modelHintsFileName, String springFileName, 521 String springBaseFileName, String springClusterFileName, 522 String springDynamicDataSourceFileName, String springHibernateFileName, 523 String springInfrastructureFileName, 524 String springShardDataSourceFileName, String apiDir, String implDir, 525 String remotingFileName, String sqlDir, String sqlFileName, 526 String sqlIndexesFileName, String sqlIndexesPropertiesFileName, 527 String sqlSequencesFileName, boolean autoNamespaceTables, 528 String beanLocatorUtil, String propsUtil, String pluginName, 529 String targetEntityName, String testDir, boolean build, 530 long buildNumber, boolean buildNumberIncrement) { 531 532 _tplBadAliasNames = _getTplProperty( 533 "bad_alias_names", _tplBadAliasNames); 534 _tplBadColumnNames = _getTplProperty( 535 "bad_column_names", _tplBadColumnNames); 536 _tplBadTableNames = _getTplProperty( 537 "bad_table_names", _tplBadTableNames); 538 _tplBlobModel = _getTplProperty("blob_model", _tplBlobModel); 539 _tplEjbPk = _getTplProperty("ejb_pk", _tplEjbPk); 540 _tplException = _getTplProperty("exception", _tplException); 541 _tplExtendedModel = _getTplProperty( 542 "extended_model", _tplExtendedModel); 543 _tplExtendedModelBaseImpl = _getTplProperty( 544 "extended_model_base_impl", _tplExtendedModelBaseImpl); 545 _tplExtendedModelImpl = _getTplProperty( 546 "extended_model_impl", _tplExtendedModelImpl); 547 _tplFinder = _getTplProperty("finder", _tplFinder); 548 _tplFinderUtil = _getTplProperty("finder_util", _tplFinderUtil); 549 _tplHbmXml = _getTplProperty("hbm_xml", _tplHbmXml); 550 _tplOrmXml = _getTplProperty("orm_xml", _tplOrmXml); 551 _tplJsonJs = _getTplProperty("json_js", _tplJsonJs); 552 _tplJsonJsMethod = _getTplProperty("json_js_method", _tplJsonJsMethod); 553 _tplModel = _getTplProperty("model", _tplModel); 554 _tplModelCache = _getTplProperty("model_cache", _tplModelCache); 555 _tplModelClp = _getTplProperty("model", _tplModelClp); 556 _tplModelHintsXml = _getTplProperty( 557 "model_hints_xml", _tplModelHintsXml); 558 _tplModelImpl = _getTplProperty("model_impl", _tplModelImpl); 559 _tplModelSoap = _getTplProperty("model_soap", _tplModelSoap); 560 _tplModelWrapper = _getTplProperty("model_wrapper", _tplModelWrapper); 561 _tplPersistence = _getTplProperty("persistence", _tplPersistence); 562 _tplPersistenceImpl = _getTplProperty( 563 "persistence_impl", _tplPersistenceImpl); 564 _tplPersistenceUtil = _getTplProperty( 565 "persistence_util", _tplPersistenceUtil); 566 _tplProps = _getTplProperty("props", _tplProps); 567 _tplRemotingXml = _getTplProperty("remoting_xml", _tplRemotingXml); 568 _tplService = _getTplProperty("service", _tplService); 569 _tplServiceBaseImpl = _getTplProperty( 570 "service_base_impl", _tplServiceBaseImpl); 571 _tplServiceClp = _getTplProperty("service_clp", _tplServiceClp); 572 _tplServiceClpInvoker = _getTplProperty( 573 "service_clp_invoker", _tplServiceClpInvoker); 574 _tplServiceClpMessageListener = _getTplProperty( 575 "service_clp_message_listener", _tplServiceClpMessageListener); 576 _tplServiceClpSerializer = _getTplProperty( 577 "service_clp_serializer", _tplServiceClpSerializer); 578 _tplServiceHttp = _getTplProperty("service_http", _tplServiceHttp); 579 _tplServiceImpl = _getTplProperty("service_impl", _tplServiceImpl); 580 _tplServiceSoap = _getTplProperty("service_soap", _tplServiceSoap); 581 _tplServiceUtil = _getTplProperty("service_util", _tplServiceUtil); 582 _tplServiceWrapper = _getTplProperty( 583 "service_wrapper", _tplServiceWrapper); 584 _tplSpringBaseXml = _getTplProperty( 585 "spring_base_xml", _tplSpringBaseXml); 586 _tplSpringClusterXml = _getTplProperty( 587 "spring_cluster_xml", _tplSpringClusterXml); 588 _tplSpringHibernateXml = _getTplProperty( 589 "spring_hibernate_xml", _tplSpringHibernateXml); 590 _tplSpringInfrastructureXml = _getTplProperty( 591 "spring_infrastructure_xml", _tplSpringInfrastructureXml); 592 _tplSpringShardDataSourceXml = _getTplProperty( 593 "spring_shard_data_source_xml", _tplSpringShardDataSourceXml); 594 _tplSpringXml = _getTplProperty("spring_xml", _tplSpringXml); 595 596 try { 597 _badTableNames = _readLines(_tplBadTableNames); 598 _badAliasNames = _readLines(_tplBadAliasNames); 599 _badColumnNames = _readLines(_tplBadColumnNames); 600 _hbmFileName = hbmFileName; 601 _ormFileName = ormFileName; 602 _modelHintsFileName = modelHintsFileName; 603 _springFileName = springFileName; 604 _springBaseFileName = springBaseFileName; 605 _springClusterFileName = springClusterFileName; 606 _springDynamicDataSourceFileName = springDynamicDataSourceFileName; 607 _springHibernateFileName = springHibernateFileName; 608 _springInfrastructureFileName = springInfrastructureFileName; 609 _springShardDataSourceFileName = springShardDataSourceFileName; 610 _apiDir = apiDir; 611 _implDir = implDir; 612 _remotingFileName = remotingFileName; 613 _sqlDir = sqlDir; 614 _sqlFileName = sqlFileName; 615 _sqlIndexesFileName = sqlIndexesFileName; 616 _sqlIndexesPropertiesFileName = sqlIndexesPropertiesFileName; 617 _sqlSequencesFileName = sqlSequencesFileName; 618 _autoNamespaceTables = autoNamespaceTables; 619 _beanLocatorUtil = beanLocatorUtil; 620 _beanLocatorUtilShortName = _beanLocatorUtil.substring( 621 _beanLocatorUtil.lastIndexOf(".") + 1); 622 _propsUtil = propsUtil; 623 _pluginName = GetterUtil.getString(pluginName); 624 _targetEntityName = targetEntityName; 625 _testDir = testDir; 626 _build = build; 627 _buildNumber = buildNumber; 628 _buildNumberIncrement = buildNumberIncrement; 629 630 String content = getContent(fileName); 631 632 Document document = SAXReaderUtil.read(content, true); 633 634 Element rootElement = document.getRootElement(); 635 636 String packagePath = rootElement.attributeValue("package-path"); 637 638 if (Validator.isNull(packagePath)) { 639 throw new IllegalArgumentException( 640 "The package-path attribute is required"); 641 } 642 643 _outputPath = 644 _implDir + "/" + StringUtil.replace(packagePath, ".", "/"); 645 646 _serviceOutputPath = 647 _apiDir + "/" + StringUtil.replace(packagePath, ".", "/"); 648 649 if (Validator.isNotNull(_testDir)) { 650 _testOutputPath = 651 _testDir + "/" + StringUtil.replace(packagePath, ".", "/"); 652 } 653 654 _packagePath = packagePath; 655 656 _autoNamespaceTables = GetterUtil.getBoolean( 657 rootElement.attributeValue("auto-namespace-tables"), 658 _autoNamespaceTables); 659 660 Element authorElement = rootElement.element("author"); 661 662 if (authorElement != null) { 663 _author = authorElement.getText(); 664 } 665 else { 666 _author = AUTHOR; 667 } 668 669 Element portletElement = rootElement.element("portlet"); 670 Element namespaceElement = rootElement.element("namespace"); 671 672 if (portletElement != null) { 673 _portletName = portletElement.attributeValue("name"); 674 675 _portletShortName = portletElement.attributeValue("short-name"); 676 677 _portletPackageName = TextFormatter.format( 678 _portletName, TextFormatter.B); 679 680 _outputPath += "/" + _portletPackageName; 681 682 _serviceOutputPath += "/" + _portletPackageName; 683 684 _testOutputPath += "/" + _portletPackageName; 685 686 _packagePath += "." + _portletPackageName; 687 } 688 else { 689 _portletShortName = namespaceElement.getText(); 690 } 691 692 _portletShortName = _portletShortName.trim(); 693 694 for (char c : _portletShortName.toCharArray()) { 695 if (!Validator.isChar(c) && (c != CharPool.UNDERLINE)) { 696 throw new RuntimeException( 697 "The namespace element must be a valid keyword"); 698 } 699 } 700 701 _ejbList = new ArrayList<Entity>(); 702 _entityMappings = new HashMap<String, EntityMapping>(); 703 704 List<Element> entityElements = rootElement.elements("entity"); 705 706 for (Element entityElement : entityElements) { 707 _parseEntity(entityElement); 708 } 709 710 List<String> exceptionList = new ArrayList<String>(); 711 712 Element exceptionsElement = rootElement.element("exceptions"); 713 714 if (exceptionsElement != null) { 715 List<Element> exceptionElements = exceptionsElement.elements( 716 "exception"); 717 718 for (Element exceptionElement : exceptionElements) { 719 exceptionList.add(exceptionElement.getText()); 720 } 721 } 722 723 if (build) { 724 for (int x = 0; x < _ejbList.size(); x++) { 725 Entity entity = _ejbList.get(x); 726 727 if (_isTargetEntity(entity)) { 728 System.out.println("Building " + entity.getName()); 729 730 if (entity.hasActionableDynamicQuery()) { 731 _createActionableDynamicQuery(entity); 732 733 if (entity.isStagedModel()) { 734 _createExportActionableDynamicQuery(entity); 735 } 736 } 737 738 if (entity.hasColumns()) { 739 _createHbm(entity); 740 _createHbmUtil(entity); 741 742 _createPersistenceImpl(entity); 743 _createPersistence(entity); 744 _createPersistenceUtil(entity); 745 746 if (Validator.isNotNull(_testDir)) { 747 _createPersistenceTest(entity); 748 } 749 750 _createModelImpl(entity); 751 _createExtendedModelBaseImpl(entity); 752 _createExtendedModelImpl(entity); 753 754 entity.setTransients(_getTransients(entity, false)); 755 entity.setParentTransients( 756 _getTransients(entity, true)); 757 758 _createModel(entity); 759 _createExtendedModel(entity); 760 761 _createModelCache(entity); 762 _createModelClp(entity); 763 _createModelWrapper(entity); 764 765 _createModelSoap(entity); 766 767 _createBlobModels(entity); 768 769 _createPool(entity); 770 771 if (entity.getPKList().size() > 1) { 772 _createEJBPK(entity); 773 } 774 } 775 776 _createFinder(entity); 777 _createFinderUtil(entity); 778 779 if (entity.hasLocalService()) { 780 _createServiceImpl(entity, _SESSION_TYPE_LOCAL); 781 _createServiceBaseImpl(entity, _SESSION_TYPE_LOCAL); 782 _createService(entity, _SESSION_TYPE_LOCAL); 783 _createServiceFactory(entity, _SESSION_TYPE_LOCAL); 784 _createServiceUtil(entity, _SESSION_TYPE_LOCAL); 785 786 _createServiceClp(entity, _SESSION_TYPE_LOCAL); 787 _createServiceClpInvoker( 788 entity, _SESSION_TYPE_LOCAL); 789 _createServiceWrapper(entity, _SESSION_TYPE_LOCAL); 790 } 791 792 if (entity.hasRemoteService()) { 793 _createServiceImpl(entity, _SESSION_TYPE_REMOTE); 794 _createServiceBaseImpl( 795 entity, _SESSION_TYPE_REMOTE); 796 _createService(entity, _SESSION_TYPE_REMOTE); 797 _createServiceFactory(entity, _SESSION_TYPE_REMOTE); 798 _createServiceUtil(entity, _SESSION_TYPE_REMOTE); 799 800 _createServiceClp(entity, _SESSION_TYPE_REMOTE); 801 _createServiceClpInvoker( 802 entity, _SESSION_TYPE_REMOTE); 803 _createServiceWrapper(entity, _SESSION_TYPE_REMOTE); 804 805 if (Validator.isNotNull(_remotingFileName)) { 806 _createServiceHttp(entity); 807 } 808 809 _createServiceJson(entity); 810 811 if (entity.hasColumns()) { 812 _createServiceJsonSerializer(entity); 813 } 814 815 _createServiceSoap(entity); 816 } 817 } 818 else { 819 if (entity.hasColumns()) { 820 entity.setTransients(_getTransients(entity, false)); 821 entity.setParentTransients( 822 _getTransients(entity, true)); 823 } 824 } 825 } 826 827 _createHbmXml(); 828 _createOrmXml(); 829 _createModelHintsXml(); 830 _createSpringXml(); 831 832 _createExceptions(exceptionList); 833 834 _createServiceClpMessageListener(); 835 _createServiceClpSerializer(exceptionList); 836 837 if (Validator.isNotNull(_remotingFileName)) { 838 _createRemotingXml(); 839 } 840 841 _createSQLIndexes(); 842 _createSQLTables(); 843 _createSQLSequences(); 844 845 _createProps(); 846 _createSpringBaseXml(); 847 _createSpringClusterXml(); 848 _createSpringDynamicDataSourceXml(); 849 _createSpringHibernateXml(); 850 _createSpringInfrastructureXml(); 851 _createSpringShardDataSourceXml(); 852 } 853 } 854 catch (FileNotFoundException fnfe) { 855 System.out.println(fnfe.getMessage()); 856 } 857 catch (Exception e) { 858 e.printStackTrace(); 859 } 860 } 861 862 public String getClassName(Type type) { 863 int dimensions = type.getDimensions(); 864 String name = type.getValue(); 865 866 if (dimensions == 0) { 867 return name; 868 } 869 870 StringBundler sb = new StringBundler(); 871 872 for (int i = 0; i < dimensions; i++) { 873 sb.append("["); 874 } 875 876 if (name.equals("boolean")) { 877 return sb.append("Z").toString(); 878 } 879 else if (name.equals("byte")) { 880 return sb.append("B").toString(); 881 } 882 else if (name.equals("char")) { 883 return sb.append("C").toString(); 884 } 885 else if (name.equals("double")) { 886 return sb.append("D").toString(); 887 } 888 else if (name.equals("float")) { 889 return sb.append("F").toString(); 890 } 891 else if (name.equals("int")) { 892 return sb.append("I").toString(); 893 } 894 else if (name.equals("long")) { 895 return sb.append("J").toString(); 896 } 897 else if (name.equals("short")) { 898 return sb.append("S").toString(); 899 } 900 else { 901 return sb.append("L").append(name).append(";").toString(); 902 } 903 } 904 905 public String getCreateMappingTableSQL(EntityMapping entityMapping) 906 throws IOException { 907 908 String createMappingTableSQL = _getCreateMappingTableSQL(entityMapping); 909 910 createMappingTableSQL = StringUtil.replace( 911 createMappingTableSQL, "\n", ""); 912 createMappingTableSQL = StringUtil.replace( 913 createMappingTableSQL, "\t", ""); 914 createMappingTableSQL = createMappingTableSQL.substring( 915 0, createMappingTableSQL.length() - 1); 916 917 return createMappingTableSQL; 918 } 919 920 public String getCreateTableSQL(Entity entity) { 921 String createTableSQL = _getCreateTableSQL(entity); 922 923 createTableSQL = StringUtil.replace(createTableSQL, "\n", ""); 924 createTableSQL = StringUtil.replace(createTableSQL, "\t", ""); 925 createTableSQL = createTableSQL.substring( 926 0, createTableSQL.length() - 1); 927 928 return createTableSQL; 929 } 930 931 public String getDimensions(int dims) { 932 String dimensions = ""; 933 934 for (int i = 0; i < dims; i++) { 935 dimensions += "[]"; 936 } 937 938 return dimensions; 939 } 940 941 public String getDimensions(String dims) { 942 return getDimensions(GetterUtil.getInteger(dims)); 943 } 944 945 public Entity getEntity(String name) throws IOException { 946 Entity entity = _entityPool.get(name); 947 948 if (entity != null) { 949 return entity; 950 } 951 952 int pos = name.lastIndexOf("."); 953 954 if (pos == -1) { 955 pos = _ejbList.indexOf(new Entity(name)); 956 957 if (pos == -1) { 958 throw new RuntimeException( 959 "Cannot find " + name + " in " + 960 ListUtil.toString(_ejbList, Entity.NAME_ACCESSOR)); 961 } 962 963 entity = _ejbList.get(pos); 964 965 _entityPool.put(name, entity); 966 967 return entity; 968 } 969 970 String refPackage = name.substring(0, pos); 971 String refEntity = name.substring(pos + 1); 972 973 if (refPackage.equals(_packagePath)) { 974 pos = _ejbList.indexOf(new Entity(refEntity)); 975 976 if (pos == -1) { 977 throw new RuntimeException( 978 "Cannot find " + refEntity + " in " + 979 ListUtil.toString(_ejbList, Entity.NAME_ACCESSOR)); 980 } 981 982 entity = _ejbList.get(pos); 983 984 _entityPool.put(name, entity); 985 986 return entity; 987 } 988 989 String refPackageDir = StringUtil.replace(refPackage, ".", "/"); 990 991 String refFileName = 992 _implDir + "/" + refPackageDir + "/service.xml"; 993 994 File refFile = new File(refFileName); 995 996 boolean useTempFile = false; 997 998 if (!refFile.exists()) { 999 refFileName = Time.getTimestamp(); 1000 refFile = new File(refFileName); 1001 1002 ClassLoader classLoader = getClass().getClassLoader(); 1003 1004 FileUtil.write( 1005 refFileName, 1006 StringUtil.read( 1007 classLoader, refPackageDir + "/service.xml")); 1008 1009 useTempFile = true; 1010 } 1011 1012 ServiceBuilder serviceBuilder = new ServiceBuilder( 1013 refFileName, _hbmFileName, _ormFileName, _modelHintsFileName, 1014 _springFileName, _springBaseFileName, _springClusterFileName, 1015 _springDynamicDataSourceFileName, _springHibernateFileName, 1016 _springInfrastructureFileName, _springShardDataSourceFileName, 1017 _apiDir, _implDir, _remotingFileName, _sqlDir, _sqlFileName, 1018 _sqlIndexesFileName, _sqlIndexesPropertiesFileName, 1019 _sqlSequencesFileName, _autoNamespaceTables, _beanLocatorUtil, 1020 _propsUtil, _pluginName, _targetEntityName, _testDir, false, 1021 _buildNumber, _buildNumberIncrement); 1022 1023 entity = serviceBuilder.getEntity(refEntity); 1024 1025 entity.setPortalReference(useTempFile); 1026 1027 _entityPool.put(name, entity); 1028 1029 if (useTempFile) { 1030 refFile.deleteOnExit(); 1031 } 1032 1033 return entity; 1034 } 1035 1036 public Entity getEntityByGenericsName(String genericsName) { 1037 try { 1038 String name = genericsName; 1039 1040 if (name.startsWith("<")) { 1041 name = name.substring(1, name.length() - 1); 1042 } 1043 1044 name = StringUtil.replace(name, ".model.", "."); 1045 1046 return getEntity(name); 1047 } 1048 catch (Exception e) { 1049 return null; 1050 } 1051 } 1052 1053 public Entity getEntityByParameterTypeValue(String parameterTypeValue) { 1054 try { 1055 String name = parameterTypeValue; 1056 1057 name = StringUtil.replace(name, ".model.", "."); 1058 1059 return getEntity(name); 1060 } 1061 catch (Exception e) { 1062 return null; 1063 } 1064 } 1065 1066 public EntityMapping getEntityMapping(String mappingTable) { 1067 return _entityMappings.get(mappingTable); 1068 } 1069 1070 public String getGeneratorClass(String idType) { 1071 if (Validator.isNull(idType)) { 1072 idType = "assigned"; 1073 } 1074 1075 return idType; 1076 } 1077 1078 public String getJavadocComment(JavaClass javaClass) { 1079 return _formatComment( 1080 javaClass.getComment(), javaClass.getTags(), StringPool.BLANK); 1081 } 1082 1083 public String getJavadocComment(JavaMethod javaMethod) { 1084 return _formatComment( 1085 javaMethod.getComment(), javaMethod.getTags(), StringPool.TAB); 1086 } 1087 1088 public String getListActualTypeArguments(Type type) { 1089 if (type.getValue().equals("java.util.List")) { 1090 Type[] types = type.getActualTypeArguments(); 1091 1092 if (types != null) { 1093 return getTypeGenericsName(types[0]); 1094 } 1095 } 1096 1097 return getTypeGenericsName(type); 1098 } 1099 1100 public String getLiteralClass(Type type) { 1101 StringBundler sb = new StringBundler(type.getDimensions() + 2); 1102 1103 sb.append(type.getValue()); 1104 1105 for (int i = 0; i < type.getDimensions(); i++) { 1106 sb.append("[]"); 1107 } 1108 1109 sb.append(".class"); 1110 1111 return sb.toString(); 1112 } 1113 1114 public List<EntityColumn> getMappingEntities(String mappingTable) 1115 throws IOException { 1116 1117 List<EntityColumn> mappingEntitiesPKList = 1118 new ArrayList<EntityColumn>(); 1119 1120 EntityMapping entityMapping = _entityMappings.get(mappingTable); 1121 1122 for (int i = 0; i < 2; i++) { 1123 Entity entity = getEntity(entityMapping.getEntity(i)); 1124 1125 if (entity == null) { 1126 return null; 1127 } 1128 1129 mappingEntitiesPKList.addAll(entity.getPKList()); 1130 } 1131 1132 return mappingEntitiesPKList; 1133 } 1134 1135 public String getNoSuchEntityException(Entity entity) { 1136 String noSuchEntityException = entity.getName(); 1137 1138 if (Validator.isNull(entity.getPortletShortName()) || 1139 (noSuchEntityException.startsWith(entity.getPortletShortName()) && 1140 !noSuchEntityException.equals(entity.getPortletShortName()))) { 1141 1142 noSuchEntityException = noSuchEntityException.substring( 1143 entity.getPortletShortName().length()); 1144 } 1145 1146 noSuchEntityException = "NoSuch" + noSuchEntityException; 1147 1148 return noSuchEntityException; 1149 } 1150 1151 public String getParameterType(JavaParameter parameter) { 1152 Type returnType = parameter.getType(); 1153 1154 return getTypeGenericsName(returnType); 1155 } 1156 1157 public String getPrimitiveObj(String type) { 1158 if (type.equals("boolean")) { 1159 return "Boolean"; 1160 } 1161 else if (type.equals("double")) { 1162 return "Double"; 1163 } 1164 else if (type.equals("float")) { 1165 return "Float"; 1166 } 1167 else if (type.equals("int")) { 1168 return "Integer"; 1169 } 1170 else if (type.equals("long")) { 1171 return "Long"; 1172 } 1173 else if (type.equals("short")) { 1174 return "Short"; 1175 } 1176 else { 1177 return type; 1178 } 1179 } 1180 1181 public String getPrimitiveObjValue(String colType) { 1182 if (colType.equals("Boolean")) { 1183 return ".booleanValue()"; 1184 } 1185 else if (colType.equals("Double")) { 1186 return ".doubleValue()"; 1187 } 1188 else if (colType.equals("Float")) { 1189 return ".floatValue()"; 1190 } 1191 else if (colType.equals("Integer")) { 1192 return ".intValue()"; 1193 } 1194 else if (colType.equals("Long")) { 1195 return ".longValue()"; 1196 } 1197 else if (colType.equals("Short")) { 1198 return ".shortValue()"; 1199 } 1200 1201 return StringPool.BLANK; 1202 } 1203 1204 public String getReturnType(JavaMethod method) { 1205 Type returnType = method.getReturns(); 1206 1207 return getTypeGenericsName(returnType); 1208 } 1209 1210 public List<String> getServiceBaseExceptions( 1211 List<JavaMethod> methods, String methodName, List<String> args, 1212 List<String> exceptions) { 1213 1214 boolean foundMethod = false; 1215 1216 for (JavaMethod method : methods) { 1217 JavaParameter[] parameters = method.getParameters(); 1218 1219 if (method.getName().equals(methodName) && 1220 (parameters.length == args.size())) { 1221 1222 for (int i = 0; i < parameters.length; i++) { 1223 JavaParameter parameter = parameters[i]; 1224 1225 String arg = args.get(i); 1226 1227 if (getParameterType(parameter).equals(arg)) { 1228 exceptions = ListUtil.copy(exceptions); 1229 1230 Type[] methodExceptions = method.getExceptions(); 1231 1232 for (Type methodException : methodExceptions) { 1233 String exception = methodException.getValue(); 1234 1235 if (exception.equals( 1236 PortalException.class.getName())) { 1237 1238 exception = "PortalException"; 1239 } 1240 1241 if (exception.equals( 1242 SystemException.class.getName())) { 1243 1244 exception = "SystemException"; 1245 } 1246 1247 if (!exceptions.contains(exception)) { 1248 exceptions.add(exception); 1249 } 1250 } 1251 1252 Collections.sort(exceptions); 1253 1254 foundMethod = true; 1255 1256 break; 1257 } 1258 } 1259 } 1260 1261 if (foundMethod) { 1262 break; 1263 } 1264 } 1265 1266 if (!exceptions.isEmpty()) { 1267 return exceptions; 1268 } 1269 else { 1270 return Collections.emptyList(); 1271 } 1272 } 1273 1274 public String getSqlType(String type) { 1275 if (type.equals("boolean") || type.equals("Boolean")) { 1276 return "BOOLEAN"; 1277 } 1278 else if (type.equals("double") || type.equals("Double")) { 1279 return "DOUBLE"; 1280 } 1281 else if (type.equals("float") || type.equals("Float")) { 1282 return "FLOAT"; 1283 } 1284 else if (type.equals("int") || type.equals("Integer")) { 1285 return "INTEGER"; 1286 } 1287 else if (type.equals("long") || type.equals("Long")) { 1288 return "BIGINT"; 1289 } 1290 else if (type.equals("short") || type.equals("Short")) { 1291 return "INTEGER"; 1292 } 1293 else if (type.equals("Date")) { 1294 return "TIMESTAMP"; 1295 } 1296 else { 1297 return null; 1298 } 1299 } 1300 1301 public String getSqlType(String model, String field, String type) { 1302 if (type.equals("boolean") || type.equals("Boolean")) { 1303 return "BOOLEAN"; 1304 } 1305 else if (type.equals("double") || type.equals("Double")) { 1306 return "DOUBLE"; 1307 } 1308 else if (type.equals("float") || type.equals("Float")) { 1309 return "FLOAT"; 1310 } 1311 else if (type.equals("int") || type.equals("Integer")) { 1312 return "INTEGER"; 1313 } 1314 else if (type.equals("long") || type.equals("Long")) { 1315 return "BIGINT"; 1316 } 1317 else if (type.equals("short") || type.equals("Short")) { 1318 return "INTEGER"; 1319 } 1320 else if (type.equals("Blob")) { 1321 return "BLOB"; 1322 } 1323 else if (type.equals("Date")) { 1324 return "TIMESTAMP"; 1325 } 1326 else if (type.equals("String")) { 1327 Map<String, String> hints = ModelHintsUtil.getHints(model, field); 1328 1329 if (hints != null) { 1330 int maxLength = GetterUtil.getInteger(hints.get("max-length")); 1331 1332 if (maxLength == 2000000) { 1333 return "CLOB"; 1334 } 1335 } 1336 1337 return "VARCHAR"; 1338 } 1339 else { 1340 return null; 1341 } 1342 } 1343 1344 public String getTypeGenericsName(Type type) { 1345 StringBundler sb = new StringBundler(); 1346 1347 sb.append(type.getValue()); 1348 1349 Type[] actualTypeArguments = type.getActualTypeArguments(); 1350 1351 if (actualTypeArguments != null) { 1352 sb.append(StringPool.LESS_THAN); 1353 1354 for (int i = 0; i < actualTypeArguments.length; i++) { 1355 if (i > 0) { 1356 sb.append(", "); 1357 } 1358 1359 sb.append(getTypeGenericsName(actualTypeArguments[i])); 1360 } 1361 1362 sb.append(StringPool.GREATER_THAN); 1363 } 1364 1365 sb.append(getDimensions(type.getDimensions())); 1366 1367 return sb.toString(); 1368 } 1369 1370 public String getVariableName(JavaField field) { 1371 String fieldName = field.getName(); 1372 1373 if ((fieldName.length() > 0) && (fieldName.charAt(0) == '_')) { 1374 fieldName = fieldName.substring(1); 1375 } 1376 1377 return fieldName; 1378 } 1379 1380 public boolean hasEntityByGenericsName(String genericsName) { 1381 if (Validator.isNull(genericsName)) { 1382 return false; 1383 } 1384 1385 if (!genericsName.contains(".model.")) { 1386 return false; 1387 } 1388 1389 if (getEntityByGenericsName(genericsName) == null) { 1390 return false; 1391 } 1392 else { 1393 return true; 1394 } 1395 } 1396 1397 public boolean hasEntityByParameterTypeValue(String parameterTypeValue) { 1398 if (Validator.isNull(parameterTypeValue)) { 1399 return false; 1400 } 1401 1402 if (!parameterTypeValue.contains(".model.")) { 1403 return false; 1404 } 1405 1406 if (getEntityByParameterTypeValue(parameterTypeValue) == null) { 1407 return false; 1408 } 1409 else { 1410 return true; 1411 } 1412 } 1413 1414 public boolean isBasePersistenceMethod(JavaMethod method) { 1415 String methodName = method.getName(); 1416 1417 if (methodName.equals("clearCache") || 1418 methodName.equals("findWithDynamicQuery")) { 1419 1420 return true; 1421 } 1422 else if (methodName.equals("findByPrimaryKey") || 1423 methodName.equals("fetchByPrimaryKey") || 1424 methodName.equals("remove")) { 1425 1426 JavaParameter[] parameters = method.getParameters(); 1427 1428 if ((parameters.length == 1) && 1429 parameters[0].getName().equals("primaryKey")) { 1430 1431 return true; 1432 } 1433 1434 if (methodName.equals("remove")) { 1435 Type[] methodExceptions = method.getExceptions(); 1436 1437 for (Type methodException : methodExceptions) { 1438 String exception = methodException.getValue(); 1439 1440 if (exception.contains("NoSuch")) { 1441 return false; 1442 } 1443 } 1444 1445 return true; 1446 } 1447 } 1448 1449 return false; 1450 } 1451 1452 public boolean isCustomMethod(JavaMethod method) { 1453 String methodName = method.getName(); 1454 1455 if (methodName.equals("afterPropertiesSet") || 1456 methodName.equals("destroy") || 1457 methodName.equals("equals") || 1458 methodName.equals("getClass") || 1459 methodName.equals("hashCode") || 1460 methodName.equals("notify") || 1461 methodName.equals("notifyAll") || 1462 methodName.equals("toString") || 1463 methodName.equals("wait")) { 1464 1465 return false; 1466 } 1467 else if (methodName.equals("getPermissionChecker")) { 1468 return false; 1469 } 1470 else if (methodName.equals("getUser") && 1471 (method.getParameters().length == 0)) { 1472 1473 return false; 1474 } 1475 else if (methodName.equals("getUserId") && 1476 (method.getParameters().length == 0)) { 1477 1478 return false; 1479 } 1480 else if (methodName.endsWith("Finder") && 1481 (methodName.startsWith("get") || 1482 methodName.startsWith("set"))) { 1483 1484 return false; 1485 } 1486 else if (methodName.endsWith("Persistence") && 1487 (methodName.startsWith("get") || 1488 methodName.startsWith("set"))) { 1489 1490 return false; 1491 } 1492 else if (methodName.endsWith("Service") && 1493 (methodName.startsWith("get") || 1494 methodName.startsWith("set"))) { 1495 1496 return false; 1497 } 1498 else { 1499 return true; 1500 } 1501 } 1502 1503 public boolean isDuplicateMethod( 1504 JavaMethod method, Map<String, Object> tempMap) { 1505 1506 StringBundler sb = new StringBundler(); 1507 1508 sb.append("isDuplicateMethod "); 1509 sb.append(getTypeGenericsName(method.getReturns())); 1510 sb.append(StringPool.SPACE); 1511 sb.append(method.getName()); 1512 sb.append(StringPool.OPEN_PARENTHESIS); 1513 1514 JavaParameter[] parameters = method.getParameters(); 1515 1516 for (int i = 0; i < parameters.length; i++) { 1517 JavaParameter javaParameter = parameters[i]; 1518 1519 sb.append(getTypeGenericsName(javaParameter.getType())); 1520 1521 if ((i + 1) != parameters.length) { 1522 sb.append(StringPool.COMMA); 1523 } 1524 } 1525 1526 sb.append(StringPool.CLOSE_PARENTHESIS); 1527 1528 String key = sb.toString(); 1529 1530 if (tempMap.put(key, key) != null) { 1531 return true; 1532 } 1533 else { 1534 return false; 1535 } 1536 } 1537 1538 public boolean isHBMCamelCasePropertyAccessor(String propertyName) { 1539 if (propertyName.length() < 3) { 1540 return false; 1541 } 1542 1543 char[] chars = propertyName.toCharArray(); 1544 1545 char c0 = chars[0]; 1546 char c1 = chars[1]; 1547 char c2 = chars[2]; 1548 1549 if (Character.isLowerCase(c0) && Character.isUpperCase(c1) && 1550 Character.isLowerCase(c2)) { 1551 1552 return true; 1553 } 1554 1555 return false; 1556 } 1557 1558 public boolean isReadOnlyMethod( 1559 JavaMethod method, List<String> txRequiredList, String[] prefixes) { 1560 1561 String methodName = method.getName(); 1562 1563 if (isTxRequiredMethod(method, txRequiredList)) { 1564 return false; 1565 } 1566 1567 for (String prefix : prefixes) { 1568 if (methodName.startsWith(prefix)) { 1569 return true; 1570 } 1571 } 1572 1573 return false; 1574 } 1575 1576 public boolean isServiceReadOnlyMethod( 1577 JavaMethod method, List<String> txRequiredList) { 1578 1579 return isReadOnlyMethod( 1580 method, txRequiredList, 1581 PropsValues.SERVICE_BUILDER_SERVICE_READ_ONLY_PREFIXES); 1582 } 1583 1584 public boolean isSoapMethod(JavaMethod method) { 1585 Type returnType = method.getReturns(); 1586 1587 String returnTypeGenericsName = getTypeGenericsName(returnType); 1588 String returnValueName = returnType.getValue(); 1589 1590 if (returnTypeGenericsName.contains( 1591 "com.liferay.portal.kernel.search.") || 1592 returnTypeGenericsName.contains("com.liferay.portal.model.Theme") || 1593 returnTypeGenericsName.contains( 1594 "com.liferay.portlet.social.model.SocialActivityDefinition") || 1595 returnTypeGenericsName.equals("java.util.List<java.lang.Object>") || 1596 returnValueName.equals("com.liferay.portal.model.Lock") || 1597 returnValueName.equals( 1598 "com.liferay.portlet.messageboards.model.MBMessageDisplay") || 1599 returnValueName.startsWith("java.io") || 1600 returnValueName.equals("java.util.Map") || 1601 returnValueName.equals("java.util.Properties") || 1602 returnValueName.startsWith("javax")) { 1603 1604 return false; 1605 } 1606 1607 if (returnTypeGenericsName.contains( 1608 "com.liferay.portal.kernel.repository.model.FileEntry") || 1609 returnTypeGenericsName.contains( 1610 "com.liferay.portal.kernel.repository.model.Folder")) { 1611 } 1612 else if (returnTypeGenericsName.contains( 1613 "com.liferay.portal.kernel.repository.")) { 1614 1615 return false; 1616 } 1617 1618 JavaParameter[] parameters = method.getParameters(); 1619 1620 for (JavaParameter javaParameter : parameters) { 1621 Type type = javaParameter.getType(); 1622 1623 String parameterTypeName = type.getValue() + _getDimensions(type); 1624 1625 if (parameterTypeName.equals( 1626 "com.liferay.portal.kernel.util.UnicodeProperties") || 1627 parameterTypeName.equals( 1628 "com.liferay.portal.theme.ThemeDisplay") || 1629 parameterTypeName.equals( 1630 "com.liferay.portlet.PortletPreferencesImpl") || 1631 parameterTypeName.equals( 1632 "com.liferay.portlet.dynamicdatamapping.storage.Fields") || 1633 parameterTypeName.startsWith("java.io") || 1634 parameterTypeName.startsWith("java.util.LinkedHashMap") || 1635 //parameterTypeName.startsWith("java.util.List") || 1636 //parameterTypeName.startsWith("java.util.Locale") || 1637 (parameterTypeName.startsWith("java.util.Map") && 1638 !_isStringLocaleMap(javaParameter)) || 1639 parameterTypeName.startsWith("java.util.Properties") || 1640 parameterTypeName.startsWith("javax")) { 1641 1642 return false; 1643 } 1644 } 1645 1646 return true; 1647 } 1648 1649 public boolean isTxRequiredMethod( 1650 JavaMethod method, List<String> txRequiredList) { 1651 1652 if (txRequiredList == null) { 1653 return false; 1654 } 1655 1656 if (txRequiredList.contains(method.getName())) { 1657 return true; 1658 } 1659 1660 return false; 1661 } 1662 1663 private static void _addElements( 1664 Element element, Map<String, Element> elements) { 1665 1666 for (Map.Entry<String, Element> entry : elements.entrySet()) { 1667 Element childElement = entry.getValue(); 1668 1669 element.add(childElement); 1670 } 1671 } 1672 1673 private static Document _getContentDocument(String fileName) 1674 throws Exception { 1675 1676 String content = FileUtil.read(new File(fileName)); 1677 1678 Document document = SAXReaderUtil.read(content); 1679 1680 Element rootElement = document.getRootElement(); 1681 1682 for (Element element : rootElement.elements()) { 1683 String elementName = element.getName(); 1684 1685 if (!elementName.equals("service-builder-import")) { 1686 continue; 1687 } 1688 1689 element.detach(); 1690 1691 String dirName = fileName.substring( 1692 0, fileName.lastIndexOf(StringPool.SLASH) + 1); 1693 String serviceBuilderImportFileName = element.attributeValue( 1694 "file"); 1695 1696 Document serviceBuilderImportDocument = _getContentDocument( 1697 dirName + serviceBuilderImportFileName); 1698 1699 Element serviceBuilderImportRootElement = 1700 serviceBuilderImportDocument.getRootElement(); 1701 1702 for (Element serviceBuilderImportElement : 1703 serviceBuilderImportRootElement.elements()) { 1704 1705 serviceBuilderImportElement.detach(); 1706 1707 rootElement.add(serviceBuilderImportElement); 1708 } 1709 } 1710 1711 return document; 1712 } 1713 1714 private static String _getPackagePath(File file) { 1715 String fileName = StringUtil.replace(file.toString(), "\\", "/"); 1716 1717 int x = fileName.indexOf("src/"); 1718 1719 if (x == -1) { 1720 x = fileName.indexOf("test/"); 1721 } 1722 1723 int y = fileName.lastIndexOf("/"); 1724 1725 fileName = fileName.substring(x + 4, y); 1726 1727 return StringUtil.replace(fileName, "/", "."); 1728 } 1729 1730 private void _createActionableDynamicQuery(Entity entity) throws Exception { 1731 Map<String, Object> context = _getContext(); 1732 1733 context.put("entity", entity); 1734 1735 // Content 1736 1737 String content = _processTemplate(_tplActionableDynamicQuery, context); 1738 1739 // Write file 1740 1741 File ejbFile = new File( 1742 _serviceOutputPath + "/service/persistence/" + 1743 entity.getName() + "ActionableDynamicQuery.java"); 1744 1745 writeFile(ejbFile, content, _author); 1746 } 1747 1748 private void _createBlobModels(Entity entity) throws Exception { 1749 List<EntityColumn> blobList = new ArrayList<EntityColumn>( 1750 entity.getBlobList()); 1751 1752 Iterator<EntityColumn> itr = blobList.iterator(); 1753 1754 while (itr.hasNext()) { 1755 EntityColumn col = itr.next(); 1756 1757 if (!col.isLazy()) { 1758 itr.remove(); 1759 } 1760 } 1761 1762 if (blobList.isEmpty()) { 1763 return; 1764 } 1765 1766 Map<String, Object> context = _getContext(); 1767 1768 context.put("entity", entity); 1769 1770 for (EntityColumn col : blobList) { 1771 context.put("column", col); 1772 1773 // Content 1774 1775 String content = _processTemplate(_tplBlobModel, context); 1776 1777 // Write file 1778 1779 File blobModelFile = new File( 1780 _serviceOutputPath + "/model/" + entity.getName() + 1781 col.getMethodName() + "BlobModel.java"); 1782 1783 writeFile(blobModelFile, content, _author); 1784 } 1785 } 1786 1787 private void _createEJBPK(Entity entity) throws Exception { 1788 Map<String, Object> context = _getContext(); 1789 1790 context.put("entity", entity); 1791 1792 // Content 1793 1794 String content = _processTemplate(_tplEjbPk, context); 1795 1796 // Write file 1797 1798 File ejbFile = new File( 1799 _serviceOutputPath + "/service/persistence/" + 1800 entity.getPKClassName() + ".java"); 1801 1802 writeFile(ejbFile, content, _author); 1803 } 1804 1805 private void _createExceptions(List<String> exceptions) throws Exception { 1806 for (int i = 0; i < _ejbList.size(); i++) { 1807 Entity entity = _ejbList.get(i); 1808 1809 if (!_isTargetEntity(entity)) { 1810 continue; 1811 } 1812 1813 if (entity.hasColumns()) { 1814 exceptions.add(getNoSuchEntityException(entity)); 1815 } 1816 } 1817 1818 for (String exception : exceptions) { 1819 File exceptionFile = new File( 1820 _serviceOutputPath + "/" + exception + "Exception.java"); 1821 1822 if (!exceptionFile.exists()) { 1823 Map<String, Object> context = _getContext(); 1824 1825 context.put("exception", exception); 1826 1827 String content = _processTemplate(_tplException, context); 1828 1829 if (exception.startsWith("NoSuch")) { 1830 content = StringUtil.replace( 1831 content, "PortalException", "NoSuchModelException"); 1832 content = StringUtil.replace( 1833 content, "kernel.exception.NoSuchModelException", 1834 "NoSuchModelException"); 1835 } 1836 1837 content = StringUtil.replace(content, "\r\n", "\n"); 1838 1839 FileUtil.write(exceptionFile, content); 1840 } 1841 1842 if (exception.startsWith("NoSuch")) { 1843 String content = FileUtil.read(exceptionFile); 1844 1845 if (!content.contains("NoSuchModelException")) { 1846 content = StringUtil.replace( 1847 content, "PortalException", "NoSuchModelException"); 1848 content = StringUtil.replace( 1849 content, "kernel.exception.NoSuchModelException", 1850 "NoSuchModelException"); 1851 1852 FileUtil.write(exceptionFile, content); 1853 } 1854 } 1855 1856 if (!_serviceOutputPath.equals(_outputPath)) { 1857 exceptionFile = new File( 1858 _outputPath + "/" + exception + "Exception.java"); 1859 1860 if (exceptionFile.exists()) { 1861 System.out.println("Relocating " + exceptionFile); 1862 1863 exceptionFile.delete(); 1864 } 1865 } 1866 } 1867 } 1868 1869 private void _createExportActionableDynamicQuery(Entity entity) 1870 throws Exception { 1871 1872 Map<String, Object> context = _getContext(); 1873 1874 context.put("entity", entity); 1875 1876 // Content 1877 1878 String content = _processTemplate( 1879 _tplExportActionableDynamicQuery, context); 1880 1881 // Write file 1882 1883 File ejbFile = new File( 1884 _serviceOutputPath + "/service/persistence/" + 1885 entity.getName() + "ExportActionableDynamicQuery.java"); 1886 1887 writeFile(ejbFile, content, _author); 1888 } 1889 1890 private void _createExtendedModel(Entity entity) throws Exception { 1891 JavaClass modelImplJavaClass = _getJavaClass( 1892 _outputPath + "/model/impl/" + entity.getName() + "Impl.java"); 1893 1894 List<JavaMethod> methods = ListUtil.fromArray( 1895 _getMethods(modelImplJavaClass)); 1896 1897 Iterator<JavaMethod> itr = methods.iterator(); 1898 1899 while (itr.hasNext()) { 1900 JavaMethod method = itr.next(); 1901 1902 String methodName = method.getName(); 1903 1904 if (methodName.equals("getStagedModelType")) { 1905 itr.remove(); 1906 } 1907 } 1908 1909 JavaClass modelJavaClass = _getJavaClass( 1910 _serviceOutputPath + "/model/" + entity.getName() + "Model.java"); 1911 1912 for (JavaMethod method : _getMethods(modelJavaClass)) { 1913 methods.remove(method); 1914 } 1915 1916 Map<String, Object> context = _getContext(); 1917 1918 context.put("entity", entity); 1919 context.put("methods", methods.toArray(new Object[methods.size()])); 1920 1921 // Content 1922 1923 String content = _processTemplate(_tplExtendedModel, context); 1924 1925 // Write file 1926 1927 File modelFile = new File( 1928 _serviceOutputPath + "/model/" + entity.getName() + ".java"); 1929 1930 writeFile(modelFile, content, _author); 1931 1932 if (!_serviceOutputPath.equals(_outputPath)) { 1933 modelFile = new File( 1934 _outputPath + "/model/" + entity.getName() + ".java"); 1935 1936 if (modelFile.exists()) { 1937 System.out.println("Relocating " + modelFile); 1938 1939 modelFile.delete(); 1940 } 1941 } 1942 } 1943 1944 private void _createExtendedModelBaseImpl(Entity entity) throws Exception { 1945 Map<String, Object> context = _getContext(); 1946 1947 context.put("entity", entity); 1948 1949 // Content 1950 1951 String content = _processTemplate(_tplExtendedModelBaseImpl, context); 1952 1953 // Write file 1954 1955 File modelFile = new File( 1956 _outputPath + "/model/impl/" + entity.getName() + "BaseImpl.java"); 1957 1958 writeFile(modelFile, content, _author); 1959 } 1960 1961 private void _createExtendedModelImpl(Entity entity) throws Exception { 1962 Map<String, Object> context = _getContext(); 1963 1964 context.put("entity", entity); 1965 1966 // Content 1967 1968 String content = _processTemplate(_tplExtendedModelImpl, context); 1969 1970 // Write file 1971 1972 File modelFile = new File( 1973 _outputPath + "/model/impl/" + entity.getName() + "Impl.java"); 1974 1975 if (modelFile.exists()) { 1976 content = FileUtil.read(modelFile); 1977 1978 content = content.replaceAll( 1979 "extends\\s+" + entity.getName() + 1980 "ModelImpl\\s+implements\\s+" + entity.getName(), 1981 "extends " + entity.getName() + "BaseImpl"); 1982 1983 writeFileRaw(modelFile, content); 1984 } 1985 else { 1986 writeFile(modelFile, content, _author); 1987 } 1988 } 1989 1990 private void _createFinder(Entity entity) throws Exception { 1991 if (!entity.hasFinderClass()) { 1992 return; 1993 } 1994 1995 JavaClass javaClass = _getJavaClass( 1996 _outputPath + "/service/persistence/" + entity.getName() + 1997 "FinderImpl.java"); 1998 1999 Map<String, Object> context = _getContext(); 2000 2001 context.put("entity", entity); 2002 context.put("methods", _getMethods(javaClass)); 2003 2004 // Content 2005 2006 String content = _processTemplate(_tplFinder, context); 2007 2008 // Write file 2009 2010 File ejbFile = new File( 2011 _serviceOutputPath + "/service/persistence/" + entity.getName() + 2012 "Finder.java"); 2013 2014 writeFile(ejbFile, content, _author); 2015 2016 if (!_serviceOutputPath.equals(_outputPath)) { 2017 ejbFile = new File( 2018 _outputPath + "/service/persistence/" + entity.getName() + 2019 "Finder.java"); 2020 2021 if (ejbFile.exists()) { 2022 System.out.println("Relocating " + ejbFile); 2023 2024 ejbFile.delete(); 2025 } 2026 } 2027 } 2028 2029 private void _createFinderUtil(Entity entity) throws Exception { 2030 if (!entity.hasFinderClass()) { 2031 return; 2032 } 2033 2034 JavaClass javaClass = _getJavaClass( 2035 _outputPath + "/service/persistence/" + entity.getName() + 2036 "FinderImpl.java"); 2037 2038 Map<String, Object> context = _getContext(); 2039 2040 context.put("entity", entity); 2041 context.put("methods", _getMethods(javaClass)); 2042 2043 // Content 2044 2045 String content = _processTemplate(_tplFinderUtil, context); 2046 2047 // Write file 2048 2049 File ejbFile = new File( 2050 _serviceOutputPath + "/service/persistence/" + entity.getName() + 2051 "FinderUtil.java"); 2052 2053 writeFile(ejbFile, content, _author); 2054 2055 if (!_serviceOutputPath.equals(_outputPath)) { 2056 ejbFile = new File( 2057 _outputPath + "/service/persistence/" + entity.getName() + 2058 "FinderUtil.java"); 2059 2060 if (ejbFile.exists()) { 2061 System.out.println("Relocating " + ejbFile); 2062 2063 ejbFile.delete(); 2064 } 2065 } 2066 } 2067 2068 private void _createHbm(Entity entity) { 2069 File ejbFile = new File( 2070 _outputPath + "/service/persistence/" + entity.getName() + 2071 "HBM.java"); 2072 2073 if (ejbFile.exists()) { 2074 System.out.println("Removing deprecated " + ejbFile); 2075 2076 ejbFile.delete(); 2077 } 2078 } 2079 2080 private void _createHbmUtil(Entity entity) { 2081 File ejbFile = new File( 2082 _outputPath + "/service/persistence/" + entity.getName() + 2083 "HBMUtil.java"); 2084 2085 if (ejbFile.exists()) { 2086 System.out.println("Removing deprecated " + ejbFile); 2087 2088 ejbFile.delete(); 2089 } 2090 } 2091 2092 private void _createHbmXml() throws Exception { 2093 Map<String, Object> context = _getContext(); 2094 2095 context.put("entities", _ejbList); 2096 2097 // Content 2098 2099 String content = _processTemplate(_tplHbmXml, context); 2100 2101 int lastImportStart = content.lastIndexOf("<import class="); 2102 int lastImportEnd = content.indexOf("/>", lastImportStart) + 3; 2103 2104 String imports = content.substring(0, lastImportEnd); 2105 2106 content = content.substring(lastImportEnd + 1); 2107 2108 File xmlFile = new File(_hbmFileName); 2109 2110 if (!xmlFile.exists()) { 2111 String xml = 2112 "<?xml version=\"1.0\"?>\n" + 2113 "<!DOCTYPE hibernate-mapping PUBLIC \"-//Hibernate/Hibernate Mapping DTD 3.0//EN\" \"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd\">\n" + 2114 "\n" + 2115 "<hibernate-mapping default-lazy=\"false\" auto-import=\"false\">\n" + 2116 "</hibernate-mapping>"; 2117 2118 FileUtil.write(xmlFile, xml); 2119 } 2120 2121 String oldContent = FileUtil.read(xmlFile); 2122 String newContent = _fixHbmXml(oldContent); 2123 2124 int firstImport = newContent.indexOf( 2125 "<import class=\"" + _packagePath + ".model."); 2126 int lastImport = newContent.lastIndexOf( 2127 "<import class=\"" + _packagePath + ".model."); 2128 2129 if (firstImport == -1) { 2130 int x = newContent.indexOf("<class"); 2131 2132 if (x != -1) { 2133 newContent = 2134 newContent.substring(0, x) + imports + 2135 newContent.substring(x); 2136 } 2137 else { 2138 content = imports + content; 2139 } 2140 } 2141 else { 2142 firstImport = newContent.indexOf("<import", firstImport) - 1; 2143 lastImport = newContent.indexOf("/>", lastImport) + 3; 2144 2145 newContent = 2146 newContent.substring(0, firstImport) + imports + 2147 newContent.substring(lastImport); 2148 } 2149 2150 int firstClass = newContent.indexOf( 2151 "<class name=\"" + _packagePath + ".model.impl."); 2152 int lastClass = newContent.lastIndexOf( 2153 "<class name=\"" + _packagePath + ".model.impl."); 2154 2155 if (firstClass == -1) { 2156 int x = newContent.indexOf("</hibernate-mapping>"); 2157 2158 if (x != -1) { 2159 newContent = 2160 newContent.substring(0, x) + content + 2161 newContent.substring(x); 2162 } 2163 } 2164 else { 2165 firstClass = newContent.lastIndexOf("<class", firstClass) - 1; 2166 lastClass = newContent.indexOf("</class>", lastClass) + 9; 2167 2168 newContent = 2169 newContent.substring(0, firstClass) + content + 2170 newContent.substring(lastClass); 2171 } 2172 2173 newContent = _formatXml(newContent); 2174 2175 if (!oldContent.equals(newContent)) { 2176 FileUtil.write(xmlFile, newContent); 2177 } 2178 } 2179 2180 private void _createModel(Entity entity) throws Exception { 2181 Map<String, Object> context = _getContext(); 2182 2183 context.put("entity", entity); 2184 2185 // Content 2186 2187 String content = _processTemplate(_tplModel, context); 2188 2189 // Write file 2190 2191 File modelFile = new File( 2192 _serviceOutputPath + "/model/" + entity.getName() + "Model.java"); 2193 2194 writeFile(modelFile, content, _author); 2195 2196 if (!_serviceOutputPath.equals(_outputPath)) { 2197 modelFile = new File( 2198 _outputPath + "/model/" + entity.getName() + "Model.java"); 2199 2200 if (modelFile.exists()) { 2201 System.out.println("Relocating " + modelFile); 2202 2203 modelFile.delete(); 2204 } 2205 } 2206 } 2207 2208 private void _createModelCache(Entity entity) throws Exception { 2209 JavaClass javaClass = _getJavaClass( 2210 _outputPath + "/model/impl/" + entity.getName() + "Impl.java"); 2211 2212 Map<String, Object> context = _getContext(); 2213 2214 context.put("entity", entity); 2215 context.put("cacheFields", _getCacheFields(javaClass)); 2216 2217 // Content 2218 2219 String content = _processTemplate(_tplModelCache, context); 2220 2221 // Write file 2222 2223 File modelFile = new File( 2224 _outputPath + "/model/impl/" + entity.getName() + 2225 "CacheModel.java"); 2226 2227 writeFile(modelFile, content, _author); 2228 } 2229 2230 private void _createModelClp(Entity entity) throws Exception { 2231 if (Validator.isNull(_pluginName)) { 2232 return; 2233 } 2234 2235 JavaClass javaClass = _getJavaClass( 2236 _outputPath + "/model/impl/" + entity.getName() + "Impl.java"); 2237 2238 Map<String, JavaMethod> methods = new HashMap<String, JavaMethod>(); 2239 2240 for (JavaMethod method : javaClass.getMethods()) { 2241 methods.put(method.getDeclarationSignature(false), method); 2242 } 2243 2244 Type superClass = javaClass.getSuperClass(); 2245 2246 String superClassValue = superClass.getValue(); 2247 2248 while (!superClassValue.endsWith("BaseModelImpl")) { 2249 int pos = superClassValue.lastIndexOf(StringPool.PERIOD); 2250 2251 if (pos > 0) { 2252 superClassValue = superClassValue.substring(pos + 1); 2253 } 2254 2255 javaClass = _getJavaClass( 2256 _outputPath + "/model/impl/" + superClassValue + ".java"); 2257 2258 for (JavaMethod method : _getMethods(javaClass)) { 2259 methods.remove(method.getDeclarationSignature(false)); 2260 } 2261 2262 superClass = javaClass.getSuperClass(); 2263 superClassValue = superClass.getValue(); 2264 } 2265 2266 Map<String, Object> context = _getContext(); 2267 2268 context.put("entity", entity); 2269 context.put("methods", methods.values()); 2270 2271 // Content 2272 2273 String content = _processTemplate(_tplModelClp, context); 2274 2275 // Write file 2276 2277 File modelFile = new File( 2278 _serviceOutputPath + "/model/" + entity.getName() + "Clp.java"); 2279 2280 writeFile(modelFile, content, _author); 2281 } 2282 2283 private void _createModelHintsXml() throws Exception { 2284 Map<String, Object> context = _getContext(); 2285 2286 context.put("entities", _ejbList); 2287 2288 // Content 2289 2290 String content = _processTemplate(_tplModelHintsXml, context); 2291 2292 File xmlFile = new File(_modelHintsFileName); 2293 2294 if (!xmlFile.exists()) { 2295 String xml = 2296 "<?xml version=\"1.0\"?>\n" + 2297 "\n" + 2298 "<model-hints>\n" + 2299 "</model-hints>"; 2300 2301 FileUtil.write(xmlFile, xml); 2302 } 2303 2304 String oldContent = FileUtil.read(xmlFile); 2305 String newContent = oldContent; 2306 2307 int firstModel = newContent.indexOf( 2308 "<model name=\"" + _packagePath + ".model."); 2309 int lastModel = newContent.lastIndexOf( 2310 "<model name=\"" + _packagePath + ".model."); 2311 2312 if (firstModel == -1) { 2313 int x = newContent.indexOf("</model-hints>"); 2314 2315 newContent = 2316 newContent.substring(0, x) + content + 2317 newContent.substring(x); 2318 } 2319 else { 2320 firstModel = newContent.lastIndexOf("<model", firstModel) - 1; 2321 lastModel = newContent.indexOf("</model>", lastModel) + 9; 2322 2323 newContent = 2324 newContent.substring(0, firstModel) + content + 2325 newContent.substring(lastModel); 2326 } 2327 2328 newContent = _formatXml(newContent); 2329 2330 if (!oldContent.equals(newContent)) { 2331 FileUtil.write(xmlFile, newContent); 2332 } 2333 } 2334 2335 private void _createModelImpl(Entity entity) throws Exception { 2336 JavaClass javaClass = _getJavaClass( 2337 _outputPath + "/model/impl/" + entity.getName() + "Impl.java"); 2338 2339 Map<String, Object> context = _getContext(); 2340 2341 context.put("entity", entity); 2342 context.put("cacheFields", _getCacheFields(javaClass)); 2343 2344 // Content 2345 2346 String content = _processTemplate(_tplModelImpl, context); 2347 2348 // Write file 2349 2350 File modelFile = new File( 2351 _outputPath + "/model/impl/" + entity.getName() + "ModelImpl.java"); 2352 2353 writeFile(modelFile, content, _author); 2354 } 2355 2356 private void _createModelSoap(Entity entity) throws Exception { 2357 File modelFile = null; 2358 2359 if (!_serviceOutputPath.equals(_outputPath)) { 2360 modelFile = new File( 2361 _outputPath + "/model/" + entity.getName() + "Soap.java"); 2362 2363 if (modelFile.exists()) { 2364 System.out.println("Relocating " + modelFile); 2365 2366 modelFile.delete(); 2367 } 2368 } 2369 2370 modelFile = new File( 2371 _serviceOutputPath + "/model/" + entity.getName() + "Soap.java"); 2372 2373 Map<String, Object> context = _getContext(); 2374 2375 context.put("entity", entity); 2376 2377 // Content 2378 2379 String content = _processTemplate(_tplModelSoap, context); 2380 2381 // Write file 2382 2383 writeFile(modelFile, content, _author); 2384 } 2385 2386 private void _createModelWrapper(Entity entity) throws Exception { 2387 JavaClass modelJavaClass = _getJavaClass( 2388 _serviceOutputPath + "/model/" + entity.getName() + "Model.java"); 2389 2390 Object[] methods = _getMethods(modelJavaClass); 2391 2392 JavaClass extendedModelBaseImplJavaClass = _getJavaClass( 2393 _outputPath + "/model/impl/" + entity.getName() + "BaseImpl.java"); 2394 2395 methods = ArrayUtil.append( 2396 methods, _getMethods(extendedModelBaseImplJavaClass)); 2397 2398 JavaClass extendedModelJavaClass = _getJavaClass( 2399 _serviceOutputPath + "/model/" + entity.getName() + ".java"); 2400 2401 methods = ArrayUtil.append( 2402 methods, _getMethods(extendedModelJavaClass)); 2403 2404 Map<String, Object> context = _getContext(); 2405 2406 context.put("entity", entity); 2407 context.put("methods", methods); 2408 2409 // Content 2410 2411 String content = _processTemplate(_tplModelWrapper, context); 2412 2413 // Write file 2414 2415 File modelFile = new File( 2416 _serviceOutputPath + "/model/" + entity.getName() + "Wrapper.java"); 2417 2418 writeFile(modelFile, content, _author); 2419 } 2420 2421 private void _createOrmXml() throws Exception { 2422 Map<String, Object> context = _getContext(); 2423 2424 context.put("entities", _ejbList); 2425 2426 // Content 2427 2428 String content = _processTemplate(_tplOrmXml, context); 2429 2430 String mappedClasses = ""; 2431 2432 int lastMappedClassStart = content.lastIndexOf("<mapped-superclass"); 2433 2434 if (lastMappedClassStart != -1) { 2435 int lastMappedClassEnd = content.indexOf( 2436 "</mapped-superclass>", lastMappedClassStart) + 20; 2437 2438 mappedClasses = content.substring(0, lastMappedClassEnd); 2439 2440 content = content.substring(lastMappedClassEnd + 1); 2441 } 2442 2443 File xmlFile = new File(_ormFileName); 2444 2445 if (!xmlFile.exists()) { 2446 String xml = 2447 "<?xml version=\"1.0\"?>\n" + 2448 "<entity-mappings version=\"1.0\" xmlns=\"http://java.sun.com/xml/ns/persistence/orm\"\n" + 2449 "\txmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" + 2450 "\txsi:schemaLocation=\"http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_1_0.xsd\"\n" + 2451 ">\n" + 2452 "<persistence-unit-metadata>\n" + 2453 "\t<xml-mapping-metadata-complete />\n" + 2454 "\t<persistence-unit-defaults>\n" + 2455 "\t\t<access>PROPERTY</access>\n" + 2456 "\t</persistence-unit-defaults>\n" + 2457 "</persistence-unit-metadata>\n" + 2458 "</entity-mappings>"; 2459 2460 FileUtil.write(xmlFile, xml); 2461 } 2462 2463 String oldContent = FileUtil.read(xmlFile); 2464 String newContent = oldContent; 2465 2466 int firstMappedClass = newContent.indexOf( 2467 "<mapped-superclass class=\"" + _packagePath + ".model."); 2468 int lastMappedClass = newContent.lastIndexOf( 2469 "<mapped-superclass class=\"" + _packagePath + ".model."); 2470 2471 if (firstMappedClass == -1) { 2472 int x = newContent.indexOf("<entity class="); 2473 2474 if (x != -1) { 2475 newContent = 2476 newContent.substring(0, x) + mappedClasses + 2477 newContent.substring(x); 2478 } 2479 else { 2480 content = mappedClasses + content; 2481 } 2482 } 2483 else { 2484 firstMappedClass = newContent.indexOf( 2485 "<mapped-superclass", firstMappedClass) - 1; 2486 lastMappedClass = newContent.indexOf( 2487 "</mapped-superclass>", lastMappedClass) + 20; 2488 2489 newContent = 2490 newContent.substring(0, firstMappedClass) + mappedClasses + 2491 newContent.substring(lastMappedClass); 2492 } 2493 2494 int firstEntity = newContent.indexOf( 2495 "<entity class=\"" + _packagePath + ".model.impl."); 2496 int lastEntity = newContent.lastIndexOf( 2497 "<entity class=\"" + _packagePath + ".model.impl."); 2498 2499 if (firstEntity == -1) { 2500 int x = newContent.indexOf("</entity-mappings>"); 2501 2502 if (x != -1) { 2503 newContent = 2504 newContent.substring(0, x) + content + 2505 newContent.substring(x); 2506 } 2507 } 2508 else { 2509 firstEntity = newContent.lastIndexOf("<entity", firstEntity) - 1; 2510 lastEntity = newContent.indexOf("</entity>", lastEntity) + 9; 2511 2512 newContent = 2513 newContent.substring(0, firstEntity) + content + 2514 newContent.substring(lastEntity); 2515 } 2516 2517 newContent = _formatXml(newContent); 2518 2519 newContent = StringUtil.replace( 2520 newContent, 2521 new String[] {"<attributes></attributes>", "<attributes/>"}, 2522 new String[] {"<attributes />", "<attributes />"}); 2523 2524 if (!oldContent.equals(newContent)) { 2525 FileUtil.write(xmlFile, newContent); 2526 } 2527 } 2528 2529 private void _createPersistence(Entity entity) throws Exception { 2530 JavaClass javaClass = _getJavaClass( 2531 _outputPath + "/service/persistence/" + entity.getName() + 2532 "PersistenceImpl.java"); 2533 2534 Map<String, Object> context = _getContext(); 2535 2536 context.put("entity", entity); 2537 context.put("methods", _getMethods(javaClass)); 2538 2539 // Content 2540 2541 String content = _processTemplate(_tplPersistence, context); 2542 2543 // Write file 2544 2545 File ejbFile = new File( 2546 _serviceOutputPath + "/service/persistence/" + entity.getName() + 2547 "Persistence.java"); 2548 2549 writeFile(ejbFile, content, _author); 2550 2551 if (!_serviceOutputPath.equals(_outputPath)) { 2552 ejbFile = new File( 2553 _outputPath + "/service/persistence/" + entity.getName() + 2554 "Persistence.java"); 2555 2556 if (ejbFile.exists()) { 2557 System.out.println("Relocating " + ejbFile); 2558 2559 ejbFile.delete(); 2560 } 2561 } 2562 } 2563 2564 private void _createPersistenceImpl(Entity entity) throws Exception { 2565 Map<String, Object> context = _getContext(); 2566 2567 context.put("entity", entity); 2568 context.put( 2569 "referenceList", _mergeReferenceList(entity.getReferenceList())); 2570 2571 // Content 2572 2573 Logger.selectLoggerLibrary(Logger.LIBRARY_NONE); 2574 2575 String content = _processTemplate(_tplPersistenceImpl, context); 2576 2577 Logger.selectLoggerLibrary(Logger.LIBRARY_AUTO); 2578 2579 // Write file 2580 2581 File ejbFile = new File( 2582 _outputPath + "/service/persistence/" + entity.getName() + 2583 "PersistenceImpl.java"); 2584 2585 writeFile(ejbFile, content, _author); 2586 } 2587 2588 private void _createPersistenceTest(Entity entity) throws Exception { 2589 Map<String, Object> context = _getContext(); 2590 2591 context.put("entity", entity); 2592 2593 // Content 2594 2595 String content = _processTemplate(_tplPersistenceTest, context); 2596 2597 // Write file 2598 2599 File ejbFile = new File( 2600 _testOutputPath + "/service/persistence/" + entity.getName() + 2601 "PersistenceTest.java"); 2602 2603 writeFile(ejbFile, content, _author); 2604 } 2605 2606 private void _createPersistenceUtil(Entity entity) throws Exception { 2607 JavaClass javaClass = _getJavaClass( 2608 _outputPath + "/service/persistence/" + entity.getName() + 2609 "PersistenceImpl.java"); 2610 2611 Map<String, Object> context = _getContext(); 2612 2613 context.put("entity", entity); 2614 context.put("methods", _getMethods(javaClass)); 2615 2616 // Content 2617 2618 String content = _processTemplate(_tplPersistenceUtil, context); 2619 2620 // Write file 2621 2622 File ejbFile = new File( 2623 _serviceOutputPath + "/service/persistence/" + entity.getName() + 2624 "Util.java"); 2625 2626 writeFile(ejbFile, content, _author); 2627 2628 if (!_serviceOutputPath.equals(_outputPath)) { 2629 ejbFile = new File( 2630 _outputPath + "/service/persistence/" + entity.getName() + 2631 "Util.java"); 2632 2633 if (ejbFile.exists()) { 2634 System.out.println("Relocating " + ejbFile); 2635 2636 ejbFile.delete(); 2637 } 2638 } 2639 } 2640 2641 private void _createPool(Entity entity) { 2642 File ejbFile = new File( 2643 _outputPath + "/service/persistence/" + entity.getName() + 2644 "Pool.java"); 2645 2646 if (ejbFile.exists()) { 2647 System.out.println("Removing deprecated " + ejbFile); 2648 2649 ejbFile.delete(); 2650 } 2651 } 2652 2653 private void _createProps() throws Exception { 2654 if (Validator.isNull(_pluginName)) { 2655 return; 2656 } 2657 2658 // Content 2659 2660 File propsFile = new File(_implDir + "/service.properties"); 2661 2662 long buildNumber = 1; 2663 long buildDate = System.currentTimeMillis(); 2664 2665 if (propsFile.exists()) { 2666 Properties properties = PropertiesUtil.load( 2667 FileUtil.read(propsFile)); 2668 2669 if (!_buildNumberIncrement) { 2670 buildDate = GetterUtil.getLong( 2671 properties.getProperty("build.date")); 2672 buildNumber = GetterUtil.getLong( 2673 properties.getProperty("build.number")); 2674 } 2675 else { 2676 buildNumber = GetterUtil.getLong( 2677 properties.getProperty("build.number")) + 1; 2678 } 2679 } 2680 2681 if (!_buildNumberIncrement && (buildNumber < _buildNumber)) { 2682 buildNumber = _buildNumber; 2683 buildDate = System.currentTimeMillis(); 2684 } 2685 2686 Map<String, Object> context = _getContext(); 2687 2688 context.put("buildNumber", buildNumber); 2689 context.put("currentTimeMillis", buildDate); 2690 2691 String content = _processTemplate(_tplProps, context); 2692 2693 // Write file 2694 2695 FileUtil.write(propsFile, content, true); 2696 } 2697 2698 private void _createRemotingXml() throws Exception { 2699 StringBundler sb = new StringBundler(); 2700 2701 Document document = SAXReaderUtil.read(new File(_springFileName)); 2702 2703 Element rootElement = document.getRootElement(); 2704 2705 List<Element> beanElements = rootElement.elements("bean"); 2706 2707 for (Element beanElement : beanElements) { 2708 String beanId = beanElement.attributeValue("id"); 2709 2710 if (beanId.endsWith("Service") && 2711 !beanId.endsWith("LocalService")) { 2712 2713 String entityName = beanId; 2714 2715 entityName = StringUtil.replaceLast( 2716 entityName, ".service.", "."); 2717 2718 int pos = entityName.lastIndexOf("Service"); 2719 2720 entityName = entityName.substring(0, pos); 2721 2722 Entity entity = getEntity(entityName); 2723 2724 String serviceName = beanId; 2725 2726 String serviceMapping = serviceName; 2727 2728 serviceMapping = StringUtil.replaceLast( 2729 serviceMapping, ".service.", ".service.spring."); 2730 serviceMapping = StringUtil.replace( 2731 serviceMapping, StringPool.PERIOD, StringPool.UNDERLINE); 2732 2733 Map<String, Object> context = _getContext(); 2734 2735 context.put("entity", entity); 2736 context.put("serviceName", serviceName); 2737 context.put("serviceMapping", serviceMapping); 2738 2739 sb.append(_processTemplate(_tplRemotingXml, context)); 2740 } 2741 } 2742 2743 File outputFile = new File(_remotingFileName); 2744 2745 if (!outputFile.exists()) { 2746 return; 2747 } 2748 2749 String content = FileUtil.read(outputFile); 2750 String newContent = content; 2751 2752 int x = content.indexOf("<bean "); 2753 int y = content.lastIndexOf("</bean>") + 8; 2754 2755 if (x != -1) { 2756 newContent = 2757 content.substring(0, x - 1) + sb.toString() + 2758 content.substring(y); 2759 } 2760 else { 2761 x = content.indexOf("</beans>"); 2762 2763 if (x != -1) { 2764 newContent = 2765 content.substring(0, x) + sb.toString() + 2766 content.substring(x); 2767 } 2768 else { 2769 x = content.indexOf("<beans/>"); 2770 y = x + 8; 2771 2772 newContent = 2773 content.substring(0, x) + "<beans>" + sb.toString() + 2774 "</beans>" + content.substring(y); 2775 } 2776 } 2777 2778 newContent = _formatXml(newContent); 2779 2780 if (!content.equals(newContent)) { 2781 FileUtil.write(outputFile, newContent); 2782 2783 System.out.println(outputFile.toString()); 2784 } 2785 } 2786 2787 private void _createService(Entity entity, int sessionType) 2788 throws Exception { 2789 2790 JavaClass javaClass = _getJavaClass( 2791 _outputPath + "/service/impl/" + entity.getName() + 2792 _getSessionTypeName(sessionType) + "ServiceImpl.java"); 2793 2794 JavaMethod[] methods = _getMethods(javaClass); 2795 2796 Type superClass = javaClass.getSuperClass(); 2797 2798 String superClassValue = superClass.getValue(); 2799 2800 if (superClassValue.endsWith( 2801 entity.getName() + _getSessionTypeName(sessionType) + 2802 "ServiceBaseImpl")) { 2803 2804 JavaClass parentJavaClass = _getJavaClass( 2805 _outputPath + "/service/base/" + entity.getName() + 2806 _getSessionTypeName(sessionType) + "ServiceBaseImpl.java"); 2807 2808 methods = ArrayUtil.append( 2809 parentJavaClass.getMethods(), methods); 2810 } 2811 2812 Map<String, Object> context = _getContext(); 2813 2814 context.put("entity", entity); 2815 context.put("methods", methods); 2816 context.put("sessionTypeName", _getSessionTypeName(sessionType)); 2817 2818 context = _putDeprecatedKeys(context, javaClass); 2819 2820 // Content 2821 2822 String content = _processTemplate(_tplService, context); 2823 2824 // Write file 2825 2826 File ejbFile = new File( 2827 _serviceOutputPath + "/service/" + entity.getName() + 2828 _getSessionTypeName(sessionType) + "Service.java"); 2829 2830 writeFile(ejbFile, content, _author); 2831 2832 if (!_serviceOutputPath.equals(_outputPath)) { 2833 ejbFile = new File( 2834 _outputPath + "/service/" + entity.getName() + 2835 _getSessionTypeName(sessionType) + "Service.java"); 2836 2837 if (ejbFile.exists()) { 2838 System.out.println("Relocating " + ejbFile); 2839 2840 ejbFile.delete(); 2841 } 2842 } 2843 } 2844 2845 private void _createServiceBaseImpl(Entity entity, int sessionType) 2846 throws Exception { 2847 2848 JavaClass javaClass = _getJavaClass( 2849 _outputPath + "/service/impl/" + entity.getName() + 2850 (sessionType != _SESSION_TYPE_REMOTE ? "Local" : "") + 2851 "ServiceImpl.java"); 2852 2853 JavaMethod[] methods = _getMethods(javaClass); 2854 2855 Map<String, Object> context = _getContext(); 2856 2857 context.put("entity", entity); 2858 context.put("methods", methods); 2859 context.put("sessionTypeName",_getSessionTypeName(sessionType)); 2860 context.put( 2861 "referenceList", _mergeReferenceList(entity.getReferenceList())); 2862 2863 context = _putDeprecatedKeys(context, javaClass); 2864 2865 // Content 2866 2867 String content = _processTemplate(_tplServiceBaseImpl, context); 2868 2869 // Write file 2870 2871 File ejbFile = new File( 2872 _outputPath + "/service/base/" + entity.getName() + 2873 _getSessionTypeName(sessionType) + "ServiceBaseImpl.java"); 2874 2875 writeFile(ejbFile, content, _author); 2876 } 2877 2878 private void _createServiceClp(Entity entity, int sessionType) 2879 throws Exception { 2880 2881 if (Validator.isNull(_pluginName)) { 2882 return; 2883 } 2884 2885 JavaClass javaClass = _getJavaClass( 2886 _serviceOutputPath + "/service/" + entity.getName() + 2887 _getSessionTypeName(sessionType) + "Service.java"); 2888 2889 Map<String, Object> context = _getContext(); 2890 2891 context.put("entity", entity); 2892 context.put("methods", _getMethods(javaClass)); 2893 context.put("sessionTypeName", _getSessionTypeName(sessionType)); 2894 2895 context = _putDeprecatedKeys(context, javaClass); 2896 2897 // Content 2898 2899 String content = _processTemplate(_tplServiceClp, context); 2900 2901 // Write file 2902 2903 File ejbFile = new File( 2904 _serviceOutputPath + "/service/" + entity.getName() + 2905 _getSessionTypeName(sessionType) + "ServiceClp.java"); 2906 2907 writeFile(ejbFile, content, _author); 2908 } 2909 2910 private void _createServiceClpInvoker(Entity entity, int sessionType) 2911 throws Exception { 2912 2913 if (Validator.isNull(_pluginName)) { 2914 return; 2915 } 2916 2917 JavaClass javaClass = _getJavaClass( 2918 _outputPath + "/service/impl/" + entity.getName() + 2919 _getSessionTypeName(sessionType) + "ServiceImpl.java"); 2920 2921 JavaMethod[] methods = _getMethods(javaClass); 2922 2923 Type superClass = javaClass.getSuperClass(); 2924 2925 String superClassValue = superClass.getValue(); 2926 2927 if (superClassValue.endsWith( 2928 entity.getName() + _getSessionTypeName(sessionType) + 2929 "ServiceBaseImpl")) { 2930 2931 JavaClass parentJavaClass = _getJavaClass( 2932 _outputPath + "/service/base/" + entity.getName() + 2933 _getSessionTypeName(sessionType) + "ServiceBaseImpl.java"); 2934 2935 methods = ArrayUtil.append( 2936 parentJavaClass.getMethods(), methods); 2937 } 2938 2939 Map<String, Object> context = _getContext(); 2940 2941 context.put("entity", entity); 2942 context.put("methods", methods); 2943 context.put("sessionTypeName", _getSessionTypeName(sessionType)); 2944 2945 context = _putDeprecatedKeys(context, javaClass); 2946 2947 // Content 2948 2949 String content = _processTemplate(_tplServiceClpInvoker, context); 2950 2951 // Write file 2952 2953 File ejbFile = new File( 2954 _outputPath + "/service/base/" + entity.getName() + 2955 _getSessionTypeName(sessionType) + "ServiceClpInvoker.java"); 2956 2957 writeFile(ejbFile, content, _author); 2958 } 2959 2960 private void _createServiceClpMessageListener() throws Exception { 2961 if (Validator.isNull(_pluginName)) { 2962 return; 2963 } 2964 2965 Map<String, Object> context = _getContext(); 2966 2967 context.put("entities", _ejbList); 2968 2969 // Content 2970 2971 String content = _processTemplate( 2972 _tplServiceClpMessageListener, context); 2973 2974 // Write file 2975 2976 File ejbFile = new File( 2977 _serviceOutputPath + "/service/messaging/ClpMessageListener.java"); 2978 2979 writeFile(ejbFile, content, _author); 2980 } 2981 2982 private void _createServiceClpSerializer(List<String> exceptions) 2983 throws Exception { 2984 2985 if (Validator.isNull(_pluginName)) { 2986 return; 2987 } 2988 2989 Map<String, Object> context = _getContext(); 2990 2991 context.put("entities", _ejbList); 2992 context.put("exceptions", exceptions); 2993 2994 // Content 2995 2996 String content = _processTemplate(_tplServiceClpSerializer, context); 2997 2998 // Write file 2999 3000 File ejbFile = new File( 3001 _serviceOutputPath + "/service/ClpSerializer.java"); 3002 3003 writeFile(ejbFile, content, _author); 3004 } 3005 3006 private void _createServiceFactory(Entity entity, int sessionType) { 3007 File ejbFile = new File( 3008 _serviceOutputPath + "/service/" + entity.getName() + 3009 _getSessionTypeName(sessionType) + "ServiceFactory.java"); 3010 3011 if (ejbFile.exists()) { 3012 System.out.println("Removing deprecated " + ejbFile); 3013 3014 ejbFile.delete(); 3015 } 3016 3017 ejbFile = new File( 3018 _outputPath + "/service/" + entity.getName() + 3019 _getSessionTypeName(sessionType) + "ServiceFactory.java"); 3020 3021 if (ejbFile.exists()) { 3022 System.out.println("Removing deprecated " + ejbFile); 3023 3024 ejbFile.delete(); 3025 } 3026 } 3027 3028 private void _createServiceHttp(Entity entity) throws Exception { 3029 JavaClass javaClass = _getJavaClass( 3030 _outputPath + "/service/impl/" + entity.getName() + 3031 "ServiceImpl.java"); 3032 3033 Map<String, Object> context = _getContext(); 3034 3035 context.put("entity", entity); 3036 context.put("methods", _getMethods(javaClass)); 3037 context.put("hasHttpMethods", new Boolean(_hasHttpMethods(javaClass))); 3038 3039 context = _putDeprecatedKeys(context, javaClass); 3040 3041 // Content 3042 3043 String content = _processTemplate(_tplServiceHttp, context); 3044 3045 // Write file 3046 3047 File ejbFile = new File( 3048 _outputPath + "/service/http/" + entity.getName() + 3049 "ServiceHttp.java"); 3050 3051 writeFile(ejbFile, content, _author); 3052 } 3053 3054 private void _createServiceImpl(Entity entity, int sessionType) 3055 throws Exception { 3056 3057 Map<String, Object> context = _getContext(); 3058 3059 context.put("entity", entity); 3060 context.put("sessionTypeName", _getSessionTypeName(sessionType)); 3061 3062 // Content 3063 3064 String content = _processTemplate(_tplServiceImpl, context); 3065 3066 // Write file 3067 3068 File ejbFile = new File( 3069 _outputPath + "/service/impl/" + entity.getName() + 3070 _getSessionTypeName(sessionType) + "ServiceImpl.java"); 3071 3072 if (!ejbFile.exists()) { 3073 writeFile(ejbFile, content, _author); 3074 } 3075 } 3076 3077 private void _createServiceJson(Entity entity) { 3078 File ejbFile = new File( 3079 _outputPath + "/service/http/" + entity.getName() + 3080 "ServiceJSON.java"); 3081 3082 if (ejbFile.exists()) { 3083 System.out.println("Removing deprecated " + ejbFile); 3084 3085 ejbFile.delete(); 3086 } 3087 } 3088 3089 private void _createServiceJsonSerializer(Entity entity) { 3090 File ejbFile = new File( 3091 _serviceOutputPath + "/service/http/" + entity.getName() + 3092 "JSONSerializer.java"); 3093 3094 if (ejbFile.exists()) { 3095 System.out.println("Removing deprecated " + ejbFile); 3096 3097 ejbFile.delete(); 3098 } 3099 3100 if (!_serviceOutputPath.equals(_outputPath)) { 3101 ejbFile = new File( 3102 _outputPath + "/service/http/" + entity.getName() + 3103 "JSONSerializer.java"); 3104 3105 if (ejbFile.exists()) { 3106 System.out.println("Removing deprecated " + ejbFile); 3107 3108 ejbFile.delete(); 3109 } 3110 } 3111 } 3112 3113 private void _createServiceSoap(Entity entity) throws Exception { 3114 JavaClass javaClass = _getJavaClass( 3115 _outputPath + "/service/impl/" + entity.getName() + 3116 "ServiceImpl.java"); 3117 3118 Map<String, Object> context = _getContext(); 3119 3120 context.put("entity", entity); 3121 context.put("methods", _getMethods(javaClass)); 3122 3123 context = _putDeprecatedKeys(context, javaClass); 3124 3125 // Content 3126 3127 String content = _processTemplate(_tplServiceSoap, context); 3128 3129 // Write file 3130 3131 File ejbFile = new File( 3132 _outputPath + "/service/http/" + entity.getName() + 3133 "ServiceSoap.java"); 3134 3135 writeFile(ejbFile, content, _author); 3136 } 3137 3138 private void _createServiceUtil(Entity entity, int sessionType) 3139 throws Exception { 3140 3141 JavaClass javaClass = _getJavaClass( 3142 _serviceOutputPath + "/service/" + entity.getName() + 3143 _getSessionTypeName(sessionType) + "Service.java"); 3144 3145 Map<String, Object> context = _getContext(); 3146 3147 context.put("entity", entity); 3148 context.put("methods", _getMethods(javaClass)); 3149 context.put("sessionTypeName", _getSessionTypeName(sessionType)); 3150 3151 context = _putDeprecatedKeys(context, javaClass); 3152 3153 // Content 3154 3155 String content = _processTemplate(_tplServiceUtil, context); 3156 3157 // Write file 3158 3159 File ejbFile = new File( 3160 _serviceOutputPath + "/service/" + entity.getName() + 3161 _getSessionTypeName(sessionType) + "ServiceUtil.java"); 3162 3163 writeFile(ejbFile, content, _author); 3164 3165 if (!_serviceOutputPath.equals(_outputPath)) { 3166 ejbFile = new File( 3167 _outputPath + "/service/" + entity.getName() + 3168 _getSessionTypeName(sessionType) + "ServiceUtil.java"); 3169 3170 if (ejbFile.exists()) { 3171 System.out.println("Relocating " + ejbFile); 3172 3173 ejbFile.delete(); 3174 } 3175 } 3176 } 3177 3178 private void _createServiceWrapper(Entity entity, int sessionType) 3179 throws Exception { 3180 3181 JavaClass javaClass = _getJavaClass( 3182 _serviceOutputPath + "/service/" + entity.getName() + 3183 _getSessionTypeName(sessionType) + "Service.java"); 3184 3185 Map<String, Object> context = _getContext(); 3186 3187 context.put("entity", entity); 3188 context.put("methods", _getMethods(javaClass)); 3189 context.put("sessionTypeName", _getSessionTypeName(sessionType)); 3190 3191 context = _putDeprecatedKeys(context, javaClass); 3192 3193 // Content 3194 3195 String content = _processTemplate(_tplServiceWrapper, context); 3196 3197 // Write file 3198 3199 File ejbFile = new File( 3200 _serviceOutputPath + "/service/" + entity.getName() + 3201 _getSessionTypeName(sessionType) + "ServiceWrapper.java"); 3202 3203 writeFile(ejbFile, content, _author); 3204 } 3205 3206 private void _createSpringBaseXml() throws Exception { 3207 if (Validator.isNull(_springBaseFileName)) { 3208 return; 3209 } 3210 3211 // Content 3212 3213 String content = _processTemplate(_tplSpringBaseXml); 3214 3215 // Write file 3216 3217 File ejbFile = new File(_springBaseFileName); 3218 3219 FileUtil.write(ejbFile, content, true); 3220 3221 if (Validator.isNotNull(_pluginName)) { 3222 FileUtil.delete( 3223 "docroot/WEB-INF/src/META-INF/data-source-spring.xml"); 3224 FileUtil.delete("docroot/WEB-INF/src/META-INF/misc-spring.xml"); 3225 } 3226 } 3227 3228 private void _createSpringClusterXml() throws Exception { 3229 if (Validator.isNull(_springClusterFileName)) { 3230 return; 3231 } 3232 3233 // Content 3234 3235 String content = _processTemplate(_tplSpringClusterXml); 3236 3237 // Write file 3238 3239 File ejbFile = new File(_springClusterFileName); 3240 3241 FileUtil.write(ejbFile, content, true); 3242 } 3243 3244 private void _createSpringDynamicDataSourceXml() throws Exception { 3245 if (Validator.isNull(_springDynamicDataSourceFileName)) { 3246 return; 3247 } 3248 3249 File ejbFile = new File(_springDynamicDataSourceFileName); 3250 3251 if (ejbFile.exists()) { 3252 System.out.println("Removing deprecated " + ejbFile); 3253 3254 ejbFile.delete(); 3255 } 3256 } 3257 3258 private void _createSpringHibernateXml() throws Exception { 3259 if (Validator.isNull(_springHibernateFileName)) { 3260 return; 3261 } 3262 3263 // Content 3264 3265 String content = _processTemplate(_tplSpringHibernateXml); 3266 3267 // Write file 3268 3269 File ejbFile = new File(_springHibernateFileName); 3270 3271 FileUtil.write(ejbFile, content, true); 3272 } 3273 3274 private void _createSpringInfrastructureXml() throws Exception { 3275 if (Validator.isNull(_springInfrastructureFileName)) { 3276 return; 3277 } 3278 3279 // Content 3280 3281 String content = _processTemplate(_tplSpringInfrastructureXml); 3282 3283 // Write file 3284 3285 File ejbFile = new File(_springInfrastructureFileName); 3286 3287 FileUtil.write(ejbFile, content, true); 3288 } 3289 3290 private void _createSpringShardDataSourceXml() throws Exception { 3291 if (Validator.isNull(_springShardDataSourceFileName)) { 3292 return; 3293 } 3294 3295 // Content 3296 3297 String content = _processTemplate(_tplSpringShardDataSourceXml); 3298 3299 // Write file 3300 3301 File ejbFile = new File(_springShardDataSourceFileName); 3302 3303 FileUtil.write(ejbFile, content, true); 3304 } 3305 3306 private void _createSpringXml() throws Exception { 3307 if (_packagePath.equals("com.liferay.counter")) { 3308 return; 3309 } 3310 3311 Map<String, Object> context = _getContext(); 3312 3313 context.put("entities", _ejbList); 3314 3315 // Content 3316 3317 String content = _processTemplate(_tplSpringXml, context); 3318 3319 File xmlFile = new File(_springFileName); 3320 3321 String xml = 3322 "<?xml version=\"1.0\"?>\n" + 3323 "\n" + 3324 "<beans\n" + 3325 "\tdefault-destroy-method=\"destroy\"\n" + 3326 "\tdefault-init-method=\"afterPropertiesSet\"\n" + 3327 "\txmlns=\"http://www.springframework.org/schema/beans\"\n" + 3328 "\txmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" + 3329 "\txsi:schemaLocation=\"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd\"\n" + 3330 ">\n" + 3331 "</beans>"; 3332 3333 if (!xmlFile.exists()) { 3334 FileUtil.write(xmlFile, xml); 3335 } 3336 3337 String oldContent = FileUtil.read(xmlFile); 3338 3339 if (Validator.isNotNull(_pluginName) && 3340 oldContent.contains("DOCTYPE beans PUBLIC")) { 3341 3342 oldContent = xml; 3343 } 3344 3345 String newContent = _fixSpringXml(oldContent); 3346 3347 int x = oldContent.indexOf("<beans"); 3348 int y = oldContent.lastIndexOf("</beans>"); 3349 3350 int firstSession = newContent.indexOf( 3351 "<bean id=\"" + _packagePath + ".service.", x); 3352 3353 int lastSession = newContent.lastIndexOf( 3354 "<bean id=\"" + _packagePath + ".service.", y); 3355 3356 if ((firstSession == -1) || (firstSession > y)) { 3357 x = newContent.indexOf("</beans>"); 3358 3359 newContent = 3360 newContent.substring(0, x) + content + newContent.substring(x); 3361 } 3362 else { 3363 firstSession = newContent.lastIndexOf("<bean", firstSession) - 1; 3364 3365 int tempLastSession = newContent.indexOf( 3366 "<bean id=\"", lastSession + 1); 3367 3368 if (tempLastSession == -1) { 3369 tempLastSession = newContent.indexOf("</beans>", lastSession); 3370 } 3371 3372 lastSession = tempLastSession; 3373 3374 newContent = 3375 newContent.substring(0, firstSession) + content + 3376 newContent.substring(lastSession); 3377 } 3378 3379 newContent = _formatXml(newContent); 3380 3381 if (!oldContent.equals(newContent)) { 3382 FileUtil.write(xmlFile, newContent); 3383 } 3384 } 3385 3386 private void _createSQLIndexes() throws IOException { 3387 if (!FileUtil.exists(_sqlDir)) { 3388 return; 3389 } 3390 3391 // indexes.sql 3392 3393 File sqlFile = new File(_sqlDir + "/" + _sqlIndexesFileName); 3394 3395 if (!sqlFile.exists()) { 3396 FileUtil.write(sqlFile, ""); 3397 } 3398 3399 Map<String, String> indexSQLs = new TreeMap<String, String>(); 3400 3401 UnsyncBufferedReader unsyncBufferedReader = new UnsyncBufferedReader( 3402 new FileReader(sqlFile)); 3403 3404 while (true) { 3405 String indexSQL = unsyncBufferedReader.readLine(); 3406 3407 if (indexSQL == null) { 3408 break; 3409 } 3410 3411 if (Validator.isNotNull(indexSQL.trim())) { 3412 int pos = indexSQL.indexOf(" on "); 3413 3414 String indexSpec = indexSQL.substring(pos + 4); 3415 3416 indexSQLs.put(indexSpec, indexSQL); 3417 } 3418 } 3419 3420 unsyncBufferedReader.close(); 3421 3422 // indexes.properties 3423 3424 File propsFile = new File( 3425 _sqlDir + "/" + _sqlIndexesPropertiesFileName); 3426 3427 if (!propsFile.exists()) { 3428 FileUtil.write(propsFile, ""); 3429 } 3430 3431 Map<String, String> indexProps = new TreeMap<String, String>(); 3432 3433 unsyncBufferedReader = new UnsyncBufferedReader( 3434 new FileReader(propsFile)); 3435 3436 while (true) { 3437 String indexMapping = unsyncBufferedReader.readLine(); 3438 3439 if (indexMapping == null) { 3440 break; 3441 } 3442 3443 if (Validator.isNotNull(indexMapping.trim())) { 3444 String[] splitIndexMapping = indexMapping.split("\\="); 3445 3446 indexProps.put(splitIndexMapping[1], splitIndexMapping[0]); 3447 } 3448 } 3449 3450 unsyncBufferedReader.close(); 3451 3452 // indexes.sql 3453 3454 for (int i = 0; i < _ejbList.size(); i++) { 3455 Entity entity = _ejbList.get(i); 3456 3457 if (!_isTargetEntity(entity)) { 3458 continue; 3459 } 3460 3461 if (!entity.isDefaultDataSource()) { 3462 continue; 3463 } 3464 3465 List<EntityFinder> finderList = entity.getFinderList(); 3466 3467 for (int j = 0; j < finderList.size(); j++) { 3468 EntityFinder finder = finderList.get(j); 3469 3470 if (finder.isDBIndex()) { 3471 List<String> finderColsNames = new ArrayList<String>(); 3472 3473 List<EntityColumn> finderColsList = finder.getColumns(); 3474 3475 for (int k = 0; k < finderColsList.size(); k++) { 3476 EntityColumn col = finderColsList.get(k); 3477 3478 finderColsNames.add(col.getDBName()); 3479 } 3480 3481 IndexMetadata indexMetadata = 3482 IndexMetadataFactoryUtil.createIndexMetadata( 3483 finder.isUnique(), entity.getTable(), 3484 finderColsNames.toArray( 3485 new String[finderColsNames.size()])); 3486 3487 indexSQLs.put( 3488 indexMetadata.getSpecification(), 3489 indexMetadata.getCreateSQL()); 3490 3491 String finderName = 3492 entity.getTable() + StringPool.PERIOD + 3493 finder.getName(); 3494 3495 indexProps.put(finderName, indexMetadata.getIndexName()); 3496 } 3497 } 3498 } 3499 3500 for (Map.Entry<String, EntityMapping> entry : 3501 _entityMappings.entrySet()) { 3502 3503 EntityMapping entityMapping = entry.getValue(); 3504 3505 _getCreateMappingTableIndex(entityMapping, indexSQLs, indexProps); 3506 } 3507 3508 StringBundler sb = new StringBundler(); 3509 3510 String prevEntityName = null; 3511 3512 for (String indexSQL : indexSQLs.values()) { 3513 int pos = indexSQL.indexOf(" on "); 3514 3515 String indexSQLSuffix = indexSQL.substring(pos + 4); 3516 3517 String entityName = indexSQLSuffix.split(" ")[0]; 3518 3519 if ((prevEntityName != null) && 3520 !prevEntityName.equals(entityName)) { 3521 3522 sb.append("\n"); 3523 } 3524 3525 sb.append(indexSQL); 3526 sb.append("\n"); 3527 3528 prevEntityName = entityName; 3529 } 3530 3531 if (!indexSQLs.isEmpty()) { 3532 sb.setIndex(sb.index() - 1); 3533 } 3534 3535 FileUtil.write(sqlFile, sb.toString(), true); 3536 3537 // indexes.properties 3538 3539 sb.setIndex(0); 3540 3541 prevEntityName = null; 3542 3543 for (String finderName : indexProps.keySet()) { 3544 String indexName = indexProps.get(finderName); 3545 3546 String entityName = finderName.split("\\.")[0]; 3547 3548 if ((prevEntityName != null) && 3549 !prevEntityName.equals(entityName)) { 3550 3551 sb.append("\n"); 3552 } 3553 3554 sb.append(indexName); 3555 sb.append(StringPool.EQUAL); 3556 sb.append(finderName); 3557 sb.append("\n"); 3558 3559 prevEntityName = entityName; 3560 } 3561 3562 if (!indexProps.isEmpty()) { 3563 sb.setIndex(sb.index() - 1); 3564 } 3565 3566 FileUtil.write(propsFile, sb.toString(), true); 3567 } 3568 3569 private void _createSQLMappingTables( 3570 File sqlFile, String newCreateTableString, 3571 EntityMapping entityMapping, boolean addMissingTables) 3572 throws IOException { 3573 3574 if (!sqlFile.exists()) { 3575 FileUtil.write(sqlFile, StringPool.BLANK); 3576 } 3577 3578 String content = FileUtil.read(sqlFile); 3579 3580 int x = content.indexOf( 3581 _SQL_CREATE_TABLE + entityMapping.getTable() + " ("); 3582 int y = content.indexOf(");", x); 3583 3584 if (x != -1) { 3585 String oldCreateTableString = content.substring(x + 1, y); 3586 3587 if (!oldCreateTableString.equals(newCreateTableString)) { 3588 content = 3589 content.substring(0, x) + newCreateTableString + 3590 content.substring(y + 2); 3591 3592 FileUtil.write(sqlFile, content); 3593 } 3594 } 3595 else if (addMissingTables) { 3596 StringBundler sb = new StringBundler(); 3597 3598 UnsyncBufferedReader unsyncBufferedReader = 3599 new UnsyncBufferedReader(new UnsyncStringReader(content)); 3600 3601 String line = null; 3602 boolean appendNewTable = true; 3603 3604 while ((line = unsyncBufferedReader.readLine()) != null) { 3605 if (appendNewTable && line.startsWith(_SQL_CREATE_TABLE)) { 3606 x = _SQL_CREATE_TABLE.length(); 3607 y = line.indexOf(" ", x); 3608 3609 String tableName = line.substring(x, y); 3610 3611 if (tableName.compareTo(entityMapping.getTable()) > 0) { 3612 sb.append(newCreateTableString); 3613 sb.append("\n\n"); 3614 3615 appendNewTable = false; 3616 } 3617 } 3618 3619 sb.append(line); 3620 sb.append("\n"); 3621 } 3622 3623 if (appendNewTable) { 3624 sb.append("\n"); 3625 sb.append(newCreateTableString); 3626 } 3627 3628 unsyncBufferedReader.close(); 3629 3630 FileUtil.write(sqlFile, sb.toString(), true); 3631 } 3632 } 3633 3634 private void _createSQLSequences() throws IOException { 3635 if (!FileUtil.exists(_sqlDir)) { 3636 return; 3637 } 3638 3639 File sqlFile = new File(_sqlDir + "/" + _sqlSequencesFileName); 3640 3641 if (!sqlFile.exists()) { 3642 FileUtil.write(sqlFile, ""); 3643 } 3644 3645 Set<String> sequenceSQLs = new TreeSet<String>(); 3646 3647 UnsyncBufferedReader unsyncBufferedReader = new UnsyncBufferedReader( 3648 new FileReader(sqlFile)); 3649 3650 while (true) { 3651 String sequenceSQL = unsyncBufferedReader.readLine(); 3652 3653 if (sequenceSQL == null) { 3654 break; 3655 } 3656 3657 if (Validator.isNotNull(sequenceSQL)) { 3658 sequenceSQLs.add(sequenceSQL); 3659 } 3660 } 3661 3662 unsyncBufferedReader.close(); 3663 3664 for (int i = 0; i < _ejbList.size(); i++) { 3665 Entity entity = _ejbList.get(i); 3666 3667 if (!_isTargetEntity(entity)) { 3668 continue; 3669 } 3670 3671 if (!entity.isDefaultDataSource()) { 3672 continue; 3673 } 3674 3675 List<EntityColumn> columnList = entity.getColumnList(); 3676 3677 for (int j = 0; j < columnList.size(); j++) { 3678 EntityColumn column = columnList.get(j); 3679 3680 if ("sequence".equals(column.getIdType())) { 3681 StringBundler sb = new StringBundler(); 3682 3683 String sequenceName = column.getIdParam(); 3684 3685 if (sequenceName.length() > 30) { 3686 sequenceName = sequenceName.substring(0, 30); 3687 } 3688 3689 sb.append("create sequence "); 3690 sb.append(sequenceName); 3691 sb.append(";"); 3692 3693 String sequenceSQL = sb.toString(); 3694 3695 if (!sequenceSQLs.contains(sequenceSQL)) { 3696 sequenceSQLs.add(sequenceSQL); 3697 } 3698 } 3699 } 3700 } 3701 3702 StringBundler sb = new StringBundler(sequenceSQLs.size() * 2); 3703 3704 for (String sequenceSQL : sequenceSQLs) { 3705 sb.append(sequenceSQL); 3706 sb.append("\n"); 3707 } 3708 3709 if (!sequenceSQLs.isEmpty()) { 3710 sb.setIndex(sb.index() - 1); 3711 } 3712 3713 FileUtil.write(sqlFile, sb.toString(), true); 3714 } 3715 3716 private void _createSQLTables() throws IOException { 3717 if (!FileUtil.exists(_sqlDir)) { 3718 return; 3719 } 3720 3721 File sqlFile = new File(_sqlDir + "/" + _sqlFileName); 3722 3723 if (!sqlFile.exists()) { 3724 FileUtil.write(sqlFile, StringPool.BLANK); 3725 } 3726 3727 for (int i = 0; i < _ejbList.size(); i++) { 3728 Entity entity = _ejbList.get(i); 3729 3730 if (!_isTargetEntity(entity)) { 3731 continue; 3732 } 3733 3734 if (!entity.isDefaultDataSource()) { 3735 continue; 3736 } 3737 3738 String createTableSQL = _getCreateTableSQL(entity); 3739 3740 if (Validator.isNotNull(createTableSQL)) { 3741 _createSQLTables(sqlFile, createTableSQL, entity, true); 3742 3743 _updateSQLFile( 3744 "update-6.1.1-6.2.0.sql", createTableSQL, entity); 3745 } 3746 } 3747 3748 for (Map.Entry<String, EntityMapping> entry : 3749 _entityMappings.entrySet()) { 3750 3751 EntityMapping entityMapping = entry.getValue(); 3752 3753 String createMappingTableSQL = _getCreateMappingTableSQL( 3754 entityMapping); 3755 3756 if (Validator.isNotNull(createMappingTableSQL)) { 3757 _createSQLMappingTables( 3758 sqlFile, createMappingTableSQL, entityMapping, true); 3759 } 3760 } 3761 3762 String content = FileUtil.read(sqlFile); 3763 3764 FileUtil.write(sqlFile, content.trim()); 3765 } 3766 3767 private void _createSQLTables( 3768 File sqlFile, String newCreateTableString, Entity entity, 3769 boolean addMissingTables) 3770 throws IOException { 3771 3772 if (!sqlFile.exists()) { 3773 FileUtil.write(sqlFile, StringPool.BLANK); 3774 } 3775 3776 String content = FileUtil.read(sqlFile); 3777 3778 int x = content.indexOf(_SQL_CREATE_TABLE + entity.getTable() + " ("); 3779 int y = content.indexOf(");", x); 3780 3781 if (x != -1) { 3782 String oldCreateTableString = content.substring(x + 1, y); 3783 3784 if (!oldCreateTableString.equals(newCreateTableString)) { 3785 content = 3786 content.substring(0, x) + newCreateTableString + 3787 content.substring(y + 2); 3788 3789 FileUtil.write(sqlFile, content); 3790 } 3791 } 3792 else if (addMissingTables) { 3793 StringBundler sb = new StringBundler(); 3794 3795 UnsyncBufferedReader unsyncBufferedReader = 3796 new UnsyncBufferedReader(new UnsyncStringReader(content)); 3797 3798 String line = null; 3799 boolean appendNewTable = true; 3800 3801 while ((line = unsyncBufferedReader.readLine()) != null) { 3802 if (appendNewTable && line.startsWith(_SQL_CREATE_TABLE)) { 3803 x = _SQL_CREATE_TABLE.length(); 3804 y = line.indexOf(" ", x); 3805 3806 String tableName = line.substring(x, y); 3807 3808 if (tableName.compareTo(entity.getTable()) > 0) { 3809 sb.append(newCreateTableString); 3810 sb.append("\n\n"); 3811 3812 appendNewTable = false; 3813 } 3814 } 3815 3816 sb.append(line); 3817 sb.append("\n"); 3818 } 3819 3820 if (appendNewTable) { 3821 sb.append("\n"); 3822 sb.append(newCreateTableString); 3823 } 3824 3825 unsyncBufferedReader.close(); 3826 3827 FileUtil.write(sqlFile, sb.toString(), true); 3828 } 3829 } 3830 3831 private String _fixHbmXml(String content) throws IOException { 3832 StringBundler sb = new StringBundler(); 3833 3834 UnsyncBufferedReader unsyncBufferedReader = new UnsyncBufferedReader( 3835 new UnsyncStringReader(content)); 3836 3837 String line = null; 3838 3839 while ((line = unsyncBufferedReader.readLine()) != null) { 3840 if (line.startsWith("\t<class name=\"")) { 3841 line = StringUtil.replace( 3842 line, 3843 new String[] { 3844 ".service.persistence.", "HBM\" table=\"" 3845 }, 3846 new String[] { 3847 ".model.", "\" table=\"" 3848 }); 3849 3850 if (!line.contains(".model.impl.") && 3851 !line.contains("BlobModel")) { 3852 3853 line = StringUtil.replace( 3854 line, 3855 new String[] { 3856 ".model.", "\" table=\"" 3857 }, 3858 new String[] { 3859 ".model.impl.", "Impl\" table=\"" 3860 }); 3861 } 3862 } 3863 3864 sb.append(line); 3865 sb.append('\n'); 3866 } 3867 3868 unsyncBufferedReader.close(); 3869 3870 return sb.toString().trim(); 3871 } 3872 3873 private String _fixSpringXml(String content) { 3874 return StringUtil.replace(content, ".service.spring.", ".service."); 3875 } 3876 3877 private String _formatComment( 3878 String comment, DocletTag[] tags, String indentation) { 3879 3880 StringBundler sb = new StringBundler(); 3881 3882 if (Validator.isNull(comment) && (tags.length <= 0)) { 3883 return sb.toString(); 3884 } 3885 3886 sb.append(indentation); 3887 sb.append("/**\n"); 3888 3889 if (Validator.isNotNull(comment)) { 3890 comment = comment.replaceAll("(?m)^", indentation + " * "); 3891 3892 sb.append(comment); 3893 sb.append("\n"); 3894 3895 if (tags.length > 0) { 3896 sb.append(indentation); 3897 sb.append(" *\n"); 3898 } 3899 } 3900 3901 for (DocletTag tag : tags) { 3902 sb.append(indentation); 3903 sb.append(" * @"); 3904 sb.append(tag.getName()); 3905 sb.append(" "); 3906 sb.append(tag.getValue()); 3907 sb.append("\n"); 3908 } 3909 3910 sb.append(indentation); 3911 sb.append(" */\n"); 3912 3913 return sb.toString(); 3914 } 3915 3916 private String _formatXml(String xml) 3917 throws DocumentException, IOException { 3918 3919 String doctype = null; 3920 3921 int x = xml.indexOf("<!DOCTYPE"); 3922 3923 if (x != -1) { 3924 int y = xml.indexOf(">", x) + 1; 3925 3926 doctype = xml.substring(x, y); 3927 3928 xml = xml.substring(0, x) + "\n" + xml.substring(y); 3929 } 3930 3931 xml = StringUtil.replace(xml, '\r', ""); 3932 xml = XMLFormatter.toString(xml); 3933 xml = StringUtil.replace(xml, "\"/>", "\" />"); 3934 3935 if (Validator.isNotNull(doctype)) { 3936 x = xml.indexOf("?>") + 2; 3937 3938 xml = xml.substring(0, x) + "\n" + doctype + xml.substring(x); 3939 } 3940 3941 return xml; 3942 } 3943 3944 private JavaField[] _getCacheFields(JavaClass javaClass) { 3945 if (javaClass == null) { 3946 return new JavaField[0]; 3947 } 3948 3949 List<JavaField> javaFields = new ArrayList<JavaField>(); 3950 3951 for (JavaField javaField : javaClass.getFields()) { 3952 Annotation[] annotations = javaField.getAnnotations(); 3953 3954 for (Annotation annotation : annotations) { 3955 Type type = annotation.getType(); 3956 3957 String className = type.getFullyQualifiedName(); 3958 3959 if (className.equals(CacheField.class.getName())) { 3960 javaFields.add(javaField); 3961 3962 break; 3963 } 3964 } 3965 } 3966 3967 return javaFields.toArray(new JavaField[javaFields.size()]); 3968 } 3969 3970 private Map<String, Object> _getContext() throws TemplateModelException { 3971 BeansWrapper wrapper = BeansWrapper.getDefaultInstance(); 3972 3973 TemplateHashModel staticModels = wrapper.getStaticModels(); 3974 3975 Map<String, Object> context = new HashMap<String, Object>(); 3976 3977 context.put("hbmFileName", _hbmFileName); 3978 context.put("ormFileName", _ormFileName); 3979 context.put("modelHintsFileName", _modelHintsFileName); 3980 context.put("springFileName", _springFileName); 3981 context.put("springBaseFileName", _springBaseFileName); 3982 context.put("springHibernateFileName", _springHibernateFileName); 3983 context.put( 3984 "springInfrastructureFileName", _springInfrastructureFileName); 3985 context.put("apiDir", _apiDir); 3986 context.put("implDir", _implDir); 3987 context.put("sqlDir", _sqlDir); 3988 context.put("sqlFileName", _sqlFileName); 3989 context.put("beanLocatorUtil", _beanLocatorUtil); 3990 context.put("beanLocatorUtilShortName", _beanLocatorUtilShortName); 3991 context.put("propsUtil", _propsUtil); 3992 context.put("portletName", _portletName); 3993 context.put("portletShortName", _portletShortName); 3994 context.put("portletPackageName", _portletPackageName); 3995 context.put("outputPath", _outputPath); 3996 context.put("serviceOutputPath", _serviceOutputPath); 3997 context.put("packagePath", _packagePath); 3998 context.put("pluginName", _pluginName); 3999 context.put("author", _author); 4000 context.put("serviceBuilder", this); 4001 4002 context.put("arrayUtil", ArrayUtil_IW.getInstance()); 4003 context.put("modelHintsUtil", ModelHintsUtil.getModelHints()); 4004 context.put( 4005 "resourceActionsUtil", ResourceActionsUtil.getResourceActions()); 4006 context.put("stringUtil", StringUtil_IW.getInstance()); 4007 context.put("system", staticModels.get("java.lang.System")); 4008 context.put("tempMap", wrapper.wrap(new HashMap<String, Object>())); 4009 context.put( 4010 "textFormatter", staticModels.get(TextFormatter.class.getName())); 4011 context.put("validator", Validator_IW.getInstance()); 4012 4013 return context; 4014 } 4015 4016 private void _getCreateMappingTableIndex( 4017 EntityMapping entityMapping, Map<String, String> indexSQLs, 4018 Map<String, String> indexProps) 4019 throws IOException { 4020 4021 Entity[] entities = new Entity[2]; 4022 4023 for (int i = 0; i < entities.length; i++) { 4024 entities[i] = getEntity(entityMapping.getEntity(i)); 4025 4026 if (entities[i] == null) { 4027 return; 4028 } 4029 } 4030 4031 for (Entity entity : entities) { 4032 List<EntityColumn> pkList = entity.getPKList(); 4033 4034 for (int j = 0; j < pkList.size(); j++) { 4035 EntityColumn col = pkList.get(j); 4036 4037 String colDBName = col.getDBName(); 4038 4039 String indexSpec = 4040 entityMapping.getTable() + " (" + colDBName + ");"; 4041 4042 String indexHash = StringUtil.toHexString(indexSpec.hashCode()); 4043 4044 indexHash = StringUtil.toUpperCase(indexHash); 4045 4046 String indexName = "IX_" + indexHash; 4047 4048 StringBundler sb = new StringBundler(); 4049 4050 sb.append("create index "); 4051 sb.append(indexName); 4052 sb.append(" on "); 4053 sb.append(indexSpec); 4054 4055 indexSQLs.put(indexSpec, sb.toString()); 4056 4057 String finderName = 4058 entityMapping.getTable() + StringPool.PERIOD + colDBName; 4059 4060 indexProps.put(finderName, indexName); 4061 } 4062 } 4063 } 4064 4065 private String _getCreateMappingTableSQL(EntityMapping entityMapping) 4066 throws IOException { 4067 4068 Entity[] entities = new Entity[2]; 4069 4070 for (int i = 0; i < entities.length; i++) { 4071 entities[i] = getEntity(entityMapping.getEntity(i)); 4072 4073 if (entities[i] == null) { 4074 return null; 4075 } 4076 } 4077 4078 Arrays.sort( 4079 entities, 4080 new Comparator<Entity>() { 4081 4082 @Override 4083 public int compare(Entity entity1, Entity entity2) { 4084 String name1 = entity1.getName(); 4085 String name2 = entity2.getName(); 4086 4087 return name1.compareTo(name2); 4088 } 4089 4090 }); 4091 4092 StringBundler sb = new StringBundler(); 4093 4094 sb.append(_SQL_CREATE_TABLE); 4095 sb.append(entityMapping.getTable()); 4096 sb.append(" (\n"); 4097 4098 for (Entity entity : entities) { 4099 List<EntityColumn> pkList = entity.getPKList(); 4100 4101 for (int i = 0; i < pkList.size(); i++) { 4102 EntityColumn col = pkList.get(i); 4103 4104 String colName = col.getName(); 4105 String colType = col.getType(); 4106 4107 sb.append("\t"); 4108 sb.append(col.getDBName()); 4109 sb.append(" "); 4110 4111 if (StringUtil.equalsIgnoreCase(colType, "boolean")) { 4112 sb.append("BOOLEAN"); 4113 } 4114 else if (StringUtil.equalsIgnoreCase(colType, "double") || 4115 StringUtil.equalsIgnoreCase(colType, "float")) { 4116 4117 sb.append("DOUBLE"); 4118 } 4119 else if (colType.equals("int") || 4120 colType.equals("Integer") || 4121 StringUtil.equalsIgnoreCase(colType, "short")) { 4122 4123 sb.append("INTEGER"); 4124 } 4125 else if (StringUtil.equalsIgnoreCase(colType, "long")) { 4126 sb.append("LONG"); 4127 } 4128 else if (colType.equals("String")) { 4129 Map<String, String> hints = ModelHintsUtil.getHints( 4130 _packagePath + ".model." + entity.getName(), colName); 4131 4132 int maxLength = 75; 4133 4134 if (hints != null) { 4135 maxLength = GetterUtil.getInteger( 4136 hints.get("max-length"), maxLength); 4137 } 4138 4139 if (col.isLocalized()) { 4140 maxLength = 4000; 4141 } 4142 4143 if (maxLength < 4000) { 4144 sb.append("VARCHAR("); 4145 sb.append(maxLength); 4146 sb.append(")"); 4147 } 4148 else if (maxLength == 4000) { 4149 sb.append("STRING"); 4150 } 4151 else if (maxLength > 4000) { 4152 sb.append("TEXT"); 4153 } 4154 } 4155 else if (colType.equals("Date")) { 4156 sb.append("DATE"); 4157 } 4158 else { 4159 sb.append("invalid"); 4160 } 4161 4162 if (col.isPrimary()) { 4163 sb.append(" not null"); 4164 } 4165 else if (colType.equals("Date") || colType.equals("String")) { 4166 sb.append(" null"); 4167 } 4168 4169 sb.append(",\n"); 4170 } 4171 } 4172 4173 sb.append("\tprimary key ("); 4174 4175 for (int i = 0; i < entities.length; i++) { 4176 Entity entity = entities[i]; 4177 4178 List<EntityColumn> pkList = entity.getPKList(); 4179 4180 for (int j = 0; j < pkList.size(); j++) { 4181 EntityColumn col = pkList.get(j); 4182 4183 String colDBName = col.getDBName(); 4184 4185 if ((i != 0) || (j != 0)) { 4186 sb.append(", "); 4187 } 4188 4189 sb.append(colDBName); 4190 } 4191 } 4192 4193 sb.append(")\n"); 4194 sb.append(");"); 4195 4196 return sb.toString(); 4197 } 4198 4199 private String _getCreateTableSQL(Entity entity) { 4200 List<EntityColumn> pkList = entity.getPKList(); 4201 List<EntityColumn> regularColList = entity.getRegularColList(); 4202 4203 if (regularColList.size() == 0) { 4204 return null; 4205 } 4206 4207 StringBundler sb = new StringBundler(); 4208 4209 sb.append(_SQL_CREATE_TABLE); 4210 sb.append(entity.getTable()); 4211 sb.append(" (\n"); 4212 4213 for (int i = 0; i < regularColList.size(); i++) { 4214 EntityColumn col = regularColList.get(i); 4215 4216 String colName = col.getName(); 4217 String colType = col.getType(); 4218 String colIdType = col.getIdType(); 4219 4220 sb.append("\t"); 4221 sb.append(col.getDBName()); 4222 sb.append(" "); 4223 4224 if (StringUtil.equalsIgnoreCase(colType, "boolean")) { 4225 sb.append("BOOLEAN"); 4226 } 4227 else if (StringUtil.equalsIgnoreCase(colType, "double") || 4228 StringUtil.equalsIgnoreCase(colType, "float")) { 4229 4230 sb.append("DOUBLE"); 4231 } 4232 else if (colType.equals("int") || 4233 colType.equals("Integer") || 4234 StringUtil.equalsIgnoreCase(colType, "short")) { 4235 4236 sb.append("INTEGER"); 4237 } 4238 else if (StringUtil.equalsIgnoreCase(colType, "long")) { 4239 sb.append("LONG"); 4240 } 4241 else if (colType.equals("Blob")) { 4242 sb.append("BLOB"); 4243 } 4244 else if (colType.equals("Date")) { 4245 sb.append("DATE"); 4246 } 4247 else if (colType.equals("String")) { 4248 Map<String, String> hints = ModelHintsUtil.getHints( 4249 _packagePath + ".model." + entity.getName(), colName); 4250 4251 int maxLength = 75; 4252 4253 if (hints != null) { 4254 maxLength = GetterUtil.getInteger( 4255 hints.get("max-length"), maxLength); 4256 } 4257 4258 if (col.isLocalized()) { 4259 maxLength = 4000; 4260 } 4261 4262 if (maxLength < 4000) { 4263 sb.append("VARCHAR("); 4264 sb.append(maxLength); 4265 sb.append(")"); 4266 } 4267 else if (maxLength == 4000) { 4268 sb.append("STRING"); 4269 } 4270 else if (maxLength > 4000) { 4271 sb.append("TEXT"); 4272 } 4273 } 4274 else { 4275 sb.append("invalid"); 4276 } 4277 4278 if (col.isPrimary()) { 4279 sb.append(" not null"); 4280 4281 if (!entity.hasCompoundPK()) { 4282 sb.append(" primary key"); 4283 } 4284 } 4285 else if (colType.equals("Date") || colType.equals("String")) { 4286 sb.append(" null"); 4287 } 4288 4289 if (Validator.isNotNull(colIdType) && 4290 colIdType.equals("identity")) { 4291 4292 sb.append(" IDENTITY"); 4293 } 4294 4295 if (((i + 1) != regularColList.size()) || 4296 entity.hasCompoundPK()) { 4297 4298 sb.append(","); 4299 } 4300 4301 sb.append("\n"); 4302 } 4303 4304 if (entity.hasCompoundPK()) { 4305 sb.append("\tprimary key ("); 4306 4307 for (int j = 0; j < pkList.size(); j++) { 4308 EntityColumn pk = pkList.get(j); 4309 4310 sb.append(pk.getDBName()); 4311 4312 if ((j + 1) != pkList.size()) { 4313 sb.append(", "); 4314 } 4315 } 4316 4317 sb.append(")\n"); 4318 } 4319 4320 sb.append(");"); 4321 4322 return sb.toString(); 4323 } 4324 4325 private String _getDimensions(Type type) { 4326 String dimensions = ""; 4327 4328 for (int i = 0; i < type.getDimensions(); i++) { 4329 dimensions += "[]"; 4330 } 4331 4332 return dimensions; 4333 } 4334 4335 private JavaClass _getJavaClass(String fileName) throws IOException { 4336 int pos = fileName.indexOf(_implDir + "/"); 4337 4338 if (pos != -1) { 4339 pos += _implDir.length(); 4340 } 4341 else { 4342 pos = fileName.indexOf(_apiDir + "/") + _apiDir.length(); 4343 } 4344 4345 String srcFile = fileName.substring(pos + 1); 4346 String className = StringUtil.replace( 4347 srcFile.substring(0, srcFile.length() - 5), "/", "."); 4348 4349 JavaClass javaClass = _javaClasses.get(className); 4350 4351 if (javaClass == null) { 4352 ClassLibrary classLibrary = new ClassLibrary(); 4353 4354 classLibrary.addClassLoader(getClass().getClassLoader()); 4355 4356 JavaDocBuilder builder = new JavaDocBuilder(classLibrary); 4357 4358 File file = new File(fileName); 4359 4360 if (!file.exists()) { 4361 return null; 4362 } 4363 4364 builder.addSource(file); 4365 4366 javaClass = builder.getClassByName(className); 4367 4368 _javaClasses.put(className, javaClass); 4369 } 4370 4371 return javaClass; 4372 } 4373 4374 private JavaMethod[] _getMethods(JavaClass javaClass) { 4375 return _getMethods(javaClass, false); 4376 } 4377 4378 private JavaMethod[] _getMethods( 4379 JavaClass javaClass, boolean superclasses) { 4380 4381 JavaMethod[] methods = javaClass.getMethods(superclasses); 4382 4383 for (JavaMethod method : methods) { 4384 Arrays.sort(method.getExceptions()); 4385 } 4386 4387 return methods; 4388 } 4389 4390 private String _getSessionTypeName(int sessionType) { 4391 if (sessionType == _SESSION_TYPE_LOCAL) { 4392 return "Local"; 4393 } 4394 else { 4395 return ""; 4396 } 4397 } 4398 4399 private String _getTplProperty(String key, String defaultValue) { 4400 return System.getProperty("service.tpl." + key, defaultValue); 4401 } 4402 4403 private List<String> _getTransients(Entity entity, boolean parent) 4404 throws Exception { 4405 4406 File modelFile = null; 4407 4408 if (parent) { 4409 modelFile = new File( 4410 _outputPath + "/model/impl/" + entity.getName() + 4411 "ModelImpl.java"); 4412 } 4413 else { 4414 modelFile = new File( 4415 _outputPath + "/model/impl/" + entity.getName() + "Impl.java"); 4416 } 4417 4418 String content = FileUtil.read(modelFile); 4419 4420 Matcher matcher = _getterPattern.matcher(content); 4421 4422 Set<String> getters = new HashSet<String>(); 4423 4424 while (!matcher.hitEnd()) { 4425 boolean found = matcher.find(); 4426 4427 if (found) { 4428 String property = matcher.group(); 4429 4430 if (property.contains("get")) { 4431 property = property.substring( 4432 property.indexOf("get") + 3, property.length() - 1); 4433 } 4434 else { 4435 property = property.substring( 4436 property.indexOf("is") + 2, property.length() - 1); 4437 } 4438 4439 if (!entity.hasColumn(property) && 4440 !entity.hasColumn(Introspector.decapitalize(property))) { 4441 4442 property = Introspector.decapitalize(property); 4443 4444 getters.add(property); 4445 } 4446 } 4447 } 4448 4449 matcher = _setterPattern.matcher(content); 4450 4451 Set<String> setters = new HashSet<String>(); 4452 4453 while (!matcher.hitEnd()) { 4454 boolean found = matcher.find(); 4455 4456 if (found) { 4457 String property = matcher.group(); 4458 4459 property = property.substring( 4460 property.indexOf("set") + 3, property.length() - 1); 4461 4462 if (!entity.hasColumn(property) && 4463 !entity.hasColumn(Introspector.decapitalize(property))) { 4464 4465 property = Introspector.decapitalize(property); 4466 4467 setters.add(property); 4468 } 4469 } 4470 } 4471 4472 getters.retainAll(setters); 4473 4474 List<String> transients = new ArrayList<String>(getters); 4475 4476 Collections.sort(transients); 4477 4478 return transients; 4479 } 4480 4481 private boolean _hasHttpMethods(JavaClass javaClass) { 4482 JavaMethod[] methods = _getMethods(javaClass); 4483 4484 for (JavaMethod javaMethod : methods) { 4485 if (!javaMethod.isConstructor() && javaMethod.isPublic() && 4486 isCustomMethod(javaMethod)) { 4487 4488 return true; 4489 } 4490 } 4491 4492 return false; 4493 } 4494 4495 private boolean _isStringLocaleMap(JavaParameter javaParameter) { 4496 Type type = javaParameter.getType(); 4497 4498 Type[] actualArgumentTypes = type.getActualTypeArguments(); 4499 4500 if (actualArgumentTypes.length != 2) { 4501 return false; 4502 } 4503 4504 if (!_isTypeValue(actualArgumentTypes[0], Locale.class.getName()) || 4505 !_isTypeValue(actualArgumentTypes[1], String.class.getName())) { 4506 4507 return false; 4508 } 4509 4510 return true; 4511 } 4512 4513 private boolean _isTargetEntity(Entity entity) { 4514 if ((_targetEntityName == null) || _targetEntityName.startsWith("$")) { 4515 return true; 4516 } 4517 4518 return _targetEntityName.equals(entity.getName()); 4519 } 4520 4521 private boolean _isTypeValue(Type type, String value) { 4522 return value.equals(type.getValue()); 4523 } 4524 4525 private List<Entity> _mergeReferenceList(List<Entity> referenceList) { 4526 List<Entity> list = new ArrayList<Entity>( 4527 _ejbList.size() + referenceList.size()); 4528 4529 list.addAll(_ejbList); 4530 list.addAll(referenceList); 4531 4532 return list; 4533 } 4534 4535 private void _parseEntity(Element entityElement) throws Exception { 4536 String ejbName = entityElement.attributeValue("name"); 4537 String humanName = entityElement.attributeValue("human-name"); 4538 4539 String table = entityElement.attributeValue("table"); 4540 4541 if (Validator.isNull(table)) { 4542 table = ejbName; 4543 4544 if (_badTableNames.contains(ejbName)) { 4545 table += StringPool.UNDERLINE; 4546 } 4547 4548 if (_autoNamespaceTables) { 4549 table = _portletShortName + StringPool.UNDERLINE + ejbName; 4550 } 4551 } 4552 4553 boolean uuid = GetterUtil.getBoolean( 4554 entityElement.attributeValue("uuid")); 4555 boolean uuidAccessor = GetterUtil.getBoolean( 4556 entityElement.attributeValue("uuid-accessor")); 4557 boolean localService = GetterUtil.getBoolean( 4558 entityElement.attributeValue("local-service")); 4559 boolean remoteService = GetterUtil.getBoolean( 4560 entityElement.attributeValue("remote-service"), true); 4561 String persistenceClass = GetterUtil.getString( 4562 entityElement.attributeValue("persistence-class"), 4563 _packagePath + ".service.persistence." + ejbName + 4564 "PersistenceImpl"); 4565 4566 String finderClass = ""; 4567 4568 if (FileUtil.exists( 4569 _outputPath + "/service/persistence/" + ejbName + 4570 "FinderImpl.java")) { 4571 4572 finderClass = 4573 _packagePath + ".service.persistence." + ejbName + "FinderImpl"; 4574 } 4575 4576 String dataSource = entityElement.attributeValue("data-source"); 4577 String sessionFactory = entityElement.attributeValue("session-factory"); 4578 String txManager = entityElement.attributeValue("tx-manager"); 4579 boolean cacheEnabled = GetterUtil.getBoolean( 4580 entityElement.attributeValue("cache-enabled"), true); 4581 boolean jsonEnabled = GetterUtil.getBoolean( 4582 entityElement.attributeValue("json-enabled"), remoteService); 4583 boolean trashEnabled = GetterUtil.getBoolean( 4584 entityElement.attributeValue("trash-enabled")); 4585 boolean deprecated = GetterUtil.getBoolean( 4586 entityElement.attributeValue("deprecated")); 4587 4588 List<EntityColumn> pkList = new ArrayList<EntityColumn>(); 4589 List<EntityColumn> regularColList = new ArrayList<EntityColumn>(); 4590 List<EntityColumn> blobList = new ArrayList<EntityColumn>(); 4591 List<EntityColumn> collectionList = new ArrayList<EntityColumn>(); 4592 List<EntityColumn> columnList = new ArrayList<EntityColumn>(); 4593 4594 List<Element> columnElements = entityElement.elements("column"); 4595 4596 boolean permissionedModel = false; 4597 4598 if (uuid) { 4599 Element columnElement = SAXReaderUtil.createElement("column"); 4600 4601 columnElement.addAttribute("name", "uuid"); 4602 columnElement.addAttribute("type", "String"); 4603 4604 columnElements.add(0, columnElement); 4605 } 4606 4607 for (Element columnElement : columnElements) { 4608 String columnName = columnElement.attributeValue("name"); 4609 4610 if (columnName.equals("resourceBlockId") && 4611 !ejbName.equals("ResourceBlock")) { 4612 4613 permissionedModel = true; 4614 } 4615 4616 String columnDBName = columnElement.attributeValue("db-name"); 4617 4618 if (Validator.isNull(columnDBName)) { 4619 columnDBName = columnName; 4620 4621 if (_badColumnNames.contains(columnName)) { 4622 columnDBName += StringPool.UNDERLINE; 4623 } 4624 } 4625 4626 String columnType = columnElement.attributeValue("type"); 4627 boolean primary = GetterUtil.getBoolean( 4628 columnElement.attributeValue("primary")); 4629 boolean accessor = GetterUtil.getBoolean( 4630 columnElement.attributeValue("accessor")); 4631 boolean filterPrimary = GetterUtil.getBoolean( 4632 columnElement.attributeValue("filter-primary")); 4633 String collectionEntity = columnElement.attributeValue("entity"); 4634 4635 String mappingTable = columnElement.attributeValue("mapping-table"); 4636 4637 if (Validator.isNotNull(mappingTable)) { 4638 if (_badTableNames.contains(mappingTable)) { 4639 mappingTable += StringPool.UNDERLINE; 4640 } 4641 4642 if (_autoNamespaceTables) { 4643 mappingTable = 4644 _portletShortName + StringPool.UNDERLINE + mappingTable; 4645 } 4646 } 4647 4648 String idType = columnElement.attributeValue("id-type"); 4649 String idParam = columnElement.attributeValue("id-param"); 4650 boolean convertNull = GetterUtil.getBoolean( 4651 columnElement.attributeValue("convert-null"), true); 4652 boolean lazy = GetterUtil.getBoolean( 4653 columnElement.attributeValue("lazy"), true); 4654 boolean localized = GetterUtil.getBoolean( 4655 columnElement.attributeValue("localized")); 4656 boolean colJsonEnabled = GetterUtil.getBoolean( 4657 columnElement.attributeValue("json-enabled"), jsonEnabled); 4658 boolean containerModel = GetterUtil.getBoolean( 4659 columnElement.attributeValue("container-model")); 4660 boolean parentContainerModel = GetterUtil.getBoolean( 4661 columnElement.attributeValue("parent-container-model")); 4662 4663 EntityColumn col = new EntityColumn( 4664 columnName, columnDBName, columnType, primary, accessor, 4665 filterPrimary, collectionEntity, mappingTable, idType, idParam, 4666 convertNull, lazy, localized, colJsonEnabled, containerModel, 4667 parentContainerModel); 4668 4669 if (primary) { 4670 pkList.add(col); 4671 } 4672 4673 if (columnType.equals("Collection")) { 4674 collectionList.add(col); 4675 } 4676 else { 4677 regularColList.add(col); 4678 4679 if (columnType.equals("Blob")) { 4680 blobList.add(col); 4681 } 4682 } 4683 4684 columnList.add(col); 4685 4686 if (Validator.isNotNull(collectionEntity) && 4687 Validator.isNotNull(mappingTable)) { 4688 4689 EntityMapping entityMapping = new EntityMapping( 4690 mappingTable, ejbName, collectionEntity); 4691 4692 int ejbNameWeight = StringUtil.startsWithWeight( 4693 mappingTable, ejbName); 4694 int collectionEntityWeight = StringUtil.startsWithWeight( 4695 mappingTable, collectionEntity); 4696 4697 if ((ejbNameWeight > collectionEntityWeight) || 4698 ((ejbNameWeight == collectionEntityWeight) && 4699 (ejbName.compareTo(collectionEntity) > 0))) { 4700 4701 _entityMappings.put(mappingTable, entityMapping); 4702 } 4703 } 4704 } 4705 4706 EntityOrder order = null; 4707 4708 Element orderElement = entityElement.element("order"); 4709 4710 if (orderElement != null) { 4711 boolean asc = true; 4712 4713 if ((orderElement.attribute("by") != null) && 4714 orderElement.attributeValue("by").equals("desc")) { 4715 4716 asc = false; 4717 } 4718 4719 List<EntityColumn> orderColsList = new ArrayList<EntityColumn>(); 4720 4721 order = new EntityOrder(asc, orderColsList); 4722 4723 List<Element> orderColumnElements = orderElement.elements( 4724 "order-column"); 4725 4726 for (Element orderColElement : orderColumnElements) { 4727 String orderColName = orderColElement.attributeValue("name"); 4728 boolean orderColCaseSensitive = GetterUtil.getBoolean( 4729 orderColElement.attributeValue("case-sensitive"), true); 4730 4731 boolean orderColByAscending = asc; 4732 4733 String orderColBy = GetterUtil.getString( 4734 orderColElement.attributeValue("order-by")); 4735 4736 if (orderColBy.equals("asc")) { 4737 orderColByAscending = true; 4738 } 4739 else if (orderColBy.equals("desc")) { 4740 orderColByAscending = false; 4741 } 4742 4743 EntityColumn col = Entity.getColumn(orderColName, columnList); 4744 4745 col.setOrderColumn(true); 4746 4747 col = (EntityColumn)col.clone(); 4748 4749 col.setCaseSensitive(orderColCaseSensitive); 4750 col.setOrderByAscending(orderColByAscending); 4751 4752 orderColsList.add(col); 4753 } 4754 } 4755 4756 List<EntityFinder> finderList = new ArrayList<EntityFinder>(); 4757 4758 List<Element> finderElements = entityElement.elements("finder"); 4759 4760 if (uuid) { 4761 if (columnList.contains(new EntityColumn("companyId"))) { 4762 Element finderElement = SAXReaderUtil.createElement("finder"); 4763 4764 finderElement.addAttribute("name", "Uuid_C"); 4765 finderElement.addAttribute("return-type", "Collection"); 4766 4767 Element finderColumnElement = finderElement.addElement( 4768 "finder-column"); 4769 4770 finderColumnElement.addAttribute("name", "uuid"); 4771 4772 finderColumnElement = finderElement.addElement("finder-column"); 4773 4774 finderColumnElement.addAttribute("name", "companyId"); 4775 4776 finderElements.add(0, finderElement); 4777 } 4778 4779 if (columnList.contains(new EntityColumn("groupId"))) { 4780 Element finderElement = SAXReaderUtil.createElement("finder"); 4781 4782 if (ejbName.equals("Layout")) { 4783 finderElement.addAttribute("name", "UUID_G_P"); 4784 } 4785 else { 4786 finderElement.addAttribute("name", "UUID_G"); 4787 } 4788 4789 finderElement.addAttribute("return-type", ejbName); 4790 finderElement.addAttribute("unique", "true"); 4791 4792 Element finderColumnElement = finderElement.addElement( 4793 "finder-column"); 4794 4795 finderColumnElement.addAttribute("name", "uuid"); 4796 4797 finderColumnElement = finderElement.addElement("finder-column"); 4798 4799 finderColumnElement.addAttribute("name", "groupId"); 4800 4801 if (ejbName.equals("Layout")) { 4802 finderColumnElement = finderElement.addElement( 4803 "finder-column"); 4804 4805 finderColumnElement.addAttribute("name", "privateLayout"); 4806 } 4807 4808 finderElements.add(0, finderElement); 4809 } 4810 4811 Element finderElement = SAXReaderUtil.createElement("finder"); 4812 4813 finderElement.addAttribute("name", "Uuid"); 4814 finderElement.addAttribute("return-type", "Collection"); 4815 4816 Element finderColumnElement = finderElement.addElement( 4817 "finder-column"); 4818 4819 finderColumnElement.addAttribute("name", "uuid"); 4820 4821 finderElements.add(0, finderElement); 4822 } 4823 4824 if (permissionedModel) { 4825 Element finderElement = SAXReaderUtil.createElement("finder"); 4826 4827 finderElement.addAttribute("name", "ResourceBlockId"); 4828 finderElement.addAttribute("return-type", "Collection"); 4829 4830 Element finderColumnElement = finderElement.addElement( 4831 "finder-column"); 4832 4833 finderColumnElement.addAttribute("name", "resourceBlockId"); 4834 4835 finderElements.add(0, finderElement); 4836 } 4837 4838 String alias = TextFormatter.format(ejbName, TextFormatter.I); 4839 4840 if (_badAliasNames.contains(StringUtil.toLowerCase(alias))) { 4841 alias += StringPool.UNDERLINE; 4842 } 4843 4844 for (Element finderElement : finderElements) { 4845 String finderName = finderElement.attributeValue("name"); 4846 String finderReturn = finderElement.attributeValue("return-type"); 4847 boolean finderUnique = GetterUtil.getBoolean( 4848 finderElement.attributeValue("unique")); 4849 4850 String finderWhere = finderElement.attributeValue("where"); 4851 4852 if (Validator.isNotNull(finderWhere)) { 4853 for (EntityColumn column : columnList) { 4854 String name = column.getName(); 4855 4856 if (finderWhere.contains(name)) { 4857 finderWhere = finderWhere.replaceAll( 4858 name, alias + "." + name); 4859 } 4860 } 4861 } 4862 4863 boolean finderDBIndex = GetterUtil.getBoolean( 4864 finderElement.attributeValue("db-index"), true); 4865 4866 List<EntityColumn> finderColsList = new ArrayList<EntityColumn>(); 4867 4868 List<Element> finderColumnElements = finderElement.elements( 4869 "finder-column"); 4870 4871 for (Element finderColumnElement : finderColumnElements) { 4872 String finderColName = finderColumnElement.attributeValue( 4873 "name"); 4874 boolean finderColCaseSensitive = GetterUtil.getBoolean( 4875 finderColumnElement.attributeValue("case-sensitive"), true); 4876 String finderColComparator = GetterUtil.getString( 4877 finderColumnElement.attributeValue("comparator"), "="); 4878 String finderColArrayableOperator = 4879 GetterUtil.getString( 4880 finderColumnElement.attributeValue( 4881 "arrayable-operator")); 4882 4883 EntityColumn col = Entity.getColumn(finderColName, columnList); 4884 4885 if (!col.isFinderPath()) { 4886 col.setFinderPath(true); 4887 } 4888 4889 col = (EntityColumn)col.clone(); 4890 4891 col.setCaseSensitive(finderColCaseSensitive); 4892 col.setComparator(finderColComparator); 4893 col.setArrayableOperator(finderColArrayableOperator); 4894 4895 finderColsList.add(col); 4896 } 4897 4898 finderList.add( 4899 new EntityFinder( 4900 finderName, finderReturn, finderUnique, finderWhere, 4901 finderDBIndex, finderColsList)); 4902 } 4903 4904 List<Entity> referenceList = new ArrayList<Entity>(); 4905 4906 if (_build) { 4907 if (Validator.isNotNull(_pluginName)) { 4908 for (String config : PropsValues.RESOURCE_ACTIONS_CONFIGS) { 4909 File file = new File(_implDir + "/" + config); 4910 4911 if (file.exists()) { 4912 InputStream inputStream = new FileInputStream(file); 4913 4914 ResourceActionsUtil.read(_pluginName, inputStream); 4915 } 4916 } 4917 } 4918 4919 List<Element> referenceElements = entityElement.elements( 4920 "reference"); 4921 4922 Set<String> referenceSet = new TreeSet<String>(); 4923 4924 for (Element referenceElement : referenceElements) { 4925 String referencePackage = referenceElement.attributeValue( 4926 "package-path"); 4927 String referenceEntity = referenceElement.attributeValue( 4928 "entity"); 4929 4930 referenceSet.add(referencePackage + "." + referenceEntity); 4931 } 4932 4933 if (!_packagePath.equals("com.liferay.counter")) { 4934 referenceSet.add("com.liferay.counter.Counter"); 4935 } 4936 4937 if (!_packagePath.equals("com.liferay.portal")) { 4938 referenceSet.add("com.liferay.portal.Resource"); 4939 referenceSet.add("com.liferay.portal.User"); 4940 } 4941 4942 for (String referenceName : referenceSet) { 4943 referenceList.add(getEntity(referenceName)); 4944 } 4945 } 4946 4947 List<String> txRequiredList = new ArrayList<String>(); 4948 4949 List<Element> txRequiredElements = entityElement.elements( 4950 "tx-required"); 4951 4952 for (Element txRequiredEl : txRequiredElements) { 4953 String txRequired = txRequiredEl.getText(); 4954 4955 txRequiredList.add(txRequired); 4956 } 4957 4958 _ejbList.add( 4959 new Entity( 4960 _packagePath, _portletName, _portletShortName, ejbName, 4961 humanName, table, alias, uuid, uuidAccessor, localService, 4962 remoteService, persistenceClass, finderClass, dataSource, 4963 sessionFactory, txManager, cacheEnabled, jsonEnabled, 4964 trashEnabled, deprecated, pkList, regularColList, blobList, 4965 collectionList, columnList, order, finderList, referenceList, 4966 txRequiredList)); 4967 } 4968 4969 private String _processTemplate(String name) throws Exception { 4970 return _processTemplate(name, _getContext()); 4971 } 4972 4973 private String _processTemplate(String name, Map<String, Object> context) 4974 throws Exception { 4975 4976 return StringUtil.strip(FreeMarkerUtil.process(name, context), '\r'); 4977 } 4978 4979 private Map<String, Object> _putDeprecatedKeys( 4980 Map<String, Object> context, JavaClass javaClass) { 4981 4982 context.put("classDeprecated", false); 4983 4984 DocletTag tag = javaClass.getTagByName("deprecated"); 4985 4986 if (tag != null) { 4987 context.put("classDeprecated", true); 4988 context.put("classDeprecatedComment", tag.getValue()); 4989 } 4990 4991 return context; 4992 } 4993 4994 private Set<String> _readLines(String fileName) throws Exception { 4995 ClassLoader classLoader = getClass().getClassLoader(); 4996 4997 Set<String> lines = new HashSet<String>(); 4998 4999 StringUtil.readLines(classLoader.getResourceAsStream(fileName), lines); 5000 5001 return lines; 5002 } 5003 5004 private void _updateSQLFile( 5005 String sqlFileName, String createTableSQL, Entity entity) 5006 throws IOException { 5007 5008 File updateSQLFile = new File(_sqlDir + "/" + sqlFileName); 5009 5010 if (updateSQLFile.exists()) { 5011 _createSQLTables(updateSQLFile, createTableSQL, entity, false); 5012 } 5013 } 5014 5015 private static final int _SESSION_TYPE_LOCAL = 1; 5016 5017 private static final int _SESSION_TYPE_REMOTE = 0; 5018 5019 private static final String _SQL_CREATE_TABLE = "create table "; 5020 5021 private static final String _TPL_ROOT = 5022 "com/liferay/portal/tools/servicebuilder/dependencies/"; 5023 5024 private static Pattern _getterPattern = Pattern.compile( 5025 "public .* get.*" + Pattern.quote("(") + "|public boolean is.*" + 5026 Pattern.quote("(")); 5027 private static Pattern _setterPattern = Pattern.compile( 5028 "public void set.*" + Pattern.quote("(")); 5029 5030 private String _apiDir; 5031 private String _author; 5032 private boolean _autoNamespaceTables; 5033 private Set<String> _badAliasNames; 5034 private Set<String> _badColumnNames; 5035 private Set<String> _badTableNames; 5036 private String _beanLocatorUtil; 5037 private String _beanLocatorUtilShortName; 5038 private boolean _build; 5039 private long _buildNumber; 5040 private boolean _buildNumberIncrement; 5041 private List<Entity> _ejbList; 5042 private Map<String, EntityMapping> _entityMappings; 5043 private Map<String, Entity> _entityPool = new HashMap<String, Entity>(); 5044 private String _hbmFileName; 5045 private String _implDir; 5046 private Map<String, JavaClass> _javaClasses = 5047 new HashMap<String, JavaClass>(); 5048 private String _modelHintsFileName; 5049 private String _ormFileName; 5050 private String _outputPath; 5051 private String _packagePath; 5052 private String _pluginName; 5053 private String _portletName = StringPool.BLANK; 5054 private String _portletPackageName = StringPool.BLANK; 5055 private String _portletShortName = StringPool.BLANK; 5056 private String _propsUtil; 5057 private String _remotingFileName; 5058 private String _serviceOutputPath; 5059 private String _springBaseFileName; 5060 private String _springClusterFileName; 5061 private String _springDynamicDataSourceFileName; 5062 private String _springFileName; 5063 private String _springHibernateFileName; 5064 private String _springInfrastructureFileName; 5065 private String _springShardDataSourceFileName; 5066 private String _sqlDir; 5067 private String _sqlFileName; 5068 private String _sqlIndexesFileName; 5069 private String _sqlIndexesPropertiesFileName; 5070 private String _sqlSequencesFileName; 5071 private String _targetEntityName; 5072 private String _testDir; 5073 private String _testOutputPath; 5074 private String _tplActionableDynamicQuery = 5075 _TPL_ROOT + "actionable_dynamic_query.ftl"; 5076 private String _tplBadAliasNames = _TPL_ROOT + "bad_alias_names.txt"; 5077 private String _tplBadColumnNames = _TPL_ROOT + "bad_column_names.txt"; 5078 private String _tplBadTableNames = _TPL_ROOT + "bad_table_names.txt"; 5079 private String _tplBlobModel = _TPL_ROOT + "blob_model.ftl"; 5080 private String _tplEjbPk = _TPL_ROOT + "ejb_pk.ftl"; 5081 private String _tplException = _TPL_ROOT + "exception.ftl"; 5082 private String _tplExportActionableDynamicQuery = 5083 _TPL_ROOT + "export_actionable_dynamic_query.ftl"; 5084 private String _tplExtendedModel = _TPL_ROOT + "extended_model.ftl"; 5085 private String _tplExtendedModelBaseImpl = 5086 _TPL_ROOT + "extended_model_base_impl.ftl"; 5087 private String _tplExtendedModelImpl = 5088 _TPL_ROOT + "extended_model_impl.ftl"; 5089 private String _tplFinder = _TPL_ROOT + "finder.ftl"; 5090 private String _tplFinderUtil = _TPL_ROOT + "finder_util.ftl"; 5091 private String _tplHbmXml = _TPL_ROOT + "hbm_xml.ftl"; 5092 private String _tplJsonJs = _TPL_ROOT + "json_js.ftl"; 5093 private String _tplJsonJsMethod = _TPL_ROOT + "json_js_method.ftl"; 5094 private String _tplModel = _TPL_ROOT + "model.ftl"; 5095 private String _tplModelCache = _TPL_ROOT + "model_cache.ftl"; 5096 private String _tplModelClp = _TPL_ROOT + "model_clp.ftl"; 5097 private String _tplModelHintsXml = _TPL_ROOT + "model_hints_xml.ftl"; 5098 private String _tplModelImpl = _TPL_ROOT + "model_impl.ftl"; 5099 private String _tplModelSoap = _TPL_ROOT + "model_soap.ftl"; 5100 private String _tplModelWrapper = _TPL_ROOT + "model_wrapper.ftl"; 5101 private String _tplOrmXml = _TPL_ROOT + "orm_xml.ftl"; 5102 private String _tplPersistence = _TPL_ROOT + "persistence.ftl"; 5103 private String _tplPersistenceImpl = _TPL_ROOT + "persistence_impl.ftl"; 5104 private String _tplPersistenceTest = _TPL_ROOT + "persistence_test.ftl"; 5105 private String _tplPersistenceUtil = _TPL_ROOT + "persistence_util.ftl"; 5106 private String _tplProps = _TPL_ROOT + "props.ftl"; 5107 private String _tplRemotingXml = _TPL_ROOT + "remoting_xml.ftl"; 5108 private String _tplService = _TPL_ROOT + "service.ftl"; 5109 private String _tplServiceBaseImpl = _TPL_ROOT + "service_base_impl.ftl"; 5110 private String _tplServiceClp = _TPL_ROOT + "service_clp.ftl"; 5111 private String _tplServiceClpInvoker = 5112 _TPL_ROOT + "service_clp_invoker.ftl"; 5113 private String _tplServiceClpMessageListener = 5114 _TPL_ROOT + "service_clp_message_listener.ftl"; 5115 private String _tplServiceClpSerializer = 5116 _TPL_ROOT + "service_clp_serializer.ftl"; 5117 private String _tplServiceHttp = _TPL_ROOT + "service_http.ftl"; 5118 private String _tplServiceImpl = _TPL_ROOT + "service_impl.ftl"; 5119 private String _tplServiceSoap = _TPL_ROOT + "service_soap.ftl"; 5120 private String _tplServiceUtil = _TPL_ROOT + "service_util.ftl"; 5121 private String _tplServiceWrapper = _TPL_ROOT + "service_wrapper.ftl"; 5122 private String _tplSpringBaseXml = _TPL_ROOT + "spring_base_xml.ftl"; 5123 private String _tplSpringClusterXml = _TPL_ROOT + "spring_cluster_xml.ftl"; 5124 private String _tplSpringHibernateXml = 5125 _TPL_ROOT + "spring_hibernate_xml.ftl"; 5126 private String _tplSpringInfrastructureXml = 5127 _TPL_ROOT + "spring_infrastructure_xml.ftl"; 5128 private String _tplSpringShardDataSourceXml = 5129 _TPL_ROOT + "spring_shard_data_source_xml.ftl"; 5130 private String _tplSpringXml = _TPL_ROOT + "spring_xml.ftl"; 5131 5132 }