Normalisierung der JSON-Antwort vom Server vor der Aktualisierung des Redux-Status

Question

Es ist mein bevorzugtes Paradigma (und wahrscheinlich jeder), dass der Server nicht interessiert, seine JSON-Antwort serialisieren, da es egal ist, welcher Client es konsumiert. Anders gesagt, meine Django-JSON-Nutzlast ist laut Standards in Schlangenhülsen geschrieben. Bevor dies den Status in meinem Redux-Speicher aktualisieren kann, sollten die Schlüssel gemäß den Javascript-Standards auf camel case gemappt werden. Die Python-Entwickler glauben nicht, dass dies die Mühe wert ist, was er recht hat, aber es fühlt sich einfach falsch an, nicht der Konvention zu folgen.

Wie soll das gehandhabt werden ??

Answer 1

Was ich normalerweise habe, ist eine Middleware, die alle meine Abrufanforderungen verarbeitet. Dort kann ich die Antwort abfangen und die Schlüssel mit humps in camelCase umwandeln.

store.dispatch({ 
    types: ['BEFORE_REQUEST', 'REQUEST_SUCCESS', 'REQUEST_FAIL'], 
    promise: { 
    url: 'some/api.json', 
    params: { x, y }, 
    }, 
}); 

ich in der Regel ein Dienstprogramm der Abruf zu handhaben, aber dies wird Ihnen die Idee auf, wie man:

// fetchMiddleware.js 
export default ({ dispatch, getState }) => next => (action) => { 
    if (typeof action === 'function') { 
    return action(dispatch, getState); 
    } 

    const { promise, types, ...rest } = action; 

    // this middleware expects a promise object in the action, 
    // the object contains all configurations to send the request to 
    // the server, if no promise is defined then it just ignores this action 
    if (!promise) { 
    return next(action); 
    } 

    return fetch(promise.url, promise) 
    .then(response => Promise.resolve(humps.camelizeKeys(response))) 
    .then(data => dispatch({ type: types[1], data })) 
    .catch(error => dispatch({ type: types[2], error })); 
} 

Dann in irgendeiner Komponente oder anderswo, wird die Aktion wie folgt versendet werden befassen sich mit CamelCase Transformation.

Answer 2

Es klingt, als ob Sie möchten, dass ein spezieller Parser und/oder Renderer zwischen Kamelfall und Schlangenfall hin und her wechselt. Wenn Sie Django Rest Framework verwenden, können Sie die JSONRenderer verwenden, um eine neue Unterklasse wie CamelCaseJSONRenderer so zu erstellen, dass es automatisch hin und her wechselt.

Im Grunde wollen Sie eine Funktion implementieren, die etwa wie folgt aussieht:

def to_camelcase(string, lower_first_char=True): 
    """Takes snakecase string and converts to camelcase.""" 
    camelize = ''.join(char.capitalize() for char in word.split('_')) 
    result = (camelize[0].lower() + result[1:]) if lower_first else camelize 
    return result 

def parse(data, lower_first=True): 
    """Camelcase the keys of a dictionary or items of a list.""" 
    if isinstance(data, dict): 
     result = {to_camelcase(k): parse(v) for k, v in data.items()} 
    elif isinstance(data, list): 
     result = [parse(item) for item in data] 
    else: 
     result = data 
    return result 

Sie könnten dann diese Funktionen in den angepassten CamelCaseJSONRenderer laufen und die Renderer auf Ihre Ansichten hinzuzufügen. Auf diese Weise sind alle Python-Objekte auf dem Rücken und Camelcase in Ihrem Javascript.