[AsteriskBrasil] Email no Asterisk

[Asterisk - Junior Polegato]

Em 20-05-2013 06:45, Manecão escreveu:
> Oi pessoal,
> Como faço para receber no meu email cada vez que forem disparadas 
> ligaçoes entrantes ou saintes no asterisk, de tal maneira que me 
> informe data, hora, tempo de conexão, numero discado e callerID de 
> origem, identificando o ramal ou portal de voz de onde partiu a ligação.

Olá!

         Tenho uma solução de monitoramento que alimenta um banco de 
dados externo, mas no seu caso é só adaptar para enviar o e-mail. Não 
precisa fazer nenhuma alteração no seu plano de discagem.

         O código é feito em python e roda em segundo plano lendo o 
final do arquivo /var/log/asterisk/cdr-csv/Master.csv.

         Tentei colocar as linhas de código para enviar e-mail dentro 
deste código, espero que seja um ponto de partida para você.

         Qualquer interesse à parte, podemo negociar em PVT.

         E-mail recebido:

Origem: 123
Destino: 909092788696
Data e hora: 20/05/2013 15:45:18 BRT(-0300)
Tempo conectado: 00:00:13
Tempo total: 00:00:30


         Logo abaixo tem o código em Python:

[]'s
         Junior Polegato


#!/usr/bin/env python
# -*- coding: utf-8 -*-

import time
import smtplib
import datetime
try:
     import pytz
     time_zone_support = True
     local = pytz.timezone(open('/etc/timezone').read().strip())
except:
     print "No time zone support"
     time_zone_support = False

_SMTP_SERVER = "smtp.googlemail.com:587"
_SMTP_EMAIL = "junior em gmail.com"
_SMTP_PASS = "SeNhAdOgMaIl"
_SUBJECT = 'Dados da chamada efetuada'

_EXTEN_EMAIL = {
     "123": "ramal_123 em gmail.com",
     "456": "ramal_456 em gmail.com",
     "789": "ramal_789 em gmail.com",
     "abc": "ramal_abc em gmail.com",
}

_CSV_FILE = "/var/log/asterisk/cdr-csv/Master.csv"

# CSV Fields from http://www.voip-info.org/wiki/view/Asterisk+cdr+csv
_ACCOUNTCODE = 0
_SRC = 1
_DST = 2
_DCONTEXT = 3
_CLID = 4
_CHANNEL = 5
_DSTCHANNEL = 6
_LASTAPP = 7
_LASTDATA = 8
_START = 9
_ANSWER = 10
_END = 11
_DURATION = 12
_BILLSEC = 13
_DISPOSITION = 14
_AMAFLAGS = 15

# Inteval between reads from _CSV_FILE
_READ_INTERVAL = 1

# This function returns a list of fields in a csv record and
# it identifies text, integer and float types,
# ignoring left and right spaces according a field delimiter
def split_csv_fields(reg, field_delimiter = ','):
     fields = []
     pos = 0
     while pos < len(reg):
         while reg[pos] < ' ':
             pos += 1
         if reg[pos] in ('"', "'"):
             text_delimiter = reg[pos]
             start = pos + 1
             while pos < len(reg):
                 pos += 1
                 while reg[pos] != text_delimiter:
                     pos += 1
                 if reg[pos - 1] != '\\':
                     pos += 1
                     break
             fields.append(reg[start:pos - 1])
             while pos < len(reg) and reg[pos] != field_delimiter:
                 pos += 1
         else:
             start = pos
             while pos < len(reg) and reg[pos] != field_delimiter:
                 pos += 1
             text = reg[start:pos].strip()
             dots = text.count('.')
             if dots < 2 and text.replace('.', '').isdigit():
                 if dots:
                     fields.append(float(text))
                 else:
                     fields.append(int(text))
             else:
                 fields.append(text)
         pos += 1
     return fields

def duration(seconds):
     h = seconds / 3600
     m = seconds / 60 % 60
     s = seconds % 60
     return "%02i:%02i:%02i" % (h, m, s)

def process_data(data):
     data = data.strip().replace('\r', '').split('/n')
     for reg in data:
         fields = split_csv_fields(reg)
         if time_zone_support:
             start_date = datetime.datetime.strptime(
                                     fields[_START], '%Y-%m-%d %H:%M:%S')
             start_date = pytz.utc.localize(start_date)
             start_date = start_date.astimezone(local)
             start_date = start_date.strftime('%d/%m/%Y %H:%M:%S %Z(%z)')
         else:
             start_date = datetime.fields[_START]
         body = ('Origem: %s\n'
                 'Destino: %s\n'
                 'Data e hora: %s\n'
                 'Tempo conectado: %s\n'
                 'Tempo total: %s\n'
                 % (fields[_SRC], fields[_DST], start_date,
                    duration(fields[_BILLSEC]),
                    duration(fields[_DURATION])))
         print body
         if fields[_SRC] not in _EXTEN_EMAIL:
             print "No e-mail to %s found!" % fields[_SRC]
             return
         try:
             to = _EXTEN_EMAIL[fields[_SRC]]
             email_date = time.strftime('%a, %d %b %Y %H:%M:%S %z')
             msg = ("From: %s\r\n"
                    "To: %s\r\n"
                    "Subject: %s\r\n"
                    "Date: %s\r\n"
                    "\r\n"
                    "%s"
                    % (_SMTP_EMAIL, to, _SUBJECT, email_date, body))
             server = smtplib.SMTP(_SMTP_SERVER, timeout = 60)
             ehlo = server.ehlo()
             if "STARTTLS" in ehlo[1]:
                 server.starttls()
             server.login(_SMTP_EMAIL, _SMTP_PASS)
             server.sendmail(_SMTP_EMAIL, to, msg)
             server.quit()
             print "Mail to %s sent!" % to
         except Exception as error:
             print str(error)
             print "Mail to %s not sent!" % to

if __name__ == "__main__":
     # Open csv file
     csv_file = open(_CSV_FILE)
     # Go to the end of file
     csv_file.seek(0, 2)
     # Try to get more data in _READ_INTERVAL
     data = ''
     while True:
         # Get more data
         data += csv_file.read()
         if '\n' in data:
             # Get the position of last new line
             last_new_line = data.rfind('\n')
             # Process data up to last new line
             try:
                 process_data(data[:last_new_line])
             except:
                 print 'Error processing data:', repr(data)
             # Delete the processed data
             data = data[last_new_line + 1:]
         # Wait for _READ_INTERVAL seconds
         time.sleep(_READ_INTERVAL)