trackington 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 835a6b6162d41dd5040a9a3992a7ee3598ab7426
+  data.tar.gz: 828145201ee43eb13a64dedfd2bb7b924fdceb6c
+SHA512:
+  metadata.gz: bdfa7f6ca8d9b34bd37c01b6f74d7556062188a457fb7421d1cb0e9aa9be9d3a3db8942ebda2b9a7387417f7c0ba33b5eae85624dd56aee2b1ee423d7564f22d
+  data.tar.gz: 7dc50add501044e7e0fbc1c9686a98d99dbf9942d6fee963c4653456d6dcc266835d2780e30f163ece5be26826f2e2519d39edc90ec1d3ca2cf975e0b2546e7b

data/lib/trackington.rb

@@ -0,0 +1,12 @@
+require_relative 'trackington/app/core'
+require_relative 'trackington/app/projects'
+require_relative 'trackington/app/sprints'
+require_relative 'trackington/app/tasks'
+require_relative 'trackington/app/users'
+
+require_relative 'trackington/db/models/credential'
+require_relative 'trackington/db/models/project'
+require_relative 'trackington/db/models/project_role'
+require_relative 'trackington/db/models/sprint'
+require_relative 'trackington/db/models/task'
+require_relative 'trackington/db/models/user'

data/lib/trackington/app/core.rb

@@ -0,0 +1,33 @@
+require 'active_record'
+require 'yaml'
+
+require_relative 'users'
+require_relative 'projects'
+
+module Trackington
+  class Application
+    attr_reader :users, :projects
+
+    def initialize(connection_config = nil)
+      @users = UserRepository.new
+      @projects = ProjectRepository.new
+
+      establish_connection(connection_config)
+    end
+
+    private
+
+    def establish_connection(config)
+      if config.nil?
+        config_path = File.expand_path('../../db/config.yml', __FILE__)
+        config = YAML.load(IO.read(config_path))
+
+        env = ENV['DB'] || 'development'
+
+        ActiveRecord::Base.establish_connection(config[env])
+      else
+        ActiveRecord::Base.establish_connection(config)
+      end
+    end
+  end
+end

data/lib/trackington/app/projects.rb

@@ -0,0 +1,175 @@
+require_relative 'sprints'
+
+module Trackington
+  class ProjectRepository
+    def create(user_id, project_information)
+      project = Models::Project.new(project_information)
+      project.save
+
+      project_role = Models::ProjectRole.new(user_id: user_id,
+                                             project_id: project.id,
+                                             role_type: :owner)
+      project_role.save
+
+      sprint = Models::Sprint.new(project_id: project.id, is_backlog: true)
+      sprint.save
+
+      project.id
+    end
+
+    def get(project_id)
+      db_project = Models::Project.find(project_id)
+
+      Project.new(db_project.id,
+                  db_project.title,
+                  db_project.description,
+                  db_project.public)
+    end
+
+    def all(user_id)
+      get_projects(user_id: user_id)
+    end
+
+    def public
+      get_projects(public: true)
+    end
+
+    private
+
+    def get_projects(params)
+      project_ids = Models::ProjectRole
+                    .where(params)
+                    .select(:project_id)
+                    .map(&:project_id)
+
+      Models::Project.find(project_ids).map do |db_project|
+        Project.new(db_project.id, db_project.title, db_project.description,
+                    db_project.public)
+      end
+    end
+  end
+
+  class Project
+    attr_reader :id, :title, :description, :public, :sprints
+
+    def initialize(id, title, description, public)
+      @id = id
+      @title = title
+      @description = description
+      @public = public
+      @sprints = SprintRepository.new(@id)
+    end
+
+    def add_user(project_user, user_to_add, type = nil)
+      check_user_role(project_user, 'owner')
+
+      type ||= 'contributor'
+
+      existing = Models::ProjectRole.where(user_id: user_to_add,
+                                           project_id: @id).first
+
+      return unless existing.nil?
+
+      new_role = Models::ProjectRole.new(user_id: user_to_add,
+                                         project_id: @id,
+                                         role_type: type)
+
+      new_role.save
+    end
+
+    def remove_user(project_user, user_to_remove)
+      check_user_role(project_user, 'owner')
+
+      Models::ProjectRole.destroy_all(project_id: @id,
+                                      user_id: user_to_remove)
+
+      nil
+    end
+
+    def update_user(project_user, user, new_type)
+      check_user_role(project_user, 'owner')
+
+      role = Models::ProjectRole.where(project_id: @id, user_id: user).first
+
+      role.role_type = new_type
+
+      role.save
+    end
+
+    def update(project_user, data)
+      check_user_role(project_user, 'owner')
+
+      @title = data[:title]
+      @description = data[:description]
+      @public = data[:public]
+
+      db_project = Models::Project.find(@id)
+      db_project.title = @title
+      db_project.description = @description
+      db_project.public = @public
+      db_project.save
+    end
+
+    def current_sprint(project_user)
+      check_user_role project_user
+
+      @sprints.current
+    end
+
+    def create_sprint(project_user, data)
+      check_user_role(project_user, 'owner')
+
+      @sprints.create(data)
+    end
+
+    def start_sprint(project_user)
+      check_user_role(project_user, 'owner')
+
+      @sprints.start_sprint
+    end
+
+    def complete_sprint(project_user)
+      check_user_role(project_user, 'owner')
+
+      @sprints.complete_sprint
+    end
+
+    def backlog(project_user)
+      check_user_role project_user
+
+      @sprints.backlog
+    end
+
+    def user_is?(user_id, type)
+      role = Models::ProjectRole.where(project_id: @id, user_id: user_id).first
+
+      return false if role.nil?
+
+      return true if role.role_type == 'owner'
+
+      role.role_type == type
+    end
+
+    def users
+      Models::Project.find(@id).project_roles.map do |role|
+        ProjectRole.new(role)
+      end
+    end
+
+    private
+
+    def check_user_role(user_id, type = 'spectator')
+      fail 'User not in role.' unless user_is?(user_id, type)
+    end
+  end
+
+  class ProjectRole
+    attr_reader :user_id, :user_email, :type
+
+    def initialize(project_role)
+      @user_id = project_role.user_id
+      @user_email = project_role.user.email
+      @type = project_role.role_type
+    end
+  end
+end

