Affichage des articles dont le libellé est api. Afficher tous les articles
Affichage des articles dont le libellé est api. Afficher tous les articles
11/02/2020

How PostgreSQL triggers works when called with a PostgREST PATCH HTTP request

Wonder what values are set or not inside your new.column_name and old.column_name when you are calling PostgREST with a PATCH request? This article is for you!

Create a private schema for our sample app, we will expose the public schema for our PostgREST API:

create schema private;

A city table:

create table private.city (
    city__id integer not null primary key ,
    name text not null,
    countrycode character(3) not null,
    district text not null,
    population integer not null
);

with some data:

copy private.city (city__id, name, countrycode, district, population) FROM stdin;
1	Kabul	AFG	Kabol	1780000
2	Qandahar	AFG	Qandahar	237500
3	Herat	AFG	Herat	186800
\.

Now let's expose this city private table through PostgREST as a public API (public schema) so we stay clean regarding the Separation of Concerns principle:

create view public.cities as 
	select city__id as id, name, countrycode, district, population 
    from private.city;

Let's add support for the PATCH HTTP verb on our newly created /cities REST endpoint.

create or replace function private.update_city() returns trigger as
$$
begin
    raise exception 'new.name = %, old.name=%, new.countrycode = %, old.countrycode = %', new.name, old.name, new.countrycode, old.countrycode;

    return new;
end;
$$ security definer language plpgsql;


create trigger city_update
    instead of update
    on public.cities
    for each row
execute procedure private.update_city();

Now our function private.update_city() will be called for each rows submitted through PATCH /cities HTTP request. As you can see from update_city function body we print the before/after values of name and countrycode columns in PATCH requests.

What's the value of new.countrycode if I don't specify countrycode property in PATCH request body?

# PATCH /cities?id=eq.1 '{"name": "new_value"}'
curl -H "content-type: application/json" \
	--request PATCH \
    --data '{"name": "new_value"}' http://localhost:3000/cities?id=eq.1 | jq '.message'
new.name = new_value, old.name=Kabul,
new.countrycode = AFG, old.countrycode = AFG
As you can see, the property (column in fact) countrycode was not specified in the PATCH request body but it still defined with its current value in new.countrycode and old.countrycode just like we expected it to be.

What's the value of new.name if I set name as a null value in PATCH request body?

# PATCH /cities?id=eq.1 '{"name": null}'

curl -H "content-type: application/json" \
	--request PATCH \
	--data '{"name": null}' http://localhost:3000/cities?id=eq.1 | jq '.message'
new.name = <NULL>, old.name=Kabul,
new.countrycode = AFG, old.countrycode = AFG

Perfect! Just like we expected. We set name property to null in our PATCH request body thus new.name is set to NULL in our trigger function.

Clone this github repository to try all of this locally. Wonder what SQL conventions you should use? Check out these SQL conventions.

4/09/2020

PostgREST "response.headers guc must be a JSON array composed of objects with a single key and a string value" error

Yep. You are wondering why it's working locally and not in production right? Or maybe why PostgREST login feature is not working at all?

The response.headers guc must be a JSON array composed of objects with a single key and a string value is often related to the fact that some call were made to set a header field but the value to be set was empty. Take a look at your settings.secrets table. If it's empty, that's the problem.

At least on the PostgREST-starter-kit, the settings.secrets table should contains at least 2 rows:

jwt_secretyour_secret_here
jwt_lifetime 3600

Looking for some guidance on PostgREST? How to setup a CI/CD with it? What test strategy to use? As a CTO I've built multiple SaaS with it underneath and now help tech teams build fast, reliable and safer API with PostgREST and PostgreSQL. Hire me on CodeMentor or Malt!

3/14/2015

[BrainDump] Versioning an HTTP API

I sometime share privately what I call a #BrainDump over a specific subject I just learned or thought about. A #BrainDump can be described as a snapshot of my current state of mind (or state of art in the current blog post) over a particular subject.

First step, let's specify an API version

    • ... in the header
      • cons:
        • requires an http client (curl/postman) to test endpoint
      • ... with accept (accept: application/vnd.haveibeenpwned+json; version=2.0)
        • pros:
          • allow the client to specify both a schema and a version
        • cons:
          • just like the other solutions, this one is also not standard: "Per the RFC, accept headers should only be used to specify the media type. Versioning is not media type, therefore using accept headers is IMO misuse.source
      • ... with user-defined header  (X-VersionX-Restful-Interface-Version)
    • ... in the URI
      • pros:
        • easy to try GET requests directly from the browser
      • cons:
        • not standard per HTTP RFC
        • does not respect REST principle
      • ... inside a sub-domain (v1.api.domain.com)
        • pros:
          • easy to configure backends with a reverse-proxy
      • ... inside the path 
        • format: /v1/
          • pros:
            • easy to configure backends with a reverse-proxy
          • used by:
        • format: /YYYYMMDD
          • pros:
            • the client does not need to remember API version
            • the client only asks for the API that was working at YYYYMMDD
          • cons:
            • between the client development and release the API may have changed
          • used by:
      • ... inside the query-string (?v=1)
        • wait, what?
    • ... once the request has been authenticated
      • assumption: each requests needs the be authenticated, then retrieve what API version the authenticated user has configured
      • pros:
        • easy to do analytics on API version usage
        • easy to inform users that access soon-to-be-removed API version
      • cons:
        • an authentication step is required
        • a user can only access to one API version at a time
        • no explicit contract between the client and the server 
        • the API version selection is hidden from the client
      • used by:

