Mirrors/open-webui
1
0
Fork 0
mirror of https://github.com/open-webui/open-webui.git synced 2025-12-16 11:57:51 +01:00
Code Issues Packages Projects Releases Wiki Activity

feat(sqlalchemy): remove session reference from router

Browse Source
This commit is contained in:
Jonathan Rohde
2024-06-21 14:58:57 +02:00
parent df09d0830a
commit bee835cb65
34 changed files with 1231 additions and 1211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
backend/apps/webui/models/auths.py
View File

@@ -8,7 +8,7 @@ from sqlalchemy.orm import Session
from apps.webui.models.users import UserModel, Users
from utils.utils import verify_password
from apps.webui.internal.db import Base
from apps.webui.internal.db import Base, get_session
from config import SRC_LOG_LEVELS
@@ -96,7 +96,6 @@ class AuthsTable:
def insert_new_auth(
self,
db: Session,
email: str,
password: str,
name: str,
@@ -104,100 +103,107 @@ class AuthsTable:
role: str = "pending",
oauth_sub: Optional[str] = None,
) -> Optional[UserModel]:
log.info("insert_new_auth")
with get_session() as db:
log.info("insert_new_auth")
id = str(uuid.uuid4())
id = str(uuid.uuid4())
auth = AuthModel(
**{"id": id, "email": email, "password": password, "active": True}
)
result = Auth(**auth.model_dump())
db.add(result)
auth = AuthModel(
**{"id": id, "email": email, "password": password, "active": True}
)
result = Auth(**auth.model_dump())
db.add(result)
user = Users.insert_new_user(
db, id, name, email, profile_image_url, role, oauth_sub
)
user = Users.insert_new_user(
id, name, email, profile_image_url, role, oauth_sub
)
db.commit()
db.refresh(result)
db.commit()
db.refresh(result)
if result and user:
return user
else:
return None
def authenticate_user(
self, db: Session, email: str, password: str
) -> Optional[UserModel]:
log.info(f"authenticate_user: {email}")
try:
auth = db.query(Auth).filter_by(email=email, active=True).first()
if auth:
if verify_password(password, auth.password):
user = Users.get_user_by_id(db, auth.id)
return user
else:
return None
if result and user:
return user
else:
return None
except:
return None
def authenticate_user(
self, email: str, password: str
) -> Optional[UserModel]:
log.info(f"authenticate_user: {email}")
with get_session() as db:
try:
auth = db.query(Auth).filter_by(email=email, active=True).first()
if auth:
if verify_password(password, auth.password):
user = Users.get_user_by_id(auth.id)
return user
else:
return None
else:
return None
except:
return None
def authenticate_user_by_api_key(
self, db: Session, api_key: str
self, api_key: str
) -> Optional[UserModel]:
log.info(f"authenticate_user_by_api_key: {api_key}")
# if no api_key, return None
if not api_key:
return None
with get_session() as db:
# if no api_key, return None
if not api_key:
return None
try:
user = Users.get_user_by_api_key(db, api_key)
return user if user else None
except:
return False
try:
user = Users.get_user_by_api_key(api_key)
return user if user else None
except:
return False
def authenticate_user_by_trusted_header(
self, db: Session, email: str
self, email: str
) -> Optional[UserModel]:
log.info(f"authenticate_user_by_trusted_header: {email}")
try:
auth = db.query(Auth).filter(email=email, active=True).first()
if auth:
user = Users.get_user_by_id(auth.id)
return user
except:
return None
with get_session() as db:
try:
auth = db.query(Auth).filter(email=email, active=True).first()
if auth:
user = Users.get_user_by_id(auth.id)
return user
except:
return None
def update_user_password_by_id(
self, db: Session, id: str, new_password: str
self, id: str, new_password: str
) -> bool:
try:
result = db.query(Auth).filter_by(id=id).update({"password": new_password})
return True if result == 1 else False
except:
return False
def update_email_by_id(self, db: Session, id: str, email: str) -> bool:
try:
result = db.query(Auth).filter_by(id=id).update({"email": email})
return True if result == 1 else False
except:
return False
def delete_auth_by_id(self, db: Session, id: str) -> bool:
try:
# Delete User
result = Users.delete_user_by_id(db, id)
if result:
db.query(Auth).filter_by(id=id).delete()
return True
else:
with get_session() as db:
try:
result = db.query(Auth).filter_by(id=id).update({"password": new_password})
return True if result == 1 else False
except:
return False
def update_email_by_id(self, id: str, email: str) -> bool:
with get_session() as db:
try:
result = db.query(Auth).filter_by(id=id).update({"email": email})
return True if result == 1 else False
except:
return False
def delete_auth_by_id(self, id: str) -> bool:
with get_session() as db:
try:
# Delete User
result = Users.delete_user_by_id(id)
if result:
db.query(Auth).filter_by(id=id).delete()
return True
else:
return False
except:
return False
except:
return False
Auths = AuthsTable()

336
backend/apps/webui/models/chats.py
View File

