Commit 261afb0d5cedc1633680685b56a72553d18c548d

Authored by Leandro Santos
Committed by Rodrigo Souto
1 parent 7164ac60

API: adding initial task endpoint

app/models/task.rb
... ... @@ -265,6 +265,19 @@ class Task < ActiveRecord::Base
265 265  
266 266 include Spammable
267 267  
  268 + #FIXME make this test
  269 + def display_to?(user = nil)
  270 + return true if self.target == user
  271 + return false if !self.target.kind_of?(Environment) && self.target.person?
  272 +
  273 + if self.target.kind_of?(Environment)
  274 + user.is_admin?(self.target)
  275 + else
  276 + self.target.members.by_role(self.target.roles.reject {|r| !r.has_permission?('perform_task')}).include?(user)
  277 + end
  278 + end
  279 +
  280 +
268 281 protected
269 282  
270 283 # This method must be overrided in subclasses, and its implementation must do
... ...
db/schema.rb
... ... @@ -729,24 +729,26 @@ ActiveRecord::Schema.define(:version => 20150525101430) do
729 729 create_table "users", :force => true do |t|
730 730 t.string "login"
731 731 t.string "email"
732   - t.string "crypted_password", :limit => 40
733   - t.string "salt", :limit => 40
  732 + t.string "crypted_password", :limit => 40
  733 + t.string "salt", :limit => 40
734 734 t.datetime "created_at"
735 735 t.datetime "updated_at"
736 736 t.string "remember_token"
737 737 t.datetime "remember_token_expires_at"
738 738 t.text "terms_of_use"
739   - t.string "terms_accepted", :limit => 1
  739 + t.string "terms_accepted", :limit => 1
740 740 t.integer "environment_id"
741 741 t.string "password_type"
742   - t.boolean "enable_email", :default => false
743   - t.string "last_chat_status", :default => ""
744   - t.string "chat_status", :default => ""
  742 + t.boolean "enable_email", :default => false
  743 + t.string "last_chat_status", :default => ""
  744 + t.string "chat_status", :default => ""
745 745 t.datetime "chat_status_at"
746   - t.string "activation_code", :limit => 40
  746 + t.string "activation_code", :limit => 40
747 747 t.datetime "activated_at"
748 748 t.string "return_to"
749 749 t.datetime "last_login_at"
  750 + t.string "private_token"
  751 + t.datetime "private_token_generated_at"
750 752 end
751 753  
752 754 create_table "validation_infos", :force => true do |t|
... ...
lib/noosfero/api/api.rb
... ... @@ -44,6 +44,7 @@ module Noosfero
44 44 mount V1::People
45 45 mount V1::Enterprises
46 46 mount V1::Categories
  47 + mount V1::Tasks
47 48 mount Session
48 49  
49 50 # hook point which allow plugins to add Grape::API extensions to API::API
... ...
lib/noosfero/api/entities.rb
... ... @@ -107,6 +107,7 @@ module Noosfero
107 107 end
108 108  
109 109 class Task < Entity
  110 + root 'tasks', 'task'
110 111 expose :id
111 112 expose :type
112 113 end
... ...
lib/noosfero/api/helpers.rb
... ... @@ -50,6 +50,11 @@ module Noosfero
50 50 article.display_to?(current_user.person) ? article : forbidden!
51 51 end
52 52  
  53 + def find_task(tasks, id)
  54 + task = tasks.find(id)
  55 + task.display_to?(current_user.person) ? task : forbidden!
  56 + end
  57 +
