Переписан бекенд. Добавлена валидация при обновлении значений в ряду.

Удалена предыдущая версия приложения без vue.

15 files changed, 728 insertions, 107 deletions

diff --git a/day9/task5_vue/backend/core.py b/day9/task5_vue/backend/core/response_types.py
index 71c6d5a..ca3a9f2 100644
--- a/day9/task5_vue/backend/core.py
+++ b/day9/task5_vue/backend/core/response_types.py
@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 import json
 
-from backend.utils import HTTP_STATUS_CODES
+from backend.core.utils import HTTP_STATUS_CODES
 
 
 class Response(ABC):
diff --git a/day9/task5_vue/backend/core/router.py b/day9/task5_vue/backend/core/router.py
new file mode 100644
index 0000000..135b241
--- /dev/null
+++ b/day9/task5_vue/backend/core/router.py
@@ -0,0 +1,49 @@
+import re
+from backend.core.response_types import *
+from backend.core.utils import NOT_FOUND_CODE
+
+
+class ResolutionError(Exception):
+    pass
+
+
+class Route:
+    """
+    Представляет из себя класс роута. При инициализации принимает допустимые
+    методы и регулярное выражение. Содержит методы для работы роутинга.
+    Чтобы созданный путь стал обрабатываться необходимо поместить объект Route в таблицу роутера.
+    """
+
+    def __init__(self, callback, url_format, methods=None):
+        self.methods = ['GET'] if methods is None else methods
+        self.url_pattern = re.compile(url_format)
+        self.callback = callback
+
+    def resolve(self, url, method, query):
+        match = self.url_pattern.fullmatch(url)
+        if match is not None:
+            groups = match.groups()
+
+            matched = len(groups) == self.url_pattern.groups and method in self.methods
+            if not matched:
+                raise ResolutionError()
+        else:
+            raise ResolutionError()
+
+        return self.callback(query, *match.groups())
+
+
+def run(request) -> Response:
+    response = ErrorResponse(NOT_FOUND_CODE)
+
+    method, url = request['method'], request['url']
+    for route in router_table:
+        try:
+            response = route.resolve(url, method, request['query'])
+        except ResolutionError:
+            continue
+
+    return response
+
+
+router_table = []
diff --git a/day9/task5_vue/backend/server.py b/day9/task5_vue/backend/core/server.py
index 48d5946..7c284c1 100644
--- a/day9/task5_vue/backend/server.py
+++ b/day9/task5_vue/backend/core/server.py
@@ -1,8 +1,8 @@
 from http.server import HTTPServer, BaseHTTPRequestHandler
 from urllib.parse import parse_qs
 
-from backend.router import run
-from backend.utils import parse_multipart_form
+from backend.core.router import run
+from backend.core.utils import parse_multipart_form
 
 import logging
 import json
@@ -34,32 +34,24 @@ class MyHTTPRequestHandler(BaseHTTPRequestHandler):
         content_length = int(self.headers['Content-Length'])
         content_type = self.headers['Content-type']
         post_data = self.rfile.read(content_length)
+        query = {}
 
         if content_type.split(';')[0] == 'multipart/form-data':
-            files = parse_multipart_form(post_data)
-            self.finalize_request(run({
-                'url': self.path,
-                'method': 'POST',
-                'query': {'files': files}
-            }))
+            query = {'files': parse_multipart_form(post_data)}
 
         elif content_type.split(';')[0] in ['text/plain', 'application/x-www-form-urlencoded']:
-            post_data = parse_qs(post_data.decode('utf-8'))
-            for key in post_data:
-                post_data[key] = post_data[key][0]
-
-            self.finalize_request(run({
-                'url': self.path,
-                'method': 'POST',
-                'query': post_data
-            }))
+            query = parse_qs(post_data.decode('utf-8'))
+            for key in query:
+                query[key] = query[key][0]
 
         elif content_type.split(';')[0] == 'application/json':
