shnaider_code 1.1.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0f2d61075e4ea8ed4bd5251fdede22a0852304e235b35286e29162649ef9748
-  data.tar.gz: ebc0f80b93bcb4c885da7370b2c42943c2b99bfe5f67237dc1eb3918a975b2ab
+  metadata.gz: bfb1264019ef4c0bff860b6dc0b31605d178ccedefd0042673ce582fcd9aceed
+  data.tar.gz: 6c1006332c4ead83f3c96bb9511bc7207759324ad09484203ea2827aa2054424
 SHA512:
-  metadata.gz: bfaa925bb39c18ab6937f9d0d5686f58b04083bc00bc941bc0fae3de3aab27daf4367dcd989221147b4256ebd8c9b46258d5f07e602e92c44711cc963b98a797
-  data.tar.gz: 300d64689ec07620cd2f11d802c221072546a66799739e4d1749914b176e50ece0fc898405257f63b95b06ffc6b32223420a271cdd6e645be48aac805e19ecca
+  metadata.gz: 2d1cadef5921778d113af10604e9d67e398311618cc72c65aeb50860275f7158363fde04610e8bc852e3e0e3417f2fff865bfa2405d47573968c5c488fba548d
+  data.tar.gz: 273aadd1b95aaf3d1658a65217e7fdc784a84194c8b8d26c6d82aa4972107f2e0c50ef88bc6dd9745ea42abc4ffb7fe1150e161f1ee35934ce64e3f35a560458

data/lib/shnaider_code/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ShnaiderCode
-  VERSION = "1.1.5"
+  VERSION = "2.0.0"
 end

data/lib/source/attr_limited_regex_accessor.rb

@@ -0,0 +1,43 @@
+def attr_limited_regex_accessor(symbol, regex)
+    class_eval %{
+        def #{symbol}
+            @#{symbol}
+        end
+
+        def #{symbol}=(new_value)
+            if new_value != nil && new_value !~ #{regex}
+                raise "invalid #{symbol} format"
+            end
+
+            @#{symbol} = new_value
+        end
+    }
+end
+
+def attr_private_limited_regex_accessor(symbol, regex)
+    class_eval %{
+        def #{symbol}
+            @#{symbol}
+        end
+
+        private def #{symbol}=(new_value)
+            if new_value != nil && new_value !~ #{regex}
+                raise "invalid #{symbol} format"
+            end
+
+            @#{symbol} = new_value
+        end
+    }
+end
+
+def attr_private_accessor(symbol)
+    class_eval %{
+        private def #{symbol}
+            @#{symbol}
+        end
+
+        private def #{symbol}=(new_value)
+            @#{symbol} = new_value
+        end
+    }
+end

data/lib/source/controllers/create_student_controller.rb

@@ -0,0 +1,8 @@
+module McDelta
+    class CreateStudentController
+        attr_accessor :onCreate
+
+        def initialize()
+        end
+    end
+end

data/lib/source/controllers/edit_student_controller.rb

@@ -0,0 +1,10 @@
+module McDelta
+    class EditStudentController
+        attr_accessor :onCreate
+        attr_reader :edit_user_id
+
+        def initialize(student)
+            @edit_user_id = student.id
+        end
+    end
+end

data/lib/source/controllers/view_controller.rb

