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 config_management(request):
if request.method == 'GET':
reload_from_cache = request.GET.get('relocate', '0') == 'YES!PLEASE!'
conf = get_config()
data = {}
sections = conf.sections()
for s in sections:
opt = {}
ox = conf.options(s)
for o in ox:
if reload_from_cache:
new_config = read_config('%s_%s' % (s, o))
set_config(s, o, new_config)
dx = {o: new_config}
else:
dx = {o: conf.get(s, o)}
opt.update(dx)
data.update({s: opt})
return render(request, 'configuration/ConfigManagement.html', {'data': data})
elif request.method == 'POST':
name = get_string(request.POST.get('name'))
value = get_string(request.POST.get('value'))
if not name:
return send_error(request, _('invalid item'))
if not value:
return send_error(request, _('invalid value'))
section = name.split('__')
if len(section) < 2:
return send_error(request, _('invalid value'))
set_config(section[0], section[1], value)
load_config(True)
return HttpResponse('200')
else:
return send_error(request, _('invalid method'))
def add_equipment_group(request):
name = get_string(request.POST.get('n'))
des = get_string(request.POST.get('d'))
eq_type = get_equipment_type_ext(request.POST.get('t'))
old = get_equipment_group(request.POST.get('pk'))
code = get_equipment_code(request.POST.get('c'))
if not name:
return send_error(request, _('please enter name'))
if not code:
return send_error(request, _('please select a code'))
if not des:
des = '--'
if not eq_type:
return send_error(request, _('please select a group'))
if old:
eq = old
else:
if EquipmentGroup.objects.filter(name__iexact=name).exists():
return send_error(request, _('item exists'))
eq = EquipmentGroup()
eq.name = name
eq.description = des
eq.equipment_type = eq_type
eq.code = code
eq.save()
return HttpResponse(eq.pk)
def view_equipment_type_au(request):
n = get_string(request.GET.get('query'))
if not n:
res = []
else:
res = list(EquipmentType.objects.filter(name__icontains=n).values_list('name', flat=True))
return HttpResponse(json.dumps(res))
def search(self):
req = self.req
name = get_string(req.GET.get('searchPhrase'))
res = DedicatedInvoiceType.objects.filter(is_deleted=False)
if name:
res = res.filter(name__icontains=name)
return res
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 search(self):
req = self.req
res = BasicService.objects.filter(is_deleted=False)
name = get_string(req.GET.get('searchPhrase'))
if name:
res = res.filter(name__icontains=name)
return res
def search(self):
req = self.req
name = get_string(req.GET.get('searchPhrase'))
res = CustomOption.objects.filter(is_deleted=False)
if name:
res = res.filter(name__icontains=name)
return res
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_new_equipment_state_list(request):
name = get_string(request.POST.get('n'))
description = get_string(request.POST.get('d'))
state = get_equipment_state_list_ext(request.POST.get('pk'))
if not name:
return send_error(request, _('please enter name'))
if not description:
return send_error(request, _('please enter description'))
if not state:
if EquipmentStateList.objects.filter(name__iexact=name).exists():
return send_error(request, _('item exists'))
state = EquipmentStateList()
state.name = name
state.description = description
state.save()
return HttpResponse(state.pk)
def add_new_transport(request):
name = get_string(request.POST.get('n'))
description = get_string(request.POST.get('d'))
t_type = get_transport_type(request.POST.get('t'))
if not name:
return send_error(request, _('please enter name'))
if not t_type:
return send_error(request, _('invalid type selected'))
if Transportation.objects.filter(name__iexact=name,
is_deleted=False).exists():
return send_error(request, _('name is exists'))
t = Transportation()
t.name = name
t.description = description
t.transport_type = t_type
t.save()
return HttpResponse('200')
def view_pop_site_au(request):
q = get_string(request.GET.get('query'))
if q:
rs = list(
PopSite.objects.filter(name__icontains=q).values('id', 'name'))
else:
rs = []
return HttpResponse(json.dumps(rs))
def reject_equipment_order_item(request):
order = get_equipment_order_item_ext(request.POST.get('pk'))
reason = get_string(request.POST.get('r'))
if not order:
return send_error(request, _('invalid order'))
if not reason:
return send_error(request, _('please enter reject reason'))
order.reject(reason)
return HttpResponse(order.ext)
def view_tower_for_au(request):
q = get_string(request.GET.get('query'))
if q:
res = list(
Tower.objects.filter(is_deleted=False,
name__icontains=q).values('name', 'id'))
else:
res = []
return HttpResponse(json.dumps(res))
def update(self, force_add=False):
store = self.store
name = get_string(store.get('n'))
if not name:
return self.error(_('please enter name'), True)
x = self.get_single_ext(False)
if not x:
x = DedicatedService()
x.name = name
x.save()
def update(self, force_add=False):
req = self.store
name = get_string(req.get('n'))
old = self.get_single_ext()
if not name:
raise RequestProcessException(_('please enter name'))
if not old:
old = DedicatedInvoiceType()
old.name = name
old.save()
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 add_new_transport_type(request):
name = get_string(request.POST.get('n'))
if not name:
return send_error(request, _('please enter name'))
if TransportType.objects.filter(name__iexact=name,
is_deleted=False).exists():
return send_error(request, _('this name is exists'))
t = TransportType()
t.name = name
t.save()
return HttpResponse('200')
def add_new_equipment_type(request):
name = get_string(request.POST.get('n'))
tx = get_equipment_type_ext(request.POST.get('pk'))
if not name:
return send_error(request, _('please enter name'))
if not tx:
if EquipmentType.objects.filter(is_deleted=False, name__iexact=name).exists():
return send_error(request, _('item exists'))
tx = EquipmentType()
tx.name = name
tx.save()
return HttpResponse(tx.ext)
def download_dedicated_invoice(request):
dm = DedicatedInvoiceManager(request)
try:
dm.set_post()
x = dm.get_single_ext(True)
data = get_string(request.POST.get('od'))
return render_to_pdf(request, 'finance/dedicate/PDFTemplate.html', {
'i': x,
'extra_data': data,
'tax': x.tax
})
except RequestProcessException as e:
return send_error(request, e.message)
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 create_invoice(self):
d = self.get_single_ext(True)
store = self.store
if d.system_invoice_number > 0:
raise RequestProcessException(_('invoice generation done before'))
bank_ref = get_string(store.get('rf'))
comment = get_string(store.get('c'))
pay_time = parse_date_from_str(store.get('pd'))
if not bank_ref:
raise RequestProcessException(_('please enter bank ref code'))
if not comment:
comment = ''
if not pay_time:
pay_time = datetime.today()
i = Invoice()
ins = InvoiceService()
ins.content_object = d
ins.service_type = 5
ins.save()
i.comment = comment
i.create_time = datetime.today()
i.debit_price = 0
i.dynamic_discount = 0
i.extra_data = 0
i.is_paid = True
i.paid_online = False
i.pay_time = pay_time
i.price = d.price
i.ref_number = bank_ref
i.service = ins
i.service_text = _('dedicate service')
i.user_id = d.user_id
i.comment = self.requester.username
i.save()
d.system_invoice_number = i.pk
d.save()
self.__update_state__(d, 7)
return i.pk
def view_charge_packages(request):
if not check_ajax(request):
return render(request, 'finance/debit/ChargePackageManagement.html',
{'groups': Group.objects.all()})
name = get_string(request.GET.get('searchPhrase'))
fields = ['pk', 'name', 'ext', 'amount']
sort = get_full_sort(request.GET, fields)
packs = PricePackage.objects.filter(is_deleted=False)
if name:
packs = packs.filter(name__icontains=name)
packs = packs.values(*fields).order_by(sort)
res = get_paginate(packs, request.GET.get('current'),
request.GET.get('rowCount'))
return HttpResponse(res)
def update(self, force_add=False):
user = self.get_target_user()
fv = FloatValidator(self.req, store=self.store)
fv.validate()
service_time = self.get_int('iMon', False, 1)
if service_time < 1:
service_time = 1 # Negative Time Validation!
res = fv.get_all()
if not len(res[0]):
raise RequestProcessException(_('nothing to calculate'))
name = get_string(self.store.get('t_name'))
if not name:
name = fv.service.name
ut = None
if force_add:
ut = self.get_single_ext()
if not ut:
ut = UserFloatTemplate()
ut.user = user
ut.service_id = fv.service.pk
ut.create_date = now()
ut.service_period = service_time
ut.name = name
ut.final_price = res[2]
ut.is_system = not force_add # Used to determine the status of template! this is not a system template
ut.save()
# option_list = []
ut.fk_float_template_template.all().delete()
for r in res[0]:
if not hasattr(r.option, 'group'):
continue
# ft = FloatTemplate.objects.filter(option=r.option.pk).first()
# if not ft:
ft = FloatTemplate()
ft.option_id = r.option.pk
ft.price = r.price
ft.total_price = r.total_price
ft.value = r.value
ft.template_id = ut.pk
# option_list.append(ft)
ft.save()
# FloatTemplate.objects.bulk_create(option_list)
utx = AssignedUserTemplate.objects.filter(user=user.pk,
template=ut.pk).first()
if not utx:
utx = AssignedUserTemplate()
utx.user = user
utx.template = ut
utx.save()
return ut
def select_equipment_for_order(request):
order = get_equipment_order_item_ext(request.POST.get('pk'))
equipment = get_equipment_ext(request.POST.get('eq'))
owner_tag = get_string(request.POST.get('bc'))
address = get_string(request.POST.get('adr'))
if not order:
return send_error(request, _('invalid order'))
if not equipment:
return send_error(request, _('invalid item'))
if InvolvedEquipment.objects.filter(equipment=equipment.pk, is_deleted=False).exists():
return send_error(request, _('this item selected for order'))
ib = order.order.is_borrow
if ib:
if not owner_tag:
return send_error(request, _('please enter property number'))
if not address:
return send_error(request, _('please enter address'))
ed = EquipmentOrderDetail()
ed.equipment = equipment
ed.order_item = order
ed.save()
order.accept()
equipment.is_involved = True
equipment.save()
ie = InvolvedEquipment()
ie.equipment = equipment
main_order = EquipmentOrder.objects.get(pk=order.order_id)
ie.item_text = main_order.item_text
ie.order_id = main_order.pk
ie.save()
if ib:
eb = EquipmentBorrow()
eb.address = address
eb.order = ed
eb.property_number = owner_tag
eb.save()
return HttpResponse(ed.ext)
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 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 add_new_equipment(request):
serial = get_string(request.POST.get('s'))
des = get_string(request.POST.get('d'))
group = get_equipment_group(request.POST.get('g'))
equipment = get_equipment_ext(request.POST.get('pk'))
if not serial:
return send_error(request, _('invalid serial'))
if not des:
return send_error(request, _('please enter description'))
if not group:
return send_error(request, _('please select group'))
if not equipment:
equipment = Equipment()
equipment.description = des
equipment.group = group
equipment.serial = serial
if equipment.pk is None:
if equipment.is_used:
equipment.group.change_remain(1, 0)
else:
equipment.group.change_remain(0, 1)
EquipmentNewItemAddedEventHandler().fire(equipment, None, request.user.pk)
equipment.save()
return HttpResponse(equipment.ext)
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 reserve_time_for_job(request):
date = get_string(request.GET.get('d'))
time = get_integer(request.GET.get('t'))
job = validate_dashboard(get_integer(request.GET.get('j')))
try:
cm = CalendarEventTypeRequestManager(request)
cm.pk_name = 'e'
event_id = cm.get_single_ext(True).pk
except RequestProcessException as e:
return e.get_response()
except Exception as e:
logger.error(e.message or e.args)
return send_error(request, _('system error'))
priority_res = get_integer(request.GET.get('pri'), True)
if not date:
return send_error(request, _('invalid date'))
if not time:
return send_error(request, _('invalid time'))
if not job:
return send_error(request, _('please select a job'))
if not priority_res.is_success():
priority = 0
else:
priority = priority_res.value()
if Calendar.objects.filter(dashboard=job.pk).exists():
return send_error(request, _('this job has been added before'))
date_split = date.split('-')
day = get_integer(date_split[2].split(' ')[0])
month = get_integer(date_split[1])
year = get_integer(date_split[0])
if not (year and month and day):
return send_error(request, _('invalid date format'))
cl = Calendar()
cl.dashboard = job
cl.work_time_id = time
cl.event_type = event_id
cl.cal_day = day
cl.priority = priority
cl.cal_month = month
cl.cal_year = year
cl.save()
wb = WorkingTime.objects.get(pk=time)
msg = u'%s در تاریخ %s از ساعت %s تا %s' % (
_('time scheduled'), date, str(wb.start_time.strftime('%H:%M')),
str(wb.end_time.strftime('%H:%M')))
add_work_history_outbox(job, request.user, msg)
return HttpResponse('200')
