class NotesController < ApplicationController
before_filter :project
# Authorize
before_filter :add_project_abilities
before_filter :authorize_write_note!, :only => [:create]
before_filter :authorize_admin_note!, :only => [:destroy]
respond_to :js
def create
@note = @project.notes.new(params[:note])
@note.author = current_user
if @note.save
notify if params[:notify] == '1'
end
respond_to do |format|
format.html {redirect_to :back}
format.js
end
end
def destroy
@note = @project.notes.find(params[:id])
@note.destroy
respond_to do |format|
format.js { render :nothing => true }
end
end
protected
def notify
@project.users.reject { |u| u.id == current_user.id } .each do |u|
case @note.noteable_type
when "Commit" then
Notify.note_commit_email(u, @note).deliver
when "Issue" then
Notify.note_issue_email(u, @note).deliver
else
Notify.note_wall_email(u, @note).deliver
end
end
end
end
class ProfileController < ApplicationController
def show
@user = current_user
end
def password
@user = current_user
end
def password_update
params[:user].reject!{ |k, v| k != "password" && k != "password_confirmation"}
@user = current_user
if @user.update_attributes(params[:user])
flash[:notice] = "Password was successfully updated. Please login with it"
redirect_to new_user_session_path
else
render :action => "password"
end
end
end
class ProjectsController < ApplicationController
before_filter :project, :except => [:index, :new, :create]
# Authorize
before_filter :add_project_abilities
before_filter :authorize_read_project!, :except => [:index, :new, :create]
before_filter :authorize_admin_project!, :only => [:edit, :update, :destroy]
def index
@projects = current_user.projects.all
respond_to do |format|
format.html # index.html.erb
format.json { render json: @projects }
end
end
def show
@repo = project.repo
@commit = @repo.commits.first
@tree = @commit.tree
@tree = @tree / params[:path] if params[:path]
respond_to do |format|
format.html # show.html.erb
format.json { render json: project }
end
rescue Grit::NoSuchPathError => ex
respond_to do |format|
format.html {render "projects/empty"}
end
end
def tree
@repo = project.repo
@branch = if !params[:branch].blank?
params[:branch]
elsif !params[:tag].blank?
params[:tag]
else
"master"
end
if params[:commit_id]
@commit = @repo.commits(params[:commit_id]).first
else
@commit = @repo.commits(@branch || "master").first
end
@tree = @commit.tree
@tree = @tree / params[:path] if params[:path]
respond_to do |format|
format.html # show.html.erb
format.js do
# temp solution
response.headers["Cache-Control"] = "no-cache, no-store, max-age=0, must-revalidate"
response.headers["Pragma"] = "no-cache"
response.headers["Expires"] = "Fri, 01 Jan 1990 00:00:00 GMT"
end
format.json { render json: project }
end
end
def blob
@repo = project.repo
@commit = project.commit(params[:commit_id])
@tree = project.tree(@commit, params[:path])
if @tree.is_a?(Grit::Blob)
send_data(@tree.data, :type => @tree.mime_type, :disposition => 'inline', :filename => @tree.name)
else
head(404)
end
end
def new
@project = Project.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @project }
end
end
def edit
end
def create
@project = Project.new(params[:project])
Project.transaction do
@project.save!
@project.users_projects.create!(:admin => true, :read => true, :write => true, :user => current_user)
end
respond_to do |format|
if @project.valid?
format.html { redirect_to @project, notice: 'Project was successfully created.' }
format.js
format.json { render json: @project, status: :created, location: @project }
else
format.html { render action: "new" }
format.js
format.json { render json: @project.errors, status: :unprocessable_entity }
end
end
rescue StandardError => ex
@project.errors.add(:base, "Cant save project. Please try again later")
respond_to do |format|
format.html { render action: "new" }
format.js
format.json { render json: @project.errors, status: :unprocessable_entity }
end
end
def update
respond_to do |format|
if project.update_attributes(params[:project])
format.html { redirect_to project, notice: 'Project was successfully updated.' }
format.js
format.json { head :ok }
else
format.html { render action: "edit" }
format.js
format.json { render json: project.errors, status: :unprocessable_entity }
end
end
end
def destroy
project.destroy
respond_to do |format|
format.html { redirect_to projects_url }
format.json { head :ok }
end
end
def wall
@notes = @project.common_notes
@note = Note.new
end
protected
def project
@project ||= Project.find_by_code(params[:id])
end
end
class TeamMembersController < ApplicationController
before_filter :project
# Authorize
before_filter :add_project_abilities
before_filter :authorize_read_team_member!
before_filter :authorize_admin_team_member!, :only => [:new, :create, :destroy, :update]
def show
@team_member = project.users_projects.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.js
format.json { render json: @team_member }
end
end
def new
@team_member = project.users_projects.new
respond_to do |format|
format.html # new.html.erb
format.js
format.json { render json: @team_member }
end
end
def create
@team_member = UsersProject.new(params[:team_member])
@team_member.project = project
respond_to do |format|
if @team_member.save
format.html { redirect_to @team_member, notice: 'Team member was successfully created.' }
format.js
format.json { render json: @team_member, status: :created, location: @team_member }
else
format.html { render action: "new" }
format.js
format.json { render json: @team_member.errors, status: :unprocessable_entity }
end
end
end
def update
@team_member = project.users_projects.find(params[:id])
@team_member.update_attributes(params[:team_member])
respond_to do |format|
format.js
format.html { redirect_to team_project_path(@project)}
end
end
def destroy
@team_member = project.users_projects.find(params[:id])
@team_member.destroy
respond_to do |format|
format.html { redirect_to root_path }
format.json { head :ok }
format.js { render :nothing => true }
end
end
end
module Admin::ProjectsHelper
end
module Admin::UsersHelper
end
require 'digest/md5'
module ApplicationHelper
def gravatar_icon(user_email)
"http://www.gravatar.com/avatar/#{Digest::MD5.hexdigest(user_email)}?s=40&d=identicon"
end
def commit_name(project, commit)
if project.commit.id == commit.id
"master"
else
commit.id
end
end
def admin_namespace?
controller.class.name.split("::").first=="Admin"
end
def projects_namespace?
!current_page?(root_url) &&
controller.controller_name != "keys" &&
!admin_namespace?
end
def last_commit(project)
if project.repo_exists?
time_ago_in_words(project.commit.committed_date) + " ago"
else
"Never"
end
end
def search_autocomplete_source
projects = current_user.projects.map{ |p| { :label => p.name, :url => project_path(p) } }
default_nav = [
{ :label => "Keys", :url => keys_path },
{ :label => "Projects", :url => projects_path },
{ :label => "Admin", :url => admin_root_path }
]
project_nav = []
if @project && !@project.new_record?
project_nav = [
{ :label => "#{@project.code} / Issues", :url => project_issues_path(@project) },
{ :label => "#{@project.code} / Wall", :url => wall_project_path(@project) },
{ :label => "#{@project.code} / Tree", :url => tree_project_path(@project) },
{ :label => "#{@project.code} / Commits", :url => project_commits_path(@project) },
{ :label => "#{@project.code} / Team", :url => team_project_path(@project) }
]
end
[projects, default_nav, project_nav].flatten.to_json
end
def handle_file_type(file_name, mime_type)
if file_name =~ /(\.rb|\.ru|\.rake|Rakefile|\.gemspec|\.rbx|Gemfile)$/
:ruby
elsif file_name =~ /\.py$/
:python
elsif file_name =~ /(\.pl|\.scala|\.c|\.cpp|\.java|\.haml|\.html|\.sass|\.scss|\.xml|\.php|\.erb)$/
$1[1..-1].to_sym
elsif file_name =~ /\.js$/
:javascript
elsif file_name =~ /\.sh$/
:bash
elsif file_name =~ /\.coffee$/
:coffeescript
elsif file_name =~ /\.yml$/
:yaml
elsif file_name =~ /\.md$/
:minid
else
:text
end
end
end
module CommitsHelper
def diff_line(line, line_new = 0, line_old = 0)
full_line = html_escape(line.gsub(/\n/, ''))
color = if line[0] == "+"
full_line = "<span class=\"old_line\">&nbsp;</span><span class=\"new_line\">#{line_new}</span> " + full_line
"#DFD"
elsif line[0] == "-"
full_line = "<span class=\"old_line\">#{line_old}</span><span class=\"new_line\">&nbsp;</span> " + full_line
"#FDD"
else
full_line = "<span class=\"old_line\">#{line_old}</span><span class=\"new_line\">#{line_new}</span> " + full_line
"none"
end
raw "<div style=\"white-space:pre;background:#{color};\">#{full_line}</div>"
end
def more_commits_link
offset = params[:offset] || 0
limit = params[:limit] || 100
link_to "More", project_commits_path(@project, :offset => offset.to_i + limit.to_i, :limit => limit),
:remote => true, :class => "lite_button vm", :style => "text-align:center; width:930px; ", :id => "more-commits-link"
end
end
module DashboardHelper
end
module IssuesHelper
end
module KeysHelper
end
module ProfileHelper
end
module ProjectsHelper
end
module TeamMembersHelper
end
class Notify < ActionMailer::Base
default_url_options[:host] = "gitlabhq.com"
default from: "notify@gitlabhq.com"
def new_user_email(user, password)
@user = user
@password = password
mail(:to => @user.email, :subject => "gitlab | Account was created for you")
end
def new_issue_email(issue)
@user = issue.assignee
@project = issue.project
@issue = issue
mail(:to => @user.email, :subject => "gitlab | New Issue was created")
end
def note_wall_email(user, note)
@user = user
@note = note
@project = note.project
mail(:to => @user.email, :subject => "gitlab | #{@note.project.name} ")
end
def note_commit_email(user, note)
@user = user
@note = note
@project = note.project
@commit = @project.repo.commits(note.noteable_id).first
mail(:to => @user.email, :subject => "gitlab | #{@note.project.name} ")
end
def note_issue_email(user, note)
@user = user
@note = note
@project = note.project
@issue = note.noteable
mail(:to => @user.email, :subject => "gitlab | #{@note.project.name} ")
end
end
class Ability
def self.allowed(object, subject)
case subject.class.name
when "Project" then project_abilities(object, subject)
else []
end
end
def self.project_abilities(user, project)
rules = []
rules << [
:read_project,
:read_issue,
:read_team_member,
:read_note
] if project.readers.include?(user)
rules << [
:write_project,
:write_issue,
:write_note
] if project.writers.include?(user)
rules << [
:admin_project,
:admin_issue,
:admin_team_member,
:admin_note
] if project.admins.include?(user)
rules.flatten
end
end
class Issue < ActiveRecord::Base
belongs_to :project
belongs_to :author, :class_name => "User"
belongs_to :assignee, :class_name => "User"
has_many :notes, :as => :noteable
attr_protected :author, :author_id, :project, :project_id
validates_presence_of :project_id
validates_presence_of :assignee_id
validates_presence_of :author_id
validates :title,
:presence => true,
:length => { :within => 0..255 }
validates :content,
:presence => true,
:length => { :within => 0..2000 }
scope :opened, where(:closed => false)
scope :closed, where(:closed => true)
scope :assigned, lambda { |u| where(:assignee_id => u.id)}
end
# == Schema Information
#
# Table name: issues
#
# id :integer not null, primary key
# title :string(255)
# content :text
# assignee_id :integer
# author_id :integer
# project_id :integer
# created_at :datetime
# updated_at :datetime
# closed :boolean default(FALSE), not null
#
app/models/key.rb 0 → 100644
class Key < ActiveRecord::Base
belongs_to :user
validates :title,
:presence => true,
:length => { :within => 0..255 }
validates :key,
:presence => true,
:uniqueness => true,
:length => { :within => 0..555 }
before_save :set_identifier
after_save :update_gitosis
after_destroy :gitosis_delete_key
def set_identifier
self.identifier = "#{user.identifier}_#{Time.now.to_i}"
end
def update_gitosis
Gitosis.new.configure do |c|
c.update_keys(identifier, key)
projects.each do |project|
c.update_project(project.path, project.gitosis_writers)
end
end
end
def gitosis_delete_key
Gitosis.new.configure do |c|
c.delete_key(identifier)
projects.each do |project|
c.update_project(project.path, project.gitosis_writers)
end
end
end
#projects that has this key
def projects
user.projects
end
end
# == Schema Information
#
# Table name: keys
#
# id :integer not null, primary key
# user_id :integer not null
# created_at :datetime
# updated_at :datetime
# key :text
# title :string(255)
# identifier :string(255)
#