Class: Api::V1::BizTxnTypesController

Inherits:
BaseController
  • Object
show all
Defined in:
app/controllers/api/v1/biz_txn_types_controller.rb

Instance Method Summary collapse

Instance Method Details

#create ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'app/controllers/api/v1/biz_txn_types_controller.rb', line 96

def create
  description = params[:description].strip

  begin

    ActiveRecord::Base.transaction do
      biz_txn_type = BizTxnType.create(description: description, internal_identifier: description.to_iid)

      if !params[:parent].blank? and params[:parent] != 'No Parent'
        parent = BizTxnType.iid(params[:parent])
        biz_txn_type.move_to_child_of(parent)
      elsif !params[:default_parent].blank?
        parent = BizTxnType.iid(params[:default_parent])
        biz_txn_type.move_to_child_of(parent)
      end

      render :json => {success: true, biz_txn_type: biz_txn_type.to_hash(only: [:id, :description, :internal_identifier])}
    end

  rescue ActiveRecord::RecordInvalid => invalid
    Rails.logger.error invalid.record.errors.full_messages

    {:success => false, :message => invalid.record.errors.full_messages.join('</br>')}
  rescue => ex
    Rails.logger.error ex.message
    Rails.logger.error ex.backtrace.join("\n")

    ExceptionNotifier.notify_exception(ex) if defined? ExceptionNotifier

    {:success => false, :message => "Error creating record"}
  end
end

#index ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'app/controllers/api/v1/biz_txn_types_controller.rb', line 5

def index
  if !params[:parent].blank?
    parent = nil
    # create parent if it doesn't exist
    # if the parent param is a comma separated string then
    # the parent is nested from left to right
    params[:parent].split(',').each do |parent_iid|
      if parent
        parent = BizTxnType.find_or_create(parent_iid, parent_iid.humanize, parent)
      else
        parent = BizTxnType.find_or_create(parent_iid, parent_iid.humanize)
      end
    end

    respond_to do |format|
      format.tree do
        render :json => {success: true, biz_txn_types: parent.children_to_tree_hash}
      end
      format.json do
        render :json => {success: true, biz_txn_types: BizTxnType.to_all_representation(parent)}
      end
    end

    # if ids are passed look up on the txn types with the ids passed
  elsif params[:ids]
    ids = params[:ids].split(',').compact

    biz_txn_types = []

    ids.each do |id|
      # check if id is a integer if so fine by id
      if id.is_integer?
        biz_txn_type = BizTxnType.find(id)
      else
        biz_txn_type = BizTxnType.iid(id)
      end

      if biz_txn_type
        respond_to do |format|
          format.tree do
            data = biz_txn_type.to_hash({
                                          only: [:id, :parent_id, :internal_identifier, :description],
                                          leaf: biz_txn_type.leaf?,
                                          text: biz_txn_type.to_label,
                                          children: []
            })

            parent = nil
            biz_txn_types.each do |biz_txn_type_hash|
              if biz_txn_type_hash[:id] == data[:parent_id]
                parent = biz_txn_type_hash
              end
            end

            if parent
              parent[:children].push(data)
            else
              biz_txn_types.push(data)
            end
          end
          format.json do
            biz_txn_types.push(biz_txn_type.to_hash(only: [:id, :description, :internal_identifier]))
          end
        end
      end
    end

    render :json => {success: true, biz_txn_types: biz_txn_types}

    # get all txn types
  else

    respond_to do |format|
      format.tree do
        nodes = [].tap do |nodes|
          BizTxnType.roots.each do |root|
            nodes.push(root.to_tree_hash)
          end
        end

        render :json => {success: true, biz_txn_types: nodes}
      end
      format.json do
        render :json => {success: true, biz_txn_types: BizTxnType.to_all_representation}
      end
    end

  end

end