@@ -0,0 +1,106 @@
+require 'source/data_construct_pattern/data_construct_pattarn.rb'
+require 'source/controllers/create_student_controller.rb'
+require 'source/controllers/edit_student_controller.rb'
+require 'source/attr_limited_regex_accessor.rb'
+require 'logger'
+
+module McDelta
+    class ViewController
+        attr_private_accessor :model
+        attr_accessor :data_list
+
+        attr_accessor :selected_page
+
+        attr_accessor :on_update_data
+
+        attr_accessor :on_add_student_clicked
+        attr_accessor :on_edit_student_clicked
+
+        attr_private_accessor :logger
+
+        def initialize(model, &on_update_data)
+            self.model = model
+            self.on_update_data = on_update_data
+
+            self.selected_page = 0
+
+            self.data_list = DataListStudentShort.new(list: [], data_constructor: DefaultDataConstructPattern.new())
+            self.model.get_students(0, 10, self.data_list)
+
+            self.logger = Logger.new('controller.log')
+        end
+    end
+
+
+    # StudentsListViewDelegate
+    class ViewController 
+        def pages_count
+            (model.count / 10.0).ceil
+        end
+
+        def table_columns
+            self.data_list.get_names
+        end
+
+        def next_page
+            if self.selected_page != self.pages_count - 1
+                self.selected_page += 1
+            end
+
+            puts self.selected_page
+
+            update_table()
+        end
+
+        def last_page
+            if self.selected_page != 0
+                self.selected_page -= 1
+            end
+
+            puts self.selected_page
+
+            
+            update_table()
+        end
+
+        def update_table
+            begin
+                model.get_students(self.selected_page * 10, (self.selected_page + 1) * 10, self.data_list)
+            rescue
+                logger.error('error in db connection')
+            end
+            self.on_update_data.call()
+        end
+
+        def open_student_creation_window()
+            self.logger.info('creating student window open')
+            on_add_student_clicked.call()
+        end
+
+        def open_student_editing_window(id)
+            self.logger.info('editing student window open')
+            on_edit_student_clicked.call(id)
+        end
+
+        def remove_student(id)
+            self.logger.info("student with id #{id} deleted")
+            model.remove_student(id)
+            update_table()
+        end
+
+        def add_student(student)
+            self.logger.info("new student added")
+            model.add_student(student)
+            puts model.count
+        end
+
+        def get_student(id)
+            model.get_student(id)
+        end
+
+        def replace_student(id, student)
+            self.logger.info("student with id #{id} updated")
+            model.replace_student(id, student)
+        end
+    end
+end

data/lib/source/data_construct_pattern/data_construct_pattarn.rb

@@ -0,0 +1,25 @@
+module McDelta
+    class DataConstructPattern 
+        def execute(values, attrs)
+            raise 'Метод не реализован'
+        end
+    end
+
+    class DefaultDataConstructPattern 
+        def execute(values, attrs)
+            (0...values.size).map { |item_index|
+                [
+                    values[item_index].id,
+                    values[item_index].lastname,
+                    values[item_index].firstname,
+                    values[item_index].patronymic,
+                    values[item_index].git,
+                    values[item_index].telegram,
+                    values[item_index].phone,
+                    values[item_index].email
+                ]
+            }
+        end
+    end
+end
+

data/lib/source/data_list.rb

@@ -0,0 +1,59 @@
+module McDelta
+    module DataListObserver
+        def notify(data)
+            raise 'not implemented'
+        end
+    end
+
+    module DataListNotifier
+        attr_accessor :data_list_observers
+
+        def notify
+            raise 'not implemented'
+        end
+    end
+
+    class DataList 
+        attr_accessor :list
+        attr_private_accessor :selected_objects
+        def initialize(list:)
+            self.data_list_observers = []
+            self.list = list
+        end
+
+        def select(index)
+            selected_objects << index
+        end
+
+        def get_selected_objects
+            (0...list.size)
+                .filter { |x| selected_objects.include? x }
+        end
+
+        def get_names
+            raise "Метод не реализован"
+        end
+
+        def get_data
+            raise "Метод не реализован"
+        end
+    end
+
+    class DataList
+        include DataListNotifier
+
+        def notify
+            data_list_observers.each { |observer|
+                observer.notify(self.get_data)
+            }
+        end
+
+        def add_observer(observer)
+            self.data_list_observers << observer
+        end
+
+        def remove_observer(observer)
+            self.data_list_observers.delete(observer) 
+        end
+    end
+end

data/lib/source/data_list_student_short.rb

@@ -0,0 +1,28 @@
+require 'source/data_list.rb'
+require 'source/data_table.rb'
+
+module McDelta
+    class DataListStudentShort < DataList 
+
+        attr_private_accessor :data_constructor
+
+        def initialize(list:, data_constructor:) 
+            self.data_constructor = data_constructor
+
+            super(list: list)
+        end
+
+        def get_names
+            ["ID", "Фамилия", "Имя", "Отчество", "Гит", "Телега", "Телефон", "Почта"]
+        end
+
+        def get_data 
+            self.data_constructor.execute(list, get_names)
+        end
+
+        def list=(new_list)
+            @list = new_list
+            notify()
+        end
+    end
+end