data/lib/trackington/app/sprints.rb

@@ -0,0 +1,101 @@
+require_relative '../db/models/user'
+require_relative '../db/models/credential'
+require_relative 'tasks'
+
+module Trackington
+  class SprintRepository
+    def initialize(project_id)
+      @project_id = project_id
+    end
+
+    def create(data)
+      data[:project_id] = @project_id
+      sprint = Models::Sprint.new(data)
+      sprint.is_active = true if current.nil?
+      sprint.save
+    end
+
+    def current
+      db_sprint = Models::Sprint.where(project_id: @project_id,
+                                       is_active: true).first
+
+      return db_sprint if db_sprint.nil?
+
+      Sprint.new(db_sprint)
+    end
+
+    def get(sprint_id)
+      db_sprint = Models::Sprint.find(sprint_id)
+      Sprint.new(db_sprint)
+    end
+
+    def complete_sprint
+      return if current.nil?
+
+      current.tasks.move_to(backlog.id)
+      current.end
+    end
+
+    def start_sprint
+      project_sprints = Models::Sprint.where(project_id: @project_id)
+      next_sprint_db = project_sprints.where('start_time > ?', Date.today).first
+
+      return if next_sprint_db.nil?
+
+      next_sprint = Sprint.new(next_sprint_db)
+
+      backlog.tasks.move_to(next_sprint.id)
+      next_sprint.start
+    end
+
+    def backlog
+      query = Models::Sprint.where(project_id: @project_id, is_backlog: true)
+      backlog = query.first
+      Sprint.new(backlog)
+    end
+  end
+
+  class Sprint
+    attr_reader :id, :start_time, :end_time, :is_active, :is_backlog, :tasks
+
+    def initialize(sprint)
+      @id = sprint.id
+      @start_time = sprint.start_time
+      @end_time = sprint.end_time
+      @is_active = sprint.is_active
+      @is_backlog = sprint.is_backlog
+      @project_id = sprint.project_id
+      @tasks = TaskRepository.new(@id)
+    end
+
+    def start
+      sprint = Models::Sprint.find(@id)
+      sprint.is_active = true
+      sprint.save
+    end
+
+    def end
+      sprint = Models::Sprint.find(@id)
+      sprint.is_active = false
+      sprint.save
+    end
+
+    def add_task(user_id, data)
+      check_user_role user_id
+      data[:created_by] = user_id
+      @tasks.add(data)
+    end
+
+    def all
+      @tasks.all
+    end
+
+    private
+
+    def check_user_role(user_id, role = 'spectator')
+      repo = ProjectRepository.new
+      project = repo.get(@project_id)
+      project.user_is?(user_id, role)
+    end
+  end
+end

