Developed a telephone management service with a customized address book and a structured API for contact management. Implements CRUD operations (Create, Read, Update, Delete) to efficiently handle contacts, ensuring seamless interaction with the telephone directory through a standardized API interface.

Client-Interaction-with-server-App

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e81cfb25-3536-44cd-ace0-1061764fcf98",
   "metadata": {},
   "source": [
    "#### Importo le librerie che mi servono\n",
    "#### Il client utilizzerà la libreria requests per interagire con il server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b03cdde7-7728-4400-93f3-4e1909d43c68",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78e8e4cb-6d72-4615-87bd-0ee0cae1de02",
   "metadata": {},
   "source": [
    "#### E' necessario specificare il link host (BASE_URL) in quanto il client deve sapere dove inviare le richieste HTTP\n",
    "#### In questo caso il link è composto da una prima parte (127.0.0.1, ovvero il pc locale) e da una seconda parte (:5000, ovvero la porta del server creata da flask)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4aa76c23-4cb5-4a17-abcd-536a0bc16341",
   "metadata": {},
   "outputs": [],
   "source": [
    "BASE_URL = \"http://127.0.0.1:5000\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96891375-25aa-4c91-b442-8120712abaf9",
   "metadata": {},
   "source": [
    "#### A questo punto definisco delle UDF come quelle già create nella serve app.\n",
    "#### A differenza di quelle lato server, queste del client servono per inviare richieste al server, mentre quelle definite nello script server app servono per gestire le richieste ricevute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cd317608-0df7-4cdd-9097-7e4cc70c2a86",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_contact(nome, cognome, email, telefono):\n",
    "    data = {\"Nome\": nome, \"Cognome\": cognome, \"Email\": email, \"Telefono\": telefono}\n",
    "    response = requests.post(f\"{BASE_URL}/contacts\", json=data)\n",
    "    print(response.json())\n",
    "    \n",
    "def get_contact(contact_id):\n",
    "    response = requests.get(f\"{BASE_URL}/contacts/{contact_id}\")\n",
    "    print(response.json())\n",
    "\n",
    "def update_contact(contact_id, nome=None, cognome=None, email=None, telefono=None):\n",
    "    data = {\"Nome\": nome, \"Cognome\": cognome, \"Email\": email, \"Telefono\": telefono}\n",
    "    response = requests.put(f\"{BASE_URL}/contacts/{contact_id}\", json=data)\n",
    "    print(response.json())\n",
    "\n",
    "def delete_contact(contact_id):\n",
    "    response = requests.delete(f\"{BASE_URL}/contacts/{contact_id}\")\n",
    "    print(response.json())\n",
    "    \n",
    "def get_contacts():\n",
    "    response = requests.get(f\"{BASE_URL}/contacts\")\n",
    "    print(response.json())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bedb868d-af41-4391-9dd7-8393c015b77b",
   "metadata": {},
   "source": [
    "#### Eseguo ora alcuni test per verificare se il server funziona, il client riesce a fare correttamente operazioni CRUD\n",
    "#### Creo un nuovo contatto specificando Nome, Cognome, Mail e Numero di cellulare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "96e9154d-87f7-44cb-bc3d-8adcb733693f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'id': 1}\n"
     ]
    }
   ],
   "source": [
    "create_contact(\"Alessandra\", \"Manolas\", \"[email protected]\", \"393313378245\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bde6e8b-02a1-4be5-9660-00ca2f12cff8",
   "metadata": {},
   "source": [
    "#### Provo ora invece a modificare un contatto già esistente in base ala user id, indicando successivamente i nuovi dettagli di contatto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5636999e-66b3-4514-972f-735280de3b7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Cognome': 'Manolo', 'Email': '[email protected]', 'Nome': 'Alexandro', 'Telefono': '393313478242'}\n"
     ]
    }
   ],
   "source": [
    "update_contact(1, \"Alexandro\", \"Manolo\", \"[email protected]\", \"393313478242\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f9d89de-cb79-47d1-a8d3-43f080b655d0",
   "metadata": {},
   "source": [
    "#### Provo ora invece ad eliminare un contatto indicando la user id:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "99a9940b-95cc-4462-8562-e1f891ef57fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'message': 'Contatto eliminato'}\n"
     ]
    }
   ],
   "source": [
    "delete_contact(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92bd388c-69a9-4f2a-9798-c96a61dc1e5e",
   "metadata": {},
   "source": [
    "### Infine, provo a eseguire contemporaneamente due operazioni di CRUD, una per creare un contatto nuovo ed una per vedere tutti i contatti presenti in questo momento nel server:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0fdb76fc-fb56-4894-a642-0102435d738d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'id': 3}\n",
      "{'2': {'Cognome': 'Rossi', 'Email': '[email protected]', 'Nome': 'Mario', 'Telefono': '1234567890'}, '3': {'Cognome': 'Rossi', 'Email': '[email protected]', 'Nome': 'Mario', 'Telefono': '1234567890'}}\n"
     ]
    }
   ],
   "source": [
    "# Esempio di utilizzo\n",
    "if __name__ == \"__main__\":\n",
    "    create_contact(\"Mario\", \"Rossi\", \"[email protected]\", \"1234567890\")\n",
    "    get_contacts()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}

Server-APP.py

# Importo le librerie che mi servono per creare un server python
#jsonify fa parte del framework Flask in Python ed è utilizzata per convertire i dati in un formato JSON valido, che è il formato standard per lo scambio di dati nelle API RESTful
from flask import Flask, request, jsonify 

# Cre l'app server utilizzando la libreria importata sopra denominata Flask;
app = Flask(__name__)

# Simula un database in memoria
# In questo caso indico che il primo id è pari a 1 e che i contatti saranno salvati in un formato python dictionary:
contacts = {}
next_id = 1

# Le righe successive, rappresentano le API utili per poi poter interarige correttamente con il server.
# Le UDF saranno ripetute anche nell'altra scritp al fine di poter interagire correttamente.
# Nello specifico, sono state definite le seguenti API.
# Definiamo le rotte RESTful per ogni operazione CRUD:
# - POST /contacts: per creare un nuovo contatto.
# - GET /contacts: per recuperare tutti i contatti.
# - GET /contacts/<id>: per recuperare un contatto specifico.
# - PUT /contacts/<id>: per aggiornare un contatto.
# - DELETE /contacts/<id>: per eliminare un contatto.

# UDF per creare un un nuovo contatto all'interno del server:
@app.route('/contacts', methods=['POST'])
def create_contact():
    global next_id
    data = request.json
    contact_id = next_id
    next_id += 1 # userid incrementale
    contacts[contact_id] = {
        "Nome": data["Nome"],
        "Cognome": data["Cognome"],
        "Email": data["Email"],
        "Telefono": data["Telefono"]
    } # Composizione del python dictionary composto da 4 campi: Nome, Cognome, Email, Telefono. Come richiesto nell'assigment.
    return jsonify({"id": contact_id}), 201 # Se l'input è stato inserito correttamente, restituisci l'user id.

# UDF per leggere tutti i contattipresenti nel server in questo momento. I contatti sono ordinati in base all'incrementale user id:
@app.route('/contacts', methods=['GET'])
def get_contacts():
    return jsonify(contacts) #jsonfy è 

# UDF per leggere un singolo contato specificandone la user id di riferimento come parametro:
@app.route('/contacts/<int:contact_id>', methods=['GET'])
def get_contact(contact_id):
    contact = contacts.get(contact_id)
    if contact:
        return jsonify(contact)
    return jsonify({"error": "Contatto non trovato"}), 404

# UDF per aggiornare un contatto già presene nel server. Il parametro che serve per modificare le info del contatto è di nuovo la relativa user id.
# Una volta specificata la user id, posso indicare le nuove info di contatto tra apici "" essendo stringhe.
@app.route('/contacts/<int:contact_id>', methods=['PUT'])
def update_contact(contact_id):
    if contact_id in contacts:
        data = request.json
        contacts[contact_id].update({
            "Nome": data.get("Nome", contacts[contact_id]["Nome"]),
            "Cognome": data.get("Cognome", contacts[contact_id]["Cognome"]),
            "Email": data.get("Email", contacts[contact_id]["Email"]),
            "Telefono": data.get("Telefono", contacts[contact_id]["Telefono"])
        })
        return jsonify(contacts[contact_id])
    return jsonify({"error": "Contatto non trovato"}), 404 # Nel caso in cui la user id non avesse trovato corrispondenza, allora viene mostrato un messaggio di errore.

# UDF per cancellare uno specifico contatto.
# Anche in questo caso, bisogna è necessario indicarne la relativa user id.
@app.route('/contacts/<int:contact_id>', methods=['DELETE'])
def delete_contact(contact_id):
    if contact_id in contacts:
        del contacts[contact_id]
        return jsonify({"message": "Contatto eliminato"}), 200
    return jsonify({"error": "Contatto non trovato"}), 404

# Controllare se la server app appena creata sta funzionando oppure no. 
# Se la serve app appena creata con Flask framework di python , verrà mostrato il relativo url: (http://127.0.0.1.5000)
# Al fine di poter eseguire poi le funzioni espresse qui sopra, il qui presente script deve correttamente essere eseguito sulla macchina locale.
if __name__ == '__main__':
    app.run(debug=True)