Module: OpenStax::Api::Roar

Included in:
V1::ApiController
Defined in:
lib/openstax/api/roar.rb

Instance Method Summary collapse

Instance Method Details

#render_api_errors(errors, status = :unprocessable_entity) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/openstax/api/roar.rb', line 113

def render_api_errors(errors, status = :unprocessable_entity)
  hash = {status: Rack::Utils.status_code(status)}
  case errors
  when ActiveModel::Errors, Lev::BetterActiveModelErrors
    hash[:errors] = []
    errors.each do |attribute, message|
      hash[:errors] << {
        code: "#{attribute.to_s}_#{
                message.to_s.gsub(/[\s-]/, '_').gsub(/[^\w]/, '')
              }",
        message: errors.full_message(attribute, message)
      }
    end
  when Lev::Errors
    hash[:errors] = errors.collect do |error|
      {code: error.code, message: error.message, data: error.data}
    end
  else
    hash[:errors] = [errors].flatten.collect do |error|
      {code: error.to_s}
    end
  end
  render json: hash, status: status
end

#standard_create(model, represent_with = nil) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/openstax/api/roar.rb', line 24

def standard_create(model, represent_with=nil)
  model.class.transaction do
    consume!(model, represent_with: represent_with)
    yield model if block_given?
    OSU::AccessPolicy.require_action_allowed!(:create,
                                              current_api_user,
                                              model)

    if model.save
      respond_with model, represent_with: represent_with,
                          status: :created
    else
      render_api_errors(model.errors)
    end
  end
end

#standard_destroy(model) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/openstax/api/roar.rb', line 71

def standard_destroy(model)
  OSU::AccessPolicy.require_action_allowed!(:destroy,
                                            current_api_user,
                                            model)
  
  if model.destroy
    head :no_content
  else
    render_api_errors(model.errors)
  end
end

#standard_index(relation, represent_with) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/openstax/api/roar.rb', line 83

def standard_index(relation, represent_with)
  model_klass = relation.base_class
  OSU::AccessPolicy.require_action_allowed!(:index,
                                            current_api_user,
                                            model_klass)
  relation.each do |item|
    # Must be able to read each record
    OSU::AccessPolicy.require_action_allowed!(:read,
                                              current_api_user,
                                              item)
  end
  respond_with(Lev::Outputs.new(items: relation),
               represent_with: represent_with)
end

#standard_nested_create(model, container_association, container, represent_with = nil) ⇒ Object 



102
103
104
105
106
107
108
109
110
111
 
# File 'lib/openstax/api/roar.rb', line 102

def standard_nested_create(model, container_association,
                           container, represent_with=nil)
  # Must be able to update the container
  OSU::AccessPolicy.require_action_allowed!(:update,
                                            current_api_user,
                                            container)
  model.send("#{container_association.to_s}=", container)

  standard_create(model, represent_with)
end

#standard_read(model, represent_with = nil) ⇒ Object 



41
42
43
44
45
46
 
# File 'lib/openstax/api/roar.rb', line 41

def standard_read(model, represent_with=nil)
  OSU::AccessPolicy.require_action_allowed!(:read,
                                            current_api_user,
                                            model)
  respond_with model, represent_with: represent_with
end

#standard_search(model, routine, represent_with, options = {}) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/openstax/api/roar.rb', line 12

def standard_search(model, routine, represent_with, options={})
  user = current_api_user
  OSU::AccessPolicy.require_action_allowed!(:search, user, model)
  result = routine.call(params)
  return render_api_errors(result.errors) if result.errors.any?
  outputs = result.outputs
  outputs[:items].each do |item|
    OSU::AccessPolicy.require_action_allowed!(:read, user, item)
  end
  respond_with outputs, represent_with: represent_with
end

#standard_sort(*args) ⇒ Object

Raises:

  • (NotYetImplemented) 


98
99
100
 
# File 'lib/openstax/api/roar.rb', line 98

def standard_sort(*args)
  raise NotYetImplemented
end

#standard_update(model, represent_with = nil) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/openstax/api/roar.rb', line 48

def standard_update(model, represent_with=nil)
  # Must be able to update the record before and after the update itself
  OSU::AccessPolicy.require_action_allowed!(:update,
                                            current_api_user,
                                            model)

  model.class.transaction do
    consume!(model, represent_with: represent_with)
    yield model if block_given?
    OSU::AccessPolicy.require_action_allowed!(:update,
                                              current_api_user,
                                              model)
  
    if model.save
      # http://stackoverflow.com/a/27413178
      respond_with model, represent_with: represent_with,
                          responder: ResponderWithPutContent
    else
      render_api_errors(model.errors)
    end
  end
end