Пример #1
0
 def call_log(self, state):
     """ Prepare crm.phonecall creation. """
     communication_id = self.env.context.get("click2dial_id")
     communication = self.env["partner.communication.job"].browse(
         communication_id)
     call_vals = {
         "state": state,
         "description": self.comments,
         "name": communication.config_id.name,
         "communication_id": communication_id,
         "partner_id": communication.partner_id.id,
     }
     try:
         parsed_num = phonenumbers.parse(
             self.env.context.get("phone_number"))
         number_type = phonenumbers.number_type(parsed_num)
         if number_type == 1:
             call_vals["partner_mobile"] = self.env.context.get(
                 "phone_number")
         else:
             call_vals["partner_phone"] = self.env.context.get(
                 "phone_number")
     except TypeError:
         _logger.info("Partner has no phone number")
     return self.env["crm.phonecall"].create(call_vals)
 def can_send(self, phone):
     return (
         isinstance(phone, PhoneNumber)
         and phone.is_valid()
         and number_type(phone)
         in [PhoneNumberType.MOBILE, PhoneNumberType.FIXED_LINE_OR_MOBILE,]
     )
Пример #3
0
 def _create_open_crm_phonecall(self, direction='outbound'):
     teams = self.env['crm.team'].search(
         [('member_ids', 'in', self._uid)])
     action_ctx = self.env.context.copy()
     action_ctx.update({
         'default_direction': direction,
         'default_team_id': teams and teams[0].id or False,
     })
     domain = False
     if self.env.context.get('click2dial_model') == 'res.partner':
         partner_id = self.env.context.get('click2dial_id')
         action_ctx['default_partner_id'] = partner_id
         domain = [('partner_id', 'child_of', partner_id)]
     elif self.env.context.get('click2dial_model') == 'crm.lead':
         lead_id = self.env.context.get('click2dial_id')
         action_ctx['default_opportunity_id'] = lead_id
         domain = [('opportunity_id', '=', lead_id)]
     parsed_num = phonenumbers.parse(self.env.context.get('phone_number'))
     number_type = phonenumbers.number_type(parsed_num)
     if number_type == 1:
         action_ctx['default_partner_mobile'] =\
             self.env.context.get('phone_number')
     else:
         action_ctx['default_partner_phone'] =\
             self.env.context.get('phone_number')
     action = self.env['ir.actions.act_window'].for_xml_id(
         'crm_phone', 'crm_phonecall_action')
     action.update({
         'domain': domain,
         'view_mode': 'form,tree,calendar',
         'context': action_ctx,
         })
     return action
