Integration av Asterisk och Bitrix24

Det finns olika alternativ för integration av IP-ATC Asterisk och CRM Bitrix24, men vi beslutade oss för att skriva vår egen lösning.

Funktionaliteten är standardiserad:

• Genom att klicka på länken med kundens telefonnummer i Bitrix24 kopplar Asterisk den interna telefonnummeranvändaren, som gjorde klicket, med kundens telefonnummer. I Bitrix24 registreras ett samtalslogg och efter samtalet hämtas inspelningen.
• När ett samtal kommer in externt visar vi kundens kort i Bitrix24 för den medarbetare vars nummer samtalet ringdes till.
  Om det inte finns en sådan kund öppnar vi ett kort för att skapa en ny lead.
  Så snart samtalet är avslutat, återspeglar vi detta i kortet och hämtar samtalsinspelningen.

Under rubriken kommer jag att berätta hur du ställer in allt och ge dig länken till github – ja, ja, ta och använd!

Allmän beskrivning

Vi kallade vår integration CallMe. CallMe är en liten webbapplikation som är skriven i PHP.

Använda teknologier och tjänster

• PHP 5.6
• PHP AMI-bibliotek
• Composer
• Nginx + php-fpm
• supervisor
• AMI (Asterisk Manager Interface)
• Bitrix-webhooks (förenklad implementation av REST API)

Förinställning

På servern med Asterisk måste du installera en webbserver (vi använder nginx+php-fpm), supervisor och git.

Kommando för att installera (CentOS):

yum install nginx php-fpm supervisor git

Gå till katalogen som är tillgänglig för webbservern, dra applikationen från git och ställ in rättigheter för mappen:

cd /var/www
git clone https://github.com/ViStepRU/callme.git
chown nginx. -R callme/

Sedan konfigurerar vi nginx, vår konfiguration ligger i

/etc/nginx/conf.d/pbx.vistep.ru.conf

server {
	server_name www.pbx.vistep.se pbx.vistep.se;
	listen *:80;
	rewrite ^  https://pbx.vistep.se$request_uri? permanent;
}

server {
#        listen *:80;
#	server_name pbx.vistep.se;


	access_log /var/log/nginx/pbx.vistep.se.access.log main;
        error_log /var/log/nginx/pbx.vistep.se.error.log;

    listen 443 ssl http2;
    server_name pbx.vistep.se;
    resolver 8.8.8.8;
    ssl_stapling on;
    ssl on;
    ssl_certificate /etc/letsencrypt/live/pbx.vistep.se/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/pbx.vistep.se/privkey.pem;
    ssl_dhparam /etc/nginx/certs/dhparam.pem;
    ssl_session_timeout 24h;
    ssl_session_cache shared:SSL:2m;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers kEECDH+AES128:kEECDH:kEDH:-3DES:kRSA+AES128:kEDH+3DES:DES-CBC3-SHA:!RC4:!aNULL:!eNULL:!MD5:!EXPORT:!LOW:!SEED:!CAMELLIA:!IDEA:!PSK:!SRP:!SSLv2;
    ssl_prefer_server_ciphers on;
    add_header Strict-Transport-Security "max-age=31536000;";
    add_header Content-Security-Policy-Report-Only "default-src https:; script-src https: 'unsafe-eval' 'unsafe-inline'; style-src https: 'unsafe-inline'; img-src https: data:; font-src https: data:; report-uri /csp-report";
	
	root /var/www/callme;
	index  index.php;
        location ~ \/. {
                deny all; # förbud mot dolda filer
        }

        location ~* \/(?:uploads|files)\/.*.php$ {
                deny all; # förbud mot uppladdade skript
        }

        location ~* ^.+\.(ogg|ogv|svg|svgz|eot|otf|woff|mp4|ttf|rss|atom|jpg|jpeg|gif|png|ico|zip|tgz|gz|rar|bz2|doc|xls|exe|ppt|tar|mid|midi|wav|bmp|rtf)$ {
                access_log off;
                log_not_found off;
                expires max; # caching av statiskt innehåll
        }

	location ~ .php {
		root /var/www/callme;
		index  index.php;
		fastcgi_pass unix:/run/php/php5.6-fpm.sock;
	#	fastcgi_pass 127.0.0.1:9000;
		fastcgi_index index.php;
		fastcgi_param SCRIPT_FILENAME $document_root/$fastcgi_script_name;
		include /etc/nginx/fastcgi_params;
		}
}

Jag lämnar konfigurationens analys, säkerhetsfrågor, certifikatförvärv och till och med valet av webbserver utanför artikeln — det har skrivits mycket om detta. Applikationen har inga begränsningar, den fungerar både med http och https.

Vi använder https, certifikat från Let’s Encrypt.

Om du har gjort allt rätt, så bör du se något liknande när du följer länken.

