Members.app_purchase_user_license() - Code Metrics - Inspection of "[FIX] bugs and issues reported by flake8" - route4me/route4me-python-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 022c91...926271 )

by Juan Jose

created 2017-03-02 07:32 UTC

Members.app_purchase_user_license() B

↳ 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	24
rs	8.9713

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

route4me / route4me-python-sdk

GitHub Access Token became invalid

Push — master ( 022c91...926271 )

Members.app_purchase_user_license() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like