Members.webinar_registration() - Code Metrics - Inspection of "Merge branch 'master' of https://github.com/route4..." - route4me/route4me-python-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( e3a209...bb2a36 )

by Juan Jose

created 2017-03-02 05:37 UTC

Members.webinar_registration() A

↳ Parent: Members

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
c	1
b	0
f	0
dl	0
loc	22
rs	9.2

import json
from route4me.base import Base
from route4me.exceptions import ParamValueException
from route4me.utils import json2obj
from route4me.api_endpoints import MEMBER_AUTHENTICATE, \
    USER_LICENSE_HOST, VALIDATE_SESSION, WEBINAR_REGISTER, VERIFY_DEVICE_LICENSE, \
    GET_USERS_HOST, USER_URL


class Members(Base):
    """
    Members management.
    """

    def __init__(self, api):
        """
        Members Instance
        :param api:
        :return:
        """
        Base.__init__(self, api)

    def app_purchase_user_license(self, **kwargs):
        """
        Application purchase user License
        :param kwargs:
        :return: API response content
        """
        if self.check_required_params(kwargs, ['member_id',
                                               'session_guid',
                                               'device_id',
                                               'device_type',
                                               'subscription_name',
                                               'token',
                                               'payload',
                                               'format', ]):
            response = self.api._request_post(USER_LICENSE_HOST,
                                              self.params,
                                              data=json.dumps(kwargs, ensure_ascii=False))
            try:
                return json.loads(response.content)
            except ValueError:
                return response.content
        else:
            raise ParamValueException('order', 'Missing required params')

    def verify_device_license(self, **kwargs):
        """
        Verify User License
        :param kwargs:
        :return: API response content
        """
        if self.check_required_params(kwargs, ['device_id',
                                               'device_type',
                                               'format', ]):
            response = self.api._request_post(VERIFY_DEVICE_LICENSE,
                                              self.params,
                                              data=json.dumps(kwargs, ensure_ascii=False))
            try:
                return json.loads(response.content)
            except ValueError:
                return response.content
        else:
            raise ParamValueException('order', 'Missing required params')

    def member_authenticate(self, **kwargs):
        """
        Member Authenticate
        :param kwargs:
        :return: API response content
        """
        if self.check_required_params(kwargs, ['email',
                                               'password', ]):
            kwargs['strEmail'] = kwargs.pop('email')
            kwargs['strPassword'] = kwargs.pop('password')
            response = self.api._request_post(MEMBER_AUTHENTICATE,
                                              self.params,
                                              data=kwargs)
            try:
                return json.loads(response.content)
            except ValueError:
                return response.content
        else:
            raise ParamValueException('order', 'Missing required params')

    def get_users(self, **kwargs):
        """
        Get users using GET request
        :return: API response
        """
        kwargs.update({'api_key': self.params['api_key'], })
        response = self.api._request_get(GET_USERS_HOST,
                                         kwargs)
        try:
            return response.json()
        except ValueError:
            return response.content

    def get_api_key_users(self, **kwargs):
        """
        Get users taht belong to a given api_key using GET request
        :return: API response
        """
        kwargs.update({'api_key': self.params['api_key'], })
        response = self.api._request_get(USER_URL,
                                         kwargs)
        try:
            return response.json()
        except ValueError:
            return response.content

    def validate_session(self, **kwargs):
        """
        Validate Session
        :param kwargs:
        :return: API response content
        """
        kwargs.update({'api_key': self.params['api_key'], })
        if self.check_required_params(kwargs, ['session_guid',
                                               'member_id', ]):
            response = self.api._request_get(VALIDATE_SESSION,
                                             kwargs)
            try:
                return json.loads(response.content)
            except ValueError:
                return response.content
        else:
            raise ParamValueException('order', 'Missing required params')

    def webinar_registration(self, **kwargs):
        """
        Webinar Register
        :param kwargs:
        :return: API response content
        """
        if self.check_required_params(kwargs, ["email_address",
                                               "first_name",
                                               "last_name",
                                               "phone_number",
                                               "company_name",
                                               "member_id",
                                               "webiinar_date"]):
            response = self.api._request_post(WEBINAR_REGISTER,
                                              self.params,
                                              data=kwargs)
            try:
                return json.loads(response.content)
            except ValueError:
                return response.content
        else:
            raise ParamValueException('order', 'Missing required params')

    def register(self, **kwargs):
        """
        Register Action
        :param kwargs:
        :return: API response content
        """
        if self.check_required_params(kwargs, ["industry",
                                               "first_name",
                                               "last_name",
                                               "email_address",
                                               "check_terms",
                                               "device_type",
                                               "plan",
                                               "password_1",
                                               "password_2",
                                               "format"]):
            params = {'plan': kwargs.pop('plan')}
            kwargs['strIndustry'] = kwargs.pop('industry')
            kwargs['strFirstName'] = kwargs.pop('first_name')
            kwargs['strLastName'] = kwargs.pop('last_name')
            kwargs['strEmail'] = kwargs.pop('email_address')
            kwargs['chkTerms'] = kwargs.pop('check_terms')
            kwargs['device_type'] = kwargs.pop('device_type')
            kwargs['strPassword_1'] = kwargs.pop('password_1')
            kwargs['strPassword_2'] = kwargs.pop('password_2')
            response = self.api._request_post(self.api.register_action_url(),
                                              params,
                                              data=kwargs)
            try:
                return response.json()
            except ValueError:
                return response.content
        else:
            raise ParamValueException('order', 'Missing required params')