Then handle multiple API versions server-side

    • ... forwarding each request to the right API server using a reverse-proxy
      • pros:
        • stale API servers are easier to remove from production
      • cons:
        • it requires (at least) 2 running servers per API version
        • need to maintain multiple HTTP servers (branch) with security patches
        • need to maintain multiple running API servers in various versions
    • ... putting every version inside a single-code base, servers are load-balanced
      • each running server have to handle multiple-versions
      • pros:
        • a lot less duplicated code between handlers
        • easier server management
      • cons:
        • business models are often poluted with old behaviours
    • ... using an API migration middleware server (this is a work-in-progress)
      • assumption: the latest API version always exposes more data than the previous one
        • In other words the huge limitation of that approach is that changes HAVE TO be additive
      • how it works:
        • HTTP front <-> API Middleware Server (APIMS) <-> Up-to-date API Server (APIS)
          • for latency, both the APIMS and the APIS SHOULD be on the same node
          • for availability, of course both the APMS and APIS should be replicated across servers
        • Each HTTP request SHOULD go through the APIMS
          • if the request specify v4 and that latest API version is v6 the middleware
          • APIMS receiving request from client (asking for v4)
            •  -> up(req) (v4->v5)
              •  -> up(req) (v5->v6)
                •  -> forward request to APIS
                  • APIS (v6) process the request
                • <- APIS response
              • <- down(res) (v6->v5)
            • <- down(res) (v5->v4)
          • APIMS sending response to client
          • Note: it should be possible to bypass the APIMS if the requested API version is the latest one
        • a migration file CAN be implemented for each new version (vN-1->vN). Each migration file should implement the above interface
          • up(req: Request, next : Function(error))
            • used to update an API request from vN to vN+1
            • if an `error` is specified in `next` the APIMS can directly answer the request thus breaking the contract
          • down(res: Response, next: Function(error))
            • used to downgrade an API response from vN to vN-1
      • pros:
        • API versioning is decoupled from the API server
        • developers only needs to deploy the latest API version
        • devops only need to ensure the latest API version is running
      • cons:
        • does not handle every case 
          • e.g. a piece of data was available in v1 but is not available in v2 thus the middleware can't add it on the down stage

This post is simply an overview of documented practice, if you know (or better: use) other way to version HTTP API, don't hesitate to share them in the comment section below!
11/30/2009

My (unofficial) Kuripotxt PHP API

If you follow me on twitter, you may have seen these tweets :
Kuripotxt.net, my new free #sms gateway #Hijack (flickr) http://flic.kr/p/7iRJpK 3:38 PM Nov 28th
Kuripotxt.net, my new free sms gateway #Hijack

Kuripotxt, free sms "api": Hijack Part2 http://flic.kr/p/7iVJtm 3:48 PM Nov 28th
Kuripotxt, free sms "api": Hijack part2
Yeah... It works ! (on my blog in less than 1 hour :)
$myGateway = new Kuripotxt();
$myGateway->sendSms(33600000000,"Hello World"); 16 minutes ago

After one hour of development, I am glad to show you a PHP Class for Kuripotxt using the HttpClient library.

Usage:
include "kuripotxt.class.php";

$mySender = new Kuripotxt();
//International number format without "+"
$phoneNumber = 33612345678;
$mySender->sendSms($phoneNumber,'Hello world');//one method


2/15/2009

Algorithme tri de couleur (+ demonstration javascript)

 

Il y a 3 semaines, j’expliquais sur ce blog comment créer un algorithme qui était capable de définir automatiquement la couleur d’un texte par rapport à son arrière plan. Aujourd’hui, je vous propose de trier un set (ou une palette) de couleur.

 

Pour vous faciliter nous faciliter la tâche voici quelques restrictions :

  1. Notre set (ou palette) sera composé de 5 couleurs
  2. Les couleurs devront être triées de la plus claire à la plus foncée (l’inverse est tout aussi possible)

 

