def update(self, force_add=False):
req = self.req
name = get_string(req.GET.get('n'))
order = get_integer(req.GET.get('i'))
is_required = get_integer(req.GET.get('ir'))
group_help = self.get_str('gh', False, '-', 2000)
metric = self.get_str('mt', max_len=255)
cr = self.get_bool('cr', False, False)
old = self.get_single_ext()
if not name:
raise RequestProcessException(_('please enter name'))
if not order:
raise RequestProcessException(_('please enter view order'))
if force_add:
if old or CustomOptionGroup.objects.filter(
name__iexact=name).exists():
raise RequestProcessException(_('item exists'))
if not old:
old = CustomOptionGroup()
old.name = name
old.view_order = order
old.is_required = is_required == 1
old.group_help = group_help
old.can_recharge = cr
old.metric = metric
old.save()
return old.ext
def view_public_dedicated_profit(request):
if request.method == 'GET':
return render(request, 'public/ResellerProfit.html')
elif request.method == 'POST':
# base_price = 240000
action = request.POST.get('a')
if action == '1':
sell = get_integer(request.POST.get('s').replace(',', ''))
res = {
'internet': int(sell * 1.5),
'once': int(sell),
'monthly': int(sell * 0.10)
}
return HttpResponse(json.dumps(res))
elif action == '2':
is_special = 'cSP' in request.POST
bw = get_integer(request.POST.get('b'))
sell = get_integer(request.POST.get('sd').replace(',', ''))
if is_special:
min_price = read_config('visitor_special_min', 240000)
if sell < min_price:
return send_error(
request,
_('min price value is') + ' ' + str(min_price))
else:
min_price = read_config('visitor_normal_min', 170000)
if sell < min_price:
return send_error(
request,
_('min price value is') + ' ' + str(min_price))
co_profit = (sell - min_price) * bw # B9
if is_special:
one_time = co_profit * 2.2
monthly = co_profit * 0.3
else:
one_time = co_profit * 2.2
monthly = co_profit * 0.3
res = {'once': int(one_time), 'monthly': int(monthly)}
return HttpResponse(json.dumps(res))
elif action == '3':
bw = get_integer(request.POST.get('bi'))
sell = get_integer(request.POST.get('si').replace(',', ''))
base_price = read_config('visitor_intranet_base_price', 30000)
if sell < base_price:
return send_error(
request,
_('min price value is') + ' ' + str(base_price))
co_profit = (sell - base_price) * bw
one_time = co_profit * 2.2
monthly = co_profit * 0.3
return HttpResponse(
json.dumps({
'once': int(one_time),
'monthly': int(monthly)
}))
else:
logger.warning('invalid action requested %s' % action)
return send_error(request, _('unknown request'))
def _validate_basic_(self, *skip):
name = get_string(self.data.get('name'))
address = get_string(self.data.get('address'))
username = get_string(self.data.get('username'))
password = get_string(self.data.get('password'))
mail = get_string(self.data.get('mail'))
mobile = get_string(self.data.get('mobile'))
tel = get_string(self.data.get('phone'))
identity = get_string(self.data.get('identity'))
gender = get_integer(self.data.get('gender'), True)
is_active = get_integer(self.data.get('active'), True)
if not name:
self.er = CreateUserError(_('please enter name'), 80404)
return None
if not address:
self.er = CreateUserError(_('please enter address'), 82404)
return None
if not username:
self.er = CreateUserError(_('please enter username'), 81404)
return None
if not password:
self.er = CreateUserError(_('please enter password'), 83404)
return None
if not validate_email(mail):
self.er = CreateUserError(_('invalid email'), 84404)
return None
if not validate_mobile(mobile):
self.er = CreateUserError(_('invalid mobile'), 85404)
return None
if not validate_tel(tel):
self.er = CreateUserError(_('invalid phone number'), 86404)
return None
if not validate_identity_number(identity):
self.er = CreateUserError(_('invalid identity number'), 87404)
return None
if not gender.is_success():
self.er = CreateUserError(_('invalid gender'), 87404)
return None
u = User()
p = UserProfile()
u.username = username
u.first_name = name
u.email = mail
u.is_active = is_active.is_success()
u.set_password(password)
p.address = address
p.gender = gender
p.identity_number = identity
p.mobile = mobile
p.telephone = tel
p.user = u
return u, p
def internet(self):
x = self._validate_basic_()
if self.er is not None:
return False, self.er
is_dedicated = get_integer(self.data.get('dedicate'))
is_company = get_integer(self.data.get('company'))
x[0].save()
if is_company:
x[1].is_company = True
xd = CompanyData()
xd.user = x[0]
x[1].save()
return x[0].pk
def update(self, force_add=False):
post = self.store
x = self.get_single_ext()
px = self.__process_params__()
# print px
total_price = 0
service_list = []
for ix in px.keys():
s = DedicatedInvoiceService()
p = get_integer(px.get(ix).get('mx')) * get_integer(
px.get(ix).get('px'))
if p < 1:
self.error(_('please enter price'), True)
total_price += p
s.period = px.get(ix).get('mx')
s.price = px.get(ix).get('px')
sm = DedicateServiceManager(self.req, store=self.store)
sm.pk_name = 'sx' + ix
s.service = sm.get_single_ext(True)
service_list.append(s)
description = get_string(post.get('d'))
user = validate_user(get_integer(post.get('u')))
discount = get_integer(self.store.get('dp'))
total_price = total_price - discount
if total_price - discount < 1:
self.error(_('please correct the discount price'), True)
if not description:
description = '-'
if not user:
raise RequestProcessException(_('invalid user'))
if not x:
x = DedicatedInvoice()
type_m = DedicatedInvoiceTypeManager(self.req,
target=DedicatedInvoiceType,
store=self.store)
type_m.pk_name = 'ity'
invoice_type_ = type_m.get_single_ext(True)
x.user = user
x.send_type = None
x.description = description
x.price = total_price
x.tax = total_price * float(read_config('invoice_tax', 0.09))
x.discount = discount
x.send_date = None
x.invoice_type = invoice_type_
x.creator_id = self.requester.pk
x.save()
for s in service_list:
s.invoice = x
DedicatedInvoiceService.objects.bulk_create(service_list)
return x
def search(self):
store = self.store
user = get_integer(store.get('u'))
pk = get_integer(store.get(self.pk_name))
if self.has_perm('CRM.view_all_templates'):
res = UserFloatTemplate.objects.filter(is_deleted=False)
else:
res = UserFloatTemplate.objects.filter(user=self.requester.pk)
if user:
res = res.filter(user=user)
if pk:
res = res.filter(pk=pk)
res = res.filter(is_system=False)
return res
def get_pop_site(pk):
x = get_integer(pk)
if not x:
return None
if PopSite.objects.filter(pk=pk, is_deleted=False).exists():
return PopSite.objects.get(pk=pk)
return None
def add_partner_to_job(request):
dash = validate_dashboard(request.POST.get('d'), request.user)
tu = validate_user(request.POST.get('t'))
cmd = get_integer(request.POST.get('c'))
max_users = int(read_config('dashboard_max_partner', 5))
if not dash:
return send_error(request, _('invalid dashboard'))
if not tu:
return send_error(request, _('invalid user'))
if not cmd:
return send_error(request, _('invalid item'))
if cmd == 1:
if TicketTeam.objects.filter(dashboard=dash.pk, user=tu.pk).exists():
return send_error(request, _('this user has been selected before'))
if TicketTeam.objects.filter(dashboard=dash.pk).count() >= max_users:
return send_error(request, _('max users selected'))
tt = TicketTeam()
tt.user = tu
tt.dashboard = dash
tt.save()
msg = '%s : %s' % (_('user added to job'), tu.first_name)
add_work_history_outbox(dash, request.user, msg)
elif cmd == 2:
if not TicketTeam.objects.filter(dashboard=dash.pk,
user=tu.pk).exists():
return HttpResponse('200')
TicketTeam.objects.get(dashboard=dash.pk, user=tu.pk).delete()
msg = '%s : %s' % (_('user removed from job'), tu.first_name)
add_work_history_outbox(dash, request.user, msg)
return HttpResponse('200')
def update_reseller_profit_data(request):
name = get_string(request.POST.get('name'))
pk = get_integer(request.POST.get('pk'))
value = get_string(request.POST.get('value'))
if not name:
return send_error(request, _('invalid name'))
if not pk:
return send_error(request, _('invalid item'))
if not value:
return send_error(request, _('invalid value'))
user = validate_user(pk)
if not user:
return send_error(request, _('invalid user'))
if not ResellerProfitOption.objects.filter(
reseller__user=user.pk).exists():
return send_error(request, _('invalid user'))
op = ResellerProfitOption.objects.get(reseller__user=user.pk)
if name == 'srv':
op.service_profit = float(value)
elif name == 'pck':
print value
op.package_profit = float(value)
elif name == 'ngv':
op.max_neg_credit = int(value)
else:
return send_error(request, _('invalid option'))
op.save()
return HttpResponse('200')
def delete_calendar_event(request):
dash = validate_dashboard(get_integer(request.GET.get('d')))
if not dash:
return send_error(request, _('invalid dashboard'))
if Calendar.objects.filter(dashboard=dash.pk).exists():
Calendar.objects.filter(dashboard=dash.pk).delete()
add_work_history_outbox(dash, request.user, _('schedule removed'))
return HttpResponse('200')
def get_int(self, name, throw=False, default=0):
param = get_integer(self.store.get(name), cls=True)
if not param.is_success() and throw:
logger.warning('item not entered for %s : int %s' %
(self.target, name))
self.error(_('this field is required'), True, name)
elif param.is_success():
return param.value()
return default
def round_price(p):
price = get_integer(p)
if not price:
return 0
r = price % 1000
if r >= 500:
s = r - 500
else:
s = r
return price - s
def get_reseller(request):
uid = get_integer(request.GET.get('u'))
if not uid:
return None
if request.user.fk_reseller_profile_user.exists() and request.user.pk != uid:
if not request.user.has_perm('CRM.view_all_reseller_data'):
return None
if User.objects.filter(pk=uid, fk_reseller_profile_user__isnull=False).exists():
return User.objects.get(pk=uid)
return None
def __process_params__(self):
keys = self.store.keys()
params = {}
for k in keys:
if len(k) == 3:
if get_integer(k[2]):
if k[2] not in params:
params.update({k[2]: {}})
params[k[2]].update({k[:2]: self.store.get(k)})
return params
def delete_working_time(request):
pk = get_integer(request.GET.get('w'), True)
if not pk.is_success():
return send_error(request, _('invalid week day'))
work = get_working_time_by_pk(pk.value())
if not work:
return send_error(request, _('invalid week day'))
work.is_deleted = True
work.save()
return HttpResponse('200')
def update_state(self):
store = self.store
x = self.get_single_ext(True)
if DedicatedInvoiceState.objects.filter(invoice=x.pk).exists():
state = DedicatedInvoiceState.objects.get(invoice=x.pk)
if state.state == 7:
return
else:
state = DedicatedInvoiceState()
state.invoice = x
state.next_change = parse_date_from_str(store.get('cd'))
state.state = get_integer(store.get('st'))
state.save()
hs = DedicatedInvoiceStateHistory()
hs.invoice = x
hs.state = get_integer(store.get('st'))
hs.user = self.requester
hs.extra_data = get_string(store.get('dt')) or '-'
hs.save()
def get_working_time(request):
week_day = get_integer(request.GET.get('w'), True)
if not week_day:
return send_error(request, _('invalid week day'))
wt = WorkingTime.objects.filter(week_day=week_day.value(),
is_deleted=False).values(
'pk', 'week_day', 'resource',
'start_time', 'end_time', 'name',
'event_type__name')
return HttpResponse(json.dumps(list(wt), default=date_handler))
def update(self, force_add=False):
self.set_post()
name = self.get_str('n', True, max_len=255)
min_value = self.get_float('i', False)
max_value = self.get_float('a', False)
group_type = self.get_int('gt', False)
var_name = self.get_str('vn')
package = self.get_int('p')
pool = get_ibs_ip_pool(self.get_uid('ip', False))
has_custom_value = self.get_int('cf')
custom_value_min = self.get_int('cfi')
custom_value_max = self.get_int('cfx')
help_text = self.get_str('ht', False, '-')
related_group = self.store.getlist('rg')
related_group_list = []
group_manager = OptionGroupManager(self.req)
group_manager.pk_name = 'og'
group_manager.set_post()
group = group_manager.get_single_ext(True)
if not min_value:
min_value = 0
if not max_value:
max_value = 0
co = self.get_single_ext()
if not custom_value_max:
custom_value_max = 0
if not custom_value_min:
custom_value_min = 0
for rg in related_group:
tmp = get_integer(rg)
if tmp:
related_group_list.append(tmp)
if not co:
co = CustomOption()
co.name = name
co.min_value = min_value
co.max_value = max_value
co.group_type = group_type
co.package = package
co.var_name = var_name
co.group = group
co.pool = pool
co.help_text = help_text
co.is_custom_value = has_custom_value == 1
co.custom_value_min = custom_value_min
co.custom_value_max = custom_value_max
co.save()
CustomOptionRelateGroup.objects.filter(option=co.pk).delete()
if related_group_list:
for rg in related_group_list:
cor = CustomOptionRelateGroup()
cor.option_id = co.pk
cor.group_id = rg
cor.save()
return co.ext
def get_config_state(request):
command = get_integer(request.GET.get('c'))
if not command:
return send_error(request, _('invalid command'))
if command == 1:
load_config(True)
return HttpResponse(get_state())
elif command == 2:
return HttpResponse(get_state())
else:
return send_error(request, _('invalid command'))
def get_single_pk(self, raise_error=False):
store = self.store
pk = get_integer(store.get(self.pk_name))
if not pk:
self.error(_('invalid item'), raise_error)
if UserFloatTemplate.objects.filter(pk=pk, is_deleted=False).exists():
x = UserFloatTemplate.objects.get(pk=pk)
if self.requester.has_perm('CRM.view_all_templates'):
return x
elif x.user_id == self.requester.pk:
return x
self.error(_('no such item'), raise_error)
def search(self):
req = self.store
sp = get_string(req.get('searchPhrase'))
user_id = get_integer(req.get('u'))
send_date = parse_date_from_str(req.get('sds'))
send_type = get_integer(req.get('stp'))
state = get_integer(req.get('st'))
invoice_type = get_integer(req.get('t'))
invoice_number = get_integer(req.get('in'))
ibs_id = get_integer(req.get('i'))
res = DedicatedInvoice.objects.all()
if sp:
res = res.filter(user__first_name__icontains=sp)
if user_id:
res = res.filter(user=user_id)
if ibs_id:
res = res.filter(user__fk_ibs_user_info_user__ibs_uid=ibs_id)
if invoice_number:
res = res.filter(system_invoice_number=invoice_number)
if invoice_type:
res = res.filter(invoice_type_id=invoice_type)
if send_type:
res = res.filter(send_type_id=send_type)
if send_date:
res = res.filter(send_date=send_date.date())
if state:
res = res.filter(fk_dedicated_invoice_state_invoice__state=state)
return res
def add_package_group(request):
pack = get_charge_package_ext(request.POST.get('p'))
groups = request.POST.getlist('grp')
if not pack:
return send_error(request, _('invalid item'))
pack.fk_price_package_group_price_package.all().delete()
for g in groups:
if get_integer(g):
if Group.objects.filter(pk=g).exists():
pp = PricePackageGroup()
pp.group_id = g
pp.price_package_id = pack.pk
pp.save()
return HttpResponse('200')
def add_charge_package(request):
name = get_string(request.POST.get('n'))
amount = get_integer(request.POST.get('a'))
if not name:
return send_error(request, _('please enter name'))
if not amount:
return send_error(request, _('please enter amount'))
if PricePackage.objects.filter(name__iexact=name,
is_deleted=False).exists():
return send_error(request, _('item exist'))
p = PricePackage()
p.name = name
p.amount = amount
p.save()
return HttpResponse(p.ext)
def add_equipment_code(request):
c = get_string(request.POST.get('p'))
sell_price = get_integer(request.POST.get('sp'))
used_sell = get_integer(request.POST.get('up'))
name = get_string(request.POST.get('n'))
if not name:
return send_error(request, _('please enter name'))
if not c:
return send_error(request, _('please enter code'))
if not sell_price:
return send_error(request, _('please enter sell price'))
if not used_sell:
return send_error(request, _('please enter used sell price'))
code = get_equipment_code(request.POST.get('pk'))
if not code:
if EquipmentCode.objects.filter(name__iexact=name).exists():
return send_error(request, _('item exist'))
code = EquipmentCode()
code.code = c
code.name = name
code.sell_price = sell_price
code.used_sell_price = used_sell
code.save()
return HttpResponse(code.pk)
def view_user_au(request):
q = get_string(request.GET.get('query'))
q2 = get_integer(request.GET.get('query'))
if q2:
rs = list(
User.objects.filter(
Q(fk_ibs_user_info_user__ibs_uid=q2) | Q(pk=q2)).values(
'id', 'first_name'))
elif q:
rs = list(
User.objects.filter(first_name__icontains=q).values(
'id', 'first_name'))
else:
rs = []
return HttpResponse(json.dumps(rs))
def view_users(request):
user_type = get_integer(request.GET.get('t'))
if not user_type:
return send_error(request, _('invalid user'))
if not check_ajax(request):
return render(request, 'user/ViewUsers.html', {
'has_nav': False,
'user_type': user_type
})
users = UserProfile.objects.all()
sp = get_string(request.GET.get('searchPhrase'))
if sp:
users = users.filter(user__first_name__icontains=sp)
if user_type == 1 and request.user.has_perm('CRM.view_admins'): # admins
users = users.filter(user__is_staff=True, user__is_superuser=True)
elif user_type == 2 and request.user.has_perm(
'CRM.view_personnel'): # personnel but not resellers!
users = users.filter(user__is_staff=True,
user__is_superuser=False,
user__fk_reseller_profile_user__isnull=True)
elif user_type == 3 and request.user.has_perm('CRM.view_resellers') and not \
request.user.fk_user_profile_user.is_reseller: # Resellers
users = users.filter(is_reseller=True)
elif user_type == 4 and request.user.has_perm(
'CRM.view_normal_users'): # Internet users
users = users.filter(user__is_staff=False, user__is_superuser=False)
elif user_type == 5 and request.user.has_perm('CRM.view_dedicated_user'):
users = users.filter(is_dedicated=True)
elif user_type == 6:
users = users.filter(user__fk_user_owner_user__owner=request.user.pk)
elif user_type == 7 and request.user.has_perm('CRM.view_visitors'):
users = users.filter(is_visitor=True)
if request.RSL_ID is not None:
users = users.filter(user__fk_user_owner_user__owner=request.RSL_ID)
fields = [
'address', 'user__pk', 'user__first_name', 'user__username',
'user__email', 'gender', 'mobile', 'telephone', 'user__is_active',
'user__fk_ibs_user_info_user__ibs_uid',
'user__fk_user_debit_user__amount',
'user__fk_user_current_service_user__service__name',
'user__fk_user_current_service_user__expire_date'
]
sort = get_full_sort(request.GET, fields)
users = users.values(*fields).distinct().order_by(sort)
res = get_paginate(users, request.GET.get('current'),
request.GET.get('rowCount'))
return HttpResponse(res)
def __update_state__(self, x, state):
cus = None
if hasattr(x, 'fk_dedicated_invoice_state_invoice'):
if x.fk_dedicated_invoice_state_invoice.state == 7:
return x.ext
cus = DedicatedInvoiceState.objects.get(invoice=x.pk)
if cus is None:
cus = DedicatedInvoiceState()
cus.invoice = x
cus.state = state
cus.save()
hs = DedicatedInvoiceStateHistory()
hs.invoice = x
hs.state = get_integer(state)
hs.user = self.requester
hs.extra_data = '-'
hs.save()
def view_all_mails(request):
mim = MailInboxManagement(request)
if not check_ajax(request):
if not request.user.has_perm('view_others_mail'):
uid = request.user.pk
elif get_integer(request.GET.get('u')):
uid = request.GET.get('u')
else:
uid = request.user.pk
has_mail = mim.get_user_data(uid)
# mim.update()
return render(request, 'mail/ViewAllMails.html', {
'has_nav': True,
'has_mail': has_mail,
'mails': mim.search()
})
mails = mim.get_all()
return HttpResponse(mails)
def get_group_data(request):
if not check_ajax(request):
return send_error(request, _('invalid method'))
gid = get_integer(request.GET.get('g'))
if not gid:
services = IBSService.objects.filter(is_deleted=False).values(
'pk', 'name')
packages = Traffic.objects.filter(is_deleted=False).values(
'pk', 'name')
else:
services = IBSService.objects.filter(
fk_service_group_service__group=gid,
is_deleted=False).values('pk', 'name')
packages = Traffic.objects.filter(
is_deleted=False,
fk_package_groups_package__group=gid).values('pk', 'name')
res = {'packages': list(packages), 'services': list(services)}
return HttpResponse(json.dumps(res))
def equipment_return_to_inventory(request):
equipment = get_equipment_ext(request.POST.get('pk'))
state = get_equipment_state_list_ext(request.POST.get('st'))
return_amount = get_integer(request.POST.get('ram'))
if not equipment:
return send_error(request, _('invalid item'))
if not state:
return send_error(request, _('invalid state'))
if EquipmentState.objects.filter(equipment=equipment.pk).exists():
st = EquipmentState.objects.get(equipment=equipment.pk)
else:
st = EquipmentState()
st.equipment = equipment
st.state = state
st.save()
if InvolvedEquipment.objects.filter(equipment=equipment.pk, is_deleted=False).exists() and 'rls' in request.POST:
ie = InvolvedEquipment.objects.get(equipment=equipment.pk, is_deleted=False)
ie.remove()
if 'srt' in request.POST:
if equipment.is_used:
equipment.group.change_remain(1, 0)
else:
equipment.group.change_remain(0, 1)
if 'rls' in request.POST:
equipment.is_involved = False
if equipment.fk_equipment_order_detail_equipment.exists():
res_x = equipment.fk_equipment_order_detail_equipment.all()
for r in res_x:
r.order_item.delete()
r.delete()
equipment.save()
if equipment.fk_equipment_order_detail_equipment.exists():
rt = EquipmentReturn()
rt.order_id = equipment.fk_equipment_order_detail_equipment.last().pk
rt.save()
ec = EquipmentItemCountHistory()
ec.equipment = equipment
if not return_amount:
return_amount = 1
ec.change = return_amount
ec.save()
return HttpResponse('200')
