feat: first commit 🎉

Author: CodingMarin

README.md

@@ -0,0 +1,95 @@
+# Flask RESTful API
+
+This is a web application developed with Flask that provides a RESTful API for managing users, posts, messages, and images. The application also includes JWT authentication and CORS support.
+
+## Installation
+
+1. Clone this repository:
+
+    ```bash
+    git clone https://github.com/your_username/your_repository.git
+    cd your_repository
+    ```
+
+2. Create and activate a virtual environment:
+
+    ```bash
+    python3 -m venv venv
+    source venv/bin/activate  # On Windows use `venv\Scripts\activate`
+    ```
+
+3. Install the dependencies:
+
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+## Configuration
+
+Make sure to configure the following variables in your configuration file:
+
+```python
+app.config['JWT_SECRET_KEY'] = 'GRUWIN-ADMIN-ACCOUNT'
+app.config['JWT_ACCESS_TOKEN_EXPIRES'] = False
+```
+
+## Usage
+
+Run the application:
+
+```bash
+flask run
+```
+
+The application will be available at `http://127.0.0.1:5000/`.
+
+## Endpoints
+
+### Authentication
+
+- `POST /signup`: Register new users.
+- `POST /login`: Log in existing users.
+
+### Users
+
+- `GET /users`: Get all users (Requires JWT authentication).
+- `POST /users`: Add a new user.
+- `GET /user/<string:id>`: Get a user by ID (Requires JWT authentication).
+
+### Posts
+
+- `GET /post`: Get all posts (Requires JWT authentication).
+- `POST /post`: Create a new post.
+
+### Image Posts
+
+- `GET /imagepost/<int:postid>`: Get an image post by post ID (Requires JWT authentication).
+- `POST /imagepost`: Create a new image post.
+
+### Messages
+
+- `GET /messages/<string:sender_id>/<string:recipient_id>`: Get messages between two users (Requires JWT authentication).
+- `POST /messages`: Create a new message (Requires JWT authentication).
+- `PUT /messages/<string:id>`: Update a message by ID (Requires JWT authentication).
+- `DELETE /messages/<string:id>`: Delete a message by ID (Requires JWT authentication).
+
+### Emails
+
+- `POST /email`: Send an email (Requires JWT authentication).
+
+### Protected Routes
+
+- `GET /protected`: Protected route that returns a welcome message with the current user's ID (Requires JWT authentication).
+
+## Error Handling
+
+- `404 Not Found`: Returned when the requested URL is not found on the server.
+
+## Dependencies
+
+- Flask
+- Flask-RESTful
+- Flask-JWT-Extended
+- Flask-CORS
+- smtplib
+- email.mime

__init__.py