En fidèle lecteur de ce blog vous vous souvenez sans doute de cet article où j’expliquais comment réaliser une fonction de tri simple. Grâce à ces deux précédents articles nous sommes capable de réaliser de réaliser une fonction de tri de couleur.

 

La théorie

Pour savoir si une couleur est plus clair ou plus foncée qu’une autre, il suffit de se référer à la luminance de leurs codes HSL. Au lieu de trier des nombres du plus petit au plus grand il faut donc trier les couleurs par leurs composantes HSL de la plus grande (100% : blanc) à la plus petite (0% : noir).

 

L’algorithme

Ce qui nous donne cet algorithme :

tabCouleur = ["0B8C8F", "FCF8BC", "CACF43","2B2825","D6156C"]

//Convertir de HEX en HSL
convertirTableauCouleurHEXversHSL(tabCouleur);

//Le tableau est maintenant de la forme :
//tabCouleur = [[,,], [,,], [,,], [,,], [,,]]

//Luminance de la première couleur : tabCouleur[0][2]

Faire
    Si(tabCouleur[0][2] < tabCouleur[1][2])
        tabCouleur.intervertir(0,1);
    SinonSi(tabCouleur[1][2] < tabCouleur[2][2])
        tabCouleur.intervertir(2,3);
    SinonSi(tabCouleur[2][2] < tabCouleur[3][2])
        tabCouleur.intervertir(2,3);
    SinonSi(tabCouleur[3][2] < tabCouleur[4][2])
        tabCouleur.intervertir(3,4);
TantQue(!(    tabCouleur[0][2] >= tabCouleur[1][2]
        &&     tabCouleur[1][2] >= tabCouleur[2][2]
        &&     tabCouleur[2][2] >= tabCouleur[3][2]
        &&     tabCouleur[3][2] >= tabCouleur[4][2]))

//Convertir de HSL -> HEX
convertirTableauCouleurHSLversHEX(tabCouleur);

L’équivalent Javascript n’est pas très différent. Les fonctions convertirTableauCouleurHEXversHSL et convertirTableauCouleurHSLversHEX vont en fait transformer le code HEXA en RGB puis en HSL et inversement.

 

Pour ce qui est de la méthode intervertir. Elle ne fait rien d’autre qu’une inversion (swap) entre 2 éléments (spécifiés par leurs index) d’un même tableau. Le code Javascript est donc :

var tmp=tabCouleur[x];
tabCouleur[x]=tabCouleur[y];
tabCouleur[y]=tmp;

 

Démonstration en javascript

J’ai réalisé une démonstration en javascript de cet algorithme sur le sous domaine projets. Le script importe dynamiquement (via l’API de ColourLovers) des palettes de couleurs il vous suffit alors de cliquer sur une palette pour la trier.

 

A chaque chargement de l’API, une seconde palette est générée et contient toutes les couleurs des autres palettes le temps de tri est légèrement plus long mais le résultat est là.

 

Pour accéder à la démo de tri des couleurs en javascript c’est par ici.

 

Remarque : Certaines palettes ont déjà leurs couleurs de triées de la plus foncées à la plus clair.

4/25/2008

Ajout d'un flux rss Feedburner

Voila, comme tout blog "hype" et malgré mon antipathie pour ce genre de service, geekfg.blogspot.com à droit à son flux rss Feedburner.

