326 lines
10 KiB
Python
326 lines
10 KiB
Python
from itertools import count
|
|
|
|
import pymongo
|
|
|
|
from json import loads
|
|
from bson import ObjectId, json_util
|
|
from pydantic import BaseModel
|
|
from api_configs import MongoConfig
|
|
|
|
from pymongo import MongoClient
|
|
from pymongo.collection import Collection
|
|
from pymongo.results import InsertManyResult
|
|
|
|
# from configs import TestMongo as MongoConfig
|
|
|
|
|
|
class Paginate(BaseModel):
|
|
pageSize: int = 10
|
|
pageNumber: int = 1
|
|
sortField: str = "_id"
|
|
sortOrder: str = "desc"
|
|
|
|
def grab_paginates(self):
|
|
size_ = self.pageSize
|
|
return (
|
|
size_,
|
|
size_ * (self.pageNumber - 1),
|
|
self.sortField,
|
|
-1 if self.sortOrder == "desc" else 1,
|
|
)
|
|
|
|
|
|
class MongoResponse:
|
|
|
|
def __init__(
|
|
self,
|
|
status: bool,
|
|
message: str,
|
|
message_code: str = None,
|
|
data: dict = None,
|
|
mongo=None,
|
|
count: int = 1,
|
|
):
|
|
self.status = status
|
|
self.message = message
|
|
self.data = data
|
|
self.mongo = mongo
|
|
self.message_code = message_code
|
|
self.count = count
|
|
|
|
def as_dict(self):
|
|
return {
|
|
"status": self.status,
|
|
"count": self.count,
|
|
"message": self.message,
|
|
"message_code": self.message_code,
|
|
"data": self.data,
|
|
}
|
|
|
|
|
|
class MongoQuery:
|
|
|
|
def __init__(self, table_name: str, database_name: str):
|
|
database = MongoClient(MongoConfig.url)[database_name]
|
|
self.table: Collection = database[table_name]
|
|
|
|
@staticmethod
|
|
def grab_paginates(paginate):
|
|
return (
|
|
paginate.size,
|
|
paginate.size * (paginate.page - 1),
|
|
paginate.order_field,
|
|
-1 if paginate.order_type == "desc" else 1,
|
|
)
|
|
|
|
@staticmethod
|
|
def parse_json(data):
|
|
return loads(json_util.dumps(data))
|
|
|
|
def insert(self, payload) -> MongoResponse:
|
|
insert = self.table.insert_one(document=payload)
|
|
if insert.acknowledged:
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been created",
|
|
message_code="CREATED",
|
|
data=payload,
|
|
mongo=insert,
|
|
)
|
|
return MongoResponse(
|
|
status=False,
|
|
message="The document has not been created",
|
|
message_code="NOT_CREATED",
|
|
data=None,
|
|
mongo=insert,
|
|
count=0,
|
|
)
|
|
|
|
def insert_many(self, payload) -> MongoResponse:
|
|
insert_many = self.table.insert_many(documents=payload)
|
|
if insert_many.acknowledged:
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The documents have been created",
|
|
message_code="CREATED",
|
|
data=payload,
|
|
mongo=insert_many,
|
|
count=len(payload),
|
|
)
|
|
return MongoResponse(
|
|
status=False,
|
|
message="The documents have not been created",
|
|
message_code="NOT_CREATED",
|
|
data=None,
|
|
mongo=insert_many,
|
|
count=0,
|
|
)
|
|
|
|
def find_or_insert(self, payload, field: str = "id") -> MongoResponse:
|
|
if field == "id":
|
|
found_row = self.get_one(match=payload["_id"], field="_id")
|
|
if found_row.status:
|
|
return MongoResponse(
|
|
status=False,
|
|
message="The document already exists",
|
|
data=found_row.data,
|
|
mongo=found_row.mongo,
|
|
)
|
|
if mongo := self.table.insert_one(document=payload).acknowledged:
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been created",
|
|
data=payload,
|
|
mongo=mongo,
|
|
)
|
|
|
|
found_row = self.get_one(match=payload[field], field=field)
|
|
if found_row.status:
|
|
return MongoResponse(
|
|
status=False,
|
|
message_code="ALREADY_EXISTS",
|
|
message="The document already exists",
|
|
data=found_row.data,
|
|
mongo=found_row.mongo,
|
|
)
|
|
insert_row = self.table.insert_one(document=payload)
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been created",
|
|
message_code="CREATED",
|
|
data=payload,
|
|
mongo=insert_row,
|
|
)
|
|
|
|
def update(self, match, payload, field: str = "id"):
|
|
if field == "id":
|
|
filter_ = {"_id": ObjectId(match)}
|
|
update_one = self.table.update_one(filter=filter_, update={"$set": payload})
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been updated",
|
|
message_code="UPDATED",
|
|
data=self.get_one(match=match, field=field).data,
|
|
mongo=update_one,
|
|
)
|
|
update_one = self.table.update_one(
|
|
filter={field: match}, update={"$set": payload}
|
|
)
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been updated",
|
|
message_code="UPDATED",
|
|
data=self.get_one(match=match, field=field).data,
|
|
mongo=update_one,
|
|
)
|
|
|
|
def get_one(self, match, field: str = "id"):
|
|
if field == "id":
|
|
if get_one := self.table.find_one(filter={"_id": ObjectId(match)}):
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been found",
|
|
message_code="FOUND",
|
|
data=self.parse_json(data=get_one),
|
|
mongo=get_one,
|
|
)
|
|
if get_one := self.table.find_one(filter={field: match}):
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been found",
|
|
message_code="FOUND",
|
|
data=self.parse_json(data=get_one),
|
|
mongo=get_one,
|
|
)
|
|
return MongoResponse(
|
|
status=False,
|
|
message="The document has not been found",
|
|
message_code="NOT_FOUND",
|
|
data=None,
|
|
mongo=None,
|
|
)
|
|
|
|
def filter_by(self, payload, sort_by: str = "_id", sort_direction: str = "asc"):
|
|
sort_direction = (
|
|
pymongo.ASCENDING
|
|
if str(sort_direction).lower() == "asc"
|
|
else pymongo.DESCENDING
|
|
)
|
|
return_ = self.table.find(payload).sort(sort_by, sort_direction)
|
|
data = self.parse_json(data=return_)
|
|
if len(data) == 0:
|
|
return MongoResponse(
|
|
status=False,
|
|
message="The documents have not been found",
|
|
message_code="NOT_FOUND",
|
|
data=None,
|
|
mongo=return_,
|
|
count=0,
|
|
)
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The documents have been found",
|
|
message_code="FOUND",
|
|
count=self.table.count_documents(payload),
|
|
data=data,
|
|
)
|
|
|
|
def delete_one(self, match, field: str = "id"):
|
|
if field == "id":
|
|
delete_one = self.table.delete_one(filter={"_id": ObjectId(match)})
|
|
if delete_one.deleted_count:
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been deleted",
|
|
message_code="DELETED",
|
|
data=None,
|
|
count=delete_one.deleted_count,
|
|
mongo=delete_one,
|
|
)
|
|
delete_one = self.table.delete_one(filter={field: match})
|
|
if delete_one.deleted_count:
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been deleted",
|
|
message_code="DELETED",
|
|
data=None,
|
|
count=delete_one.deleted_count,
|
|
mongo=delete_one,
|
|
)
|
|
return MongoResponse(
|
|
status=False,
|
|
message="The document has not been deleted",
|
|
message_code="NOT_DELETED",
|
|
data=None,
|
|
mongo=None,
|
|
count=0,
|
|
)
|
|
|
|
def delete_all(self, match, field: str = "id"):
|
|
if field == "id":
|
|
delete_many = self.table.delete_many(filter={"_id": ObjectId(match)})
|
|
if delete_many.deleted_count:
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been deleted",
|
|
message_code="DELETED",
|
|
data=None,
|
|
count=delete_many.deleted_count,
|
|
mongo=delete_many,
|
|
)
|
|
delete_many = self.table.delete_many(filter={field: match})
|
|
if delete_many.deleted_count:
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The document has been deleted",
|
|
message_code="DELETED",
|
|
data=None,
|
|
count=delete_many.deleted_count,
|
|
mongo=delete_many,
|
|
)
|
|
return MongoResponse(
|
|
status=False,
|
|
message="The document has not been deleted",
|
|
message_code="NOT_DELETED",
|
|
data=None,
|
|
mongo=None,
|
|
count=0,
|
|
)
|
|
|
|
def list_all(self, paginate: Paginate):
|
|
size, skip, field, order = paginate.grab_paginates()
|
|
return_ = self.table.find().sort([(field, order)]).skip(skip).limit(size)
|
|
self.table.count_documents({}), self.parse_json(data=return_)
|
|
data = self.parse_json(data=return_)
|
|
if len(data) == 0:
|
|
return MongoResponse(
|
|
status=False,
|
|
message="The documents have not been found",
|
|
message_code="NOT_FOUND",
|
|
data=None,
|
|
mongo=return_,
|
|
count=0,
|
|
)
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The documents have been found",
|
|
message_code="FOUND",
|
|
count=self.table.count_documents({}),
|
|
data=data,
|
|
mongo=return_,
|
|
)
|
|
|
|
def get_all(self):
|
|
return_ = self.table.find()
|
|
return MongoResponse(
|
|
status=True,
|
|
message="The documents have been found",
|
|
message_code="FOUND",
|
|
count=self.table.count_documents({}),
|
|
data=self.parse_json(data=return_),
|
|
mongo=return_,
|
|
)
|
|
|
|
|
|
# Mongo = MongoQuery(table_name="XcompanyConfig", database_name="mongo_database")
|