summaryrefslogtreecommitdiff
path: root/misc/freeswitch/scripts/common/conference.lua
blob: 423d5644d23fe07fefc61366a207c15bf42c77ab (plain)
1
2
3
4
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
95
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
-- Gemeinschaft 5 module: conference class
-- (c) AMOOMA GmbH 2013
-- 

module(...,package.seeall)

Conference = {}

-- create conference object
function Conference.new(self, arg)
  arg = arg or {}
  object = arg.object or {}
  setmetatable(object, self);
  self.__index = self;
  self.class = 'conference';
  self.log = arg.log;
  self.database = arg.database;
  self.record = arg.record;
  return object;
end


function Conference.settings_get(self)
  require 'common.array';
  require 'common.configuration_table';

  local configuration = common.configuration_table.get(self.database, 'conferences');
  if not configuration then
    return nil;
  end

  local parameters = configuration.parameters or {};
  local settings = configuration.settings or {};
  local sounds = configuration.sounds or {};

  settings.members_max = settings.members_max or tonumber(parameters['max-members']) or 100;
  settings.pin_length_max = tonumber(settings.pin_length_max) or 10;
  settings.pin_length_min = tonumber(settings.pin_length_min) or 2;
  settings.pin_timeout = tonumber(settings.pin_timeout) or 4000;
  settings.announcement_max_length = tonumber(settings.announcement_max_length) or 10;
  settings.announcement_silence_threshold = tonumber(settings.announcement_silence_threshold) or 500;
  settings.announcement_silence_length = tonumber(settings.announcement_silence_length) or 3;
  settings.flags = settings.flags or { waste = true };
  sounds.pin = sounds.pin or 'conference/conf-pin.wav';
  sounds.has_joined = sounds.has_joined or 'conference/conf-has_joined.wav';
  sounds.has_left = sounds.has_left or 'conference/conf-has_left.wav';
  sounds.alone = sounds.has_alone or 'conference/conf-alone.wav';

  settings.key_enter = parameters.key_enter or '#';
  settings.spool_dir = settings.spool_dir or '/var/spool/freeswitch';
  return settings, sounds;
end


function Conference.find_sql(self, sql_query)
  local conference = nil;

  self.database:query(sql_query, function(conference_entry)
    conference = Conference:new(self);
    conference.record = conference_entry;
    conference.id = tonumber(conference_entry.id);
    conference.identifier = 'conference' .. conference.id;
    conference.uuid = conference_entry.uuid;
    conference.pin = conference_entry.pin;
    conference.open_for_public = common.str.to_b(conference_entry.open_for_anybody);
    conference.announce_entering = common.str.to_b(conference_entry.announce_new_member_by_name);
    conference.announce_leaving = common.str.to_b(conference_entry.announce_left_member_by_name);
    if not common.str.blank(conference_entry.open_now) then
      conference.open_now = common.str.to_b(conference_entry.open_now);
    end

    conference.settings, conference.sounds = self:settings_get();
    if conference.settings then
      conference.settings.members_max = tonumber(conference.record.max_members) or conference.settings.members_max;
    else
      conference.log:error('CONFERENCE - no basic configuration');
    end
  end)
  
  return conference; 
end


function Conference.find_by_id(self, id)
  return self:find_sql('SELECT *, (NOW() >= `start` AND NOW() <= `end`) AS `open_now` FROM `conferences` WHERE `id`= ' .. tonumber(id) .. '  LIMIT 1');
end


function Conference.find_by_uuid(self, uuid)
  return self:find_sql('SELECT *, (NOW() >= `start` AND NOW() <= `end`) AS `open_now` FROM `conferences` WHERE `uuid`= ' .. self.database:escape(uuid, '"') .. '  LIMIT 1');
end


function Conference.find_invitee_by_numbers(self, phone_numbers)
  if not self.record then 
    return false;
  end

  local sql_query = 'SELECT `a`.* \
    FROM `conference_invitees` `a` \
    JOIN `phone_numbers` `b` ON `b`.`phone_numberable_id` = `a`.`id` \
    WHERE `b`.`phone_numberable_type` = "ConferenceInvitee" \
    AND `a`.`conference_id` = ' .. self.id .. ' \
    AND `b`.`number` IN ("' .. table.concat(phone_numbers, "','") .. '") \
    LIMIT 1';
  
  local invitee = nil;

  self.database:query(sql_query, function(invitee_entry)
    invitee = invitee_entry;
  end)

  return invitee;
end


function Conference.members_count(self)
  return tonumber(self.caller:result('conference ' .. self.identifier .. ' list count')) or 0;
end


function Conference.check_pin(self, pin)
  local digits = '';
  for i = 1, 3 do
    if digits == pin then
      self.caller:send_display('PIN: OK');
      break
    elseif digits ~= "" then
      self.caller:send_display('PIN: wrong');
      self.caller.session:sayPhrase('conference_bad_pin');
    end
    self.caller:send_display('Enter PIN');
    digits = self.caller.session:read(self.settings.pin_length_min, self.settings.pin_length_max, self.sounds.pin, self.settings.pin_timeout, self.settings.key_enter);
  end

  if digits ~= pin then
    return false
  end

  return true;
end


function Conference.check_ownership(self, check_caller)
  local owner = nil;

  if check_caller then
    owner = common.array.try(self.caller, 'account.owner');
  else
    owner = common.array.try(self.caller, 'auth_account.owner');
  end
  if not owner then
    return false;
  end

  if tonumber(self.record.conferenceable_id) == owner.id and self.record.conferenceable_type:lower() == owner.class then
    return true;
  end
