Merge pull request 'check condition' (#42) from feature/add-condition into master

Reviewed-on: #42

app/main.py

@@ -1,7 +1,7 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
-from .routers import users, token, mail, events
+from .routers import users, token, mail, events, tags
 from .dependencies import user_add
 
 import os
@@ -29,6 +29,7 @@ app.include_router(users.router)
 app.include_router(token.router)
 app.include_router(mail.router)
 app.include_router(events.router)
+app.include_router(tags.router)
 
 
 @app.on_event("startup")

app/models/tags.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel, EmailStr
+from pydantic_mongo import AbstractRepository, ObjectIdField
+from datetime import datetime, date
+
+class Tags(BaseModel):
+    id: ObjectIdField = None
+    name: str
+    created_at: datetime = datetime.today()
+
+class TagsOut(BaseModel):
+    id: ObjectIdField = None
+    name: str
+
+
+class TagsIn(BaseModel):
+    name: str
+
+class TagsIDS(BaseModel):
+    ids: list[str]
+
+
+class TagsRepository(AbstractRepository[Tags]):
+    class Meta:
+        collection_name = "tags"

app/models/users.py

@@ -11,7 +11,7 @@ class User(BaseModel):
     roles: str = "User"
     status: int = 0
     email: EmailStr
-    birth: str | None = None
+    birth: datetime | None = None
     created_at: datetime = datetime.today()
     connected_at: datetime | None = None
     updated_at: datetime | None = None

app/routers/events.py

@@ -2,303 +2,221 @@ from fastapi import APIRouter, Depends, HTTPException, status, Response
 from fastapi.responses import JSONResponse
 from datetime import datetime
 from ..dependencies import users_token, permissions_checker, database
-from ..models import events, users
+from ..models import events, users, tags
 from pydantic import EmailStr
-from typing import Annotated
+from typing import Annotated, Union
 from bson import ObjectId
 from datetime import datetime
 router = APIRouter()
 
+def build_location_filter(min_lat, max_lat, min_lon, max_lon):
+    """Build location-based query filters."""
+    if min_lat is not None and max_lat is not None and min_lon is not None and max_lon is not None:
+        return [
+            {"latitude": {"$gte": min_lat}},
+            {"latitude": {"$lte": max_lat}},
+            {"longitude": {"$gte": min_lon}},
+            {"longitude": {"$lte": max_lon}},
+        ]
+    return []
+
+def build_datetime_filter(current_datetime):
+    """Build filters for current datetime."""
+    if current_datetime:
+        return {
+            "$or": [
+                {"start_date": {"$gte": current_datetime}},  # Upcoming events
+                {
+                    "$and": [
+                        {"start_date": {"$lte": current_datetime}},  # Already started
+                        {"$or": [
+                            {"end_date": {"$gte": current_datetime}},  # Ongoing
+                            {"end_date": None},  # No end date
+                        ]},
+                    ],
+                },
+            ],
+        }
+    return None
+
+def build_date_filter(start_date, end_date):
+    """Build date range filters."""
+    if start_date and end_date:
+        return [
+            {"start_date": {"$gte": datetime.combine(start_date, datetime.min.time())}},
+            {"start_date": {"$lte": datetime.combine(end_date, datetime.max.time())}},
+        ]
+    return []
+
+def build_text_filter(item):
+    """Build text-based search filters."""
+    if item:
+        return {
+            "$or": [
+                {"name": {"$regex": item, "$options": "i"}},
+                {"tags": {"$regex": item, "$options": "i"}},
+                {"organizers": {"$regex": item, "$options": "i"}},
+            ]
+        }
+    return None
+
+
 
 
 @router.get("/events", tags=["events"], response_model=list[events.EventOut])
-async def read_events(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))], skip: int = 0, limit: int = 20, id_event: str | None = None, name: str | None = None, status: int = 1, tags: str | None = None, organizers: str | None = None, current_datetime: datetime | None = None):
+async def read_events(
+    authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))],
+    skip: int = 0,
+    limit: int = 20,
+    id_event: str | None = None,
+    name: str | None = None,
+    status: int = 1,
+    tags: str | None = None,
+    organizers: str | None = None,
+    current_datetime: datetime | None = None,
+    date_event: datetime | None = None,
+    start_date: datetime | None = None,
+    end_date: datetime | None = None,
+):
+    # Validate `skip` and `limit`
     if limit < 1 or skip < 0 or limit < skip:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail="skip should be greater than 0 and limit should be greater than 1. Limit should be greater than skip"
