Added predavanja, restructure, progress on solar.

portal/base.py

@@ -2,6 +2,7 @@ import hashlib
 import time
 import ssl
 import traceback
+import re
 from pathlib import Path
 from datetime import datetime
 
@@ -18,19 +19,22 @@ from email.mime.application import MIMEApplication
 import pdfkit
 from jinja2 import Environment, FileSystemLoader
 
-from . model import db, UploadUnauthenticated, UploadSolar
+from . model import db, UploadRegular, UploadSolar, RegisteredUser
 
 
 ENABLED_FILETYPES = ['txt', 'csv', 'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'xml', 'mxliff', 'tmx']
 REGEX_EMAIL = re.compile('^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w{2,3}$')
 
+MAX_FNAME_LEN = 100
+
 
 class ContractCreator:
 
-    def __init__(self):
+    def __init__(self, base_path, template_path):
+        self.base = base_path
         template_loader = FileSystemLoader(searchpath="./")
         template_env = Environment(loader=template_loader)
-        self.template = template_env.get_template('contract/template.html')
+        self.template = template_env.get_template(template_path)
 
         self.pdfkit_options = {
             'page-size': 'A4',
@@ -47,7 +51,11 @@ class ContractCreator:
     def fill_template(self, **kwargs):
         return self.template.render(**kwargs)
 
-    def create_pdf(self, out_f, fields_dict):
+    def create_pdf(self, f_name, fields_dict):
+        sub_dir = self.base / Path(f_name[:2])
+        if not sub_dir.exists():
+            sub_dir.mkdir()
+        out_f = sub_dir / Path(f_name[2:])
         html_str = self.fill_template(**fields_dict)
         pdfkit.from_string(html_str, out_f, options=self.pdfkit_options)
 
@@ -56,17 +64,26 @@ class UploadHandler:
 
     def __init__(self, **kwargs):
         self.config = kwargs
+    
+    def set_contract_creator(self, contract_creator):
+        assert isinstance(contract_creator, ContractCreator)
+        self._contract_creator = contract_creator
 
-        self.contract_creator = ContractCreator()
+    def get_uploads_subdir(self, dir_name):
+        subdir = Path(self.config['UPLOADS_DIR']) / dir_name
+        if not subdir.exists():
+            subdir.mkdir(parents=True)
+        return subdir
 
-    def extract_upload_metadata(self, corpus_name, request):
+    @staticmethod
+    def extract_upload_metadata(corpus_name, request):
         upload_metadata = dict()
 
-        file_hashes = self.create_file_hashes(request.files)
+        file_hashes = UploadHandler.create_file_hashes(request.files)
         file_names = file_hashes.keys()
         form_data = request.form.copy()
         upload_timestamp = int(time.time())
-        upload_id = self.create_upload_id(corpus_name, form_data, upload_timestamp, file_hashes)
+        upload_id = UploadHandler.create_upload_id(corpus_name, form_data, upload_timestamp, file_hashes)
 
         upload_metadata['corpus_name'] = corpus_name
         upload_metadata['form_data'] = form_data
@@ -78,14 +95,8 @@ class UploadHandler:
 
         return upload_metadata
 
-    def get_uploads_subdir(self, dir_name):
-        subdir = Path(self.config['UPLOADS_DIR']) / dir_name
-        if not subdir.exists():
-            subdir.mkdir(parents=True)
-        return subdir
-
-
-    def create_upload_id(self, corpus_name, form_data, upload_timestamp, file_hashes):
+    @staticmethod
+    def create_upload_id(corpus_name, form_data, upload_timestamp, file_hashes):
         # Order is important while hashing, hence the sorting.
         val_buff = [str(upload_timestamp)]
         for key in sorted(form_data):
@@ -102,7 +113,8 @@ class UploadHandler:
 
         return metahash
 
-    def create_file_hashes(self, files):
+    @staticmethod
+    def create_file_hashes(files):
         res = dict()
         for key, f in files.items():
             if key.startswith('file'):
@@ -112,57 +124,14 @@ class UploadHandler:
                 f.seek(0)
         return res
 
-    def store_metadata_unauthenticated(self, upload_metadata):
-        timestamp = datetime.fromtimestamp(upload_metadata['timestamp'])
-        form_data = upload_metadata['form_data']
-        file_hashes = upload_metadata['file_hashes_dict']
-        sorted_f_hashes = list(file_hashes.values())
-        sorted_f_hashes.sort()
-        
+    @staticmethod
+    def store_model(self, model_obj):
         try:
-            upload_unauthenticated = UploadUnauthenticated(
-                    upload_hash=upload_metadata['upload_id'],
-                    timestamp=timestamp,
-                    form_name=form_data['ime'],
-                    form_org=form_data['podjetje'],
-                    form_address=form_data['naslov'],
-                    form_zipcode=form_data['posta'],
-                    form_email=form_data['email'],
-                    file_contract=upload_metadata['contract_file'],
-                    upload_file_hashes=sorted_f_hashes,
-                    corpus_name=todo
-                   )
-
-            db.session.add(upload_unauthenticated)
-            db.session.commit()
-        except Exception:
-            traceback.print_exc()
-
-    def store_metadata_solar(self, upload_metadata):
-        timestamp = datetime.fromtimestamp(upload_metadata['timestamp'])
-        form_data = upload_metadata['form_data']
-        file_hashes = upload_metadata['file_hashes_dict']
-        sorted_f_hashes = list(file_hashes.values())
-        sorted_f_hashes.sort()
-
-        try:
-            upload_solar = UploadSolar(
-                    upload_user = todo,
-                    institution = todo,
-                    upload_hash=upload_metadata['upload_id'],
-                    timestamp=timestamp,
-                    form_program=form_data['program'],
-                    form_subject=form_data['subject'],
-                    form_grade=form_data['grade'],
-                    form_text_type=form_data['text_type'],
-                    form_school_year=form_data['school_year'],
-                    form_grammar_corrections=form_data['grammar_corrections'],
-                    upload_file_hashes=sorted_f_hashes
-                   )
-            db.session.add(upload_unauthenticated)
+            db.session.add(model_obj)
             db.session.commit()
         except Exception:
             traceback.print_exc()
+    
 
     def store_datafiles(self, files, upload_metadata):
         base = self.get_uploads_subdir('files')
@@ -170,32 +139,18 @@ class UploadHandler:
 
         for key, f in files.items():
             if key.startswith('file'):
-                path = base / file_hashes[f.filename]
+                f_hash = file_hashes[f.filename]
+                
+                # First byte used for indexing, similarly like git does for example.
+                sub_dir = base / f_hash[:2]
+                if not sub_dir.exists():
+                    sub_dir.mkdir()
+
+                path = sub_dir / f_hash[2:]
                 if not path.exists():
                     path.mkdir()
                     f.save(path / f.filename)
 
-    def generate_upload_contract_pdf(self, upload_metadata):
-        base = self.get_uploads_subdir('contracts')
-        form_data = upload_metadata['form_data']
-
-        files_table_str = []
-        for file_name in upload_metadata['file_names']:
-            files_table_str.append('<tr><td style="text-align: center;">')
-            files_table_str.append(file_name)
-            files_table_str.append('</td></tr>')
-        files_table_str = ''.join(files_table_str)
-
-        data = {
-            'ime_priimek': form_data['ime'],
-            'naslov': form_data['naslov'],
-            'posta': form_data['posta'],
-            'kontakt_narocnik': self.config['CONTRACT_CLIENT_CONTACT'],
-            'kontakt_imetnikpravic': form_data['ime'],
-            'files_table_str': files_table_str
-            }
-
-        self.contract_creator.create_pdf(base / upload_metadata['contract_file'], data)
 
     def send_confirm_mail(self, upload_metadata):
         upload_id = upload_metadata['upload_id']
@@ -207,15 +162,16 @@ class UploadHandler:
         body = self.config['MAIL_BODY'].format(upload_id=upload_id)
         message.attach(MIMEText(body, "plain"))
 
-        contracts_dir = self.get_uploads_subdir('contracts')
-        base_name = upload_metadata['contract_file']
-        contract_file = contracts_dir / base_name
+        contracts_dir = self.contract_creator.base
+        f_name = upload_metadata['contract_file']
+        sub_dir = contracts_dir / Path(f_name[:2])
+        contract_file = sub_dir / Path(f_name[2:])
         with open(contract_file, "rb") as f:
             part = MIMEApplication(
                     f.read(),
-                    Name = base_name
+                    Name = f_name
                 )
-        part['Content-Disposition'] = 'attachment; filename="%s"' % base_name
+        part['Content-Disposition'] = 'attachment; filename="%s"' % f_name
         message.attach(part)
 
         text = message.as_string()
@@ -223,89 +179,57 @@ class UploadHandler:
         # Create a secure SSL context
         context = ssl.create_default_context()
 
-        with SMTP_SSL(self.config['MAIL_HOST'], self.config['SMTP_PORT'], context=context) as server:
-            server.login(self.config['MAIL_LOGIN'], self.config['MAIL_PASS'])
-            server.sendmail(message['From'], message['To'], text)
+        try:
+            with SMTP_SSL(self.config['MAIL_HOST'], self.config['SMTP_PORT'], context=context) as server:
+                server.login(self.config['MAIL_LOGIN'], self.config['MAIL_PASS'])
+                server.sendmail(message['From'], message['To'], text)
 
-        # Save copy of sent mail in Sent mailbox
-        imap = imaplib.IMAP4_SSL(self.config['MAIL_HOST'], self.config['IMAP_PORT'])
-        imap.login(self.config['MAIL_LOGIN'], self.config['MAIL_PASS'])
-        imap.append('Sent', '\\Seen', imaplib.Time2Internaldate(time.time()), text.encode('utf8'))
-        imap.logout()
+            # Save copy of sent mail in Sent mailbox
+            imap = imaplib.IMAP4_SSL(self.config['MAIL_HOST'], self.config['IMAP_PORT'])
+            imap.login(self.config['MAIL_LOGIN'], self.config['MAIL_PASS'])
+            imap.append('Sent', '\\Seen', imaplib.Time2Internaldate(time.time()), text.encode('utf8'))
+            imap.logout()
+        except Exception:
+            traceback.print_exc()
 
 
-def handle_upload_unauthenticated(request, corpus_name, upload_handler):
-    files = request.files
-    if len(files) > upload_handler.MAX_FILES_PER_UPLOAD:
-        return 'Naložite lahko do {} datotek hkrati.'.format(upload_handler.MAX_FILES_PER_UPLOAD), 400
-    elif len(files) < 1:
-        return 'Priložena ni bila nobena datoteka.', 400
+    @staticmethod
+    def check_suffixes(files):
+        for key, f in files.items():
+            if key.startswith('file'):
+                suffix = f.filename.split('.')[-1]
+                if suffix not in ENABLED_FILETYPES:
+                    return 'Datoteka "{}" ni pravilnega formata.'.format(f.filename)
+        return None
 
-    err = check_suffixes(files)
-    if err:
-        return err, 400
+    @staticmethod
+    def check_fname_lengths(files):
+        for key, f in files.items():
+            if key.startswith('file'):
+                if len(f.filename) > MAX_FNAME_LEN:
+                    return 'Ime datoteke presega dolžino {} znakov.'.format(MAX_FNAME_LEN)
+        return None
 
-    err = check_form(request.form)
-    if err:
-        return err, 400
+    def check_upload_request(self, request):
+        files = request.files
+        max_files = self.config['MAX_FILES_PER_UPLOAD']
+        if len(files) > max_files:
+            return 'Naložite lahko do {} datotek hkrati.'.format(max_files), 400
+        elif len(files) < 1:
+            return 'Priložena ni bila nobena datoteka.', 400
 
-    # Parse request.
-    upload_metadata = upload_handler.extract_upload_metadata(corpus_name, request)
+        err = UploadHandler.check_suffixes(files)
+        if err:
+            return err, 400
 
-    logging.info('Upload with id "{}" supplied form data: {}'.format(upload_metadata['upload_id'],
-        str(upload_metadata['form_data'])))
+        err = UploadHandler.check_fname_lengths(files)
+        if err:
+            return err, 400
 
-    # Generate contract PDF file based on the uploads metadata.
-    upload_handler.generate_upload_contract_pdf(upload_metadata)
+        return None
 
-    # Store uploaded files to disk.
-    upload_handler.store_datafiles(files, upload_metadata)
-
-    # Store metadata to database.
-    upload_handler.store_metadata_unauthenticated(upload_metadata)
-
-    # Send confirmation mail along with the contract to the submitted email address.
-    upload_handler.send_confirm_mail(upload_metadata)
-
-    return 'Uspešno ste oddali datotek(e). Št. datotek: {}'.format(len(files))
-
-
-def check_suffixes(files):
-    for key, f in files.items():
-        if key.startswith('file'):
-            suffix = f.filename.split('.')[-1]
-            if suffix not in ENABLED_FILETYPES:
-                return 'Datoteka "{}" ni pravilnega formata.'.format(f.filename)
-    return None
-
-
-def check_form(form):
-    ime = form.get('ime')
-    podjetje = form.get('podjetje')
-    naslov = form.get('naslov')
-    posta = form.get('posta')
-    email = form.get('email')
-    telefon = form.get('telefon')
-
-    if len(ime) > 100:
-        return 'Predolgo ime.'
-
-    if len(podjetje) > 100:
-        return 'Predolgo ime institucije.'
-
-    if len(email) > 100:
-        return 'Predolgi email naslov'
-    elif not re.search(REGEX_EMAIL, email):
-        return 'Email napačnega formata.'
-
-    if len(telefon) > 100:
-        return 'Predolga telefonska št.'
-
-    if len(naslov) > 100:
-        return 'Predolg  naslov.'
-
-    if len(posta) > 100:
-        return 'Predolga pošta'
-
-    return None
+    @staticmethod
+    def get_user_institution(user_id):
+        match = db.session.query(RegisteredUser).filter(RegisteredUser.id == user_id).one()
+        return match.institution
 

portal/model.py

@@ -12,22 +12,39 @@ from flask_login import UserMixin
 db = SQLAlchemy()
 
 
-# Entries for uploads to corpora, that have no authentication. E.g. "prevodi" or "gigafida".
-class UploadUnauthenticated(db.Model):
-    __tablename__ = 'upload_unauthenticated'
+# "prevodi" or "gigafida".
+class UploadRegular(db.Model):
+    __tablename__ = 'upload_regular'
     id = db.Column(db.Integer, primary_key=True)
     upload_hash = db.Column(db.String)
     timestamp = db.Column(db.DateTime, default=datetime.utcnow)
-    form_name = db.Column(db.String)
-    form_org = db.Column(db.String)
-    form_address = db.Column(db.String)
-    form_zipcode = db.Column(db.String)
-    form_email = db.Column(db.String)
+    name = db.Column(db.String)
+    org = db.Column(db.String)
+    address = db.Column(db.String)
+    zipcode = db.Column(db.String)
+    email = db.Column(db.String)
     file_contract = db.Column(db.String)
     upload_file_hashes = db.Column(sqlalchemy.types.ARRAY(db.String))
     corpus_name = db.Column(db.String)
 
 
+class UploadPredavanja(db.Model):
+    __tablename__ = 'upload_predavanja'
+    id = db.Column(db.Integer, primary_key=True)
+    upload_hash = db.Column(db.String)
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+    name = db.Column(db.String)
+    address = db.Column(db.String)
+    subject = db.Column(db.String)
+    faculty = db.Column(db.String)
+    email = db.Column(db.String)
+    phone = db.Column(db.String)
+    keywords = db.Column(db.String)
+    agree_publish = db.Column(db.Boolean)
+    file_contract = db.Column(db.String)
+    upload_file_hashes = db.Column(sqlalchemy.types.ARRAY(db.String))
+
+
 class UploadSolar(db.Model):
     __tablename__ = 'upload_solar'
     id = db.Column(db.Integer, primary_key=True)
@@ -35,13 +52,14 @@ class UploadSolar(db.Model):
     institution = db.Column(db.Integer, sqlalchemy.ForeignKey('institution.id'))
     upload_hash = db.Column(db.String)
     timestamp = db.Column(db.DateTime, default=datetime.utcnow)
-    corpus_name = db.Column(db.String)
-    form_program = db.Column(db.String)
-    form_subject = db.Column(db.String)
-    form_grade = db.Column(db.Integer)
-    form_text_type = db.Column(db.String)
-    form_school_year = db.Column(db.String)
-    form_grammar_corrections = db.Column(db.String)
+    program = db.Column(db.String)
+    subject = db.Column(db.String)
+    subject_custom = db.Column(db.String)
+    grade = db.Column(db.Integer)
+    text_type = db.Column(db.String)
+    text_type_custom = db.Column(db.String)
+    school_year = db.Column(db.String)
+    grammar_corrections = db.Column(db.String)
     upload_file_hashes = db.Column(sqlalchemy.types.ARRAY(db.String))
 
 

portal/predavanja.py

@@ -0,0 +1,123 @@
+import logging
+import traceback
+import re
+from datetime import datetime
+
+import portal.base
+from portal.base import UploadHandler, ContractCreator, REGEX_EMAIL
+from portal.model import db, UploadPredavanja
+
+
+MAXLEN_FORM = 150
+
+class UploadHandlerPredavanja(UploadHandler):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.contract_creator = ContractCreator(base_path=self.get_uploads_subdir('contracts'),
+                                                    template_path='contract/predavanja.html')
+
+    def generate_upload_contract_pdf(self, upload_metadata):
+        form_data = upload_metadata['form_data']
+
+        files_table_str = []
+        for file_name in upload_metadata['file_names']:
+            files_table_str.append('<tr><td style="text-align: center;">')
+            files_table_str.append(file_name)
+            files_table_str.append('</td></tr>')
+        files_table_str = ''.join(files_table_str)
+
+        data = {
+            'ime_priimek': form_data['ime'],
+            'files_table_str': files_table_str
+            }
+
+        self.contract_creator.create_pdf(upload_metadata['contract_file'], data)
+
+    @staticmethod
+    def store_metadata(upload_metadata):
+        timestamp = datetime.fromtimestamp(upload_metadata['timestamp'])
+        form_data = upload_metadata['form_data']
+        file_hashes = upload_metadata['file_hashes_dict']
+        sorted_f_hashes = list(file_hashes.values())
+        sorted_f_hashes.sort()
+        
+        try:
+            model_obj = UploadPredavanja(
+                    upload_hash=upload_metadata['upload_id'],
+                    timestamp=timestamp,
+                    name=form_data['ime'],
+                    address=form_data['naslov-predavanja'],
+                    subject=form_data['predmet'],
+                    faculty=form_data['fakulteta'],
+                    email=form_data['email'],
+                    phone=form_data.get('phone'),
+                    keywords=form_data['kljucne-besede'],
+                    agree_publish=True if 'kljucne-besde' in form_data else False,
+                    file_contract=upload_metadata['contract_file'],
+                    upload_file_hashes=sorted_f_hashes,
+                   )
+            db.session.add(model_obj)
+            db.session.commit()
+        except Exception:
+            traceback.print_exc()
+
+    def handle_upload(self, request):
+        err = self.check_upload_request(request)
+        if err:
+            return err, 400
+
+        err = self.check_form(request.form)
+        if err:
+            return err, 400
+
+        # Parse request.
+        upload_metadata = self.extract_upload_metadata('predavanja', request)
+
+        logging.info('Upload for "predavanja" with id "{}" supplied form data: {}'.format(
+                        upload_metadata['upload_id'], str(upload_metadata['form_data'])))
+
+        # Generate contract PDF file based on the uploads metadata.
+        self.generate_upload_contract_pdf(upload_metadata)
+
+        # Store uploaded files to disk.
+        self.store_datafiles(request.files, upload_metadata)
+
+        # Store metadata to database.
+        self.store_metadata(upload_metadata)
+
+        # Send confirmation mail along with the contract to the submitted email address.
+        self.send_confirm_mail(upload_metadata)
+
+        return 'Uspešno ste oddali datotek(e). Št. datotek: {}'.format(len(request.files))
+
+
+    @staticmethod
+    def check_form(form):
+        name = form.get('ime')
+        address = form.get('naslov-predavanja')
+        subject = form.get('predmet')
+        faculty = form.get('fakulteta')
+        email = form.get('email')
+        phone = form.get('telefon')
+        keywords = form.get('kljucne-besede')
+
+        if not name \
+                or not address \
+                or not subject \
+                or not faculty \
+                or not email \
+                or not keywords:
+            return 'Izpolnite vsa obvezna polja.'
+
+        for keyword in keywords.split():
+            if not keyword.isalpha():
+                return 'Ključna beseda "{}" ni pravilnega formata.'.format(keyword)
+
+        if not re.search(REGEX_EMAIL, email):
+            return 'Email napačnega formata.'
+
+        for key, val in form.items():
+            if len(val) > MAXLEN_FORM:
+                return 'Polje "{}" presega dolžino {} znakov.'.format(key, MAXLEN_FORM)
+

portal/regular.py

@@ -0,0 +1,130 @@
+import logging
+import re
+import traceback
+from datetime import datetime
+
+from portal.base import UploadHandler, ContractCreator, REGEX_EMAIL
+from portal.model import db, UploadRegular
+
+
+class UploadHandlerRegular(UploadHandler):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.contract_creator = ContractCreator(base_path=self.get_uploads_subdir('contracts'),
+                                                    template_path='contract/regular.html')
+
+    def generate_upload_contract_pdf(self, upload_metadata):
+        base = self.get_uploads_subdir('contracts')
+        form_data = upload_metadata['form_data']
+
+        files_table_str = []
+        for file_name in upload_metadata['file_names']:
+            files_table_str.append('<tr><td style="text-align: center;">')
+            files_table_str.append(file_name)
+            files_table_str.append('</td></tr>')
+        files_table_str = ''.join(files_table_str)
+
+        data = {
+            'ime_priimek': form_data['ime'],
+            'naslov': form_data.get('naslov', ''),
+            'posta': form_data.get('posta', ''),
+            'kontakt_narocnik': self.config['CONTRACT_CLIENT_CONTACT'],
+            'kontakt_imetnikpravic': form_data['ime'],
+            'files_table_str': files_table_str
+            }
+
+        self.contract_creator.create_pdf(upload_metadata['contract_file'], data)
+
+    @staticmethod
+    def store_metadata(upload_metadata, corpus_name):
+        timestamp = datetime.fromtimestamp(upload_metadata['timestamp'])
+        form_data = upload_metadata['form_data']
+        file_hashes = upload_metadata['file_hashes_dict']
+        sorted_f_hashes = list(file_hashes.values())
+        sorted_f_hashes.sort()
+        
+        try:
+            model_obj = UploadRegular(
+                    upload_hash=upload_metadata['upload_id'],
+                    timestamp=timestamp,
+                    name=form_data['ime'],
+                    org=form_data.get('podjetje'),
+                    address=form_data.get('naslov'),
+                    zipcode=form_data.get('posta'),
+                    email=form_data['email'],
+                    file_contract=upload_metadata['contract_file'],
+                    upload_file_hashes=sorted_f_hashes,
+                    corpus_name=corpus_name
+                   )
+
+            db.session.add(model_obj)
+            db.session.commit()
+        except Exception:
+            traceback.print_exc()
+
+ 
+    def handle_upload(self, request, corpus_name):
+        err = self.check_upload_request(request)
+        if err:
+            return err, 400
+
+        err = self.check_form(request.form)
+        if err:
+            return err, 400
+
+        # Parse request.
+        upload_metadata = self.extract_upload_metadata(corpus_name, request)
+
+        logging.info('Upload with id "{}" supplied form data: {}'.format(upload_metadata['upload_id'],
+            str(upload_metadata['form_data'])))
+
+        # Generate contract PDF file based on the uploads metadata.
+        self.generate_upload_contract_pdf(upload_metadata)
+
+        # Store uploaded files to disk.
+        self.store_datafiles(request.files, upload_metadata)
+
+        # Store metadata to database.
+        self.store_metadata(upload_metadata, corpus_name)
+
+        # Send confirmation mail along with the contract to the submitted email address.
+        self.send_confirm_mail(upload_metadata)
+
+        return 'Uspešno ste oddali datotek(e). Št. datotek: {}'.format(len(request.files))
+
+    @staticmethod
+    def check_form(form):
+        ime = form.get('ime')
+        podjetje = form.get('podjetje')
+        naslov = form.get('naslov')
+        posta = form.get('posta')
+        email = form.get('email')
+        telefon = form.get('telefon')
+
+        if not ime:
+            return 'Prazno polje za ime.'
+        if len(ime) > 100:
+            return 'Predolgo ime.'
+
+        if podjetje and len(podjetje) > 100:
+            return 'Predolgo ime institucije.'
+
+        if not email:
+            return 'Prazno polje za elektronsko pošto.'
+        if len(email) > 100:
+            return 'Predolgi email naslov'
+        elif not re.search(REGEX_EMAIL, email):
+            return 'Email napačnega formata.'
+
+        if telefon and len(telefon) > 100:
+            return 'Predolga telefonska št.'
+
+        if naslov and len(naslov) > 100:
+            return 'Predolg  naslov.'
+
+        if posta and len(posta) > 100:
+            return 'Predolga pošta'
+
+        return None
+

portal/solar.py

@@ -1,41 +1,101 @@
+import logging
+import re
+from datetime import datetime
+
 import portal.base
+from portal.base import UploadHandler
+from portal.model import UploadSolar
 
 
-def handle_upload(request, upload_handler):
-    files = request.files
-    if len(files) > upload_handler.MAX_FILES_PER_UPLOAD:
-        return 'Naložite lahko do {} datotek hkrati.'.format(upload_handler.MAX_FILES_PER_UPLOAD), 400
-    elif len(files) < 1:
-        return 'Priložena ni bila nobena datoteka.', 400
+VALID_PROGRAMS = {'OS', 'SSG', 'MGP', 'ZG', 'NPI', 'SPI', 'SSI', 'PTI'}
+VALID_SUBJECTS = {'slo', 'drug-jez', 'drug-druz', 'drug-narav', 'drug-strok', 'drug-izb'}
+VALID_TEXT_TYPES = {'esej-spis', 'prakticno', 'solski-test', 'delo-v-razredu'}
+VALID_GRAMMAR_CORRECTIONS = {'popr-ne', 'brez-popr', 'popr-da'}
 
-    err = portal.base.check_suffixes(files)
-    if err:
-        return err, 400
-
-    err = check_form(request.form)
-    if err:
-        return err, 400
-
-    # Parse request.
-    upload_metadata = upload_handler.extract_upload_metadata(corpus_name, request)
-
-    logging.info('Upload from user "{}" with upload id "{}" supplied form data: {}'.format(
-        request.user,
-        upload_metadata['upload_id'],
-        str(upload_metadata['form_data']
-    )))
-
-    # Store uploaded files to disk.
-    upload_handler.store_datafiles(files, upload_metadata)
-
-    # Store metadata to database.
-    upload_handler.store_metadata_solar(upload_metadata)
-
-    # Send confirmation mail along with the contract to the submitted email address.
-    upload_handler.send_confirm_mail(upload_metadata)
-
-    return 'Uspešno ste oddali datotek(e). Št. datotek: {}'.format(len(files))
+MAXLEN_FORM = 150
 
 
-def check_form(form):
-    pass
+class UploadHandlerSolar(UploadHandler):
+
+    @staticmethod
+    def store_metadata(upload_metadata, user_id):
+        timestamp = datetime.fromtimestamp(upload_metadata['timestamp'])
+        form_data = upload_metadata['form_data']
+        file_hashes = upload_metadata['file_hashes_dict']
+        sorted_f_hashes = list(file_hashes.values())
+        sorted_f_hashes.sort()
+
+        institution_id = UploadHandler.get_user_institution(user_id)
+
+        try:
+            model_obj = UploadSolar(
+                        upload_user = user_id,
+                        institution = institution_id,
+                        upload_hash=upload_metadata['upload_id'],
+                        timestamp=timestamp,
+                        program=form_data['program'],
+                        subject=form_data['predmet'],
+                        subject_custom=form_data['predmet-custom'],
+                        grade=form_data['letnik'],
+                        text_type=form_data['vrsta'],
+                        text_type_custom=form_data['vrsta-custom'],
+                        school_year=form_data['solsko-leto'],
+                        grammar_corrections=form_data['jezikovni-popravki'],
+                        upload_file_hashes=sorted_f_hashes
+                   )
+            db.session.add(model_obj)
+            db.session.commit()
+        except Exception:
+            traceback.print_exc()
+
+    def handle_upload(self, request, user_id):
+        err = portal.base.check_upload_request(request, self)
+        if err:
+            return err, 400
+
+        err = self.check_form(request.form)
+        if err:
+            return err, 400
+
+        # Parse request.
+        upload_metadata = self.extract_upload_metadata('solar', request)
+
+        logging.info('Upload from user "{}" with upload id "{}" supplied form data: {}'.format(
+            user_id,
+            upload_metadata['upload_id'],
+            str(upload_metadata['form_data']
+        )))
+
+        # Store uploaded files to disk.
+        self.store_datafiles(request.files, upload_metadata)
+
+        # Store to database.
+        self.store_metadata(upload_metadata, user_id)
+
+        return 'Uspešno ste oddali datotek(e). Št. datotek: {}'.format(len(request.files))
+
+    @staticmethod
+    def check_form(form):
+        program = form['program']
+        predmet = form['predmet']
+        letnik = int(form['letnik'])
+        vrsta = form['vrsta']
+        solsko_leto = form['solsko-leto']
+        jezikovni_popravki = form['jezikovni-popravki']
+
+        if program not in VALID_PROGRAMS:
+            return 'Invalid program "{}"'.format(program)
+        if predmet not in VALID_SUBJECTS:
+            return 'Invalid subject "{}"'.format(premdet)
+        if letnik < 1 or letnik > 9:
+            return 'Invalid grade: {}'.format(letnik)
+        if vrsta not in VALID_TEXT_TYPES:
+            return 'Invalid text type "{}"'.format(vrsta)
+        if not re.match('^\d{0,2}-\d{0,2}$', solsko_leto):
+            return 'Invalid school year "{}"'.format(solsko_leto)
+        if jezikovni_popravki not in VALID_GRAMMAR_CORRECTIONS:
+            return 'Invalid text type "{}"'.format(jezikovni_popravki)
+
+        for key, val in form.items():
+            if len(val) > MAXLEN_FORM:
+                return 'Value in form field "{}" exceeds max len of {}'.format(key, MAXLEN_FORM)