end


function Conference.account_name_file(self)
  if not self.caller.account or tostring(self.caller.account.class):lower() ~= 'sipaccount' then
    return;
  end

  require 'dialplan.voicemail'
  local voicemail_account = dialplan.voicemail.Voicemail:new{ log = self.log, database = self.database }:find_by_sip_account_id(self.caller.account.id);
  if voicemail_account and not common.str.blank(voicemail_account.record.name_path) then
    self.log:debug('CONFERENCE ', self.id, ' - caller_name_file: ', voicemail_account.record.name_path);
    return voicemail_account.record.name_path;
  end
end


function Conference.record_name(self)
  self.caller:send_display('Record name');
  local name_file = self.settings.spool_dir .. '/conference_caller_name_' .. self.caller.uuid .. '.wav';
  self.caller.session:sayPhrase('conference_record_name');
  self.caller.session:recordFile(name_file, self.settings.announcement_max_length, self.settings.announcement_silence_threshold, self.settings.announcement_max_length);
  self.caller:send_display('Playback name');
  self.caller:playback(name_file);

  return name_file;
end


function Conference.playback(self, ...)
  local sound_files = {...};
  for index=1, #sound_files do
    self.caller:execute('set',"result=${conference(" .. self.identifier .. " play ".. tostring(sound_files[index]) .. ")}");
  end
end

function Conference.phrase(self, phrase, file_name)
  self.caller:execute('set',"result=${conference(" .. self.identifier .. " phrase ".. phrase .. ':' .. file_name .. ")}");
end

function Conference.enter(self, caller, domain)
  self.caller = caller;
  local members = self:members_count();

  self.log:info('CONFERENCE ', self.id, ' - open_for_public: ', self.open_for_public, ', open_now: ', self.open_now, ', members: ', members, ', members_max: ', self.settings.members_max);

  if self.open_now == false then
    self.log:notice('CONFERENCE ', self.id, ' - currently closed, start: ', self.record.start, ', end: ', self.record['end']);
    return { continue = false, code = 493, phrase = 'Conference closed' };
  end

  if members >= self.settings.members_max then
    self.log:notice('CONFERENCE ', self.id, ' - full, members: ', members, ', members_max: ', self.settings.members_max);
    return { continue = false, code = 493, phrase = 'Conference closed' };
  end

  local invitee = self:find_invitee_by_numbers(caller.caller_phone_numbers);
  if invitee then
    if common.str.to_b(invitee.speaker) then
      self.settings.flags.mute = nil;
    end
    if common.str.to_b(invitee.moderator) then
      self.settings.flags.moderator = true;
    end
    self.log:info('CONFERENCE ', self.id, ' - invitee=', invitee.id, '/', invitee.uuid, ', speaker: ', not self.settings.flags.mute, ', moderator: ', self.settings.flags.moderator);
    self.pin = invitee.pin;
  elseif self:check_ownership() then
    self.pin = nil;
    local caller_owner = false;
    if self:check_ownership(true) then
      self.settings.flags.moderator = true;
      self.settings.flags.dtmf = true;
      caller_owner = true;
    end
    self.log:info('CONFERENCE ', self.id, ' - owner authenticated: ', self.caller.auth_account.owner.class,'=', self.caller.auth_account.owner.id, '/', self.caller.auth_account.owner.uuid, ', owner: ', caller_owner, ', speaker: ', not self.settings.flags.mute, ', moderator: ', self.settings.flags.moderator);
  elseif not self.open_for_public then
    self.log:notice('CONFERENCE ', self.id, ' - not open for public');
    return { continue = false, code = 493, phrase = 'Conference closed' };
  end

  caller:answer();
  if not common.str.blank(self.pin) and not self:check_pin(self.pin) then
    self.log:notice('CONFERENCE ', self.id, ' - PIN wrong');
    caller.session:sayPhrase('conference_goodbye');
    return { continue = false, code = 493, phrase = 'Not authorized' };
  end

  self.caller:send_display(tostring(self.record.name) .. ', members: ' .. tostring(members));
  caller:sleep(1000);
  caller.session:sayPhrase('conference_welcome');


  local name_file = nil;
  local name_file_delete = nil;

  if self.announce_entering or self.announce_leaving then
    name_file = self:account_name_file();
    if not name_file then
      name_file = self:record_name(caller);
      name_file_delete = true;
    end
  end

  members = self:members_count();
  if self.announce_entering and name_file then
    if members > 0 then
      self:playback(name_file, self.sounds.has_joined);
    end
  end

  if members == 0 then 
    caller.session:sayPhrase('conference_alone');
  end

  self.caller:send_display(tostring(self.record.name));
  local result =  caller:execute('conference', self.identifier .. "@profile_" .. self.identifier .. "++flags{" .. common.array.keys_to_s(self.settings.flags, '|') .. "}");
  
  self.caller:send_display('Goodbye');
  caller.session:sayPhrase('conference_goodbye');

  if name_file then
    if self.announce_leaving then
      members = self:members_count();
      if members > 0 then
        self:playback(name_file, self.sounds.has_left);
        if members == 1 then 
          self:playback(self.sounds.alone);
        end
      end
    end
    if name_file_delete then
      os.remove(name_file);
    end
  end

  return { continue = false, code = 200, phrase = 'OK' }
end