53 58 def make_conditions_with_parameter(params = {})
54 59 parsed_params = parser_params(params)
55 60 conditions = {}
... ...
lib/noosfero/api/v1/tasks.rb 0 → 100644
... ... @@ -0,0 +1,164 @@
  1 +module Noosfero
  2 + module API
  3 + module V1
  4 + class Tasks < Grape::API
  5 +# before { authenticate! }
  6 +
  7 +# ARTICLE_TYPES = Article.descendants.map{|a| a.to_s}
  8 +
  9 + resource :tasks do
  10 +
  11 + # Collect tasks
  12 + #
  13 + # Parameters:
  14 + # from - date where the search will begin. If nothing is passed the default date will be the date of the first article created
  15 + # oldest - Collect the oldest articles. If nothing is passed the newest articles are collected
  16 + # limit - amount of articles returned. The default value is 20
  17 + #
  18 + # Example Request:
  19 + # GET host/api/v1/tasks?from=2013-04-04-14:41:43&until=2015-04-04-14:41:43&limit=10&private_token=e96fff37c2238fdab074d1dcea8e6317
  20 + get do
  21 + #FIXME check for permission
  22 + tasks = select_filtered_collection_of(environment, 'tasks', params)
  23 + present tasks, :with => Entities::Task, :fields => params[:fields]
  24 + end
  25 +
  26 + desc "Return the task id"
  27 + get ':id' do
  28 + task = find_task(environment.tasks, params[:id])
  29 + present task, :with => Entities::Task, :fields => params[:fields]
  30 + end
  31 +
  32 +
  33 + end
  34 +
  35 + resource :communities do
  36 + segment '/:community_id' do
  37 + resource :tasks do
  38 + get do
  39 + #FIXME check for permission
  40 + community = environment.communities.find(params[:community_id])
  41 + tasks = select_filtered_collection_of(community, 'tasks', params)
  42 + present tasks, :with => Entities::Task, :fields => params[:fields]
  43 + end
  44 +
  45 + get ':id' do
  46 + community = environment.communities.find(params[:community_id])
  47 + task = find_task(community.tasks, params[:id])
  48 + present task, :with => Entities::Task, :fields => params[:fields]
  49 + end
  50 +
  51 + # Example Request:
  52 + # POST api/v1/communites/:community_id/articles?private_token=234298743290432&article[name]=title&article[body]=body
  53 + post do
  54 + community = environment.communities.find(params[:community_id])
  55 +#FIXME see the correct permission
  56 + return forbidden! unless current_person.can_post_content?(community)
  57 +#FIXME check the task type before create
  58 + klass_type= params[:content_type].nil? ? 'Task' : params[:content_type]
  59 +# return forbidden! unless ARTICLE_TYPES.include?(klass_type)
  60 +#
  61 + task = klass_type.constantize.new(params[:task])
  62 + task.requestor = current_person
  63 + task.target = community
  64 +
  65 + if !task.save
  66 + render_api_errors!(task.errors.full_messages)
  67 + end
  68 + present task, :with => Entities::Task, :fields => params[:fields]
  69 + end
  70 +
  71 + end
  72 + end
  73 +
  74 + end
  75 +
  76 + resource :people do
  77 + segment '/:person_id' do
  78 + resource :tasks do
  79 + get do
  80 +# person = environment.people.find(params[:person_id])
  81 +# articles = select_filtered_collection_of(person, 'articles', params)
  82 +# articles = articles.display_filter(current_person, person)
  83 +tasks = Task.all
  84 + present tasks, :with => Entities::Task, :fields => params[:fields]
  85 + end
  86 +
  87 + get ':id' do
  88 +# person = environment.people.find(params[:person_id])
  89 +# article = find_article(person.articles, params[:id])
  90 +task = Task.first
  91 + present task, :with => Entities::Task, :fields => params[:fields]
  92 + end
  93 +
  94 + post do
  95 +# person = environment.people.find(params[:person_id])
  96 +# return forbidden! unless current_person.can_post_content?(person)
  97 +#
  98 +# klass_type= params[:content_type].nil? ? 'TinyMceArticle' : params[:content_type]
  99 +# return forbidden! unless ARTICLE_TYPES.include?(klass_type)
  100 +#
  101 +# article = klass_type.constantize.new(params[:article])
  102 +# article.last_changed_by = current_person
  103 +# article.created_by= current_person
  104 +# article.profile = person
  105 +#
  106 +# if !article.save
  107 +# render_api_errors!(article.errors.full_messages)
  108 +# end
  109 +task = Task.first
  110 + present task, :with => Entities::Task, :fields => params[:fields]
  111 + end
  112 +
  113 + end
  114 + end
  115 +
  116 + end
  117 +
  118 + resource :enterprises do
  119 + segment '/:enterprise_id' do
  120 + resource :tasks do
  121 + get do
  122 +# enterprise = environment.enterprises.find(params[:enterprise_id])
  123 +# articles = select_filtered_collection_of(enterprise, 'articles', params)
  124 +# articles = articles.display_filter(current_person, enterprise)
  125 +tasks = Task.all
  126 + present tasks, :with => Entities::Task, :fields => params[:fields]
  127 + end
  128 +
  129 + get ':id' do
  130 +# enterprise = environment.enterprises.find(params[:enterprise_id])
  131 +# article = find_article(enterprise.articles, params[:id])
  132 +task = Task.first
  133 + present task, :with => Entities::Task, :fields => params[:fields]
  134 + end
  135 +
  136 + post do
  137 +# enterprise = environment.enterprises.find(params[:enterprise_id])
  138 +# return forbidden! unless current_person.can_post_content?(enterprise)
  139 +#
  140 +# klass_type= params[:content_type].nil? ? 'TinyMceArticle' : params[:content_type]
  141 +# return forbidden! unless ARTICLE_TYPES.include?(klass_type)
  142 +#
  143 +# article = klass_type.constantize.new(params[:article])
  144 +# article.last_changed_by = current_person
  145 +# article.created_by= current_person
  146 +# article.profile = enterprise
  147 +#
  148 +# if !article.save
  149 +# render_api_errors!(article.errors.full_messages)
  150 +# end
  151 +task = Task.first
  152 + present task, :with => Entities::Task, :fields => params[:fields]
  153 + end
  154 +
  155 + end
  156 + end
  157 +
  158 + end
  159 +
  160 +
  161 + end
  162 + end
  163 + end
  164 +end