data/lib/source/data_table.rb

@@ -0,0 +1,21 @@
+module McDelta
+    class DataTable
+        attr_private_accessor :data
+
+        def initialize(data:)
+            self.data = data
+        end
+
+        def element(row:, column:)
+            data[row][column]
+        end
+
+        def columnsCount 
+            data[0].size
+        end
+
+        def rowsCount
+            data.size
+        end
+    end
+end

data/lib/source/database/scripts/create_table.sql

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS student(
+    id INT NOT NULL auto_increment PRIMARY KEY,
+    lastname CHAR(255) NOT NULL,
+    firstname CHAR(255) NOT NULL,
+    patronymic CHAR(255) NOT NULL,
+    git CHAR(255),
+    phone CHAR(255),
+    email CHAR(255),
+    telegram CHAR(255)
+);

data/lib/source/database/scripts/fill_data.sql

@@ -0,0 +1,14 @@
+INSERT INTO student (lastname, firstname, patronymic, git, phone, email, telegram) VALUES
+ROW("Шнайдер", "Ия", "Альбертовна", "@bushmrz", NULL, NULL, NULL),
+ROW("Хахук", "Рустам", "Нальбиевич", "@deltanull", "+7-800-555-35-35", NULL, NULL),
+ROW("Гиренко", "Даниил", "Евгениевич", "@iamgirya", NULL, "iamgirya@yandex.ru", NULL),
+ROW("Худокмырлов", "Дмитрий", "Александрович", "@kitten_qz", NULL, "kittenbomba@yandex.ru", NULL),
+ROW("Шнайдер", "Александр", "Павлович", "@invisible", NULL, NULL, @invisible),
+ROW("Сайксова", "Северина", "Альбертовна", "@slowrunner3000", NULL, NULL, @slowrunner3000),
+ROW("Худокормов", "Дмитрий", "Александрович", "@kitten_qzzz", NULL, "kittenbombaz@yandex.ru", NULL),
+ROW("Шнайдер", "Ий", "Альбертович", "@shnaider", NULL, NULL, @shnaider),
+ROW("Сайксов", "Олег", "Васильевич", "@olifmus", NULL, NULL, @music3000),
+ROW("Водянов", "Андрей", "Александрович", "@ovipivo", NULL, "yandexfan@yandex.ru", NULL),
+ROW("Фейков", "Александр", "Александрович", "@fakegit", NULL, NULL, @empty),
+ROW("Сайксов", "Оливер", "Брингович", "@bmth", NULL, NULL, @olybmth),
+

data/lib/source/database/students_db.rb