+            detail="`skip` should be >= 0 and `limit` should be > 0 and greater than `skip`.",
         )
     limit = limit + skip
-    listEvents = []
+
+    # Initialize filters
+    filters = []
+
+    # Add status filter
+    filters.append({"status": {"$eq": status}})
+
+    # Add date filters
+    if date_event:
+        start_of_day = datetime.combine(date_event, datetime.min.time())
+        end_of_day = datetime.combine(date_event, datetime.max.time())
+        filters.extend(build_date_filter(start_of_day, end_of_day))
+    elif start_date and end_date:
+        filters.extend(build_date_filter(start_date, end_date))
+
+    # Add current datetime filter
+    datetime_filter = build_datetime_filter(current_datetime)
+    if datetime_filter:
+        filters.append(datetime_filter)
+
+    # Add text-based filters
+    if name:
+        filters.append(build_text_filter(name))
+    if tags:
+        filters.append({"tags": {"$eq": tags}})
+    if organizers:
+        filters.append({"organizers": {"$eq": organizers}})
+
+    # Add ID filter
+    if id_event:
+        try:
+            event_id = ObjectId(id_event)
+            filters.append({"_id": {"$eq": event_id}})
+        except Exception:
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid event ID format.")
+
+    # Combine all filters
+    object_search = {"$and": filters} if filters else {}
+
+    # Fetch and return results
     event_repository = events.EventRepository(database=database.database)
-    object_search = {}
+    list_events = []
-    if current_datetime is not None:
-        object_search ={
-            "$or": [{"start_date": {"$gte": current_datetime}},  # Upcoming events
-                    {"$and": [  # Ongoing events
-                        {"start_date": {"$lte": current_datetime}},  # Already started
-                        {"$or": [
-                            {"end_date": {"$gte": current_datetime}},  # End date in the future
-                            {"end_date": None}  # No end date set
-                            ]}
-                        ]}
-                    ]
-                }
-            
-    if status is not 1:
-        object_search = {"status":{"$eq": status}}
-        if current_datetime is not None:
-            object_search = { "$and": [ {"status":{"$eq": status}},
-                 {
-                        "$or": [
-                            {"start_date": {"$gte": current_datetime}},  # Upcoming events
-                            {"$and": [  # Ongoing events
-                                {"start_date": {"$lte": current_datetime}},  # Already started
-                                {"$or": [
-                                    {"end_date": {"$gte": current_datetime}},  # End date in the future
-                                    {"end_date": None}  # No end date set
-                                ]}
-                            ]}
-                        ]
-                    }
-            ] }
-    if tags is not None:
-        object_search = {"$and":[{"tags":{"$eq": tags}}, {"status":{"$eq":status}}]}
-        if current_datetime is not None:
-            object_search = {"$and":[{"tags":{"$eq": tags}}, 
-                {"status":{"$eq":status}},
-                {
-                        "$or": [
-                            {"start_date": {"$gte": current_datetime}},  # Upcoming events
-                            {"$and": [  # Ongoing events
-                                {"start_date": {"$lte": current_datetime}},  # Already started
-                                {"$or": [
-                                    {"end_date": {"$gte": current_datetime}},  # End date in the future
-                                    {"end_date": None}  # No end date set
-                                ]}
-                            ]}
-                        ]
-                    }
-            ]
-            }
-    if organizers is not None:
-        object_search = {"$and":[{"organizers":{"$eq": organizers}}, {"status":{"$eq":status}}]}
-        if current_datetime is not None:
-             object_search = {"$and":[{"organizers":{"$eq": organizers}}, 
-             {"status":{"$eq":status}},
-              {
-                        "$or": [
-                            {"start_date": {"$gte": current_datetime}},  # Upcoming events
-                            {"$and": [  # Ongoing events
-                                {"start_date": {"$lte": current_datetime}},  # Already started
-                                {"$or": [
-                                    {"end_date": {"$gte": current_datetime}},  # End date in the future
-                                    {"end_date": None}  # No end date set
-                                ]}
-                            ]}
-                        ]
-                    }
-            ]}
-    if id_event is not None:
-        eventid = ObjectId(id_event)
-        object_search = {"$and":[{"id":{"$regex": eventid}}, {"status":{"$eq":status}}]}
-        if current_datetime is not None:
-            object_search = {"$and":[{"id":{"$regex": eventid}}, 
-            {"status":{"$eq":status}},
-            {
-                        "$or": [
-                            {"start_date": {"$gte": current_datetime}},  # Upcoming events
-                            {"$and": [  # Ongoing events
-                                {"start_date": {"$lte": current_datetime}},  # Already started
-                                {"$or": [
-                                    {"end_date": {"$gte": current_datetime}},  # End date in the future
-                                    {"end_date": None}  # No end date set
-                                ]}
-                            ]}
-                        ]
-                    }
-        ]}
-    if name is not None:
-        object_search = {"$and":[{"name":{"$regex": name}}, {"status":{"$eq":status}}]}
-        if current_datetime is not None:
-            object_search = {"$and":[{"name":{"$regex": name}}, 
-                {"status":{"$eq":status}},
-                {
-                        "$or": [
-                            {"start_date": {"$gte": current_datetime}},  # Upcoming events
-                            {"$and": [  # Ongoing events
-                                {"start_date": {"$lte": current_datetime}},  # Already started
-                                {"$or": [
-                                    {"end_date": {"$gte": current_datetime}},  # End date in the future
-                                    {"end_date": None}  # No end date set
-                                ]}
-                            ]}
-                        ]
-                    }
-            ]}
-
-
     for event_index in event_repository.find_by(object_search, limit=limit, skip=skip):