data/lib/trackington/app/tasks.rb

@@ -0,0 +1,121 @@
+require_relative '../db/models/task'
+
+module Trackington
+  class TaskRepository
+    STATUSES = %w(open in_progress resolved closed reopened)
+    PRIORITIES = %w(blocker critical major minor trivial)
+    TYPES = %w(bug improvement new_feature story task)
+
+    def initialize(sprint_id)
+      @sprint_id = sprint_id
+    end
+
+    def move_to(sprint_id)
+      tasks = Models::Task.where(sprint_id: sprint_id)
+
+      tasks.each do |task|
+        task.sprint_id = sprint_id if active?(task.status)
+        task.save
+      end
+    end
+
+    def add(data)
+      data[:sprint_id] = @sprint_id
+      task = Models::Task.new(data)
+      task.save
+    end
+
+    def all
+      Models::Task.where(sprint_id: @sprint_id).map do |db_task|
+        Task.new(db_task)
+      end
+    end
+
+    def get(id)
+      db_task = Models::Task.where(sprint_id: @sprint_id, id: id).first
+      Task.new(db_task)
+    end
+
+    def status_types
+      STATUSES
+    end
+
+    def priorities
+      PRIORITIES
+    end
+
+    def types
+      TYPES
+    end
+
+    private
+
+    def active?(status)
+      %w(in_progress reopened open).include? status
+    end
+  end
+
+  class Task
+    STATUSES = %w(open in_progress resolved closed reopened)
+    PRIORITIES = %w(blocker critical major minor trivial)
+    TYPES = %w(bug improvement new_feature story task)
+
+    attr_reader :id, :title, :description, :time_planned, :time_actual
+    attr_reader :priority, :task_type, :status, :assigned_to, :created_by
+
+    def initialize(db_task)
+      basic_properties(db_task)
+      status_properties(db_task)
+      person_properties(db_task)
+    end
+
+    def active?
+      %w(in_progress reopened open).include? @status
+    end
+
+    def update(data)
+      db_task = Models::Task.find(@id)
+
+      data.each do |property, new_value|
+        db_task[property] = get_value(property, new_value) if property != :id
+      end
+
+      db_task.save
+
+      basic_properties(db_task)
+      status_properties(db_task)
+      person_properties(db_task)
+    end
+
+    private
+
+    def basic_properties(db_task)
+      @id = db_task.id
+      @title = db_task.title
+      @description = db_task.description
+    end
+
+    def status_properties(db_task)
+      @time_planned = db_task.time_planned
+      @time_actual =  db_task.time_actual
+
+      @priority = db_task.priority
+      @task_type = db_task.task_type
+      @status = db_task.status
+    end
+
+    def person_properties(db_task)
+      @assigned_to = db_task.assigned_to
+      @created_by = db_task.created_by
+    end
+
+    def get_value(property, value)
+      case property
+      when :status then STATUSES.index(value)
+      when :priority then PRIORITIES.index(value)
+      when :task_type then TYPES.index(value)
+      else value
+      end
+    end
+  end
+end

data/lib/trackington/app/users.rb

@@ -0,0 +1,107 @@
+require_relative '../db/models/user'
+require_relative '../db/models/credential'
+
+module Trackington
+  class UserRepository
+    SALT_LENGHT = 50
+    SESSION_KEY_LENGTH = 50
+
+    def register(email, password)
+      check_existing email
+
+      user = Models::User.new
+      user.email = email
+      user.save
+
+      credential = create_credentials(user.id, password)
+
+      credential.session_key
+    end
+
+    def user(session_key)
+      db_credential = Models::Credential.where(session_key: session_key).first
+
+      db_user = Models::User.find(db_credential.user_id)
+
+      User.new(db_user.id, db_user.email)
+    end
+
+    def login(email, password)
+      user = Models::User.where(email: email).first
+
+      fail "Email/password don't match" if user.nil?
+
+      credential = Models::Credential.where(user_id: user.id).first
+
+      check_credentials(credential, password)
+
+      credential.session_key = generate_string SESSION_KEY_LENGTH
+
+      credential.save
+
+      credential.session_key
+    end
+
+    def logout(session_key)
+      credential = Models::Credential.where(session_key: session_key).first
+
+      return if credential.nil?
+
+      credential.session_key = nil
+      credential.save
+    end
+
+    def count
+      Models::User.count
+    end
+
+    def search(query)
+      Models::User.where('email like ?', "%#{query}%").map do |user|
+        User.new(user.id, user.email)
+      end
+    end
+
+    private
+
+    def check_credentials(credential, password)
+      expected = hash(credential.salt + password)
+
+      fail "Username/password don't match." if expected != credential.password
+    end
+
+    def check_existing(email)
+      existing_user = Models::User.where(email: email).first
+
+      fail 'User already exists.' unless existing_user.nil?
+    end
+
+    def create_credentials(user_id, password)
+      salt = hash(generate_string(SALT_LENGHT))
+      credential = Models::Credential.new
+      credential.password = hash(salt + password)
+      credential.salt = salt
+      credential.session_key = generate_string SESSION_KEY_LENGTH
+      credential.user_id = user_id
+      credential.save
+      credential
+    end
+
+    def hash(input)
+      Digest::SHA256.base64digest(input)
+    end
+
+    def generate_string(length)
+      o = [('a'..'z'), ('A'..'Z')].map(&:to_a).flatten
+      (0...length).map { o[rand(o.length)] }.join
+    end
+  end
+
+  class User
+    attr_reader :id, :email
+
+    def initialize(id, email)
+      @id = id
+      @email = email
+    end
+  end
+end

