my_students 1.0.1

data/lib/source/models/student.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'student_short'
+
+class Student < StudentShort
+  # стандартные геттеры и сеттеры для класса
+  attr_writer :id
+  attr_reader :phone, :telegram, :email, :first_name, :paternal_name
+
+  # валидаТОР номера телефона
+  def self.valid_phone?(phone)
+    phone.match(/^\+?[7,8] ?\(?\d{3}\)?-?\d{3}-?\d{2}-?\d{2}$/)
+  end
+
+  # валидаТОР имени
+  def self.valid_name?(name)
+    name.match(/^[А-Я][а-я]+$/)
+  end
+
+  # валидаТОР профиля
+  def self.valid_account?(account)
+    account.match(/^@[A-Za-z0-9\-_]+$/)
+  end
+
+  # валидаТОР почты
+  def self.valid_email?(email)
+    email.match(/^[A-Za-z0-9\-_]+@[A-Za-z]+\.([A-Za-z]+\.)*[A-Za-z]+$/)
+  end
+
+  # стандартный конструктор
+  def initialize(last_name, first_name, paternal_name, id: nil, git: nil, phone: nil, email: nil, telegram: nil)
+    self.last_name = last_name
+    self.first_name = first_name
+    self.paternal_name = paternal_name
+    self.id = id
+    self.git = git
+    set_contacts(phone: phone, email: email, telegram: telegram)
+  end
+
+
+  # конструктор принимающий на вход хээээш
+  def self.from_hash(hash)
+    hash = hash.dup
+    raise ArgumentError, 'Missing fields: last_name, first_name, paternal_name' unless hash.key?(:first_name) && hash.key?(:last_name) && hash.key?(:paternal_name)
+
+    first_name = hash.delete(:first_name)
+    last_name = hash.delete(:last_name)
+    paternal_name = hash.delete(:paternal_name)
+
+    Student.new(last_name, first_name,  paternal_name, **hash)
+  end
+
+  def to_hash
+    attrs = {}
+    %i[last_name first_name paternal_name id phone telegram email git].each do |attr|
+      attr_val = send(attr)
+      attrs[attr] = attr_val unless attr_val.nil?
+    end
+    attrs
+  end
+
+  # конструктор из json-строки
+  def self.init_from_json(str)
+    params = JSON.parse(str, { symbolize_names: true })
+    from_hash(params)
+  end
+
+    #сеттеры
+  def phone=(phone)
+    raise ArgumentError, "Incorrect value: phone=#{phone}!" if !phone.nil? && !Student.valid_phone?(phone)
+
+    @phone = phone
+  end
+
+  def first_name=(first_name)
+    raise ArgumentError, "Incorrect value: first_name=#{first_name}!" if !first_name.nil? && !Student.valid_name?(first_name)
+
+    @first_name = first_name
+  end
+
+  def last_name=(last_name)
+    raise ArgumentError, "Incorrect value: last_name=#{last_name}" if !last_name.nil? && !Student.valid_name?(last_name)
+
+    @last_name = last_name
+  end
+
+  def paternal_name=(paternal_name)
+    raise ArgumentError, "Incorrect value: paternal_name=#{paternal_name}!" if !paternal_name.nil? && !Student.valid_name?(paternal_name)
+
+    @paternal_name = paternal_name
+  end
+
+  def git=(git)
+    raise ArgumentError, "Incorrect value: git=#{git}!" if !git.nil? && !Student.valid_account?(git)
+
+    @git = git
+  end
+
+  def telegram=(telegram)
+    raise ArgumentError, "Incorrect value: telegram=#{telegram}!" if !telegram.nil? && !Student.valid_account?(telegram)
+
+    @telegram = telegram
+  end
+
+  def email=(email)
+    raise ArgumentError, "Incorrect value: email=#{email}!" if !email.nil? && !Student.valid_email?(email)
+
+    @email = email
+  end
+
+  # метод возвращающий фамилию и инициалы у объекта
+  def last_name_and_initials
+    "#{last_name} #{first_name[0]}. #{paternal_name[0]}."
+  end
+
+  # метод возвращающий краткую инф-ю об объекте
+  def short_info
+    info = {}
+    info[:last_name_and_initials] = last_name_and_initials
+    info[:contact] = contact
+    info[:git] = git
+    JSON.generate(info)
+  end
+
+
+  def set_contacts(phone: nil, telegram: nil, email: nil)
+    self.phone = phone if phone
+    self.telegram = telegram if telegram
+    self.email = email if email
+    @contact = contact
+  end
+
+  # метод возвращающий представление объекта в виде строки
+  def to_s
+    result = "#{last_name} #{first_name} #{paternal_name}"
+    result += " id=#{id}" unless id.nil?
+    result += " phone=#{phone}" unless phone.nil?
+    result += " git=#{git}" unless git.nil?
+    result += " telegram=#{telegram}" unless telegram.nil?
+    result += " email=#{email}" unless email.nil?
+    result
+  end
+
+private
+
+# метод устанавливающий контакт
+  def contact
+    # return @contact = {phone: phone} unless phone.nil?
+    # return @contact = {telegram: telegram} unless telegram.nil?
+    # return @contact = {email: email} unless email.nil?
+    #
+    # nil
+
+    if phone
+      @contact = {type: :phone, value: phone}
+    elsif telegram
+      @contact = {type: :telegram, value: telegram}
+    elsif email
+      @contact = {type: :email, value: email}
+    end
+  end
+end