@@ -0,0 +1,189 @@
+from src.services.userservice import UserService
+from flask import Flask, jsonify, request
+from flask_restful import Api
+from src.models.user import Users, User
+from src.models.post import Posts
+from src.models.message import MessageService
+from src.models.image_post import ImagePost
+from flask_jwt_extended import (
+    JWTManager,
+    jwt_required,
+    get_jwt_identity
+)
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from flask_cors import CORS
+
+app = Flask(__name__)
+CORS(app)
+
+app.config['JWT_SECRET_KEY'] = 'GRUWIN-ADMIN-ACCOUNT'
+
+app.config['JWT_ACCESS_TOKEN_EXPIRES'] = False
+
+jwt = JWTManager(app)
+
+api = Api(app)
+
+uservice = UserService()
+
+msg_service = MessageService()
+
+@app.route('/')
+def welcome():
+    return jsonify({'Flask restful': 'conected'})
+
+
+@app.route('/signup', methods=['POST'])
+def signup():
+    return uservice.signup()
+
+
+@app.route('/login', methods=['POST'])
+def login():
+    return uservice.login()
+
+
+@app.route('/users', methods=['GET'])
+@jwt_required()
+def getUsers():
+    users = Users().get()
+    return users
+
+
+@app.route('/users', methods=['POST'])
+def addUsers():
+    users = Users()
+    return users.post()
+
+
+@app.route('/user/<string:id>')
+@jwt_required()
+def getUserById(id):
+    user = User().get(id)
+    return jsonify(user)
+
+
+@app.route('/post', methods=['GET'])
+@jwt_required()
+def getPost():
+    posts = Posts().get()
+    return posts
+
+
+@app.route('/post', methods=['POST'])
+def createPost():
+    post = Posts()
+    return post.post()
+
+
+@app.route('/imagepost/<int:postid>', methods=['GET'])
+@jwt_required()
+def getImagePost(postid):
+    Image = ImagePost()
+    return Image.get(postid)
+
+
+@app.route('/imagepost', methods=['POST'])
+def createImagePost():
+    image_post = ImagePost()
+    return image_post.post()
+
+
+@app.route('/messages/<string:sender_id>/<string:recipient_id>', methods=['GET'])
+@jwt_required()
+def getMessages(sender_id, recipient_id):
+    messages = msg_service.get_messages(sender_id, recipient_id)
+    return jsonify(messages)
+
+
+@app.route('/messages', methods=['POST'])
+@jwt_required()
+def createMessage():
+    data = request.get_json()
+    message = msg_service.create_message(data['sender_id'], data['recipient_id'], data['content'])
+    return jsonify(message)
+
+
+@app.route('/messages/<string:id>', methods=['PUT'])
+@jwt_required()
+def updateMessage(id):
+    data = request.get_json()
+    message = msg_service.update_message(id, data)
+    return jsonify(message)
+
+
+@app.route('/messages/<string:id>', methods=['DELETE'])
+@jwt_required()
+def deleteMessage(id):
+    msg_service.delete_message(id)
+    return '', 204
+
+
+@app.route('/protected')
+@jwt_required()
+def protected():
+    current_user_id = get_jwt_identity()
+    return jsonify({'message': f'¡Bienvenido, usuario con id {current_user_id}!'}), 200
+
+@app.route('/email', methods=['POST'])
+@jwt_required()
+def sendEmail():
+    try:
+        # Obtener los datos del cuerpo del mensaje
+        data = request.get_json()
+
+        if data:
+            name_client = data.get('name_client')
+            email_client = data.get('email_client')
+            phone_client = data.get('phone_client')
+            email_address = data.get('email_address')
+            message_subject = data.get('message_subject')
+            message_send = data.get('message_send')
+
+            sender_email = "[email protected]"
+            password = "ibdzsrjmsfkjhdbj"
+            receiver_email = email_client
+
+            message = MIMEMultipart("alternative")
+            message["Subject"] = message_subject
+            message["From"] = "Intermediario <{}>".format(sender_email)
+            message["To"] = receiver_email
+
+            # Crear el cuerpo del correo electrónico con los datos
+            text = """<html>
+                        <body>
+                        <span style="font-size:15px;">Ey! Te estamos enviando este correo para informarte que tienes un nuevo mensaje:</span>
+                        <br>
+                        <br>
+                        <b style="font-size:15px;">Cliente:</b><br><span style="font-size:15px;">{}</span><br><br>
+                        <b style="font-size:15px;">Telefono:</b><br><span style="font-size:15px;">{}</span><br><br>
+                        <b style="font-size:15px;">Correo del cliente:</b><br><span style="font-size:15px;">{}</span><br><br>
+                        <b style="font-size:15px;">Mensaje del cliente:</b><br><span style="font-size:15px;">{}</span><br><br>
+                        </body>
+                        </html>""".format(name_client, phone_client, email_address, message_send)
+
+            message.attach(MIMEText(text, "html"))
+
+            # Iniciar sesión en el servidor SMTP y enviar el correo electrónico
+            with smtplib.SMTP("smtp.gmail.com", 587) as server:
+                server.starttls()
+                server.login(sender_email, password)
+                server.sendmail(sender_email, receiver_email, message.as_string())
+
+            return jsonify({"message": "Email sent successfully"})
+        else:
+            return jsonify({"message": "No data received"}), 400
+
+    except Exception as e:
+        return jsonify({"message": "An error occurred: {}".format(str(e))}), 500
+
+
+@app.errorhandler(404)
+def not_found(error):
+    return jsonify({'message': 'La URL solicitada no se encontró en el servidor.'}), 404
+
+
+if __name__ == '__main__':
+    app.run()

