def SpecifyStatus(self, order, status, *executors):
statusid = -1
status_partten = ['未', '待', '没有', '尚未', '还没有', '没']
left_status = [i for i in status_partten if i in status]
statusid = 0 if len(left_status) else 3
# 判断是否过期
isExpire = self.JudgeStatusExpired(status, status_partten)
if isExpire == 1:
starttime = None
logger.info('未过期')
_, _endtime = CNTime('今天').guess_time()
logger.info('{}'.format(_endtime))
# endtime = str(int(_endtime.timestamp() * 1000))
return self.SpecifyTime(order, starttime, _endtime, *executors)
elif isExpire == 0:
logger.info('已过期')
starttime = None
_, _endtime = CNTime('昨天').guess_time()
logger.info('{}'.format(_endtime))
# endtime = str(int(_endtime.timestamp() * 1000))
return self.SpecifyTime(order, starttime, _endtime, *executors)
params = {
'srcInput':
order,
'stateId':
statusid,
'filterAssigners':
','.join([str(v) if v > 0 else str(-1) for v in executors]),
}
logger.info('PARAMS:{}'.format(params))
return self.Do(params)
def main():
global Cases
print('---')
for case in Cases:
_ts = time.time()
data = CNTime(case)
#data = json.dumps(data, ensure_ascii=False, sort_keys=True, indent=4)
start, end = data.guess_time()
print('{} => {}, ({}, {})'.format(case, data.desc_time(), start, end))
_te = time.time()
print('Assumed: {}ms'.format(round((_te - _ts) * 1000)))
print('---')
Cases = [
('8号', '13号'),
('三天前', '三天后'),
('前三天', '后三天'),
]
for cfrom, cto in Cases:
_ts = time.time()
a = CNTime(cfrom)
b = CNTime(cto)
start, end = CNTime.Merge(a.guess_time(), b.guess_time())
print('from {} to {}, ({}, {})'.format(
a.desc_time(), b.desc_time(),
start, end,
))
_te = time.time()
print('Assumed: {}ms'.format(round((_te - _ts) * 1000)))
print('---')
def intents_who_time(self):
# 2 谁+时间
query = self.request.Message()
bdc = teamin.BizDocCount(self.request.AgentName, self.request.AgentUID)
executors = teamin.NameFindNames().ResolveName(self.request.UID(),
self.executor)
start = None
end = None
if hasattr(self, 'stime') and hasattr(self, 'etime'):
s = CNTime(self.stime)
e = CNTime(self.etime)
st, en = CNTime.Merge(s.guess_time(), e.guess_time())
logger.info('raw time {},{}'.format(st, en))
start, end = st, en
if hasattr(self, 'etime') and not hasattr(self, 'stime'):
time = CNTime(self.etime)
fromt, tot = time.guess_time()
logger.info('raw time {},{}'.format(fromt, tot))
start, end = fromt, tot
(count, weburl) = bdc.SpecifyDblSelect(query,
executors,
stime=start,
etime=end,
executors=executors)
self.intent.set_interval(int(start.timestamp() * 1000),
int(end.timestamp() * 1000), weburl)
return self.Response(count, weburl)
def intents_time_actions(self):
# 5 时间+行为
query = self.request.Message()
btc = teamin.BizTaskCount(self.request.AgentName,
self.request.AgentUID)
me = teamin.NameFindNames().ResolveName(self.request.UID(), self.me)
start = None
end = None
if hasattr(self, 'stime') and hasattr(self, 'etime'):
s = CNTime(self.stime)
e = CNTime(self.etime)
st, en = CNTime.Merge(s.guess_time(), e.guess_time())
logger.info('raw time {},{}'.format(st, en))
start, end = st, en
if hasattr(self, 'etime') and not hasattr(self, 'stime'):
time = CNTime(self.etime)
fromt, tot = time.guess_time()
logger.info('raw time {},{}'.format(fromt, tot))
start, end = fromt, tot
(count, finished,
expired), weburl = btc.SpecifyDblSelect(query,
me,
stime=start,
etime=end,
actions=self.actions)
if (start != None and end != None):
self.intent.set_interval(int(start.timestamp() * 1000),
int(end.timestamp() * 1000), weburl)
return self.Response(count, finished, expired, weburl)
def initSlots(self):
slots = self.intent.slots.filter(type__startswith='user_').all()
for slot in slots:
f = slot.type[5:]
if f == 'q':
self.slot_q = slot
elif f == 'tsk':
self.slot_tsk = slot
elif f == 'p':
self.slot_p = slot
elif f == 't':
self.slot_t = slot
elif f == 't2':
self.slot_t2 = slot
if hasattr(self, 'slot_p'):
self.cond_p = self.slot_p.original_word
if hasattr(self, 'slot_t'):
self.cond_t = CNTime(self.slot_t.original_word).guess_time()
if hasattr(self, 'slot_t2'):
t2 = CNTime(self.slot_t2.original_word).guess_time()
self.cond_t = CNTime.Merge(self.cond_t, t2)
def Go(self):
self.initSlots()
query = self.request.Message()
bdc = teamin.BizDocCount(self.request.AgentName, self.request.AgentUID)
if hasattr(self, 'creator'):
creator = teamin.NameFindNames().ResolveName(
self.request.UID(), self.creator)
count, weburl = bdc.SpecifyCreators(query, creator)
self.intent.set_interval(0, 0, weburl)
elif hasattr(self, 'stime') or hasattr(self, 'etime'):
me = teamin.NameFindNames().ResolveName(self.request.UID(),
self.me)
if hasattr(self, 'stime') and hasattr(self, 'etime'):
# 6号和7号
s = CNTime(self.stime)
e = CNTime(self.etime)
start, end = CNTime.Merge(s.guess_time(), e.guess_time())
# start = str(int(st.timestamp() * 1000))
# end = str(int(en.timestamp() * 1000))
if hasattr(self, 'etime') and not hasattr(self, 'stime'):
# endt:6号到7号
time = CNTime(self.etime)
start, end = time.guess_time()
logger.info('raw time {},{}'.format(start, end))
# start = str(int(fromt.timestamp()*1000))
# end = str(int(tot.timestamp()*1000))
logger.info('类型：s:{},e:{}'.format(type(str(start)),
type(str(end))))
logger.info('时间戳:{}~{}'.format(start, end))
count, weburl = bdc.SpecifyTime(query, start, end, me)
self.intent.set_interval(int(start.timestamp() * 1000),
int(end.timestamp() * 1000), weburl)
elif hasattr(self, 'actions'):
me = teamin.NameFindNames().ResolveName(self.request.UID(),
self.me)
count, weburl = bdc.SpecifyCreators(query, me)
self.intent.set_interval(0, 0, weburl)
return self.Response(count, weburl)
def Go(self):
self.initSlots()
query = self.request.Message()
btc = teamin.BizTaskCount(self.request.AgentName,
self.request.AgentUID)
slot = self.intent.slots.filter(type='user_tsk').first()
keyword = self.parse_keyword(self.intent, query, slot)
if hasattr(self, 'executor'):
executor = teamin.NameFindNames().ResolveName(
self.request.UID(), self.executor)
(count, finished,
expired), weburl = btc.SpecifyExecutors(query, executor)
self.intent.set_interval(0, 0, weburl)
elif hasattr(self, 'stime') or hasattr(self, 'etime'):
me = teamin.NameFindNames().ResolveName(self.request.UID(),
self.me)
start = None
end = None
if hasattr(self, 'stime') and hasattr(self, 'etime'):
s = CNTime(self.stime)
e = CNTime(self.etime)
st, en = CNTime.Merge(s.guess_time(), e.guess_time())
if st == None or en == None:
(count, finished, expired), weburl = btc.Deprecated(
self.request.UID(),
0,
0,
query,
keyword,
matcher.extract_watch(query),
)
self.intent.set_interval(0, 0, weburl)
start = st
end = en
if hasattr(self, 'etime') and not hasattr(self, 'stime'):
# endt:6号到7号
setime = CNTime(self.etime)
fromt, tot = setime.guess_time()
logger.info('raw time {},{}'.format(fromt, tot))
if fromt == None or tot == None:
(count, finished, expired), weburl = btc.Deprecated(
self.request.UID(),
0,
0,
query,
keyword,
matcher.extract_watch(query),
)
self.intent.set_interval(0, 0, weburl)
start = fromt
end = tot
logger.info('类型：s:{},e:{}'.format(type(str(start)),
type(str(end))))
logger.info('时间:{}~{}'.format(start, end))
(count, finished,
expired), weburl = btc.SpecifyTime(query, start, end, me)
if (start != None and end != None):
self.intent.set_interval(int(start.timestamp() * 1000),
int(end.timestamp() * 1000), weburl)
return self.Response(count, finished, expired, weburl)
elif hasattr(self, 'status'):
me = teamin.NameFindNames().ResolveName(self.request.UID(),
self.me)
(count, finished,
expired), weburl = btc.SpecifyStatus(query, self.status, me)
self.intent.set_interval(0, 0, weburl)
elif hasattr(self, 'actions'):
me = teamin.NameFindNames().ResolveName(self.request.UID(),
self.me)
(count, finished,
expired), weburl = btc.SpecifyActions(query, self.actions, me)
self.intent.set_interval(0, 0, weburl)
return self.Response(count, finished, expired, weburl)