data/lib/source/models/student_short.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require 'json'
+
+class StudentShort
+  # стандартные геттеры для класса
+  attr_reader :id, :git, :contact, :last_name, :initials
+
+  # стандартный конструктор, принимающий аргументов экземпляр класса student
+  def initialize(student)
+    @id = student.id
+
+    @last_name = student.last_name
+    @initials = "#{student.first_name[0]}. #{student.paternal_name[0]}."
+    @git = student.git unless student.git.nil?
+    @contact = student.set_contacts(phone: student.phone, email: student.email, telegram: student.telegram)
+  end
+
+  # кастомный конструктор, принимающий на вход id и строку, которая содержит всю остальную инф-ю
+  def self.from_str(id, str)
+    result = JSON.parse(str)
+    raise ArgumentError, 'Missing fields: last_name, first_name, paternal_name' unless result.key?('first_name') &&
+      result.key?('last_name') && result.key?('paternal_name')
+
+    StudentShort.new(Student.new(result['last_name'],result['first_name'],result['paternal_name'],id: id,
+                                 phone: result['phone'], git: result['git'],
+                                 email: result['email'],telegram: result['telegram']))
+  end
+
+  # метод возвращающий фамилию и инициалы у объекта
+  def last_name_and_initials
+    "#{@last_name} #{@initials}"
+  end
+
+  # метод возвращающий представление объекта в виде строки
+  def to_s
+    result = last_name_and_initials
+    result += " id= #{id} " unless id.nil?
+    result += contact unless contact.nil?
+    result
+  end
+
+  # метод проверяющий наличие гита
+  def git?
+    !git.nil?
+  end
+
+  # метод проверяющий наличие контакта
+  def contact?
+    !contact.nil?
+  end
+
+  def validate
+    git? && contact?
+  end
+
+end

data/lib/source/repositories/containers/data_list.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require_relative 'data_table'
+
+class DataList
+
+  private_class_method :new
+
+  attr_writer :objects_list
+
+  def initialize(objects)
+    self.objects_list = objects
+    @observers = []
+  end
+
+  def add_observer(observer)
+    @observers.append(observer)
+  end
+
+  def remove_observer(observer)
+    @observers.delete(observer)
+  end
+  def notify
+    @observers.each { |observer| observer.on_datalist_changed(get_data) }
+  end
+
+  # добавить айди в выборку
+  def select_elem(number)
+    self.selected_object = number
+  end
+
+  def selected_id
+    objects_list[selected_object].id
+  end
+
+  # шаблон
+  def get_data
+    index_id=0
+    dt = objects_list.inject([]) do |res, object|
+      row=[index_id]
+      row.append(*table_fields(object))
+      index_id+=1
+      res<<row
+    end
+    DataTable.new(dt)
+  end
+
+
+  def replace_objects(objects)
+    self.objects_list = objects.dup
+    notify
+  end
+
+  protected
+
+  # должен быть реализован в детях
+  def get_names; end
+
+  # теперь этот метод необходимо переопределять у наследников(если я правильно понял принцип паттерна)
+  def table_fields(object)
+    []
+  end
+
+  private
+
+  attr_reader :objects_list
+  attr_accessor :selected_object
+end

data/lib/source/repositories/containers/data_list_student_short.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'data_list'
+class DataListStudentShort < DataList
+  public_class_method :new
+
+  # переопределенный метод из предка
+  def get_names
+    ["last_name_and_initials", "git", "contact"]
+  end
+
+  protected
+
+  # паблон шаттерн
+  def table_fields(object)
+    [object.last_name_and_initials, object.git, object.contact]
+  end
+end

