student_mvp 0.1.0

data/lib/data_access/DB_client/DB_client.rb

@@ -0,0 +1,26 @@
+require 'mysql2'
+
+class DB_client
+    private_class_method :new
+
+    def initialize(db_config)
+        raise 'Database configuration is required' unless db_config
+        self.client = Mysql2::Client.new(db_config)
+    end
+
+    def self.instance(db_config = nil)
+        @instance ||= new(db_config)
+    end
+
+    def query(query, params=[])
+        self.client.prepare(query).execute(*params)
+    end
+
+    def close
+        self.client.close
+    end
+
+    private
+    attr_accessor :client
+    @instance = nil
+end

data/lib/deep_dup/deep_dup.rb

@@ -0,0 +1,14 @@
+module Deep_dup
+    # deep copy
+    def deep_dup(element)
+        if element.is_a?(Array)
+            element.map { |sub_element| deep_dup(sub_element) }
+        else
+            begin
+                element.dup
+            rescue
+                element
+            end
+        end
+    end
+end

data/lib/logger/logger.rb

@@ -0,0 +1,64 @@
+require 'logger'
+
+class App_logger
+  LOG_FILE_PATH = File.expand_path('../../log/app.log', __FILE__)
+  private_class_method :new
+
+  def initialize
+    ensure_log_directory
+    self.logger = Logger.new(LOG_FILE_PATH)
+    self.logger.formatter = proc do |severity, datetime, progname, msg|
+      "[#{datetime}] #{severity}: #{msg}\n"
+    end
+    setup_log_level
+  end
+
+  def self.instance
+    @instance ||= new
+  end
+
+  def log(severity, message)
+    self.logger.send(severity, message)
+  end
+
+  def info(message)
+    log(:info, message)
+  end
+
+  def debug(message)
+    log(:debug, message)
+  end
+
+  def error(message)
+    log(:error, message)
+  end
+
+  def warn(message)
+    log(:warn, message)
+  end
+
+  def fatal(message)
+    log(:fatal, message)
+  end
+
+  private
+  attr_accessor :logger
+
+  def ensure_log_directory
+    log_directory = File.dirname(LOG_FILE_PATH)
+    Dir.mkdir(log_directory) unless Dir.exist?(log_directory)
+  end
+
+  def setup_log_level
+    log_mode = ENV['LOG_MODE'] || 'hybrid'
+
+    case log_mode.downcase
+    when 'all'
+      self.logger.level = Logger::DEBUG
+    when 'errors'
+      self.logger.level = Logger::ERROR
+    when 'hybrid'
+      self.logger.level = Logger::INFO
+    end
+  end
+end

data/lib/models/binary_tree/binary_tree.rb

