def get(self):
username = current_identity.to_dict()['username']
# parser = reqparse.RequestParser()
# parser.add_argument('incident_status', type=int)
# args = parser.parse_args()
print(username)
u_auth = UserAuth().getUserAuth(username)
conditions = []
if (u_auth != 'adminAll'):
conditions.append(IncidentModel.create_name == username)
results = IncidentModel.query.filter(*conditions). \
join(ProcessModel,IncidentModel.incident_id==ProcessModel.incident_id).\
filter(or_(ProcessModel.process_status == 1,ProcessModel.process_status == 2,ProcessModel.process_status == 3,and_(ProcessModel.process_status == 4, ProcessModel.pos_process_id == None))).\
join(ProgramModel, ProgramModel.order_number==IncidentModel.order_number).\
join(ProjectModel, ProjectModel.id==ProgramModel.pro_id).\
with_entities(ProgramModel.pro_name, ProgramModel.pro_id,\
IncidentModel.incident_status,\
IncidentModel.incident_id, IncidentModel.create_name, ProgramModel.order_number,
ProcessModel.process_id,
ProcessModel.process_owner,
IncidentModel.create_at, ProjectModel.finish_time, ProcessModel.start_time_d, ProcessModel.end_time_d, ProcessModel.process_name,ProcessModel.process_status, ProcessModel.experimenter).all()
response_data = [
dict(zip(result.keys(), result)) for result in results
]
for entity in response_data:
entity['start_time_d'] = datetime.datetime.strftime(
entity['start_time_d'], '%Y-%m-%d %H:%M:%S')
entity['end_time_d'] = datetime.datetime.strftime(
entity['end_time_d'], '%Y-%m-%d %H:%M:%S')
entity['create_at'] = datetime.datetime.strftime(
entity['create_at'], '%Y-%m-%d %H:%M:%S')
return {'data': response_data}
def overviewIncidentStatus():
username = current_identity.to_dict()['username']
u_auth = UserAuth().getUserAuth(username)
if u_auth != 'adminAll':
allIncident = IncidentModel.query.filter(
IncidentModel.create_name == username).count()
finishIncident = IncidentModel.query.filter(
IncidentModel.create_name == username).filter(
IncidentModel.incident_status == 2).count()
unprocessIncident = IncidentModel.query.filter(
IncidentModel.create_name == username).filter(
IncidentModel.incident_status == 0).count()
processIncident = IncidentModel.query.filter(
IncidentModel.create_name == username).filter(
IncidentModel.incident_status == 1).count()
else:
allIncident = IncidentModel.query.count()
finishIncident = IncidentModel.query.filter(
IncidentModel.incident_status == 2).count()
unprocessIncident = IncidentModel.query.filter(
IncidentModel.incident_status == 0).count()
processIncident = IncidentModel.query.filter(
IncidentModel.incident_status == 1).count()
data = {
"allIncident": allIncident,
"finishIncident": finishIncident,
"processIncident": processIncident,
"unprocessIncident": unprocessIncident
}
return data
def get(self, pro_name):
username = current_identity.to_dict()['username']
print(username)
project = ProjectModel.query.filter_by(pro_name=pro_name).first()
if project:
return project.to_dict()
return NotFound.message, NotFound.code
def get(self):
username = current_identity.to_dict()['username']
conditions = []
u_auth = UserAuth().getUserAuth(username)
if(u_auth != 'adminAll'):
conditions.append(InstoreModel.create_name == username)
results = InstoreModel.query.filter(*conditions).join(ProgramModel,InstoreModel.order_number == ProgramModel.order_number).\
with_entities(InstoreModel.id,InstoreModel.is_num,InstoreModel.is_status,InstoreModel.is_type,InstoreModel.location,InstoreModel.order_number,InstoreModel.in_store_num,InstoreModel.check_name,InstoreModel.check_time,InstoreModel.check_form_id,ProgramModel.pro_name,InstoreModel.in_date,InstoreModel.store_name,ProgramModel.task_name_book).order_by(InstoreModel.in_date.desc()).all()
response_data = [dict(zip(result.keys(), result)) for result in results]
return {'data': response_data}
def get(self):
username = current_identity.to_dict()['username']
u_auth = UserAuth().getUserAuth(username)
conditions = []
if (u_auth != 'adminAll'):
conditions.append(OutstoreModel.create_name == username)
results = OutstoreModel.query.filter(*conditions).join(ProgramModel,OutstoreModel.order_number == ProgramModel.order_number).\
with_entities(OutstoreModel.id,OutstoreModel.is_num,OutstoreModel.is_type,OutstoreModel.order_number,ProgramModel.pro_name,OutstoreModel.out_date,OutstoreModel.out_name).order_by(OutstoreModel.out_date.desc()).all()
response_data = [
dict(zip(result.keys(), result)) for result in results
]
return {'data': response_data}
def get(self):
conditions = []
username = current_identity.to_dict()['username']
u_auth = UserAuth().getUserAuth(username)
print(u_auth)
if (u_auth != 'adminAll'):
conditions.append(ProjectModel.create_name == username)
projects = [
project.to_dict() for project in ProjectModel.query.filter(
*conditions).order_by(ProjectModel.create_time.desc()).all()
]
return {'data': projects}
def get(self):
username = current_identity.to_dict()['username']
u_auth = UserAuth().getUserAuth(username)
print(u_auth)
if (u_auth != 'adminAll'):
sql = 'SELECT * FROM PROGRAM_VIEW WHERE RES_NAME = (:USER) ORDER BY create_time DESC'
else:
sql = 'SELECT * FROM PROGRAM_VIEW ORDER BY create_time DESC'
data = db.session.execute(sql, {"USER": username}).fetchall()
results = [dict(zip(result.keys(), result)) for result in data]
# print(results)
str = json.dumps(results, cls=DateEncoder)
result = json.loads(str)
return {'data': result}
def get(self):
username = current_identity.to_dict()['username']
messages = MessageModel.query.filter(
MessageModel.recipient_name == username).join(
MessagetxtModel, MessagetxtModel.message_type ==
MessageModel.message_type).with_entities(
MessageModel.message_id, MessageModel.recipient_name,
MessagetxtModel.message_notes, MessageModel.message_satus,
MessageModel.create_name, MessageModel.create_at).all()
response_data = [
dict(zip(result.keys(), result)) for result in messages
]
count = len(response_data)
str = json.dumps(response_data, cls=DateEncoder)
result = json.loads(str)
return {'data': result, 'count': count}
def get(self):
username = current_identity.to_dict()['username']
conditions = []
u_auth = UserAuth().getUserAuth(username)
print(u_auth)
parser = reqparse.RequestParser()
parser.add_argument('role_type')
args = parser.parse_args()
role_type = args['role_type']
if (u_auth != 'adminAll'):
if role_type == 'process_owner':
conditions.append(ProcessModel.process_owner == username)
if role_type == "experimenter":
conditions.append(ProcessModel.experimenter == username)
results = ProcessModel.query.filter(*conditions).filter(ProcessModel.process_status != 0).join(IncidentModel, IncidentModel.incident_id==ProcessModel.incident_id). \
join(ProgramModel, ProgramModel.order_number==IncidentModel.order_number).\
join(ProjectModel, ProjectModel.id==ProgramModel.pro_id).\
with_entities(ProgramModel.pro_name, ProgramModel.pro_id,
ProjectModel.finish_time,
IncidentModel.incident_id, IncidentModel.create_name,IncidentModel.order_number, IncidentModel.experi_project, IncidentModel.experi_type,
ProcessModel.process_id, ProcessModel.process_name, ProcessModel.start_time_d, ProcessModel.end_time_d, ProcessModel.process_name,ProcessModel.process_status, ProcessModel.experimenter).all()
#incidents = [incident.to_dict() for incident in IncidentModel.query.filter_by(IncidentModel.process_status==args['process_status']).all()]
#print(results)
if role_type == "experimenter":
if u_auth != 'adminAll':
sql = 'SELECT * FROM SUB_PROCESS_VIEW WHERE experimenter = (:USER) '
else:
sql = 'SELECT * FROM SUB_PROCESS_VIEW'
results = db.session.execute(sql, {"USER": username}).fetchall()
response_data = [
dict(zip(result.keys(), result)) for result in results
]
for entity in response_data:
entity['start_time_d'] = datetime.datetime.strftime(
entity['start_time_d'], '%Y-%m-%d %H:%M:%S')
entity['end_time_d'] = datetime.datetime.strftime(
entity['end_time_d'], '%Y-%m-%d %H:%M:%S')
return {'data': response_data}
def post(self):
# print(json.load(request.json))
username = current_identity.to_dict()['username']
program = ProgramModel()
program = program.from_dict(request.json)
program.create_name = username
try:
db.session.add(program)
# db.session.commit()
db.session.commit()
except IntegrityError as e:
print(e)
return NotUnique.message, NotUnique.code
except SQLAlchemyError as e:
print(e)
return DBError.message, DBError.code
return Success.message, Success.code
def edit_account():
profile_pic = request.files.get('profile_pic')
user_details = dictify_form(request.form)
password = user_details.pop('password', None)
if username_taken(current_identity, user_details.get('username')):
response = jsonify({'error': 'Username already taken'})
response.status_code = 400
return response
if password:
current_identity.update_password(password)
if profile_pic:
user_details['profile_pic_url'] = upload_image(profile_pic)
current_identity.update(user_details).save()
return jsonify(current_identity.to_dict())
def getProjects():
username = current_identity.to_dict()['username']
u_auth = UserAuth().getUserAuth(username)
print(u_auth)
if (u_auth != 'adminAll'):
sql = 'select * from PROGRAM_VIEW where order_number is null and res_name = (:username)'
else:
sql = 'select * from PROGRAM_VIEW where order_number is null'
data = db.session.execute(sql, {"username": username}).fetchall()
results = [dict(zip(result.keys(), result)) for result in data]
#projects = [data.to_dict() for data in ProjectModel.query.filter_by(res_name=username).all()]
data = []
obj = {}
for r in results:
obj = {}
obj['key'] = r['project_id']
obj['value'] = r['project_name']
data.append(obj)
return {'data': data}
def post(self):
username = current_identity.to_dict()['username']
# print(json.load(request.json))
Outstore = OutstoreModel()
Outstore = Outstore.from_dict(request.json)
Outstore.create_name = username
try:
db.session.add(Outstore)
#db.session.commit()
db.session.commit()
except IntegrityError as e:
print(e)
return NotUnique.message, NotUnique.code
except SQLAlchemyError as e:
print(e)
return DBError.message, DBError.code
#新建入库申请
# data = db.session.query(ProgramModel.create_name).join(OutstoreModel,OutstoreModel.order_number == ProgramModel.order_number).first()
# data = dict(zip(data.keys(), data))
# MessageList().newMeassge(0,Outstore.create_name,data['create_name'])
return Outstore.id, Success.code
def confirmStore():
username = current_identity.to_dict()['username']
value = {}
value['order_number'] = request.json['order_number']
value['id'] = request.json['id']
#value['is_num'] = request.json['is_num'] 不改变入库数量
value['is_status'] = request.json['status'] #审核状态
value['check_name'] = request.json['check_name']
value['check_time'] = request.json['check_time']
if value['is_status'] == 1: #申请入库成功
value['sign_check_form_id'] = request.json['sign_check_form_id']
try:
InstoreModel.query.filter_by(order_number=request.json['order_number'], id=request.json['id']).update(value)
#db.session.commit()
db.session.commit()
except IntegrityError as e:
print(e)
return NotUnique.message, NotUnique.code
except SQLAlchemyError as e:
print(e)
return DBError.message, DBError.code
#new a 入库申请通过/驳回
data = db.session.query(InstoreModel.create_name).filter_by(order_number=request.json['order_number'], id=request.json['id']).first()
data = dict(zip(data.keys(), data))
if value['is_status'] == 1:
MessageList().newMeassge(5,username,data['create_name'])
elif value['is_status'] == 2:
MessageList().newMeassge(6,username,data['create_name'])
return 'Update %s store successfully' % request.json['order_number']
def get(self):
username = current_identity.to_dict()['username']
u_auth = UserAuth().getUserAuth(username)
parser = reqparse.RequestParser()
parser.add_argument('process_id', type=int)
parser.add_argument('process_status', type=int)
parser.add_argument('role_type')
args = parser.parse_args()
print(args)
response_data = {}
conditions = []
role_type = args['role_type']
if role_type == 'process_owner' and u_auth != 'adminAll':
conditions.append(ComponentModel.process_owner == username)
if role_type == "experimenter":
conditions.append(ComponentModel.experimenter == username)
print(args['process_status'])
# 1. Get current process
dis_process = ProcessModel.query.filter(ProcessModel.process_id == args['process_id']) \
.join(IncidentModel, IncidentModel.incident_id == ProcessModel.incident_id) \
.join(ProgramModel, ProgramModel.order_number == IncidentModel.order_number) \
.join(ProjectModel, ProjectModel.id == ProgramModel.pro_id) \
.with_entities(ProgramModel.pro_name, ProgramModel.pro_id, ProgramModel.order_number, ProgramModel.task_id, ProgramModel.program_id,
ProjectModel.finish_time,
IncidentModel.incident_id, IncidentModel.create_name, IncidentModel.experi_type,
ProcessModel.process_id, ProcessModel.process_name,
ProcessModel.start_time_d, ProcessModel.end_time_d,
ProcessModel.process_name, ProcessModel.process_status, ProcessModel.experimenter, ProcessModel.process_owner, ProcessModel.experiment_sheet_id).all()
response_data = [
dict(zip(result.keys(), result)) for result in dis_process
]
for entity in response_data:
entity['start_time_d'] = datetime.datetime.strftime(
entity['start_time_d'], '%Y-%m-%d %H:%M:%S')
entity['end_time_d'] = datetime.datetime.strftime(
entity['end_time_d'], '%Y-%m-%d %H:%M:%S')
response_data = response_data[0]
# 2 Get group process under the same incident
group_incident_id = response_data['incident_id']
group_processes = ProcessModel.query.filter(
ProcessModel.incident_id == group_incident_id).order_by(
ProcessModel.step_number).all()
co_workers = set()
group_processes_names = []
for g_p in group_processes:
co_workers.add(g_p.process_owner)
processObj = {}
processObj['process_name'] = g_p.process_name
processObj['process_id'] = g_p.process_id
processObj['process_owner'] = g_p.process_owner
group_processes_names.append(processObj)
response_data["co_experimenter"] = list(co_workers)
response_data["processes"] = group_processes_names
# 3 get group Components
if response_data['process_status'] == 4: #当前工序已经完成，读历史components
conditions = []
if role_type == 'process_owner' and u_auth != 'adminAll':
conditions.append(ComponentHisModel.process_owner == username)
if role_type == "experimenter":
conditions.append(ComponentHisModel.experimenter == username)
group_components = ComponentHisModel.query.filter(*conditions).filter(ComponentHisModel.incident_id == group_incident_id) \
.filter(ComponentHisModel.process_id == args['process_id']).all()
else:
group_components = ComponentModel.query.filter(*conditions).filter(ComponentModel.incident_id == group_incident_id) \
.all()
components_data = [result.to_dict() for result in group_components]
for entity in components_data:
del entity['create_at']
del entity['update_at']
#del components_data['create_at']
#del components_data['update_at']
# 4 update return data
response_data['componentlist'] = components_data
# response_data.update(components_data)
return {'data': response_data}
def get(self):
logger.debug('UserMe.get(self)')
return Response(json.dumps(current_identity.to_dict()), mimetype='application/json')
def overviewStatus():
username = current_identity.to_dict()['username']
u_auth = UserAuth().getUserAuth(username)
req_data = request.json
conditions = []
parser = reqparse.RequestParser()
parser.add_argument('role_type')
args = parser.parse_args()
role_type = args['role_type']
if role_type == 'process_owner' and u_auth != 'adminAll':
conditions.append(ProcessModel.process_owner == username)
if role_type == "experimenter" and u_auth != 'adminAll':
conditions.append(ProcessModel.experimenter == username)
print(username)
print(role_type)
if role_type == 'experimenter':
if u_auth != 'adminAll':
sql1 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW WHERE experimenter = (:USER)'
sql2 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW WHERE subProStatus = 4 AND experimenter = (:USER)'
sql3 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW WHERE experimenter = (:USER) and subProStatus = 2'
sql4 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW WHERE experimenter = (:USER) and subProStatus = 3'
sql5 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW WHERE experimenter = (:USER) and subProStatus = 1'
else:
sql1 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW'
sql2 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW WHERE subProStatus = 4'
sql3 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW WHERE subProStatus = 2'
sql4 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW WHERE subProStatus = 3'
sql5 = 'SELECT count(*) as c FROM SUB_PROCESS_VIEW WHERE subProStatus = 1'
allIncident = db.session.execute(sql1, {"USER": username}).scalar()
finishIncident = db.session.execute(sql2, {
"USER": username
}).scalar() #已完成
assginIncident = db.session.execute(sql3, {
"USER": username
}).scalar() #已分配和待领取
processIncident = db.session.execute(sql4, {
"USER": username
}).scalar() #实验中
unassginIncident = db.session.execute(sql4, {
"USER": username
}).scalar() #待分配
else:
allIncident = ProcessModel.query.filter(*conditions).count() #分配给自己的工序
finishIncident = ProcessModel.query.filter(*conditions).filter(
ProcessModel.process_status == 4).count() #已完成
assginIncident = ProcessModel.query.filter(*conditions).filter(
ProcessModel.process_status == 2).count() #已分配和待领取
processIncident = ProcessModel.query.filter(*conditions).filter(
ProcessModel.process_status == 3).count() #实验中
unassginIncident = ProcessModel.query.filter(*conditions).filter(
ProcessModel.process_status == 1).count() #待分配
data = {
"allIncident": allIncident,
"finishIncident": finishIncident,
"assginIncident": assginIncident,
"processIncident": processIncident,
"unassginIncident": unassginIncident
}
return data
def get(self):
username = current_identity.to_dict()['username']
print(username)
def post(self):
username = current_identity.to_dict()['username']
req_data = request.json
req_data['create_name'] = username
u_auth = UserAuth().getUserAuth(username)
#1. get process list and component_list
component_list = req_data['component_list']
process_list = req_data['process_list']
#2. get component list
#3. remove the process list and component_list in the orginal json
del req_data['process_list']
del req_data['component_list']
#4. insert into incident table
incident = IncidentModel()
incident = incident.from_dict(req_data)
#更改incident状态为已创建
incident.incident_status = 0
try:
db.session.add(incident)
#db.session.commit()
db.session.commit()
except IntegrityError as e:
print(e)
return NotUnique.message, NotUnique.code
except SQLAlchemyError as e:
print(e)
return DBError.message, DBError.code
#5. update insert into process table
list_l = len(process_list)
update_process_list = []
for i in range(list_l):
process_list[i]['incident_id'] = incident.incident_id
process_list[i]['experiment_owner'] = username
if process_list[i]['step_number'] == 0:
#第一个工序的状态默认为待分配
process_list[i]['process_status'] = 1
#取第一个工序负责人，并向其发消息
recipient_name = process_list[i]['process_owner']
else:
process_list[i]['process_status'] = 0
p = ProcessModel().from_dict(process_list[i])
try:
db.session.add(p)
#db.session.commit()
db.session.commit()
except IntegrityError as e:
print(e)
return NotUnique.message, NotUnique.code
except SQLAlchemyError as e:
print(e)
return DBError.message, DBError.code
update_process_list.append(p)
for i in range(list_l):
if i == list_l - 1:
update_process_list[i].pre_process_id = update_process_list[
i - 1].process_id
elif i == 0:
update_process_list[i].pos_process_id = update_process_list[
i + 1].process_id
else:
update_process_list[i].pre_process_id = update_process_list[
i - 1].process_id
update_process_list[i].pos_process_id = update_process_list[
i + 1].process_id
for i in range(list_l):
value = {}
value['process_id'] = update_process_list[i].process_id
if i == list_l - 1:
value['pre_process_id'] = update_process_list[i - 1].process_id
value['pos_process_id'] = None
elif i == 0:
value['pre_process_id'] = None
value['pos_process_id'] = update_process_list[i + 1].process_id
else:
value['pre_process_id'] = update_process_list[i - 1].process_id
value['pos_process_id'] = update_process_list[i + 1].process_id
try:
ProcessModel.query.filter(
ProcessModel.process_id == value['process_id']).update({
'pre_process_id':
value['pre_process_id'],
'pos_process_id':
value['pos_process_id']
})
#db.session.commit()
db.session.commit()
except IntegrityError as e:
print(e)
return NotUnique.message, NotUnique.code
except SQLAlchemyError as e:
print(e)
return DBError.message, DBError.code
#6. update insert into Component table
for i, _ in enumerate(component_list):
value = {}
#value['id'] = component_list[i]['id']
value['incident_id'] = incident.incident_id
value['create_at'] = datetime.datetime.strptime(
component_list[i]['create_at'].encode('utf-8'),
'%Y-%m-%d %H:%M:%S')
value['order_number'] = component_list[i]['order_number']
value['original_id'] = component_list[i]['original_id']
#value['component_status'] = component_list[i]['component_status']
#更改试验件的状态 变更为已分配
value['component_status1'] = 1
value['outstore_id'] = component_list[i]['outstore_id']
value['component_unique_id'] = component_list[i][
'component_unique_id']
##更新试验件的工序负责人和实验室负责人
value['experiment_owner'] = username
#工序负责人为第一个负责人
value['process_owner'] = recipient_name
#del component_list[i]['create_at']
#del component_list[i]['update_at']
try:
ComponentModel.query.filter(
ComponentModel.id == component_list[i]['id']).update(value)
#db.session.commit()
db.session.commit()
except IntegrityError as e:
print(e)
return NotUnique.message, NotUnique.code
except SQLAlchemyError as e:
print(e)
return DBError.message, DBError.code
#new message
MessageList().newMeassge(4, username, recipient_name)
return Success.message, Success.code
def MyInfos():
"""
Returns info on account
"""
d = current_identity.to_dict(exclude=['password'])
return json.dumps(d)
