applications/luci-pbx/luasrc/model/cbi/pbx-calls.lua

   1 --[[
   2     Copyright 2011 Iordan Iordanov <iiordanov (AT) gmail.com>
   3
   4     This file is part of luci-pbx.
   5
   6     luci-pbx is free software: you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation, either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     luci-pbx is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with luci-pbx.  If not, see <http://www.gnu.org/licenses/>.
  18 ]]--
  19
  20 if     nixio.fs.access("/etc/init.d/asterisk")   then
  21    server = "asterisk"
  22 elseif nixio.fs.access("/etc/init.d/freeswitch") then
  23    server = "freeswitch"
  24 else
  25    server = ""
  26 end
  27
  28 modulename       = "pbx-calls"
  29 voipmodulename   = "pbx-voip"
  30 googlemodulename = "pbx-google"
  31 usersmodulename  = "pbx-users"
  32 validoutaccounts = {}
  33 allvalidusers    = {}
  34
  35 -- Checks whether the entered extension is valid syntactically.
  36 function is_valid_extension(exten)
  37    return (exten:match("[#*+0-9NXZ]+$") ~= nil)
  38 end
  39
  40
  41 m = Map (modulename, translate("Call Routing"),
  42          translate("This is where you indicate which Google/SIP accounts are used to call what \
  43                    country/area codes, which users can use which SIP/Google accounts, how incoming\
  44                    calls are routed, what numbers can get into this PBX with a password, and what\
  45                    numbers are blacklisted."))
  46
  47 -- Recreate the config, and restart services after changes are commited to the configuration.
  48 function m.on_after_commit(self)
  49         luci.sys.call("/etc/init.d/pbx-" .. server .. " restart 1\>/dev/null 2\>/dev/null")
  50         luci.sys.call("/etc/init.d/"     .. server .. " restart 1\>/dev/null 2\>/dev/null")
  51 end
  52
  53 ----------------------------------------------------------------------------------------------------
  54 s = m:section(NamedSection, "outgoing_calls", "call_routing", translate("Outgoing Calls"),
  55         translate("If you have more than one account which can make outgoing calls, you\
  56                 should enter a list of phone numbers and prefixes in the following fields for each\
  57                 provider listed. Invalid prefixes are removed silently, and only 0-9, X, Z, N, #, *,\
  58                 and + are valid characters. The letter X matches 0-9, Z matches 1-9, and N matches 2-9.\
  59                 For example to make calls to Germany through a provider, you can enter 49. To make calls\
  60                 to North America, you can enter 1NXXNXXXXXX. If one of your providers can make \"local\"\
  61                 calls to an area code like New York's 646, you can enter 646NXXXXXX for that\
  62                 provider. You should leave one account with an empty list to make calls with\
  63                 it by default, if no other provider's prefixes match. The system will automatically\
  64                 replace an empty list with a message that the provider dials all numbers. Be as specific as\
  65                 possible (i.e. 1NXXNXXXXXX is better than 1). Please note all international dial codes\
  66                 are discarded (e.g. 00, 011, 010, 0011). Entries can be made in a space-separated\
  67                 list, and/or one per line by hitting enter after every one."))
  68 s.anonymous = true
  69
  70 m.uci:foreach(googlemodulename, "gtalk_jabber",
  71               function(s1)
  72                  if s1.username ~= nil and s1.name ~= nil and
  73                     s1.make_outgoing_calls == "yes" then
  74                     patt = s:option(DynamicList, s1.name, s1.username)
  75
  76                     -- Add provider to the associative array of valid accounts.
  77                     validoutaccounts[s1.name] = s1.username
  78
  79                     -- If the saved field is empty, we return a string
  80                     -- telling the user that this account would dial any exten.
  81                     function patt.cfgvalue(self, section)
  82                        value = self.map:get(section, self.option)
  83
  84                        if value == nil then
  85                           return {"Dials any number"}
  86                        else
  87                           return value
  88                        end
  89                     end
  90
  91                     -- Write only valid extensions into the config file.
  92                     function patt.write(self, section, value)
  93                        newvalue = {}
  94                        nindex = 1
  95                        for index, field in ipairs(value) do
  96                           val = luci.util.trim(value[index])
  97                           if is_valid_extension(val) == true then
  98                              newvalue[nindex] = val
  99                              nindex = nindex + 1
 100                           end
 101                        end
 102                        DynamicList.write(self, section, newvalue)
 103                     end
 104                  end
 105               end)
 106
 107 m.uci:foreach(voipmodulename, "voip_provider",
 108               function(s1)
 109                  if s1.defaultuser ~= nil and s1.host ~= nil and
 110                     s1.name ~= nil        and s1.make_outgoing_calls == "yes" then
 111                     patt = s:option(DynamicList, s1.name, s1.defaultuser .. "@" .. s1.host)
 112
 113                     -- Add provider to the associative array of valid accounts.
 114                     validoutaccounts[s1.name] = s1.defaultuser .. "@" .. s1.host
 115
 116                     -- If the saved field is empty, we return a string
 117                     -- telling the user that this account would dial any exten.
 118                     function patt.cfgvalue(self, section)
 119                        value = self.map:get(section, self.option)
 120
 121                        if value == nil then
 122                           return {"Dials any number"}
 123                        else
 124                           return value
 125                        end
 126                     end
 127
 128                     -- Write only valid extensions into the config file.
 129                     function patt.write(self, section, value)
 130                        newvalue = {}
 131                        nindex = 1
 132                        for index, field in ipairs(value) do
 133                           val = luci.util.trim(value[index])
 134                           if is_valid_extension(val) == true then
 135                              newvalue[nindex] = val
 136                              nindex = nindex + 1
 137                           end
 138                        end
 139                        DynamicList.write(self, section, newvalue)
 140                     end
 141                  end
 142               end)
 143
 144 ----------------------------------------------------------------------------------------------------
 145 s = m:section(NamedSection, "incoming_calls", "call_routing", translate("Incoming Calls"),
 146         translate("For each provider that receives calls, here you can restrict which users to ring\
 147                 on incoming calls. If the list is empty, the system will indicate that all users\
 148                 which are enabled for incoming calls will ring. Invalid usernames will be rejected\
 149                 silently. Also, entering a username here overrides the user's setting to not receive\
 150                 incoming calls, so this way, you can make users ring only for select providers.\
 151                 Entries can be made in a space-separated list, and/or one per\
 152                 line by hitting enter after every one."))
 153 s.anonymous = true
 154
 155 m.uci:foreach(googlemodulename, "gtalk_jabber",
 156               function(s1)
 157                  if s1.username ~= nil and s1.register == "yes" then
 158                     field_name=string.gsub(s1.username, "%W", "_")
 159                     gtalkaccts = s:option(DynamicList, field_name, s1.username)
 160
 161                     -- If the saved field is empty, we return a string
 162                     -- telling the user that this account would dial any exten.
 163                     function gtalkaccts.cfgvalue(self, section)
 164                        value = self.map:get(section, self.option)
 165
 166                        if value == nil then
 167                           return {"Rings all users"}
 168                        else
 169                           return value
 170                        end
 171                     end
 172
 173                     -- Write only valid user names.
 174                     function gtalkaccts.write(self, section, value)
 175                        newvalue = {}
 176                        nindex = 1
 177                        for index, field in ipairs(value) do
 178                           trimuser = luci.util.trim(value[index])
 179                           if allvalidusers[trimuser] == true then
 180                              newvalue[nindex] = trimuser
 181                              nindex = nindex + 1
 182                           end
 183                        end
 184                        DynamicList.write(self, section, newvalue)
 185                     end
 186                  end
 187               end)
 188
 189
 190 m.uci:foreach(voipmodulename, "voip_provider",
 191               function(s1)
 192                  if s1.defaultuser ~= nil and s1.host ~= nil and s1.register == "yes" then
 193                     field_name=string.gsub(s1.defaultuser .. "_" .. s1.host, "%W", "_")
 194                     voipaccts = s:option(DynamicList, field_name, s1.defaultuser .. "@" .. s1.host)
 195
 196                     -- If the saved field is empty, we return a string
 197                     -- telling the user that this account would dial any exten.
 198                     function voipaccts.cfgvalue(self, section)
 199                        value = self.map:get(section, self.option)
 200
 201                        if value == nil then
 202                           return {"Rings all users"}
 203                        else
 204                           return value
 205                        end
 206                     end
 207
 208                     -- Write only valid user names.
 209                     function voipaccts.write(self, section, value)
 210                        newvalue = {}
 211                        nindex = 1
 212                        for index, field in ipairs(value) do
 213                           trimuser = luci.util.trim(value[index])
 214                           if allvalidusers[trimuser] == true then
 215                              newvalue[nindex] = trimuser
 216                              nindex = nindex + 1
 217                           end
 218                        end
 219                        DynamicList.write(self, section, newvalue)
 220                     end
 221                  end
 222               end)
 223
 224 ----------------------------------------------------------------------------------------------------
 225 s = m:section(NamedSection, "providers_user_can_use", "call_routing",
 226       translate("Providers Used for Outgoing Calls"),
 227       translate("If you would like, you could restrict which providers users are allowed to use for outgoing\
 228         calls. By default all users can use all providers. To show up in the list below the user should\
 229         be allowed to make outgoing calls in the \"User Accounts\" page. Enter VoIP providers in the format\
 230         username@some.host.name, as listed in \"Outgoing Calls\" above. It's easiest to copy and paste\
 231         the providers from above. Invalid entries will be rejected silently. Entries can be made in a \
 232         space-separated list, and/or one per line by hitting enter after every one."))
 233 s.anonymous = true
 234
 235 m.uci:foreach(usersmodulename, "local_user",
 236               function(s1)
 237                  -- Add user to list of all valid users.
 238                  if s1.defaultuser ~= nil then allvalidusers[s1.defaultuser] = true end
 239
 240                  if s1.defaultuser ~= nil and s1.can_call == "yes" then
 241                     providers = s:option(DynamicList, s1.defaultuser, s1.defaultuser)
 242
 243                     -- If the saved field is empty, we return a string
 244                     -- telling the user that this account would dial any exten.
 245                     function providers.cfgvalue(self, section)
 246                        value = self.map:get(section, self.option)
 247
 248                        if value == nil then
 249                           return {"Uses all provider accounts"}
 250                        else
 251                           newvalue = {}
 252                           -- Convert internal names to user@host values.
 253                           for i,v in ipairs(value) do
 254                              newvalue[i] = validoutaccounts[v]
 255                           end
 256                           return newvalue
 257                        end
 258                     end
 259
 260                     -- Cook the new values prior to entering them into the config file.
 261                     -- Also, enter them only if they are valid.
 262                     function providers.write(self, section, value)
 263                        cookedvalue = {}
 264                        cindex = 1
 265                        for index, field in ipairs(value) do
 266                           cooked = string.gsub(luci.util.trim(value[index]), "%W", "_")
 267                           if validoutaccounts[cooked] ~= nil then
 268                              cookedvalue[cindex] = cooked
 269                              cindex = cindex + 1
 270                           end
 271                        end
 272                        DynamicList.write(self, section, cookedvalue)
 273                     end
 274                  end
 275               end)
 276
 277 ----------------------------------------------------------------------------------------------------
 278 s = m:section(TypedSection, "callthrough_numbers", translate("Call-through Numbers"),
 279         translate("Designate numbers which will be allowed to call through this system and which user's\
 280                   privileges it will have."))
 281 s.anonymous = true
 282 s.addremove = true
 283
 284 num = s:option(DynamicList, "callthrough_number_list", translate("Call-through Numbers"))
 285 num.datatype = "uinteger"
 286
 287 p = s:option(ListValue, "enabled", translate("Enabled"))
 288 p:value("yes", translate("Yes"))
 289 p:value("no",  translate("No"))
 290 p.default = "yes"
 291
 292 user = s:option(Value, "defaultuser",  translate("User Name"),
 293          translate("The number(s) specified above will be able to dial out with this user's providers.\
 294                    Invalid usernames are dropped silently, please verify that the entry was accepted."))
 295 function user.write(self, section, value)
 296    trimuser = luci.util.trim(value)
 297    if allvalidusers[trimuser] == true then
 298       Value.write(self, section, trimuser)
 299    end
 300 end
 301
 302 pwd = s:option(Value, "pin", translate("PIN"),
 303                translate("Your PIN disappears when saved for your protection. It will be changed\
 304                          only when you enter a value different from the saved one. Leaving the PIN\
 305                          empty is possible, but please beware of the security implications."))
 306 pwd.password = true
 307 pwd.rmempty = false
 308
 309 -- We skip reading off the saved value and return nothing.
 310 function pwd.cfgvalue(self, section)
 311     return ""
 312 end
 313
 314 -- We check the entered value against the saved one, and only write if the entered value is
 315 -- something other than the empty string, and it differes from the saved value.
 316 function pwd.write(self, section, value)
 317     local orig_pwd = m:get(section, self.option)
 318     if value and #value > 0 and orig_pwd ~= value then
 319         Value.write(self, section, value)
 320     end
 321 end
 322
 323 ----------------------------------------------------------------------------------------------------
 324 s = m:section(NamedSection, "blacklisting", "call_routing", translate("Blacklisted Numbers"),
 325                  translate("Enter phone numbers that you want to decline calls from automatically.\
 326                         You should probably omit the country code and any leading\
 327                         zeroes, but please experiment to make sure you are blocking numbers from your\
 328                         desired area successfully."))
 329 s.anonymous = true
 330
 331 b = s:option(DynamicList, "blacklist1", translate("Dynamic List of Blacklisted Numbers"),
 332             translate("Specify numbers individually here. Press enter to add more numbers."))
 333 b.cast = "string"
 334 b.datatype = "uinteger"
 335
 336 b = s:option(Value, "blacklist2", translate("Space-Separated List of Blacklisted Numbers"),
 337             translate("Copy-paste large lists of numbers here."))
 338 b.template = "cbi/tvalue"
 339 b.rows = 3
 340
 341 return m