@@ -0,0 +1,163 @@
+require_relative './binary_tree_iterator.rb'
+
+class Binary_tree
+    include Enumerable
+
+    RED = true
+    BLACK = false
+
+    class Node
+        attr_accessor :value, :left, :right, :color, :parent
+
+        def initialize(value, color = RED)
+            self.value = value
+            self.left = nil
+            self.right = nil
+            self.color = color
+            self.parent = nil
+        end
+    end
+
+    attr_accessor :root
+
+    def initialize
+        self.root = nil
+    end
+
+    def add(value)
+        new_node = Node.new(value)
+        self.root = insert(self.root, new_node)
+        self.balance(new_node)
+    end
+
+    def each(&block)
+        iterator = Binary_tree_iterator.new(self.root)
+        iterator.each(&block)
+    end
+
+    def find(key)
+        result = nil
+        self.each do |value|
+            if value.key == key
+                result = value
+                break
+            end
+        end
+        result
+    end
+
+    private
+    def insert(root, node)
+        if root.nil?
+            return node
+        elsif node.value < root.value
+            root.left = insert(root.left, node)
+            root.left.parent = root
+        else
+            root.right = insert(root.right, node)
+            root.right.parent = root
+        end
+        root
+    end
+
+    # метод для балансировки узла
+    def balance(node)
+        while node != self.root && node.parent.color == RED
+            if node.parent == node.parent.parent.left
+                balance_with_uncle_on_left(node)
+            else
+                balance_with_uncle_on_right(node)
+            end
+        end
+        self.root.color = BLACK
+    end
+
+    # балансировка, когда дядя находится слева
+    def balance_with_uncle_on_left(node)
+        uncle = node.parent.parent.right
+
+        if uncle&.color == RED  # дядя красный
+            recolor(node)
+            node = node.parent.parent  # дед
+        else
+            if node == node.parent.right  # правый узел
+                node = node.parent  # поворот влево
+                left_rotate(node)
+            end
+            rotate_and_recolor(node)  # поворот вправо и перекраска
+        end
+    end
+
+    # балансировка, когда дядя находится справа
+    def balance_with_uncle_on_right(node)
+        uncle = node.parent.parent.left
+
+        if uncle&.color == RED  # дядя красный
+            recolor(node)
+            node = node.parent.parent  # дед
+        else
+            if node == node.parent.left  # левый узел
+                node = node.parent  # поворот вправо
+                right_rotate(node)
+            end
+            rotate_and_recolor(node)  # поворот вправо и перекраска
+        end
+    end
+
+    # перекраска дяди и деда
+    def recolor(node)
+        node.parent.color = BLACK  # родителя в черный
+        node.parent.parent.color = RED  # деда в красный
+        uncle = node.parent.parent.right 
+        uncle.color = BLACK if uncle  # дядю в черный
+    end
+
+    # поворачиваем узел вправо и перекрашиваем
+    def rotate_and_recolor(node)
+        node.parent.color = BLACK  # родителя в черный
+        node.parent.parent.color = RED  # деда в красный
+        right_rotate(node.parent.parent)  # поворот деда вправо
+    end
+
+    # левое вращение
+    def left_rotate(node)
+        right_child = node.right
+        return if right_child.nil?
+
+        node.right = right_child.left
+        right_child.left.parent = node if right_child.left
+        right_child.parent = node.parent
+
+        if node.parent.nil?
+            self.root = right_child
+        elsif node == node.parent.left
+            node.parent.left = right_child
+        else
+            node.parent.right = right_child
+        end
+
+        right_child.left = node
+        node.parent = right_child
+    end
+
+    # правое вращение
+    def right_rotate(node)
+        left_child = node.left
+        return if left_child.nil?
+
+        node.left = left_child.right
+        left_child.right.parent = node if left_child.right
+        left_child.parent = node.parent
+
+        if node.parent.nil?
+            self.root = left_child
+        elsif node == node.parent.left
+            node.parent.left = left_child
+        else
+            node.parent.right = left_child
+        end
+
+        left_child.right = node
+        node.parent = left_child
+    end
+end

data/lib/models/binary_tree/binary_tree_iterator.rb

@@ -0,0 +1,36 @@
+class Binary_tree_iterator
+    include Enumerable
+
+    attr_reader :root
+
+    def initialize(root)
+        self.root = root
+    end
+
+    def each(&block)
+        self.enumerator.each(&block)
+    end
+
+    private
+    attr_writer :root
+
+    def enumerator
+        Enumerator.new do |yielder|
+            stack = []
+            push_left_branch(yielder, self.root, stack)
+        end
+    end
+
+    def push_left_branch(yielder, node, stack)
+        while node
+            yielder << node.value
+            stack.push(node)
+            node = node.left
+        end
+
+        until stack.empty?
+            current = stack.pop
+            push_left_branch(yielder, current.right, stack)
+        end
+    end
+end

data/lib/models/data_list/data_list.rb

@@ -0,0 +1,97 @@
+require_relative '../../deep_dup/deep_dup.rb'
+
+class Data_list
+    include Deep_dup
+
+    attr_accessor :index, :count
+
+    # constructor
+    def initialize(elements)
+        self.data = elements
+        self.selected = []
+        self.index = 1
+        self.observers = []
+    end
+
+    # select element id by number
+    def select(number)
+        raise IndexError, "Index out of bounds" unless self.valid_index?(number)
+        self.selected << number unless self.selected.include?(number)
+    end
+
+    # get selected ids
+    def get_selected
+        ids = []
+        self.selected.each do |key|
+            ids << self.data[key].id
+        end
+        ids
+    end
+
+    # deselect
+    def deselect(number)
+        self.selected.delete(number) if self.selected.include?(number)
+    end
+
+    # clear selected
+    def clear_selected
+        self.selected = []
+    end
+
+    # pattern-method
+    def retrieve_data()
+        result = []
+        result << self.get_names
+        result.concat(self.get_data)
+        Data_table.new(result)
+    end
+
+    # get names (abstract)
+    def get_names
+        raise NotImplementedError, "Not implemented"
+    end
+
+    # get_data
+    def get_data()
+        result = []
+        self.data.each do |key, value|
+            row = build_row(key, value)
+            result.append(row)
+        end
+        result
+    end
+
+    # data setter
+    def data=(data)
+        @data = {}
+        data.each do |element|
+            @data[index] = deep_dup(element)
+            self.index += 1
+        end
+    end
+
+    def notify
+        observers.each do |observer|
+            observer.set_table_params(self.get_names, self.count)
+            observer.set_table_data(self.retrieve_data)
+        end
+    end
+
+    def add_observer(observer)
+        self.observers << observer
+    end
+
+    protected
+    attr_reader :data
+    attr_accessor :selected, :observers
+
+    # validate index
+    def valid_index?(index)
+        self.data.key?(index)
+    end
+
+    # build row method (abstract)
+    def build_row(index, obj)
+        raise NotImplementedError, "Not implemented"
+    end
+end

