2016-02-08 11 views
6

In graal 2.4.x non è stato chiamato modello src/templates/scaffolding/Controller.groovy che è stato utilizzato per generare azioni CRUD per ponteggi dinamica come:Grails3 modello di controller per ponteggi dinamica

class BookController { 
     static scaffold = domain.Book 
     static responseFormats = ['html', 'json'] 
} 

In graal 3 (3.1.x) alternate questo file (probabilmente 3.0.x install-templates creato uno per me) non funziona. Esiste un modo per modificare il comportamento predefinito dello scaffold dinamico in Grails 3 (.1)? install-templates crea un file src/main/templates/scaffolding/ScaffoldedController.groovy ma il suo contenuto è simile alla mia classe BookController. La documentazione non dice nulla a riguardo.

risposta

0

Penso che stiate cercando generate-controller.

+0

No. 'generate-controller' crea un file/classe reale per lo scaffolding del controller g particolare classe di dominio. Osserva la situazione in presenza di dozzine di tali file e vorresti modificare alcuni comportamenti a livello di app, ad esempio "ogni azione di salvataggio dovrebbe reindirizzare al precedente controller che chiama azione di modifica" - decine di file da modificare. E 'templates/Controller.groovy' era il file che modellava ogni scaffold dinamico creato al volo dal' static scaffold = domain.class' all'interno del controller. – mkr

1

Dai un'occhiata al comando create-script.

create-script quick ref...

create-script User Guide

che vi permetterà di creare il proprio script per fare la generazione di codice, ma non credo che consente di ottenere l'accesso alle proprietà del dominio Gorm a Grails 3. (1) . In realtà ho pubblicato la mia domanda qui: How can I access GORM object properties in a GroovyScriptCommand?

Prima ho eseguito il comando install-templates e poi il comando create-script, non so se necessario, ma mi ha dato alcuni esempi di modelli limitati da guardare.

Ecco un esempio di quello che ho creato. Ho inserito le istruzioni println solo per vedere quali sono le diverse proprietà sul modello con cui devo lavorare. Si sentono un po 'limitati perché sono tutti basati sull'argomento della riga di comando che inserisci e non un'istanza di un vero artefatto di Grails.

src/main/scripts/geta-creare-schermo-groove:

import grails.build.logging.ConsoleLogger 

description("Creates a GETA scaffolded controller, views, and integration test artifacts") { 
    usage 'geta-create-screen [domain name]' 
    completer org.grails.cli.interactive.completers.DomainClassCompleter 
    argument name:'Controller Name', description:"The name of controller", required:true 
    flag name:'force', description:"Whether to overwrite existing files" 
} 

def model = model(args[0]) 
def overwrite = flag('force') ? true : false 

println "DAC: model.className:..... ${model.className}" 
println "DAC: model.fullName:...... ${model.fullName}" 
println "DAC: model.propertyName:.. ${model.propertyName}" 
println "DAC: model.packageName:... ${model.packageName}" 
println "DAC: model.simpleName:.... ${model.simpleName}" 
println "DAC: model.lowerCaseName:. ${model.lowerCaseName}" 
println "DAC: model.packagePath:... ${model.packagePath}" 

render template: template('scaffolding/EtaController.groovy'), 
    destination: file("grails-app/controllers/${model.packagePath}/${model.convention("Controller")}.groovy"), 
    model: model, 
    overwrite: overwrite 

render template: template('scaffolding/EtaDomainObject.groovy'), 
    destination: file("grails-app/domain/${model.packagePath}/${model.convention("Domain")}.groovy"), 
    model: model, 
    overwrite: overwrite 

render template: template('scaffolding/EtaService.groovy'), 
    destination: file("grails-app/services/${model.packagePath}/${model.convention("Service")}.groovy"), 
    model: model, 
    overwrite: overwrite 

render template: template('scaffolding/EtaGsp.gsp'), 
    destination: file("grails-app/views/${model.packagePath}/${model.propertyName}/${model.propertyName}.gsp"), 
    model: model, 
    overwrite: overwrite 

render template: template('scaffolding/EtaGspTabHeader.gsp'), 
    destination: file("grails-app/views/${model.packagePath}/${model.propertyName}/_tabHeader.gsp"), 
    model: model, 
    overwrite: overwrite 


return true 

Il modello: src/main/templates/ponteggi/EtaController.groovy

<%=packageName ? "package ${packageName}" : ''%> 

class ${className}Controller { 

    static scaffold = ${className} 

    def index(){ 
     render view: "${packageName.replaceAll('\\\\', '/')}/${propertyName}/${propertyName}.gsp" 
    } 

} 

Per eseguire la comando: grails geta-create-screen my.package.MyClass --force --stacktrace --verbose

+0

Interessante, ma questa funzionalità è completamente diversa. La mia domanda riguardava il ponteggio dinamico - qualcosa che imposta il controller in fase di esecuzione utilizzando alcune azioni CRUD. Lo script di comando blocca quelle azioni sul tempo di generazione ed è molto più difficile da mantenere. Se devi cambiare qualcosa, devi rifattorizzare o rigenerare ogni controller generato. In grails 2.x l'impalcatura dinamica ha funzionato come una tale rigenerazione di ogni controller con 'impalcatura statica' nella compilazione di app, quindi è stato sufficiente cambiare il template usato lì, ma in Grails 3 questo non funziona. – mkr

Problemi correlati