Class: Kogno::Messenger::Notification

Inherits:
Notification show all
Defined in:
lib/core/lib/messenger/notification.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Notification

#answer_callback_query, #answer_inline_query, #confirm, #contact, #document, #html, #html_template, #initialize, #list, #location, #markdown, #match_next_message, #payload, #push_inline_query_result, #raw, #render_html_template, #scheduled, #template, #typing, #whatsapp_template

Constructor Details

This class inherits a constructor from Kogno::Notification

Class Method Details

.rand_text(text) ⇒ Object 



292
293
294
295
296
297
298
 
# File 'lib/core/lib/messenger/notification.rb', line 292

def self.rand_text(text)    
  if text.class == Array
    return(text[rand(text.count)])
  else
    return(text)
  end
end

Instance Method Details

#button(text, buttons, extra_settings = {}) ⇒ Object 



158
159
160
161
162
163
164
165
166
167
 
# File 'lib/core/lib/messenger/notification.rb', line 158

def button(text,buttons,extra_settings={})
  settings = {typed_postbacks: Kogno::Application.config.typed_postbacks}.merge(extra_settings) # defaults
  buttons = buttons.map{|h| {type: :postback}.merge(h)}
  text = t(text) if text.class == Symbol
  text = Notification::rand_text(text)
  set_typed_postbacks(buttons.map{|button|
    [button[:title].to_payload, button[:payload]] if button[:type] == :postback
  }.compact.to_h) if settings[:typed_postbacks]
  self.push_message(Api::button_template(text,buttons))
end

#carousel(elements, quick_replies = [], image_aspect_ratio = :horizontal) ⇒ Object 



207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/core/lib/messenger/notification.rb', line 207

def carousel(elements, quick_replies=[], image_aspect_ratio=:horizontal)
  elements = elements[0..9]
  elements.map do |element| # sharing element: se va a enviar el mismo elemento con los modificadores agregados en :share_contents
    unless element[:buttons].nil?
      element[:buttons].map do |button|
        if button[:type] == :element_share
          share_element = Marshal.load(Marshal.dump(element))
          share_element[:buttons].delete_if{|button| button[:type] == :element_share }
          button[:share_contents] = Api::generic_template(share_element.merge(button[:share_contents]))
        end
      end
    end
  end

  if quick_replies.empty?
    message = Api::generic_template(elements,image_aspect_ratio)
  else
    message = Api::generic_template_with_replies(elements,image_aspect_ratio, quick_replies)
  end
  self.push_message(message)  
end

#delete_messages ⇒ Object 



117
118
119
120
121
 
# File 'lib/core/lib/messenger/notification.rb', line 117

def delete_messages()
  @before_messages = []
  @messages = []
  @after_messages = []
end

#destroy_message_log ⇒ Object 



78
79
80
 
# File 'lib/core/lib/messenger/notification.rb', line 78

def destroy_message_log
  @message_log = []
end

#export_messages ⇒ Object 



109
110
111
112
113
114
115
 
# File 'lib/core/lib/messenger/notification.rb', line 109

def export_messages

  messages = @messages.to_json
  self.delete_messages()
  return messages

end

#get_psid_from_response_log ⇒ Object 



82
83
84
 
# File 'lib/core/lib/messenger/notification.rb', line 82

def get_psid_from_response_log
  return(@response_log.first[:recipient_id] rescue nil)
end

#image(params) ⇒ Object 



249
250
251
252
253
254
255
256
257
258
259
260
261
262
 
# File 'lib/core/lib/messenger/notification.rb', line 249

def image(params)
  params[:image_aspect_ratio] = :horizontal if params[:image_aspect_ratio].nil?

  message = {
    title: params[:caption],
    image_url: params[:url]
  }

  quick_replies = []
  quick_replies = params[:buttons] unless params[:buttons].nil?

  self.messenger_generic_template(message,params[:image_aspect_ratio], quick_replies)

end

#import_messages(messages, position = "") ⇒ Object 



97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/core/lib/messenger/notification.rb', line 97

def import_messages(messages,position="")
  messages = messages.class == Array ? messages : JSON.parse(messages,{:symbolize_names => true})
  case position.to_sym
    when :before
      @before_messages = messages
    when :after
      @after_messages = messages
    else
      @messages = messages
  end
end

#loading_typing_off(recipient_id) ⇒ Object 



133
134
135
 
# File 'lib/core/lib/messenger/notification.rb', line 133

def loading_typing_off(recipient_id)
  Api::send_action(recipient_id,:typing_off)
end

#loading_typing_on(recipient_id) ⇒ Object 



129
130
131
 
# File 'lib/core/lib/messenger/notification.rb', line 129

def loading_typing_on(recipient_id)
  Api::send_action(recipient_id,:typing_on)
end

#location_request(text) ⇒ Object

def opt_out(text, button_label)

