Wie man die Reihenfolge der Spalten in der generierten Tabelle ändert (Grails Constraints funktionieren nicht mit dem Mongodb Plugin)

Question

Ich benutze Grails 2.1.1 mit mongodb plugin. Ich habe Probleme mit der Reihenfolge der Spalten in der generierten Liste. Als grails scaffolding guide sagt, dass Sie nur Attribute in constraints Block ordnungsgemäß bestellen müssen.

Meine Domain:

class Section { 

String idName 
String visible 
String required 
String name 
String bold 

static embedded = ['question'] 

List<Question> questions 
static hasMany = [questions : Question] 

static constraints = { 
    idName (blank: false) 
    name (blank: false) 
    visible (blank: false) 
    required (blank: false) 
    bold (blank: false) 
} 

@Override 
public String toString() { 
    name 
} 
} 

aber Spalten sind noch alphabetisch geordnet. Ich benutze statische Scaffolding, also nach Änderungen in den Einschränkungen verwende ich grails generate-all * Befehl und überschreiben alle Dateien.

Und ja, ich habe versucht, Code zu reinigen und zu kompilieren, auch Säuberung und Neustart des Servers (dies integriert mit STS) und Reinigung des Browser-Cache. Gibt es ein Problem mit der Mongo-Datenbank (das Hibernate-Plugin wird deinstalliert)?

Danach habe ich auch Grails Templates installiert. In list.gsp ist es Linie mit Sortier Attribute:

Collections.sort(props, comparator.constructors[0].newInstance([domainClass] as Object[])) 

Jede Idee, wie kann ich diese Arbeit zu erhalten, um ändern, dass ich in Zwänge setzen?

Answer 1

Ein Jira-Problem sollte ausgefüllt werden. Wenn man sieht https://github.com/grails/grails-core/blob/master/grails-crud/src/main/groovy/org/codehaus/groovy/grails/scaffolding/DefaultGrailsTemplateGenerator.groovy

void generateView(GrailsDomainClass domainClass, String viewName, Writer out) { 
    def templateText = getTemplateText("${viewName}.gsp") 

    if (templateText) { 
     def t = engine.createTemplate(templateText) 
     def multiPart = domainClass.properties.find {it.type == ([] as Byte[]).class || it.type == ([] as byte[]).class} 

     boolean hasHibernate = pluginManager?.hasGrailsPlugin('hibernate') 
     def packageName = domainClass.packageName ? "<%@ page import=\"${domainClass.fullName}\" %>" : "" 
     def binding = [pluginManager: pluginManager, 
       packageName: packageName, 
       domainClass: domainClass, 
       multiPart: multiPart, 
       className: domainClass.shortName, 
       propertyName: getPropertyName(domainClass), 
       renderEditor: renderEditor, 
       comparator: hasHibernate ? DomainClassPropertyComparator : SimpleDomainClassPropertyComparator] 

     t.make(binding).writeTo(out) 
    } 

} 

Es ist klar, dass der Anruf Ansichten erzeugen entscheidet SimpleDomainClassPropertyComparator zu verwenden. Grails wurde ursprünglich gebaut, um vom Winterschlaf abhängig zu sein. In den letzten Jahren hat die Welt zusätzliche Persistenzmechanismen eingesetzt. Wenn Sie DomainClassPropertyComparator betrachten, besteht keine Abhängigkeit vom Ruhezustand. Ich denke, der Code sollte testen, ob das domainObject "hasConstraints" entscheidet, welcher Komparator verwendet werden soll, oder einfach DomainClassPropertyComparator verwenden. Das Verhalten ist dasselbe, wenn keine Einschränkungen gefunden werden. Der Aufruf von "hasHibernate" sollte nicht von DefaultGrailsTemplateGenerator benötigt werden.

Als eine Umgehung können Sie die Gerüstvorlagen installieren, bearbeiten Sie _form.gsp und ändern Sie den Vergleich, den es verwendet, zu DomainClassPropertyComparator z. meine _form.gsp

<%=packageName%> 
<% import grails.persistence.Event %> 
<% import org.codehaus.groovy.grails.scaffolding.DomainClassPropertyComparator %> 