data/lib/source/repositories/containers/data_table.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class DataTable
+
+  attr_reader :rows_count, :cols_count
+
+  def initialize(table)
+
+    self.rows_count = table.length
+    max_cols = 0
+    table.each do |row|
+      max_cols = row.length if row.size > max_cols
+    end
+    self.cols_count = max_cols
+    self.table = table
+  end
+
+  def get_item(row, col)
+    return nil if row >= rows_count || row.negative?
+    return nil if col >= cols_count || col.negative?
+
+    table[row][col]
+  end
+
+  def to_my_array
+    table.dup
+  end
+
+  def to_s
+    table.map { |row| "[#{row.join(', ')}]" }.join("\n")
+  end
+
+  private
+
+  attr_accessor :table
+  attr_writer :rows_count, :cols_count
+
+end

data/lib/source/repositories/data_sources/strategy/student_list_json.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative '../student_list_strategy'
+require 'json'
+class StudentListJSON < StudentListStrategy
+  public_class_method :new
+
+
+  def str_to_list(str)
+    JSON.parse(str, { symbolize_names: true })
+  end
+
+  def list_to_str(list)
+    JSON.generate(list)
+  end
+end

data/lib/source/repositories/data_sources/strategy/student_list_txt.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../student_list_strategy'
+require 'json'
+class StudentListTxt < StudentListStrategy
+  public_class_method :new
+
+
+  def str_to_list(str)
+    transform_to_hashes(str.split("\n").map(&:chomp))
+  end
+
+  def list_to_str(list)
+    transform_to_string(list)
+  end
+
+  private
+
+  def transform_to_hashes(list_of_strings)
+    list_of_hashes = []
+    list_of_strings.each do |string|
+      string = string.gsub('"', "")
+      hash = {}
+      string.split(',').each do |attribute|
+        key, value = attribute.split(':').map(&:strip)
+        hash[key.to_sym] = value
+      end
+      list_of_hashes << hash
+    end
+    list_of_hashes
+  end
+
+  def transform_to_string(hashes)
+    lines = hashes.map do |hash|
+      hash.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+    end
+    lines.join("\n")
+  end
+end

data/lib/source/repositories/data_sources/strategy/student_list_yaml.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../student_list_strategy'
+require 'yaml'
+
+class StudentListYaml<StudentListStrategy
+  public_class_method :new
+
+
+  def str_to_list(str)
+    YAML.safe_load(str).map { |h| h.transform_keys(&:to_sym) }
+  end
+
+  def list_to_str(hash_list)
+    hash_list.map { |h| h.transform_keys(&:to_s) }.to_yaml
+  end
+end

data/lib/source/repositories/data_sources/student_list_base.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+class StudentListBase
+
+
+  attr_writer :data_type
+
+  # конструктор
+  def initialize(data_type)
+    self.students = []
+    self.cur_id = 1
+    self.data_type = data_type
+  end
+
+  # загрузка из файла
+  def load_from_file(file_path)
+    list = data_type.str_to_list(File.read(file_path))
+    self.students = list.map { |h| Student.from_hash(h) }
+    update_cur_id
+  end
+
+  # выгрузка в файл
+  def save_to_file(file_path)
+    list = students.map(&:to_hash)
+    File.write(file_path, data_type.list_to_str(list))
+  end
+
+  # найти студента по айди
+  def student_by_id(student_id)
+    students.detect { |s| s.id == student_id }
+  end
+
+  # найти студента по фамилии и инциалам
+  def student_by_name(student_name)
+    students.filter { |s| s.last_name_and_initials == student_name }
+  end
+
+  # Получить page по счету count элементов (страница начинается с 1)
+  def k_n_student_short_list(page, n, data_list)
+    page_list = students[(page-1)*n, n].map{|st| StudentShort.new(st)}
+    return DataListStudentShort.new(page_list) if data_list.nil?
+
+    data_list.replace_objects(page_list)
+    data_list
+  end
+
+  # сортировка
+  def sorted
+    students.sort_by(&:last_name_and_initials)
+  end
+
+  # добавление студента
+  def add_student(student)
+    student.id = cur_id
+    students << student
+    self.cur_id += 1
+  end
+
+  # замена студента
+  def replace_student(student_id, student)
+    idx = students.find_index { |s| s.id == student_id }
+    students[idx] = student
+  end
+
+  # отчисление студента))
+  def remove_student(student_id)
+    students.reject! { |s| s.id == student_id }
+  end
+
+  # число студентов
+  def student_count
+    students.size
+  end
+
+
+  protected
+
+  attr_accessor :students, :cur_id
+
+  private
+
+  attr_reader :data_type
+
+  # Метод для обновлении информации в cur_id
+  def update_cur_id
+    self.cur_id = students.max_by(&:id).id.to_i + 1
+  end
+
+  # чтобы никто мне ничего не трогал в списке студентов
+
+end