-        event = events.EventOut(id=event_index.id, tags=event_index.tags, imgUrl=event_index.imgUrl, name=event_index.name, description=event_index.description, place=event_index.place,  status=event_index.status, start_date=event_index.start_date, end_date=event_index.end_date)
+        event = events.EventOut(
-        listEvents.append(event)
+            id=event_index.id,
-    return listEvents
+            tags=event_index.tags,
+            imgUrl=event_index.imgUrl,
+            name=event_index.name,
+            description=event_index.description,
+            place=event_index.place,
+            status=event_index.status,
+            start_date=event_index.start_date,
+            end_date=event_index.end_date,
+        )
+        list_events.append(event)
+
+    return list_events
 
 
 @router.get("/events/search", tags=["events"], response_model=list[events.EventOut])
-async def search_events(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))], skip: int = 0, limit: int = 20, item: str | None = None, status: int = 1, min_lat: float | None = None, max_lat: float | None = None, min_lon: float | None = None, max_lon: float | None = None, current_datetime: datetime | None = None):
+async def search_events(
+    authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))],
+    skip: int = 0,
+    limit: int = 20,
+    item: Union[str, None] = None,
+    status: int = 1,
+    min_lat: Union[float, None] = None,
+    max_lat: Union[float, None] = None,
+    min_lon: Union[float, None] = None,
+    max_lon: Union[float, None] = None,
+    current_datetime: Union[datetime, None] = None,
+    date_event: Union[datetime, None] = None,
+    start_date: Union[datetime, None] = None,
+    end_date: Union[datetime, None] = None,
+    tags: Union[str, None] = None,
+):
     if limit < 1 or skip < 0 or limit < skip:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail="skip should be greater than 0 and limit should be greater than 1. Limit should be greater than skip"
+            detail="`skip` should be >= 0 and `limit` should be > 0 and greater than `skip`.",
         )
     limit = limit + skip
-    listEvents = []
+
+    # Initialize filters
+    filters = [{"status": {"$eq": status}}]
+
+    # Date filters
+    if date_event:
+        start_of_day = datetime.combine(date_event, datetime.min.time())
+        end_of_day = datetime.combine(date_event, datetime.max.time())
+        filters.extend(build_date_filter(start_of_day, end_of_day))
+    else:
+        filters.extend(build_date_filter(start_date, end_date))
+
+    # Add location filter
+    filters.extend(build_location_filter(min_lat, max_lat, min_lon, max_lon))
+
+    # Add datetime filter
+    datetime_filter = build_datetime_filter(current_datetime)
+    if datetime_filter:
+        filters.append(datetime_filter)
+
+    # Add text filter
+    text_filter = build_text_filter(item)
+    if text_filter:
+        filters.append(text_filter)
+
+    if tags is not None:
+        filters.append({"tags": {"$eq": tags}})
+
+    # Combine filters
+    object_search = {"$and": filters} if filters else {}
+
+    # Fetch and return results
     event_repository = events.EventRepository(database=database.database)
