student_mvp 0.1.0

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

@@ -0,0 +1,32 @@
+require_relative '../filter_decorator.rb'
+
+class Full_name_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)
+      
+      if filtered_students.nil?
+        return []
+      end
+
+      sorted_students = filtered_students.sort_by do |student|
+        "#{student.first_name} #{student.name} #{student.patronymic}".downcase
+      end
+
+      sorted_students.reverse! if self.order == :desc
+
+      return sorted_students
+    else
+      query = super(filtering_obj)
+      "#{query} ORDER BY CONCAT(first_name, ' ', name, ' ', patronymic) #{self.order == :asc ? 'ASC' : 'DESC'}"
+    end
+  end
+
+  private
+  attr_accessor :order
+end

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

@@ -0,0 +1,35 @@
+require_relative '../filter_decorator.rb'
+
+class Git_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)
+      if filtered_students.nil?
+        return []
+      end
+
+      sorted_students = filtered_students.sort_by do |student|
+        value = student.git
+        String(value.nil? || value.empty? ? Float::INFINITY : value.downcase)
+      end
+      sorted_students.reverse! if self.order == :desc
+      sorted_students
+    else
+      query = super(filtering_obj)
+      "#{query} ORDER BY 
+          CASE 
+            WHEN git IS NULL OR git = '' THEN 1 
+            ELSE 0 
+          END, 
+          git #{self.order == :asc ? 'ASC' : 'DESC' }"
+    end
+  end
+
+  private
+  attr_accessor :order
+end

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

@@ -0,0 +1,24 @@
+require_relative '../filter_decorator.rb'
+
+class Has_not_field_filter_decorator < Filter_decorator
+  def initialize(filter, field)
+    super(filter)
+    self.field = field
+  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
+        student_value.nil? || student_value.empty?
+      end
+    else
+      query = super(filtering_obj)
+      condition = query.include?("WHERE") ? "AND" : "WHERE"
+      "#{query} #{condition} (#{field} = '' OR #{field} IS NULL)"
+    end
+  end
+
+  private
+  attr_accessor :field
+end

data/lib/models/person/person.rb

