web-dev-qa-db-fra.com

Lier une date Grails à partir de paramètres dans un contrôleur

Pourquoi est-il si difficile d'extraire la date de la vue via les paramètres d'un contrôleur Grails?

Je ne veux pas extraire la date à la main comme ceci:

instance.dateX = parseDate(params["dateX_value"])//parseDate is from my helper class

Je veux juste utiliser instance.properties = params.

Dans le modèle, le type est Java.util.Date et dans les paramètres se trouvent toutes les informations: [dateX_month: 'value', dateX_day: 'value', ...]

J'ai cherché sur le net et je n'ai rien trouvé à ce sujet. J'espérais que Grails 1.3.0 pourrait aider mais toujours la même chose.

Je ne peux pas et ne croirai pas que l'extraction de la date à la main est nécessaire!

data-bindingdategrailsgroovycontroller
40
nils petersohn

Version Grails> = 2.3

Un paramètre dans Config.groovy définit les formats de date qui seront utilisés à l'échelle de l'application lors de la liaison des paramètres à un Date

grails.databinding.dateFormats = [
        'MMddyyyy', 'yyyy-MM-dd HH:mm:ss.S', "yyyy-MM-dd'T'hh:mm:ss'Z'"
]

Les formats spécifiés dans grails.databinding.dateFormats sera tenté dans l'ordre dans lequel ils sont inclus dans la liste.

Vous pouvez remplacer ces formats à l'échelle de l'application pour un objet de commande individuel à l'aide de @BindingFormat

import org.grails.databinding.BindingFormat

class Person { 
    @BindingFormat('MMddyyyy') 
    Date birthDate 
}

Version Grails <2.3

je ne peux pas et ne croirai pas que l'extraction de la date à la main est nécessaire!

Votre entêtement est récompensé, il a été possible de lier une date directement depuis bien avant Grails 1.3. Les étapes sont les suivantes:

(1) Créez une classe qui enregistre un éditeur pour votre format de date

import org.springframework.beans.PropertyEditorRegistrar
import org.springframework.beans.PropertyEditorRegistry
import org.springframework.beans.propertyeditors.CustomDateEditor
import Java.text.SimpleDateFormat

public class CustomDateEditorRegistrar implements PropertyEditorRegistrar {

    public void registerCustomEditors(PropertyEditorRegistry registry) {

        String dateFormat = 'yyyy/MM/dd'
        registry.registerCustomEditor(Date, new CustomDateEditor(new SimpleDateFormat(dateFormat), true))
    }
}

(2) Informez Grails de cet éditeur de date en enregistrant le bean suivant dans grails-app/conf/spring/resources.groovy

beans = {
    customPropertyEditorRegistrar(CustomDateEditorRegistrar)
}

(3) Maintenant, lorsque vous envoyez une date dans un paramètre nommé foo au format yyyy/MM/dd il sera automatiquement lié à une propriété nommée foo en utilisant soit:

myDomainObject.properties = params

ou

new MyDomainClass(params)
87
Dónal

Grails 2.1.1 a une nouvelle méthode dans les paramètres pour une analyse sécurisée null facile.

def val = params.date('myDate', 'dd-MM-yyyy')
// or a list for formats
def val = params.date('myDate', ['yyyy-MM-dd', 'yyyyMMdd', 'yyMMdd']) 
// or the format read from messages.properties via the key 'date.myDate.format'
def val = params.date('myDate')

Trouvez-le dans le doc ici

14
Kumar Sambhav

Version Grails> = 3.x

Vous pouvez définir dans application.yml les formats de date en suivant cette syntaxe:

grails:
  databinding:
    dateFormats:
      - 'dd/MM/yyyy'
      - 'dd/MM/yyyy HH:mm:ss'
      - 'yyyy-MM-dd HH:mm:ss.S'
      - "yyyy-MM-dd'T'hh:mm:ss'Z'"
      - "yyyy-MM-dd HH:mm:ss.S z"
      - "yyyy-MM-dd'T'HH:mm:ssX"