data/lib/models/data_list/data_list_student_short.rb

@@ -0,0 +1,16 @@
+require_relative '../data_list/data_list.rb'
+require_relative '../data_table/data_table.rb'
+
+class Data_list_student_short < Data_list
+    # get_names for student short
+    def get_names
+        ["№", "full name", "git", "contact"]
+    end
+
+    private
+
+    # build row for student short
+    def build_row(index, obj)
+        [index, obj.full_name, obj.git, obj.get_any_contact]
+    end
+end

data/lib/models/data_storage_strategy/JSON_storage_strategy.rb

@@ -0,0 +1,20 @@
+require 'json'
+require_relative '../student/student.rb'
+require_relative './data_storage_strategy.rb'
+
+class JSON_storage_strategy < Data_storage_strategy
+    # read from json file
+    def read(file_path)
+        return [] unless File.exist?(file_path)
+        data = JSON.parse(File.read(file_path), symbolize_names: true) rescue []
+        data.map do |data|
+            Student.new(**data)
+        end
+    end
+
+    # read to json file
+    def write(file_path, students)
+        data = students.map { |student| student.to_h }
+        File.write(file_path, JSON.pretty_generate(data))
+    end
+end

data/lib/models/data_storage_strategy/YAML_storage_strategy.rb

@@ -0,0 +1,20 @@
+require 'yaml'
+require_relative '../student/student.rb'
+require_relative './data_storage_strategy.rb'
+
+class YAML_storage_strategy < Data_storage_strategy
+    # read from yaml file
+    def read(file_path)
+        return [] unless File.exist?(file_path)
+        data = YAML.safe_load(File.read(file_path), permitted_classes: [Date, Symbol]) || []
+        data.map do |student| 
+            Student.new_from_hash(student) 
+        end
+    end
+
+    # read to yaml file
+    def write(file_path, students)
+        data = students.map { |student| student.to_h }
+        File.write(file_path, data.to_yaml)
+    end
+end

data/lib/models/data_storage_strategy/data_storage_strategy.rb

@@ -0,0 +1,11 @@
+class Data_storage_strategy
+    # read from file
+    def read(file_path)
+        raise NotImplementedError, 'Not implemented'
+    end
+
+    # write to file
+    def write(file_path, students)
+        raise NotImplementedError, 'Not implemented'
+    end
+end

data/lib/models/data_table/data_table.rb

@@ -0,0 +1,52 @@
+require_relative '../../deep_dup/deep_dup.rb'
+
+class Data_table
+    include Deep_dup
+
+    # constructor
+    def initialize(data)
+        self.data = data
+    end
+
+    # row count
+    def row_count
+        self.data.size
+    end
+
+    # column count
+    def col_count
+        if self.data.empty?
+            return 0
+        end
+        self.data[0].size
+    end
+
+    # get element
+    def get(row, col)
+        raise IndexError, "Row out of bounds" unless self.valid_row?(row)
+        raise IndexError, "Column out of bounds" unless self.valid_col?(col)
+        self.deep_dup(self.data[row][col])
+    end
+
+    private
+    attr_reader :data
+
+    # data setter
+    def data=(data)
+        unless data.is_a?(Array) && data.all? {|row| row.is_a?(Array)}
+            raise ArgumentError, "Data must be a two-dimensional array"
+        end
+
+        @data = data.map{ |row| row.map { |element| deep_dup(element) }}
+    end
+
+    # row validation
+    def valid_row?(row)
+        row.between?(0, self.row_count - 1)
+    end
+
+    # column validation
+    def valid_col?(col)
+        col.between?(0, self.col_count - 1)
+    end
+end

data/lib/models/filter/filter.rb

@@ -0,0 +1,5 @@
+class Filter
+    def apply(filtering_obj)
+        filtering_obj
+    end
+end

