def reference_job_to_other(request):
if request.method == 'POST':
job = request.POST.get('rfj')
message = request.POST.get('rf')
group = request.POST.get('rg')
if not validate_integer(job):
return _return_error_(_('invalid dashboard'), request)
if not validate_empty_str(message):
return _return_error_(_('please enter message'), request)
if not validate_integer(group):
return _return_error_(_('invalid group'), request)
dash = get_current_user_dashboard(request.user, True)
if int(job) not in dash:
return _return_error_(_('invalid dashboard'), request)
if not Group.objects.filter(pk=group).exists():
return _return_error_(_('invalid group'), request)
d = Dashboard.objects.get(pk=job)
if DashboardReferences.objects.filter(
dashboard=d.pk, target_group_id=group,
source_group_id=d.group_id).exists():
dr = DashboardReferences.objects.get(dashboard=d.pk,
target_group_id=group,
source_group_id=d.group_id)
else:
dr = DashboardReferences()
if request.user.is_superuser:
src_id = d.group_id
else:
user_groups = request.user.groups.all().values_list('pk',
flat=True)
if d.group_id in user_groups:
src_id = d.group_id
else:
src_id = user_groups[0]
d.last_state = 0
d.save()
dr.dashboard = d
dr.reason = message
dst = Group.objects.get(pk=group)
src = Group.objects.get(pk=src_id)
dr.target_group = dst
dr.source_group = src
dr.user = request.user
dr.save()
uw = UserWorkHistory()
uw.group = src
uw.dashboard = d
uw.message = _('job referenced to other group'
) + ' - ' + dst.name + ' - ' + message
uw.start_date = now()
uw.state = 5 # referenced
uw.user = request.user
uw.save()
dc = DashboardCurrentGroup.objects.get(dashboard=d.pk)
dc.group_id = group
dc.save()
if check_ajax(request):
return HttpResponse('200')
return redirect(reverse(view_dashboard) + '?j=%s' % job)
return _return_error_('invalid method', request)
def get_paginate(lst, current, rows, extra_data=None):
res = {
'rows': [],
'current': 1,
'rowCount': 0,
'total': 0,
'extra': extra_data
}
# if not isinstance(lst, QuerySet):
# return json.dumps(res)
if not validate_integer(current):
return json.dumps(res)
if not validate_integer(rows):
return json.dumps(json.dumps(res))
c = int(current)
r = int(rows)
ctx = lst.count()
if c == 1:
start = 0
else:
start = (c - 1) * r
if r < 1:
end = ctx
else:
end = start + r
data = lst[start:end]
# print str(lst.query)
res['rows'] = list(data)
res['total'] = ctx
res['rowCount'] = int(rows)
res['current'] = c
rt = json.dumps(res, default=date_handler)
return rt
def send_from_template(user_id, code_id, **kwargs):
if not validate_integer(user_id):
return False
if not validate_integer(code_id):
return False
try:
n = NotifySettings.objects.get(code_id=code_id)
u = User.objects.get(pk=user_id)
params = {'username': u.username,
'id': u.pk,
'name': u.first_name, # User First name
'phone': u.fk_user_profile_user.telephone, # User telephone
'mobile': u.fk_user_profile_user.mobile, # User Mobile Number
'cdt': datetime.today(), # Current Date Time
}
params.update(kwargs)
if n.email_enabled:
res = __render__(n.mail_text, params)
send_email(res, u.email, 'CRM', user_id, (code_id == 4 or code_id == 6))
if n.inbox_enabled:
res = __render__(n.inbox_text, params=params)
send_inbox(user_id, res, (code_id == 4 or code_id == 6))
if n.sms_enabled:
res = __render__(n.sms_text, params)
send_text_message(user_id, res, (code_id == 4 or code_id == 6))
return True
except Exception as e:
print e.message
return False
def update_dedicated_user_service(request):
if request.method == 'POST':
service_id = request.POST.get('si')
name = request.POST.get('s')
price = request.POST.get('pr')
ip = request.POST.get('i')
if not validate_integer(service_id):
return send_error(request, _('invalid service'))
if not DedicatedUserService.objects.filter(pk=service_id).exists():
return send_error(request, _('no such service'))
if not validate_empty_str(name):
return send_error(request, _('please enter service'))
if not validate_integer(price):
return send_error(request, _('please enter valid price'))
if not validate_empty_str(ip):
return send_error(request, _('please enter ip'))
x = DedicatedUserService.objects.get(pk=service_id)
x.price = int(price)
x.service = name
x.ip_pool = ip
x.save()
if check_ajax(request):
return HttpResponse('200')
return redirect(
reverse(view_dedicated_user_service) + '?u=%s' % x.user_id)
return send_error(request, _('invalid method'))
def delete_traffic(request):
if request.method == 'GET':
t = request.GET.get('t')
if not validate_integer(t):
return redirect(reverse(view_all_traffics))
try:
traffic = Traffic.objects.get(pk=t)
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
return render(request, 'traffic/DeleteTraffic.html',
{'traffic': traffic})
elif request.method == 'POST':
tid = request.POST.get('tid', 'empty')
if not validate_integer(tid):
return redirect(reverse(view_all_traffics))
try:
d_t = Traffic(pk=tid)
d_t.is_deleted = True
d_t.save()
fire_event(2603, d_t, None, request.user.pk)
# insert_new_action_log(request, None, _('package deleted') + ' : ' + d_t.name)
return redirect(reverse(view_all_traffics))
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
else:
return render(request, 'errors/AccessDenied.html')
def delete_discount(request):
delete_discount.__cid__ = 4361
if request.method == 'GET':
d = request.GET.get('d')
if not validate_integer(d):
return redirect(reverse(view_all_discounts))
try:
dis = IBSServiceDiscount.objects.get(pk=d)
return render(request,
'finance/discount/service/DeleteDiscount.html',
{'d': dis})
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
elif request.method == 'POST':
d = request.POST.get('d')
if request.POST.get('cancel'):
return redirect(reverse(view_all_discounts))
if not validate_integer(d):
return redirect(reverse(view_all_discounts))
try:
dis = IBSServiceDiscount.objects.get(pk=d)
dis.is_deleted = True
dis.save()
fire_event(delete_discount, dis, None, request.user.pk)
# send_to_dashboard(4361, request.user.pk)
return redirect(reverse(view_all_discounts))
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
else:
return render(request, 'errors/AccessDenied.html')
def post(request):
invoice_user_id = request.POST.get('u', 'Invalid')
service_id = request.POST.get('s', 'invalid')
extra_month = request.POST.get('m')
property_id = request.POST.get('pr', -1)
if not validate_integer(extra_month):
extra_month = 1
if not validate_integer(invoice_user_id):
return render(request, 'errors/CustomError.html',
{'error_message': _('invalid user data')})
if not validate_integer(service_id):
return render(request, 'errors/ServerError.html')
if request.POST.get('cancel'):
return redirect(
reverse(show_user_navigation) + '?uid=%s' % invoice_user_id)
if request.user.is_staff or request.user.is_superuser:
user = User.objects.get(pk=invoice_user_id)
else:
user = request.user
if not IBSService.objects.filter(
pk=service_id, is_visible=True, is_deleted=False).exists():
fire_event(6362, user)
return redirect('/')
i_s = IBSService.objects.get(pk=service_id)
x = InvoiceGen(i_s,
1,
service_property=property_id,
uid=user.pk,
extra_month=extra_month)
x.calculate()
if user.fk_vip_users_group_user.exists():
vid = user.fk_vip_users_group_user.get().pk
else:
vid = None
if not is_in_valid_services(service_id, int(property_id), vid):
return redirect(
reverse(show_user_navigation) + '?uid=%s' % invoice_user_id)
service_pr = ServiceProperty.objects.get(pk=property_id)
try:
if service_pr.fk_vip_services_service.exists():
if not user.fk_vip_users_group_user.exists():
fire_event(10547, user)
return redirect('/')
if service_pr.fk_vip_services_service.get().group.group_id != \
user.fk_user_service_group_user.get().service_group_id:
fire_event(10547, user)
return redirect('/')
if not x.get_is_done():
fire_event(10276, user)
return redirect('/')
f = x.get_invoice()
f.save()
fire_event(5524, f)
if request.user.is_staff:
return redirect(reverse(show_all_invoices))
return redirect(reverse(e_pay_invoice) + '?f=' + str(f.pk))
except Exception as e:
print e.args[1]
return render(request, 'errors/ServerError.html')
def api_request(request):
if request.method == 'GET':
command = request.GET.get('c')
if command == 'user':
param = request.GET.get('p')
if validate_ip(param):
ibm = IBSManager()
return HttpResponse(ibm.get_username_from_ip(param))
elif command == 'gift':
uid = request.GET.get('user')
days = request.GET.get('days')
package = request.GET.get('pack')
if not validate_integer(uid):
return HttpResponse('')
if not validate_integer(days):
return HttpResponse('')
if not validate_integer(package):
return HttpResponse('')
if User.objects.filter(
fk_ibs_user_info_user__ibs_uid=uid).exists():
# if not UserPollTempDB.objects.filter(uid=uid).exists():
# tmp = UserPollTempDB()
# tmp.uid = int(uid)
# tmp.save()
send_gift_for_users.delay(
User.objects.filter(fk_ibs_user_info_user__ibs_uid=uid),
int(days), int(package), False)
return HttpResponse('1')
elif command == 'poll':
return api_request_accept_poll(request)
elif command == 'poll_user':
return api_request_find_user(request)
return HttpResponse('')
else:
return HttpResponse('')
def delete_group(request):
delete_group.__cid__ = 2200
if request.method == 'GET':
gid = request.GET.get('gid')
if gid is None:
return redirect(reverse(show_all_groups))
if not validate_integer(gid):
return redirect(reverse(show_all_groups))
try:
group = Group.objects.get(pk=gid)
return render(request, 'group/DeleteGroupConfirm.html',
{'group': group})
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
elif request.method == 'POST':
gid = request.POST.get('gid', -1)
if gid is -1 and not validate_integer(gid):
return redirect(reverse(show_all_groups))
try:
Group.objects.get(pk=gid).delete()
fire_event(delete_group, None, gid, request.user.pk)
return redirect(reverse(show_all_groups))
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html', {})
def add_new_job_state(request):
ai = check_ajax(request)
if request.method == 'GET':
if ai:
return redirect(reverse(view_dashboard))
return redirect('/')
elif request.method == 'POST':
message = request.POST.get('msg')
dash_id = request.POST.get('di')
state = request.POST.get('s')
to_edit = request.POST.get('te')
if not validate_integer(dash_id):
return _return_error_(_('no such data found'), request)
if not validate_empty_str(message):
return _return_error_(_('please enter your report'), request)
if not Dashboard.objects.filter(pk=dash_id).exists():
return _return_error_(_('no such dashboard found'), request)
if not validate_integer(state):
state = 2
else:
state = int(state)
# if state > 4:
# state = 4
uw = None
if request.user.has_perm('CRM.change_userworkhistory'):
if validate_integer(to_edit):
if UserWorkHistory.objects.filter(pk=to_edit).exists():
uw = UserWorkHistory.objects.get(pk=to_edit)
if state < 2: # user is trying to modify start state
uw = None
if not uw:
uw = UserWorkHistory()
dash = Dashboard.objects.get(pk=dash_id)
uw.dashboard = dash
# DashboardReferences.objects.get().
if request.user.is_superuser:
dst = Group.objects.get(pk=dash.group_id)
else:
dst = Group.objects.get(pk=request.user.groups.first().pk)
uw.group = dst
uw.message = message
uw.start_date = now()
uw.user = request.user
if dash.is_read:
dash.last_state = state
else:
state = 0
uw.state = state
uw.save()
if state == 3 or state == 4:
dash.is_done = True
dash.done_date = now()
remove_calendar_event(dash)
dash.save()
if ai:
return HttpResponse('200')
return redirect(reverse(view_dashboard) + '?j=%s' % dash_id)
else:
return render(request, 'errors/AccessDenied.html')
def create_traffic_invoice(request):
user = request.user
if request.method == 'GET':
sid = request.GET.get('t')
if request.user.is_staff or request.user.is_superuser:
uid = request.GET.get('u')
else:
uid = user.pk
if not validate_integer(sid):
return redirect('/user/nav/?uid=%s' % uid)
if not validate_user(uid, request.RSL_ID):
return redirect('/user/nav/?uid=%s' % uid)
try:
x = InvoiceGen(Traffic.objects.get(pk=sid), 2, uid=uid)
x.calculate()
if not x.get_is_done():
fire_event(10231, User.objects.get(pk=uid))
return redirect('/')
extra_data = x.get_extra_data()
return render(
request, 'finance/TrafficInvoice.html', {
's': x.get_service(),
'tax': extra_data.get('tax'),
'price': x.get_final_price(),
'u': uid,
'discounted_price': extra_data.get('discount_price'),
'extra_amount': extra_data.get('extra_package'),
'base_service_price': x.get_base_price(),
'debit': extra_data.get('debit')
})
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
elif request.method == 'POST':
uid = request.POST.get('uid', 'INVALID')
sid = request.POST.get('sid', 'INVALID')
if not validate_user(uid, request.RSL_ID) or not validate_integer(sid):
return redirect('/user/nav/?uid=%s' % uid)
if not user.is_staff:
uid = user.pk
try:
x = InvoiceGen(Traffic.objects.get(pk=sid), 2, uid=uid)
x.calculate()
if not x.get_is_done():
fire_event(10231, User.objects.get(pk=uid))
return redirect('/')
f = x.get_invoice()
f.save()
# PackageInvoiceCreatedNotify().send(user_id=uid, invoice_id=f.pk, create_time=f.create_time)
if request.user.is_staff:
return redirect(reverse(show_all_invoices) + '?u=%s' % uid)
else:
return redirect(reverse(e_pay_invoice) + '?f=' + str(f.pk))
except Exception as e:
print e.args[0]
return render(request, 'errors/ServerError.html')
else:
return render(request, 'errors/AccessDenied.html')
def assign_service_to_group(request):
"""
assign service to price list
@param request:
@return:
@type request: django.core.handlers.wsgi.WSGIRequest
"""
if request.method != 'GET':
return render(request, 'errors/AccessDenied.html')
list_name = request.GET.get('l')
service_name = request.GET.get('s')
action = request.GET.get('a')
if not validate_integer(list_name):
return render(request, 'errors/CustomError.html',
{'error_message': _('no list selected')})
try:
if not action:
services = IBSService.objects.filter(
is_visible=True, is_deleted=False).filter(
Q(fk_service_group_service=None)
| Q(fk_service_group_service__group=list_name)
| Q(fk_service_group_service__is_deleted=True))
selected_list = ServiceGroup.objects.filter(
group=list_name, is_deleted=False).values_list('service__pk',
flat=True)
return render(
request, 'service/groups/AssignService.html', {
'services': services,
'current_selected': selected_list,
'list_name': list_name
})
if not validate_integer(service_name):
return render(request, 'errors/CustomError.html',
{'error_message': _('no service selected')})
if action == 'a':
if not ServiceGroup.objects.filter(service=service_name).exists():
sp = ServiceGroup()
elif ServiceGroup.objects.filter(is_deleted=True,
service=service_name).exists():
sp = ServiceGroup.objects.get(service=service_name)
sp.is_deleted = False
else:
return redirect(
reverse(assign_service_to_group) + '?l=%s' % list_name)
sp.group = ServiceGroups.objects.get(pk=list_name)
sp.service = IBSService.objects.get(pk=service_name)
sp.save()
elif action == 'd':
if ServiceGroup.objects.filter(service=service_name).exists():
sp = ServiceGroup.objects.get(service=service_name)
sp.is_deleted = True
sp.save()
return redirect(reverse(assign_service_to_group) + "?l=%s" % list_name)
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
def import_services(request):
if request.method == 'GET':
groups = ServiceGroups.objects.filter(is_deleted=False)
is_importing = cache.get('IBS_IMPORTING') or cache.get('SETTING_USERS')
return render(request, 'configuration/ibs/ImportGroups.html', {'groups': groups,
'is_importing': is_importing})
elif request.method == 'POST':
if cache.get('IBS_IMPORTING'):
return redirect(reverse(import_services))
try:
if request.POST.get('groups'):
import_services.__cid__ = 2707
fire_event(import_services, IBSService.objects.first(), None, request.user.pk)
import_groups_from_ibs()
return redirect(reverse(show_all_service))
elif request.POST.get('groupService'):
import_groups_from_ibs(True)
return redirect(reverse(show_all_service))
elif request.POST.get('current'):
pl = request.POST.get('sg')
if not validate_integer(pl):
return render(request, 'errors/CustomError.html', {'error_message':
_('please select a valid list')})
import_services.__cid__ = 6126
fire_event(import_services, IBSService.objects.first(), None, request.user.pk)
# assign_current_users_to_service_group.delay(pl)
elif request.POST.get('users'):
pl = request.POST.get('sg')
if not validate_integer(pl):
return render(request, 'errors/CustomError.html', {'error_message':
_('please select a valid price')})
fire_event(3437, None, None, request.user.pk)
# import_ibs_users_job.delay(pl)
elif request.POST.get('su'):
ibs_uid = request.POST.get('su')
if validate_integer(ibs_uid):
res = create_user_from_ibs(int(ibs_uid))
if res[0]:
fire_event(2101002, User.objects.get(pk=res[2]), None, None)
return redirect('/user/nav/uid=%s' % res[2])
else:
fire_event(2101003, None, _('invalid user').decode('utf-8') + ' %s ' % ibs_uid, None)
print res[3]
elif request.POST.get('ips'):
fire_event(2101001, None, None, request.user.pk)
import_ip_statics_job.delay()
return redirect(reverse(import_services))
except Exception as e:
print '[UNEXPECTED] An Error raised when importing data : '
if e.args:
print(" ".join([str(a) for a in e.args]))
else:
print(e.message)
return render(request, 'errors/ServerError.html')
else:
return render(request, 'errors/AccessDenied.html')
def get_paging(list_len, start_point, per_page=None):
if per_page:
block_count = int(per_page)
if block_count == 0:
block_count = 10
else:
block_count = 30
if not validate_integer(list_len):
return {}
if not validate_integer(start_point):
return {}
if list_len == 0:
sp = 0
nx = 0
p = 1
pc = 1
bp = -1
elif list_len <= block_count:
sp = 0
nx = list_len
p = 1
pc = 1
bp = -1
elif (start_point + block_count) < list_len:
if start_point == 0:
sp = 0
elif start_point == block_count:
sp = block_count
elif (start_point % block_count) == 0:
sp = start_point
else:
sp = block_count + int(start_point / block_count) + 1
nx = sp + block_count
bp = start_point - block_count
if bp < 0:
bp = 0
pc = int(list_len / block_count) + 1
if (list_len % block_count) == 0:
pc -= 1
p = int((start_point + block_count) / block_count)
else:
sp = start_point
bp = start_point - block_count
if (list_len % block_count) == 0:
nx = start_point + block_count
else:
nx = start_point + (list_len % block_count)
p = int((start_point + block_count) / block_count)
pc = int(list_len / block_count) + 1
if (list_len % block_count) == 0:
pc -= 1
return {'start': sp, 'back': bp, 'page': p, 'page_count': pc, 'end': nx}
def send_new_notification(request):
if request.method == 'GET':
if len(request.GET) < 1:
return redirect(reverse(search_users))
data = build_params_by_get(request.GET)
users = advanced_search_users(**data)
res = init_pager(users, 15, request.GET.get('nx'), 'users',
{'show_res': True}, request)
return render(request, 'notify/SendNewMessage.html', res)
elif request.method == 'POST':
if not request.GET:
return redirect('/')
data = build_params_by_get(request.GET)
users = advanced_search_users(**data)
if request.POST.get('gift'):
add_days = request.POST.get('ad')
extra_package = request.POST.get('pa')
add_days_for_limited = request.POST.get('sfl')
if not validate_integer(add_days):
add_days = 0
if not validate_integer(extra_package):
extra_package = 0
if not add_days_for_limited:
add_days_for_limited = False
else:
add_days_for_limited = True
send_gift_for_users.delay(users, int(add_days), int(extra_package),
add_days_for_limited)
else:
inbox = request.POST.get('box') is not None
sms = request.POST.get('s') is not None
mail = request.POST.get('e') is not None
use_template = request.POST.get('t') is not None
msg = request.POST.get('msg')
if not (inbox or sms or mail):
return render(
request, 'errors/CustomError.html',
{'error_message': _('please select a notify type')})
if not msg:
return render(
request, 'errors/CustomError.html',
{'error_message': _('please enter a message for users')})
fire_event(5267, None, None, request.user.pk)
for u in users:
if use_template:
send_from_template.delay(u.pk, 10, otx=msg)
else:
send_notifications(u.pk, msg, sms, mail, inbox)
return redirect(reverse(show_all_notifications))
else:
return render(request, 'errors/AccessDenied.html')
def create_department(request):
if request.method == 'GET':
did = request.GET.get('d')
try:
groups = Group.objects.all()
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
if validate_integer(did):
try:
department = HelpDepartment.objects.get(pk=did)
return render(request, 'help_desk/CreateDepartment.html', {
'dep': department,
'groups': groups
})
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
return render(request, 'help_desk/CreateDepartment.html',
{'groups': groups})
elif request.method == 'POST':
gid = request.POST.get('slGroups', 'Invalid')
name = request.POST.get('txtName')
d = request.POST.get('d')
if not validate_integer(gid) or gid == '-1':
return render(request, 'errors/CustomError.html',
{'error_message': _('no group selected')})
if not validate_empty_str(name):
return render(request, 'errors/CustomError.html',
{'error_message': _('enter a name please')})
try:
if validate_integer(d):
h = HelpDepartment.objects.get(pk=d)
else:
h = HelpDepartment()
h.group = Group.objects.get(pk=gid)
h.department_name = name
# insert_new_action_log(request, None, _('create or update help department') + ' :' + name)
h.save()
fire_event(3617, h, None, request.user.pk)
return redirect(reverse(show_all_departments))
except DBRecordExist:
return render(request, 'errors/CustomError.html',
{'error_message': _('the department name is exist')})
except DBInsertException as e:
print e.message
return render(request, 'errors/ServerError.html')
def __init__(self, host=None, port=None, username=None, password=None, ibs_type=1):
if not validate_empty_str(host):
self.hostname = read_config('ibs_address', '212.16.80.145')
else:
self.hostname = host
if not validate_integer(port):
self.port = read_config('ibs_port', '1235')
else:
self.port = port
if not validate_empty_str(username):
self.username = read_config('ibs_username', 'CRM')
else:
# log.debug('Setting the username')
self.username = username
if not validate_empty_str(password):
# log.debug('Password is empty')
self.password = read_config('ibs_password', '!@#CRM!@#')
else:
# log.debug('Setting the password')
self.password = password
self.proxy = xmlrpclib.ServerProxy('http://{0}:{1}/'.format(self.hostname, self.port))
self.auth_params = {"auth_name": self.username,
'auth_pass': self.password,
'auth_type': 'ADMIN'}
# self.auth_params = self.__get_auth__(username, password)
# print self.auth_params
self.ibs_type = ibs_type
def temp_recharge(request):
return redirect('/')
user = request.user
granted = False
if user.is_staff or user.is_superuser:
granted = True
if request.method == 'GET':
if not granted:
uid = user.pk
else:
uid = request.GET.get('uid')
if not validate_integer(uid):
return render(request, 'errors/ServerError.html')
if not granted:
check = check_user_temp_charge(int(uid))
if not check:
fire_event(4300, request.user, None, request.user.pk)
return redirect(
reverse(show_user_service_summery) + '?u=%s' % uid)
res = temp_charge_user(uid, user.pk)
if res:
kill_user(uid, get_client_ip(request))
# send_from_template.delay(uid, 15, ftime=read_config('service_temp_time', 2),
# fta=read_config('service_temp_amount', 700))
return redirect(reverse(show_user_service_summery) + '?u=%s' % uid)
else:
fire_event(4124, request.user, None, request.user.pk)
return render(
request, 'errors/CustomError.html',
{'error_message': _('unable to charge. contact support')})
def temp_charge_user(user_id, requester_id):
if not validate_integer(user_id):
return False
try:
if not IBSUserInfo.objects.filter(user=user_id).exists():
return False
user = IBSUserInfo.objects.get(user=user_id)
ibs = IBSManager()
# expire = ibs.get_expire_date(user.user.username)
# expire = parse_date_from_str_to_julian(expire)
# if expire.date() <= datetime.today().date():
res = ibs.temp_charge(user.user.username)
# else:
# ibs.temp_charge()
# res = ibs.change_credit(float(get_config_value('ibs_temp_charge_amount', 700)),
# user.user.username,
# replace_credit=True)
if res:
fr = FreeTrafficLog()
fr.user_id = user_id
fr.recharger = User.objects.get(pk=requester_id)
fr.datetime = datetime.today()
fr.save()
fire_event(3720, fr, None, int(user_id))
return True
return False
except Exception as e:
print e.args[1]
return False
def bank_api_management(request):
"""
Management bank gateways
@param request: user request
@return: HttpResponse
@type request: django.core.handlers.wsgi.WSGIRequest
"""
if request.method != 'GET':
return render(request, 'errors/AccessDenied.html')
action = request.GET.get('a')
try:
if action == 'i': # Install bank template data
bank_id = request.GET.get('i')
if validate_integer(bank_id):
install_bank_api(bank_id)
return redirect(reverse(bank_api_management))
ready_banks = get_banking_gateways(True)
banks_identifier = ready_banks.pop(0)
installed_banks = Banks.objects.filter(internal_value__in=banks_identifier)
# print Banks.objects.all().count()
installed_ids = installed_banks.values_list('internal_value', flat=True)
return render(request, 'finance/BankManagement.html', {'installed_api': installed_banks,
'ready_api': ready_banks,
'ready_ids': banks_identifier,
'installed_ids': installed_ids})
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
def create_internet_account(request):
if request.method == 'GET':
uid = request.GET.get('u')
if not validate_integer(uid):
return send_error(request, _('no user selected'))
if not User.objects.filter(pk=uid).exists():
return redirect('/')
ibs = IBSManager()
rnd = ''.join(random.choice(string.lowercase) for i in range(5))
u = User.objects.get(pk=uid)
u.is_active = True
if not ibs.add_new_user(u.username, rnd, 0):
return send_error(request, _('unable to create ibs user'))
u.set_password(rnd)
u.save()
ib_id = ibs.get_user_id_by_username(u.username)
ibi = IBSUserInfo()
ibi.ibs_uid = int(ib_id)
ibi.user = u
ibi.save()
u.groups.add(Group.objects.get(pk=int(read_config('groups_customer', 1))))
update_ibs_user_from_crm(u.pk)
fire_event(4537, u, None, request.user.pk)
return redirect('/user/nav/?uid=%s' % uid)
else:
return redirect('/')
def start_poll(request):
uid = request.user_pk
if request.method == 'GET':
poll_id = request.GET.get('p')
if not validate_integer(poll_id):
return redirect(reverse('/'))
if UserPolls.objects.filter(user=uid, poll=poll_id, is_finished=True).exists():
print '[UNEXPECTED] User %s is trying to vote #%s again' % (uid, poll_id)
return redirect('/')
if not validate_poll(poll_id, uid):
print '[UNEXPECTED] User %s requested a closed poll %s' % (uid, poll_id)
return redirect('/')
if UserPolls.objects.filter(user=uid, poll=poll_id).exists():
user_poll = UserPolls.objects.get(user=uid, poll=poll_id)
token = user_poll.user_token
else:
user_poll = UserPolls()
token = ''.join(random.choice(string.lowercase) for i in range(30))
p = Polls.objects.get(pk=poll_id)
user_poll.poll = p
user_poll.user = User.objects.get(pk=uid)
user_poll.user_token = token
user_poll.save()
return redirect(p.target_address + '?token=' + token)
else:
return redirect('/')
def toggle_free_ip(request):
if request.method == 'GET':
uid = request.GET.get('u')
if not validate_integer(uid):
return HttpResponseBadRequest('500')
if not UserIPStatic.objects.filter(user=uid).exists():
return HttpResponseBadRequest('500')
if not UserIPStatic.objects.filter(user=uid).exists():
return HttpResponseBadRequest('500')
ips = UserIPStatic.objects.get(user=uid)
ips.is_free = not ips.is_free
# ipr = UserIPStatic.objects.get(user=uid)
if ips.is_free:
ips.expire_date = None
# ipr.end_date = None
# ipr.save()
ips.save()
configure_static_ip_address(uid)
else:
ips.expire_date = datetime.today() + timedelta(days=5)
# ipr.end_date = datetime.today() + timedelta(days=5)
ips.save()
# ipr.is_free = not ipr.is_free
# ipr.save()
return HttpResponse('200')
else:
return redirect(reverse(view_ip_static))
def edit_telegram_data(request):
if request.method == 'POST':
action = request.POST.get('name')
uid = request.POST.get('pk')
value = request.POST.get('value')
if not validate_empty_str(value):
if check_ajax(request):
return HttpResponseBadRequest(_('please enter username'))
return render(request, 'errors/CustomError.html',
{'error_message': _('please enter username')})
if not validate_integer(uid):
if check_ajax(request):
return HttpResponseBadRequest(_('invalid user'))
return render(request, 'errors/CustomError.html',
{'error_message': _('invalid user')})
if not TelegramUser.objects.filter(pk=uid).exists():
if check_ajax(request):
return HttpResponseBadRequest(_('no such user found!'))
return render(request, 'errors/CustomError.html',
{'error_message': _('no such user found')})
u = TelegramUser.objects.get(pk=uid)
u.username = value
u.save()
if check_ajax(request):
return HttpResponse('200')
return redirect(reverse(view_active_users))
else:
if check_ajax(request):
return HttpResponseBadRequest(_('invalid method'))
return redirect(reverse(view_active_users))
def inner(request):
if request.user.is_authenticated():
request.user_pk = request.user.pk
return func(request)
elif not validate_integer(request.user_pk):
return redirect('/')
return func(request)
def init_pager(list_to_page,
per_page_res=10,
current_page=0,
collection_name='data',
other_params=None,
request=None):
if validate_integer(current_page):
paging = get_paging(len(list_to_page), int(current_page), per_page_res)
next_link = paging['end']
back_link = paging['back']
current_page = paging['page']
page_count = paging['page_count']
res = list_to_page[paging['start']:paging['end']]
else:
paging = get_paging(len(list_to_page), 0, per_page_res)
next_link = paging['end']
back_link = paging['back']
current_page = paging['page']
page_count = paging['page_count']
res = list_to_page[paging['start']:paging['end']]
params = {
collection_name: res,
'next_link': next_link,
'back_link': back_link,
'page': current_page,
'page_count': page_count,
'request': request,
'per_page': 30
}
if other_params is not None:
params.update(other_params)
return params
def check_user_temp_charge(user_id):
if not validate_integer(user_id):
return False
try:
ibs = IBSManager()
user = IBSUserInfo.objects.get(
user=user_id) # User.objects.get(pk=user_id)
expire_date = ibs.get_expire_date(user.user.username)
expire_date = parse_date_from_str_to_julian(expire_date)
credit = ibs.get_user_credit(user.user.username)
# cs = CurrentService.objects.get(user=user_id).service.period
if Invoice.objects.filter(user=user.user_id, is_paid=True).exists():
latest_inv = Invoice.objects.filter(
user=user_id, is_paid=True).latest('pay_time').pay_time.date()
else:
# Security HOLE! telta time added to check more than today
latest_inv = datetime.today().date(
) # Bug fix for those who did not paid any invoice on new CRM
latest_inv = latest_inv - timedelta(days=10)
# print '********************' + str(type(latest_inv)) + '---' + str(latest_inv)
if expire_date:
is_expired = expire_date <= datetime.today()
else:
is_expired = True
low_credit = (credit <= 5 and UserCurrentService.objects.get(
user=user_id).service_property.initial_package > 2)
is_valid_to_charge = not FreeTrafficLog.objects.filter(
datetime__gt=latest_inv, user=user_id).exists()
res = (is_expired and is_valid_to_charge) or (is_valid_to_charge
and low_credit)
return res
except Exception as e:
print e.message
return False
def kill_user(user_id, ip_address):
if not validate_integer(user_id):
return False
try:
ibs = IBSManager()
if IBSUserInfo.objects.filter(user=user_id).exists():
ibs_uid = IBSUserInfo.objects.get(user=user_id).ibs_uid
else:
ibs_uid = ibs.get_user_id_by_username(
User.objects.get(pk=user_id).username)
if ibs.kill_user(ibs_uid):
return True
failed_user_id = read_config('service_failed_users', 3306)
failed_user_ids = failed_user_id.split(',')
for f in failed_user_ids:
if IBSUserInfo.objects.filter(user=f).exists():
f_ibi = IBSUserInfo.objects.get(user=f).ibs_uid
elif ip_address is not None:
fu = User.objects.get(pk=f)
f_ibi = ibs.get_user_id_by_username(fu.username, True)
else:
return False
connections = ibs.get_user_connection_info_1(f_ibi)
for c in connections:
if c[4] == ip_address:
ibs = IBSManager()
if ibs.kill_failed_user(c[2], f_ibi, c[0]):
return True
return False
except Exception as e:
print e.message
return False
def mismatch_invoice_price(i,
price,
as_discount=False,
default_subject_more=None,
default_subject_less=None,
invoice_id=None):
price = int(price)
diff = (i.price - i.debit_price) - price
diff *= -1
if as_discount:
i.dynamic_discount = diff
return i
if diff > 0:
if default_subject_more:
subject_id = default_subject_more
else:
subject_id = read_config('invoice_extra_payment')
diff = (price - i.price) * -1
elif diff < 0:
if default_subject_less:
subject_id = default_subject_less
else:
subject_id = read_config('invoice_lower_payment')
diff = i.debit_price + (diff * -1)
else:
subject_id = read_config('invoice_zero_payment')
diff = i.debit_price
if not validate_integer(subject_id):
return None
change_user_debit(subject_id, diff, i.user_id, _('system assign'),
invoice_id)
return i
def buy_traffic(request):
user = request.user
if request.method == 'GET':
if user.is_staff or user.is_superuser:
uid = request.GET.get('u')
else:
uid = user.pk
if not validate_integer(uid):
return render(request, 'errors/ServerError.html')
try:
traffics, is_vip_package = get_packages_for_user(uid)
pp = UserCurrentService.objects.get(
user=uid).service_property.package_price
if pp > 0:
each_gig = pp
else:
each_gig = 5400
return render(
request,
'service/traffic/BuyTraffic.html',
{
'traffics': traffics.order_by('-amount'),
'price_value': each_gig,
# 'vip_packages': vip_package,
'uid': uid,
'is_vip_list': is_vip_package is not None
})
except Exception as e:
print e.message
return render(request, 'errors/ServerError.html')