11
tgarcia

Avez-vous essayé d'utiliser l'un des plugins de sélection de date Grails?

Ive a eu de bonnes expériences avec le plugin de calendrier .

(Lors de l'utilisation du plug-in de calendrier) Lorsque vous soumettez la demande de sélection de date, vous pouvez automatiquement lier le paramètre de requête à l'objet de domaine que vous souhaitez remplir avec la demande.

Par exemple.

new DomainObject(params)

Vous pouvez également analyser une chaîne de date "aaaa/MM/jj" comme ceci ...

new Date().parse("yyyy/MM/dd", "2010/03/18")
2
tinny

@Don Merci pour la réponse ci-dessus.

Voici une alternative à l'éditeur personnalisé qui vérifie la première date, l'heure et le format de la date.

Groovy, ajoutez simplement des points-virgules pour Java

import Java.text.DateFormat
import Java.text.ParseException
import org.springframework.util.StringUtils
import Java.beans.PropertyEditorSupport

class CustomDateTimeEditor extends PropertyEditorSupport {
    private final Java.text.DateFormat dateTimeFormat
    private final Java.text.DateFormat dateFormat
    private final boolean allowEmpty

    public CustomDateTimeEditor(DateFormat dateTimeFormat, DateFormat dateFormat, boolean allowEmpty) {
        this.dateTimeFormat = dateTimeFormat
        this.dateFormat = dateFormat
        this.allowEmpty = allowEmpty
    }

    /**
     * Parse the Date from the given text, using the specified DateFormat.
     */
    public void setAsText(String   text) throws IllegalArgumentException   {
        if (this.allowEmpty && !StringUtils.hasText(text)) {
            // Treat empty String as null value.
            setValue(null)
        }
        else {
            try {
                setValue(this.dateTimeFormat.parse(text))
            }
            catch (ParseException dtex) {
                try {
                    setValue(this.dateFormat.parse(text))
                }
                catch ( ParseException dex ) {
                    throw new IllegalArgumentException  ("Could not parse date: " + dex.getMessage() + " " + dtex.getMessage() )
                }
            }
        }
    }

    /**
     * Format the Date as String, using the specified DateFormat.
     */
    public String   getAsText() {
        Date   value = (Date) getValue()
        return (value != null ? this.dateFormat.format(value) : "")
    }
}
2
chim

Version Grails> = 2.

Une version localeAware pour convertir les chaînes à ce jour

En src/groovy:

package test

import org.codehaus.groovy.grails.web.servlet.mvc.GrailsWebRequest
import org.grails.databinding.converters.ValueConverter
import org.springframework.context.MessageSource
import org.springframework.web.servlet.LocaleResolver

import javax.servlet.http.HttpServletRequest
import Java.text.SimpleDateFormat

class StringToDateConverter implements ValueConverter {
    MessageSource messageSource
    LocaleResolver localeResolver

    @Override
    boolean canConvert(Object value) {
        return value instanceof String
    }

    @Override
    Object convert(Object value) {
        String format = messageSource.getMessage('default.date.format', null, "dd/MM/yyyy", getLocale())
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format)
        return simpleDateFormat.parse(value)
    }

    @Override
    Class<?> getTargetType() {
        return Date.class
    }

    protected Locale getLocale() {
        def locale
        def request = GrailsWebRequest.lookup()?.currentRequest
        if(request instanceof HttpServletRequest) {
            locale = localeResolver?.resolveLocale(request)
        }
        if(locale == null) {
            locale = Locale.default
        }
        return locale
    }
}

Dans conf/spring/resources.groovy:

beans = {
    defaultDateConverter(StringToDateConverter){
        messageSource = ref('messageSource')
        localeResolver = ref('localeResolver')
    }
}

Le nom du bean 'defaultDateConverter' est vraiment important (pour remplacer le convertisseur de date par défaut)

1
mpccolorado