... ...
test/unit/api/task_test.rb 0 → 100644
... ... @@ -0,0 +1,389 @@
  1 +require File.dirname(__FILE__) + '/test_helper'
  2 +
  3 +class TasksTest < ActiveSupport::TestCase
  4 +
  5 + def setup
  6 + login_api
  7 + @person = user.person
  8 + @community = fast_create(Community)
  9 + @environment = Environment.default
  10 + end
  11 +
  12 + attr_accessor :person, :community, :environment
  13 +
  14 + should 'list tasks' do
  15 + task = fast_create(Task, :requestor_id => environment.id, :target_id => community.id)
  16 + get "/api/v1/tasks?#{params.to_query}"
  17 + json = JSON.parse(last_response.body)
  18 + assert_includes json["tasks"].map { |a| a["id"] }, task.id
  19 + end
  20 +
  21 + should 'return environment task by id' do
  22 + environment.add_admin(person)
  23 + task = create(Task, :requestor => person, :target => environment)
  24 + get "/api/v1/tasks/#{task.id}?#{params.to_query}"
  25 + json = JSON.parse(last_response.body)
  26 + assert_equal task.id, json["task"]["id"]
  27 + end
  28 +
  29 + should 'not return environmet task if user has no permission to view it' do
  30 + person = fast_create(Person)
  31 + task = create(Task, :requestor => person, :target => environment)
  32 +
  33 + get "/api/v1/tasks/#{task.id}?#{params.to_query}"
  34 + assert_equal 403, last_response.status
  35 + end
  36 +
  37 + #############################
  38 + # Community Tasks #
  39 + #############################
  40 +
  41 + should 'return task by community' do
  42 + community = fast_create(Community)
  43 + task = create(Task, :requestor => person, :target => community)
  44 + get "/api/v1/communities/#{community.id}/tasks/#{task.id}?#{params.to_query}"
  45 + json = JSON.parse(last_response.body)
  46 + assert_equal task.id, json["task"]["id"]
  47 + end
  48 +
  49 + should 'not return task by community if user has no permission to view it' do
  50 + community = fast_create(Community)
  51 + task = create(Task, :requestor => person, :target => community)
  52 + assert !person.is_member_of?(community)
  53 +
  54 + get "/api/v1/communities/#{community.id}/tasks/#{task.id}?#{params.to_query}"
  55 + assert_equal 403, last_response.status
  56 + end
  57 +
  58 +# should 'not list forbidden article when listing articles by community' do
  59 +# community = fast_create(Community)
  60 +# article = fast_create(Article, :profile_id => community.id, :name => "Some thing", :published => false)
  61 +# assert !article.published?
  62 +#
  63 +# get "/api/v1/communities/#{community.id}/articles?#{params.to_query}"
  64 +# json = JSON.parse(last_response.body)
  65 +# assert_not_includes json['articles'].map {|a| a['id']}, article.id
  66 +# end
  67 +
  68 + should 'create task in a community' do
  69 + community = fast_create(Community)
  70 + give_permission(person, 'post_content', community)
  71 + post "/api/v1/communities/#{community.id}/tasks?#{params.to_query}"
  72 + json = JSON.parse(last_response.body)
  73 + assert_not_nil json["task"]["id"]
  74 + end
  75 +
  76 + should 'do not create article if user has no permission to post content' do
  77 +assert false
  78 +# community = fast_create(Community)
  79 +# give_permission(user.person, 'invite_members', community)
  80 +# params[:article] = {:name => "Title"}
  81 +# post "/api/v1/communities/#{community.id}/articles?#{params.to_query}"
  82 +# assert_equal 403, last_response.status
  83 + end
  84 +
  85 +# should 'create article with parent' do
  86 +# community = fast_create(Community)
  87 +# community.add_member(user.person)
  88 +# article = fast_create(Article)
  89 +#
  90 +# params[:article] = {:name => "Title", :parent_id => article.id}
  91 +# post "/api/v1/communities/#{community.id}/articles?#{params.to_query}"
  92 +# json = JSON.parse(last_response.body)
  93 +# assert_equal article.id, json["article"]["parent"]["id"]
  94 +# end
  95 +
  96 + should 'create task defining the requestor as current profile logged in' do
  97 + community = fast_create(Community)
  98 + community.add_member(person)
  99 +
  100 + post "/api/v1/communities/#{community.id}/tasks?#{params.to_query}"
  101 + json = JSON.parse(last_response.body)
  102 +
  103 + assert_equal person, Task.last.requestor
  104 + end
  105 +
  106 + should 'create task defining the target as the community' do
  107 + community = fast_create(Community)
  108 + community.add_member(person)
  109 +
  110 + post "/api/v1/communities/#{community.id}/tasks?#{params.to_query}"
  111 + json = JSON.parse(last_response.body)
  112 +
  113 + assert_equal community, Task.last.target
  114 + end
  115 +
  116 +# #############################
  117 +# # Person Articles #
  118 +# #############################
  119 +#
  120 +# should 'return article by person' do
  121 +# person = fast_create(Person)
  122 +# article = fast_create(Article, :profile_id => person.id, :name => "Some thing")
  123 +# get "/api/v1/people/#{person.id}/articles/#{article.id}?#{params.to_query}"
  124 +# json = JSON.parse(last_response.body)
  125 +# assert_equal article.id, json["article"]["id"]
  126 +# end
  127 +#
  128 +# should 'not return article by person if user has no permission to view it' do
  129 +# person = fast_create(Person)
  130 +# article = fast_create(Article, :profile_id => person.id, :name => "Some thing", :published => false)
  131 +# assert !article.published?
  132 +#
  133 +# get "/api/v1/people/#{person.id}/articles/#{article.id}?#{params.to_query}"
  134 +# assert_equal 403, last_response.status
  135 +# end
  136 +#
  137 +# should 'not list forbidden article when listing articles by person' do
  138 +# person = fast_create(Person)
  139 +# article = fast_create(Article, :profile_id => person.id, :name => "Some thing", :published => false)
  140 +# assert !article.published?
  141 +# get "/api/v1/people/#{person.id}/articles?#{params.to_query}"
  142 +# json = JSON.parse(last_response.body)
  143 +# assert_not_includes json['articles'].map {|a| a['id']}, article.id
  144 +# end
  145 +#
  146 +# should 'create article in a person' do
  147 +# params[:article] = {:name => "Title"}
  148 +# post "/api/v1/people/#{user.person.id}/articles?#{params.to_query}"
  149 +# json = JSON.parse(last_response.body)
  150 +# assert_equal "Title", json["article"]["title"]
  151 +# end
  152 +#
  153 +# should 'person do not create article if user has no permission to post content' do
  154 +# person = fast_create(Person)
  155 +# params[:article] = {:name => "Title"}
  156 +# post "/api/v1/people/#{person.id}/articles?#{params.to_query}"
  157 +# assert_equal 403, last_response.status
  158 +# end
  159 +#
  160 +# should 'person create article with parent' do
  161 +# article = fast_create(Article)
  162 +#
  163 +# params[:article] = {:name => "Title", :parent_id => article.id}
  164 +# post "/api/v1/people/#{user.person.id}/articles?#{params.to_query}"
  165 +# json = JSON.parse(last_response.body)
  166 +# assert_equal article.id, json["article"]["parent"]["id"]
  167 +# end
  168 +#
  169 +# should 'person create article with content type passed as parameter' do
  170 +# Article.delete_all
  171 +# params[:article] = {:name => "Title"}
  172 +# params[:content_type] = 'TextArticle'
  173 +# post "/api/v1/people/#{user.person.id}/articles?#{params.to_query}"
  174 +# json = JSON.parse(last_response.body)
  175 +#
  176 +# assert_kind_of TextArticle, Article.last
  177 +# end
  178 +#
  179 +# should 'person create article of TinyMceArticle type if no content type is passed as parameter' do
  180 +# params[:article] = {:name => "Title"}
  181 +# post "/api/v1/people/#{user.person.id}/articles?#{params.to_query}"
  182 +# json = JSON.parse(last_response.body)
  183 +#
  184 +# assert_kind_of TinyMceArticle, Article.last
  185 +# end
  186 +#
  187 +# should 'person not create article with invalid article content type' do
  188 +# params[:article] = {:name => "Title"}
  189 +# params[:content_type] = 'Person'
  190 +# post "/api/v1/people/#{user.person.id}/articles?#{params.to_query}"
  191 +# json = JSON.parse(last_response.body)
  192 +#
  193 +# assert_equal 403, last_response.status
  194 +# end
  195 +#
  196 +# should 'person create article defining the correct profile' do
  197 +# params[:article] = {:name => "Title"}
  198 +# post "/api/v1/people/#{user.person.id}/articles?#{params.to_query}"
  199 +# json = JSON.parse(last_response.body)
  200 +#
  201 +# assert_equal user.person, Article.last.profile
  202 +# end
  203 +#
  204 +# should 'person create article defining the created_by' do
  205 +# params[:article] = {:name => "Title"}
  206 +# post "/api/v1/people/#{user.person.id}/articles?#{params.to_query}"
  207 +# json = JSON.parse(last_response.body)
  208 +#
  209 +# assert_equal user.person, Article.last.created_by
  210 +# end
  211 +#
  212 +# should 'person create article defining the last_changed_by' do
  213 +# params[:article] = {:name => "Title"}
  214 +# post "/api/v1/people/#{user.person.id}/articles?#{params.to_query}"
  215 +# json = JSON.parse(last_response.body)
  216 +#
  217 +# assert_equal user.person, Article.last.last_changed_by
  218 +# end
  219 +#
  220 +# #############################
  221 +# # Enterprise Articles #
  222 +# #############################
  223 +#
  224 +# should 'return article by enterprise' do
  225 +# enterprise = fast_create(Enterprise)
  226 +# article = fast_create(Article, :profile_id => enterprise.id, :name => "Some thing")
  227 +# get "/api/v1/enterprises/#{enterprise.id}/articles/#{article.id}?#{params.to_query}"
  228 +# json = JSON.parse(last_response.body)
  229 +# assert_equal article.id, json["article"]["id"]
  230 +# end
  231 +#
  232 +# should 'not return article by enterprise if user has no permission to view it' do
  233 +# enterprise = fast_create(Enterprise)
  234 +# article = fast_create(Article, :profile_id => enterprise.id, :name => "Some thing", :published => false)
  235 +# assert !article.published?
  236 +#
  237 +# get "/api/v1/enterprises/#{enterprise.id}/articles/#{article.id}?#{params.to_query}"
  238 +# assert_equal 403, last_response.status
  239 +# end
  240 +#
  241 +# should 'not list forbidden article when listing articles by enterprise' do
  242 +# enterprise = fast_create(Enterprise)
  243 +# article = fast_create(Article, :profile_id => enterprise.id, :name => "Some thing", :published => false)
  244 +# assert !article.published?
  245 +#
  246 +# get "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  247 +# json = JSON.parse(last_response.body)
  248 +# assert_not_includes json['articles'].map {|a| a['id']}, article.id
  249 +# end
  250 +#
  251 +# should 'create article in a enterprise' do
  252 +# enterprise = fast_create(Enterprise)
  253 +# give_permission(user.person, 'post_content', enterprise)
  254 +# params[:article] = {:name => "Title"}
  255 +# post "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  256 +# json = JSON.parse(last_response.body)
  257 +# assert_equal "Title", json["article"]["title"]
  258 +# end
  259 +#
  260 +# should 'enterprise: do not create article if user has no permission to post content' do
  261 +# enterprise = fast_create(Enterprise)
  262 +# give_permission(user.person, 'invite_members', enterprise)
  263 +# params[:article] = {:name => "Title"}
  264 +# post "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  265 +# assert_equal 403, last_response.status
  266 +# end
  267 +#
  268 +# should 'enterprise: create article with parent' do
  269 +# enterprise = fast_create(Enterprise)
  270 +# enterprise.add_member(user.person)
  271 +# article = fast_create(Article)
  272 +#
  273 +# params[:article] = {:name => "Title", :parent_id => article.id}
  274 +# post "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  275 +# json = JSON.parse(last_response.body)
  276 +# assert_equal article.id, json["article"]["parent"]["id"]
  277 +# end
  278 +#
  279 +# should 'enterprise: create article with content type passed as parameter' do
  280 +# enterprise = fast_create(Enterprise)
  281 +# enterprise.add_member(user.person)
  282 +#
  283 +# Article.delete_all
  284 +# params[:article] = {:name => "Title"}
  285 +# params[:content_type] = 'TextArticle'
  286 +# post "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  287 +# json = JSON.parse(last_response.body)
  288 +#
  289 +# assert_kind_of TextArticle, Article.last
  290 +# end
  291 +#
  292 +# should 'enterprise: create article of TinyMceArticle type if no content type is passed as parameter' do
  293 +# enterprise = fast_create(Enterprise)
  294 +# enterprise.add_member(user.person)
  295 +#
  296 +# params[:article] = {:name => "Title"}
  297 +# post "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  298 +# json = JSON.parse(last_response.body)
  299 +#
  300 +# assert_kind_of TinyMceArticle, Article.last
  301 +# end
  302 +#
  303 +# should 'enterprise: not create article with invalid article content type' do
  304 +# enterprise = fast_create(Enterprise)
  305 +# enterprise.add_member(user.person)
  306 +#
  307 +# params[:article] = {:name => "Title"}
  308 +# params[:content_type] = 'Person'
  309 +# post "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  310 +# json = JSON.parse(last_response.body)
  311 +#
  312 +# assert_equal 403, last_response.status
  313 +# end
  314 +#
  315 +# should 'enterprise: create article defining the correct profile' do
  316 +# enterprise = fast_create(Enterprise)
  317 +# enterprise.add_member(user.person)
  318 +#
  319 +# params[:article] = {:name => "Title"}
  320 +# post "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  321 +# json = JSON.parse(last_response.body)
  322 +#
  323 +# assert_equal enterprise, Article.last.profile
  324 +# end
  325 +#
  326 +# should 'enterprise: create article defining the created_by' do
  327 +# enterprise = fast_create(Enterprise)
  328 +# enterprise.add_member(user.person)
  329 +#
  330 +# params[:article] = {:name => "Title"}
  331 +# post "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  332 +# json = JSON.parse(last_response.body)
  333 +#
  334 +# assert_equal user.person, Article.last.created_by
  335 +# end
  336 +#
  337 +# should 'enterprise: create article defining the last_changed_by' do
  338 +# enterprise = fast_create(Enterprise)
  339 +# enterprise.add_member(user.person)
  340 +#
  341 +# params[:article] = {:name => "Title"}
  342 +# post "/api/v1/enterprises/#{enterprise.id}/articles?#{params.to_query}"
  343 +# json = JSON.parse(last_response.body)
  344 +#
  345 +# assert_equal user.person, Article.last.last_changed_by
  346 +# end
  347 +#
  348 +# should 'list article children with partial fields' do
  349 +# article = fast_create(Article, :profile_id => user.person.id, :name => "Some thing")
  350 +# child1 = fast_create(Article, :parent_id => article.id, :profile_id => user.person.id, :name => "Some thing")
  351 +# params[:fields] = [:title]
  352 +# get "/api/v1/articles/#{article.id}/children?#{params.to_query}"
  353 +# json = JSON.parse(last_response.body)
  354 +# assert_equal ['title'], json['articles'].first.keys
  355 +# end
  356 +#
  357 +# should 'suggest article children' do
  358 +# article = fast_create(Article, :profile_id => user.person.id, :name => "Some thing")
  359 +# params[:target_id] = user.person.id
  360 +# params[:article] = {:name => "Article name", :body => "Article body"}
  361 +# assert_difference "SuggestArticle.count" do
  362 +# post "/api/v1/articles/#{article.id}/children/suggest?#{params.to_query}"
  363 +# end
  364 +# json = JSON.parse(last_response.body)
  365 +# assert_equal 'SuggestArticle', json['type']
  366 +# end
  367 +#
  368 +# should 'suggest event children' do
  369 +# article = fast_create(Article, :profile_id => user.person.id, :name => "Some thing")
  370 +# params[:target_id] = user.person.id
  371 +# params[:article] = {:name => "Article name", :body => "Article body", :type => "Event"}
  372 +# assert_difference "SuggestArticle.count" do
  373 +# post "/api/v1/articles/#{article.id}/children/suggest?#{params.to_query}"
  374 +# end
  375 +# json = JSON.parse(last_response.body)
  376 +# assert_equal 'SuggestArticle', json['type']
  377 +# end
  378 +#
  379 +# should 'update hit attribute of article children' do
  380 +# a1 = fast_create(Article, :profile_id => user.person.id)
  381 +# a2 = fast_create(Article, :parent_id => a1.id, :profile_id => user.person.id)
  382 +# a3 = fast_create(Article, :parent_id => a1.id, :profile_id => user.person.id)
  383 +# get "/api/v1/articles/#{a1.id}/children?#{params.to_query}"
  384 +# json = JSON.parse(last_response.body)
  385 +# assert_equal [1, 1], json['articles'].map { |a| a['hits']}
  386 +# assert_equal [0, 1, 1], [a1.reload.hits, a2.reload.hits, a3.reload.hits]
  387 +# end
  388 +#
  389 +end
... ...