Konfiguration av Bitrix24

Vi skapar två webbhookar.

Inkommande webhook.

Under administratörskontot (med id 1) går vi till: Applikationer -> Webbhookar -> Lägg till webhook -> Inkommande webhook

Fyll i parametrarna för det inkommande webhooket som på skärmdumparna:

Och klicka på spara.

Efter att ha sparat kommer Bitrix24 att tillhandahålla URL:en för det inkommande webhooket, till exempel:

Spara din variant av URL:en utan slutande /profile/ — den kommer att användas i applikationen för att hantera inkommande samtal.

Detta är min https://b24-xsynia.bitrix24.ru/rest/1/7eh61lh8pahw0fwt/

Utgående webhook.

Applikationer -> Webbhookar -> Lägg till webhook -> Utgående webhook

Detaljer igen på skärmdumparna:

Spara och få autorisationskoden

Detta är min xcrp2ylhzzd2v43cmfjqmkvrgrcbkni6. Denna måste också kopieras, den behövs för att göra utgående samtal.

Viktigt!

På Bitrix24-servern måste ett SSL-certifikat (man kan använda Let’s Encrypt) vara inställt, annars fungerar inte Bitrix API. Om du har en molnversion behöver du inte oroa dig – den har redan SSL.

Viktigt!

I fältet "Handler-adress" måste en adress som är tillgänglig från internet anges!

Som sista steg installerar vi vårt CallMeOut som en applikation för att göra samtal (så att en kommando skickas till telefonväxeln för att initiera samtalet när man klickar på numret).

I menyn väljer vi: Mer -> Telefonilösning -> Mer -> Inställningar, sätter "Nummer för standardutgående samtal" till Applikation: CallMeOut och klickar på "Spara".

Konfigurera Asterisk

För att Asterisk och Bitrix24 ska kunna kommunicera framgångsrikt behöver vi lägga till AMI-användaren callme i manager.conf:

[callme]
secret = JD3clEB8_f23r-3ry84gJ
deny = 0.0.0.0/0.0.0.0
permit = 127.0.0.1/255.255.255.0
permit= 10.100.111.249/255.255.255.255
permit = 192.168.254.0/255.255.255.0
read = system,call,log,verbose,agent,user,config,dtmf,reporting,cdr,dialplan
write = system,call,agent,log,verbose,user,config,command,reporting,originate

Vidare finns det flera knep som behöver implementeras genom dialplan (hos oss är det extensions.ael).

Här är hela filen, och efter det kommer jag att ge förklaringar:

globals {
    WAV=\/var\/www\/pbx.vistep.ru\/callme\/records\/wav; \/\/ Temporär katalog med WAV
    MP3=\/var\/www\/pbx.vistep.ru\/callme\/records\/mp3; \/\/ Var man laddar upp mp3-filer
    URLRECORDS=https:\/\/pbx.vistep.ru\/callme\/records\/mp3;
    RECORDING=1; \/\/ Inspelning, 1 - aktiverad.
};

macro recording(calling,called) {
        if ("${RECORDING}" = "1"){
              Set(fname=${UNIQUEID}-${STRFTIME(${EPOCH},,%Y-%m-%d-%H_%M)}-${calling}-${called});
	      Set(datedir=${STRFTIME(${EPOCH},,%Y\/ %m\/ %d)});
	      System(mkdir -p ${MP3}\/ ${datedir});
	      System(mkdir -p ${WAV}\/ ${datedir});
              Set(monopt=nice -n 19 \/usr\/bin\/lame -b 32  --silent "${WAV}\/ ${datedir}\/ ${fname}.wav"  "${MP3}\/ ${datedir}\/ ${fname}.mp3" && rm -f "${WAV}\/ ${fname}.wav" && chmod o+r "${MP3}\/ ${datedir}\/ ${fname}.mp3");
	      Set(FullFname=${URLRECORDS}\/ ${datedir}\/ ${fname}.mp3);
              Set(CDR(filename)=${fname}.mp3);
	      Set(CDR(recordingfile)=${fname}.wav);
              Set(CDR(realdst)=${called});
              MixMonitor(${WAV}\/ ${datedir}\/ ${fname}.wav,b,${monopt});

       };
};


context incoming {
888999 => {
	&recording(${CALLERID(number)},${EXTEN});
        Answer();
        ExecIF(${CallMeCallerIDName}?Set(CALLERID(name)=${CallMeCallerIDName}):NoOp()); \/\/ sätter CallerID om vi har känslighet av Bitrix24
        Set(CallStart=${STRFTIME(epoch,,%s)});  
        Queue(Q1,tT);
        Set(CallMeDISPOSITION=${CDR(disposition)}); 
        Hangup();
        }

h => {
    Set(CDR_PROP(disable)=true); 
    Set(CallStop=${STRFTIME(epoch,,%s)}); 
    Set(CallMeDURATION=${MATH(${CallStop}-${CallStart},int)}); 
    ExecIF(${ISNULL(${CallMeDISPOSITION})}?Set(CallMeDISPOSITION=${CDR(disposition)}):NoOP(=== CallMeDISPOSITION redan var inställt ===));  
}

}