Voici quelques inconvénients que je trouve à Feedburner :
  • FeedBurner est une surcouche à votre flux rss, il va chercher de temps en temps l'information sur votre flux rss, vérifie qu'il n'y a rien de nouveau, et dans le cas contraire met à jour son propre flux. Plus il y a d'intermédiaire moins on a le contrôle, personnellement je n'aime pas ça.
  • Vous externalisez le flux rss (url de type : http://feeds.feedburner.com/****), les statistiques, vous n'avez pas le même contrôle que vous pourriez avoir s'il s'agissait de votre propre plateforme de rss, avec votre propre code.
  • Si du jour au lendemain, Google décide de passer Feedburner payant (sais-t-on jamais) comment allez vous faire pour changer automatiquement l'adresse du flux rss dans les agrégateurs ? Alors vous allez me dire, justement, c'est le but de Feedburner il empêche de changer l'adresse du flux rss si vous changer d'adresse de blog. Mais réfléchissons, il suffit d'une simple redirection 301 vers votre nouvelle adresse de flux rss, et voila !
    • Exemple : votre ancienne adresse de flux rss est la suivante : http://vistarc.info/rss/ et vous souhaitez que la nouvelle adresse soit : http://vistarc.net/rss/ :
      • Remplacer le script du flux rss par (avec les balises php)
        • header('Status: 301 Moved Permanently', false, 301);
          header('Location: http://vistarc.net/rss/');
    • Et c'est tout ! Est-ce 2 lignes de code qui peuvent vous faire passer du côté obscure ?
  • Maintenant un bon côté à FeedBurner est que pour les bloggeurs non développeurs parlant d'IT (cela peut faire un non sens mais pourtant ils sont très très nombreux) c'est un très bon moyen d'obtenir des statistiques facilement ainsi que toute une panoplie d'option de personnalisation pour le flux.
  • Un autre bon point est l'API offerte par FeedBurner notamment pour la visualisation des statistiques du blog.
  • En contre partie j'observe que de plus en plus de société demande l'adresse du flux Feedburner, c'est le cas pour Blogrider, qui m'a demandé, lors de l'inscription, de fournir un flux Feedburner (je crois même que le champs était obligatoire). C'est révoltant! Pour ma part je viens juste d'installer le flux FeedBurner sur ce blog, alors qu'il a été créé le 30 Aout 2004 ! Les données que retournera l'API seront donc clairement erronées puisque bon nombre de personne souscrivant déjà au flux ne sont pas sous FeedBurner.
Ainsi ce termine ma petite analyse sur ce service, ses bons côtés et ses mauvais, je pense tout de même qu'il ne serait pas inintéressant de re-créer un service comme FeedBurner mais en libre, open source, intégrée de base dans les différentes plateformes de blogging (wordpress, dotclear...), cms (nukedclan, xoops...) et tout autre plateforme générant du contenu.
Le service devra être décentralisé, c'est à dire qu'il travail sur le serveur du site même (plus de ressource demandée mais plus de flexibilité au niveau du code). Il devra se mettre à jour automatiquement depuis le serveur mère (même si en écrivant ces lignes, il me vient à l'esprit de large problème de sécurité...puis je plongea dans mes songes)....

Une question me taraude l'esprit, pourquoi Blogspot, qui est la plateforme de blogging de Google, n'inclue-t-elle pas Feedburner par défaut ? Est-ce pour concurrence déloyale ? Google n'arrête pas d'ouvrir de nouveaux services, mais peu sont reliés correctement entre eux (sans doute aussi par soucis de confidentialité et de sécurité), je trouve cela vraiment dommage, et vous ?
4/14/2008

Ecran de veille matrix version 2 [MAJ]

Voila, dans ma série de petit programme en C, cela fait maintenant 1h que je travaille sur un écran de veille Matrix (étant fan de la trilogie), voici donc la première version de cet écran de veille, n'hésitez pas à apporter des commentaires :

http://fg.logiciel.free.fr/lycee/CPI1/Programme_C/ecran_de_veille_matrix_v1.exe

Ps : Le programme est exclusivement créé en ASCII donc impossible de partir dans de la 3D poussée, mais j'espère pouvoir un jour porter le code sous opengl, ou glut...


[MAJ]
Une nouvelle version est disponible à l'adresse ci-dessous :
http://fg.logiciel.free.fr/lycee/CPI1/Programme_C/ecran_de_veille_matrix_v2.exe
Elle incorpore un meilleur rendu par rapport à la version 1 (plus de noir, et d'effet de glissement).

Ma petite librairie Windows

J'ai créé une petite libraire windows que j'utilise de tous mes programmes nécessitant l'utilisation de l'API Windows. Cette petite librairie me permet de :
  • Créer des rectangles *
  • Changer la couleur/arrière plan du texte *
  • Gérer des barres de progression *
  • Gérer les évènements claviers
  • Récupérer la largeur et la hauteur de la console *
  • Passer la console en mode plein écran
  • Remplir/effacer une zone de la console
* fonction utilisé dans le programme de démonstration

Voici donc une petit programme qui dessine une fenêtre, affiche une barre de progression et la fait bouger en fonction du sons. Appuyez sur une touche lorsque vos oreilles crieront de douleurs !

Le programme est disponible ici :
http://fg.logiciel.free.fr/lycee/CPI1/Programme_C/sons.exe

Liste des codes ASCII

Voici un petit programme sous la console windows, qui vous permet de voir la liste des codes ASCII (ainsi que ASCII Extended) disponible sur votre console.

Ce programme est disponible gratuitement à l'adresse : http://fg.logiciel.free.fr/lycee/CPI1/Programme_C/ascii.exe
10/30/2007

"Détournement" de l'API de Twitter pour envoyer des sms groupés

Simon Robic (de SimonRobic.com) m'à demandé comment je faisais pour envoyer des sms groupés à mon staff via l’interface administrateur sur VistaRC. D'où l'objet de ce post.

Ci-joint le pdf de l'article, car Blogger rend très mal le code ^^'.

[MAJ] Révision 1 :
http://vistarc.net/public/1193778828twitter-apirev1-pdf.pdf

Anciennes versions :
http://vistarc.net/public/1193758079twitter-api-pdf.pdf
»
 
 
Made with on a hot august night from an airplane the 19th of March 2017.