<% excludedProps = Event.allEvents.toList() << 'version' << 'dateCreated' << 'lastUpdated' 
    persistentPropNames = domainClass.persistentProperties*.name 
    boolean hasHibernate = pluginManager?.hasGrailsPlugin('hibernate') 
    if (hasHibernate && org.codehaus.groovy.grails.orm.hibernate.cfg.GrailsDomainBinder.getMapping(domainClass)?.identity?.generator == 'assigned') { 
     persistentPropNames << domainClass.identifier.name 
    } 

DomainClassPropertyComparator mattsComparator = new DomainClassPropertyComparator(domainClass) 
comparator = mattsComparator 

props = domainClass.properties.findAll { persistentPropNames.contains(it.name) && !excludedProps.contains(it.name) } 
    Collections.sort(props, comparator) 
    for (p in props) { 
     if (p.embedded) { 
      def embeddedPropNames = p.component.persistentProperties*.name 
      def embeddedProps = p.component.properties.findAll { embeddedPropNames.contains(it.name) && !excludedProps.contains(it.name) } 
      Collections.sort(embeddedProps, comparator) 
      %><fieldset class="embedded"><legend><g:message code="${domainClass.propertyName}.${p.name}.label" default="${p.naturalName}" /></legend><% 
       for (ep in p.component.properties) { 
        renderFieldForProperty(ep, p.component, "${p.name}.") 
       } 
      %></fieldset><% 
     } else { 
      renderFieldForProperty(p, domainClass) 
     } 
    } 

private renderFieldForProperty(p, owningClass, prefix = "") { 
    boolean hasHibernate = pluginManager?.hasGrailsPlugin('hibernate') 
    boolean display = true 
    boolean required = false 
    if (hasHibernate) { 
     cp = owningClass.constrainedProperties[p.name] 
     display = (cp ? cp.display : true) 
     required = (cp ? !(cp.propertyType in [boolean, Boolean]) && !cp.nullable && (cp.propertyType != String || !cp.blank) : false) 
    } 
    if (display) { %> 
<div class="fieldcontain \${hasErrors(bean: ${propertyName}, field: '${prefix}${p.name}', 'error')} ${required ? 'required' : ''}"> 
    <label for="${prefix}${p.name}"> 
     <g:message code="${domainClass.propertyName}.${prefix}${p.name}.label" default="${p.naturalName}" /> 
     <% if (required) { %><span class="required-indicator">*</span><% } %> 
    </label> 
    ${renderEditor(p)} 
</div> 
<% } } %> 

Answer 2

Die Einschränkungen sollten die Ansicht wie beschrieben aktualisieren. Versuchen Sie zu laufen grails generate-all --stacktrace Es ist möglich, dass das Skript beendet wird, bevor die Ansichten entsprechend aktualisiert werden. Eine andere Strategie wäre es, zu überprüfen, ob das Problem in den folgenden Aussagen liegt. Sie loszuwerden und zu überprüfen, ob die Ansichten entsprechend aktualisiert werden, bringt Sie wahrscheinlich näher zur Lösung Ihres Problems.

static embedded = ['question'] 

List<Question> questions 
static hasMany = [questions : Question] 

Hoffe, das hilft!

Answer 3

Nach einigen Tests bin ich mir sicher, dass die Verwendung von nur mongodb plugin ohne Hibernate Plugin einige Gerüstfunktionen deaktiviert. Zum Beispiel wird die constraints-Klausel beim Erzeugen von Sichten weggelassen. Damit dies funktioniert, müssen Sie den Ruhezustand verwenden. Also, wenn Sie automatisch generierten Code haben wollen und immer noch mongodb verwenden, gibt es einen Trick: erstellen, generieren und beenden Projekt mit Ruhezustand, dann für die Produktion deinstallieren Ruhezustand und installieren mongodb.

Answer 4

Wenn Sie die folgende Zeile in der Vorlage Stellung zu nehmen und die Aussicht regenerieren, die Reihenfolge, in den Beschränkungen wird der Auftrag im Gerüstbau seine

//Collections.sort(props, comparator.constructors[0].newInstance([domainClass] as Object[]))