def deleteSchedule(self, data):
stationID = data.get("stationID", None)
if stationID is None:
raise Exception("[ERR]: stationID required")
queueID = data.get("queueID", None)
if queueID is None:
raise Exception("[ERR]: queueID required")
date = data.get("workDate", None)
if date is None:
raise Exception("[ERR]: date required")
weekday = data.get("weekday", None)
if weekday is None:
raise Exception("[ERR]: weekday required")
isTemporary = data.get("isTemporary", 0)
queueInfo = QueueInfoInterface().getInfo({"stationID": stationID, "id": queueID})
queue = queueInfo["filter"]
if isTemporary == 0:
DB.DBLocal.delete("schedule", where="queue=$queue AND weekday=$weekday AND workDate>=$workDate",
vars={"queue": queue, "weekday": weekday, "workDate": date})
else:
DB.DBLocal.delete("schedule", where="queue=$queue AND workDate=$workDate",
vars={"queue": queue, "workDate": date})
result = {}
result["result"] = "success"
return result
def collectScore(cls, scene, sourceData, localData): #收集访客的优先信息
stationID = localData["stationID"]
queueID = localData["queueID"]
workDays, date = QueueInfoInterface().getWorkDays(stationID, queueID)
date = datetime.datetime.strptime(date, "%Y%m%d")
level = LocalVisitor.collectLevel(scene, sourceData, localData)
rankWay = scene["rankWay"]
registDateTime = sourceData["registTime"]
activeLocalTime = localData["activeLocalTime"]
if rankWay == "snumber":
num = sourceData["snumber"]
# TODO: V1.21 Test. scene property add morningPrior
sceneProperty = scene.get("property")
if sceneProperty["morningPrior"]:
#Todo: 判断时间大于12点
#if registDateTime.hours >= 12:
# level = level + 1
pass
score = (level * levelMask) + (num) * 160
elif rankWay == "registTime" or rankWay == "registTimeAndSmart":
second = (registDateTime - date).total_seconds()
score = (level * levelMask) + int(second) * 160
else:
if activeLocalTime < date:
second = (registDateTime - date).total_seconds()
else:
second = (activeLocalTime - date).total_seconds()
score = (level * levelMask) + int(second) * 160
return score
def addSchedule(self, data):
scheduleList = data.get("scheduleList")
schedule_values = []
queue_workers = []
for schedule in scheduleList:
# 获取某个队列需要插入数据库的所有数据，以及添加到该队列的医生
stationID = schedule.get("stationID")
queueID = schedule.get("queueID")
schedule_value, workers = self.convertSchedule(schedule)
schedule_values.extend(schedule_value)
schedule_values = sorted(schedule_values, key=lambda value: (value["queue"], value["workDate"]))
queue_workers.append({"stationID": stationID, "queueID": queueID, "workers": workers})
try:
start = time.time()
DB.DBLocal.multiple_insert("schedule", values=schedule_values)
print "TIME COST FOR INSERT SCHEDULES: {0} ms".format((time.time() - start) * 1000)
for item in queue_workers:
QueueInfoInterface().updateWorkerLimit(item)
except:
raise
else:
result = {}
result["result"] = "success"
return result
def backupOld(self):
queueList = self.queueInfo.getList({"stationID": self.stationID})
LogOut.info("station %d backupOld" % self.stationID)
#遍历分诊台的队列
for queue in queueList:
#得到策略的工作时间
workDays, dateStr = QueueInfoInterface().getWorkDays(
self.stationID, queue["id"])
joinView = "(select id, queueID, status as localStatus,workStartTime,workEndTime from visitor_local_data where stationID = %d and queueID = %d) as joinView" \
%(self.stationID , queue["id"])
joinSql = "select * from visitor_source_data a inner join %s on a.id=joinView.id where registDate < %s" % (
joinView, dateStr)
print("backupView sql: " + joinSql)
# find the visitors outof date
backupList = self.DBLocal.query(joinSql)
for item in backupList:
print "find backup item name: " + item[
"name"] + " registDate: " + str(
item["registDate"]) + " workEndTime: " + str(
item["workEndTime"])
BackupTableInterface(self.stationID).add(item)
VisitorSourceInterface(self.stationID).delete(item)
VisitorLocalInterface(self.stationID).delete(item)
"""
def visitorActiveSet(self, inputData):
stationID = inputData["stationID"]
queueID = inputData["queueID"]
visitor = {}
visitor["id"] = inputData["id"]
visitor["stationID"] = stationID
if inputData["active"]:
activeTime = datetime.datetime.now()
visitor["activeLocal"] = 1
visitor["activeLocalTime"] = activeTime
queueInfo = QueueInfoInterface().getInfo({
"stationID": stationID,
"id": queueID
})
sceneID = queueInfo["sceneID"]
scene = SceneInterface().getSceneInfo({"sceneID": sceneID})
if scene["delayTime"] == 0:
visitor["status"] = "waiting"
else:
visitor["status"] = "unactivewaiting"
else:
visitor["activeLocal"] = 0
visitor["status"] = "unactive"
VisitorLocalInterface(stationID).edit(visitor)
QueueDataController().sortVisitor(stationID, queueID, scene)
return
def backupOld(self):
stationList = StationInterface().getList()
for station in stationList:
stationID = station["id"]
queueList = self.queueInfo.getList({"stationID": stationID})
LogOut.info("station %d backupOld" % stationID)
#遍历分诊台的队列
for queue in queueList:
#得到策略的工作时间
workDays, dateStr = QueueInfoInterface().getWorkDays(
stationID, queue["id"])
joinSql = "select * from visitor_view_data where queueID = %d and registDate < %s" % (
queue["id"], dateStr)
print("backupView sql: " + joinSql)
# find the visitors outof date
backupList = self.db.query(joinSql)
for item in backupList:
print "find backup item name: " + item[
"name"] + " registDate: " + str(
item["registDate"]) + " workEndTime: " + str(
item["workEndTime"])
item.pop("lid")
BackupTableInterface(stationID).add(item)
VisitorSourceInterface().delete(item)
VisitorLocalInterface(stationID).delete(item)
def getCallerPublish(self,inputData):
retlistInfo = {}
retWorker = {}
retQueue = {}
ret = {}
stationID = inputData["stationID"]
callerID = inputData["callerID"]
selCaller = CallerInterface().getInfo({"stationID":stationID ,"id" :callerID})
workerOnlineID = selCaller["workerOnline"]
if workerOnlineID:
workerOnline = WorkerInterface().getInfo({"stationID":stationID, "id" :workerOnlineID})
#显示呼叫记录表单中的项目，有效时间内
validDataTime = "timestamp\'" + self.getValidDateTime() + "\'"
callRecordList = DB.DBLocal.where("callingRecord",stationID = stationID, callerID = callerID)
if len(callRecordList) > 0:
record = callRecordList[0]
# 从窗口的最后一次呼叫 得到队列信息
queueID = record["queueID"]
queueList = StationMainController().getQueueList({"stationID":stationID, "queueID" :queueID})
queueInfo = QueueInfoInterface().getInfo({"stationID":stationID, "id" :queueID})
doingList = queueList["doingList"]
waitingList = queueList["waitingList"]
retQueue["listNum"] = len(waitingList)
retQueue["department"] = workerOnline["department"]
retQueue["pos"] = selCaller["pos"]
#获得Seeing数据 从记录中的ID中得到呼叫的患者信息 呼叫显示次数递减
seeing = StationMainController().getVisitorInfo({"stationID":stationID,"id":record["currentVisitorID"]})
retlistInfo["seeing"] = {}
retlistInfo["seeing"]["name"] = seeing["name"]
retlistInfo["seeing"]["id"] = seeing["snumber"]
if record["showCnt"] > 0:
retlistInfo["seeing"]["show"] = 1
record["showCnt"] -= 1
callRecordInterface().edit(record)
else:
retlistInfo["seeing"]["show"] = 0
#获得waiting数据
retlistInfo["waiting"] = []
for item in waitingList:
waitItem = {}
waitItem["name"] = item["name"]
waitItem["id"] = item["snumber"]
retlistInfo["waiting"].append(waitItem)
# 获得医生数据
retWorker["name"] = workerOnline["name"]
retWorker["id"] = workerOnline["id"]
retWorker["department"] = workerOnline["department"]
retWorker["title"] = workerOnline["title"]
retWorker["headpic"] = workerOnline["headPic"]
ret["workerInfo"] = retWorker
ret["queueInfo"] = retQueue
ret["listInfo"] = retlistInfo
return ret
def fuzzySearchSchedule(self, data):
related_queue = QueueInfoInterface().fuzzySearchQueue(data)
suggestions = []
for item in related_queue:
stationID = item.get("stationID")
queueID = item.get("id")
startTime = data.get("startTime")
endTime =data.get("endTime")
result = self.getQueueSchedule({"stationID": stationID, "queueID": queueID,
"startTime": startTime, "endTime": endTime})
suggestions.append(result)
return suggestions
def getCallerListPublish(self,inputData):
retlistInfo = {}
ret = {}
stationID = inputData["stationID"]
callerID = inputData["callerID"]
callerList = DB.DBLocal.select("caller", where="id=$id", vars={"id": callerID})
if len(callerList) == 0:
raise Exception("[ERR]: caller not exists.")
validDateTime = datetime.datetime.strptime(self.getValidDateTime(), "%Y-%m-%d %H:%M:%S")
callRecordList = DB.DBLocal.select("callingRecord",
where="stationID=$stationID AND callerID=$callerID AND dateTime>$dateTime",
vars={"stationID": stationID, "callerID": callerID, "dateTime": validDateTime})
if len(callRecordList) > 0:
record = callRecordList[0]
# 从窗口的最后一次呼叫 得到队列信息
queueID = record["queueID"]
queueList = StationMainController().getQueueList({"stationID":stationID, "queueID" :queueID})
queueInfo = QueueInfoInterface().getInfo({"stationID":stationID, "id" :queueID})
doingList = queueList["doingList"]
waitingList = queueList["waitingList"]
retlistInfo["seeingList"] = []
for item in doingList:
seeingItem = {}
seeingItem["name"] = item["name"]
seeingItem["id"] = item["snumber"]
retlistInfo["seeingList"].append(seeingItem)
retlistInfo["watingList"] = []
for item in waitingList:
waitItem = {}
if item["locked"]:
continue
waitItem["name"] = item["name"]
waitItem["id"] = item["snumber"]
retlistInfo["watingList"].append(waitItem)
callRecordList = DB.DBLocal.where("callingRecord", stationID=stationID, callerID=callerID)
retlistInfo["calling"] = []
if len(callRecordList) > 0:
record = callRecordList[0]
# 病人ID显示为snumber
currentVisitor = self.stationController.getVisitorInfo(
{"stationID": stationID, "id": record["currentVisitorID"]})
calling = {}
calling["name"] = record["currentVisitorName"]
calling["id"] = currentVisitor["snumber"]
calling["pos"] = callerList[0]["pos"]
retlistInfo["calling"] = calling
ret = retlistInfo
return ret
def setVisitorStatus(self, inputData, action=None):
stationID = inputData.get("stationID")
queueID = inputData.pop("queueID")
# 根据访客所处队列选择的策略信息，获取缓冲人数
queueInfo = QueueInfoInterface().getInfo({
"stationID": stationID,
"id": queueID
})
sceneID = queueInfo["sceneID"]
scene = SceneInterface().getSceneInfo({"sceneID": sceneID})
if action == "pass" or action == "delay":
waitNum = scene["passedWaitNum"]
elif action == "review":
waitNum = scene["reviewWaitNum"]
else:
# raise Exception("[ERR]: visitor status action not support.")
waitNum = 0
# 获取队列访客信息，如果等待队列中已经有过号或者复诊的访客，则调整缓冲人数
fliter = "stationID=$stationID and queueID=$queueID and status=$status"
visitorList = DB.DBLocal.select("visitor_local_data",
where=fliter,
vars={
"stationID": stationID,
"queueID": queueID,
"status": "waiting"
},
order="finalScore, originScore")
visitorNum = len(visitorList)
if action == "pass" or action == "delay":
InsertSeries = scene["InsertPassedSeries"]
InsertInterval = scene["InsertPassedInterval"]
elif action == "review":
InsertSeries = scene["InsertReviewSeries"]
InsertInterval = scene["InsertReviewInterval"]
else: #default val
InsertSeries = 2
InsertInterval = 3
destPos, destScore = QueueDataController().getInsertPos(
visitor=inputData,
vList=visitorList,
numNormal=InsertInterval,
numHigher=InsertSeries,
numWaitting=waitNum)
inputData["finalScore"] = destScore
return inputData
def getQueueSchedule(self, data):
stationID = data.get("stationID", None)
queueID = data.get("queueID", None)
if queueID is None:
raise Exception("[ERR]: queueID required")
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")
queueInfo = QueueInfoInterface().getInfo({"stationID": stationID, "id": queueID})
queue = queueInfo["filter"]
try:
self.autoGenSchedule(startTime, endTime)
except:
raise
scheduleList = DB.DBLocal.select("schedule", where="queue=$queue AND workDate BETWEEN $startTime AND $endTime",
vars={"queue": queue, "startTime": startTime, "endTime": endTime})
schedule = []
isExpert = None
for item in scheduleList:
tmp = {}
scheduleTempList = DB.DBLocal.select("schedule_temp", where={"queue": item["queue"],
"workDate": item["workDate"].strftime("%Y-%m-%d"),
"workTime": item["workTime"]})
if len(scheduleTempList) > 0:
schedule_temp = scheduleTempList[0]
item = self._cmpOnDuty(item, schedule_temp)
tmp["workDate"] = item["workDate"]
tmp["workTime"] = item["workTime"]
tmp["weekday"] = item["weekday"]
tmp["onDuty"] = item["onDuty"]
tmp["workerID"] = str2List(item["workerID"])
isExpert = item["isExpert"]
schedule.append(tmp)
result = {}
result["stationID"] = queueInfo["stationID"]
result["queueID"] = queueID
result["name"] = queueInfo["name"]
result["filter"] = queue
#TODO： 专家队列信息是否和队列信息放在一起
result["isExpert"] = isExpert
result["schedule"] = schedule
return result
def getAvaliableQueue(self, data):
stationID = data.get("stationID", None)
if stationID is None:
raise Exception("[ERR]: stationID required")
queueList = DB.DBLocal.select("queueInfo",
where={"stationID": stationID},
what="id")
queueIDList = []
for item in queueList:
queueIDList.append(item["id"])
choseQueueList = DB.DBLocal.select("queue_machine",
where={"stationID": stationID},
what="queueLimit")
choseQueueIDList = []
for item in choseQueueList:
queueLimit = str2List(item["queueLimit"])
for queueID in queueLimit:
if queueID not in choseQueueIDList:
choseQueueIDList.append(queueID)
choseQueueIDList = map(int, choseQueueIDList)
avaliableQueue = [
item for item in queueIDList if item not in choseQueueIDList
]
result = {"list": []}
for item in avaliableQueue:
try:
queueInfo = QueueInfoInterface().getInfo({
"stationID": stationID,
"id": item
})
except:
pass
else:
result["list"].append({
"queueID": queueInfo["id"],
"name": queueInfo["name"]
})
result["num"] = len(result["list"])
return result
def getQueueListInfo(self, inputData):
stationID = inputData.get("stationID")
station = DB.DBLocal.select("stationSet",
where="id=$id",
vars={"id": stationID})
if len(station) == 0:
raise Exception("[ERR]: station not exists.")
# sql = "SELECT q.id, q.name, q.workerOnline, s.activeLocal FROM queueInfo AS q " \
# "INNER JOIN scene AS s ON q.sceneID = s.id WHERE q.stationID=%s" % stationID
# # list = DB.DBLocal.where('queueInfo', stationID=inputData["stationID"])
# list = DB.DBLocal.query(sql)
list = QueueInfoInterface().getList({"stationID": stationID})
ret = {"num": len(list), "list": []}
for item in list:
queueInfo = {}
queueInfo["id"] = item["id"]
queueInfo["name"] = item["name"]
queueInfo["workerOnline"] = item["workerOnline"]
if item["activeLocal"] == 1:
queueInfo["tab"] = ["unactive", "waiting", "finish"]
else:
queueInfo["tab"] = ["waiting", "finish"]
ret["list"].append(queueInfo)
return ret
def getPublishList(self, inputData):
stationID = inputData.get("stationID", None)
if stationID is None:
raise Exception("[ERR]: stationID required.")
callerID = inputData.get("callerID", None)
action = inputData.get("action", None)
if action is None:
raise Exception("[ERR]: action required.")
# if can get from Memcached
key = "_getPublishList_stationID" + str(stationID) +"_callerID"+ str(callerID) + "_action" + action
value = common.func.CachedGetValue(json.dumps(key))
if value != False:
return value
# TODO： 试验删掉医生的情况
# 如果获取叫号器信息时发生异常，在上层函数中处理
caller = self.callerInterface.getInfo({"stationID": stationID, "id": callerID})
workerID = caller["workerOnline"]
try:
workerOnline = self.workerInterface.getInfo({"stationID": stationID, "id": workerID})
workerInfo = {
"id": workerOnline["id"],
"name": workerOnline["name"],
"title": workerOnline["title"],
"descText": workerOnline["descText"],
"department": workerOnline["department"],
"headpic": workerOnline["headPic"],
"status": workerOnline["status"],
"speciality": workerOnline["speciality"]
}
if action == 'getStationList' and workerInfo["status"] == "离开":
return None
except:
workerInfo = {"id": "", "name": "", "title": "", "descText": "", "department": "", "headpic": ""}
# 获取呼叫队列的信息
queueInfo = {
"department": workerInfo["department"],
"pos": caller["pos"],
"listNum": 0
}
# 获取正在就诊、正在排队的信息
seeing = {"id": "", "name": "", "show": 0, "status": ""}
waiting = []
validDateTime = datetime.datetime.strptime(self.getValidDateTime(), "%Y-%m-%d %H:%M:%S")
callerRecord = DB.DBLocal.select("callingRecord",
where="stationID=$stationID AND callerID=$callerID AND dateTime>$dateTime",
vars={"stationID": stationID, "callerID": callerID, "dateTime": validDateTime})
try:
record = callerRecord[0]
queueID = record["queueID"]
queue = QueueInfoInterface().getInfo({"stationID": stationID, "id": queueID})
sceneID = queue["sceneID"]
scene = SceneInterface().getSceneInfo({"sceneID": sceneID})
queueList = self.stationController.getQueueList({"stationID": stationID, "queueID": queueID})
except:
if action == 'getStationList':
result = {}
return result
else:
# 获取呼叫队列中当前看诊的信息
currentVisitor = self.stationController.getVisitorInfo({"stationID": stationID, "id": record["currentVisitorID"]})
if currentVisitor["localStatus"] == 'doing':
seeing["id"] = currentVisitor["snumber"]
seeing["name"] = currentVisitor["name"]
seeing["status"] = self.getVisitorStatus(**currentVisitor)
seeing["outputText"] = scene["outputText"]
seeing["show"] = 0
seeing["dateTime"] = record["dateTime"]
# 获取呼叫队列中当前排队的信息
waitingList = queueList["waitingList"]
queueInfo.update({"listNum": len(waitingList), "queueName": queue["name"]})
for item in waitingList:
if item["locked"]:
continue
waitingVisitor = {}
waitingVisitor["id"] = item["snumber"]
waitingVisitor["name"] = item["name"]
waitingVisitor["status"] = self.getVisitorStatus(**item)
waiting.append(waitingVisitor)
result = {}
result["workerInfo"] = workerInfo
result["queueInfo"] = queueInfo
result["listInfo"] = {"seeing": seeing, "waiting": waiting}
# 缓存 value
common.func.CahedSetValue(json.dumps(key), result, 3)
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 updateVisitor(self, inputData):
stationID = inputData["stationID"]
queueID = inputData["queueID"]
queueInfo = QueueInfoInterface().getInfo({
"stationID": stationID,
"id": queueID
})
sceneID = queueInfo["sceneID"]
scene = SceneInterface().getSceneInfo({"sceneID": sceneID})
visitorLocalInterface = VisitorLocalInterface(stationID)
filter = str(queueInfo["filter"])
sourceList = DB.DBLocal.where("visitor_source_data", queue=filter)
sourceList = list(sourceList)
localList = DB.DBLocal.where("visitor_local_data",
stationID=stationID,
queueID=queueID)
localDict = list2Dict(localList)
# 遍历 sourceList
for sourceItem in sourceList:
if str(sourceItem["id"]) not in localDict:
localData = {
"id": sourceItem["id"],
"name": sourceItem["name"],
"registDate": sourceItem["registDate"],
"stationID": stationID,
"queueID": queueID,
"activeLocal": 0,
"activeLocalTime": datetime.datetime(2000, 1, 1),
"prior": 0,
"vip": 0,
"locked": 0
}
status = "unactive" if scene["activeLocal"] else "waiting"
originLevel = LocalVisitor.collectLevel(
scene, sourceItem, localData)
originScore = LocalVisitor.collectScore(
scene, sourceItem, localData)
finalScore = finalScoreDef
localData.update({
"status": status,
"originLevel": originLevel,
"originScore": originScore,
"finalScore": finalScore
})
localDict[str(sourceItem["id"])] = localData
visitorLocalInterface.add(localData)
else:
localData = localDict[str(sourceItem["id"])]
# 更新访客的分数
originScore = LocalVisitor.collectScore(
scene, sourceItem, localData)
originLevel = LocalVisitor.collectLevel(
scene, sourceItem, localData)
if localData["originScore"] != originScore or localData[
"originLevel"] != originLevel:
localData.update({
"originLevel": originLevel,
"originScore": originScore,
"finalScore": finalScoreDef
})
localDict[str(sourceItem["id"])] = localData
visitorLocalInterface.edit(localData)
# 如果队列需要激活且访客处于等待激活的状态，根据激活时间更新访客的状态
if scene["activeLocal"] and localData[
"status"] == "unactivewaiting":
now = datetime.datetime.now()
activeTime = localData["activeLocalTime"]
interval = (now - activeTime).total_seconds()
if interval >= scene["delayTime"] * 60:
localData.update({"status": "waiting"})
visitorLocalInterface.edit(localData)
self.sortVisitor(stationID, queueID, scene)
def _addVisitor(self, inputData, action=None):
stationID = inputData.get("stationID", None)
queueID = inputData.get("queueID", None)
name = inputData.get("name", None)
snumber = inputData.get("snumber", None)
VIP = inputData.get("VIP", 0)
descText = inputData.get("descText", None)
cardID = inputData.get("cardID", None)
age = inputData.get("orderType", None)
orderType = inputData.get("orderType", 0)
personID = inputData.get("personID", None)
phone = inputData.get("phone", None)
if stationID is None:
raise Exception("[ERR]: stationID required to add visitor")
if queueID is None:
raise Exception("[ERR]: queueID required to add visitor")
if action is None:
action = "nurser_add"
# 自动生成患者ID
now = datetime.datetime.now()
current_date = now.strftime("%Y-%m-%d")
current_time = now.strftime("%Y-%m-%d %H:%M:%S")
timestamp = int(time.time() * 1000000)
id = str(stationID) + str(queueID) + str(timestamp)
# 如果cardID不存在，从id中获取；如果存在，查询数据获得病人的姓名
if cardID is None:
cardID = id[-16:]
else:
visitor_list = DB.DBLocal.select(
"visitor_source_data",
where="cardID=$cardID AND name NOT LIKE $name",
vars={
"cardID": cardID,
"name": "%号"
})
visitor_bak_list = DB.DBLocal.select(
"visitor_backup_data",
where="cardID=$cardID AND name NOT LIKE $name",
vars={
"cardID": cardID,
"name": "%号"
})
if visitor_list:
name = visitor_list[0]["name"]
else:
if visitor_bak_list:
name = visitor_bak_list[0]["name"]
# 如果snumber不存在，则根据分诊台下的患者数自动生成一个序号
if not snumber:
where = "stationID=$stationID"
visitor_all = DB.DBLocal.select("visitor_local_data",
where=where,
vars={"stationID": stationID})
visitor_all_count = len(visitor_all)
snumber = visitor_all_count + 1
# 如果name不存在，则根据snumber生成一个名字
if name is None:
name = "{0}号".format(snumber)
# 根据队列中的等待、未激活、等待激活的人数，确定总的等待人数
where = "stationID=$stationID AND queueID=$queueID AND status IN $status"
visitor_wait = DB.DBLocal.select("visitor_local_data",
where=where,
vars={
"stationID":
stationID,
"queueID":
queueID,
"status": ('waiting', 'unactive',
'unactivewaiting')
})
waitNum = len(visitor_wait)
# 获取队列关键字
queueInfo = QueueInfoInterface().getInfo({
"stationID": stationID,
"id": queueID
})
queue = queueInfo["filter"]
workerID = queueInfo["workerOnline"]
workerList = DB.DBLocal.select("workers",
where="id=$id",
vars={"id": workerID})
workerName = None
department = None
if len(workerList) != 0:
worker = workerList[0]
workerName = worker["name"]
department = worker["department"]
# 修改患者来源
status = None
if action == "nurser_add":
status = "护士新增"
elif action == "self_pick_up":
status = "自助取号"
visitor = {
"id": id,
"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": status
}
values = {}
for key, value in visitor.items():
if value is not None:
values.update({key: value})
if value is None:
visitor.update({key: ""})
try:
DB.DBLocal.insert("visitor_source_data", **values)
except Exception, e:
print "Exception : %s " % str(e)
raise Exception(
"[ERR]: insert into visitor_source_data failed. %s " % str(e))
def getQueueListAll(self, inputData, useCache):
stationID = inputData["stationID"]
queueID = inputData["queueID"]
#if can get from Memcached
key = "_getQueueListAll_stationID" + str(stationID) + "_queueID" + str(
queueID)
value = common.func.CachedGetValue(json.dumps(key))
if value != False:
if useCache:
return value
ret = {
"name": "",
"workerOnline": "",
"waitingList": [],
"finishList": []
}
queue = QueueInfoInterface().getInfo({
"stationID": stationID,
"id": queueID
})
ret.update({
"name": queue["name"],
"workerOnline": queue["workerOnline"]
})
if queue["activeLocal"] == 1:
unactiveList = DB.DBLocal.where("visitor_view_data",
stationID=stationID,
queueID=queueID,
localStatus="unactive") # 未激活的所有访客
ret["unactiveList"] = []
for item in unactiveList:
ret["unactiveList"].append(item)
doingList = DB.DBLocal.where("visitor_view_data",
stationID=stationID,
queueID=queueID,
localStatus="doing") # 进行中的所有访客
ret["waitingList"] = list(doingList)
waitList = DB.DBLocal.where("visitor_view_data",
stationID=stationID,
queueID=queueID,
localStatus="waiting") # 等待中的所有访客
ret["waitingList"] = ret["waitingList"] + list(waitList)
finishList = DB.DBLocal.where("visitor_view_data",
stationID=stationID,
queueID=queueID,
localStatus="pass") # 过号的所有访客
for item in finishList:
ret["finishList"].append(item)
finishList = DB.DBLocal.where("visitor_view_data",
stationID=stationID,
queueID=queueID,
localStatus="finish") # 已完成的所有访客
for item in finishList:
ret["finishList"].append(item)
#缓存 value
common.func.CahedSetValue(json.dumps(key), ret, 2)
return ret
def getInfo(self, data):
"""获取某个取号机的详细信息"""
stationID = data.get("stationID", None)
if stationID is None:
raise Exception("[ERR]: stationID required for queue_machine")
where = {"stationID": stationID}
id = data.get("id", None)
if id is None:
where.update({"deviceIP": web.ctx.ip})
else:
where.update({"id": id})
queue_machine_list = DB.DBLocal.select("queue_machine", where=where)
queue_machine = queue_machine_list[0]
for key, value in queue_machine.items():
if value is None:
queue_machine.update({key: ""})
result = {}
# 取号机选择的队列信息
queueLimit = str2List(queue_machine["queueLimit"])
queue_machine["queueLimit"] = []
for queueID in queueLimit:
try:
queueInfo = QueueInfoInterface().getInfo({
"stationID": stationID,
"id": queueID
})
except:
continue
else:
queue_machine["queueLimit"].append({
"queueID": queueInfo["id"],
"name": queueInfo["name"]
})
# 取号机支持的特性
supportFeature = str2List(queue_machine.pop("supportFeature"))
queue_machine["supportFeature"] = {}
for key, value in self.support_feature.items():
keyword = self.feature_keywords[key]
if keyword in supportFeature:
queue_machine["supportFeature"].update({key: 1})
else:
queue_machine["supportFeature"].update({key: value})
# 取号机打印设置项
printSettings = {}
printSettings["title"] = queue_machine.pop("title")
printSettings["subtitle"] = queue_machine.pop("subtitle")
printSettings["footer1"] = queue_machine.pop("footer1")
printSettings["footer2"] = queue_machine.pop("footer2")
styleID = queue_machine.pop("styleID", 1)
styleList = DB.DBLocal.select("style", where={"id": styleID})
printSettings["styleInfo"] = {
"id": "",
"name": "",
"styleURL": "",
"previewURL": ""
}
for item in styleList:
printSettings["styleInfo"] = item
queue_machine["printSettings"] = printSettings
queue_machine = self.queueMachineStatus(queue_machine)
queue_machine.update({"queueNum": len(queue_machine["queueLimit"])})
result.update(queue_machine)
return result
def getExpertSchedule(self, data):
"""获取专家队列的上班情况"""
stationID = data.get("stationID", None)
where = None
if stationID:
where = {}
where.update({"stationID": stationID})
# 判断哪些队列属于专家队列
queueID = data.get("queueID", None)
if not queueID:
queueID = []
queueList = DB.DBLocal.select("queueInfo", what="id", where=where)
for item in queueList:
id = item["id"]
try:
isExpert = self._isExpertQueue(id)
except:
continue
if isExpert:
queueID.append(id)
if not isinstance(queueID, list):
raise Exception("[ERR] queueID must be a list")
isExpert = data.get("isExpert", 1)
startTime = data.get("startTime", None)
endTime = data.get("endTime", None)
if not startTime or not endTime:
current_date = datetime.datetime.today()
startTime = (current_date - datetime.timedelta(current_date.weekday())).strftime("%Y-%m-%d")
endTime = (current_date + datetime.timedelta(6 - current_date.weekday())).strftime("%Y-%m-%d")
if endTime < startTime:
raise Exception("[ERR]: endTime should larger than startTime")
data.update({"isExpert": isExpert, "startTime": startTime, "endTime": endTime})
result = {"list":[]}
for item in queueID:
data.update({"queueID": item})
queueInfo = QueueInfoInterface().getInfo({"stationID":"", "id": item})
queue_schedule = self.getQueueSchedule(data)
schedule = queue_schedule.pop("schedule")
workerID = None
if queueInfo["workerLimit"]:
workerID = str2List(queueInfo["workerLimit"])[0]
tmp = []
for s in schedule:
if s["onDuty"] == 1:
s.pop("workerID")
tmp.append(s)
queue_schedule.update({"schedule": tmp})
if not queue_schedule["schedule"]:
continue
workerList = DB.DBLocal.select("workers", where={"id": workerID})
workerInfo = {"name": "", "department": "", "title": "", "descText": "", "headPic": "", "speciality": ""}
if len(workerList) !=0:
worker = workerList[0]
for key in workerInfo.keys():
if worker[key]:
workerInfo.update({key: worker[key]})
queue_schedule.update({"workerInfo": workerInfo})
if queue_schedule["workerInfo"]["name"]:
result["list"].append(queue_schedule)
return result
def importSchedule(self, config):
"""导入排班信息
排班信息导入支持导入1周、2周、4周的数据，在导入时需要确认数据源排班信息的周数
是否和选择导入的周数相匹配。
在导入时，导入数据会完全覆盖数据库中对应的数据。
"""
db_config = convertDBConfig(**config)
if config["DBType"] == 'mssql':
DBSource = DB.MSSQLController(config).MSSQLDB
else:
DBSource = web.database(**db_config)
# 导入数据的周数，默认1周，可选1周、2周、4周数据
import_weeks = config.pop("importWeeks", 1)
# 数据源连接测试
connect_test = self.testSourceConfig(config)
if connect_test["result"] == "failed":
raise Exception("[ERR]: import failed, please check the config")
else:
sql = connect_test["sql"]
tmp = DBSource.select(sql, what="MAX(workDate) as MAX_DATE, MIN(workDate) as MIN_DATE")[0]
max_date = tmp["MAX_DATE"]
min_date = tmp["MIN_DATE"]
if not max_date or not min_date:
# raise Exception("[ERR]: import failed, please check whether the source has {0} week(s) data".format(import_weeks))
raise Exception("importWeeks error")
# MSSQL 查询出来是Unicode，需要进行转换
if isinstance(max_date, str) or isinstance(max_date, unicode):
max_date = datetime.datetime.strptime(max_date, "%Y-%m-%d")
if isinstance(min_date, str) or isinstance(min_date, unicode):
min_date = datetime.datetime.strptime(min_date, "%Y-%m-%d")
# 判断是否是最新的数据
current_date = datetime.datetime.today()
isNewData = int(datetime.datetime.strftime(current_date, '%W')) - int(datetime.datetime.strftime(min_date, '%W'))
if isNewData !=0:
raise Exception("importWeeks error")
# 判断导入数据的周数和配置的导入周数是否相同
interval = int(datetime.datetime.strftime(max_date, '%W')) - int(datetime.datetime.strftime(min_date, '%W'))
count = interval + 1
if count != import_weeks:
# raise Exception("[ERR]: import failed, please check whether the source has {0} week(s) data".format(import_weeks))
raise Exception("importWeeks error")
# 数据源排班数据
scheduleList = DBSource.select(sql)
# 插入到排班表中的排班数据列表，可使用multiple_insert方法实现多条插入
insert_items = []
# 每个队列关键字对应的分诊台ID、队列ID、可登陆医生等信息
queue_workers = []
# 根据循环的次数，生成相应的排班数据
for item in scheduleList:
if config["DBType"] == "oracle":
item = self.convertItem(item)
for i in range(0, self.repeat_count, import_weeks):
# 生成排班信息
workDate = item["workDate"]
if isinstance(workDate, str) or isinstance(workDate, unicode):
workDate = datetime.datetime.strptime(workDate, "%Y-%m-%d")
date = workDate + datetime.timedelta(self.repeat_interval*i)
item_copy = copy.deepcopy(item)
item_copy["workDate"] = date
insert_items.append(dict(item_copy))
# 导入数据时也要覆盖临时调班数据
schedule_temp = DB.DBLocal.select("schedule_temp", where={"queue": item_copy["queue"], "workTime": item_copy["workTime"],
"workDate": item_copy["workDate"].strftime("%Y-%m-%d")})
if len(schedule_temp) != 0:
DB.DBLocal.delete("schedule_temp", where={"queue": item_copy["queue"], "workTime": item_copy["workTime"],
"workDate": item_copy["workDate"].strftime("%Y-%m-%d")})
# 生成每个队列的医生数据
workers = str2List(item["workerID"])
queue = item["queue"]
try:
queueInfo = QueueInfoInterface().getInfoByFilter({"queue": queue})
worker_paras = {"stationID": queueInfo["stationID"], "queueID": queueInfo["id"], "workers": workers}
except:
continue
if not queue_workers:
queue_workers.append(worker_paras)
else:
for item in queue_workers:
if item["stationID"] == queueInfo["stationID"] and item["queueID"] == queueInfo["id"]:
item["workers"] = list(set(item["workers"] + workers))
break
else:
queue_workers.append(worker_paras)
insert_items = sorted(insert_items, key=lambda value: (value["queue"], value["workDate"]))
try:
start = time.time()
# 批量插入或者更新排班数据
if insert_items:
insert_sql = multiple_insert_sql("schedule", insert_items)
DB.DBLocal.query(insert_sql)
print "Worker: {0}".format(queue_workers)
# 更新每个队列可登陆医生
for item in queue_workers:
QueueInfoInterface().updateWorkerLimit(item)
# 如果导入成功，将import_weeks写入数据库配置中
DB.DBLocal.update("import_config", where={"type": "schedule"}, importWeeks=import_weeks)
except:
raise
else:
print "IMPORT TIME COST: {0} ms".format((time.time() - start) * 1000)
print "INSERT/UPDATE: {0}".format(len(insert_items))
result = {}
result["result"] = "success"
result["successCount"] = len(insert_items)
result["totalImport"] = len(insert_items)
result["failedCount"] = result["totalImport"] - result["successCount"]
return result