data/lib/models/filter/filter_decorator.rb

@@ -0,0 +1,14 @@
+require_relative './filter.rb'
+
+class Filter_decorator < Filter
+    def initialize(filter)
+        self.filter = filter
+    end
+
+    def apply(filtering_obj)
+        self.filter.apply(filtering_obj)
+    end
+
+    protected
+    attr_accessor :filter
+end

data/lib/models/filter/sort_decorator.rb

@@ -0,0 +1,15 @@
+require_relative './filter_decorator.rb'
+
+class Sort_decorator < Filter_decorator
+  def initialize(filter, order)
+    super(filter)
+    self.order = order
+  end
+
+  def apply(filtering_obj)
+    raise NotImplementedError
+  end
+  
+  protected
+  attr_accessor :order
+end

data/lib/models/filter/student_filters/contact_sort_decorator.rb

@@ -0,0 +1,50 @@
+require_relative '../filter_decorator.rb'
+
+class Contact_sort_decorator < Filter_decorator
+  def initialize(filter, order)
+    super(filter)
+    self.order = order
+  end
+
+  def apply(filtering_obj)
+    if filtering_obj.is_a?(Array)
+      filtered_students = super(filtering_obj)
+      return [] if filtered_students.nil?
+
+      sorted_students = filtered_students.sort_by do |student|
+        self.get_priority(student)
+      end
+      sorted_students.reverse! if self.order == :desc
+      sorted_students
+    else
+      query = super(filtering_obj)
+      "#{query} ORDER BY 
+        CASE
+          WHEN telegram IS NOT NULL AND telegram != '' THEN 1
+          WHEN email IS NOT NULL AND email != '' THEN 2
+          WHEN phone_number IS NOT NULL AND phone_number != '' THEN 3
+          ELSE 4
+        END #{self.order_clause}
+      "
+    end
+  end
+
+  private
+  attr_accessor :order
+
+  def order_clause
+    self.order == :asc ? 'ASC' : 'DESC'
+  end
+
+  def get_priority(student)
+    if student.telegram && !student.telegram.empty?
+      1
+    elsif student.email && !student.email.empty?
+      2
+    elsif student.phone_number && !student.phone_number.empty?
+      3
+    else
+      4
+    end
+  end
+end

data/lib/models/filter/student_filters/field_filter_decorator.rb

@@ -0,0 +1,34 @@
+require_relative '../filter_decorator.rb'
+
+class Field_filter_decorator < Filter_decorator
+  def initialize(filter, field, value)
+    super(filter)
+    self.field = field
+    self.value = value.strip.downcase
+  end
+
+  def apply(filtering_obj)
+    if filtering_obj.is_a?(Array)
+      super(filtering_obj).select do |student|
+        student_value = student.send(self.field).to_s.downcase
+        if self.value.nil? || self.value.empty?
+          !student_value.nil? && !student_value.empty?
+        else
+          student_value.include?(self.value)
+        end
+      end
+    else
+      query = super(filtering_obj)
+      condition = query.include?("WHERE") ? "AND" : "WHERE"
+      if self.value.nil? || self.value.empty?
+        "#{query} #{condition} (#{self.field} IS NOT NULL AND #{self.field} != '')"
+      else
+        "#{query} #{condition} #{self.field} LIKE '%#{self.value}%'"
+      end
+      
+    end
+  end
+
+  private
+  attr_accessor :field, :value
+end

data/lib/models/filter/student_filters/full_name_filter_decorator.rb

@@ -0,0 +1,26 @@
+require_relative '../filter_decorator.rb'
+
+class Full_name_filter_decorator < Filter_decorator
+  def initialize(filter, full_name)
+    super(filter)
+      self.full_name = full_name.strip.downcase unless full_name.nil?
+  end
+
+  def apply(filtering_obj)
+    return super(filtering_obj) if self.full_name.nil? || self.full_name.empty?
+
+    if filtering_obj.is_a?(Array)
+      super(filtering_obj).select do |student| 
+        initials = "#{student.get_full_name}"
+        initials.downcase.include?(self.full_name)
+      end
+    else
+      query = super(filtering_obj)
+      condition = query.include?("WHERE") ? "AND" : "WHERE"
+      "#{query} #{condition} CONCAT(LOWER(first_name), ' ', LOWER(LEFT(name, 1)), '.', LOWER(LEFT(patronymic, 1)), '.') LIKE '%#{self.full_name}%'"
+    end
+  end
+
+  private
+  attr_accessor :full_name
+end