@@ -8,7 +8,7 @@ import time
from sqlalchemy import Column, String, BigInteger, Boolean
from sqlalchemy.orm import Session
from apps.webui.internal.db import Base
from apps.webui.internal.db import Base, get_session
####################
@@ -80,249 +80,269 @@ class ChatTitleIdResponse(BaseModel):
class ChatTable:
def insert_new_chat(
self, db: Session, user_id: str, form_data: ChatForm
self, user_id: str, form_data: ChatForm
) -> Optional[ChatModel]:
id = str(uuid.uuid4())
chat = ChatModel(
**{
"id": id,
"user_id": user_id,
"title": (
form_data.chat["title"] if "title" in form_data.chat else "New Chat"
),
"chat": json.dumps(form_data.chat),
"created_at": int(time.time()),
"updated_at": int(time.time()),
}
)
result = Chat(**chat.model_dump())
db.add(result)
db.commit()
db.refresh(result)
return ChatModel.model_validate(result) if result else None
def update_chat_by_id(
self, db: Session, id: str, chat: dict
) -> Optional[ChatModel]:
try:
db.query(Chat).filter_by(id=id).update(
{
"chat": json.dumps(chat),
"title": chat["title"] if "title" in chat else "New Chat",
with get_session() as db:
id = str(uuid.uuid4())
chat = ChatModel(
**{
"id": id,
"user_id": user_id,
"title": (
form_data.chat["title"] if "title" in form_data.chat else "New Chat"
),
"chat": json.dumps(form_data.chat),
"created_at": int(time.time()),
"updated_at": int(time.time()),
}
)
return self.get_chat_by_id(db, id)
except:
return None
result = Chat(**chat.model_dump())
db.add(result)
db.commit()
db.refresh(result)
return ChatModel.model_validate(result) if result else None
def update_chat_by_id(
self, id: str, chat: dict
) -> Optional[ChatModel]:
with get_session() as db:
try:
chat_obj = db.get(Chat, id)
chat_obj.chat = json.dumps(chat)
chat_obj.title = chat["title"] if "title" in chat else "New Chat"
chat_obj.updated_at = int(time.time())
db.commit()
db.refresh(chat_obj)
return ChatModel.model_validate(chat_obj)
except Exception as e:
return None
def insert_shared_chat_by_chat_id(
self, db: Session, chat_id: str
self, chat_id: str
) -> Optional[ChatModel]:
# Get the existing chat to share
chat = db.get(Chat, chat_id)
# Check if the chat is already shared
if chat.share_id:
return self.get_chat_by_id_and_user_id(db, chat.share_id, "shared")
# Create a new chat with the same data, but with a new ID
shared_chat = ChatModel(
**{
"id": str(uuid.uuid4()),
"user_id": f"shared-{chat_id}",
"title": chat.title,
"chat": chat.chat,
"created_at": chat.created_at,
"updated_at": int(time.time()),
}
)
shared_result = Chat(**shared_chat.model_dump())
db.add(shared_result)
db.commit()
db.refresh(shared_result)
# Update the original chat with the share_id
result = (
db.query(Chat).filter_by(id=chat_id).update({"share_id": shared_chat.id})
)
return shared_chat if (shared_result and result) else None
def update_shared_chat_by_chat_id(
self, db: Session, chat_id: str
) -> Optional[ChatModel]:
try:
print("update_shared_chat_by_id")
with get_session() as db:
# Get the existing chat to share
chat = db.get(Chat, chat_id)
print(chat)
db.query(Chat).filter_by(id=chat.share_id).update(
{"title": chat.title, "chat": chat.chat}
# Check if the chat is already shared
if chat.share_id:
return self.get_chat_by_id_and_user_id(chat.share_id, "shared")
# Create a new chat with the same data, but with a new ID
shared_chat = ChatModel(
**{
"id": str(uuid.uuid4()),
"user_id": f"shared-{chat_id}",
"title": chat.title,
"chat": chat.chat,
"created_at": chat.created_at,
"updated_at": int(time.time()),
}
)
shared_result = Chat(**shared_chat.model_dump())
db.add(shared_result)
db.commit()
db.refresh(shared_result)
# Update the original chat with the share_id
result = (
db.query(Chat).filter_by(id=chat_id).update({"share_id": shared_chat.id})
)
return self.get_chat_by_id(db, chat.share_id)
except:
return None
return shared_chat if (shared_result and result) else None
def delete_shared_chat_by_chat_id(self, db: Session, chat_id: str) -> bool:
def update_shared_chat_by_chat_id(
self, chat_id: str
) -> Optional[ChatModel]:
with get_session() as db:
try:
print("update_shared_chat_by_id")
chat = db.get(Chat, chat_id)
print(chat)
chat.title = chat.title
chat.chat = chat.chat
db.commit()
db.refresh(chat)
return self.get_chat_by_id(chat.share_id)
except:
return None
def delete_shared_chat_by_chat_id(self, chat_id: str) -> bool:
try:
db.query(Chat).filter_by(user_id=f"shared-{chat_id}").delete()
with get_session() as db:
db.query(Chat).filter_by(user_id=f"shared-{chat_id}").delete()
return True
except:
return False
def update_chat_share_id_by_id(
self, db: Session, id: str, share_id: Optional[str]
self, id: str, share_id: Optional[str]
) -> Optional[ChatModel]:
try:
db.query(Chat).filter_by(id=id).update({"share_id": share_id})
return self.get_chat_by_id(db, id)
with get_session() as db:
chat = db.get(Chat, id)
chat.share_id = share_id
db.commit()
db.refresh(chat)
return chat
except:
return None
def toggle_chat_archive_by_id(self, db: Session, id: str) -> Optional[ChatModel]:
def toggle_chat_archive_by_id(self, id: str) -> Optional[ChatModel]:
try:
chat = self.get_chat_by_id(db, id)
db.query(Chat).filter_by(id=id).update({"archived": not chat.archived})
with get_session() as db:
chat = self.get_chat_by_id(id)
db.query(Chat).filter_by(id=id).update({"archived": not chat.archived})
return self.get_chat_by_id(db, id)
return self.get_chat_by_id(id)
except:
return None
def archive_all_chats_by_user_id(self, db: Session, user_id: str) -> bool:
def archive_all_chats_by_user_id(self, user_id: str) -> bool:
try:
db.query(Chat).filter_by(user_id=user_id).update({"archived": True})
with get_session() as db:
db.query(Chat).filter_by(user_id=user_id).update({"archived": True})
return True
except:
return False
def get_archived_chat_list_by_user_id(
self, db: Session, user_id: str, skip: int = 0, limit: int = 50
self, user_id: str, skip: int = 0, limit: int = 50
) -> List[ChatModel]:
all_chats = (
db.query(Chat)
.filter_by(user_id=user_id, archived=True)
.order_by(Chat.updated_at.desc())
# .limit(limit).offset(skip)
.all()
)
return [ChatModel.model_validate(chat) for chat in all_chats]
with get_session() as db:
all_chats = (
db.query(Chat)
.filter_by(user_id=user_id, archived=True)
.order_by(Chat.updated_at.desc())
# .limit(limit).offset(skip)
.all()
)
return [ChatModel.model_validate(chat) for chat in all_chats]
def get_chat_list_by_user_id(
self,
db: Session,
user_id: str,
include_archived: bool = False,
skip: int = 0,
limit: int = 50,
) -> List[ChatModel]:
query = db.query(Chat).filter_by(user_id=user_id)
if not include_archived:
query = query.filter_by(archived=False)
all_chats = (
query.order_by(Chat.updated_at.desc())
# .limit(limit).offset(skip)
.all()
)
return [ChatModel.model_validate(chat) for chat in all_chats]
with get_session() as db:
query = db.query(Chat).filter_by(user_id=user_id)
if not include_archived:
query = query.filter_by(archived=False)
all_chats = (
query.order_by(Chat.updated_at.desc())
# .limit(limit).offset(skip)
.all()
)
return [ChatModel.model_validate(chat) for chat in all_chats]
def get_chat_list_by_chat_ids(
self, db: Session, chat_ids: List[str], skip: int = 0, limit: int = 50
self, chat_ids: List[str], skip: int = 0, limit: int = 50
) -> List[ChatModel]:
all_chats = (
db.query(Chat)
.filter(Chat.id.in_(chat_ids))
.filter_by(archived=False)
.order_by(Chat.updated_at.desc())
.all()
)
return [ChatModel.model_validate(chat) for chat in all_chats]
with get_session() as db:
all_chats = (
db.query(Chat)
.filter(Chat.id.in_(chat_ids))
.filter_by(archived=False)
.order_by(Chat.updated_at.desc())
.all()
)
return [ChatModel.model_validate(chat) for chat in all_chats]
def get_chat_by_id(self, db: Session, id: str) -> Optional[ChatModel]:
def get_chat_by_id(self, id: str) -> Optional[ChatModel]:
try:
chat = db.get(Chat, id)
return ChatModel.model_validate(chat)
with get_session() as db:
chat = db.get(Chat, id)
return ChatModel.model_validate(chat)
except:
return None
def get_chat_by_share_id(self, db: Session, id: str) -> Optional[ChatModel]:
def get_chat_by_share_id(self, id: str) -> Optional[ChatModel]:
try:
chat = db.query(Chat).filter_by(share_id=id).first()
with get_session() as db:
chat = db.query(Chat).filter_by(share_id=id).first()
if chat:
return self.get_chat_by_id(db, id)
else:
return None
if chat:
return self.get_chat_by_id(id)
else:
return None
except Exception as e:
return None
def get_chat_by_id_and_user_id(
self, db: Session, id: str, user_id: str
self, id: str, user_id: str
) -> Optional[ChatModel]:
try:
chat = db.query(Chat).filter_by(id=id, user_id=user_id).first()
return ChatModel.model_validate(chat)
with get_session() as db:
chat = db.query(Chat).filter_by(id=id, user_id=user_id).first()
return ChatModel.model_validate(chat)
except:
return None
def get_chats(self, db: Session, skip: int = 0, limit: int = 50) -> List[ChatModel]:
all_chats = (
db.query(Chat)
# .limit(limit).offset(skip)
.order_by(Chat.updated_at.desc())
)
return [ChatModel.model_validate(chat) for chat in all_chats]
def get_chats(self, skip: int = 0, limit: int = 50) -> List[ChatModel]:
with get_session() as db:
all_chats = (
db.query(Chat)
# .limit(limit).offset(skip)
.order_by(Chat.updated_at.desc())
)
return [ChatModel.model_validate(chat) for chat in all_chats]
def get_chats_by_user_id(self, db: Session, user_id: str) -> List[ChatModel]:
all_chats = (
db.query(Chat).filter_by(user_id=user_id).order_by(Chat.updated_at.desc())
)
return [ChatModel.model_validate(chat) for chat in all_chats]
def get_chats_by_user_id(self, user_id: str) -> List[ChatModel]:
with get_session() as db:
all_chats = (
db.query(Chat).filter_by(user_id=user_id).order_by(Chat.updated_at.desc())
)
return [ChatModel.model_validate(chat) for chat in all_chats]
def get_archived_chats_by_user_id(
self, db: Session, user_id: str
self, user_id: str
) -> List[ChatModel]:
all_chats = (
db.query(Chat)
.filter_by(user_id=user_id, archived=True)
.order_by(Chat.updated_at.desc())
)
return [ChatModel.model_validate(chat) for chat in all_chats]
with get_session() as db:
all_chats = (
db.query(Chat)
.filter_by(user_id=user_id, archived=True)
.order_by(Chat.updated_at.desc())
)
return [ChatModel.model_validate(chat) for chat in all_chats]
def delete_chat_by_id(self, db: Session, id: str) -> bool:
def delete_chat_by_id(self, id: str) -> bool:
try:
db.query(Chat).filter_by(id=id).delete()
with get_session() as db:
db.query(Chat).filter_by(id=id).delete()
return True and self.delete_shared_chat_by_chat_id(db, id)
return True and self.delete_shared_chat_by_chat_id(id)
except:
return False
def delete_chat_by_id_and_user_id(self, db: Session, id: str, user_id: str) -> bool:
def delete_chat_by_id_and_user_id(self, id: str, user_id: str) -> bool:
try:
db.query(Chat).filter_by(id=id, user_id=user_id).delete()
with get_session() as db:
db.query(Chat).filter_by(id=id, user_id=user_id).delete()
return True and self.delete_shared_chat_by_chat_id(db, id)
return True and self.delete_shared_chat_by_chat_id(id)
except:
return False
def delete_chats_by_user_id(self, db: Session, user_id: str) -> bool:
def delete_chats_by_user_id(self, user_id: str) -> bool:
try:
with get_session() as db:
self.delete_shared_chats_by_user_id(user_id)
self.delete_shared_chats_by_user_id(db, user_id)
db.query(Chat).filter_by(user_id=user_id).delete()
db.query(Chat).filter_by(user_id=user_id).delete()
return True
except:
return False
def delete_shared_chats_by_user_id(self, db: Session, user_id: str) -> bool:
def delete_shared_chats_by_user_id(self, user_id: str) -> bool:
try:
chats_by_user = db.query(Chat).filter_by(user_id=user_id).all()
shared_chat_ids = [f"shared-{chat.id}" for chat in chats_by_user]
with get_session() as db:
chats_by_user = db.query(Chat).filter_by(user_id=user_id).all()
shared_chat_ids = [f"shared-{chat.id}" for chat in chats_by_user]
db.query(Chat).filter(Chat.user_id.in_(shared_chat_ids)).delete()
db.query(Chat).filter(Chat.user_id.in_(shared_chat_ids)).delete()
return True
except:

83
backend/apps/webui/models/documents.py
View File

@@ -6,7 +6,7 @@ import logging
from sqlalchemy import String, Column, BigInteger
from sqlalchemy.orm import Session
from apps.webui.internal.db import Base
from apps.webui.internal.db import Base, get_session
import json
@@ -73,7 +73,7 @@ class DocumentForm(DocumentUpdateForm):
class DocumentsTable:
def insert_new_doc(
self, db: Session, user_id: str, form_data: DocumentForm
self, user_id: str, form_data: DocumentForm
) -> Optional[DocumentModel]:
document = DocumentModel(
**{
@@ -84,66 +84,73 @@ class DocumentsTable:
)
try:
result = Document(**document.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return DocumentModel.model_validate(result)
else:
return None
with get_session() as db:
result = Document(**document.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return DocumentModel.model_validate(result)
else:
return None
except:
return None
def get_doc_by_name(self, db: Session, name: str) -> Optional[DocumentModel]:
def get_doc_by_name(self, name: str) -> Optional[DocumentModel]:
try:
document = db.query(Document).filter_by(name=name).first()
return DocumentModel.model_validate(document) if document else None
with get_session() as db:
document = db.query(Document).filter_by(name=name).first()
return DocumentModel.model_validate(document) if document else None
except:
return None
def get_docs(self, db: Session) -> List[DocumentModel]:
return [DocumentModel.model_validate(doc) for doc in db.query(Document).all()]
def get_docs(self) -> List[DocumentModel]:
with get_session() as db:
return [DocumentModel.model_validate(doc) for doc in db.query(Document).all()]
def update_doc_by_name(
self, db: Session, name: str, form_data: DocumentUpdateForm
self, name: str, form_data: DocumentUpdateForm
) -> Optional[DocumentModel]:
try:
db.query(Document).filter_by(name=name).update(
{
"title": form_data.title,
"name": form_data.name,
"timestamp": int(time.time()),
}
)
return self.get_doc_by_name(db, form_data.name)
with get_session() as db:
db.query(Document).filter_by(name=name).update(
{
"title": form_data.title,
"name": form_data.name,
"timestamp": int(time.time()),
}
)
db.commit()
return self.get_doc_by_name(form_data.name)
except Exception as e:
log.exception(e)
return None
def update_doc_content_by_name(
self, db: Session, name: str, updated: dict
self, name: str, updated: dict
) -> Optional[DocumentModel]:
try:
doc = self.get_doc_by_name(db, name)
doc_content = json.loads(doc.content if doc.content else "{}")
doc_content = {**doc_content, **updated}
with get_session() as db:
doc = self.get_doc_by_name(name)
doc_content = json.loads(doc.content if doc.content else "{}")
doc_content = {**doc_content, **updated}
db.query(Document).filter_by(name=name).update(
{
"content": json.dumps(doc_content),
"timestamp": int(time.time()),
}
)
return self.get_doc_by_name(db, name)
db.query(Document).filter_by(name=name).update(
{
"content": json.dumps(doc_content),
"timestamp": int(time.time()),
}
)
db.commit()
return self.get_doc_by_name(name)
except Exception as e:
log.exception(e)
return None
def delete_doc_by_name(self, db: Session, name: str) -> bool:
def delete_doc_by_name(self, name: str) -> bool:
try:
db.query(Document).filter_by(name=name).delete()
with get_session() as db:
db.query(Document).filter_by(name=name).delete()
return True
except:
return False

45
backend/apps/webui/models/files.py
View File

@@ -6,7 +6,7 @@ import logging
from sqlalchemy import Column, String, BigInteger
from sqlalchemy.orm import Session
from apps.webui.internal.db import JSONField, Base
from apps.webui.internal.db import JSONField, Base, get_session
import json
@@ -60,7 +60,7 @@ class FileForm(BaseModel):
class FilesTable:
def insert_new_file(self, db: Session, user_id: str, form_data: FileForm) -> Optional[FileModel]:
def insert_new_file(self, user_id: str, form_data: FileForm) -> Optional[FileModel]:
file = FileModel(
**{
**form_data.model_dump(),
@@ -70,38 +70,45 @@ class FilesTable:
)
try:
result = File(**file.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return FileModel.model_validate(result)
else:
return None
with get_session() as db:
result = File(**file.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return FileModel.model_validate(result)
else:
return None
except Exception as e:
print(f"Error creating tool: {e}")
return None
def get_file_by_id(self, db: Session, id: str) -> Optional[FileModel]:
def get_file_by_id(self, id: str) -> Optional[FileModel]:
try:
file = db.get(File, id)
return FileModel.model_validate(file)
with get_session() as db:
file = db.get(File, id)
return FileModel.model_validate(file)
except:
return None
def get_files(self, db: Session) -> List[FileModel]:
return [FileModel.model_validate(file) for file in db.query(File).all()]
def get_files(self) -> List[FileModel]:
with get_session() as db:
return [FileModel.model_validate(file) for file in db.query(File).all()]
def delete_file_by_id(self, db: Session, id: str) -> bool:
def delete_file_by_id(self, id: str) -> bool:
try:
db.query(File).filter_by(id=id).delete()
with get_session() as db:
db.query(File).filter_by(id=id).delete()
db.commit()
return True
except:
return False
def delete_all_files(self, db: Session) -> bool:
def delete_all_files(self) -> bool:
try:
db.query(File).delete()
with get_session() as db:
db.query(File).delete()
db.commit()
return True
except:
return False

117
backend/apps/webui/models/functions.py
View File

@@ -6,7 +6,7 @@ import logging
from sqlalchemy import Column, String, Text, BigInteger, Boolean
from sqlalchemy.orm import Session
from apps.webui.internal.db import JSONField, Base
from apps.webui.internal.db import JSONField, Base, get_session
from apps.webui.models.users import Users
import json
@@ -87,7 +87,7 @@ class FunctionValves(BaseModel):
class FunctionsTable:
def insert_new_function(
self, db: Session, user_id: str, type: str, form_data: FunctionForm
self, user_id: str, type: str, form_data: FunctionForm
) -> Optional[FunctionModel]:
function = FunctionModel(
**{
@@ -100,57 +100,64 @@ class FunctionsTable:
)
try:
result = Function(**function.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return FunctionModel.model_validate(result)
else:
return None
with get_session() as db:
result = Function(**function.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return FunctionModel.model_validate(result)
else:
return None
except Exception as e:
print(f"Error creating tool: {e}")
return None
def get_function_by_id(self, db: Session, id: str) -> Optional[FunctionModel]:
def get_function_by_id(self, id: str) -> Optional[FunctionModel]:
try:
function = db.get(Function, id)
return FunctionModel.model_validate(function)
with get_session() as db:
function = db.get(Function, id)
return FunctionModel.model_validate(function)
except:
return None
def get_functions(self, active_only=False) -> List[FunctionModel]:
if active_only:
return [
FunctionModel(**model_to_dict(function))
for function in Function.select().where(Function.is_active == True)
]
with get_session() as db:
return [
FunctionModel.model_validate(function)
for function in db.query(Function).filter_by(is_active=True).all()
]
else:
return [
FunctionModel(**model_to_dict(function))
for function in Function.select()
]
with get_session() as db:
return [
FunctionModel.model_validate(function)
for function in db.query(Function).all()
]
def get_functions_by_type(
self, type: str, active_only=False
) -> List[FunctionModel]:
if active_only:
return [
FunctionModel(**model_to_dict(function))
for function in Function.select().where(
Function.type == type, Function.is_active == True
)
]
with get_session() as db:
return [
FunctionModel.model_validate(function)
for function in db.query(Function).filter_by(
type=type, is_active=True
).all()
]
else:
return [
FunctionModel(**model_to_dict(function))
for function in Function.select().where(Function.type == type)
]
with get_session() as db:
return [
FunctionModel.model_validate(function)
for function in db.query(Function).filter_by(type=type).all()
]
def get_function_valves_by_id(self, id: str) -> Optional[dict]:
try:
function = Function.get(Function.id == id)
return function.valves if function.valves else {}
with get_session() as db:
function = db.get(Function, id)
return function.valves if function.valves else {}
except Exception as e:
print(f"An error occurred: {e}")
return None
@@ -159,14 +166,12 @@ class FunctionsTable:
self, id: str, valves: dict
) -> Optional[FunctionValves]:
try:
query = Function.update(
**{"valves": valves},
updated_at=int(time.time()),
).where(Function.id == id)
query.execute()
function = Function.get(Function.id == id)
return FunctionValves(**model_to_dict(function))
with get_session() as db:
db.query(Function).filter_by(id=id).update(
{"valves": valves, "updated_at": int(time.time())}
)
db.commit()
return self.get_function_by_id(id)
except:
return None
@@ -214,30 +219,32 @@ class FunctionsTable:
def update_function_by_id(self, id: str, updated: dict) -> Optional[FunctionModel]:
try:
db.query(Function).filter_by(id=id).update({
**updated,
"updated_at": int(time.time()),
})
return self.get_function_by_id(db, id)
with get_session() as db:
db.query(Function).filter_by(id=id).update({
**updated,
"updated_at": int(time.time()),
})
db.commit()
return self.get_function_by_id(id)
except:
return None
def deactivate_all_functions(self) -> Optional[bool]:
try:
query = Function.update(
**{"is_active": False},
updated_at=int(time.time()),
)
query.execute()
with get_session() as db:
db.query(Function).update({
"is_active": False,
"updated_at": int(time.time()),
})
db.commit()
return True
except:
return None
def delete_function_by_id(self, db: Session, id: str) -> bool:
def delete_function_by_id(self, id: str) -> bool:
try:
db.query(Function).filter_by(id=id).delete()
with get_session() as db:
db.query(Function).filter_by(id=id).delete()
return True
except:
return False

63
backend/apps/webui/models/memories.py
View File

@@ -4,7 +4,7 @@ from typing import List, Union, Optional
from sqlalchemy import Column, String, BigInteger
from sqlalchemy.orm import Session
from apps.webui.internal.db import Base
from apps.webui.internal.db import Base, get_session
from apps.webui.models.chats import Chats
import time
@@ -44,7 +44,6 @@ class MemoriesTable:
def insert_new_memory(
self,
db: Session,
user_id: str,
content: str,
) -> Optional[MemoryModel]:
@@ -59,53 +58,59 @@ class MemoriesTable:
"updated_at": int(time.time()),
}
)
result = Memory(**memory.dict())
db.add(result)
db.commit()
db.refresh(result)
if result:
return MemoryModel.model_validate(result)
else:
return None
with get_session() as db:
result = Memory(**memory.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return MemoryModel.model_validate(result)
else:
return None
def update_memory_by_id(
self,
db: Session,
id: str,
content: str,
) -> Optional[MemoryModel]:
try:
db.query(Memory).filter_by(id=id).update(
{"content": content, "updated_at": int(time.time())}
)
return self.get_memory_by_id(db, id)
with get_session() as db:
db.query(Memory).filter_by(id=id).update(
{"content": content, "updated_at": int(time.time())}
)
db.commit()
return self.get_memory_by_id(id)
except:
return None
def get_memories(self, db: Session) -> List[MemoryModel]:
def get_memories(self) -> List[MemoryModel]:
try:
memories = db.query(Memory).all()
return [MemoryModel.model_validate(memory) for memory in memories]
with get_session() as db:
memories = db.query(Memory).all()
return [MemoryModel.model_validate(memory) for memory in memories]
except:
return None
def get_memories_by_user_id(self, db: Session, user_id: str) -> List[MemoryModel]:
def get_memories_by_user_id(self, user_id: str) -> List[MemoryModel]:
try:
memories = db.query(Memory).filter_by(user_id=user_id).all()
return [MemoryModel.model_validate(memory) for memory in memories]
with get_session() as db:
memories = db.query(Memory).filter_by(user_id=user_id).all()
return [MemoryModel.model_validate(memory) for memory in memories]
except:
return None
def get_memory_by_id(self, db: Session, id: str) -> Optional[MemoryModel]:
def get_memory_by_id(self, id: str) -> Optional[MemoryModel]:
try:
memory = db.get(Memory, id)
return MemoryModel.model_validate(memory)
with get_session() as db:
memory = db.get(Memory, id)
return MemoryModel.model_validate(memory)
except:
return None
def delete_memory_by_id(self, db: Session, id: str) -> bool:
def delete_memory_by_id(self, id: str) -> bool:
try:
db.query(Memory).filter_by(id=id).delete()
with get_session() as db:
db.query(Memory).filter_by(id=id).delete()
return True
except:
@@ -113,7 +118,8 @@ class MemoriesTable:
def delete_memories_by_user_id(self, db: Session, user_id: str) -> bool:
try:
db.query(Memory).filter_by(user_id=user_id).delete()
with get_session() as db:
db.query(Memory).filter_by(user_id=user_id).delete()
return True
except:
return False
@@ -122,7 +128,8 @@ class MemoriesTable:
self, db: Session, id: str, user_id: str
) -> bool:
try:
db.query(Memory).filter_by(id=id, user_id=user_id).delete()
with get_session() as db:
db.query(Memory).filter_by(id=id, user_id=user_id).delete()
return True
except:
return False

55
backend/apps/webui/models/models.py
View File

@@ -6,7 +6,7 @@ from pydantic import BaseModel, ConfigDict
from sqlalchemy import String, Column, BigInteger
from sqlalchemy.orm import Session
from apps.webui.internal.db import Base, JSONField
from apps.webui.internal.db import Base, JSONField, get_session
from typing import List, Union, Optional
from config import SRC_LOG_LEVELS
@@ -78,8 +78,6 @@ class Model(Base):
class ModelModel(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: str
user_id: str
base_model_id: Optional[str] = None
@@ -91,6 +89,8 @@ class ModelModel(BaseModel):
updated_at: int # timestamp in epoch
created_at: int # timestamp in epoch
model_config = ConfigDict(from_attributes=True)
####################
# Forms
@@ -116,7 +116,7 @@ class ModelForm(BaseModel):
class ModelsTable:
def insert_new_model(
self, db: Session, form_data: ModelForm, user_id: str
self, form_data: ModelForm, user_id: str
) -> Optional[ModelModel]:
model = ModelModel(
**{
@@ -127,47 +127,52 @@ class ModelsTable:
}
)
try:
result = Model(**model.dict())
db.add(result)
db.commit()
db.refresh(result)
with get_session() as db:
result = Model(**model.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return ModelModel.model_validate(result)
else:
return None
if result:
return ModelModel.model_validate(result)
else:
return None
except Exception as e:
print(e)
return None
def get_all_models(self, db: Session) -> List[ModelModel]:
return [ModelModel.model_validate(model) for model in db.query(Model).all()]
def get_all_models(self) -> List[ModelModel]:
with get_session() as db:
return [ModelModel.model_validate(model) for model in db.query(Model).all()]
def get_model_by_id(self, db: Session, id: str) -> Optional[ModelModel]:
def get_model_by_id(self, id: str) -> Optional[ModelModel]:
try:
model = db.get(Model, id)
return ModelModel.model_validate(model)
with get_session() as db:
model = db.get(Model, id)
return ModelModel.model_validate(model)
except:
return None
def update_model_by_id(
self, db: Session, id: str, model: ModelForm
self, id: str, model: ModelForm
) -> Optional[ModelModel]:
try:
# update only the fields that are present in the model
model = db.query(Model).get(id)
model.update(**model.model_dump())
db.commit()
db.refresh(model)
return ModelModel.model_validate(model)
with get_session() as db:
model = db.query(Model).get(id)
model.update(**model.model_dump())
db.commit()
db.refresh(model)
return ModelModel.model_validate(model)
except Exception as e:
print(e)
return None
def delete_model_by_id(self, db: Session, id: str) -> bool:
def delete_model_by_id(self, id: str) -> bool:
try:
db.query(Model).filter_by(id=id).delete()
with get_session() as db:
db.query(Model).filter_by(id=id).delete()
return True
except:
return False

102
backend/apps/webui/models/prompts.py
View File

@@ -5,7 +5,7 @@ import time
from sqlalchemy import String, Column, BigInteger
from sqlalchemy.orm import Session
from apps.webui.internal.db import Base
from apps.webui.internal.db import Base, get_session
import json
@@ -48,61 +48,65 @@ class PromptForm(BaseModel):
class PromptsTable:
def insert_new_prompt(
self, db: Session, user_id: str, form_data: PromptForm
self, user_id: str, form_data: PromptForm
) -> Optional[PromptModel]:
prompt = PromptModel(
**{
"user_id": user_id,
"command": form_data.command,
"title": form_data.title,
"content": form_data.content,
"timestamp": int(time.time()),
}
)
try:
result = Prompt(**prompt.dict())
db.add(result)
db.commit()
db.refresh(result)
if result:
return PromptModel.model_validate(result)
else:
return None
except Exception as e:
return None
def get_prompt_by_command(self, db: Session, command: str) -> Optional[PromptModel]:
try:
prompt = db.query(Prompt).filter_by(command=command).first()
return PromptModel.model_validate(prompt)
except:
return None
def get_prompts(self, db: Session) -> List[PromptModel]:
return [PromptModel.model_validate(prompt) for prompt in db.query(Prompt).all()]
def update_prompt_by_command(
self, db: Session, command: str, form_data: PromptForm
) -> Optional[PromptModel]:
try:
db.query(Prompt).filter_by(command=command).update(
{
with get_session() as db:
prompt = PromptModel(
**{
"user_id": user_id,
"command": form_data.command,
"title": form_data.title,
"content": form_data.content,
"timestamp": int(time.time()),
}
)
return self.get_prompt_by_command(db, command)
except:
return None
def delete_prompt_by_command(self, db: Session, command: str) -> bool:
try:
db.query(Prompt).filter_by(command=command).delete()
return True
except:
return False
try:
result = Prompt(**prompt.dict())
db.add(result)
db.commit()
db.refresh(result)
if result:
return PromptModel.model_validate(result)
else:
return None
except Exception as e:
return None
def get_prompt_by_command(self, command: str) -> Optional[PromptModel]:
with get_session() as db:
try:
prompt = db.query(Prompt).filter_by(command=command).first()
return PromptModel.model_validate(prompt)
except:
return None
def get_prompts(self) -> List[PromptModel]:
with get_session() as db:
return [PromptModel.model_validate(prompt) for prompt in db.query(Prompt).all()]
def update_prompt_by_command(
self, command: str, form_data: PromptForm
) -> Optional[PromptModel]:
with get_session() as db:
try:
prompt = db.query(Prompt).filter_by(command=command).first()
prompt.title = form_data.title
prompt.content = form_data.content
prompt.timestamp = int(time.time())
db.commit()
return prompt
# return self.get_prompt_by_command(command)
except:
return None
def delete_prompt_by_command(self, command: str) -> bool:
with get_session() as db:
try:
db.query(Prompt).filter_by(command=command).delete()
return True
except:
return False
Prompts = PromptsTable()

217
backend/apps/webui/models/tags.py
View File

@@ -9,7 +9,7 @@ import logging
from sqlalchemy import String, Column, BigInteger
from sqlalchemy.orm import Session
from apps.webui.internal.db import Base
from apps.webui.internal.db import Base, get_session
from config import SRC_LOG_LEVELS
@@ -80,37 +80,39 @@ class ChatTagsResponse(BaseModel):
class TagTable:
def insert_new_tag(
self, db: Session, name: str, user_id: str
self, name: str, user_id: str
) -> Optional[TagModel]:
id = str(uuid.uuid4())
tag = TagModel(**{"id": id, "user_id": user_id, "name": name})
try:
result = Tag(**tag.dict())
db.add(result)
db.commit()
db.refresh(result)
if result:
return TagModel.model_validate(result)
else:
return None
with get_session() as db:
result = Tag(**tag.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return TagModel.model_validate(result)
else:
return None
except Exception as e:
return None
def get_tag_by_name_and_user_id(
self, db: Session, name: str, user_id: str
self, name: str, user_id: str
) -> Optional[TagModel]:
try:
tag = db.query(Tag).filter(name=name, user_id=user_id).first()
return TagModel.model_validate(tag)
with get_session() as db:
tag = db.query(Tag).filter(name=name, user_id=user_id).first()
return TagModel.model_validate(tag)
except Exception as e:
return None
def add_tag_to_chat(
self, db: Session, user_id: str, form_data: ChatIdTagForm
self, user_id: str, form_data: ChatIdTagForm
) -> Optional[ChatIdTagModel]:
tag = self.get_tag_by_name_and_user_id(db, form_data.tag_name, user_id)
tag = self.get_tag_by_name_and_user_id(form_data.tag_name, user_id)
if tag == None:
tag = self.insert_new_tag(db, form_data.tag_name, user_id)
tag = self.insert_new_tag(form_data.tag_name, user_id)
id = str(uuid.uuid4())
chatIdTag = ChatIdTagModel(
@@ -123,118 +125,127 @@ class TagTable:
}
)
try:
result = ChatIdTag(**chatIdTag.dict())
db.add(result)
db.commit()
db.refresh(result)
if result:
return ChatIdTagModel.model_validate(result)
else:
return None
with get_session() as db:
result = ChatIdTag(**chatIdTag.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return ChatIdTagModel.model_validate(result)
else:
return None
except:
return None
def get_tags_by_user_id(self, db: Session, user_id: str) -> List[TagModel]:
tag_names = [
chat_id_tag.tag_name
for chat_id_tag in (
db.query(ChatIdTag)
.filter_by(user_id=user_id)
.order_by(ChatIdTag.timestamp.desc())
.all()
)
]
def get_tags_by_user_id(self, user_id: str) -> List[TagModel]:
with get_session() as db:
tag_names = [
chat_id_tag.tag_name
for chat_id_tag in (
db.query(ChatIdTag)
.filter_by(user_id=user_id)
.order_by(ChatIdTag.timestamp.desc())
.all()
)
]
return [
TagModel.model_validate(tag)
for tag in (
db.query(Tag)
.filter_by(user_id=user_id)
.filter(Tag.name.in_(tag_names))
.all()
)
]
return [
TagModel.model_validate(tag)
for tag in (
db.query(Tag)
.filter_by(user_id=user_id)
.filter(Tag.name.in_(tag_names))
.all()
)
]
def get_tags_by_chat_id_and_user_id(
self, db: Session, chat_id: str, user_id: str
self, chat_id: str, user_id: str
) -> List[TagModel]:
tag_names = [
chat_id_tag.tag_name
for chat_id_tag in (
db.query(ChatIdTag)
.filter_by(user_id=user_id, chat_id=chat_id)
.order_by(ChatIdTag.timestamp.desc())
.all()
)
]
with get_session() as db:
tag_names = [
chat_id_tag.tag_name
for chat_id_tag in (
db.query(ChatIdTag)
.filter_by(user_id=user_id, chat_id=chat_id)
.order_by(ChatIdTag.timestamp.desc())
.all()
)
]
return [
TagModel.model_validate(tag)
for tag in (
db.query(Tag)
.filter_by(user_id=user_id)
.filter(Tag.name.in_(tag_names))
.all()
)
]
return [
TagModel.model_validate(tag)
for tag in (
db.query(Tag)
.filter_by(user_id=user_id)
.filter(Tag.name.in_(tag_names))
.all()
)
]
def get_chat_ids_by_tag_name_and_user_id(
self, db: Session, tag_name: str, user_id: str
self, tag_name: str, user_id: str
) -> List[ChatIdTagModel]:
return [
ChatIdTagModel.model_validate(chat_id_tag)
for chat_id_tag in (
db.query(ChatIdTag)
.filter_by(user_id=user_id, tag_name=tag_name)
.order_by(ChatIdTag.timestamp.desc())
.all()
)
]
with get_session() as db:
return [
ChatIdTagModel.model_validate(chat_id_tag)
for chat_id_tag in (
db.query(ChatIdTag)
.filter_by(user_id=user_id, tag_name=tag_name)
.order_by(ChatIdTag.timestamp.desc())
.all()
)
]
def count_chat_ids_by_tag_name_and_user_id(
self, db: Session, tag_name: str, user_id: str
self, tag_name: str, user_id: str
) -> int:
return db.query(ChatIdTag).filter_by(tag_name=tag_name, user_id=user_id).count()
with get_session() as db:
return db.query(ChatIdTag).filter_by(tag_name=tag_name, user_id=user_id).count()
def delete_tag_by_tag_name_and_user_id(
self, db: Session, tag_name: str, user_id: str
self, tag_name: str, user_id: str
) -> bool:
try:
res = (
db.query(ChatIdTag)
.filter_by(tag_name=tag_name, user_id=user_id)
.delete()
)
log.debug(f"res: {res}")
with get_session() as db:
res = (
db.query(ChatIdTag)
.filter_by(tag_name=tag_name, user_id=user_id)
.delete()
)
log.debug(f"res: {res}")
db.commit()
tag_count = self.count_chat_ids_by_tag_name_and_user_id(
db, tag_name, user_id
)
if tag_count == 0:
# Remove tag item from Tag col as well
db.query(Tag).filter_by(name=tag_name, user_id=user_id).delete()
tag_count = self.count_chat_ids_by_tag_name_and_user_id(
tag_name, user_id
)
if tag_count == 0:
# Remove tag item from Tag col as well
db.query(Tag).filter_by(name=tag_name, user_id=user_id).delete()
return True
except Exception as e:
log.error(f"delete_tag: {e}")
return False
def delete_tag_by_tag_name_and_chat_id_and_user_id(
self, db: Session, tag_name: str, chat_id: str, user_id: str
self, tag_name: str, chat_id: str, user_id: str
) -> bool:
try:
res = (
db.query(ChatIdTag)
.filter_by(tag_name=tag_name, chat_id=chat_id, user_id=user_id)
.delete()
)
log.debug(f"res: {res}")
with get_session() as db:
res = (
db.query(ChatIdTag)
.filter_by(tag_name=tag_name, chat_id=chat_id, user_id=user_id)
.delete()
)
log.debug(f"res: {res}")
db.commit()
tag_count = self.count_chat_ids_by_tag_name_and_user_id(
db, tag_name, user_id
)
if tag_count == 0:
# Remove tag item from Tag col as well
db.query(Tag).filter_by(name=tag_name, user_id=user_id).delete()
tag_count = self.count_chat_ids_by_tag_name_and_user_id(
tag_name, user_id
)
if tag_count == 0:
# Remove tag item from Tag col as well
db.query(Tag).filter_by(name=tag_name, user_id=user_id).delete()
return True
except Exception as e:
@@ -242,13 +253,13 @@ class TagTable:
return False
def delete_tags_by_chat_id_and_user_id(
self, db: Session, chat_id: str, user_id: str
self, chat_id: str, user_id: str
) -> bool:
tags = self.get_tags_by_chat_id_and_user_id(db, chat_id, user_id)
tags = self.get_tags_by_chat_id_and_user_id(chat_id, user_id)
for tag in tags:
self.delete_tag_by_tag_name_and_chat_id_and_user_id(
db, tag.tag_name, chat_id, user_id
tag.tag_name, chat_id, user_id
)
return True

70
backend/apps/webui/models/tools.py
View File

@@ -5,7 +5,7 @@ import logging
from sqlalchemy import String, Column, BigInteger
from sqlalchemy.orm import Session
from apps.webui.internal.db import Base, JSONField
from apps.webui.internal.db import Base, JSONField, get_session
from apps.webui.models.users import Users
import json
@@ -82,7 +82,7 @@ class ToolValves(BaseModel):
class ToolsTable:
def insert_new_tool(
self, db: Session, user_id: str, form_data: ToolForm, specs: List[dict]
self, user_id: str, form_data: ToolForm, specs: List[dict]
) -> Optional[ToolModel]:
tool = ToolModel(
**{
@@ -95,46 +95,48 @@ class ToolsTable:
)
try:
result = Tool(**tool.dict())
db.add(result)
db.commit()
db.refresh(result)
if result:
return ToolModel.model_validate(result)
else:
return None
with get_session() as db:
result = Tool(**tool.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return ToolModel.model_validate(result)
else:
return None
except Exception as e:
print(f"Error creating tool: {e}")
return None
def get_tool_by_id(self, db: Session, id: str) -> Optional[ToolModel]:
def get_tool_by_id(self, id: str) -> Optional[ToolModel]:
try:
tool = db.get(Tool, id)
return ToolModel.model_validate(tool)
with get_session() as db:
tool = db.get(Tool, id)
return ToolModel.model_validate(tool)
except:
return None
def get_tools(self, db: Session) -> List[ToolModel]:
return [ToolModel.model_validate(tool) for tool in db.query(Tool).all()]
def get_tools(self) -> List[ToolModel]:
with get_session() as db:
return [ToolModel.model_validate(tool) for tool in db.query(Tool).all()]
def get_tool_valves_by_id(self, id: str) -> Optional[dict]:
try:
tool = Tool.get(Tool.id == id)
return tool.valves if tool.valves else {}
with get_session() as db:
tool = db.get(Tool, id)
return tool.valves if tool.valves else {}
except Exception as e:
print(f"An error occurred: {e}")
return None
def update_tool_valves_by_id(self, id: str, valves: dict) -> Optional[ToolValves]:
try:
query = Tool.update(
**{"valves": valves},
updated_at=int(time.time()),
).where(Tool.id == id)
query.execute()
tool = Tool.get(Tool.id == id)
return ToolValves(**model_to_dict(tool))
with get_session() as db:
db.query(Tool).filter_by(id=id).update(
{"valves": valves, "updated_at": int(time.time())}
)
db.commit()
return self.get_tool_by_id(id)
except:
return None
@@ -172,8 +174,7 @@ class ToolsTable:
user_settings["tools"]["valves"][id] = valves
# Update the user settings in the database
query = Users.update_user_by_id(user_id, {"settings": user_settings})
query.execute()
Users.update_user_by_id(user_id, {"settings": user_settings})
return user_settings["tools"]["valves"][id]
except Exception as e:
@@ -182,16 +183,19 @@ class ToolsTable:
def update_tool_by_id(self, id: str, updated: dict) -> Optional[ToolModel]:
try:
db.query(Tool).filter_by(id=id).update(
{**updated, "updated_at": int(time.time())}
)
return self.get_tool_by_id(db, id)
with get_session() as db:
db.query(Tool).filter_by(id=id).update(
{**updated, "updated_at": int(time.time())}
)
db.commit()
return self.get_tool_by_id(id)
except:
return None
def delete_tool_by_id(self, db: Session, id: str) -> bool:
def delete_tool_by_id(self, id: str) -> bool:
try:
db.query(Tool).filter_by(id=id).delete()
with get_session() as db:
db.query(Tool).filter_by(id=id).delete()
return True
except:
return False

309
backend/apps/webui/models/users.py
View File

@@ -7,7 +7,7 @@ from sqlalchemy.orm import Session
from utils.misc import get_gravatar_url
from apps.webui.internal.db import Base, JSONField
from apps.webui.internal.db import Base, JSONField, get_session
from apps.webui.models.chats import Chats
####################
@@ -42,8 +42,6 @@ class UserSettings(BaseModel):
class UserModel(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: str
name: str
email: str
@@ -60,6 +58,8 @@ class UserModel(BaseModel):
oauth_sub: Optional[str] = None
model_config = ConfigDict(from_attributes=True)
####################
# Forms
@@ -82,7 +82,6 @@ class UsersTable:
def insert_new_user(
self,
db: Session,
id: str,
name: str,
email: str,
@@ -90,165 +89,181 @@ class UsersTable:
role: str = "pending",
oauth_sub: Optional[str] = None,
) -> Optional[UserModel]:
user = UserModel(
**{
"id": id,
"name": name,
"email": email,
"role": role,
"profile_image_url": profile_image_url,
"last_active_at": int(time.time()),
"created_at": int(time.time()),
"updated_at": int(time.time()),
"oauth_sub": oauth_sub,
}
)
result = User(**user.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return user
else:
return None
with get_session() as db:
user = UserModel(
**{
"id": id,
"name": name,
"email": email,
"role": role,
"profile_image_url": profile_image_url,
"last_active_at": int(time.time()),
"created_at": int(time.time()),
"updated_at": int(time.time()),
"oauth_sub": oauth_sub,
}
)
result = User(**user.model_dump())
db.add(result)
db.commit()
db.refresh(result)
if result:
return user
else:
return None
def get_user_by_id(self, db: Session, id: str) -> Optional[UserModel]:
try:
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except Exception as e:
return None
def get_user_by_id(self, id: str) -> Optional[UserModel]:
with get_session() as db:
try:
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except Exception as e:
return None
def get_user_by_api_key(self, db: Session, api_key: str) -> Optional[UserModel]:
try:
user = db.query(User).filter_by(api_key=api_key).first()
return UserModel.model_validate(user)
except:
return None
def get_user_by_api_key(self, api_key: str) -> Optional[UserModel]:
with get_session() as db:
try:
user = db.query(User).filter_by(api_key=api_key).first()
return UserModel.model_validate(user)
except:
return None
def get_user_by_email(self, db: Session, email: str) -> Optional[UserModel]:
try:
user = db.query(User).filter_by(email=email).first()
return UserModel.model_validate(user)
except:
return None
def get_user_by_email(self, email: str) -> Optional[UserModel]:
with get_session() as db:
try:
user = db.query(User).filter_by(email=email).first()
return UserModel.model_validate(user)
except:
return None
def get_user_by_oauth_sub(self, sub: str) -> Optional[UserModel]:
try:
user = User.get(User.oauth_sub == sub)
return UserModel(**model_to_dict(user))
except:
return None
with get_session() as db:
try:
user = db.query(User).filter_by(oauth_sub=sub).first()
return UserModel.model_validate(user)
except:
return None
def get_users(self, db: Session, skip: int = 0, limit: int = 50) -> List[UserModel]:
users = (
db.query(User)
# .offset(skip).limit(limit)
.all()
)
return [UserModel.model_validate(user) for user in users]
def get_users(self, skip: int = 0, limit: int = 50) -> List[UserModel]:
with get_session() as db:
users = (
db.query(User)
# .offset(skip).limit(limit)
.all()
)
return [UserModel.model_validate(user) for user in users]
def get_num_users(self, db: Session) -> Optional[int]:
return db.query(User).count()
def get_num_users(self) -> Optional[int]:
with get_session() as db:
return db.query(User).count()
def get_first_user(self, db: Session) -> UserModel:
try:
user = db.query(User).order_by(User.created_at).first()
return UserModel.model_validate(user)
except:
return None
def get_first_user(self) -> UserModel:
with get_session() as db:
try:
user = db.query(User).order_by(User.created_at).first()
return UserModel.model_validate(user)
except:
return None
def update_user_role_by_id(
self, db: Session, id: str, role: str
self, id: str, role: str
) -> Optional[UserModel]:
try:
db.query(User).filter_by(id=id).update({"role": role})
db.commit()
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except:
return None
def update_user_profile_image_url_by_id(
self, db: Session, id: str, profile_image_url: str
) -> Optional[UserModel]:
try:
db.query(User).filter_by(id=id).update(
{"profile_image_url": profile_image_url}
)
db.commit()
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except:
return None
def update_user_last_active_by_id(
self, db: Session, id: str
) -> Optional[UserModel]:
try:
db.query(User).filter_by(id=id).update({"last_active_at": int(time.time())})
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except:
return None
def update_user_oauth_sub_by_id(
self, db: Session, id: str, oauth_sub: str
) -> Optional[UserModel]:
try:
db.query(User).filter_by(id=id).update({"oauth_sub": oauth_sub})
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except:
return None
def update_user_by_id(
self, db: Session, id: str, updated: dict
) -> Optional[UserModel]:
try:
db.query(User).filter_by(id=id).update(updated)
db.commit()
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
# return UserModel(**user.dict())
except Exception as e:
return None
def delete_user_by_id(self, db: Session, id: str) -> bool:
try:
# Delete User Chats
result = Chats.delete_chats_by_user_id(db, id)
if result:
# Delete User
db.query(User).filter_by(id=id).delete()
with get_session() as db:
try:
db.query(User).filter_by(id=id).update({"role": role})
db.commit()
return True
else:
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except:
return None
def update_user_profile_image_url_by_id(
self, id: str, profile_image_url: str
) -> Optional[UserModel]:
with get_session() as db:
try:
db.query(User).filter_by(id=id).update(
{"profile_image_url": profile_image_url}
)
db.commit()
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except:
return None
def update_user_last_active_by_id(
self, id: str
) -> Optional[UserModel]:
with get_session() as db:
try:
db.query(User).filter_by(id=id).update({"last_active_at": int(time.time())})
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except:
return None
def update_user_oauth_sub_by_id(
self, id: str, oauth_sub: str
) -> Optional[UserModel]:
with get_session() as db:
try:
db.query(User).filter_by(id=id).update({"oauth_sub": oauth_sub})
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
except:
return None
def update_user_by_id(
self, id: str, updated: dict
) -> Optional[UserModel]:
with get_session() as db:
try:
db.query(User).filter_by(id=id).update(updated)
db.commit()
user = db.query(User).filter_by(id=id).first()
return UserModel.model_validate(user)
# return UserModel(**user.dict())
except Exception as e:
return None
def delete_user_by_id(self, id: str) -> bool:
with get_session() as db:
try:
# Delete User Chats
result = Chats.delete_chats_by_user_id(id)
if result:
# Delete User
db.query(User).filter_by(id=id).delete()
db.commit()
return True
else:
return False
except:
return False
except:
return False
def update_user_api_key_by_id(self, db: Session, id: str, api_key: str) -> str:
try:
result = db.query(User).filter_by(id=id).update({"api_key": api_key})
db.commit()
return True if result == 1 else False
except:
return False
def update_user_api_key_by_id(self, id: str, api_key: str) -> str:
with get_session() as db:
try:
result = db.query(User).filter_by(id=id).update({"api_key": api_key})
db.commit()
return True if result == 1 else False
except:
return False
def get_user_api_key_by_id(self, db: Session, id: str) -> Optional[str]:
try:
user = db.query(User).filter_by(id=id).first()
return user.api_key
except Exception as e:
return None
def get_user_api_key_by_id(self, id: str) -> Optional[str]:
with get_session() as db:
try:
user = db.query(User).filter_by(id=id).first()
return user.api_key
except Exception as e:
return None
Users = UsersTable()