@@ -0,0 +1,78 @@
+require 'mysql2'
+
+module McDelta
+
+    class StudentsDB
+        attr_private_accessor :db_connection
+
+        def initialize()
+            self.db_connection = Mysql2::Client.new(:host => "localhost", :username => "root")
+            self.db_connection.query('CREATE DATABASE IF NOT EXISTS my_db')
+            self.db_connection.query('USE my_db')
+            self.db_connection.query('DROP TABLE IF EXISTS student')
+            self.db_connection.query(File.read(File.dirname(__FILE__) + '/scripts/create_table.sql'))
+            self.fill_data()
+        end
+
+        private def fill_data()
+            db_connection.query(File.read(File.dirname(__FILE__) + '/scripts/fill_data.sql'))
+        end
+
+        def select_by_id(id)
+            db_connection.query("SELECT * FROM student WHERE id = #{id}").map { |x| x }[0]
+        end
+
+        def remove_by_id(id)
+            db_connection.query("DELETE FROM student WHERE id = #{id}")
+        end
+
+        def replace_by_id(id, student_json)
+            db_connection.query("DELETE FROM student WHERE id = #{id}")
+            db_connection.query("""
+                INSERT INTO student (id, lastname, firstname, patronymic, git, phone, email, telegram) VALUES
+                ROW(
+                    \"#{id}\",
+                    \"#{attr_or_null(student_json[:lastname])}\",
+                    \"#{attr_or_null(student_json[:firstname])}\",
+                    \"#{attr_or_null(student_json[:patronymic])}\", 
+                    \"#{attr_or_null(student_json[:git])}\", 
+                    \"#{attr_or_null(student_json[:phone])}\",
+                    \"#{attr_or_null(student_json[:email])}\",
+                    \"#{attr_or_null(student_json[:telegram])}\"
+                )
+                """)
+        end
+
+        def add_student(student_json)
+            puts student_json[:lastname]
+            db_connection.query("""
+            INSERT INTO student (lastname, firstname, patronymic, git, phone, email, telegram) VALUES
+            ROW(
+                \"#{attr_or_null(student_json[:lastname])}\",
+                \"#{attr_or_null(student_json[:firstname])}\",
+                \"#{attr_or_null(student_json[:patronymic])}\", 
+                \"#{attr_or_null(student_json[:git])}\", 
+                \"#{attr_or_null(student_json[:phone])}\",
+                \"#{attr_or_null(student_json[:email])}\",
+                \"#{attr_or_null(student_json[:telegram])}\"
+            )
+            """)
+        end
+
+        def select_students(from, to)
+            db_connection.query("SELECT * FROM student LIMIT #{from}, #{to}")
+        end
+
+        def count()
+            db_connection.query("SELECT * FROM student").count
+        end
+
+        private def attr_or_null(attr) 
+            if attr == nil
+                "NULL"
+            else
+                attr
+            end
+        end
+    end
+end

data/lib/source/database/students_list_db.rb

@@ -0,0 +1,36 @@
+require 'source/database/students_db.rb'
+
+module McDelta
+    class StudentsListDB    
+        private_class_method :new
+
+        def self.get_student(id)
+            Student.from_json(StudentsListDB.database.select_by_id(id))
+        end
+
+        def self.remove_student(id)
+            StudentsListDB.database.remove_by_id(id)
+        end
+
+        def self.replace_student(id, student)
+            StudentsListDB.database.replace_by_id(id, student.as_json)
+        end
+
+        def self.add_student(student)
+            StudentsListDB.database.add_student(student.as_json)
+        end
+
+        def self.get_students_slice(from, to)
+            StudentsListDB.database.select_students(from, to).map { |x| Student.from_json(x) }
+        end
+
+        def self.count()
+            StudentsListDB.database.count()
+        end
+
+        def self.database
+            @database ||= StudentsDB.new()
+            @database
+        end
+    end
+end

data/lib/source/student/abstract_student.rb

@@ -0,0 +1,26 @@
+module McDelta
+    class AbstractStudent
+        private_class_method :new
+        attr_accessor :lastname, :firstname, :patronymic, :id
+
+        def get_info
+            raise "method not implemented"
+        end
+
+        def fio_info
+            raise "method not implemented"
+        end
+
+        def contacts_info
+            raise "method not implemented"
+        end
+
+        def to_s
+            get_info
+        end
+
+        def as_json 
+
+        end
+    end
+end

data/lib/source/student/student.rb