-    object_search = {}
+    list_events = []
-    if min_lat is not None and max_lat is not None and min_lon is not None and max_lon is not None:
-        object_search = {
-                "$and": [
-                    {"status": {"$eq": status}},
-                    {
-                        "latitude": {"$gte": min_lat},  # Minimum latitude
-                    },
-                    {
-                        "latitude": {"$lte": max_lat},  # Maximum latitude
-                    },
-                    {
-                        "longitude": {"$gte": min_lon},  # Minimum longitude
-                    },
-                    {
-                        "longitude": {"$lte": max_lon},  # Maximum longitude
-                    }
-                ]
-            }
-        if current_datetime is not None:
-            object_search = {
-                "$and": [
-                    {"status": {"$eq": status}},
-                    {
-                        "latitude": {"$gte": min_lat},  # Minimum latitude
-                    },
-                    {
-                        "latitude": {"$lte": max_lat},  # Maximum latitude
-                    },
-                    {
-                        "longitude": {"$gte": min_lon},  # Minimum longitude
-                    },
-                    {
-                        "longitude": {"$lte": max_lon},  # Maximum longitude
-                    },
-                     {
-                        "$or": [
-                            {"start_date": {"$gte": current_datetime}},  # Upcoming events
-                            {"$and": [  # Ongoing events
-                                {"start_date": {"$lte": current_datetime}},  # Already started
-                                {"$or": [
-                                    {"end_date": {"$gte": current_datetime}},  # End date in the future
-                                    {"end_date": None}  # No end date set
-                                ]}
-                            ]}
-                        ]
-                    }
-                ]
-            }
-
-    if item is not None:
-        object_search = {
-        "$and": [
-            {
-                "$or": [
-                    {"name": {"$regex": item}},
-                    {"tags": {"$regex": item}},
-                    {"organizers": {"$regex": item}}
-                ]
-            },
-            {"status": {"$eq": status}}
-        ]
-        }
-        if current_datetime is not None:
-            object_search = {
-            "$and": [
-                {
-                    "$or": [
-                        {"name": {"$regex": item}},
-                        {"tags": {"$regex": item}},
-                        {"organizers": {"$regex": item}}
-                    ]
-                },
-                {"status": {"$eq": status}},
-                 {
-                        "$or": [
-                            {"start_date": {"$gte": current_datetime}},  # Upcoming events
-                            {"$and": [  # Ongoing events
-                                {"start_date": {"$lte": current_datetime}},  # Already started
-                                {"$or": [
-                                    {"end_date": {"$gte": current_datetime}},  # End date in the future
-                                    {"end_date": None}  # No end date set
-                                ]}
-                            ]}
-                        ]
-                    }
-            ]
-            }
-        if min_lat is not None and max_lat is not None and min_lon is not None and max_lon is not None:
-            object_search = {
-                "$and": [
-                    {
-                        "$or": [
-                            {"name": {"$regex": item}},
-                            {"tags": {"$regex": item}},
-                            {"organizers": {"$regex": item}}
-                        ]
-                    },
-                    {"status": {"$eq": status}},
-                    {
-                        "latitude": {"$gte": min_lat},  # Minimum latitude
-                    },
-                    {
-                        "latitude": {"$lte": max_lat},  # Maximum latitude
-                    },
-                    {
-                        "longitude": {"$gte": min_lon},  # Minimum longitude
-                    },
-                    {
-                        "longitude": {"$lte": max_lon},  # Maximum longitude
-                    }
-                ]
-            }
-            if current_datetime is not None:
-                object_search = {
-                "$and": [
-                    {
-                        "$or": [
-                            {"name": {"$regex": item}},
-                            {"tags": {"$regex": item}},
-                            {"organizers": {"$regex": item}}
-                        ]
-                    },
-                    {"status": {"$eq": status}},
-                    {
-                        "latitude": {"$gte": min_lat},  # Minimum latitude
-                    },
-                    {
-                        "latitude": {"$lte": max_lat},  # Maximum latitude
-                    },
-                    {
-                        "longitude": {"$gte": min_lon},  # Minimum longitude
-                    },
-                    {
-                        "longitude": {"$lte": max_lon},  # Maximum longitude
-                    },
-                    {
-                        "$or": [
-                            {"start_date": {"$gte": current_datetime}},  # Upcoming events
-                            {"$and": [  # Ongoing events
-                                {"start_date": {"$lte": current_datetime}},  # Already started
-                                {"$or": [
-                                    {"end_date": {"$gte": current_datetime}},  # End date in the future
-                                    {"end_date": None}  # No end date set
-                                ]}
-                            ]}
-                        ]
-                    }
-                ]
-            }
-
     for event_index in event_repository.find_by(object_search, limit=limit, skip=skip):