data/lib/trackington/db/config.yml

@@ -0,0 +1,21 @@
+development:
+  adapter: sqlite3
+  database: lib/db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+# production:
+#   adapter: pg
+#   encoding: utf8
+#   reconnect: false
+#   database: somedatabase_dev
+#   pool: 5
+#   username: root
+#   password:
+#   socket: /var/run/mysqld/mysqld.sock
+
+test: &test
+  adapter: sqlite3
+  database: lib/trackington/db/tmp/test.sqlite3
+  pool: 5
+  timeout: 5000

data/lib/trackington/db/migrate/20160207202529_create_users.rb

@@ -0,0 +1,7 @@
+class CreateUsers < ActiveRecord::Migration
+  def change
+    create_table :users do |t|
+      t.string :email
+    end
+  end
+end

data/lib/trackington/db/migrate/20160207203302_create_user_credentials.rb

@@ -0,0 +1,11 @@
+class CreateUserCredentials < ActiveRecord::Migration
+  def change
+    create_table :credentials do |t|
+      t.string :password
+      t.string :salt
+      t.string :session_key
+
+      t.belongs_to :user, index: true
+    end
+  end
+end

data/lib/trackington/db/migrate/20160209100247_create_projects.rb

@@ -0,0 +1,9 @@
+class CreateProjects < ActiveRecord::Migration
+  def change
+    create_table :projects do |t|
+      t.string :description
+      t.string :title
+      t.boolean :public, default: false
+    end
+  end
+end

data/lib/trackington/db/migrate/20160209101604_create_project_roles.rb

@@ -0,0 +1,10 @@
+class CreateProjectRoles < ActiveRecord::Migration
+  def change
+    create_table :project_roles do |t|
+      t.integer :role_type, default: 0
+
+      t.belongs_to :user, index: true
+      t.belongs_to :project, index: true
+    end
+  end
+end

data/lib/trackington/db/migrate/20160209153945_create_sprints.rb

@@ -0,0 +1,11 @@
+class CreateSprints < ActiveRecord::Migration
+  def change
+    create_table :sprints do |t|
+      t.date :start_time
+      t.date :end_time
+      t.boolean :is_backlog
+
+      t.belongs_to :project, index: true
+    end
+  end
+end

data/lib/trackington/db/migrate/20160209154117_create_tasks.rb

@@ -0,0 +1,18 @@
+class CreateTasks < ActiveRecord::Migration
+  def change
+    create_table :tasks do |t|
+      t.string :title
+      t.string :description
+
+      t.integer :time_planned
+      t.integer :time_actual
+
+      t.integer :priority  # Blocker, Critical, Major, Minor, Trivial
+      t.integer :type # Epic, Bug, Improvement, New Feature, Story, Task
+      t.integer :status 
+
+      t.integer :assigned_to # should be belongs_to :user
+      t.integer :created_by # should be belongs_to :user
+    end
+  end
+end

data/lib/trackington/db/migrate/20160209165534_update_sprint_columns.rb

@@ -0,0 +1,5 @@
+class UpdateSprintColumns < ActiveRecord::Migration
+  def change
+    add_column :sprints, :is_active, :boolean
+  end
+end

data/lib/trackington/db/migrate/20160209193650_update_tasks_references.rb

@@ -0,0 +1,5 @@
+class UpdateTasksReferences < ActiveRecord::Migration
+  def change
+    add_reference :tasks, :sprint, index: true, foreign_key: true
+  end
+end

