def view_equipment_type(request):
if not check_ajax(request):
return render(request, 'equipment/equipment_type/TypeManagement.html', {'has_nav': True})
fields = ['pk', 'ext', 'name']
sort = get_full_sort(request.GET, fields)
res = search_equipment_type(request.GET).values(*fields).order_by(sort)
p = get_paginate(res, request.GET.get('current'), request.GET.get('rowCount'))
return HttpResponse(p)
def view_equipment_code(request):
if not check_ajax(request):
return render(request, 'equipment/codes/CodeManagement.html', {'has_nav': False})
fields = ['pk', 'ext', 'code', 'sell_price', 'used_sell_price', 'name']
sort = get_full_sort(request.GET, fields)
ec = search_equipment_code(request.GET).values(*fields).order_by(sort)
rs = get_paginate(ec, request.GET.get('current'), request.GET.get("rowCount"))
return HttpResponse(rs)
def view_equipment_state_list(request):
if not check_ajax(request):
return render(request, 'equipment/state_list/StateListManagement.html', {'has_nav': True, 'get': request.GET})
fields = ['pk', 'name', 'description', 'ext']
order = get_full_sort(request.GET, fields)
states = search_equipment_state_list(request.GET).values(*fields).order_by(order)
res = get_paginate(states, request.GET.get('current'), request.GET.get('rowCount'))
return HttpResponse(res)
def view_equipment_group(request):
if not check_ajax(request):
return render(request, 'equipment/group/GroupManagement.html', {'has_nav': False})
fields = ['name', 'pk', 'description', 'ext', 'equipment_type__name', 'remain_items', 'used_remain_items',
'code__code']
sort = get_full_sort(request.GET, fields)
groups = search_equipment_group(request.GET).values(*fields).order_by(sort)
rs = get_paginate(groups, request.GET.get('current'), request.GET.get('rowCount'))
return HttpResponse(rs)
def get_type_sub_group(request):
ext = get_uuid(request.GET.get('pk'))
if not ext:
return send_error(request, _('invalid item'))
fields = ['ext', 'pk', 'name', 'remain_items', 'used_remain_items',
'code__sell_price', 'code__used_sell_price', 'code__code']
sort = get_full_sort(request.GET, fields)
groups = EquipmentGroup.objects.filter(Q(remain_items__gt=0) | Q(used_remain_items__gt=0),
equipment_type__ext=ext).values(*fields).order_by(sort)
return HttpResponse(get_paginate(groups, request.GET.get('current'), request.GET.get('rowCount')))
def view_equipment(request):
if not check_ajax(request):
groups = EquipmentGroup.objects.all()
return render(request, 'equipment/ViewEquipment.html', {'has_nav': True, 'equipment_groups': groups})
fields = ['ext', 'description', 'group__name', 'last_update',
'is_involved', 'is_used', 'pk', 'serial', 'fk_equipment_state_equipment__state__name']
order = get_full_sort(request.GET, fields)
res = search_equipment(request.GET).values(*fields).order_by(order)
x = get_paginate(res, request.GET.get('current'), request.GET.get('rowCount'))
return HttpResponse(x)
def view_equipment_order_select(request):
order = get_equipment_order_item_ext(request.GET.get('pk'))
if not order:
return send_error(request, _('invalid item'))
fields = ['pk', 'ext', 'is_used', 'description', 'group__name', 'serial']
sort = get_full_sort(request.GET, fields)
init_eq = get_equipment_by_group_pk(order.equipment_id).filter(is_used=order.is_used)
res = search_equipment(request.GET, init_eq).values(*fields).order_by(sort)
x = get_paginate(res, request.GET.get('current'), request.GET.get('rowCount'),
{'is_borrow': order.order.is_borrow})
return HttpResponse(x)
def view_reseller_profit_change(request):
rsl = get_reseller(request)
if not rsl:
return send_error(request, _('invalid user'))
fields = ['pk', 'update_date', 'new_value', 'old_value']
sort = get_full_sort(request.GET, fields)
data = ResellerProfitHistory.objects.filter(user_id=rsl.pk).values(
*fields).order_by(sort)
x = get_paginate(data, request.GET.get('current'),
request.GET.get('rowCount'))
return HttpResponse(x)
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 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)
class BaseRequestManager(object):
def __init__(self, request, **kwargs):
if not isinstance(request, HttpRequest):
raise TypeError('Expected %s Got %s' %
(type(HttpRequest), type(request)))
self.req = request
self.__kw__ = kwargs
if 'store' in kwargs:
store = kwargs.get('store')
if not isinstance(store, QueryDict):
raise TypeError('QueryDict Type Expected')
else:
store = request.GET
if 'fields' in kwargs:
self.fields = kwargs.get('fields')
if 'target' in kwargs:
self.target = kwargs.get('target')
if 'upload_type' in kwargs:
self.upload_type = kwargs.get('upload_type')
self.store = store
if hasattr(request, 'RSL_ID'): # Reseller Validation
self.__rsl_id = request.RSL_ID
self.__target_user_field = 'u'
__target = None
__fields = []
__store = None
__rsl_id = None
__upload_type = None
__pk_name = 'pk'
def __get_upload_type(self):
if self.__dict__.get('upload_type'):
return self.__dict__.get('upload_type')
return self.__upload_type
def __set_upload_type(self, v):
self.__upload_type = v
def __get_reseller(self):
return self.__rsl_id
def __get_db_fields(self):
if self.__fields:
return self.__fields
else:
return self.__dict__.get('fields')
def __set_db_fields(self, v):
if isinstance(v, list):
self.__fields = v
else:
raise TypeError('List Required')
def __get_target_object(self):
return self.__target
def __set_target_object(self, v):
self.__target = v
def __set_store(self, v):
self.__store = v
def __get_store(self):
return self.__store
url_data = property(lambda self: self.req.GET.urlencode())
fields = property(__get_db_fields, __set_db_fields)
sort = property(lambda self: get_full_sort(self.store, self.fields))
store = property(__get_store, __set_store)
requester = property(lambda self: self.req.user)
target = property(__get_target_object, __set_target_object)
upload_type = property(__get_upload_type, __set_upload_type)
current = property(lambda self: self.__dict__.get('current_object'))
reseller = property(__get_reseller) # Change for prevent Errors!
@staticmethod
def as_json(data):
return json.dumps(data, default=date_handler)
def get_target_user(self, throw=False):
if not self.requester.is_authenticated():
if throw:
self.error(_('user is not logged in'), True)
if hasattr(self.req, 'ip_login'):
return self.req.user
return AnonymousUser()
if self.requester.is_staff:
uid = self.get_int(self.target_user_field, throw)
user = User.objects.filter(pk=uid)
if self.reseller:
user = user.filter(fk_user_owner_user__owner=self.reseller)
user = user.first()
if not user:
if throw:
logger.warning('invalid user selected')
self.error(_('invalid user selected'), True, 'u')
return self.requester
else:
user = self.requester
return user
def get_file(self):
x = self.get_single_ext(True)
files = self.get_model_files().filter(upload_type__object_id=x.pk)
return files
def get_file_json(self):
x = self.get_file()
res = x.values('pk', 'ext', 'upload_date', 'original_name',
'upload_type_text', 'uploader__first_name',
'uploader__pk', 'user__first_name', 'user__pk')
return json.dumps(list(res), default=date_handler)
def get_model_files(self):
if not self.upload_type:
raise NotImplementedError('Without upload type?')
up = DocumentUpload.objects.filter(
upload_type__upload_type=self.upload_type)
return up
def get_model_files_json(self):
res = self.get_model_files()
x = res.values('pk', 'ext', 'upload_date', 'original_name',
'upload_type_text', 'uploader__first_name',
'uploader__pk', 'user__first_name', 'user__pk')
return json.dumps(list(x), default=date_handler)
def set_get(self):
self.__store = self.req.GET
def set_post(self):
self.__store = self.req.POST
def __set_pk__(self, val):
self.__pk_name = val
def __get_pk(self):
return self.__pk_name
def __set_target_user_field(self, n):
"""
Set Target User Filed from "u" to n
@param n: str
@return: str
"""
self.__target_user_field = n
def __get_target_user_field(self):
return self.__target_user_field
pk_name = property(__get_pk, __set_pk__)
target_user_field = property(__get_target_user_field,
__set_target_user_field)
def search(self):
raise NotImplementedError('Implement This!')
def get_all(self):
res = self.search().values(*self.fields).order_by(self.sort)
paged = self.paginate(res)
return paged
def file_upload(self):
x = self.get_single_ext(True)
uh = UploadFileHandler(self.req, x, x.user_id, self.upload_type)
try:
uh.save()
except Exception as e:
logger.error(e.message or e.args)
raise RequestProcessException(e.message, self.pk_name)
def get_single_ext(self, raise_error=False):
if not self.target:
raise NotImplementedError('target is not set!')
if self.current:
return self.current
pk = self.get_uid(self.pk_name, raise_error)
if not pk:
return None
if self.target.objects.filter(ext=pk).exists():
ob = self.target.objects.get(ext=pk)
self.__dict__.update({'current_object': ob})
return ob
logger.warning('no such item found for %s : %s' % (self.target, pk))
return self.error(_('no such item'), raise_error, self.pk_name)
def get_single_pk(self, raise_error=False):
if not self.target:
raise NotImplementedError('target is not set!')
if self.current:
return self.current
pk = self.get_pk(raise_error)
if not pk:
return None
if self.target.objects.filter(pk=pk).exists():
ob = self.target.objects.get(pk=pk)
self.__dict__.update({'current_object': ob})
return ob
logger.warning('no such item found for %s : %s' % (self.target, pk))
return self.error(_('no such item'), raise_error, self.pk_name)
def delete(self):
x = self.get_single_ext(True)
x.delete()
def update(self, force_add=False):
raise NotImplementedError('This Method Is not Working yet')
def paginate(self, l):
rex = get_paginate(l, self.get_int('current', default=1),
self.get_int('rowCount', default=10))
return rex
def error(self, message, raise_error, param=None):
if raise_error:
raise RequestProcessException(message, param)
return None
def attach_file(self, file_name):
pass
# dir_name = os.path.dirname(os.path.dirname(__file__)) + '/../Docs/' + str(self.user_id) + '/'
def get_search_phrase(self):
return self.get_str('searchPhrase')
def get_str(self, name, throw=False, default=None, max_len=0, min_len=0):
param = self.store.get(name)
if not param and throw:
logger.warning('item not entered for %s : str %s' %
(self.target, name))
self.error(_('this field is required'), True, name)
elif param:
if max_len > 0:
if len(param) > max_len:
logger.warning(
'item len is too long for %s : %s, max : %s' %
(self.target, name, max_len))
if throw:
self.error(_('length is too long.'), True, name)
return None
if min_len > 0:
if len(param) < min_len:
if throw:
self.error(_('invalid data'), throw, name)
else:
return default
if param == default:
if throw:
self.error(_('invalid data'), True, name)
return param
return default
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 get_float(self, name, throw, default=0.0):
param = validate_float(self.store.get(name))
if not param and throw:
logger.warning('item not entered for %s : float %s' %
(self.target, name))
self.error(_('this field is required'), True, name)
elif not param:
return default
else:
return param
def get_pk(self, throw):
pk = self.get_int(self.pk_name)
if not pk and throw:
logger.warning('item not entered for %s : %s' %
(self.target, self.pk_name))
self.error(_('invalid item selected'), True, self.pk_name)
elif pk:
return pk
return 0
def get_date(self, name, throw=False, only_date=False):
"""
Parse Persian Input Date in to Julian Standard datetime to save in DB
:param only_date: only get the date object if found
:param name: name of the param to read
:param throw: raise error if param not validated
:return: datetime
"""
res = parse_date_from_str(self.store.get(name))
if not res and throw:
logger.warning('item not entered for %s : datetime %s' %
(self.target, name))
self.error(_('no date selected'), True, name)
elif res and only_date:
return res.date()
return res
def get_uid(self, name, throw, default=None):
param = get_uuid(self.store.get(name))
if not param and throw:
logger.warning('item not entered for %s : uid %s' %
(self.target, name))
self.error(_('invalid item selected'), True, name)
elif param:
return param
return default
def get_bool(self,
name,
throw=False,
default=False,
true_value='1',
only_contains=False):
"""
Get Bool value
:param name: name of parameter to find
:param throw: raise error if not found
:param default: default value if not found
:param true_value: match with this value to detect is condition true or not
:param only_contains: just if the 'name' is exists.
:return: bool
"""
exist = name in self.store
value = self.store.get(name)
if only_contains and exist:
return True
elif only_contains and not exist:
if throw:
self.error(_('this item is required'), True, name)
else:
return default
elif not only_contains and value == true_value:
return True
elif throw:
logger.warning('item not entered for %s : bool %s' %
(self.target, name))
self.error(_('this item is required'), True, name)
return default
def has_perm(self, perm):
if perm is None:
return False
return self.requester.has_perm(perm)
def get_single_dict(self, is_pk=False, dump=True, other_field=()):
if is_pk:
ob = self.get_single_pk(True)
else:
ob = self.get_single_ext(True)
res = {}
new_f = other_field or self.fields
for f in new_f:
res.update({f: getattr(ob, f)})
if dump:
return json.dumps(res, default=date_handler)
return res
def get_time(self, name, throw, default=None):
nx = self.get_str(name, throw)
res = get_time_str(nx, True)
if res.is_success():
return res.value()
elif throw:
self.error(_('selected time is not valid'), True, name)
else:
return default
def get_all(self):
sort = get_full_sort(self.req.GET, self.fields)
x = self.search().values(*self.fields).order_by(sort)
return get_paginate(x, self.req.GET.get('current'),
self.req.GET.get('rowCount'))