context default {

_X. => {
        Hangup();
        }
};


context dial_out {

_[1237]XX => {
	&recording(${CALLERID(number)},${EXTEN});
        Set(__CallIntNum=${CALLERID(num)})
	Set(CallStart=${STRFTIME(epoch,,%s)});
        Dial(SIP\/ ${EXTEN},,tTr);
        Hangup();
        }

_11XXX => {
	&recording(${CALLERID(number)},${EXTEN});
	Set(CallStart=${STRFTIME(epoch,,%s)});
	Set(__CallIntNum=${CALLERID(num)});
        Dial(SIP\/ ${EXTEN:2}@toOurAster,,t);
        Hangup();
        }

_. => {
	&recording(${CALLERID(number)},${EXTEN});
        Set(__CallIntNum=${CALLERID(num)})
	Set(CallStart=${STRFTIME(epoch,,%s)});
	Dial(SIP\/ ${EXTEN}@toOurAster,,t);
	Hangup();
        }

h => {
        Set(CDR_PROP(disable)=true);
        Set(CallStop=${STRFTIME(epoch,,%s)});
        Set(CallMeDURATION=${MATH(${CallStop}-${CallStart},int)});
	if(${ISNULL(${CallMeDISPOSITION})}) {
          Set(CallMeDISPOSITION=${CDR(disposition)});
        }
	System(curl -s http:\/\/pbx.vistep.ru\/CallMeOut.php --data action=sendcall2b24 --data call_id=${CallMeCALL_ID} --data-urlencode FullFname=${FullFname} --data CallIntNum=${CallIntNum} --data CallDuration=${CallMeDURATION} --data-urlencode CallDisposition=${CallMeDISPOSITION});
}

};

Låt oss börja från början: direktiv globals.

Variabel URLRECORDS innehåller URL till samtalsinspelningarna, som Bitrix24 kommer att dra in i kontaktkortet.

Vidare är vi intresserade av makrot recording.

Här, förutom inspelning av samtal, kommer vi att ställa in variabeln FullFname.

Set(FullFname=${URLRECORDS}\/ ${datedir}\/ ${fname}.mp3);

Den lagrar den fullständiga URL:en till en specifik fil (makrot anropas överallt).

Låt oss analysera ett utgående samtal:

_. => {
	&recording(${CALLERID(number)},${EXTEN});
        Set(__CallIntNum=${CALLERID(num)})
	Set(CallStart=${STRFTIME(epoch,,%s)});
	Dial(SIP/${EXTEN}@toOurAster,,t);
	Hangup();
        }