data/lib/trackington/db/migrate/20160209195016_update_tasks_column.rb

@@ -0,0 +1,5 @@
+class UpdateTasksColumn < ActiveRecord::Migration
+  def change
+    rename_column :tasks, :type, :task_type
+  end
+end

data/lib/trackington/db/models/credential.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+
+module Trackington
+  module Models
+    class Credential < ActiveRecord::Base
+      belongs_to :user
+    end
+  end
+end

data/lib/trackington/db/models/project.rb

@@ -0,0 +1,10 @@
+require 'active_record'
+
+module Trackington
+  module Models
+    class Project < ActiveRecord::Base
+      has_many :sprints
+      has_many :project_roles
+    end
+  end
+end

data/lib/trackington/db/models/project_role.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+
+module Trackington
+  module Models
+    class ProjectRole < ActiveRecord::Base
+      enum role_type: [:owner, :contributor, :spectator]
+
+      belongs_to :project
+      belongs_to :user
+    end
+  end
+end

data/lib/trackington/db/models/sprint.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+
+module Trackington
+  module Models
+    class Sprint < ActiveRecord::Base
+      has_many :tasks
+
+      belongs_to :project
+    end
+  end
+end

data/lib/trackington/db/models/task.rb

@@ -0,0 +1,13 @@
+require 'active_record'
+
+module Trackington
+  module Models
+    class Task < ActiveRecord::Base
+      enum status: [:open, :in_progress, :resolved, :closed, :reopened]
+      enum priority: [:blocker, :critical, :major, :minor, :trivial]
+      enum task_type: [:bug, :improvement, :new_feature, :story, :task]
+
+      belongs_to :sprint
+    end
+  end
+end

data/lib/trackington/db/models/user.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+
+module Trackington
+  module Models
+    class User < ActiveRecord::Base
+      has_many :project_roles
+    end
+  end
+end

data/lib/trackington/rake/task.rb

@@ -0,0 +1,44 @@
+require 'rake'
+require 'rake/tasklib'
+require 'uri'
+require 'active_record'
+
+module Trackington
+  class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    def initialize
+      namespace :trackington do
+        namespace :db do
+          task :migrate do
+            establish_connection
+
+            migrate
+          end
+        end
+      end
+    end
+
+    private
+
+    def establish_connection
+      db_query = ENV['DB_QUERY']
+
+      db = URI.parse(db_query)
+
+      ActiveRecord::Base.establish_connection(
+        adapter:  db.scheme == 'postgres' ? 'postgresql' : db.scheme,
+        host:     db.host,
+        username: db.user,
+        password: db.password,
+        database: db.path[1..-1],
+        encoding: 'utf8')
+    end
+
+    def migrate
+      migrations_path = File.expand_path('../../db/migrate', __FILE__)
+
+      ActiveRecord::Migrator.migrate(migrations_path, nil)
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: trackington
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yoan Dinkov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-10 00:00:00.000000000 Z
+dependencies: []
+description: Simple bug tracking system based on projects, sprints, tasks. (University
+  project)
+email:
+- yoandinkov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/trackington.rb
+- lib/trackington/app/core.rb
+- lib/trackington/app/projects.rb
+- lib/trackington/app/sprints.rb
+- lib/trackington/app/tasks.rb
+- lib/trackington/app/users.rb
+- lib/trackington/db/config.yml
+- lib/trackington/db/migrate/20160207202529_create_users.rb
+- lib/trackington/db/migrate/20160207203302_create_user_credentials.rb
+- lib/trackington/db/migrate/20160209100247_create_projects.rb
+- lib/trackington/db/migrate/20160209101604_create_project_roles.rb
+- lib/trackington/db/migrate/20160209153945_create_sprints.rb
+- lib/trackington/db/migrate/20160209154117_create_tasks.rb
+- lib/trackington/db/migrate/20160209165534_update_sprint_columns.rb
+- lib/trackington/db/migrate/20160209193650_update_tasks_references.rb
+- lib/trackington/db/migrate/20160209195016_update_tasks_column.rb
+- lib/trackington/db/models/credential.rb
+- lib/trackington/db/models/project.rb
+- lib/trackington/db/models/project_role.rb
+- lib/trackington/db/models/sprint.rb
+- lib/trackington/db/models/task.rb
+- lib/trackington/db/models/user.rb
+- lib/trackington/rake/task.rb
+homepage: http://rubygems.org/gems/trackington
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Trackington - bug tracking system. (University project)
+test_files: []