task.rb

# require 'faker' #if you want to test code with random-generated tasks
require 'sqlite3'
require 'date'
require_relative 'service/priority_algorithm'
require 'fileutils'

FileUtils::mkdir_p(Dir.home + '/.taskki')
DB = SQLite3::Database.new(Dir.home + '/.taskki/tasks.db')


class Task
  attr_reader :title, :takes, :reoccur, :interval
  attr_accessor :id, :due, :score, :numbering, :done, :top_priority
  def initialize(infos = {})
    Task.create_db
    @id = infos['id']
    @title = infos['title'] || infos[:title]
    # default should be today
    @due = infos['due']
    @takes = infos['takes'] || 0
    @top_priority = (infos['top_priority'] == 1 ? true : false) || false
    @reoccur = (infos['reoccur'] == 1 ? true : false) || false
    @interval = infos['interval'] || 0
    @done = (infos['done'] == 1 ? true : false) || false
  end

  def self.today
    return Task.all.today
  end

  def self.week
    return Task.all.week
  end

  def self.longterm
    return Task.all.longterm
  end

  def self.done_list
    return Task.all.done
  end

  def self.all
    DB.results_as_hash = true
    result = DB.execute("SELECT * FROM tasks")
    instance_arr = []
    result.each do |infos|
      instance_arr << Task.new(infos)
    end
    algo = PriorityAlgorithm.new(instance_arr)
    return algo
  end

  def add
    if @due
      @due = Date.parse(@due).to_s
    else
      due_date = Date.today
      if @takes
        @due = (due_date + @takes).to_s
      else
        @due = due_date.to_s
      end
    end
    save
  end

  def self.find(id)
    DB.results_as_hash = true
    result = DB.execute("SELECT * from tasks WHERE id = ?", id).first
    return Task.new(result)
  end

  def edit_title(value)
    @title = value
    save
  end

  def edit_due(value)
    @due = Date.parse(value).to_s
    save
  end

  def edit_takes(value)
    @takes = value
    save
  end

  def edit_top_priority
    @top_priority = !@top_priority
    puts "Top priority toggled"
    puts ""
    save
  end

  def edit_repeat(value)
    @reoccur = true
    @interval = value
    save
  end

  def self.done(task)
    if task.reoccur
      intv = task.interval
      new_due = (Date.today + intv).to_s
      task.due = new_due
      puts "Reoccurring task: every #{intv} days, NEW due: #{new_due}"
      if task.top_priority
        puts "keep top_priority? [y/n]"
        task.top_priority = STDIN.gets.chomp == 'y'
      end
    else
      task.done = true
      task.top_priority = false
    end
    task.save
  end
  
  def self.revive(id)
    task = Task.find(id)
    task.done = false
    task.save
  end

  def save
    @id ? update : insert
  end

  def destroy
    DB.execute("DELETE FROM tasks WHERE id = #{@id}")
  end

  def self.create_db
    st = "
    CREATE TABLE IF NOT EXISTS`tasks` (
    `id`  INTEGER PRIMARY KEY AUTOINCREMENT,
    `title` TEXT,
    `due` TEXT,
    `takes`  INTEGER,
    `top_priority` BOOLEAN,
    `reoccur` BOOLEAN,
    `interval` INTEGER,
    `done` BOOLEAN
    );"
    DB.execute(st)
  end

  private

  def insert
    pr = @top_priority ? 1 : 0
    ro = @reoccur ? 1 : 0
    dn = @done ? 1 : 0
    st = "
    INSERT INTO tasks (title, due, takes, top_priority, reoccur, interval, done)
    VALUES (?, ?, ?, ?, ?, ?, ?) 
    "
    DB.execute(st, self.title, self.due, self.takes, pr, ro, self.interval, dn)
    self.id = DB.last_insert_row_id
  end

  def update
    pr = @top_priority ? 1 : 0
    ro = @reoccur ? 1 : 0
    dn = @done ? 1 : 0
    st = "
    UPDATE tasks
    SET title = ?, due = ?, takes = ?, top_priority = ?, reoccur =?,
    interval = ?, done = ?
    WHERE id = #{@id}
    "
    DB.execute(st, self.title, self.due, self.takes, pr, ro, self.interval, dn)
  end
  
  # def self.seed
  #   puts 'Creating 30 fake tasks...'
  #   30.times do
  #     task = Task.new(
  #     title: Faker::Lorem.sentence,
  #     due: Faker::Date.forward(100).to_s,
  #     takes: (0..5).to_a.sample,
  #     top_priority: [true, false].sample,
  #     reoccur: [true, false].sample
  #     )
  #     task.save
  #   end
  #   puts 'Finished!'
  # end
end