app.py

@@ -0,0 +1,4 @@
+DB_USER=gruwin
+DB_PASSWORD=marinmarin123
+DB_HOST=gruwin.mysql.pythonanywhere-services.com
+DB_NAME=gruwin$default

env.txt

@@ -0,0 +1,18 @@
+aniso8601==9.0.1
+autopep8==2.0.2
+click==8.1.3
+colorama==0.4.6
+Flask==2.2.3
+Flask-JWT-Extended==4.4.4
+Flask-RESTful==0.3.9
+itsdangerous==2.1.2
+Jinja2==3.1.2
+MarkupSafe==2.1.2
+mysql-connector-python==8.0.32
+protobuf==3.20.3
+pycodestyle==2.10.0
+PyJWT==2.6.0
+python-dotenv==1.0.0
+pytz==2023.2
+six==1.16.0
+Werkzeug==2.2.3

requirements.txt

@@ -0,0 +1,11 @@
+import mysql.connector
+
+def config():
+    dsource = mysql.connector.connect(
+        user='gruwin',
+        password='marinmarin123',
+        host='gruwin.mysql.pythonanywhere-services.com',
+        database='gruwin$default'
+    )
+    return dsource
+

src/config/__init__.py

@@ -0,0 +1,62 @@
+from flask import request, jsonify, Response
+from flask_restful import Resource
+from src.config.database import config
+from werkzeug.utils import secure_filename
+import os
+
+class ImagePost(Resource):
+    def get(self, postid):
+        db = config()
+        cur = db.cursor()
+        cur.execute("SELECT image FROM image_post WHERE postid = %s", (postid,))
+        result = cur.fetchone()
+
+        if result is None:
+            return {'message': 'La imagen solicitada no existe.'}, 404
+
+        image_data = result[0]
+        cur.close()
+
+        # Obtener la extensión del archivo a partir del nombre de archivo
+        filename = f'image_{postid}'
+        extension = os.path.splitext(filename)[-1]
+
+        # Establecer el tipo MIME en la respuesta
+        mimetype = f'image/{extension[1:]}'
+
+        return Response(image_data, mimetype=mimetype)
+
+
+    def post(self):
+        data = request.form
+        postid = data['postid']
+        image = request.files['image']
+
+        # Verificar que se haya enviado una imagen
+        if image.filename == '':
+            return jsonify({'message': 'No se ha seleccionado ninguna imagen.'}), 400
+
+        # Verificar que la extensión de la imagen sea permitida
+        allowed_extensions = {'png', 'jpg', 'jpeg', 'gif'}
+        if not allowed_file(image.filename, allowed_extensions):
+            return jsonify({'message': 'El archivo de imagen no es válido.'}), 400
+
+        # Guardar la imagen en el servidor
+        filename = secure_filename(image.filename)
+        image.save(filename)
+
+       # Leer la imagen y guardarla en la base de datos
+        with open(filename, 'rb') as f:
+            image_data = f.read()
+
+        db = config()
+        cur = db.cursor()
+        cur.execute("INSERT INTO image_post (postid, image) VALUES (%s, %s)", (postid, image_data))
+        db.commit()
+        cur.close()
+
+        return jsonify({'message': 'La imagen ha sido agregada correctamente.'})
+
+
+def allowed_file(filename, allowed_extensions):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in allowed_extensions