@@ -0,0 +1,120 @@
+require "source/attr_limited_regex_accessor.rb"
+require "source/student/abstract_student.rb"
+
+module McDelta
+    class Student < AbstractStudent    
+        attr_limited_regex_accessor :phone, '/\d-\d{3}-\d{3}-\d{2}-\d{2}/'
+        attr_limited_regex_accessor :email, '/\w*@\w*.\w{2,3}/'
+        attr_limited_regex_accessor :telegram, '/@\w*/'
+        attr_limited_regex_accessor :git, '/@\w*/'
+
+        public_class_method :new
+
+        def initialize(
+            lastname:,
+            firstname:,
+            patronymic:,
+            params: {}
+        )
+            self.lastname = lastname
+            self.firstname = firstname
+            self.patronymic = patronymic
+            self.id = params[:id]
+
+            self.phone = params[:phone]
+            self.telegram = params[:telegram]
+            self.email = params[:email]
+            self.git = params[:git]
+
+            validate()
+        end
+
+        def self.from_json(json)
+            params = json.map { |v| 
+                [v[0].to_sym, v[1]]
+            }.filter { |v|
+                v[1] != "NULL"
+            }.to_h
+
+            Student.new(
+                lastname: json["lastname"],
+                firstname: json["firstname"],
+                patronymic: json["patronymic"],
+                params: params
+            )
+        end
+
+        def self.from_string(str)
+            params = str
+            .split(";")
+            .map { |x| x.split(":") }
+            .map { |x| [x[0].to_sym, x[1]] }
+            .to_h
+
+            if params[:fio] == nil
+                raise "invalid string representation"
+            end
+
+            fio_components = params[:fio].split(" ")
+
+            Student.new(
+                lastname: fio_components[0],
+                firstname: fio_components[1],
+                patronymic: fio_components[2],
+                params: params
+            )
+        end
+
+        def have_any_contact
+            phone != nil || telegram  != nil || email != nil || git != nil
+        end
+
+        def validate
+            if !have_any_contact 
+                raise "Not finded git or any contact"
+            end
+        end
+
+        def set_contacts(phone: nil, email: nil, git: nil, telegram: nil)
+            if phone != nil then self.phone = phone end
+            if email != nil then self.email = email end
+            if git != nil then self.git = git end
+            if telegram != nil then self.telegram = telegram end
+        end
+
+        def contacts_info
+            contacts = ""
+            if git != nil then contacts << "git:#{git};" end
+            if phone != nil then contacts << "phone:#{phone};" end
+            if email != nil then contacts << "email:#{email};" end
+            if telegram != nil then contacts << "telegram:#{telegram};" end
+            
+            contacts
+        end
+
+        def get_info
+            if id != nil
+                "id:#{id};#{fio_info};#{contacts_info}"
+            else 
+                "#{fio_info};#{contacts_info}"
+            end
+        end
+
+        def fio_info
+            "fio:#{lastname} #{firstname} #{patronymic}"
+        end
+
+        def as_json 
+            {
+                lastname: lastname,
+                firstname: firstname,
+                patronymic: patronymic,
+                id: id,
+                phone: phone,
+                email: email,
+                git: git,
+                telegram: telegram
+            }
+        end
+    end
+end

data/lib/source/student/student_short.rb

@@ -0,0 +1,59 @@
+require "source/attr_limited_regex_accessor.rb"
+require "source/student/abstract_student.rb"
+
+module McDelta
+    class StudentShort < AbstractStudent
+        attr_private_limited_regex_accessor :git, '/@\w*/'
+        attr_private_limited_regex_accessor :email, '/\w*@\w*.\w{2,3}/'
+
+        public_class_method :new
+
+        def initialize(id:, fio:, git:, email:)
+            fio_components = fio.split(" ")
+
+            self.id = id
+            self.firstname = fio_components[0]
+            self.lastname = fio_components[1]
+            self.patronymic = fio_components[2]
+
+            self.git = git
+            self.email = email
+        end
+
+        def self.from_student(student) 
+            StudentShort.new(
+                id: student.id, 
+                fio: "#{student.firstname} #{student.lastname} #{student.patronymic}",
+                git: student.git,
+                email: student.email
+            )
+        end
+
+        def self.from_string(id, info) 
+            params = info
+            .split(";")
+            .map { |x| x.split(":") }
+            .map { |x| [x[0].to_sym, x[1]] }
+            .to_h
+
+            StudentShort.new(
+                id: id, 
+                fio: params[:fio],
+                git: params[:git],
+                email: params[:email]
+            )
+        end
+
+        def fio_info
+            "fio:#{firstname} #{lastname.upcase[0]} #{patronymic.upcase[0]}"
+        end
+
+        def contacts_info
+            "git:#{git};email:#{email}"
+        end
+
+        def get_info
+            [fio_info, contacts_info].join(";")
+        end
+    end
+end