def POST(self, name):
webData = json.loads(web.data())
action = webData["action"]
if "token" in webData:
token = webData["token"]
if checkSession(token) == False:
return packOutput({}, "401", "Tocken authority failed")
if action == "getList":
list = self.getList(webData)
num = len(list)
resultJson = {"num": num, "list": []}
for item in list:
caller = item.copy()
caller["workerLimit"] = str2List(caller["workerLimit"])
resultJson["list"].append(caller)
return packOutput(resultJson)
elif action == "getInfo":
caller = self.getInfo(webData)
caller["workerLimit"] = str2List(caller["workerLimit"])
return packOutput(caller)
elif action == "add":
webData["workerLimit"] = list2Str(webData["workerLimit"])
ret = self.add(webData)
return packOutput({})
elif action == "edit":
webData["workerLimit"] = list2Str(webData["workerLimit"])
id = self.edit(webData)
return packOutput({})
elif action == "delete":
ret = self.delete(webData)
if ret == -1:
resultJson = {"result": "failed"}
else:
resultJson = {"result": "success"}
return packOutput(resultJson)
elif action == "setWorkerStatus":
ret = self.setWorkerStatus(webData)
if ret == -1:
resultJson = {"result": "failed"}
else:
resultJson = {"result": "success"}
return packOutput(resultJson)
else:
return packOutput({}, "500", "unsupport action")
def updateWorkerLimit(self, inputData):
stationID = inputData.get("stationID", None)
if stationID is None:
raise Exception("[ERR]: stationID required")
queueID = inputData.get("queueID", None)
if queueID is None:
raise Exception("[ERR]: queueID required")
workers = inputData.get("workers")
if not isinstance(workers, list):
raise Exception("[ERR]: workers should be a list")
queueInfo = DB.DBLocal.select("queueInfo", where="stationID=$stationID AND id=$queueID",
vars={"stationID": stationID, "queueID": queueID})
if len(queueInfo) == 0:
raise Exception("[ERR]: queue not exists")
queue = queueInfo[0]
if not queue["workerLimit"]:
workerLimit = []
else:
workerLimit = str2List(queue["workerLimit"])
try:
for worker in workers:
if worker in workerLimit:
continue
else:
workerLimit.append(worker)
workerLimit_str = list2Str(workerLimit)
DB.DBLocal.update("queueInfo", where="stationID=$stationID AND id=$queueID",
vars={"stationID": stationID, "queueID": queueID},
workerLimit=workerLimit_str)
except:
raise
else:
result = {"result": "success"}
return result
def edit(self, data):
"""Interface to edit the information of a media box.
Args:
data: JSON format data. For example:
{
"token": " safe action",
"id": "12",
"speed": "50",
"volume": "50",
"pitch" : "50"
}
If the data does not have `speed`, `pitch` or `volume` field,
raise an Exception.
Returns:
Apply the settings to the media box and update the database for input data.
If success, returns JSON format data, otherwise raise an Exception.
"""
id = data.get("id", None)
if id is None:
raise Exception("[ERR]: id required.")
mediabox = DB.select("publish",
what="deviceIP",
where="id=$id",
vars={"id": id})
if len(mediabox) == 0:
raise Exception("[ERR]: mediabox not exists.")
ip = mediabox[0].deviceIP
speed = data.get("speed", 50)
pitch = data.get("pitch", 50)
volume = data.get("volume", 100)
callerLimit = data.get("callerLimit", [])
# if not speed or not pitch or not volume:
# raise Exception("[ERR]: speed, pitch, volume required.")
values = {"callerLimit": list2Str(callerLimit)}
mediaboxInfo = self.getInfo({"id": id})
if mediaboxInfo["status"] == 'online':
values.update({"speed": speed, "pitch": pitch, "volume": volume})
url = "%s/setting/%s/%s/%s" % (str(ip), str(volume), str(pitch),
str(speed))
r = requests.get(url)
try:
DB.update("publish", where="id=$id", vars={"id": id}, **values)
result = {"result": "success"}
except:
result = {"result": "failed"}
return result
def editQueueMachine(self, data):
"""编辑一个取号机的信息"""
stationID = data.get("stationID", None)
if stationID is None:
raise Exception("[ERR]: stationID required to edit queueMachine")
id = data.get("id", None)
if id is None:
raise Exception("[ERR]: id required to edit queueMachine")
queueLimit = data.get("queueLimit", None)
if queueLimit and not isinstance(queueLimit, list):
raise Exception("[ERR]: queueLimit must be a list")
supportFeature = []
for key in self.support_feature.keys():
keyword = self.feature_keywords[key]
value = data.pop(key, None)
if value:
supportFeature.append(keyword)
data.update({"supportFeature": supportFeature})
values = {}
for key, value in data.items():
if value is not None:
if key == "queueLimit":
value = list2Str(value)
if key == "supportFeature":
value = list2Str(value)
values.update({key: value})
result = {}
try:
DB.DBLocal.update("queue_machine",
where={
"stationID": stationID,
"id": id
},
**values)
except:
raise
else:
result.update({"result": "success"})
return result
def getStationSchedule(self, data):
stationID = data.get("stationID", None)
startTime = data.get("startTime", None)
endTime = data.get("endTime", None)
if not startTime or not endTime:
raise Exception("[ERR]: startTime or endTime required")
if endTime < startTime:
raise Exception("[ERR]: endTime should larger than startTime")
pageNum = data.get("pageNum", None)
pageSize = data.get("pageSize", None)
where = None
if stationID is not None and stationID != "":
where = {}
where.update({"stationID": stationID})
else:
stationList = DB.DBLocal.select("stationSet", what="id")
stationIDList = []
for item in stationList:
stationIDList.append(item["id"])
if stationIDList:
stationIDList = list2Str(stationIDList)
where = "stationID IN ({0})".format(stationIDList)
tmp = DB.DBLocal.select("queueInfo", where=where)
count = len(tmp)
if pageNum and pageSize:
if not isinstance(pageSize, int) or not isinstance(pageSize, int):
raise Exception("[ERR]: pagination parameters should be int")
queueList = DB.DBLocal.select("queueInfo", what="id", where=where,
limit=pageSize, offset=(pageNum-1)*pageSize)
else:
queueList = DB.DBLocal.select("queueInfo", what="id", where=where)
list = []
for item in queueList:
data.update({"queueID": item["id"]})
schedule = self.getQueueSchedule(data)
list.append(schedule)
result = {}
result["list"] = list
result["count"] = count
return result
def heartBeat(self, data):
"""取号机心跳请求"""
stationID = data.get("stationID", None)
if not stationID:
raise Exception("[ERR]: stationID required.")
station = DB.DBLocal.select("stationSet",
where="id=$id",
vars={"id": stationID})
if len(station) == 0:
raise Exception("[ERR]: station not exists for id %s" % stationID)
deviceIP = web.ctx.ip
queue_machine = DB.DBLocal.select("queue_machine",
where="deviceIP=$deviceIP",
vars={"deviceIP": deviceIP})
current_time = datetime.datetime.now()
values = {
"stationID": stationID,
"deviceIP": deviceIP,
"lastDateTime": current_time,
}
if len(queue_machine) == 0:
values.update({
"styleID":
1,
"supportFeature":
list2Str([value for value in self.feature_keywords.values()])
})
DB.DBLocal.insert("queue_machine", **values)
else:
if queue_machine[0]["stationID"] != stationID:
values.update({"queueLimit": ""})
DB.DBLocal.update("queue_machine",
where="deviceIP=$deviceIP",
vars={"deviceIP": deviceIP},
**values)
Date = current_time.date().strftime("%Y-%m-%d")
time = current_time.time().strftime("%H:%M:%S")
result = {"Date": Date, "time": time}
return result
def changeWorkerLimit(self, inputData):
stationID = inputData.get("stationID", None)
if stationID is None:
raise Exception("[ERR]: stationID required")
queueID = inputData.get("queueID", None)
if queueID is None:
raise Exception("[ERR]: queueID required")
workers = inputData.get("workers")
if not isinstance(workers, list):
raise Exception("[ERR]: workers should be a list")
queueInfo = DB.DBLocal.select("queueInfo", where="stationID=$stationID AND id=$queueID",
vars={"stationID": stationID, "queueID": queueID})
if len(queueInfo) == 0:
raise Exception("[ERR]: queue not exists")
try:
workerLimit = list2Str(workers)
DB.DBLocal.update("queueInfo", where="stationID=$stationID AND id=$queueID",
vars={"stationID": stationID, "queueID": queueID},
workerLimit=workerLimit)
except:
raise
else:
result = {"result": "success"}
return result
def addVisitor(self, inputData):
stationID = inputData.get("stationID", None)
queueID = inputData.get("queueID", None)
name = inputData.get("name", None)
snumber = inputData.get("snumber", None)
VIP = inputData.get("VIP", None)
descText = inputData.get("descText", None)
cardID = inputData.get("cardID", None)
if not all((stationID, queueID, name, snumber, descText,
cardID)) or VIP is None:
raise Exception("[ERR] parameter required.")
age = inputData.get("orderType", None)
orderType = inputData.get("orderType", 0)
personID = inputData.get("personID", None)
phone = inputData.get("phone", None)
queueInfo = QueueInfoInterface().getInfo({
"stationID": stationID,
"id": queueID
})
# if not queueInfo:
# raise Exception("[ERR]: queue not exists.")
filter = queueInfo["filter"]
filter = re.findall(r'queue=\'(.*)\'', filter)
queue = filter[0]
now = datetime.datetime.now()
current_date = now.strftime("%Y-%m-%d")
current_time = now.strftime("%H:%M:%S")
timestamp = int(time.mktime(now.timetuple()))
workerID = queueInfo["workerOnline"]
workerList = DB.DBLocal.select("workers",
where="stationID=$stationID and id=$id",
vars={
"stationID": stationID,
"id": workerID
})
if len(workerList) == 0:
workerName = ""
department = ""
else:
worker = workerList[0]
workerName = worker["name"]
department = worker["department"]
if len(cardID) <= 10:
id = cardID + str(timestamp)
else:
id = cardID[-10:] + str(timestamp)
values = {
"id": id,
"stationID": stationID,
"queueID": queueID,
"name": name,
"age": age,
"queue": queue,
"snumber": snumber,
"orderDate": current_date,
"orderTime": current_time,
"registDate": current_date,
"registTime": current_time,
"VIP": VIP,
"orderType": orderType,
"workerID": workerID,
"workerName": workerName,
"descText": descText,
"department": department,
"cardID": cardID,
"personID": personID,
"phone": phone,
"status": "护士新增"
}
try:
DB.DBLocal.insert("visitor_source_data", **values)
except:
raise Exception("[ERR]: insert into visitor_source_data failed.")
result = {"result": "success"}
para = {"stationID": stationID, "queueID": queueID}
QueueDataController().updateVisitor(para)
"""更新锁定和特性说明"""
values = {
"id": id,
}
if "locked" in inputData:
values["locked"] = inputData["locked"]
if "property" in inputData:
values["property"] = list2Str(inputData["property"])
try:
DB.DBLocal.update("visitor_local_data",
where="id=$id",
vars={"id": id},
**values)
except:
raise Exception("[ERR]: update visitor_local_data failed.")
return result
def convertSchedule(self, schedules):
"""将JSON格式的排班数据转换为可以插入数据库的数据
JSON格式的排班数据：某分诊台某队列一周、二周或四周的排班数据。
经过转换后，默认可以得到这个队列四周的排班记录，可以直接插入数据库
"""
stationID = schedules.get("stationID")
queueID = schedules.get("queueID")
isExpert = schedules.get("isExpert")
schedule = schedules.get("schedule")
queueInfo = QueueInfoInterface().getInfo({"stationID": stationID, "id": queueID})
queue = queueInfo["filter"]
max_date = DB.DBLocal.select("schedule", what="MAX(workDate) as max_date")[0]["max_date"]
schedule_value = []
schedule_temp_value = []
workers = {"stationID": stationID, "queueID": queueID, "workers": []}
for item in schedule:
date = datetime.datetime.strptime(item.get("workDate"), "%Y-%m-%d")
weekday = item.get("weekday")
time_state = item.get("workTime")
onDuty = item.get("onDuty")
workerList = item.get("workerID")
isTemporary = item.get("isTemporary")
value = {
"queue": queue,
"isExpert": isExpert,
"workDate": date,
"weekday": weekday,
"workTime": time_state,
"onDuty": onDuty,
"workerID": list2Str(workerList)
}
# 计算某一条排班数据要循环的次数
if max_date is None:
count = self.repeat_count
else:
interval = int(datetime.datetime.strftime(max_date, '%W')) - int(datetime.datetime.strftime(date, '%W'))
if interval in range(self.repeat_count):
count = interval + 1
else:
count = self.repeat_count
# 获取排班信息以几周为最小编辑单位
edit_period = self._getImportWeeks()
# 根据循环次数生成多条数据
for i in range(0, count, edit_period):
value_copy = copy.deepcopy(value)
start_date = date + datetime.timedelta(self.repeat_interval*i)
value_copy.update({"workDate": start_date})
schedule_info = DB.DBLocal.select("schedule", where="queue=$queue AND workDate=$workDate AND workTime=$workTime",
vars={"queue": queue, "workDate": start_date, "workTime": time_state})
# 如果是临时更改数据，则保存到临时排班表中
if isTemporary:
if i == 0:
schedule_temp_value.append(copy.deepcopy(value_copy))
if len(schedule_info) == 0:
value_copy.update({"onDuty": 0})
else:
continue
else:
if len(schedule_info) > 0:
value_copy = self._cmpOnDuty(value_copy, schedule_info[0])
schedule_value.append(value_copy)
for worker in workerList:
if worker not in workers["workers"]:
workers["workers"].append(worker)
return schedule_value, schedule_temp_value, workers
def POST(self, name):
webData = json.loads(web.data())
action = webData["action"]
if "token" in webData:
token = webData["token"]
if checkSession(token) == False:
return packOutput({}, "401", "Tocken authority failed")
if action == "getList":
list = self.getList(webData)
num = len(list)
resultJson = {"num": num, "list": []}
for item in list:
queue = item.copy()
queue["workerLimit"] = str2List(queue["workerLimit"])
resultJson["list"].append(queue)
return packOutput(resultJson)
elif action == "getInfo":
queueInfo = self.getInfo(webData)
queueInfo["workerLimit"] = str2List(queueInfo["workerLimit"])
return packOutput(queueInfo)
elif action == "add":
webData["workerLimit"] = list2Str(webData["workerLimit"])
ret = self.add(webData)
return packOutput({})
elif action == "edit":
webData["workerLimit"] = list2Str(webData["workerLimit"])
id = self.edit(webData)
return packOutput({})
elif action == "delete":
ret = self.delete(webData)
if ret == -1:
resultJson = {"result": "failed"}
else:
resultJson = {"result": "success"}
return packOutput(resultJson)
elif action == "getSourceQueueList":
ret = self.getSourceQueueList(webData)
jsonData = {"num": len(ret), "list": ret}
return packOutput(jsonData)
elif action == "getSceneSupportList":
ret = self.getSceneSupportList(webData)
list = []
for item in ret:
list.append(item)
jsonData = {"num": len(ret), "list": list}
return packOutput(jsonData)
elif action == "getAvgWaitTime":
try:
result = self.getAvgWaitTime(webData)
return packOutput(result)
except Exception as errorInfo:
return packOutput({}, code="400", errorInfo=str(errorInfo))
else:
return packOutput({}, "500", "unsupport action")
def genSceneData(self, **kwargs):
sceneName = kwargs.get("name", None)
if sceneName is None:
raise Exception("[ERR]: sceneName required.")
sceneNameText = "%s场景" % sceneName
activeLocal = kwargs.get("activeLocal")
tmp = {"0": "不需要", "1": "需要"}
activeLocalText = "%s本地激活" % tmp[activeLocal]
rankWay = kwargs.get("rankWay")
tmp = {"registTime": "挂号时间", "snumber": "序号", "activeTime": "激活时间"}
rankWayText = "使用%s进行排序" % tmp[rankWay]
delayTime = kwargs.get("delayTime")
waitNum = kwargs.get("waitNum")
passedWaitNum = kwargs.get("passedWaitNum", 2)
reviewWaitNum = kwargs.get("reviewWaitNum", 2)
priorNum = kwargs.get("priorNum", 2)
output = kwargs.get("outputText")
outputText = "播报请**到**%s" % output
workDays = kwargs.get("workDays", 1)
InsertPassedSeries = kwargs.get("InsertPassedSeries", 2)
InsertPassedInterval = kwargs.get("InsertPassedInterval", 3)
InsertReviewSeries = kwargs.get("InsertReviewSeries", 2)
InsertReviewInterval = kwargs.get("InsertReviewInterval", 3)
InsertPriorSeries = kwargs.get("InsertPriorSeries", 2)
InsertPriorInterval = kwargs.get("InsertPriorInterval", 3)
support_property = kwargs.get("property", self.support_property)
property = []
for key, value in support_property.items():
if key == 'callMode':
property.append(value)
else:
if value:
property.append(key)
descText = ', '.join(
[sceneNameText, activeLocalText, rankWayText, outputText])
values = {
"name": sceneName,
"descText": descText,
"activeLocal": activeLocal,
"rankWay": rankWay,
"delayTime": delayTime,
"waitNum": waitNum,
"output": output,
"passedWaitNum": passedWaitNum,
"reviewWaitNum": reviewWaitNum,
"priorNum": priorNum,
"orderAllow": 0,
"workDays": workDays,
"InsertPassedSeries": InsertPassedSeries,
"InsertPassedInterval": InsertPassedInterval,
"InsertReviewSeries": InsertReviewSeries,
"InsertReviewInterval": InsertReviewInterval,
"InsertPriorSeries": InsertPriorSeries,
"InsertPriorInterval": InsertPriorInterval,
"property": list2Str(property)
}
return values