self.quick_reply(
  text,
  [
    {
      :content_type => :text,
      :title => button_label,
      :payload => PAYLOADS[:opt_out]
    }
  ]
)

end



337
338
339
340
341
342
343
344
345
346
347
 
# File 'lib/core/lib/messenger/notification.rb', line 337

def location_request(text) # Deprecated by Facebook
  self.quick_reply(
    text,
    [
      {
        :content_type => :location
      }
    ],
    {typed_postbacks: false}
  )
end

#message_log ⇒ Object 



74
75
76
 
# File 'lib/core/lib/messenger/notification.rb', line 74

def message_log
  @message_log
end

#messenger_generic_template(elements, image_aspect_ratio = :horizontal, quick_replies = []) ⇒ Object 



169
170
171
172
173
174
175
176
177
178
 
# File 'lib/core/lib/messenger/notification.rb', line 169

def messenger_generic_template(elements,image_aspect_ratio=:horizontal, quick_replies=[])
  if quick_replies.empty?
    message = Api::generic_template(elements,image_aspect_ratio)
  else
    quick_replies = [quick_replies] if quick_replies.class == Hash
    quick_replies = quick_replies.map{|h| {content_type: :text}.merge(h)}
    message = Api::generic_template_with_replies(elements,image_aspect_ratio, quick_replies)
  end
  self.push_message(message)  
end

#push_message(message, type = :message) ⇒ Object

:message o :action



310
311
312
313
314
 
# File 'lib/core/lib/messenger/notification.rb', line 310

def push_message(message,type=:message) # :message o :action
  new_message = {:type => type, :value => message}
  logger.debug_json new_message, :blue
  @messages << new_message
end

#quick_reply(text, replies, extra_settings = {}) ⇒ Object 



145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/core/lib/messenger/notification.rb', line 145

def quick_reply(text,replies,extra_settings={})
  settings = {typed_postbacks: Kogno::Application.config.typed_postbacks}.merge(extra_settings) # defaults
  replies = [replies] if replies.class == Hash
  replies = replies.map{|h| {content_type: :text}.merge(h)}
  text = t(text) if text.class == Symbol
  text = Notification::rand_text(text)
  replies = replies.map{|r| {title: r[:title], payload: r[:payload], content_type: r[:content_type] || :text}} # :text as default
  set_typed_postbacks(replies.map{|reply|
    [reply[:title].to_payload, reply[:payload]] unless reply[:title].nil?
  }.compact.to_h) if settings[:typed_postbacks]
  self.push_message(Api::quick_replies(text, replies))
end

#recurring_notification_request(request) ⇒ Object 



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'lib/core/lib/messenger/notification.rb', line 229

def recurring_notification_request(request)

  attachment = {
    type: :template,
    payload: {
      template_type: :notification_messages, 
      title: request[:title],
      notification_messages_frequency: request[:frequency].to_s.upcase,
      notification_messages_reoptin: request[:reoptin] ? "ENABLED" : "DISABLED",
    }
  }

  attachment[:payload][:image_url] = request[:image_url] unless request[:image_url].nil?
  attachment[:payload][:payload] = request[:payload] unless request[:payload].nil?
  attachment[:payload][:notification_messages_timezone] = request[:timezone] unless request[:timezone].nil?

  self.push_message(Api.attachment_message(attachment))

end

#replace_place_holders(message) ⇒ Object 



301
302
303
304
305
306
307
 
# File 'lib/core/lib/messenger/notification.rb', line 301

def replace_place_holders(message)
  message_in_json = message.to_json
  @vars.each do |place_holder,replacement_value|
   message_in_json = message_in_json.gsub(":::#{place_holder}:::",replacement_value.to_s)
  end
  JSON.parse(message_in_json)
end

#response_log ⇒ Object 



70
71
72
 
# File 'lib/core/lib/messenger/notification.rb', line 70

def response_log
  @response_log
end

#send(messaging_type = "RESPONSE", recipient_id = nil, page_id = nil, delete = true) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/core/lib/messenger/notification.rb', line 9

def send(messaging_type="RESPONSE",recipient_id=nil,page_id=nil,delete=true)
  recipient_id = @recipient.psid if recipient_id.nil?
  page_id = @recipient.page_id if page_id.nil?
  messages = @before_messages+@messages+@after_messages
  @message_log = messages
  messages.each do |message|
    if message[:type].to_sym == :action
      @response_log << Api::send_action(recipient_id,message[:value][:action],messaging_type,page_id)
      sleep(message[:value][:duration]) if message[:value][:action].to_sym == :typing_on
    else
      message = self.replace_place_holders(message[:value])
      @response_log << Api::send_message(recipient_id,message,messaging_type,page_id)
    end
  end    
  self.delete_messages() if delete
end

#send_multiple(users, messaging_type) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
 
# File 'lib/core/lib/messenger/notification.rb', line 86

