def test_01_get_provider_class(self):
_provider =get_sms_provider_class(
"privacyidea.lib.smsprovider.SipgateSMSProvider",
"SipgateSMSProvider")
_provider =get_sms_provider_class(
"privacyidea.lib.smsprovider.HttpSMSProvider",
"HttpSMSProvider")
_provider =get_sms_provider_class(
"privacyidea.lib.smsprovider.SmtpSMSProvider",
"SmtpSMSProvider")
_provider =get_sms_provider_class(
"privacyidea.lib.smsprovider.SmppSMSProvider",
"SmppSMSProvider")
# A non-existing module will raise an error
self.assertRaises(Exception,
get_sms_provider_class,
"DoesNotExist",
"DoesNotExist")
# Any other arbitrary class will raise an error, since it has not
# submit_method
self.assertRaises(Exception,
get_sms_provider_class,
"privacyidea.lib.smsprovider.SMSProvider",
"SMSError")
def test_01_get_provider_class(self):
_provider =get_sms_provider_class(
"privacyidea.lib.smsprovider.SipgateSMSProvider",
"SipgateSMSProvider")
_provider =get_sms_provider_class(
"privacyidea.lib.smsprovider.HttpSMSProvider",
"HttpSMSProvider")
_provider =get_sms_provider_class(
"privacyidea.lib.smsprovider.SmtpSMSProvider",
"SmtpSMSProvider")
_provider =get_sms_provider_class(
"privacyidea.lib.smsprovider.SmppSMSProvider",
"SmppSMSProvider")
# A non-existing module will raise an error
self.assertRaises(Exception,
get_sms_provider_class,
"DoesNotExist",
"DoesNotExist")
# Any other arbitrary class will raise an error, since it has not
# submit_method
self.assertRaises(Exception,
get_sms_provider_class,
"privacyidea.lib.smsprovider.SMSProvider",
"SMSError")
def get_gateway(gwid=None):
"""
returns a json list of the gateway definitions
Or
returns a list of available sms providers with their configuration
/smsgateway/providers
"""
res = {}
# TODO: if the gateway definitions contains a password normal users should
# not be allowed to read the configuration. Normal users should only be
# allowed to read the identifier of the definitions!
if gwid == "providers":
for classname in SMS_PROVIDERS:
smsclass = get_sms_provider_class(
classname.rsplit(".", 1)[0],
classname.rsplit(".", 1)[1])
res[classname] = smsclass.parameters()
else:
res = [gw.as_dict() for gw in get_smsgateway(id=gwid)]
g.audit_object.log({"success": True})
return send_result(res)
def _send_sms(self, message="<otp>"):
"""
send sms
:param message: the sms submit message - could contain placeholders
like <otp> or <serial>
:type message: string
:return: submitted message
:rtype: string
"""
ret = None
phone = self.get_tokeninfo("phone")
otp = self.get_otp()[2]
serial = self.get_serial()
message = message.replace("<otp>", otp)
message = message.replace("<serial>", serial)
log.debug("sending SMS to phone number {0!s} ".format(phone))
# First we try to get the new SMS gateway config style
sms_gateway_identifier = get_from_config("sms.identifier")
if sms_gateway_identifier:
# New style
sms = create_sms_instance(sms_gateway_identifier)
else:
# Old style
(SMSProvider, SMSProviderClass) = self._get_sms_provider()
log.debug("smsprovider: {0!s}, class: {1!s}".format(
SMSProvider, SMSProviderClass))
try:
sms = get_sms_provider_class(SMSProvider, SMSProviderClass)()
except Exception as exc:
log.error("Failed to load SMSProvider: {0!r}".format(exc))
log.debug("{0!s}".format(traceback.format_exc()))
raise exc
try:
# now we need the config from the env
log.debug(
"loading SMS configuration for class {0!s}".format(sms))
config = self._get_sms_provider_config()
log.debug("config: {0!r}".format(config))
sms.load_config(config)
except Exception as exc:
log.error(
"Failed to load sms.providerConfig: {0!r}".format(exc))
log.debug("{0!s}".format(traceback.format_exc()))
raise Exception(
"Failed to load sms.providerConfig: {0!r}".format(exc))
log.debug("submitMessage: {0!r}, to phone {1!r}".format(
message, phone))
ret = sms.submit_message(phone, message)
return ret, message
def _send_sms(self, message="<otp>"):
"""
send sms
:param message: the sms submit message - could contain placeholders
like <otp> or <serial>
:type message: string
:return: submitted message
:rtype: string
"""
ret = None
phone = self.get_tokeninfo("phone")
otp = self.get_otp()[2]
serial = self.get_serial()
message = message.replace("<otp>", otp)
message = message.replace("<serial>", serial)
log.debug("sending SMS to phone number {0!s} ".format(phone))
# First we try to get the new SMS gateway config style
sms_gateway_identifier = get_from_config("sms.identifier")
if sms_gateway_identifier:
# New style
sms = create_sms_instance(sms_gateway_identifier)
else:
# Old style
(SMSProvider, SMSProviderClass) = self._get_sms_provider()
log.debug("smsprovider: {0!s}, class: {1!s}".format(SMSProvider,
SMSProviderClass))
try:
sms = get_sms_provider_class(SMSProvider, SMSProviderClass)()
except Exception as exc:
log.error("Failed to load SMSProvider: {0!r}".format(exc))
log.debug("{0!s}".format(traceback.format_exc()))
raise exc
try:
# now we need the config from the env
log.debug("loading SMS configuration for class {0!s}".format(sms))
config = self._get_sms_provider_config()
log.debug("config: {0!r}".format(config))
sms.load_config(config)
except Exception as exc:
log.error("Failed to load sms.providerConfig: {0!r}".format(exc))
log.debug("{0!s}".format(traceback.format_exc()))
raise Exception("Failed to load sms.providerConfig: {0!r}".format(exc))
log.debug("submitMessage: {0!r}, to phone {1!r}".format(message, phone))
ret = sms.submit_message(phone, message)
return ret, message
def _send_sms(self, message="<otp>"):
"""
send sms
:param message: the sms submit message - could contain placeholders
like <otp> or <serial>
:type message: string
:return: submitted message
:rtype: string
"""
ret = None
phone = self.get_tokeninfo("phone")
otp = self.get_otp()[2]
serial = self.get_serial()
message = message.replace("<otp>", otp)
message = message.replace("<serial>", serial)
log.debug("sending SMS to phone number %s " % phone)
(SMSProvider, SMSProviderClass) = self._get_sms_provider()
log.debug("smsprovider: %s, class: %s" % (SMSProvider,
SMSProviderClass))
try:
sms = get_sms_provider_class(SMSProvider, SMSProviderClass)()
except Exception as exc:
log.error("Failed to load SMSProvider: %r" % exc)
log.debug("%s" % traceback.format_exc())
raise exc
try:
# now we need the config from the env
log.debug("loading SMS configuration for class %s" % sms)
config = self._get_sms_provider_config()
log.debug("config: %r" % config)
sms.load_config(config)
except Exception as exc:
log.error("Failed to load sms.providerConfig: %r" % exc)
log.debug("%s" % traceback.format_exc())
raise Exception("Failed to load sms.providerConfig: %r" % exc)
log.debug("submitMessage: %r, to phone %r" % (message, phone))
ret = sms.submit_message(phone, message)
return ret, message
def _send_sms(self, message="<otp>"):
"""
send sms
:param message: the sms submit message - could contain placeholders
like <otp> or <serial>
:type message: string
:return: submitted message
:rtype: string
"""
ret = None
phone = self.get_tokeninfo("phone")
otp = self.get_otp()[2]
serial = self.get_serial()
message = message.replace("<otp>", otp)
message = message.replace("<serial>", serial)
log.debug("sending SMS to phone number %s " % phone)
(SMSProvider, SMSProviderClass) = self._get_sms_provider()
log.debug("smsprovider: %s, class: %s" % (SMSProvider,
SMSProviderClass))
try:
sms = get_sms_provider_class(SMSProvider, SMSProviderClass)()
except Exception as exc:
log.error("Failed to load SMSProvider: %r" % exc)
log.debug("%s" % traceback.format_exc())
raise exc
try:
# now we need the config from the env
log.debug("loading SMS configuration for class %s" % sms)
config = self._get_sms_provider_config()
log.debug("config: %r" % config)
sms.load_config(config)
except Exception as exc:
log.error("Failed to load sms.providerConfig: %r" % exc)
log.debug("%s" % traceback.format_exc())
raise Exception("Failed to load sms.providerConfig: %r" % exc)
log.debug("submitMessage: %r, to phone %r" % (message, phone))
ret = sms.submit_message(phone, message)
return ret, message
def get_gateway(gwid=None):
"""
returns a json list of the gateway definitions
Or
returns a list of available sms providers with their configuration
/smsgateway/providers
"""
res = {}
# TODO: if the gateway definitions contains a password normal users should
# not be allowed to read the configuration. Normal users should only be
# allowed to read the identifier of the definitions!
if gwid == "providers":
for classname in SMS_PROVIDERS:
smsclass = get_sms_provider_class(classname.rsplit(".", 1)[0],
classname.rsplit(".", 1)[1])
res[classname] = smsclass.parameters()
else:
res = [gw.as_dict() for gw in get_smsgateway(id=gwid)]
g.audit_object.log({"success": True})
return send_result(res)
def _send_sms(self, message="<otp>"):
"""
send sms
:param message: the sms submit message - could contain placeholders
like <otp> or <serial>
:type message: string
:return: submitted message
:rtype: string
"""
if is_true(self.get_tokeninfo("dynamic_phone")):
phone = self.user.get_user_phone("mobile")
if type(phone) == list and phone:
# if there is a non-empty list, we use the first entry
phone = phone[0]
else:
phone = self.get_tokeninfo("phone")
if not phone: # pragma: no cover
log.warning("Token {0!s} does not have a phone number!".format(
self.token.serial))
otp = self.get_otp()[2]
serial = self.get_serial()
message = message.replace("<otp>", otp)
message = message.replace("<serial>", serial)
log.debug("sending SMS to phone number {0!s} ".format(phone))
# First we try to get the new SMS gateway config style
# The token specific identifier has priority over the system wide identifier
sms_gateway_identifier = self.get_tokeninfo(
"sms.identifier") or get_from_config("sms.identifier")
if sms_gateway_identifier:
# New style
sms = create_sms_instance(sms_gateway_identifier)
else:
# Old style
(SMSProvider, SMSProviderClass) = self._get_sms_provider()
log.debug("smsprovider: {0!s}, class: {1!s}".format(
SMSProvider, SMSProviderClass))
try:
sms = get_sms_provider_class(SMSProvider, SMSProviderClass)()
except Exception as exc:
log.error("Failed to load SMSProvider: {0!r}".format(exc))
log.debug("{0!s}".format(traceback.format_exc()))
raise exc
try:
# now we need the config from the env
log.debug(
"loading SMS configuration for class {0!s}".format(sms))
config = self._get_sms_provider_config()
log.debug("config: {0!r}".format(config))
sms.load_config(config)
except Exception as exc:
log.error(
"Failed to load sms.providerConfig: {0!r}".format(exc))
log.debug("{0!s}".format(traceback.format_exc()))
raise Exception(
"Failed to load sms.providerConfig: {0!r}".format(exc))
log.debug("submitMessage: {0!r}, to phone {1!r}".format(
message, phone))
ret = sms.submit_message(phone, message)
return ret, message
def _send_sms(self, message="<otp>"):
"""
send sms
:param message: the sms submit message - could contain placeholders
like <otp> or <serial>
:type message: string
:return: submitted message
:rtype: string
"""
if is_true(self.get_tokeninfo("dynamic_phone")):
phone = self.user.get_user_phone("mobile")
if type(phone) == list and phone:
# if there is a non-empty list, we use the first entry
phone = phone[0]
else:
phone = self.get_tokeninfo("phone")
if not phone: # pragma: no cover
log.warning("Token {0!s} does not have a phone number!".format(self.token.serial))
otp = self.get_otp()[2]
serial = self.get_serial()
message = message.replace("<otp>", otp)
message = message.replace("<serial>", serial)
log.debug("sending SMS to phone number {0!s} ".format(phone))
# First we try to get the new SMS gateway config style
# The token specific identifier has priority over the system wide identifier
sms_gateway_identifier = self.get_tokeninfo("sms.identifier") or get_from_config("sms.identifier")
if sms_gateway_identifier:
# New style
sms = create_sms_instance(sms_gateway_identifier)
else:
# Old style
(SMSProvider, SMSProviderClass) = self._get_sms_provider()
log.debug("smsprovider: {0!s}, class: {1!s}".format(SMSProvider,
SMSProviderClass))
try:
sms = get_sms_provider_class(SMSProvider, SMSProviderClass)()
except Exception as exc:
log.error("Failed to load SMSProvider: {0!r}".format(exc))
log.debug("{0!s}".format(traceback.format_exc()))
raise exc
try:
# now we need the config from the env
log.debug("loading SMS configuration for class {0!s}".format(sms))
config = self._get_sms_provider_config()
log.debug("config: {0!r}".format(config))
sms.load_config(config)
except Exception as exc:
log.error("Failed to load sms.providerConfig: {0!r}".format(exc))
log.debug("{0!s}".format(traceback.format_exc()))
raise Exception("Failed to load sms.providerConfig: {0!r}".format(exc))
log.debug("submitMessage: {0!r}, to phone {1!r}".format(message, phone))
ret = sms.submit_message(phone, message)
return ret, message