data/lib/source/repositories/data_sources/student_list_strategy.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class StudentListStrategy
+  private_class_method :new
+
+  protected
+
+  # Паблон шаттерн
+  def str_to_list(str); end
+
+  def list_to_str(list); end
+end

data/lib/source/repositories/db_university.rb

@@ -0,0 +1,28 @@
+class DBUniversity
+  private_class_method :new
+  @instance_mutex = Mutex.new
+
+  def initialize
+    @client = SQLite3::Database.open '/Users/kirilltitov/RubymineProjects/ruby_labs/university.sqlite'
+    @client.results_as_hash = true
+  end
+
+  def self.instance
+    return @instance if @instance
+
+    @instance_mutex.synchronize do
+      @instance ||= new
+    end
+    @instance
+  end
+
+  def prepare_exec(statement, *params)
+    @client.prepare(statement).execute(*params)
+  end
+
+  def query(statement)
+    @client.query(statement)
+  end
+
+
+end

data/lib/source/repositories/student_list.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class StudentList
+
+  # конструктор
+  def initialize(data_adapter)
+    @data_adapter = data_adapter
+  end
+
+  # получить студента по id
+  def student_by_id(student_id)
+    @data_adapter.student_by_id(student_id)
+  end
+
+
+  #добавление студента
+  def add_student(student)
+    @data_adapter.add_student(student)
+  end
+
+  #отчисление студента
+  def remove_student(student_id)
+    @data_adapter.remove_student(student_id)
+  end
+
+  #замена студента
+  def replace_student(student_id, student)
+    @data_adapter.replace_student(student_id, student)
+  end
+
+  #подсчет количества студентов
+  def student_count
+    @data_adapter.student_count
+  end
+
+  #получение n элементов k страницы
+  def k_n_student_short_list(k,n, data_list)
+    @data_adapter.k_n_student_short_list(k,n,data_list)
+  end
+end

data/lib/source/repositories/student_list_db_adapter.rb

@@ -0,0 +1,75 @@
+require_relative 'db_university'
+require 'json'
+require 'sqlite3'
+class StudentListDbAdapter
+
+  # новый конструктор
+  def initialize
+    self.client = DBUniversity.instance
+  end
+
+  def from_array_to_hash(arr)
+    attrs = {}
+    i=0
+    %i[id last_name first_name paternal_name phone telegram email git].each do |attr|
+      attrs[attr] = arr[i] unless arr[i].nil?
+      i=i+1
+    end
+    attrs
+  end
+
+  # вернуть студента по ид
+  def student_by_id(student_id)
+    hash = client.prepare_exec('SELECT * FROM students WHERE id = ?',student_id).first
+    hash = from_array_to_hash(hash)
+    return nil if hash.nil?
+
+    Student.from_hash(hash)
+
+  end
+
+  def k_n_student_short_list(k,n, data_list=nil)
+
+    offset = (k - 1) * n
+    students = client.prepare_exec('SELECT * FROM students LIMIT ?, ?', offset, n)
+
+    slice = students.map { |h|
+      h = h.transform_keys(&:to_sym)
+      StudentShort.new(Student.from_hash(h))
+    }
+    return DataListStudentShort.new(slice) if data_list.nil?
+
+    data_list.replace_objects(slice)
+    data_list
+  end
+
+  # добавление студента
+  def add_student(student)
+    stmt = client.prepare_exec('insert into students (first_name, last_name, paternal_name, phone, telegram, email, git) VALUES (?, ?, ?, ?, ?, ?, ?)', *student_fields(student))
+  end
+
+  # отчисление студента
+  def remove_student(student_id)
+    client.prepare_exec('DELETE FROM students WHERE id = ?', student_id)
+  end
+
+  # обновление студента
+  def replace_student(student_id, student)
+    template = 'UPDATE students SET first_name=?, last_name=?, paternal_name=?, phone=?, telegram=?, email=?, git=? WHERE id=?'
+    client.prepare_exec(template, *student_fields(student), student_id)
+
+  end
+
+  def student_count
+    client.query('SELECT COUNT(id) FROM students').next[0]
+  end
+
+
+  private
+
+  attr_accessor :client
+
+  def student_fields(student)
+    [student.first_name, student.last_name,  student.paternal_name, student.phone, student.telegram, student.email, student.git]
+  end
+end