> ## Documentation Index
> Fetch the complete documentation index at: https://auth0.generaltranslation.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Applications serveur + API : Implémentation Python pour la tâche Cron

> L’implémentation Python de la tâche Cron du serveur pour le scénario d’architecture Serveur client + API

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        let processedChildren = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          processedChildren = processedChildren.replace(new RegExp(key, "g"), value);
        }
        setProcessedChildren(processedChildren);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
      {processedChildren}
    </CodeBlock>;
};

Dans le cadre du [scénario d’architecture Serveur + API](https://auth0.com/docs/architecture-scenarios/application/server-api), nous expliquerons comment implémenter le processus du serveur dans Python. Veuillez vous référer au document [Scénario d’architecture Serveur + API](https://auth0.com/docs/architecture-scenarios/application/server-api) pour obtenir des informations sur la solution implémentée.

Le code source complet de l’implémentation Python se trouve dans [ce référentiel GitHub](https://github.com/auth0-samples/auth0-pnp-exampleco-timesheets/tree/master/timesheets-cron/python).

<div id="get-an-access-token">
  ## Obtenir un jeton d’accès
</div>

Pour effectuer la requête HTTP vers le point de terminaison Auth0 `/oauth/token` de l’API, nous utiliserons les bibliothèques `json`, `urllib` et `urllib2`.

Voici un exemple d’implémentation :

export const codeExample = `def main():
  import json, urllib, urllib2, httplib

  # Configuration Values
  domain = "{yourDomain}" # Your Auth0 Domain
  api_identifier = "API_IDENTIFIER" # API Identifier of your API
  client_id = "{yourClientId}" # Client ID of your Machine-to-Machine Application
  client_secret = "{yourClientSecret}" # Client Secret of your Machine to Machine Application
  api_url = "http://localhost:8080/timesheets/upload"
  grant_type = "client_credentials" # OAuth 2.0 flow to use

  # Get an access token from Auth0
  base_url = "https://{domain}".format(domain=domain)
  data = urllib.urlencode({'client_id': client_id,
                            'client_secret': client_secret,
                            'audience': api_identifier,
                            'grant_type': grant_type})
  req = urllib2.Request(base_url + "/oauth/token", data, headers={"Accept": "application/x-www-form-urlencoded"})
  response = urllib2.urlopen(req)
  resp_body = response.read()
  oauth = json.loads(resp_body)
  access_token = oauth['access_token']

# Standard boilerplate to call the main() function.
if __name__ == '__main__':
  main()`;

<AuthCodeBlock children={codeExample} language="python" />

Pour la tester, modifiez votre code pour imprimer la variable `access_token` et exécutez le processus en utilisant `python cron.py`.

<div id="invoke-the-api">
  ## Invoquer l’API
</div>

Les étapes que nous suivons pour l’implémentation sont les suivantes :

* Créer un objet JSON contenant les données de la feuille de temps et affectez-le à une variable `timesheet`.
* Ajoutez l’URL de l’API et le contenu de la variable `timesheet` au corps de la requête en utilisant `urllib2.Request`.
* Ajouter l’en-tête `Authorization` à la requête.
* Définir l’en-tête `Content-Type` sur `application/json`.
* Invoquer l’API en utllisant `urllib2.urlopen` et ajouter des fonctions de gestion des erreurs. Récupérer l’API en utilisant `json.loads`  et imprimez-la dans la console.

Voici un exemple d’implémentation (certains codes sont omis par souci de concision) :

```python lines theme={null}
def main():
  # import libraries - code omitted

  # Configuration Values - code omitted

  # Get an Access Token from Auth0 - code omitted

  #Post new timesheet to API
  timesheet = {'user_id': '007',
                          'date': '2017-05-10T17:40:20.095Z',
                          'project': 'StoreZero',
                          'hours': 5}
  req = urllib2.Request(api_url, data = json.dumps(timesheet))
  req.add_header('Authorization', 'Bearer ' + access_token)
  req.add_header('Content-Type', 'application/json')

  try:
    response = urllib2.urlopen(req)
    res = json.loads(response.read())
    print 'Created timesheet ' + str(res['id']) + ' for employee ' + str(res['user_id'])
  except urllib2.HTTPError, e:
    print 'HTTPError = ' + str(e.code) + ' ' + str(e.reason)
  except urllib2.URLError, e:
    print 'URLError = ' + str(e.reason)
  except httplib.HTTPException, e:
    print 'HTTPException'
  except Exception, e:
    print 'Generic Exception' + str(e)

# Standard boilerplate to call the main() function - code omitted
```

Pour la tester, assurez-vous que votre API est en cours d’exécution et lancez le processus en utilisant `python cron.py`.

C’est tout! Vous avez terminé!