-        event = events.EventOut(id=event_index.id, tags=event_index.tags, imgUrl=event_index.imgUrl, name=event_index.name, description=event_index.description, place=event_index.place,  status=event_index.status, start_date=event_index.start_date, end_date=event_index.end_date)
+        event = events.EventOut(
-        listEvents.append(event)
+            id=event_index.id,
-    return listEvents
+            tags=event_index.tags,
+            imgUrl=event_index.imgUrl,
+            name=event_index.name,
+            description=event_index.description,
+            place=event_index.place,
+            status=event_index.status,
+            start_date=event_index.start_date,
+            end_date=event_index.end_date,
+        )
+        list_events.append(event)
+
+    return list_events
+
 
 
 @router.get("/events/me",tags=["events"])
@@ -412,8 +330,12 @@ async def update_events(authorize: Annotated[bool, Depends(permissions_checker.P
             detail="Body request is empty"
         )
     event_repository = events.EventRepository(database=database.database)
+    tags_repository = tags.TagsRepository(database=database.database)            
 
-    event = event_repository.find_one_by({"name": {'$eq': eventSingle.name}})
+    event = event_repository.find_one_by( {"$and": [
+                        {"start_date": {"$eq": eventSingle.start_date}},  # Already started
+                        {"name": {"$eq": eventSingle.name}},
+                    ]})
     if event is not None:
         raise HTTPException(
             status_code=status.HTTP_204_NO_CONTENT,
@@ -429,6 +351,11 @@ async def update_events(authorize: Annotated[bool, Depends(permissions_checker.P
     event.longitude = eventSingle.longitude
     event.imgUrl = eventSingle.imgUrl
     event.tags = eventSingle.tags
+    for tag_name in eventSingle.tags:
+        tag = tags_repository.find_one_by({"name": {'$eq': tag_name}})
+        if tag is None:
+            tag = tags.Tags(name=tag_name)
+            tags_repository.save(tag)
     event.status = 1
     event.created_at = datetime.today()
     event_repository.save(event)
@@ -445,7 +372,7 @@ async def update_events_id(item_id: str, authorize: Annotated[bool, Depends(perm
             detail="Body request is empty"
         )
     event_repository = events.EventRepository(database=database.database)
-
+    tags_repository = tags.TagsRepository(database=database)
     event = event_repository.find_one_by({"id": {'$eq': ObjectId(item_id)}})
     if event is None:
         raise HTTPException(
@@ -460,6 +387,11 @@ async def update_events_id(item_id: str, authorize: Annotated[bool, Depends(perm
     event.end_date = eventSingle.end_date
     event.organizers = eventSingle.organizers
     event.tags = eventSingle.tags
+    for tag_name in eventSingle:
+        tag = tags_repository.find_one_by({"name": {'$eq': tag_name}})
+        if tag is None:
+            tag = Tags(name=tag_name)
+            tags_repository.save(tag)
     event.latitude = eventSingle.latitude
     event.longitude = eventSingle.longitude
     event.updated_at = datetime.today()

app/routers/tags.py

@@ -0,0 +1,119 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Response
+from fastapi.responses import JSONResponse
+from datetime import datetime
+from ..dependencies import users_token, permissions_checker, database
+from ..models import tags, users
+from pydantic import EmailStr
+from typing import Annotated, Union
+from bson import ObjectId
+from datetime import datetime
+router = APIRouter()
+
+
+@router.get("/tags", tags=["tags"], response_model=list[tags.TagsOut])
+async def read_tags(
+    authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))],
+    skip: int = 0,
+    limit: int = 20,
+    id_tags: str | None = None,
+    name: str | None = None
+):
+    # Validate `skip` and `limit`
+    if limit < 1 or skip < 0 or limit < skip:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="`skip` should be >= 0 and `limit` should be > 0 and greater than `skip`.",
+        )
+    limit = limit + skip
+
+    # Initialize filters
+    filters = []
+
+
+    if name:
+        filters.append({"name": {"$regex": name, "$options": "i"}})
+
+    # Add ID filter
+    if id_tags:
+        try:
+            tags_id = ObjectId(id_tags)
+            filters.append({"_id": {"$eq": event_id}})
+        except Exception:
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid event ID format.")
+
+    # Combine all filters
+    object_search = {"$and": filters} if filters else {}
+
+    # Fetch and return results
+    tags_repository = tags.TagsRepository(database=database.database)
+    list_tags = []
+    for tag_index in tags_repository.find_by(object_search, limit=limit, skip=skip):
+        tag = tags.TagsOut(
+            id=tag_index.id,
+            name=tag_index.name
+        )
+        list_tags.append(tag)
+
+    return list_tags
+
+@router.get("/tags/count", tags=["tags"])
+async def read_tags_count(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))]):
+    count = database.database.get_collection("tags").estimated_document_count()
+    content = {"count":count}
+    response = JSONResponse(content=content)
+    return response
+
+
+@router.get("/tags/{item_id}", tags=["tags"], response_model=tags.Tags)
+async def read_tags_id(item_id : str, authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))]):
+    tags_repository = tags.TagsRepository(database=database.database)
+    tag = tags_repository.find_one_by_id(ObjectId(item_id))
+    return tag
+
+
+@router.delete("/tags/groups",tags=["tags"])
+async def delete_tags_groups(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))], tagsids: tags.TagsIDS | None = None):
+    if len(tagsids.ids) == 0:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="eventids should be greater than 0"
+        )
+    
+    tag_repository = tags.TagsRepository(database=database.database)
+    for i in tagsids.ids:
+        tag = tag_repository.find_one_by_id(ObjectId(i))
+        tag_repository.delete_one(tag)
+    content = {"message": "tags removed"}
+    response = JSONResponse(content=content)
+    return response
+
+@router.delete("/tags/{item_id}", tags=["tags"])
+async def delete_tags_id(item_id : str, authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))]):
+    tag_repository = tags.TagsRepository(database=database.database)
+    tag = tag_repository.find_one_by_id(ObjectId(item_id))        
+    event_repository.delete_one(event)
+    content = {"message": "tags delete"}
+    response = JSONResponse(content=content)  
+    return responsed
+
+@router.put("/tags", tags=["tags"], status_code=status.HTTP_201_CREATED)
+async def update_tags(authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin"]))], tagSingle: tags.TagsIn | None = None):
+    if tagSingle is None:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Body request is empty"
+        )
+    tag_repository = tags.TagsRepository(database=database.database)
+
+    tag = tag_repository.find_one_by({"name": {'$eq': tagSingle.name}})
+    if tag is not None:
+        raise HTTPException(
+            status_code=status.HTTP_204_NO_CONTENT,
+            detail="name"
+        )
+    tag = tags.Tags(name=tagSingle.name)
+    tag.created_at = datetime.today()
+    tag_repository.save(event)
+    content = {"message": "tags created"}
+    response = JSONResponse(content=content, status_code=status.HTTP_201_CREATED)  
+    return response

app/routers/users.py

@@ -143,7 +143,8 @@ async def delete_users_id(item_id : str, authorize: Annotated[bool, Depends(perm
 async def update_users_me(current_user: Annotated[users.User, Depends(users_token.get_current_active_user)], authorize: Annotated[bool, Depends(permissions_checker.PermissionChecker(roles=["Admin", "User"]))], userSingle: users.UserIn | None = None):
     user_repository = users.UserRepository(database=database.database)
     current_user.username = userSingle.username
-    current_user.password = user_token.get_password_hash(userSingle.password)
+    if len(userSingle.password) > 0:
+        current_user.password = user_token.get_password_hash(userSingle.password)
     current_user.roles = userSingle.roles
     current_user.email = userSingle.email
     user_repository.save(current_user)
@@ -202,7 +203,8 @@ async def update_users_id(item_id: str, authorize: Annotated[bool, Depends(permi
         )
         
     user.username = userSingle.username
-    user.password = users_token.get_password_hash(userSingle.password)
+    if len(userSingle.password) > 0:
+        user.password = users_token.get_password_hash(userSingle.password)
     user.roles = userSingle.roles
     user.email = userSingle.email
     user.firstName = userSingle.firstName