1			import json
2			from route4me.base import Base
3			from route4me.exceptions import ParamValueException
4			from route4me.utils import json2obj
5			from route4me.api_endpoints import MEMBER_AUTHENTICATE, \
6			USER_LICENSE_HOST, VALIDATE_SESSION, WEBINAR_REGISTER, VERIFY_DEVICE_LICENSE, \
7			GET_USERS_HOST, USER_URL
8
9
10			class Members(Base):
11			"""
12			Members management.
13			"""
14
15			def __init__(self, api):
16			"""
17			Members Instance
18			:param api:
19			:return:
20			"""
21			Base.__init__(self, api)
22
23			def app_purchase_user_license(self, **kwargs):
24			"""
25			Application purchase user License
26			:param kwargs:
27			:return: API response content
28			"""
29			if self.check_required_params(kwargs, ['member_id',
30			'session_guid',
31			'device_id',
32			'device_type',
33			'subscription_name',
34			'token',
35			'payload',
36			'format', ]):
37			response = self.api._request_post(USER_LICENSE_HOST,
38			self.params,
39			data=json.dumps(kwargs, ensure_ascii=False))
40			try:
41			return json.loads(response.content)
42			except ValueError:
43			return response.content
44			else:
45			raise ParamValueException('order', 'Missing required params')
46
47			def verify_device_license(self, **kwargs):
48			"""
49			Verify User License
50			:param kwargs:
51			:return: API response content
52			"""
53			if self.check_required_params(kwargs, ['device_id',
54			'device_type',
55			'format', ]):
56			response = self.api._request_post(VERIFY_DEVICE_LICENSE,
57			self.params,
58			data=json.dumps(kwargs, ensure_ascii=False))
59			try:
60			return json.loads(response.content)
61			except ValueError:
62			return response.content
63			else:
64			raise ParamValueException('order', 'Missing required params')
65
66			def member_authenticate(self, **kwargs):
67			"""
68			Member Authenticate
69			:param kwargs:
70			:return: API response content
71			"""
72			if self.check_required_params(kwargs, ['email',
73			'password', ]):
74			kwargs['strEmail'] = kwargs.pop('email')
75			kwargs['strPassword'] = kwargs.pop('password')
76			response = self.api._request_post(MEMBER_AUTHENTICATE,
77			self.params,
78			data=kwargs)
79			try:
80			return json.loads(response.content)
81			except ValueError:
82			return response.content
83			else:
84			raise ParamValueException('order', 'Missing required params')
85
86			def get_users(self, **kwargs):
87			"""
88			Get users using GET request
89			:return: API response
90			"""
91			kwargs.update({'api_key': self.params['api_key'], })
92			response = self.api._request_get(GET_USERS_HOST,
93			kwargs)
94			try:
95			return response.json()
96			except ValueError:
97			return response.content
98
99			def get_api_key_users(self, **kwargs):
100			"""
101			Get users taht belong to a given api_key using GET request
102			:return: API response
103			"""
104			kwargs.update({'api_key': self.params['api_key'], })
105			response = self.api._request_get(USER_URL,
106			kwargs)
107			try:
108			return response.json()
109			except ValueError:
110			return response.content
111
112			def validate_session(self, **kwargs):
113			"""
114			Validate Session
115			:param kwargs:
116			:return: API response content
117			"""
118			kwargs.update({'api_key': self.params['api_key'], })
119			if self.check_required_params(kwargs, ['session_guid',
120			'member_id', ]):
121			response = self.api._request_get(VALIDATE_SESSION,
122			kwargs)
123			try:
124			return json.loads(response.content)
125			except ValueError:
126			return response.content
127			else:
128			raise ParamValueException('order', 'Missing required params')
129
130			def webinar_registration(self, **kwargs):
131			"""
132			Webinar Register
133			:param kwargs:
134			:return: API response content
135			"""
136			if self.check_required_params(kwargs, ["email_address",
137			"first_name",
138			"last_name",
139			"phone_number",
140			"company_name",
141			"member_id",
142			"webiinar_date"]):
143			response = self.api._request_post(WEBINAR_REGISTER,
144			self.params,
145			data=kwargs)
146			try:
147			return json.loads(response.content)
148			except ValueError:
149			return response.content
150			else:
151			raise ParamValueException('order', 'Missing required params')
152
153			def register(self, **kwargs):
154			"""
155			Register Action
156			:param kwargs:
157			:return: API response content
158			"""
159			if self.check_required_params(kwargs, ["industry",
160			"first_name",
161			"last_name",
162			"email_address",
163			"check_terms",
164			"device_type",
165			"plan",
166			"password_1",
167			"password_2",
168			"format"]):
169			params = {'plan': kwargs.pop('plan')}
170			kwargs['strIndustry'] = kwargs.pop('industry')
171			kwargs['strFirstName'] = kwargs.pop('first_name')
172			kwargs['strLastName'] = kwargs.pop('last_name')
173			kwargs['strEmail'] = kwargs.pop('email_address')
174			kwargs['chkTerms'] = kwargs.pop('check_terms')
175			kwargs['device_type'] = kwargs.pop('device_type')
176			kwargs['strPassword_1'] = kwargs.pop('password_1')
177			kwargs['strPassword_2'] = kwargs.pop('password_2')
178			response = self.api._request_post(self.api.register_action_url(),
179			params,
180			data=kwargs)
181			try:
182			return response.json()
183			except ValueError:
184			return response.content
185			else:
186			raise ParamValueException('order', 'Missing required params')
187

route4me / route4me-python-sdk

GitHub Access Token became invalid

Push — master ( e3a209...bb2a36 )

Members.webinar_registration() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like