def post(self, request, *args, **kwargs):
import applications.user.models
serializer = self.get_serializer(data=request.data)
try:
is_valid = serializer.is_valid()
except applications.user.models.UserModel.DoesNotExist:
raise rest.NotAuthenticated
if is_valid:
user, token = (serializer.object.get('user')
or request.user), serializer.object.get('token')
return rest.Response((token, user, request))
return rest.Response(detail='会话已过期', status=rest.HTTP_401_UNAUTHORIZED)
def retrieve(self, request, *args, **kwargs):
if not request.user.department_id: raise rest.PermissionDenied
instance = self.queryset.filter(
date__exact=kwargs.get('pk'),
department_id__exact=request.user.department_id).first()
if not instance:
return rest.Response(
data={
'id': None,
'submitter':
f'{request.user.get_full_name()} ({request.user.username})',
'content': '',
})
serializer = self.get_serializer(instance)
return rest.Response(data=serializer.data)
def create(self, request, *args, **kwargs):
title, protype, organizer_id, status = '假期请休申请', ProcessModel.T4, request.user.id, ProcessModel.OPEN
at_leader = '"' + str(request.user.department.usermodel_set.all().filter(work_management__exact=True).first().id) + '"'
(starttime, _s), (endtime, _e) = (
self.get_time(request.data.get('startDate'), request.data.get('startTime')),
self.get_time(request.data.get('endDate'), request.data.get('endTime')),
)
if starttime > endtime: raise rest.ParseError(detail='时间区间不合法')
n = (_e - _s).days
if request.data.get('startTime') == '1' and request.data.get('endTime') == '3':
n += .5
else:
n += 1
demand = request.data.get('demand') + f'\n\n系统数据：\n 请休假期时间为 {starttime} 至 {endtime}，共计 {n} 天。'
if request.data.get('holiday') == '1':
if request.user.paid_leave < n: raise rest.ParseError(detail='申请不通过，剩余年假小于请休时间。')
demand += f'\n 当前申请者剩余年休假为 {request.user.paid_leave} 天'
_ = ProcessModel.objects.create(
title=title,
organizer_id=organizer_id,
at_leader=at_leader,
demand=demand,
status=status,
protype=protype,
)
return rest.Response(data=dict(
id=_.id,
title=title,
organizer_id=organizer_id,
at_leader=at_leader,
demand=demand,
status=status,
protype=protype
))
def get(self, request, *args, **kwargs):
return rest.Response(
overview=overview(),
overview_detail=overview_detail(),
useractive=useractive(),
attendance=attendance(),
)
def put(self, request, *args, **kwargs):
data, index = request.data, 0
try:
workplace = json.loads(data.get('workplace', '{}'))
except json.decoder.JSONDecodeError:
raise rest.ParseError(detail='工位录入数据无法解析')
if not isinstance(workplace, dict):
raise rest.ParseError(detail='工位录入数据无法解析')
www = dict()
for key, value in workplace.items():
if not isinstance(value, list):
raise rest.ParseError(detail='工位录入数据无法解析')
children = dict()
for i, v in enumerate(value):
if not isinstance(v, (str, int)):
raise rest.ParseError(detail='工位录入数据无法解析')
children[str(i)] = {'code': f'{index}{i}', 'name': str(v)}
www[str(index)] = {
'code': str(index),
'name': key,
'children': children,
}
index += 1
try:
password = rsa_decrypt(data.get('system-email-pwd'))
except (ValueError, AttributeError):
raise rest.ParseError(detail='密码无法验证')
file = open(os.path.join(BASE_DIR, 'conf', 'conf.json'),
'r',
encoding='UTF-8')
info = file.read()
file.close()
jinfo = json.loads(info)
file = open(os.path.join(BASE_DIR, 'conf', 'conf.json'),
'w',
encoding='UTF-8')
file2 = open(os.path.join(BASE_DIR, 'applications', 'user',
'workplace.json'),
'w',
encoding='UTF-8')
if password == 'HiddenPassword':
jinfo.update({
'email-address': data.get('email-address'),
'system-email': data.get('system-email')
})
else:
jinfo.update({
'email-address': data.get('email-address'),
'system-email': data.get('system-email'),
'system-email-pwd': password,
})
file.write(json.dumps(jinfo))
file2.write(json.dumps(www))
file.close()
file2.close()
return rest.Response(
data={
'email-address': data.get('email-address'),
'system-email': data.get('system-email')
})
def create(self, request, *args, **kwargs):
file, name, type_, fields, alias, regex = (
request.FILES.get('file'), str(uuid1()).replace('-', ''),
request.data.get('type'), request.data.get('fields'),
request.data.get('alias'), request.data.get('regex'),
)
if file:
try:
fields = ujson.loads(fields)
except ValueError:
raise rest.ParseError(detail='字段映射错误')
if not isinstance(fields, dict): raise rest.ParseError(detail='字段映射错误')
f = open(os.path.join(BASE_DIR, 'applications', 'tools', 'tf', f'M{name}.py'), 'w', encoding='UTF-8')
while text := file.read(10240):
f.write(text.decode().replace('\r\n', '\n'))
f.close()
file.close()
tools = cache.get(NAME, {})
tools[f'{request.user.id}{name}'] = {
'timeout': time.time(),
'name': name,
'type': type_,
'stat': True,
'fields': fields,
'alias': alias,
'regex': regex,
}
cache.set(NAME, tools, timeout=CACHE_TIMEOUT)
return rest.Response(status=200)
def update(self, request, *args, **kwargs):
serializer = UserBatchSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
queryset = self.verify()
queryset.update(is_active=serializer.data.get('is_active'))
if serializer.initial_data.get('is_active') is False:
queryset.update(user_secret=uuid.uuid4())
return rest.Response()
def list(self, request, *args, **kwargs):
with open(
os.path.join(settings.BASE_DIR, 'applications', 'user',
'public.pem')) as file:
pub = file.read()
file.close()
if not pub: raise rest.ParseError(detail='获取密钥信息失败')
return rest.Response(data=pub)
def create(self, request, *args, **kwargs):
# TODO 省略数据校验
ProcessModel.objects.create(
title='考勤异常申请',
organizer=request.user,
at_leader='"' + str(request.user.department.usermodel_set.all().filter(work_management__exact=True).first().id) + '"',
demand=f'{request.data.get("demand")} ({self.demo()[int(request.data.get("time"))]["description"]})',
status=ProcessModel.OPEN,
protype=ProcessModel.T2,
)
return rest.Response(data={'demand': request.data.get("demand"), 'time': request.data.get("time")}, status=rest.HTTP_201_CREATED)
def put(self, request, *args, **kwargs):
serializer = PersonalSettingSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = request.user
user.email = serializer.data.get('email')
user.phone = serializer.data.get('phone')
user.last_name = serializer.data.get('full_name')
user.first_name = ''
user.workplace = f'{serializer.data.get("workplace")}/{serializer.data.get("jobnumber")}'
user.save()
return rest.Response(data=request.data)
def destroy(self, request, *args, **kwargs):
pks = list(set(kwargs.get('pk').split(',')))
if '' in pks: pks.remove('')
if ' ' in pks: pks.remove(' ')
try:
queryset = self.queryset.filter(id__in=pks)
except ValueError:
raise rest.ParseError(detail='包含无法解析的数据')
if queryset.count() != len(pks):
raise rest.ParseError(detail='包含无法解析的数据')
queryset.update(status=ProcessModel.CLOSE)
return rest.Response()
def create(self, request, *args, **kwargs):
data = dict(
title=html.escape(request.data.get('title', '')),
content=html.escape(request.data.get('content', '')),
author=request.user.id,
)
serializer = self.get_serializer(data=data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return rest.Response(data=serializer.data,
status=rest.HTTP_201_CREATED,
headers=headers)
def create(self, request, *args, **kwargs):
date = datetime.now().strftime('%Y-%m-%d')
if self.queryset.filter(person_id__exact=request.user.id,
date__year=date.split('-')[0],
date__month=date.split('-')[1],
date__day=date.split('-')[2]):
raise rest.ParseError(detail='无法重复创建日报内容')
data = {
'person_id': request.user.id,
'content': html.escape(str(request.data.get('content', '')))
}
ReportModel.objects.create(**data)
return rest.Response(data=data, status=rest.HTTP_201_CREATED)
def update(self, request, *args, **kwargs):
partial = kwargs.pop('partial', False)
instance = self.get_object()
if not isinstance(request.data.get('role'), list):
raise rest.ParseError(detail='规则参数格式错误')
serializer = RoleSerializerU(
instance,
data={'role': format_role(request.data.get('role'))},
partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
if getattr(instance, '_prefetched_objects_cache', None):
instance._prefetched_objects_cache = {}
return rest.Response(data=serializer.data)
def retrieve(self, request, *args, **kwargs):
date = kwargs.get('pk')
if not re.match(r'\d{4}-\d{2}-\d{2}', date):
raise rest.ParseError(detail='时间格式错误，如 "2020-10-01" 格式')
queryset = self.queryset.filter(date__year=date.split('-')[0],
date__month=date.split('-')[1],
date__day=date.split('-')[2],
person_id__exact=request.user.id)
if not queryset:
return rest.Response(
data={
'id': None,
'person':
f'{request.user.get_full_name()} ({request.user.username})',
'content': ''
})
return rest.Response(
data={
'id': queryset.first().id,
'person':
f'{request.user.get_full_name()} ({request.user.username})',
'content': queryset.first().content
})
def create(self, request, *args, **kwargs):
data = {
'title': request.data.get('title'),
'content': request.data.get('content'),
'draft': True,
'author': request.user.id,
}
serializer = DraftSerializerC(data=data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return rest.Response(data=serializer.data,
status=rest.HTTP_201_CREATED,
headers=headers)
def get(self, request, *args, **kwargs):
instance = request.user
a, b = instance.get_workplace()
return rest.Response(
data={
'email': instance.email,
'username': instance.username,
'full_name': instance.get_full_name(),
'workplace_a': a if a else '',
'workplace_b': a + b if a and b else '',
'phone': instance.phone,
'paid_leave': instance.paid_leave,
},
workplace=get_workplace(),
)
def update(self, request, *args, **kwargs):
if instance := self.queryset.filter(
id__exact=kwargs.get('pk'),
at_leader__regex=f'"{self.request.user.id}"').first():
if instance.status not in [ProcessModel.OPEN, ProcessModel.DENY]:
raise rest.NotFound
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
status, review, delindex = serializer.data.get(
'status'), serializer.data.get('addreview'), sorted(
list(set(serializer.data.get('delhistory'))), reverse=True)
if delindex == ['']: delindex = list()
content = json.loads(instance.content)
if delindex:
if not all(x.isdigit() for x in delindex):
raise rest.ParseError(detail='删除历史审批参数中包含不能识别的数据')
if int(delindex[-1]) < 0:
raise rest.ParseError(detail='删除历史审批参数中包含不能识别的数据')
for i in delindex:
try:
if str(content[int(i)][0]) == str(request.user.id):
content.pop(int(i))
except IndexError:
...
if review:
content.append([request.user.id, status, html.escape(review)])
instance.content = json.dumps(content)
instance.save()
update_instance = self.queryset.filter(
id__exact=kwargs.get('pk')).first()
state_ids = {
i[0]: i[1]
for i in json.loads(update_instance.content)
}
at_leader = re.findall(r'"(\d+)"', update_instance.at_leader)
if len(set(at_leader)) == len(state_ids):
if list(set(state_ids.values())) == ['ok']:
update_instance.status = ProcessModel.APPROVE
else:
update_instance.status = ProcessModel.DENY
update_instance.save()
return rest.Response(data={
'status': status,
'addreview': review,
'delhistory': delindex
})
def get(self, request, *args, **kwargs):
file = open(os.path.join(BASE_DIR, 'conf', 'conf.json'),
'r',
encoding='UTF-8')
info = file.read()
file.close()
jinfo = json.loads(info)
workplace = {
i['name']: [i2['name'] for i2 in i['children']]
for i in get_workplace()
}
return rest.Response(
data={
'email-address': jinfo.get('email-address'),
'system-email': jinfo.get('system-email'),
'workplace': json.dumps(
workplace, indent=4, ensure_ascii=False)
})
def update(self, request, *args, **kwargs):
type_, regex, fields, name = request.data.get('type'), request.data.get('regex'), request.data.get('fields'), kwargs.get('pk')
tools = cache.get(NAME, {})
tool = tools.get(f'{request.user.id}{name}')
if not tool: raise rest.NotFound
try:
fields = ujson.loads(fields)
except ValueError:
raise rest.ParseError(detail='字段映射错误')
if not isinstance(fields, dict): raise rest.ParseError(detail='字段映射错误')
tool.update({
'timeout': time.time(),
'type': type_,
'fields': fields,
'regex': regex,
})
tools[f'{request.user.id}{name}'] = tool
cache.set(NAME, tools, timeout=CACHE_TIMEOUT)
return rest.Response(data={'type': type_, 'fields': fields, 'regex': regex})
def create(self, request, *args, **kwargs):
if not request.user.department_id: raise rest.PermissionDenied
data = {
'person': request.user.id,
'content': request.data.get('content'),
'date': request.data.get('date'),
'department': request.user.department_id,
}
if not re.search(r'^20\d\d(0[1-9]|1[0-2])$', data.get('date')):
raise rest.ParseError(detail='填报日期格式错误')
if self.queryset.filter(date__exact=data.get('date'),
department_id__exact=data.get('department')):
raise rest.ParseError(detail='无法重复创建月报内容')
serializer = self.get_serializer(data=data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return rest.Response(data=serializer.data,
status=rest.HTTP_201_CREATED,
headers=headers)
def create(self, request, *args, **kwargs):
data = request.data
if hasattr(data, '_mutable'): data._mutable = True
if data.get('at_leader'):
data.update({
'status': ProcessModel.OPEN,
'organizer': request.user.id
})
else:
data.update({
'status': ProcessModel.UNASSIGNED,
'organizer': request.user.id
})
serializer = self.get_serializer(data=data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return rest.Response(data=serializer.data,
status=rest.HTTP_201_CREATED,
headers=headers)
def post(self, request, *args, **kwargs):
username, password = request.data.get('username'), request.data.get(
'password')
queryset = UserModel.objects.filter(username__exact=username)
if not queryset: raise rest.ParseError(detail='账号或密码错误')
try:
password = rsa_decrypt(password)
except (ValueError, AttributeError):
raise rest.ParseError(detail='账号或密码错误')
serializer = self.get_serializer(data={
'username': username,
'password': password
})
if serializer.is_valid():
token = serializer.object.get('token')
user = serializer.object.get('user') if isinstance(
request.user, AnonymousUser) else request.user
if not user: user = serializer.object.get('username')
return rest.Response(
data=jwt_response_payload_handler(token, user, request))
raise rest.ParseError(detail='账号或密码错误')
def create(self, request, *args, **kwargs):
name, leader = request.data.get('name'), request.data.get('leader')
if not name: raise rest.ParseError(detail='名称字段是必须的')
if self.queryset.filter(name__exact=name):
raise rest.ParseError(detail='部门已存在')
user = None
if leader:
if not str(leader).isdigit():
raise rest.ParseError(detail='部门负责人不合法')
user = UserModel.objects.filter(id__exact=leader)
if not user: raise rest.ParseError(detail='部门负责人不存在')
obj = self.queryset.create(name=name)
if user:
user.update(department_id=obj.id,
work_management=True,
head_of_department=True)
return rest.Response(status=rest.HTTP_201_CREATED,
data={
'name': name,
'leader': leader
})
def put(self, request, *args, **kwargs):
try:
old, new, again = (rsa_decrypt(request.data.get('old')),
rsa_decrypt(request.data.get('new')),
rsa_decrypt(request.data.get('again')))
except (ValueError, AttributeError):
raise rest.ParseError(detail='原密码错误')
if not check_password(old, request.user.password):
raise rest.ParseError(detail='原密码错误')
serializer = self.serializer_class(data={
'old': old,
'new': new,
'again': again
})
if serializer.is_valid():
if new != again: raise rest.ParseError(detail='两次输入的密码不一致')
user = request.user
user.user_secret = uuid.uuid4()
user.password = make_password(new)
user.save()
return rest.Response(detail='密码修改成功，请重新登录')
raise rest.ParseError(detail='会话已过期')
def retrieve(self, request, *args, **kwargs):
timeout, tools, limit, page = (
time.time(),
cache.get(NAME, {}),
request.query_params.get('limit', '20'),
request.query_params.get('page', '1'),
)
tool = tools.get(f'{request.user.id}{kwargs.get("pk")}')
if not limit.isdigit() or not page.isdigit(): raise rest.ParseError(detail='分页参数错误')
limit, page = int(limit), int(page)
if limit < 0 or limit > 100 or page < 1: raise rest.ParseError(detail='分页参数错误')
if not tool: raise rest.NotFound
if timeout - tool['timeout'] >= CACHE_TIMEOUT:
try:
os.remove(os.path.join(BASE_DIR, 'applications', 'tools', 'tf', f'M{tool["name"]}'))
tools.pop(f'{request.user.id}{kwargs.get("pk")}')
cache.set(NAME, tools, timeout=CACHE_TIMEOUT)
except (Exception,):
pass
raise rest.NotFound
data, count = analyze_engine(tool, limit, page, tool['fields'], tool['regex'])
return rest.Response(data=data, count=count)
def list(self, request, *args, **kwargs):
data = list()
now = datetime.now()
for i in range(1, 51):
date = (now + timedelta(days=-i))
if date.isoweekday() > 5:
from_ = to = None
else:
from_ = date.replace(hour=8, minute=randint(1, 59), second=randint(1, 59)).strftime("%Y-%m-%d %H:%M:%S")
to = date.replace(hour=16, minute=randint(1, 59), second=randint(1, 59)).strftime("%Y-%m-%d %H:%M:%S")
data.append({
'id': i,
'date': date.strftime("%Y-%m-%d"),
'from': from_,
'to': to,
'status': 0,
'account': 'admin',
'fullname': 'Medusa Sorcerer'
})
limit, page = int(request.query_params.get('limit')), int(request.query_params.get('page'))
a, b = (page - 1) * limit, page * limit
return rest.Response(data=data[a:b], count=len(data))
def list(self, request, *args, **kwargs):
data, timeout, tools, d = [], time.time(), cache.get(NAME, {}), []
for k, v in tools.items():
if timeout - v['timeout'] <= CACHE_TIMEOUT and k.startswith(str(request.user.id)):
fields = {str(k): str(v) for k, v in v['fields'].items()}
fields['__all__'] = '原数据'
data.append({
'id': v['name'],
'fields': fields,
'name': v['alias'],
'type': v['type'],
'regex': v['regex'],
})
else:
try:
d.append(f'{request.user.id}{v["name"]}')
os.remove(os.path.join(BASE_DIR, 'applications', 'tools', 'tf', f'M{v["name"]}'))
except (Exception,):
pass
if d: [tools.pop(i, '') for i in d]
cache.set(NAME, tools, timeout=CACHE_TIMEOUT)
return rest.Response(data=data)
def get(self, request, *args, **kwargs):
return rest.Response(data={'username': request.user.username})
def retrieve(self, request, *args, **kwargs):
queryset = self.queryset.filter(
subject_id__exact=kwargs.get('pk')).order_by('-create')
serializer = self.get_serializer(queryset, many=True)
return rest.Response(data=serializer.data)