@@ -0,0 +1,72 @@
+class Person
+    attr_reader :id, :git
+
+    # checking for git availability
+    def validate_git?
+        !self.git.nil?
+    end
+
+    # validate git
+    def validate?
+        self.validate_git?
+    end
+
+    protected
+
+    # phone number validation
+    def self.valid_phone_number?(phone_number)
+        phone_number.nil? || phone_number == "" || phone_number =~ /^(?:\+7|8)[\s-]?(?:\(?\d{3}\)?[\s-]?)\d{3}[\s-]?\d{2}[\s-]?\d{2}$/
+    end
+
+    # telegram validation
+    def self.valid_telegram?(telegram)
+        telegram.nil? || telegram == "" || telegram =~ /@[a-zA-Z0-9_]{5,}$/
+    end
+
+    # git link validation
+    def self.valid_git?(git)
+        git.nil? || git == "" || git =~ %r{^https?://github\.com/[a-zA-Z0-9_\-]+$}
+    end
+
+    # email validation
+    def self.valid_email?(email)
+        email.nil? || email == "" || email =~ /^[\w+_.-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
+    end
+
+    # names validation
+    def self.valid_name?(name)
+        name =~ /^[А-ЯЁ][а-яё]{1,}(-[А-ЯЁ][а-яё]{1,})?$/
+    end
+
+    # git setter
+    def git=(git)
+        unless self.class.valid_git?(git)
+            raise ArgumentError, "Wrong git link format"
+        end
+        @git = git
+    end
+
+    # returning hash
+    def self.parse_string(string)
+        data = string.split(',')
+        hash = {}
+
+        data.each do |x|
+            pair = x.strip.split(':')
+            if pair[0] && !pair[0].strip.empty? && pair[1] then
+                hash[pair[0].strip] = pair[1].strip + (pair[2] ? ":#{pair[2].strip}" : '')
+            else
+                raise ArgumentError, "Wrong string format"
+            end
+        end
+
+        hash
+    end
+
+    def get_any_contact
+    end
+
+    def set_contacts
+    end
+
+end

data/lib/models/student/student.rb

@@ -0,0 +1,204 @@
+require_relative '../person/person.rb'
+require 'date'
+
+class Student < Person
+    include Comparable
+    attr_reader :first_name, :name, :patronymic, :telegram, :email, :phone_number, :birthdate
+    attr_writer :id
+    attr_accessor :key_type
+
+    # constructor
+    def initialize(first_name:, name:, patronymic:, birthdate:, id: nil, telegram: nil, phone_number: nil, email: nil, git: nil, key_type: :birthdate)
+        self.id = id
+        self.first_name = first_name
+        self.name = name
+        self.patronymic = patronymic
+        self.git = git
+        self.set_contacts(email: email, telegram: telegram, phone_number: phone_number)
+        self.birthdate = birthdate
+        self.key_type = key_type
+    end
+
+    # constructor_from_string
+    def self.new_from_string(string)
+        hash = self.parse_string(string)
+
+        self.new(
+            id: hash['id'].to_i,
+            first_name: hash['first_name'],
+            name: hash['name'],
+            patronymic: hash['patronymic'],
+            telegram: hash['telegram'],
+            email: hash['email'],
+            phone_number: hash['phone_number'],
+            git: hash['git'],
+            birthdate: hash['birthdate']
+        )
+    end
+
+    # constructor_from_hash
+    def self.new_from_hash(hash)
+        self.new(**hash.transform_keys(&:to_sym))
+    end
+
+    # to string
+    def to_s 
+        "#{"-------------------\nID: #{self.id}\n" unless self.id.nil?}First Name: #{ self.first_name }\nName: #{ self.name }\nPatronymic: #{ self.patronymic }\nBithdate: #{ self.birthdate }\n#{"Phone Number: #{ self.phone_number }\n" unless self.phone_number.nil?}#{"Telegram: #{ self.phone_number }\n" unless self.telegram}#{"Email: #{ self.email }\n" unless self.email.nil?}#{"Git: #{ self.git }\n" unless self.git.nil?}-------------------"
+    end
+
+    # to hash
+    def to_h
+        { id: self.id, first_name: self.first_name, name: self.name, patronymic: self.patronymic, 
+        birthdate: self.birthdate, telegram: self.telegram, email: self.email, phone_number: self.phone_number, git: self.git }
+    end
+
+    # get short info in string
+    def get_info
+        "#{get_full_name}, git: #{self.git}, #{get_any_contact}"
+    end
+
+    # get full name in string
+    def get_full_name
+        "full_name: #{self.first_name} #{self.name[0]}.#{self.patronymic[0]}."
+    end
+
+    # get any contact in string
+    def get_any_contact
+        if telegram then
+            "telegram: #{self.telegram}"
+        elsif email
+            "email: #{self.email}"
+        elsif phone_number
+            "phone_number: #{self.phone_number}"
+        else
+            "no contact provided"
+        end
+    end
+
+    # to string
+    def to_line_s
+        data = []
+        data << "first_name: #{self.first_name}"
+        data << "name: #{self.name}"
+        data << "patronymic: #{self.patronymic}"
+        data << "git: #{self.git}"
+        if self.id then
+            data << "id: #{self.id}"
+        end
+        if self.telegram then
+            data << "telegram: #{self.telegram}"
+        end
+        if self.email then
+            data << "email: #{self.email}"
+        end
+        if self.phone_number then
+            data << "phone_number: #{phone_number}"
+        end
+        data.join(', ')
+    end
+
+    # checking for contacts availability
+    def validate_contacts?
+        !self.telegram.nil? || !self.email.nil? || !self.phone_number.nil?
+    end
+
+    # validate git and contacts
+    def validate?
+        super && self.validate_contacts?
+    end
+
+    # key for binary tree
+    def key
+        case self.key_type
+        when :birthdate
+            self.birthdate
+        when :id
+            self.id
+        when :full_name
+            self.get_full_name
+        when :contacts
+            self.get_any_contact
+        when :git
+            self.git
+        when :email
+            self.email
+        when :phone_number
+            self.phone_number
+        when :telegram
+            self.telegram
+        else
+            raise ArgumentError, "Unknown key_type"
+        end
+    end
+
+    def <=>(other)
+        if self.key.nil? && other.key.nil?
+            0
+        elsif self.key.nil?
+            1
+        elsif other.key.nil?
+            -1
+        else
+            self.key <=> other.key
+        end
+    end
+
+    def self.valid_birthdate?(birthdate)
+        valid = (birthdate =~ /^\d{2}\.\d{2}\.\d{4}$/)
+        begin
+            Date.parse(birthdate)
+        rescue
+            false
+        end
+        valid
+    end
+
+    private
+
+    # birthdate setter
+    def birthdate=(birthdate)
+        @birthdate = birthdate.is_a?(String) ? Date.parse(birthdate) : birthdate
+    end
+
+    # first name setter
+    def first_name=(first_name)
+        unless self.class.valid_name?(first_name)
+            raise ArgumentError, "Wrong first name format"
+        end
+        @first_name = first_name
+    end
+
+    #name setter
+    def name=(name)
+        unless self.class.valid_name?(name)
+            raise ArgumentError, "Wrong name format"
+        end
+        @name = name
+    end
+
+    # patronymic setter
+    def patronymic=(patronymic)
+        unless self.class.valid_name?(patronymic)
+            raise ArgumentError, "Wrong patronymic format"
+        end
+        @patronymic = patronymic
+    end
+
+    # contacts setter
+    def set_contacts(contacts)
+        unless self.class.valid_phone_number?(contacts[:phone_number])
+            raise ArgumentError, "Wrong phone number format"
+        end
+        @phone_number = contacts[:phone_number]
+
+        unless self.class.valid_telegram?(contacts[:telegram])
+            raise ArgumentError, "Wrong telegram format"
+        end
+        @telegram = contacts[:telegram]
+
+        unless self.class.valid_email?(contacts[:email])
+            raise ArgumentError, "Wrong Email format"
+        end
+        @email = contacts[:email]
+    end
+end

data/lib/models/student_short/student_short.rb

@@ -0,0 +1,98 @@
+require_relative '../person/person.rb'
+
+class Student_short < Person
+    attr_reader :id, :full_name
+    private_class_method :new
+
+    def initialize(full_name:, git:, contact:, id: nil)
+        self.id = id
+        self.full_name = full_name
+        self.git = git
+        self.set_contacts(contact)
+    end
+
+    # constructor from Student object
+    def self.new_from_student_obj(student)
+        self.new(
+            id: student.id.to_i,
+            full_name: student.get_full_name.slice(11..-1),
+            git: student.git,
+            contact: student.get_any_contact
+        )
+    end
+
+    # constructor from string
+    def self.new_from_string(id, string)
+        hash = self.parse_string(string)
+        contact = ''
+        if hash['telegram'] then
+            contact = "telegram: #{hash['telegram']}"
+        elsif hash['email']
+            contact = "email: #{hash['email']}"
+        else 
+            contact = "phone_number #{hash['phone_number']}"
+        end
+        
+        self.new(
+            id: id.to_i,
+            full_name: hash['full_name'],
+            git: hash['git'],
+            contact: contact
+        )
+    end
+
+    # checking for contacts availability
+    def validate_contacts?
+        !(self.get_any_contact.nil? || self.get_any_contact == "")
+    end
+
+    # validate git and contacts
+    def validate?
+        super && self.validate_contacts?
+    end
+
+    def get_any_contact
+        @contact
+    end
+
+    private 
+    attr_writer :id
+
+    def set_contacts(contact)
+        if contact == 'no contact provided'
+            @contact = nil 
+            return
+        end
+        if contact.start_with?('telegram:') then
+            telegram = contact.slice(9..-1).strip
+            unless self.class.valid_telegram?(telegram)
+                raise ArgumentError, "Wrong telegram format"
+            end
+        elsif contact.start_with?('email:')
+            email = contact.slice(6..-1).strip
+            unless self.class.valid_email?(email)
+                raise ArgumentError, "Wrong email format"
+            end
+        elsif contact.start_with?('phone_number:')
+            phone_number = contact.slice(13..-1).strip
+            unless self.class.valid_phone_number?(phone_number)
+                raise ArgumentError, "Wrong phone number format"
+            end
+        else
+            raise ArgumentError, "Wrong contact format"
+        end
+        @contact = contact
+    end
+
+    def full_name=(full_name)
+        unless self.class.valid_name?(full_name)
+            raise ArgumentError, "Wrong name format"
+        end
+        @full_name = full_name
+    end
+
+    # full name validation
+    def self.valid_name?(name)
+        name =~ /^[А-ЯЁ][а-яё]{1,}(-[А-ЯЁ][а-яё]{1,})?\s[А-ЯЁ].\s?[А-ЯЁ].$/
+    end
+end

data/lib/models/students_list/students_list.rb

@@ -0,0 +1,32 @@
+class Students_list 
+    def initialize(adapter)
+        self.adapter = adapter
+    end
+
+    def get_student_by_id(id)
+        self.adapter.get_student_by_id(id)
+    end
+    
+    def get_k_n_student_short_list(k, n, filter = nil, data_list = nil)
+        self.adapter.get_k_n_student_short_list(k, n, filter, data_list)
+    end
+    
+    def add_student(student)
+        self.adapter.add_student(student)
+    end
+    
+    def replace_student(id, new_student)
+        self.adapter.replace_student(id, new_student)
+    end
+    
+    def delete_student(id)
+        self.adapter.delete_student(id)
+    end
+    
+    def get_student_short_count(filter = nil)
+        self.adapter.get_student_short_count(filter)
+    end
+
+    private
+    attr_accessor :adapter
+end

data/lib/models/students_list/students_list_DB.rb

@@ -0,0 +1,95 @@
+require 'mysql2'
+require_relative '../student/student.rb'
+require_relative '../student_short/student_short.rb'
+require_relative '../data_list/data_list_student_short.rb'
+require_relative '../../data_access/DB_client/DB_client.rb'
+require_relative './students_list_interface.rb'
+
+class Students_list_DB < Students_list_interface
+    def get_student_by_id(id)
+        result = DB_client.instance.query("SELECT * FROM student WHERE id = ?", [id])
+        row = result.first
+        return nil unless row
+
+        Student.new_from_hash(row)
+    end
+
+    def get_k_n_student_short_list(k, n, filter = nil, data_list = nil)
+        base_query = "SELECT * FROM student"
+        filter_query = filter ? filter.apply(base_query) : base_query
+        start = (k - 1) * n
+
+        result = DB_client.instance.query(filter_query + " LIMIT ? OFFSET ?", [n, start])
+        students_short = result.map { |row| Student_short.new_from_student_obj(Student.new_from_hash(row)) }
+        data_list ||= Data_list_student_short.new(students_short)
+        data_list.index = start + 1
+        data_list.data = students_short
+        data_list
+    end
+
+    def add_student(student)
+        query = <<-SQL
+            INSERT INTO student (first_name, name, patronymic, birthdate, telegram, email, phone_number, git)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        SQL
+
+        begin
+            DB_client.instance.query(query, [
+                student.first_name,
+                student.name,
+                student.patronymic,
+                student.birthdate,
+                student.telegram,
+                student.email,
+                student.phone_number,
+                student.git
+            ])
+        rescue Mysql2::Error => e
+            if e.message.include?('Duplicate entry')
+                raise "Student with this unique value already exists - #{e.message}"
+            else
+                raise e
+            end
+        end
+    end
+
+    def replace_student(id, new_student)
+        query = <<-SQL
+            UPDATE student
+            SET first_name = ?, name = ?, patronymic = ?, birthdate = ?, telegram = ?, email = ?, phone_number = ?, git = ?
+            WHERE id = ?
+        SQL
+        begin
+            DB_client.instance.query(query, [
+                new_student.first_name,
+                new_student.name,
+                new_student.patronymic,
+                new_student.birthdate,
+                new_student.telegram,
+                new_student.email,
+                new_student.phone_number,
+                new_student.git,
+                id
+            ])
+        rescue Mysql2::Error => e
+            if e.message.include?('Duplicate entry')
+                raise "Error: Student with this unique value already exists - #{e.message}"
+            else
+                raise e
+            end
+        end
+    end
+
+    def delete_student(id)
+        query = "DELETE FROM student WHERE id = ?"
+        DB_client.instance.query(query, [id])
+    end
+
+    def get_student_short_count(filter = nil)
+        base_query = "SELECT COUNT(*) AS count FROM student"
+        filter_query = filter ? filter.apply(base_query) : base_query
+
+        result = DB_client.instance.query(filter_query)
+        result.first['count']
+    end
+end