-            self.finalize_request(run({
-                'url': self.path,
-                'method': 'POST',
-                'query': json.loads(post_data.decode('utf-8'))
-            }))
+            query = json.loads(post_data.decode('utf-8'))
+
+        self.finalize_request(run({
+            'url': self.path,
+            'method': 'POST',
+            'query': query
+        }))
 
     def finalize_request(self, response):
         self._set_response(response.status_code, response.content_type)
diff --git a/day9/task5_vue/backend/utils.py b/day9/task5_vue/backend/core/utils.py
index c1b3a04..c1b3a04 100644
--- a/day9/task5_vue/backend/utils.py
+++ b/day9/task5_vue/backend/core/utils.py
diff --git a/day9/task5_vue/backend/database.py b/day9/task5_vue/backend/database.py
deleted file mode 100644
index 5484041..0000000
--- a/day9/task5_vue/backend/database.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import MySQLdb
-from backend.config import *
-
-import logging
-
-
-def db_column_names():
-    cursor = db.cursor()
-    cursor.execute('DESCRIBE table_task1;')
-    table_structure = cursor.fetchall()
-    table_headers = [field[0] for field in table_structure]
-    return table_headers
-
-
-logger = logging.getLogger('tableApp')
-logger.info(f'Trying to connect to database "{DATABASE_NAME}@{HOST}"...')
-# В файле config.py создайте соответствующие переменные
-db = MySQLdb.connect(
-    host=HOST,
-    user=USERNAME,
-    passwd=PASSWORD,
-    db=DATABASE_NAME
-)
-logger.info('Connected')
-
-logger.info(f'Preparing table "table_task1"...')
-db.cursor().execute(
-    '''
-    CREATE TABLE IF NOT EXISTS `table_task1` (
-      `service_id` int(11) NOT NULL AUTO_INCREMENT,
-      `servtype` varchar(20) NOT NULL DEFAULT 'hosting',
-      `subtype` varchar(32) NOT NULL DEFAULT '',
-      `user_id` bigint(20) NOT NULL,
-      `referrer_user_id` bigint(20) NOT NULL,
-      `state` varchar(1) NOT NULL DEFAULT 'N',
-      `creation_date` date NOT NULL DEFAULT '0000-01-01',
-      `creation_time` time NOT NULL DEFAULT '00:00:00',
-      `creation_request_sent_date` datetime DEFAULT NULL,
-      `notified_about_expiration` smallint(6) NOT NULL DEFAULT '0',
-      PRIMARY KEY (`service_id`)
-    ) ENGINE=InnoDB AUTO_INCREMENT=35109400 DEFAULT CHARSET=utf8;
-    '''
-)
diff --git a/day9/task5_vue/backend/database/database.py b/day9/task5_vue/backend/database/database.py
new file mode 100644
index 0000000..87982cf
--- /dev/null
+++ b/day9/task5_vue/backend/database/database.py
@@ -0,0 +1,29 @@
+from backend.database.wrappers import Wrapper, MySQLWrapper
+
+import logging
+
+
+def initialize_databases(configs, schemes):
+    for config in configs:
+        if config['type'] == 'mysql':
+            logger = logging.getLogger('backendDebug')
+
+            logger.debug('Connected')
+            logger.debug(f'Trying to connect to database "{config["db_name"]}@{config["host"]}"...')
+
+            wrapper = MySQLWrapper(config['host'], config['username'], config['password'], config['db_name'])
+            wrappers[config['name']] = wrapper
+
+            cursor = wrapper.connection.cursor()
+            for scheme in schemes:
+                logger.debug(f'Preparing table "{scheme.meta["name"]}"...')
+                cursor.execute('START TRANSACTION; {} COMMIT;'.format(scheme.get_create_line()))
+                wrapper.schemes[scheme.meta['name']] = scheme
+            cursor.close()
+
+
+def get_wrapper_for(database_name) -> Wrapper:
+    return wrappers.get(database_name, None)
+
+
+wrappers = {}
diff --git a/day9/task5_vue/backend/database/field_types.py b/day9/task5_vue/backend/database/field_types.py
new file mode 100644
index 0000000..d0b2c3b
--- /dev/null
+++ b/day9/task5_vue/backend/database/field_types.py
@@ -0,0 +1,128 @@
+from abc import ABC, abstractmethod
+
+
+class Field(ABC):
+    def __init__(self, validators=None):
+        self.validators = []
+        if validators is not None:
+            self.validators.extend(validators)
+
+    def _validate_attributes(self):
+        pass
+
+    @property
+    @abstractmethod
+    def sql_line(self):
+        pass
+
+    def validate(self, value):
+        for validator in self.validators:
+            validator.validate(value, self)
+
+
+class TextField(Field):
+    def __init__(self, max_length, is_variable_length, nullable, default, validators=None):
+        super().__init__(validators)
+
+        self.max_length = max_length
+        self.is_variable_length = is_variable_length
+        self.nullable = nullable
+        self.default = default
+
+        self.data_type = str
+
+    @property
+    def sql_line(self):
+        request = [
+            ('varchar' if self.is_variable_length else 'char') + f'({self.max_length})',
+            'NULL' if self.nullable else 'NOT NULL'
+        ]
+
+        if self.default is not None or self.nullable:
+            request.append(f'DEFAULT "{self.default}"')
+
+        return ' '.join(request)
+
+
+class IntegerField(Field):
+    def __init__(self, max_length, nullable, is_auto_increment, default, validators=None):
+        super().__init__(validators)
+
+        self.max_length = max_length
+        self.nullable = nullable
+        self.is_auto_increment = is_auto_increment
+        self.default = default
+
+        self.data_type = int
+
+    @property
+    def sql_line(self):
+        request = [
+            'int' + (f'({self.max_length})' if self.max_length is not None else ''), 
+            'NULL' if self.nullable else 'NOT NULL'
+        ]
+
+        if self.default is not None:
+            request.append(f'DEFAULT "{self.default}"')
+
+        if self.is_auto_increment:
+            request.append('AUTO_INCREMENT')
+
+        return ' '.join(request)
+
+
+class DateField(Field):
+    def __init__(self, nullable, default, validators=None):
+        super().__init__(validators)
+
+        self.nullable = nullable
+        self.default = default
+
+        self.data_type = str
+
+    @property
+    def sql_line(self):
+        request = ['date', 'NULL' if self.nullable else 'NOT NULL']
+
+        if self.default is not None:
+            request.append(f'DEFAULT "{self.default}"')
+
+        return ' '.join(request)
+
+
+class TimeField(Field):
+    def __init__(self, nullable, default, validators=None):
+        super().__init__(validators)
+
+        self.nullable = nullable
+        self.default = default
+
+        self.data_type = str
+
+    @property
+    def sql_line(self):
+        request = ['time', 'NULL' if self.nullable else 'NOT NULL']
+
+        if self.default is not None:
+            request.append(f'DEFAULT "{self.default}"')
+
+        return ' '.join(request)
+
+
+class DatetimeField(Field):
+    def __init__(self, nullable, default, validators=None):
+        super().__init__(validators)
+
+        self.nullable = nullable
+        self.default = default
+
+        self.data_type = str
+
+    @property
+    def sql_line(self):
+        request = ['datetime', 'NULL' if self.nullable else 'NOT NULL']
+
+        if self.default is not None:
+            request.append(f'DEFAULT "{self.default}"')
+
+        return ' '.join(request)
diff --git a/day9/task5_vue/backend/database/scheme.py b/day9/task5_vue/backend/database/scheme.py
new file mode 100644
index 0000000..f783f79
--- /dev/null
+++ b/day9/task5_vue/backend/database/scheme.py
@@ -0,0 +1,46 @@
+from backend.database.validators import ValidationError
+
+
+class DatabaseScheme:
+    meta = {}
+    fields = {}
+
+    @classmethod
+    def get_create_line(cls) -> str:
+        fields = cls.fields
+        meta = cls.meta
+
+        lines = [f'`{name}` {field.sql_line}' for name, field in fields.items()]
+
+        if 'primary_key' in meta:
+            primary_key = ', PRIMARY KEY (`{}`)'.format(meta['primary_key'])
+        else:
+            primary_key = ''
+
+        return 'CREATE TABLE IF NOT EXISTS `{name}` (\n{fields}{primary_key}\n);'.format(
+            name=meta['name'], fields=',\n'.join(lines), primary_key=primary_key
+        )
+
+    @classmethod
+    def validate(cls, data: dict) -> dict:
+        data_fields = set(data.keys())
+        scheme_fields = set(cls.fields.keys())
+
+        defined_fields = scheme_fields & data_fields
+        not_defined_fields = scheme_fields ^ defined_fields
+
+        validation_results = {'error': False}
+        for field in not_defined_fields:
+            validation_results['error'] = True
+            validation_results[field] = 'Field is not defined'
+
+        for field in defined_fields:
+            try:
+                cls.fields[field].validate(data[field])
+            except ValidationError as e:
+                validation_results['error'] = True
+                validation_results[field] = str(e)
+            else:
+                validation_results[field] = None
+
+        return validation_results
diff --git a/day9/task5_vue/backend/database/validators.py b/day9/task5_vue/backend/database/validators.py
new file mode 100644
index 0000000..e4b7310
--- /dev/null
+++ b/day9/task5_vue/backend/database/validators.py
@@ -0,0 +1,96 @@
+from abc import ABC, abstractmethod
+import re
+
+
+class ValidationError(Exception):
+    pass
+
+
+class Validator(ABC):
+    @staticmethod
+    @abstractmethod
+    def validate(value, field_object):
+        pass
+
+
+class ValidateNull(Validator):
+    @staticmethod
+    def validate(value, field_object):
+        if value is None and not field_object.nullable:
+            raise ValidationError('Value cannot be NULL')
+
+
+class ValidateType(Validator):
+    @staticmethod
+    def validate(value, field_object):
+        if field_object.nullable and value is None:
+            return
+        if not isinstance(value, field_object.data_type):
+            raise ValidationError('Value is of wrong type')
+
+
+class ValidateLength(Validator):
+    @staticmethod
+    def validate(value, field_object):
+        if len(str(value)) > field_object.max_length:
+            raise ValidationError('Value has too many digits')
+
+
+class ValidateTime(Validator):
+    @staticmethod
+    def validate(value, field_object):
+        match = re.fullmatch(r'(\d\d):(\d\d):(\d\d)', value)
+        if not match:
+            raise ValidationError('Wrong time format')
+        else:
+            hour, minute, second = map(int, match.groups())
+            if hour not in range(0, 24):
+                raise ValidationError('Wrong hour value')
+
+            if minute not in range(0, 60):
+                raise ValidationError('Wrong minute value')
+
+            if second not in range(0, 60):
+                raise ValidationError('Wrong second value')
+
+
+class ValidateDate(Validator):
+    @staticmethod
+    def validate(value, field_object):
+        match = re.fullmatch(r'(\d\d\d\d)-(\d\d)-(\d\d)', value)
+        if not match:
+            raise ValidationError('Wrong date format')
+        else:
+            year, month, day = map(int, match.groups())
+            if year < 0:
+                raise ValidationError('Wrong year value')
+
+            if month not in range(1, 12):
+                raise ValidationError('Wrong month value')
+
+            if month == 2:
+                if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
+                    febr_range = range(1, 29)
+                else:
+                    febr_range = range(1, 28)
+                if day not in febr_range:
+                    raise ValidationError('Wrong day value')
+            else:
+                days_count = {
+                    1: 31, 3: 31, 4: 30, 5: 31,
+                    6: 30, 7: 31, 8: 31, 9: 30,
+                    10: 31, 11: 30, 12: 31
+                }.get(month)
+                if day not in range(1, days_count):
+                    raise ValidationError('Wrong day value')
+
+
+class ValidateDatetime(Validator):
+    @staticmethod
+    def validate(value, field_object):
+        datetime = value.split()
+        if len(datetime) != 2:
+            raise ValidationError('Wrong datetime format')
+        else:
+            ValidateDate.validate(datetime[0], {})
+            ValidateTime.validate(datetime[1], {})
\ No newline at end of file
diff --git a/day9/task5_vue/backend/database/wrappers.py b/day9/task5_vue/backend/database/wrappers.py
new file mode 100644
index 0000000..824d19e
--- /dev/null
+++ b/day9/task5_vue/backend/database/wrappers.py
@@ -0,0 +1,149 @@
+from abc import ABC, abstractmethod
+
+import MySQLdb
+
+
+class Wrapper(ABC):
+    def __init__(self):
+        self.schemes = {}
+
+    @abstractmethod
+    def clear_table(self, table_name):
+        pass
+
+    @abstractmethod
+    def get_column_names(self):
+        pass
+
+    @abstractmethod
+    def insert_one(self, table_name, row, field_names=None):
+        pass
+
+    @abstractmethod
+    def update(self, table_name, expressions, conditions):
+        pass
+
+    @abstractmethod
+    def delete_from(self, table_name, conditions):
+        pass
+
+    @abstractmethod
+    def get_data(self, table_name):
+        pass
+
+    @abstractmethod
+    def get_rows(self, table_name, conditions):
+        pass
+
+
+class MySQLWrapper(Wrapper):
+    def __init__(self, host, username, password, db_name):
+        super().__init__()
+        self.connection = MySQLdb.connect(
+            host=host,
+            user=username,
+            passwd=password,
+            db=db_name
+        )
+
+    def clear_table(self, table_name):
+        cursor = self.connection.cursor()
+        cursor.execute(f"START TRANSACTION; DELETE FROM `{table_name}`; COMMIT;")
+        cursor.close()
+
+    def get_column_names(self):
+        cursor = self.connection.cursor()
+        cursor.execute('DESCRIBE table_task1;')
+        table_structure = cursor.fetchall()
+        table_headers = [field[0] for field in table_structure]
+        return table_headers
+
+    def insert_one(self, table_name, row, field_names=None):
+        cursor = self.connection.cursor()
+
+        if field_names is not None:
+            field_names_formatted = []
+            for name in field_names:
+                if name != 'NULL' or not name.isnumeric():
+                    name = f'`{name}`'
+                field_names_formatted.append(name)
+            field_names_formatted = f'({",".join(field_names_formatted)})'
+        else:
+            field_names_formatted = ''
+
+        row_formatted = []
+        for value in row:
+            if value == 'NULL' or value.isnumeric():
+                row_formatted.append(value)
+            else:
+                row_formatted.append(f'"{value}"')
+
+        request = "START TRANSACTION; INSERT INTO `{}` {} VALUES ({}); COMMIT;".format(
+            table_name, field_names_formatted, ",".join(row_formatted)
+        )
+
+        print(request)
+
+        cursor.execute(request)
+        cursor.close()
+
+    def update(self, table_name, expressions, conditions):
+        cursor = self.connection.cursor()
+
+        expressions_formatted = []
+        for field_name, value in expressions.items():
+            if value != 'NULL' or not value.isnumeric():
+                value = f'"{value}"'
+            expressions_formatted.append(f'`{field_name}`={value}')
+
+        conditions_formatted = []
+        for field_name, value in conditions.items():
+            if value != 'NULL' or not value.isnumeric():
+                value = f'"{value}"'
+            conditions_formatted.append(f'`{field_name}`={value}')
+
+        cursor.execute("START TRANSACTION; UPDATE `{}` SET {} WHERE {}; COMMIT;".format(
+            table_name, ','.join(expressions_formatted), ' AND '.join(conditions_formatted)
+        ))
+
+        cursor.close()
+
+    def delete_from(self, table_name, conditions):
+        cursor = self.connection.cursor()
+
+        conditions_formatted = []
+        for field_name, value in conditions.items():
+            if value != 'NULL' or not value.isnumeric():
+                value = f'"{value}"'
+            conditions_formatted.append(f'`{field_name}`={value}')
+
+        cursor.execute("START TRANSACTION; DELETE FROM `{}` WHERE {}; COMMIT;".format(
+            table_name, ' AND '.join(conditions_formatted)
+        ))
+
+        cursor.close()
+
+    def get_data(self, table_name):
+        cursor = self.connection.cursor()
+
+        cursor.execute(f'SELECT * FROM `{table_name}`;')
+        content = list(map(list, cursor.fetchall()))
+
+        cursor.close()
+        return content
+
+    def get_rows(self, table_name, conditions):
+        cursor = self.connection.cursor()
+
+        conditions_formatted = []
+        for field_name, value in conditions.items():
+            if value != 'NULL' or not value.isnumeric():
+                value = f'"{value}"'
+            conditions_formatted.append(f'`{field_name}`={value}')
+
+        cursor.execute(f'SELECT * FROM `{table_name}` WHERE {" AND ".join(conditions_formatted)};')
+        content = list(map(list, cursor.fetchall()))
+
+        cursor.close()
+
+        return content
diff --git a/day9/task5_vue/backend/router.py b/day9/task5_vue/backend/router.py
deleted file mode 100644
index be8305e..0000000
--- a/day9/task5_vue/backend/router.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import re
-from backend.utils import NOT_FOUND_CODE, BAD_REQUEST_CODE
-from backend.core import Response, ErrorResponse
-
-
-def route(url_format, methods=None):
-    if methods is None:
-        methods = ['GET']
-
-    def wrapper(func):
-        def inner(url, query, *args, **kwargs):
-            pattern = re.compile(url_format)
-            match = re.fullmatch(pattern, url)
-
-            if match is None or len(match.groups()) != pattern.groups:
-                return ErrorResponse(BAD_REQUEST_CODE)
-
-            return func(query, *match.groups(), *args, **kwargs)
-
-        _router_tree[url_format] = _router_tree.get(url_format, {})
-        for method in methods:
-            _router_tree[url_format][method] = inner
-
-        return inner
-
-    return wrapper
-
-
-def run(request) -> Response:
-    res = ErrorResponse(NOT_FOUND_CODE)
-
-    method, url = request['method'], request['url']
-    for url_pattern in _router_tree:
-        if re.fullmatch(url_pattern, url) and method in _router_tree[url_pattern]:
-            res = _router_tree[url_pattern][method](url, request['query'])
-            break
-
-    return res
-
-
-_router_tree = {}
diff --git a/day9/task5_vue/backend/routes.py b/day9/task5_vue/backend/routes.py
new file mode 100644
index 0000000..65117c2
--- /dev/null
+++ b/day9/task5_vue/backend/routes.py
@@ -0,0 +1,15 @@
+from backend.core.router import Route, router_table
+from backend.views import *
+
+router_table.extend([
+    Route(index_get, '/'),
+    Route(return_static, r'/static/(.*?)/(.*?)/?'),
+
+    Route(upload_file, '/api/upload/?', ['POST']),
+    Route(update_post, '/api/update/?', ['POST']),
+    Route(delete_post, '/api/delete/?', ['POST']),
+    Route(add_post, '/api/add/?', ['POST']),
+    Route(db_get, '/api/get/?', ['POST']),
+
+    Route(validate, '/validate/?', ['POST']),
+])
diff --git a/day9/task5_vue/backend/schemes.py b/day9/task5_vue/backend/schemes.py
new file mode 100644
index 0000000..c0af1dd
--- /dev/null
+++ b/day9/task5_vue/backend/schemes.py
@@ -0,0 +1,23 @@
+from backend.database.field_types import *
+from backend.database.validators import *
+from backend.database.scheme import DatabaseScheme
+
+
+class Day9Table(DatabaseScheme):
+    meta = {
+        'name': 'table_task1',
+        'primary_key': 'service_id'
+    }
+
+    fields = {
+        'service_id': IntegerField(None, False, True, None, validators=[ValidateNull, ValidateType]),
+        'servtype': TextField(20, True, False, 'hosting', validators=[ValidateNull, ValidateLength, ValidateType]),
+        'subtype': TextField(32, True, False, '', validators=[ValidateNull, ValidateLength, ValidateType]),
+        'user_id': IntegerField(None, False, False, None, validators=[ValidateNull, ValidateType]),
+        'referrer_user_id': IntegerField(None, False, False, None, validators=[ValidateNull, ValidateType]),
+        'state': TextField(1, False, False, 'N', validators=[ValidateNull, ValidateLength, ValidateType]),
+        'creation_date': DateField(False, '0000-01-01', validators=[ValidateType, ValidateNull, ValidateDate]),
+        'creation_time': TimeField(False, '00:00:00', validators=[ValidateType, ValidateNull, ValidateTime]),
+        'creation_request_sent_date': DatetimeField(True, None, validators=[ValidateType, ValidateDatetime]),
+        'notified_about_expiration': IntegerField(None, False, False, 0, validators=[ValidateNull, ValidateType])
+    }
diff --git a/day9/task5_vue/backend/settings.py b/day9/task5_vue/backend/settings.py
new file mode 100644
index 0000000..2271672
--- /dev/null
+++ b/day9/task5_vue/backend/settings.py
@@ -0,0 +1,18 @@
+STATIC_FILES_PATH = 'static'
+
+SERVER_HOST = ''
+SERVER_PORT = 8000
+
+DEBUG_MODE = True
+
+DATABASES = [
+    {
+        'type': 'mysql',
+
+        'name': 'mysql',
+        'host': 'pcserv2',
+        'username': 'day9',
+        'password': 'day9',
+        'db_name': 'day9'
+    }
+]
diff --git a/day9/task5_vue/backend/views.py b/day9/task5_vue/backend/views.py
new file mode 100644
index 0000000..d6d9351
--- /dev/null
+++ b/day9/task5_vue/backend/views.py
@@ -0,0 +1,160 @@
+from backend.core.utils import render_template, NOT_FOUND_CODE
+from backend.settings import STATIC_FILES_PATH
+
+from backend.core.response_types import ErrorResponse, TextFileResponse, ImageResponse, HtmlResponse, JsonResponse
+from backend.database.database import get_wrapper_for
+
+import csv
+
+
+def return_static(query, *args):
+    if args[0] in ['css', 'js']:
+        try:
+            return TextFileResponse(
+                path=STATIC_FILES_PATH + f'/{args[0]}/{args[1]}',
+                extension={'js': 'javascript', 'css': 'css'}.get(args[0])
+            )
+
+        except (PermissionError, FileNotFoundError):
+            return ErrorResponse(404)
+
+    elif args[0] == 'images':
+        try:
+            return ImageResponse(STATIC_FILES_PATH + f'/{args[0]}/{args[1]}', args[1].split('.')[-1])
+
+        except (PermissionError, FileNotFoundError):
+            return ErrorResponse(404)
+
+
+def upload_file(query, *args):
+    base_html = '<a href="/">Return to main page</a><br>%s'
+
+    try:
+        data = query['files'][0]['data'].decode('utf-8')
+    except (UnicodeDecodeError, KeyError, IndexError):
+        return ErrorResponse(500, base_html % '<h1>Error while reading file</h1>')
+
+    wrapper = get_wrapper_for('mysql')
+
+    permitted_headers = wrapper.get_column_names()
+
+    try:
+        data = list(csv.reader(data.strip().splitlines(), delimiter=';', quotechar='"'))
+        if len(data[0]) != len(permitted_headers) or set(data[0]) != set(permitted_headers):
+            return ErrorResponse(500, base_html % '<h1>File format error</h1>')
+    except IndexError:
+        return ErrorResponse(500, base_html % '<h1>File format error</h1>')
+
+    wrapper.clear_table('table_task1')
+
+    scheme = wrapper.schemes['table_task1']
+    for row in data[1:]:
+        validation_results = scheme.validate(dict(zip(data[0], row)))
+        if not validation_results['error']:
+            wrapper.insert_one('table_task1', row, data[0])
+        else:
+            return ErrorResponse(500)
+
+    return HtmlResponse(base_html % '<h1>File uploaded</h1>')
+
+
+def validate(query, *args):
+    wrapper = get_wrapper_for('mysql')
+    scheme = wrapper.schemes['table_task1']
+    validation_results = scheme.validate(query)
+    return JsonResponse(validation_results)
+
+
+def update_post(query, *args):
+    wrapper = get_wrapper_for('mysql')
+    service_id = query['service_id']
+    permitted_fields = wrapper.get_column_names()
+    permitted_fields.remove('service_id')
+
+    query_set = []
+    for field_name, value in query.items():
+        if field_name in permitted_fields:
+            query_set.append(f'{field_name}="{value}"')
+
+    wrapper.update('table_task1', query_set, {'service_id': service_id})
+    return HtmlResponse('<a href="/">Return to main page</a><br><h1>Database Updated</h1>')
+
+
+def delete_post(query, *args):
+    get_wrapper_for('mysql').delete_from('table_task1', {'service_id': query['service_id']})
+    return HtmlResponse('<a href="/">Return to main page</a><br><h1>Database Updated</h1>')
+
+
+def add_post(query, *args):
+    wrapper = get_wrapper_for('mysql')
+    header_fields = wrapper.get_column_names()
+    headers = []
+    values = []
+    for field_name in query:
+        if field_name in header_fields:
+            headers.append(field_name)
+            values.append(f'"{query[field_name]}"')
+
+    if len(headers) == len(header_fields):
+        wrapper.insert_one('table_task1', values, headers)
+
+    return HtmlResponse('<a href="/">Return to main page</a><br><h1>Database Updated</h1>')
+
+
+def db_get(query, *args):
+    wrapper = get_wrapper_for('mysql')
+    table_headers = wrapper.get_column_names()
+
+    if query['type'] == 'full':
+        content = wrapper.get_data('table_task1')
+
+        for row in content:
+            # creation_time
+            row[7] = ':'.join(_.rjust(2, '0') for _ in str(row[7]).split(':'))
+
+            # creation_request_sent_date
+            if row[8] is not None:
+                creation_date, creation_time = str(row[8]).split()
+                creation_time = ':'.join(_.rjust(2, '0') for _ in creation_time.split(':'))
+                row[8] = creation_date + ' ' + creation_time
+
+        json_content = []
+        for row in content:
+            new_row = []
+            for col in row:
+                if not isinstance(col, (float, bool, int, dict, list, tuple, str)):
+                    col = str(col)
+                new_row.append(col)
+            json_content.append(new_row)
+
+        return JsonResponse({'headers': table_headers, 'content': json_content})
+
+    elif query['type'] == 'single_id':
+        content = wrapper.get_rows('table_task1', {'service_id': query['service_id']})[0]
+
+        # creation_time
+        content[7] = ':'.join(_.rjust(2, '0') for _ in str(content[7]).split(':'))
+
+        # creation_request_sent_date
+        if content[8] is not None:
+            creation_date, creation_time = str(content[8]).split()
+            creation_time = ':'.join(_.rjust(2, '0') for _ in creation_time.split(':'))
+            content[8] = creation_date + ' ' + creation_time
+
+        if content is not None:
+            json_content = []
+            for col in content:
+                if not isinstance(col, (float, bool, int, dict, list, tuple)):
+                    col = str(col)
+                json_content.append(col)
+
+            return JsonResponse(dict(zip(table_headers, json_content)))
+        else:
+            return JsonResponse({})
+
+    return ErrorResponse(NOT_FOUND_CODE)
+
+
+def index_get(query, *args):
+    data = render_template('index.html')
+    return HtmlResponse(data)