h => {
        Set(CDR_PROP(disable)=true);
        Set(CallStop=${STRFTIME(epoch,,%s)});
        Set(CallMeDURATION=${MATH(${CallStop}-${CallStart},int)});
	if(${ISNULL(${CallMeDISPOSITION})}) {
          Set(CallMeDISPOSITION=${CDR(disposition)});
        }
	System(curl -s http://pbx.vistep.ru/CallMeOut.php --data action=sendcall2b24 --data call_id=${CallMeCALL_ID} --data-urlencode FullFname=${FullFname} --data CallIntNum=${CallIntNum} --data CallDuration=${CallMeDURATION} --data-urlencode CallDisposition=${CallMeDISPOSITION});
}

Låt oss säga att vi ringer till 89991234567, först hamnar vi här:

&recording(${CALLERID(number)},${EXTEN});

Det vill säga, makrot för samtalsinspelning körs och nödvändiga variabler sätts.

Nästa

        Set(__CallIntNum=${CALLERID(num)})
	Set(CallStart=${STRFTIME(epoch,,%s)});

Vi registrerar vem som initierade samtalet och registrerar starttiden för samtalet.

Och efter att det har avslutats, i en speciell kontext h

h => {
        Set(CDR_PROP(disable)=true);
        Set(CallStop=${STRFTIME(epoch,,%s)});
        Set(CallMeDURATION=${MATH(${CallStop}-${CallStart},int)});
	if(${ISNULL(${CallMeDISPOSITION})}) {
          Set(CallMeDISPOSITION=${CDR(disposition)});
        }
	System(curl -s http://pbx.vistep.ru/CallMeOut.php --data action=sendcall2b24 --data call_id=${CallMeCALL_ID} --data-urlencode FullFname=${FullFname} --data CallIntNum=${CallIntNum} --data CallDuration=${CallMeDURATION} --data-urlencode CallDisposition=${CallMeDISPOSITION});
}

Vi stänger av inspelningen i CDR-tabellen för denna förlängning (det är inte nödvändigt där), sätter tiden för samtalets slut, beräknar varaktigheten, om resultatet av samtalet är okänt – så sätter vi (variabeln CallMeDISPOSITION) och, som sista steg, skickar allt till Bitrix via systemcurl.

Och lite mer magi – inkommande samtal:

888999 => {
	&recording(${CALLERID(number)},${EXTEN});
        Answer();
        ExecIF(${CallMeCallerIDName}?Set(CALLERID(name)=${CallMeCallerIDName}):NoOp()); // sätter CallerID om vi känner till den från Bitrix24
        Set(CallStart=${STRFTIME(epoch,,%s)}); // börjar tidtagning för samtalet
        Queue(Q1,tT);
        Set(CallMeDISPOSITION=${CDR(disposition)});
        Hangup();
        }

Här är vi endast intresserade av en rad.

ExecIF(${CallMeCallerIDName}?Set(CALLERID(name)=${CallMeCallerIDName}):NoOp());

Den säger till växel att ställa in CallerID(name) till värdet av variabeln CallMeCallerIDName.

Själva variabeln CallMeCallerIDName sätts av applikationen CallMe (om det finns en fullständig namnregistrering i Bitrix24 för numret som ringer – så sätts det som CallerID(name), om inte – så gör vi ingenting).

Appinställning

Inställningsfilen för applikationen – /var/www/pbx.vistep.ru/config.php

Beskrivning av applikationens parametrar:

• CallMeDEBUG – om 1, så kommer alla händelser som applikationen bearbetar att skrivas till loggfilen, 0 – ingen loggning
• tech – SIP/PJSIP/IAX/etc
• authToken — autentiseringstoken för Bitrix24, kod för den utgående webhooken
• bitrixApiUrl — inkommande webhook-URL, utan profile/
• extentions — lista över externa nummer
• context — kontext för uppringning
• listener_timeout — hastigheten för händelsebehandling från Asterisk
• asterisk — array med anslutningsinställningar till Asterisk:
• host — ip eller värdnamn för Asterisk-servern
• scheme — anslutningsschema (tcp://, tls://)
• port — port
• username — användarnamn
• secret — lösenord
• connect_timeout — anslutningstimeout
• read_timeout — lästimeout

exempel på konfigurationsfil:

 <?php
return array(

        'CallMeDEBUG' => 1, // debugmeddelanden i loggen: 1 - skriver, 0 - skriver inte
        'tech' => 'SIP',
        'authToken' => 'xcrp2ylhzzd2v43cmfjqmkvrgrcbkni6', // autentiseringstoken för Bitrix
        'bitrixApiUrl' => 'https://b24-xsynia.bitrix24.ru/rest/1/7eh61lh8pahw0fwt/', // url till Bitrix API (inkommande webhook)
        'extentions' => array('888999'), // lista över externa nummer, separerade med kommatecken
        'context' => 'dial_out', // utgående kontext för uppringning
        'asterisk' => array( // inställningar för anslutning till Asterisk
                    'host' => '10.100.111.249',
                    'scheme' => 'tcp://',
                    'port' => 5038,
                    'username' => 'callme',
                    'secret' => 'JD3clEB8_f23r-3ry84gJ',
                    'connect_timeout' => 10000,
                    'read_timeout' => 10000
                ),
        'listener_timeout' => 300, // hastighet för händelsebehandling från Asterisk

);

Konfigurera supervisor

Supervisor används för att köra processhanteraren för händelser från Asterisk CallMeIn.php, som övervakar inkommande samtal och interagerar med Bitrix24 (visa kort, dölja kort osv.).

Konfigurationsfilen som behöver skapas:

/etc/supervisord.d/callme.conf

[program:callme]
command=/usr/bin/php CallMeIn.php
directory=/var/www/pbx.vistep.ru
autostart=true
autorestart=true
startretries=5
stderr_logfile=/var/www/pbx.vistep.ru/logs/daemon.log
stdout_logfile=/var/www/pbx.vistep.ru/logs/daemon.log

Starta och starta om applikationen:

supervisorctl start callme
supervisorctl restart callme

visa applikationens status:

supervisorctl status callme
callme                           RUNNING   pid 11729, uptime 17 days, 16:58:07

Slutsats

Det har blivit ganska komplicerat, men jag är säker på att en erfaren administratör kan implementera detta och glädja sina användare.

Som jag lovade, länk till GitHub.

Frågor, önskemål — vänligen lämna i kommentarerna. Om du är intresserad av hur utvecklingen av denna integration gick till, skriv gärna, så ska jag i nästa artikel försöka förklara allt mer detaljerat.

Källa: habr.com