def send_multiple(users,messaging_type)
  logger.write "Sending..", :green
  logger.write_json @messages, :bright
  logger.write "To:", :green
  users.each do |user|
    logger.write "PSID: #{user[:psid]}", :bright
    send(messaging_type,user[:psid],user[:page_id],false)
  end
  self.delete_messages()
end

#send_private_reply(recipient_id = nil, page_id = nil, delete = true) ⇒ Object

def schedule(send_at, tag=nil)

unless @recipient.nil?
  @recipient.scheduled_messages.create({
    messages: @messages.to_json,
    tag: tag,
    send_at: send_at
  })
  self.delete_messages()
end

end



59
60
61
62
63
64
65
66
67
68
 
# File 'lib/core/lib/messenger/notification.rb', line 59

def send_private_reply(recipient_id=nil,page_id=nil,delete=true)
  response = []
  recipient_id = @recipient.psid if recipient_id.nil?
  @message_log = @messages
  @messages.each do |message|
    message = self.replace_place_holders(message[:value])
    @response_log << Api::send_private_reply(recipient_id,message,page_id)
  end
  self.delete_messages() if delete
end

#send_using_token ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/core/lib/messenger/notification.rb', line 26

def send_using_token()
  notification_token = @recipient.messenger_recurring_notification.token rescue nil
  if notification_token.nil?
    logger.write "Error. The user doesn't have a messenger recurring notification token", :red
    return false
  end
  page_id = @recipient.page_id if page_id.nil?
  messages = @before_messages+@messages+@after_messages
  @message_log = messages
  messages.each do |message|
    if message[:type].to_sym == :action
      # @response_log << Api::send_action(recipient_id,message[:value][:action],messaging_type,page_id)
      sleep(message[:value][:duration]) if message[:value][:action].to_sym == :typing_on
    else
      message = self.replace_place_holders(message[:value])
      @response_log << Api::send_message_with_rn_token(notification_token,message,page_id)
    end
  end    
  self.delete_messages()
end

#set_context(context) ⇒ Object 



5
6
7
 
# File 'lib/core/lib/messenger/notification.rb', line 5

def set_context(context)
  @context = context
end

#set_typed_postbacks(typed_postbacks) ⇒ Object 



317
318
319
320
 
# File 'lib/core/lib/messenger/notification.rb', line 317

def set_typed_postbacks(typed_postbacks)
  @recipient.vars[:typed_postbacks] = {} if @recipient.vars[:typed_postbacks].nil?
  @recipient.vars[:typed_postbacks] = @recipient.vars[:typed_postbacks].merge(typed_postbacks)
end

#set_vars(vars) ⇒ Object 



288
289
290
 
# File 'lib/core/lib/messenger/notification.rb', line 288

def set_vars(vars)
  @vars = @vars.merge(vars)
end

#text(text, extra_params = {}) ⇒ Object 



123
124
125
126
127
 
# File 'lib/core/lib/messenger/notification.rb', line 123

def text(text, extra_params={})
  text = t(text) if text.class == Symbol
  text = Notification::rand_text(text)
  self.push_message(Api::text_message(text))
end

#typing_off ⇒ Object 



141
142
143
 
# File 'lib/core/lib/messenger/notification.rb', line 141

def typing_off
  self.push_message({:action => :typing_off}, :action)
end

#typing_on(duration) ⇒ Object 



137
138
139
 
# File 'lib/core/lib/messenger/notification.rb', line 137

def typing_on(duration)
  self.push_message({:action => :typing_on, :duration => duration}, :action)
end

#url(params) ⇒ Object 



180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/core/lib/messenger/notification.rb', line 180

def url(params)
  params[:messenger_extensions] = false if params[:messenger_extensions].nil?
  params[:image_aspect_ratio] = :horizontal if params[:image_aspect_ratio].nil?

  ge_params = {
    title: params[:title],
    image_url: params[:image],
    default_action: {
      type: :web_url,
      url: params[:url],
      messenger_extensions: params[:messenger_extensions]
    }
  }

  ge_params[:buttons] =  [
    {
      type: :web_url,
      url: params[:url],
      title: params[:button],
      messenger_extensions: params[:messenger_extensions]
    }
  ] unless params[:button].nil?

  self.messenger_generic_template(ge_params,params[:image_aspect_ratio])
end

#video(params) ⇒ Object 



264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
 
# File 'lib/core/lib/messenger/notification.rb', line 264

def video(params)

  message = {
    type: :template,
    payload: {
        template_type: :media,
        elements: [
          {
              media_type: :video,
              url: params[:url]
          }
       ]
    }
  } 

  unless params[:buttons].nil?
    buttons = params[:buttons].class == Hash ? [params[:buttons]] : params[:buttons]
    buttons.map{|button| {type: :postback}.merge(button)}
    message[:payload][:elements][0][:buttons] = buttons
  end

  Api::attachment_message(message)
end