changes

Author: t33nsy

app/api/files.py

@@ -146,6 +146,12 @@ def upload_presentation() -> (dict, int):
                 Config.c.constants.presentation_file_max_size_in_megabytes
             )
         }, 404
+    # check if file can be stored (*2.5 is an estimate of pdf and preview)
+    if not DBManager().check_storage_limit(request.content_length * 2.5):
+        return {
+            'message': "Not enough place in database to store file"
+        }, 404
+        
     presentation_file = request.files['presentation']
 
     # check extension and mimetype of file 
@@ -172,19 +178,13 @@ def upload_presentation() -> (dict, int):
         presentation_file.filename = converted_name
         # save nonconverted file with original_name
         nonconverted_file_id = DBManager().add_file(non_converted_file, original_name)
-        if nonconverted_file_id is None:
-            return {'message': 'Недостаточно места.'}, 404
 
     presentation_file_id = DBManager().add_file(presentation_file, presentation_file.filename)
-    if presentation_file_id is None:
-        return {'message': 'Недостаточно места.'}, 400
     presentation_file_preview = get_presentation_file_preview(DBManager().get_file(presentation_file_id))
     presentation_file_preview_id = DBManager().read_and_add_file(
         presentation_file_preview.name,
         presentation_file_preview.name,
     )
-    if presentation_file_preview_id is None:
-        return {'message': 'Недостаточно места.'}, 400
     presentation_file_preview.close()
     PresentationFilesDBManager().add_presentation_file(
         presentation_file_id,

app/api/trainings.py

@@ -275,8 +275,6 @@ def add_presentation_record(training_id: str) -> (dict, int):
     TrainingsDBManager().change_training_status_by_training_id(training_id,
                                                                TrainingStatus.SENT_FOR_PREPARATION)
     presentation_record_file_id = DBManager().add_file(presentation_record_file)
-    if presentation_record_file_id is None:
-        return {'message': 'Недостаточно места.'}, 404
     TrainingsDBManager().add_presentation_record(
         training_id, presentation_record_file_id, presentation_record_duration,
     )

app/mongo_odm.py

@@ -29,30 +29,26 @@
 from app.utils import remove_blank_and_none
 
 logger = get_root_logger()
-    
+
+BYTES_PER_MB = 1024*1024    
 
 class DBManager:
-    def __new__(cls, max_size=20000): # max_size only on first creation
+    def __new__(cls, max_size=20000): # max_size only on first creation, in MB
         if not hasattr(cls, 'init_done'):
             cls.instance = super(DBManager, cls).__new__(cls)
             connect(Config.c.mongodb.url + Config.c.mongodb.database_name)
             cls.instance.storage = GridFSStorage(GridFSBucket(_get_db()))
-            cls.instance.max_size = max_size
+            cls.instance.max_size = max_size * BYTES_PER_MB
             cls.init_done = True
         return cls.instance
 
-    # returns id of saved file and None if storage limit exceeded
     def add_file(self, file, filename=uuid.uuid4()):
         try:
             file.seek(0, os.SEEK_END)
             size = file.tell()
             file.seek(0)
         except:
             size = len(file)
-        cur_size = self.check_storage_limit(size)
-        if cur_size > self.max_size:
-            logger.error(f"Could not save file {filename}: Storage limit exceeded")
-            return None  # storage limit exceeded, can't add file
         _id = self.storage.save(name=filename, content=file)
         self.update_storage_size(size)
         return _id
@@ -100,17 +96,21 @@ def update_storage_size(self, deltasize):
         meta = self._get_or_create_storage_meta()
         meta.used_size += deltasize
         meta.save()
+        
+    def get_max_size(self):
+        return self.max_size
 
+    # returns Bool variable - True if file can be stored else False
     def check_storage_limit(self, new_file_size):
         current_size = self.get_used_storage_size()
         inf_msg = (
             f"Check for ability to add file: "
-            f"Current: {current_size/(1024*1024):.2f} MB, "
-            f"New file: {new_file_size/(1024*1024):.2f} MB, "
-            f"Storage size: {self.max_size} MB"
+            f"Current: {current_size/BYTES_PER_MB:.2f} MB, "
+            f"New file: {new_file_size/BYTES_PER_MB:.2f} MB, "
+            f"Storage size: {self.max_size/BYTES_PER_MB} MB"
         )
         logger.info(inf_msg)
-        return current_size + new_file_size
+        return False if current_size + new_file_size > self.max_size else True
 
 
 class TrainingsDBManager:

app/routes/capacity.py

@@ -1,11 +1,12 @@
 from flask import Blueprint, render_template
 from app.mongo_odm import DBManager
-from app.config import Config
 from app.root_logger import get_root_logger
 from app.lti_session_passback.auth_checkers import is_admin
 
 logger = get_root_logger()
 
+BYTES_PER_MB = 1024*1024
+
 routes_capacity = Blueprint(
     'routes_capacity', __name__, url_prefix='/capacity')
 
@@ -14,12 +15,12 @@ def storage_capacity():
     if not is_admin():
         return {}, 404
     current_size = DBManager().get_used_storage_size()
-    max_size = int(Config.c.constants.storage_max_size_mbytes)*1024*1024
+    max_size = DBManager().get_max_size()
     ratio = current_size / max_size
     return render_template(
         'capacity.html',
-        size=round(current_size / (1024*1024), 2),
-        max_size=round(max_size / (1024*1024), 2),
+        size=round(current_size / BYTES_PER_MB, 2),
+        max_size=round(max_size / BYTES_PER_MB, 2),
         ratio=round(ratio * 100, 1)
     )