def add_topup(request):
form = CreditForm(request.POST)
if not form.is_valid():
error_msg = ""
for k, v in form.errors.items():
error_msg += "%s: %s\n" % (k, ", ".join(v))
return HttpResponse(json.dumps({
'success': False,
'msg': error_msg
}),
content_type="application/json")
subscriber_id = form.cleaned_data['userName']
transaction_id = form.cleaned_data['transactionId']
credit_amount = form.cleaned_data['creditAmount']
logger.debug(
"Adding topup for user (%s), with credit amount (%s), transaction id: (%s)",
subscriber_id, credit_amount, transaction_id)
pcrf_client = PCRFClient()
result = pcrf_client.credit_subscriber(subscriber_id, credit_amount)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message')
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), content_type="application/json")
def get(self, request, format=None, **kwargs):
serializer = kwargs['serializer']
card_number = serializer.validated_data['cardNumber']
port_number = serializer.validated_data['portNumber']
host_address = serializer.validated_data['deviceIp']
shelf_number = serializer.validated_data.get('shelfNumber')
community_id = serializer.validated_data['communityId']
transaction_id = serializer.validated_data.get('transactionId')
client = get_client(community_id)
result, msg, physical_status = client.get_subscriber_status(
host_address, port_number, card_number, shelf_number)
if not result:
response = {
'success': False,
'msg': "Error while getting ADSL subscriber, {0}".format(msg)
}
log_action("{0}.{1}".format(str(self), 'get'), request, response,
transaction_id)
return Response(response, status=status.HTTP_200_OK)
response = {'success': True, 'enabled': physical_status, 'msg': None}
log_action("{0}.{1}".format(str(self), 'get'), request, response,
transaction_id)
return Response(response, status=status.HTTP_200_OK)
def get_services(request):
logger.debug("Getting (%s) services for user (%s), transaction id: (%s)",
request.GET['serviceType'].encode('utf-8').strip(),
request.GET['userName'].encode('utf-8').strip(),
request.GET['transactionId'].encode('utf-8').strip())
form = ServiceForm(request.GET)
if not form.is_valid():
error_msg = ""
for k, v in form.errors.items():
error_msg += "%s: %s\n" % (k, ", ".join(v))
return HttpResponse(json.dumps({
'success': False,
'msg': error_msg
}),
content_type="application/json")
pcrf_client = PCRFClient()
result = pcrf_client.get_services(
subscriber_id=form.cleaned_data['userName'],
service_type=form.cleaned_data['serviceType'],
start_date=form.cleaned_data.get('startDate'),
end_date=form.cleaned_data.get('endDate'))
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
'services': result.get('services')
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=request.GET['transactionId'])
return HttpResponse(json.dumps(response), content_type="application/json")
def get_session(request):
form = InputForm(request.GET)
if not form.is_valid():
error_msg = ""
for k, v in form.errors.items():
error_msg += "%s: %s\n" % (k, ", ".join(v))
return HttpResponse(json.dumps({
'success': False,
'msg': error_msg
}),
content_type="application/json")
subscriber_id = form.cleaned_data['userName']
transaction_id = form.cleaned_data['transactionId']
logger.debug("Getting session for user (%s), transaction id: (%s)",
subscriber_id, transaction_id)
pcrf_client = PCRFClient()
result = pcrf_client.query_session(subscriber_id=subscriber_id)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
'session': result.get('session')
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), content_type="application/json")
def debit_user(request):
form = DebitForm(request.POST)
if not form.is_valid():
error_msg = ""
for k, v in form.errors.items():
error_msg += "%s: %s\n" % (k, ", ".join(v))
return HttpResponse(json.dumps({
'success': False,
'msg': error_msg
}),
content_type="application/json")
subscriber_id = form.cleaned_data['userName']
service_name = form.cleaned_data['serviceName']
debit_amount = int(form.cleaned_data['debitAmount'])
transaction_id = form.cleaned_data['transactionId']
logger.debug(
"Debiting user (%s), for service (%s), with amount (%s), transaction id: (%s)",
subscriber_id, service_name, debit_amount, transaction_id)
pcrf_client = PCRFClient()
result = pcrf_client.debit_subscriber(subscriber_id, service_name,
debit_amount)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), content_type="application/json")
def get_profile(request):
form = InputForm(request.GET)
if not form.is_valid():
error_msg = ""
for k, v in form.errors.items():
error_msg += "%s: %s\n" % (k, ", ".join(v))
return HttpResponse(json.dumps({
'success': False,
'msg': error_msg
}),
content_type="application/json")
subscriber_id = form.cleaned_data['userName']
transaction_id = form.cleaned_data['transactionId']
free_quota = form.cleaned_data['freeQuota']
pcrf_client = PCRFClient()
profile_result = pcrf_client.get_profile(subscriber_id=subscriber_id,
free_quota=free_quota)
logger.debug("Getting profile for user (%s), transaction id: (%s)",
subscriber_id, transaction_id)
if not profile_result['action_result']:
response = {
'success':
True if profile_result.get('action_error_message').endswith(
"does not exist") else profile_result['action_result'],
'msg':
profile_result.get('action_error_message'),
}
if 'not_exist' in profile_result:
response['not_exist'] = profile_result['not_exist']
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response),
content_type="application/json")
topups_result = pcrf_client.get_services(subscriber_id,
service_type='topup',
free_quota=free_quota)
response = {
'success':
True if topups_result.get('action_error_message',
'').endswith("does not exist") else
topups_result['action_result'],
'msg':
topups_result.get('action_error_message'),
'profile':
profile_result.get('profile'),
'topups':
topups_result.get('services')
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), content_type="application/json")
def create_or_change_service(request):
logger.debug(
"Creating or changing service (%s) for user (%s), transaction id: (%s)",
request.POST['serviceName'].encode('utf-8').strip(),
request.POST['userName'].encode('utf-8').strip(),
request.POST['transactionId'].encode('utf-8').strip())
form = CreateOrChangeForm(request.POST)
if not form.is_valid():
error_msg = ""
for k, v in form.errors.items():
error_msg += "%s: %s\n" % (k, ", ".join(v))
return HttpResponse(json.dumps({
'success': False,
'msg': error_msg
}),
content_type="application/json")
pcrf_client = PCRFClient()
result = pcrf_client.provision_subscriber(
subscriber_id=form.cleaned_data['userName'],
service_name=form.cleaned_data['serviceName'],
start_date=form.cleaned_data['startDate'],
end_date=form.cleaned_data['endDate'],
reset_consumed=form.cleaned_data['resetConsumed'],
carry_over=form.cleaned_data.get('carryOver'))
response = {
'success': result['action_result'],
'msg': result.get('action_error_message')
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=request.POST['transactionId'])
return HttpResponse(json.dumps(response), content_type="application/json")
def get_user_by_ip(request):
form = IpInputForm(request.GET)
if not form.is_valid():
error_msg = ""
for k, v in form.errors.items():
error_msg += k + ": " + ", ".join(v) + "\n"
logger.error(error_msg)
result = {'error': True, 'error_message': error_msg}
return HttpResponse(json.dumps(result),
content_type="application/json")
logger.debug("Getting username for ip (%s)", request.GET['ipAddress'])
aaa_client = AAAClient()
result = aaa_client.get_session_by_ip(
request.GET['ipAddress'].encode('utf-8').strip())
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
'username': result.get('username')
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=request.GET['transactionId'])
return HttpResponse(json.dumps(response), content_type="application/json")
def get_full_session(request):
logger.debug("Getting full session for username (%s)",
request.GET['userName'])
aaa_client = AAAClient()
result = aaa_client.get_full_session(
request.GET['userName'].encode('utf-8').strip())
sessions = result.get('sessions')
formatted_sessions = []
if sessions:
for session in sessions:
formatted_session = {}
for k, v in session.items():
formatted_session[k.lower().replace('-', '_')] = v
formatted_sessions.append(formatted_session)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
'sessions': formatted_sessions
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=request.GET['transactionId'])
return HttpResponse(json.dumps(response), content_type="application/json")
def block_iptv_subscription(request):
client = IPTVClient()
customer_number = request.POST['customerNumber']
result = client.create_iptv_session()
transaction_id = request.POST['transactionId']
if not result['action_result']:
response = {
'success': False,
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), mimetype="application/json")
session_id = result['session_id']
result = client.fetch_tv_subscriptions(session_id, customer_number)
if not result['action_result']:
response = {
'success': False,
'msg': result.get('action_error_message'),
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
if not result['subscription'][0] or not result['subscription'][
0].tvSubscriptionId:
response = {
'success': False,
'msg':
"Subscriber (%s) has no IPTV subscriptions." % customer_number,
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
subscription_id = result['subscription'][0].tvSubscriptionId
result = client.block_tv_subscription(session_id, subscription_id)
if not result['action_result']:
response = {
'success': False,
'msg': result.get('action_error_message'),
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
response = {'success': True, 'msg': ""}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
def delete(self, request, adslUserName, format=None):
serializer = WifiSubscriberSerializer(data=request.data,
is_delete=True)
if not serializer.is_valid():
return send_404_error_message(serializer)
adsl_subscriber = adslUserName.strip("/ ")
wifi_subscriber = ADSL_PATTERN.sub(r"\[email protected]",
adsl_subscriber)
transaction_id = serializer.validated_data['transactionId'].encode(
'utf-8').strip()
ldap_client = LDAPClient()
result = ldap_client.get_subscriber_services(wifi_subscriber)
if not result['action_result']:
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
}
return Response(response, status=status.HTTP_200_OK)
if not result.get('user_exists', True):
response = {
'success':
True,
'msg':
"User ({0}) has no WiFi profile on AAA".format(
adsl_subscriber),
'user_exists':
False
}
return Response(response, status=status.HTTP_200_OK)
services = result.get('services')
if not services:
response = {'success': True, 'msg': ""}
return Response(response, status=status.HTTP_200_OK)
service = services[0]
logger.debug(
"Removing WiFi service (%s) for user (%s), transaction ID: ",
service, wifi_subscriber, transaction_id)
result = ldap_client.remove_service(wifi_subscriber,
service,
is_adsl=False)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message')
}
if not response['success']:
return Response(response, status=status.HTTP_200_OK)
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
ldap_client.disconnect()
return Response(response, status=status.HTTP_200_OK)
def delete_option_pack(request):
user_name = request.POST['userName'].encode('utf-8').strip()
transaction_id = request.POST['transactionId'].encode('utf-8').strip()
ldap_client = LDAPClient()
result = ldap_client.delete_option_pack(user_name)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
ldap_client.disconnect()
return HttpResponse(json.dumps(response), content_type="application/json")
def reset_session(request):
user_name = request.POST['userName'].encode('utf-8').strip()
transaction_id = request.POST['transactionId'].encode('utf-8').strip()
logger.debug("Resetting session for user (%s), transaction id: ",
user_name, transaction_id)
response = {
'success': True,
'msg': "",
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), content_type="application/json")
def check_user_exists(request):
user_name = request.GET['userName'].encode('utf-8').strip()
transaction_id = request.GET['transactionId'].encode('utf-8').strip()
ldap_client = LDAPClient()
result = ldap_client.check_user_exists(user_name)
response = {
'success': False if result.get('user_exists') is None else True,
'msg': result.get('action_error_message'),
'user_exists': result.get('user_exists')
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
ldap_client.disconnect()
return HttpResponse(json.dumps(response), content_type="application/json")
def get(self, request, adslUserName, format=None):
"""returns wifi service assigned to user"""
serializer = WifiSubscriberSerializer(data=request.query_params,
is_get=True)
if not serializer.is_valid():
return send_404_error_message(serializer)
adsl_subscriber = adslUserName.strip("/ ")
wifi_subscriber = ADSL_PATTERN.sub(r"\[email protected]",
adsl_subscriber)
transaction_id = serializer.validated_data['transactionId'].encode(
'utf-8').strip()
ldap_client = LDAPClient()
result = ldap_client.get_subscriber_services(wifi_subscriber)
if not result['action_result']:
response = {
'success': result['action_result'],
'msg': result.get('action_error_message')
}
return Response(response, status=status.HTTP_200_OK)
if not result.get('user_exists', True):
response = {
'success':
True,
'msg':
"User ({0}) has no WiFi profile on AAA".format(
adsl_subscriber),
'user_exists':
False
}
return Response(response, status=status.HTTP_200_OK)
services = result.get('services') or []
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
'services': services
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
ldap_client.disconnect()
return Response(response, status=status.HTTP_200_OK)
def create_or_change_ldap_service(request):
form = CreateOrChangeForm(request.POST)
if not form.is_valid():
error_msg = ""
for k, v in form.errors.items():
error_msg += "%s: %s\n" % (k, ", ".join(v))
return HttpResponse(json.dumps({
'success': True,
'msg': error_msg,
'form_error': True
}),
content_type="application/json")
user_name = form.cleaned_data['userName'].encode('utf-8').strip()
service_name = form.cleaned_data['serviceName'].encode('utf-8').strip()
transaction_id = form.cleaned_data['transactionId'].encode('utf-8').strip()
logger.debug(
"Creating or changing LDAP service (%s) for user (%s), transaction ID: ",
service_name, user_name, transaction_id)
ldap_client = LDAPClient()
result = ldap_client.add_or_change_service(
user_name, service_name, request_params=form.cleaned_data)
if not result.get('user_exists', True):
response = {
'success': True,
'msg': "User ({0}) has no profile on AAA".format(user_name),
'user_exists': False
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
ldap_client.disconnect()
return HttpResponse(json.dumps(response),
content_type="application/json")
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
ldap_client.disconnect()
return HttpResponse(json.dumps(response), content_type="application/json")
def get_ldap_services(request):
user_name = request.GET['userName'].encode('utf-8').strip()
transaction_id = request.GET['transactionId'].encode('utf-8').strip()
ldap_client = LDAPClient()
result = ldap_client.get_subscriber_services(user_name)
services = result.get('services') or []
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
'services': services
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
ldap_client.disconnect()
return HttpResponse(json.dumps(response), content_type="application/json")
def remove_user(request):
subscriber_id = request.POST['userName'].encode('utf-8').strip()
transaction_id = request.POST['transactionId'].encode('utf-8').strip()
logger.debug("Removing user (%s), transaction id: ", subscriber_id,
transaction_id)
pcrf_client = PCRFClient()
result = pcrf_client.remove_subscriber(subscriber_id)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), content_type="application/json")
def _release_session_and_return(session_id, request, fn_name, return_response,
transaction_id):
client = IPTVClient()
result = client.release_iptv_session(session_id)
if not result['action_result']:
response = {
'success': False,
'msg': result.get('action_error_message'),
}
log_action(fn_name, request, response, transaction_id=transaction_id)
log_action(fn_name,
request,
return_response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(return_response),
mimetype="application/json")
def send_start_coa(request):
subscriber_id = request.POST['userName'].encode('utf-8').strip()
service_name = request.POST['serviceName'].encode('utf-8').strip()
logger.debug("Sending Start Coa for Subscriber (%s), Service (%s)",
subscriber_id, service_name)
aaa_client = AAAClient()
result = aaa_client.send_start_coa(subscriber_id, service_name)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
start_coa=result.get('coa_result'),
transaction_id=request.POST['transactionId'])
return HttpResponse(json.dumps(response), content_type="application/json")
def get_user_by_name(request):
logger.debug("Getting ip address for username (%s)",
request.GET['userName'])
aaa_client = AAAClient()
result = aaa_client.get_session_by_name(
request.GET['userName'].encode('utf-8').strip())
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
'ipAddress': result.get('IpAddress')
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=request.GET['transactionId'])
return HttpResponse(json.dumps(response), content_type="application/json")
def post(self, request, *args, **kwargs):
serializer = WifiSubscriberSerializer(data=request.data)
if not serializer.is_valid():
return send_404_error_message(serializer)
adsl_subscriber = serializer.validated_data['adslUserName'].encode(
'utf-8').strip()
wifi_subscriber = ADSL_PATTERN.sub(r"\[email protected]",
adsl_subscriber)
password = serializer.validated_data['password'].encode(
'utf-8').strip()
service = serializer.validated_data['serviceName'].encode(
'utf-8').strip()
transaction_id = serializer.validated_data['transactionId'].encode(
'utf-8').strip()
logger.debug(
"Creating or changing WiFi service (%s) for user (%s), transaction ID: ",
service, wifi_subscriber, transaction_id)
ldap_client = LDAPClient()
result = ldap_client.add_wifi_service(adsl_subscriber, wifi_subscriber,
service, password)
if result.get('user_exists', False):
response = {
'success':
True,
'msg':
"User ({0}) already has a WiFi profile on AAA".format(
adsl_subscriber),
'user_exists':
True
}
return Response(response, status=status.HTTP_200_OK)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
ldap_client.disconnect()
return Response(response, status=status.HTTP_200_OK)
def remove_ldap_service(request):
user_name = request.POST['userName'].encode('utf-8').strip()
service_name = request.POST['serviceName'].encode('utf-8').strip()
transaction_id = request.POST['transactionId'].encode('utf-8').strip()
logger.debug("Removing LDAP service (%s) for user (%s), transaction ID: ",
service_name, user_name, transaction_id)
ldap_client = LDAPClient()
result = ldap_client.remove_service(user_name, service_name)
response = {
'success': result['action_result'],
'msg': result.get('action_error_message')
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
ldap_client.disconnect()
return HttpResponse(json.dumps(response), content_type="application/json")
def remove_iptv_stb(request):
client = IPTVClient()
customer_number = request.POST['customerNumber']
mac_address = request.POST['macAddress']
transaction_id = request.POST['transactionId']
result = client.create_iptv_session()
if not result['action_result']:
response = {
'success': False,
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), mimetype="application/json")
session_id = result['session_id']
result = client.fetch_tv_subscriptions(session_id, customer_number)
if not result['action_result']:
response = {
'success': False,
'msg': result.get('action_error_message'),
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
if not result['subscription'][0].tvSubscriptionId:
response = {
'success': False,
'msg':
"Subscriber (%s) has no IPTV subscriptions." % customer_number,
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
subscription_id = result['subscription'][0].tvSubscriptionId
result = client.remove_stb(session_id, subscription_id, customer_number,
mac_address)
if not result['action_result']:
if "STB" in result['action_error_message'] and "does not exist on subscription" \
in result['action_error_message']:
response = {
'success':
False,
'msg':
"STB (%s) is not assigned to subscriber (%s)" %
(mac_address, customer_number),
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
response = {
'success': False,
'msg': result.get('action_error_message'),
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
response = {'success': True, 'msg': ''}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
def query_user_info(request):
client = IPTVClient()
customer_number = request.GET['customerNumber']
transaction_id = request.GET['transactionId']
result = client.create_iptv_session()
if not result['action_result']:
response = {
'success': False,
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), mimetype="application/json")
session_id = result['session_id']
result = client.fetch_tv_subscriptions(session_id, customer_number)
if not result['action_result']:
response = {
'success': False,
'msg': result.get('action_error_message'),
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
if not result['subscription'][0] or not result['subscription'][
0].tvSubscriptionId:
response = {
'success': False,
'msg':
"Subscriber (%s) has no IPTV subscriptions." % customer_number,
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
subscription = result['subscription'][0]
status = subscription.status
package = subscription.packages[0].name if len(
subscription.packages) else None
stb = subscription.stbs[0].macAddress if hasattr(subscription,
'stbs') else None
response = {
'success': True,
'msg': '',
'status': status,
'package': package,
'stb': stb
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
def create_customer(request):
client = IPTVClient()
customer_number = request.POST['customerNumber']
package_name = request.POST['packageName']
mac_address = request.POST['macAddress']
transaction_id = request.POST['transactionId']
result = client.create_iptv_session()
if not result['action_result']:
response = {
'success': False,
'msg': result.get('action_error_message'),
}
log_action(inspect.stack()[0][3],
request,
response,
transaction_id=transaction_id)
return HttpResponse(json.dumps(response), mimetype="application/json")
session_id = result['session_id']
subscription_result = client.fetch_tv_subscriptions(
session_id, customer_number)
if subscription_result['action_result']:
response = {'success': False, 'msg': 'Subscriber exists.'}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
result = client.create_customer(session_id=session_id,
customer_number=customer_number)
if not result['action_result'] and not result[
'action_error_message'].endswith('already exists. '):
response = {
'success': False,
'msg': result.get('action_error_message'),
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
result = client.order_tv_subscription(session_id, customer_number,
package_name, mac_address)
if not result['action_result']:
client.remove_iptv_customer(session_id, customer_number)
if "STB" in result[
'action_error_message'] and "is already on subscription" in result[
'action_error_message']:
order_id = re.findall("[\d]{5}", result['action_error_message'])[0]
single_subscription_result = client.fetch_tv_subscription(
session_id, order_id)
if single_subscription_result['action_result']:
error_msg = "STB already assigned to subscriber (%s)" % \
single_subscription_result['subscription'].customerNumber
else:
error_msg = "STB already assigned to another subscriber"
response = {
'success': False,
'msg': error_msg,
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
response = {
'success': False,
'msg': result.get('action_error_message'),
}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
response = {'success': True, 'msg': ""}
return _release_session_and_return(session_id,
request,
fn_name=inspect.stack()[0][3],
return_response=response,
transaction_id=transaction_id)