Пример #4
0
 def call_success(self):
     """ Prepare crm.phonecall creation. """
     action_ctx = self.env.context.copy()
     action_ctx.update({
         'default_state': 'done',
         'default_description': self.comments,
         'default_name': self.env.context.get('call_name'),
     })
     partner_id = self.env.context.get('click2dial_id')
     action_ctx['default_partner_id'] = partner_id
     domain = [('partner_id', '=', partner_id)]
     try:
         parsed_num = phonenumbers.parse(
             self.env.context.get('phone_number'))
         number_type = phonenumbers.number_type(parsed_num)
         if number_type == 1:
             action_ctx['default_partner_mobile'] = \
                 self.env.context.get('phone_number')
         else:
             action_ctx['default_partner_phone'] = \
                 self.env.context.get('phone_number')
     except TypeError:
         _logger.info("Partner has no phone number")
     return {
         'name': _('Phone Call'),
         'domain': domain,
         'res_model': 'crm.phonecall',
         'view_mode': 'form,tree,calendar',
         'type': 'ir.actions.act_window',
         'nodestroy': False,  # close the pop-up wizard after action
         'target': 'new',
         'context': action_ctx,
     }
 def default_get(self, fields_list):
     res = super(NumberNotFound, self).default_get(fields_list)
     if not res:
         res = {}
     if res.get('calling_number'):
         if not self.env.user.company_id.country_id:
             raise UserError(_(
                 'Missing country on company %s'
                 % self.env.user.company_id.name))
         country_code = self.env.user.company_id.country_id.code
         try:
             parsed_num = phonenumbers.parse(
                 res['calling_number'], country_code)
             res['e164_number'] = phonenumbers.format_number(
                 parsed_num, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
             number_type = phonenumbers.number_type(parsed_num)
             if number_type == 1:
                 res['number_type'] = 'mobile'
             else:
                 res['number_type'] = 'phone'
         except Exception, e:
             _logger.error(
                 "Cannot reformat the phone number '%s': %s",
                 res['calling_number'], e)
             pass
Пример #6
0
 def call_success(self):
     """ Prepare crm.phonecall creation. """
     action_ctx = self.env.context.copy()
     action_ctx.update({
         'default_state': 'done',
         'default_description': self.comments,
         'default_name': self.env.context.get('call_name'),
     })
     partner_id = self.env.context.get('click2dial_id')
     action_ctx['default_partner_id'] = partner_id
     domain = [('partner_id', '=', partner_id)]
     try:
         parsed_num = phonenumbers.parse(
             self.env.context.get('phone_number'))
         number_type = phonenumbers.number_type(parsed_num)
         if number_type == 1:
             action_ctx['default_partner_mobile'] = \
                 self.env.context.get('phone_number')
         else:
             action_ctx['default_partner_phone'] = \
                 self.env.context.get('phone_number')
     except TypeError:
         _logger.info("Partner has no phone number")
     return {
         'name': _('Phone Call'),
         'domain': domain,
         'res_model': 'crm.phonecall',
         'view_mode': 'form,tree,calendar',
         'type': 'ir.actions.act_window',
         'nodestroy': False,  # close the pop-up wizard after action
         'target': 'new',
         'context': action_ctx,
     }
Пример #7
0
 def _create_open_crm_phonecall(self, direction='outbound'):
     teams = self.env['crm.team'].search([('member_ids', 'in', self._uid)])
     action_ctx = self.env.context.copy()
     action_ctx.update({
         'default_direction': direction,
         'default_team_id': teams and teams[0].id or False,
     })
     domain = False
     if self.env.context.get('click2dial_model') == 'res.partner':
         partner_id = self.env.context.get('click2dial_id')
         action_ctx['default_partner_id'] = partner_id
         domain = [('partner_id', 'child_of', partner_id)]
     elif self.env.context.get('click2dial_model') == 'crm.lead':
         lead_id = self.env.context.get('click2dial_id')
         action_ctx['default_opportunity_id'] = lead_id
         domain = [('opportunity_id', '=', lead_id)]
     parsed_num = phonenumbers.parse(self.env.context.get('phone_number'))
     number_type = phonenumbers.number_type(parsed_num)
     if number_type == 1:
         action_ctx['default_partner_mobile'] =\
             self.env.context.get('phone_number')
     else:
         action_ctx['default_partner_phone'] =\
             self.env.context.get('phone_number')
     return {
         'name': _('Phone Call'),
         'type': 'ir.actions.act_window',
         'res_model': 'crm.phonecall',
         'domain': domain,
         'view_mode': 'form,tree,calendar',
         'nodestroy': False,  # close the pop-up wizard after action
         'target': 'current',
         'context': action_ctx,
     }
 def _create_open_crm_phonecall(self, direction="outbound", state="done"):
     teams = self.env["crm.team"].search([("member_ids", "in", self._uid)])
     action_ctx = self.env.context.copy()
     action_ctx.update({
         "default_direction": direction,
         "default_team_id": teams and teams[0].id or False,
         "default_state": state,
     })
     if self.env.context.get("click2dial_model") == "res.partner":
         partner_id = self.env.context.get("click2dial_id")
         action_ctx["default_partner_id"] = partner_id
     elif self.env.context.get("click2dial_model") == "crm.lead":
         lead_id = self.env.context.get("click2dial_id")
         action_ctx["default_opportunity_id"] = lead_id
     parsed_num = phonenumbers.parse(self.env.context.get("phone_number"))
     number_type = phonenumbers.number_type(parsed_num)
     if number_type == 1:
         action_ctx["default_partner_mobile"] = self.env.context.get(
             "phone_number")
     else:
         action_ctx["default_partner_phone"] = self.env.context.get(
             "phone_number")
     action = self.env.ref(
         "crm_phone.crm_phonecall_action").sudo().read()[0]
     action.update({
         "view_mode": "form,tree,calendar",
         "views": False,
         "context": action_ctx,
     })
     return action
 def default_get(self, fields_list):
     res = super().default_get(fields_list)
     if not res:
         res = {}
     if res.get("calling_number"):
         if not self.env.company.country_id:
             raise UserError(
                 _("Missing country on company %s" %
                   self.env.company.display_name))
         country_code = self.env.company.country_id.code
         try:
             parsed_num = phonenumbers.parse(res["calling_number"],
                                             country_code)
             res["e164_number"] = phonenumbers.format_number(
                 parsed_num, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
             number_type = phonenumbers.number_type(parsed_num)
             if number_type == 1:
                 res["number_type"] = "mobile"
             else:
                 res["number_type"] = "phone"
         except Exception as e:
             _logger.error(
                 "Cannot reformat the phone number '%s': %s",
                 res["calling_number"],
                 e,
             )
     return res
Пример #10
0
 def default_get(self, fields_list):
     res = super(NumberNotFound, self).default_get(fields_list)
     if not res:
         res = {}
     if res.get('calling_number'):
         if not self.env.user.company_id.country_id:
             raise UserError(
                 _('Missing country on company %s' %
                   self.env.user.company_id.name))
         country_code = self.env.user.company_id.country_id.code
         try:
             parsed_num = phonenumbers.parse(res['calling_number'],
                                             country_code)
             res['e164_number'] = phonenumbers.format_number(
                 parsed_num, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
             number_type = phonenumbers.number_type(parsed_num)
             if number_type == 1:
                 res['number_type'] = 'mobile'
             else:
                 res['number_type'] = 'phone'
         except Exception as e:
             _logger.error("Cannot reformat the phone number '%s': %s",
                           res['calling_number'], e)
             pass
     return res
Пример #11
0
def send_sms(message, phone_number, force=False, at=None):
    phone_number = to_phone_number(phone_number)

    if not force and not phone_number.is_valid():
        raise SMSSendException("Le numéro ne semble pas correct")

    if not force and number_type(phone_number) not in [
            PhoneNumberType.FIXED_LINE_OR_MOBILE,
            PhoneNumberType.MOBILE,
    ]:
        raise SMSSendException(
            "Le numéro ne semble pas être un numéro de mobile")

    try:
        result = _send_sms(message, [phone_number], at=at)
    except Exception:
        logger.exception("Le message n'a pas été envoyé.")
        raise SMSSendException("Le message n'a pas été envoyé.")

    if len(result["invalidReceivers"]) > 0:
        logger.error(
            f"Destinataires invalides {' '.join(result['invalidReceivers'])}")
        raise SMSSendException("Destinataire invalide.")

    if len(result["validReceivers"]) < 1:
        raise SMSSendException("Le message n'a pas été envoyé.")
Пример #12
0
def validate_number(number,
                    country,
                    include_description=True) -> Optional[Number]:
    try:
        p = parse_number(number, country)
    except NumberParseException:
        return

    if not is_valid_number(p):
        return

    is_mobile = number_type(p) in MOBILE_NUMBER_TYPES
    descr = None
    if include_description:
        country = country_name_for_number(p, 'en')
        region = description_for_number(p, 'en')
        descr = country if country == region else f'{region}, {country}'

    return Number(
        number=format_number(p, PhoneNumberFormat.E164),
        country_code=f'{p.country_code}',
        number_formatted=format_number(p, PhoneNumberFormat.INTERNATIONAL),
        descr=descr,
        is_mobile=is_mobile,
    )
    def create_partner(self):
        """Function called by the related button of the wizard"""
        self.ensure_one()
        parsed_num = phonenumbers.parse(self.e164_number, None)
        phonenumbers.number_type(parsed_num)

        context = dict(self._context or {})
        context["default_%s" % self.number_type] = self.e164_number
        action = {
            "name": _("Create New Partner"),
            "view_mode": "form,tree,kanban",
            "res_model": "res.partner",
            "type": "ir.actions.act_window",
            "target": "current",
            "context": context,
        }
        return action
Пример #14
0
    def create_partner(self):
        '''Function called by the related button of the wizard'''
        wiz = self[0]
        parsed_num = phonenumbers.parse(wiz.e164_number, None)
        phonenumbers.number_type(parsed_num)

        context = dict(self._context or {})
        context.update({'default_%s' % wiz.number_type: wiz.e164_number})
        action = {
            'name': _('Create New Partner'),
            'view_mode': 'form,tree,kanban',
            'res_model': 'res.partner',
            'type': 'ir.actions.act_window',
            'nodestroy': False,
            'target': 'current',
            'context': context,
        }
        return action
    def create_partner(self):
        '''Function called by the related button of the wizard'''
        wiz = self[0]
        parsed_num = phonenumbers.parse(wiz.e164_number, None)
        phonenumbers.number_type(parsed_num)

        context = dict(self._context or {})
        context.update({'default_%s' % wiz.number_type: wiz.e164_number})
        action = {
            'name': _('Create New Partner'),
            'view_mode': 'form,tree,kanban',
            'res_model': 'res.partner',
            'type': 'ir.actions.act_window',
            'nodestroy': False,
            'target': 'current',
            'context': context,
        }
        return action
Пример #16
0
def validate_phone(value):
    try:
        phone_obj = phonenumbers.parse(value, 'UA')
    except:
        raise forms.ValidationError(
            _(u'The string is not a valid phone number.'))
    phone_type = phonenumbers.number_type(phone_obj)
    if phone_type == 99:
        raise forms.ValidationError(_(u"Invalid phone number."))
    return f'{phone_obj.country_code}{phone_obj.national_number}'
Пример #17
0
    def clean_number(self):
        try:
            data = parse(self.cleaned_data['number'], None)

            if not number_type(data) == PhoneNumberType.MOBILE:
                raise forms.ValidationError('Please enter a valid mobile phone number.')

            return '+{}{}'.format(data.country_code, data.national_number)
        except NumberParseException:
            raise forms.ValidationError(validate_international_phonenumber.message)
Пример #18
0
    def create_partner(self, cr, uid, ids, context=None):
        '''Function called by the related button of the wizard'''
        if context is None:
            context = {}
        wiz = self.browse(cr, uid, ids[0], context=context)
        parsed_num = phonenumbers.parse(wiz.e164_number, None)
        phonenumbers.number_type(parsed_num)

        context['default_%s' % wiz.number_type] = wiz.e164_number
        action = {
            'name': _('Create New Partner'),
            'view_mode': 'form,tree,kanban',
            'res_model': 'res.partner',
            'type': 'ir.actions.act_window',
            'nodestroy': False,
            'target': 'current',
            'context': context,
            }
        return action
Пример #19
0
    def do_transform(self, request, response, config):

        phone = request.entity

        # Formats the string for the parser to understand the phone number
        number = ""
        if phone.countrycode:
            number += "+" + phone.countrycode + " "

        if phone.citycode:
            number += citycode

        if phone.areacode:
            number += phone.areacode

        number += phone.lastnumbers

        try:
            parsed = phonenumbers.parse(number)
        except phonenumbers.NumberParseException as e:
            # The phone number couldn't be parsed
            return response

        # Gets the country from the country code (if any)
        country_code = phonenumbers.region_code_for_number(parsed)

        # It may be the country, city, or any string that defines a geographical area
        location_str = str(description_for_number(parsed, "en"))

        phone_type = self.phonetype_lookup[phonenumbers.number_type(parsed)]
        # Returns the result in english (we don't care, as it's just the carrier's name)
        carrier_name = carrier.name_for_number(parsed, "en")

        valid_number = phonenumbers.is_valid_number(parsed)

        # Creates the entities to be added to the graph
        if not valid_number:
            # Adds a phrase warning about the invalid phone
            response += ents.Phrase(text="Possibly invalid number",
                                    link_color=LinkColor.Red,
                                    link_thickness=3)

        # Phrase with the carrier info
        if carrier_name:
            response += ents.Phrase("Carrier: " + carrier_name)

        # Phrase with the phone type
        if phone_type and phone_type.lower() != "unknown":
            response += ents.Phrase("Phone type: " + phone_type)

        # Location
        if location_str or country_code:
            response += self.extract_location(location_str, country_code)

        return response
Пример #20
0
def process_phone(phone_raw, country='ID', lang='en', metadata=True):

    if not phone_raw:
        return None

    if type(phone_raw) != str:
        phone_raw = str(phone_raw)

    if any(e.isalpha() or e in '#*' for e in phone_raw) or \
            len(phone_raw) <= 7:
        if not metadata:
            return phone_raw

        else:
            dct = {'phone': phone_raw, 'phone_type': 'SHORT_CODE'}
            return dct

    phone = re.sub('[/;].*$', '', phone_raw)
    phone = re.sub('[^+#*0-9]', '', phone)

    if country == 'ID':
        phone = re.sub('^0062|^062', '+62', phone)
        phone = re.sub('^\+0', '0', phone)

        if phone in ('+62', '62'):
            return None

    try:
        x = phonenumbers.parse(phone, country)
        phone = '+{}{}'.format(x.country_code, x.national_number)

        if not metadata:
            return phone

        else:
            location = geocoder.description_for_number(x, lang)
            phone_type = PHONE_TYPE[phonenumbers.number_type(x)]
            telco = carrier.name_for_number(x, lang)

            dct = {'phone': phone, 'phone_type': phone_type}

            if location:
                dct['location'] = location

            if telco:
                dct['carrier'] = telco

    except:
        if not metadata:
            return phone_raw

        else:
            dct = {'phone': phone_raw}

    return dct
Пример #21
0
def isTollFreeNumber(number, region='US'):
    """ returns True if number is a TollFree Number """
    try:
        p = phonenumbers.parse(number, 'US')
    except phonenumbers.NumberParseException:
        return False

    if phonenumbers.number_type(p) == \
            phonenumbers.PhoneNumberType.TOLL_FREE:
        return True

    return False
Пример #22
0
    def clean_number(self):
        try:
            data = phonenumbers.parse(self.cleaned_data['number'], None)

            if not phonenumbers.number_type(data) == PhoneNumberType.MOBILE:
                raise forms.ValidationError(
                    'Please enter a valid mobile phone number.')

            return '+{}{}'.format(data.country_code, data.national_number)
        except NumberParseException:
            raise forms.ValidationError(
                validate_international_phonenumber.message)
Пример #23
0
    def check_valid_phonenumber(self):
        if not phonenumbers or self.type not in _PHONE_TYPES:
            return

        Configuration = Pool().get('party.configuration')
        config = Configuration(1)
        if config.party_phonecountry:
            code = config.party_phonecountry.code

        try:
            phonenumber = phonenumbers.parse(self.value, region=code)
        except NumberParseException:
            self.raise_user_error('invalid_phonenumber', {
                'phone': self.value,
                'party': self.party.rec_name
            })
        else:
            if not phonenumbers.is_possible_number(
                    phonenumber) or not phonenumbers.is_valid_number(
                        phonenumber):
                self.raise_user_error('invalid_phonenumber', {
                    'phone': self.value,
                    'party': self.party.rec_name
                })
            elif phonenumbers.number_type(
                    phonenumber
            ) == PhoneNumberType.FIXED_LINE and self.type == 'mobile':
                self.raise_user_warning(
                    'warn_fixed_line_phone.%d' % self.id,
                    'The phone number "%(phone)s" is a fixed line number.',
                    {'phone': self.value},
                )
            elif phonenumbers.number_type(
                    phonenumber
            ) == PhoneNumberType.MOBILE and self.type != 'mobile':
                self.raise_user_warning(
                    'warn_mobile_line_phone.%d' % self.id,
                    'The phone number "%(phone)s" is a mobile line number.',
                    {'phone': self.value},
                )
def do(x):
    phonenumber = phonenumbers.parse(x, 'NZ')
    print "Raw: %s" % x
    print "PhoneNumber: %s" % phonenumber
    print "National: %s" % phonenumbers.format_number(phonenumber, phonenumbers.PhoneNumberFormat.NATIONAL)
    print "International: %s" % phonenumbers.format_number(phonenumber, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
    print "E164: %s" % phonenumbers.format_number(phonenumber, phonenumbers.PhoneNumberFormat.E164)
    print "Possible Number: %s" % phonenumbers.is_valid_number(phonenumber)
    print "Valid Number: %s" % phonenumbers.is_possible_number(phonenumber)
    print "Type: %s" % phonenumbers.number_type(phonenumber)

    print "*********************"
    print '\n'
Пример #25
0
 def call_success(self):
     """ Prepare crm.phonecall creation. """
     categ = self.with_context(lang='en_US').env['crm.case.categ'].search([
         ('name', '=', 'Outbound')
     ])
     case_section = self.env['crm.case.section'].search([('member_ids',
                                                          'in', self._uid)])
     action_ctx = self.env.context.copy()
     now = self.env.context.get('timestamp')
     if isinstance(now, int):
         now = datetime.fromtimestamp(now / float(1000))
     else:
         now = fields.Datetime.from_string(now)
     call_time = datetime.now() - now
     action_ctx.update({
         'default_categ_id':
         categ and categ[0].id or False,
         'default_section_id':
         case_section and case_section[0].id or False,
         'default_state':
         'done',
         'default_description':
         self.comments,
         'default_name':
         self.env.context.get('call_name'),
         'default_duration':
         call_time.total_seconds() / 60,
     })
     partner_id = self.env.context.get('click2dial_id')
     action_ctx['default_partner_id'] = partner_id
     domain = [('partner_id', '=', partner_id)]
     parsed_num = phonenumbers.parse(self.env.context.get('phone_number'))
     number_type = phonenumbers.number_type(parsed_num)
     if number_type == 1:
         action_ctx['default_partner_mobile'] = \
             self.env.context.get('phone_number')
     else:
         action_ctx['default_partner_phone'] = \
             self.env.context.get('phone_number')
     return {
         'name': _('Phone Call'),
         'domain': domain,
         'res_model': 'crm.phonecall',
         'view_mode': 'form,tree',
         'type': 'ir.actions.act_window',
         'nodestroy': False,  # close the pop-up wizard after action
         'target': 'current',
         'context': action_ctx,
     }
Пример #26
0
def lookup(phonenum):
    returndict = {}
    phoneobj = phonenumbers.parse(phonenum)
    returndict['valid'] = phonenumbers.is_valid_number(phoneobj)
    returndict['local_format'] = phonenumbers.format_in_original_format(
        phoneobj, 'local')
    returndict[
        'intl_format'] = phonenumbers.format_out_of_country_keeping_alpha_chars(
            phoneobj, 'world')
    returndict['carrier'] = carrier.name_for_number(phoneobj, "en")
    returndict['country_code'] = geocoder.region_code_for_number(phoneobj)
    returndict['country_name'] = geocoder.country_name_for_number(
        phoneobj, "en")
    returndict['location'] = geocoder.description_for_number(phoneobj, "en")
    returndict['line_type'] = get_type(phonenumbers.number_type(phoneobj))
    return json.dumps(returndict)
Пример #27
0
 def default_get(self, fields_list):
     res = super(NumberNotFound, self).default_get(fields_list)
     if not res:
         res = {}
     if res.get('calling_number'):
         convert = self.env['res.partner']._generic_reformat_phonenumbers(
             None, {'phone': res.get('calling_number')})
         parsed_num = phonenumbers.parse(convert.get('phone'))
         res['e164_number'] = phonenumbers.format_number(
             parsed_num, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
         number_type = phonenumbers.number_type(parsed_num)
         if number_type == 1:
             res['number_type'] = 'mobile'
         else:
             res['number_type'] = 'phone'
     return res
def do(x):
    phonenumber = phonenumbers.parse(x, 'NZ')
    print "Raw: %s" % x
    print "PhoneNumber: %s" % phonenumber
    print "National: %s" % phonenumbers.format_number(
        phonenumber, phonenumbers.PhoneNumberFormat.NATIONAL)
    print "International: %s" % phonenumbers.format_number(
        phonenumber, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
    print "E164: %s" % phonenumbers.format_number(
        phonenumber, phonenumbers.PhoneNumberFormat.E164)
    print "Possible Number: %s" % phonenumbers.is_valid_number(phonenumber)
    print "Valid Number: %s" % phonenumbers.is_possible_number(phonenumber)
    print "Type: %s" % phonenumbers.number_type(phonenumber)

    print "*********************"
    print '\n'
 def default_get(self, cr, uid, fields_list, context=None):
     res = super(number_not_found, self).default_get(
                 cr, uid, fields_list, context=context)
     if not res:
         res = {}
     if res.get('calling_number'):
         convert = self.pool['phone.common']._generic_reformat_phonenumbers(
             cr, uid, {'phone': res.get('calling_number')}, context=context)
         parsed_num = phonenumbers.parse(convert.get('phone'))
         res['e164_number'] = phonenumbers.format_number(
             parsed_num, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
         number_type = phonenumbers.number_type(parsed_num)
         if number_type == 1:
             res['number_type'] = 'mobile'
         else:
             res['number_type'] = 'phone'
     return res
Пример #30
0
def correct_mobile(mobile, country, raise_exception=False):
    try:
        mobile = mobile.replace(' ', '')
        country = country.upper()
        if country in ['KW', 'OM', 'BH', 'QA'] and not mobile.startswith('00') and mobile.startswith('0'):
            mobile = mobile[1:]
        p = phonenumbers.parse(mobile, country)
        fixed_line = phonenumbers.phonenumberutil.PhoneNumberType.FIXED_LINE
        if phonenumbers.is_valid_number(p) and phonenumbers.number_type(p) != fixed_line:
            mobile = phonenumbers.format_number(p, phonenumbers.PhoneNumberFormat.E164)
        else:
            raise ValueError()
    except (phonenumbers.NumberParseException, ValueError):
        if raise_exception:
            raise ValidationError(_("Is not valid in %(country)s") % {'country': COUNTRY_ISO[country]})
        mobile = ''
    return mobile
Пример #31
0
    def _abides_by_the_rule(self, value) -> bool:
        # Fail when the format of the given file is not in the formats list.
        try:
            number = phonenumbers.parse(value, None)
        except phonenumbers.NumberParseException:
            return False

        phoneType = phonenumbers.number_type(number)

        if phoneType == phonenumbers.PhoneNumberType.MOBILE:
            return self.phoneType == 'mobile'
        elif phoneType == phonenumbers.PhoneNumberType.FIXED_LINE:
            return self.phoneType == 'landline'
        elif phoneType == phonenumbers.PhoneNumberType.FIXED_LINE_OR_MOBILE:
            return True
        else:
            return False
Пример #32
0
def number_to_text(num):
    try:
        if not num.startswith('+'):
            num = '+' + num

        x = phonenumbers.parse(num)

        def number_type_desc(num_type):
            if num_type == PhoneNumberType.PREMIUM_RATE:
                return 'premium-rate'
            elif num_type == PhoneNumberType.TOLL_FREE:
                return 'toll-free'
            elif num_type == PhoneNumberType.MOBILE:
                return 'mobile'
            elif num_type == PhoneNumberType.FIXED_LINE:
                return 'fixed-line'
            elif num_type == PhoneNumberType.FIXED_LINE_OR_MOBILE:
                return 'fixed-line or mobile'
            elif num_type == PhoneNumberType.SHARED_COST:
                return 'shared cost'
            elif num_type == PhoneNumberType.VOIP:
                return 'VoIP'
            elif num_type == PhoneNumberType.PERSONAL_NUMBER:
                return 'personal number'
            elif num_type == PhoneNumberType.PAGER:
                return 'pager'
            elif num_type == PhoneNumberType.UAN:
                return 'company "universal access number"'
            elif num_type == PhoneNumberType.VOICEMAIL:
                return 'voicemail'
            else:
                return 'unknown type'

        number = phonenumbers.format_number(x, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
        numtype = number_type_desc(phonenumbers.number_type(x))
        country = geocoder.country_name_for_number(x, "en")
        desc = geocoder.description_for_number(x, "en")

        if not desc or desc == country:
            return '%s\n%s - %s' % (number, country, numtype)
        else:
            return '%s\n%s, %s - %s' % (number, desc, country, numtype)

    except:
        return '%s\ninvalid' % (num)
Пример #33
0
def _parseNumber(num):
    if num:
        try:
            num = num.replace(' ', '').replace('/', '').replace('-', '')
            if num:
                num = phonenumbers.parse(num, region='DE')
                num_type = phonenumbers.number_type(num)
                if phonenumbers.is_valid_number(num) and num_type in [
                        phonenumbers.PhoneNumberType.FIXED_LINE,
                        phonenumbers.PhoneNumberType.PERSONAL_NUMBER,
                        phonenumbers.PhoneNumberType.MOBILE,
                        phonenumbers.PhoneNumberType.FIXED_LINE_OR_MOBILE
                ]:
                    return phonenumbers.format_number(
                        num, phonenumbers.PhoneNumberFormat.E164)
        except phonenumbers.NumberParseException as e:
            logger.warning(f'Number "{num}" caused an exception: ' + str(e))
    return None
Пример #34
0
    def check_phone_number(cls, v):
        if v is None:
            return v
        try:
            n = parse_phone_number(v, "RO")
        except NumberParseException as e:
            raise ValueError(
                "Please provide a valid mobile phone number") from e

        if not is_valid_number(n) or number_type(n) not in (
                PhoneNumberType.MOBILE,
                PhoneNumberType.FIXED_LINE_OR_MOBILE,
        ):
            raise ValueError("Please provide a valid mobile phone number")

        return format_number(
            n, PhoneNumberFormat.NATIONAL
            if n.country_code == 44 else PhoneNumberFormat.INTERNATIONAL)
Пример #35
0
 def default_get(self, cr, uid, fields_list, context=None):
     res = super(number_not_found, self).default_get(
         cr, uid, fields_list, context=context
     )
     if not res:
         res = {}
     if res.get('calling_number'):
         convert = self.pool['res.partner']._generic_reformat_phonenumbers(
             cr, uid, None, {'phone': res.get('calling_number')},
             context=context)
         parsed_num = phonenumbers.parse(convert.get('phone'))
         res['e164_number'] = phonenumbers.format_number(
             parsed_num, phonenumbers.PhoneNumberFormat.INTERNATIONAL)
         number_type = phonenumbers.number_type(parsed_num)
         if number_type == 1:
             res['number_type'] = 'mobile'
         else:
             res['number_type'] = 'phone'
     return res
Пример #36
0
 def _create_open_crm_phonecall(self, crm_categ):
     categ = self.with_context(lang='en_US').env['crm.case.categ'].search([
         ('name', '=', crm_categ)
     ])
     case_section = self.env['crm.case.section'].search([('member_ids',
                                                          'in', self._uid)])
     action_ctx = self.env.context.copy()
     action_ctx.update({
         'default_categ_id':
         categ and categ[0].id or False,
         'default_section_id':
         case_section and case_section[0].id or False,
     })
     domain = False
     if self.env.context.get('click2dial_model') == 'res.partner':
         partner_id = self.env.context.get('click2dial_id')
         action_ctx['default_partner_id'] = partner_id
         domain = [('partner_id', '=', partner_id)]
     elif self.env.context.get('click2dial_model') == 'crm.lead':
         lead_id = self.env.context.get('click2dial_id')
         action_ctx['default_opportunity_id'] = lead_id
         domain = [('opportunity_id', '=', lead_id)]
     parsed_num = phonenumbers.parse(self.env.context.get('phone_number'))
     number_type = phonenumbers.number_type(parsed_num)
     if number_type == 1:
         action_ctx['default_partner_mobile'] =\
             self.env.context.get('phone_number')
     else:
         action_ctx['default_partner_phone'] =\
             self.env.context.get('phone_number')
     return {
         'name': _('Phone Call'),
         'domain': domain,
         'res_model': 'crm.phonecall',
         'view_mode': 'form,tree',
         'type': 'ir.actions.act_window',
         'nodestroy': False,  # close the pop-up wizard after action
         'target': 'current',
         'context': action_ctx,
     }
 def _create_open_crm_phonecall(self, crm_categ):
     categ = self.with_context(lang='en_US').env['crm.case.categ'].search(
         [('name', '=', crm_categ)])
     case_section = self.env['crm.case.section'].search(
         [('member_ids', 'in', self._uid)])
     action_ctx = self.env.context.copy()
     action_ctx.update({
         'default_categ_id': categ and categ[0].id or False,
         'default_section_id':
         case_section and case_section[0].id or False,
     })
     domain = False
     if self.env.context.get('click2dial_model') == 'res.partner':
         partner_id = self.env.context.get('click2dial_id')
         action_ctx['default_partner_id'] = partner_id
         domain = [('partner_id', '=', partner_id)]
     elif self.env.context.get('click2dial_model') == 'crm.lead':
         lead_id = self.env.context.get('click2dial_id')
         action_ctx['default_opportunity_id'] = lead_id
         domain = [('opportunity_id', '=', lead_id)]
     parsed_num = phonenumbers.parse(self.env.context.get('phone_number'))
     number_type = phonenumbers.number_type(parsed_num)
     if number_type == 1:
         action_ctx['default_partner_mobile'] =\
             self.env.context.get('phone_number')
     else:
         action_ctx['default_partner_phone'] =\
             self.env.context.get('phone_number')
     return {
         'name': _('Phone Call'),
         'domain': domain,
         'res_model': 'crm.phonecall',
         'view_mode': 'form,tree',
         'type': 'ir.actions.act_window',
         'nodestroy': False,  # close the pop-up wizard after action
         'target': 'current',
         'context': action_ctx,
     }
Пример #38
0
def validate_phone_number(phone_number, faults):
    if not isinstance(phone_number, dict):
        faults.append('phone_number must be a dict')
        return
    if not 'number' in phone_number.keys():
        faults.append('phone_number must contain the field \'number\'')
        return
    if not 'country_code' in phone_number.keys():
        faults.append('phone_number must contain the field \'country_code\'')
        return
    try:
        number = phonenumbers.parse(str(phone_number['number']), str(phone_number['country_code']))
        valid = phonenumbers.is_valid_number(number)
        if not valid:
            faults.append(
                'The phone number %s (country %s) is invalid.' % (phone_number['number'], phone_number['country_code']))
            return
        number_type = phonenumbers.number_type(number)
        if number_type != PhoneNumberType.MOBILE:
            faults.append('The phone number %s (country %s) is not a mobile number.' % (phone_number['number'], phone_number['country_code']))
    except Exception as e:
        faults.append('The phone number %s (country %s) is invalid. Reason: %s' % (
            phone_number['number'], phone_number['country_code'], str(e)))
Пример #39
0
 def get_typeid(self):
     self.phonenumber_details['typeid'] = dicts.phonenumber_types.get(phonenumbers.number_type(self.phonenumber_object))
     return self.phonenumber_details['typeid']