def join_square(self, sqid):
if(
type(sqid) != int
):
return 'Eparameter'
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Euid'
sq = self.get_square_info_by_sqid(sqid)
if sq == None:
return 'Eno_such_sqid'
with TOJAuth.change_current_iden(self._idendesc):
sqobj = self.load_square(sqid)
result = sqobj.join_square(uid)
if result == self.JOIN_REJECT:
return 'Ereject'
elif result == self.JOIN_PENDING:
with TOJAuth.change_current_iden(self._idendesc):
self._set_user_square_relation(uid, sqid, False)
return {'active': False}
elif result == self.JOIN_ACCEPT:
with TOJAuth.change_current_iden(self._idendesc):
self._set_user_square_relation(uid, sqid, True)
return {'active': True}
else:
return 'Ejoin_sq_error'
def _create_problem(self, title, pmodid):
cur = self.db.cursor()
sqlstr = ('INSERT INTO "PROBLEM" ("title", "pmodid", "accessid") '
'VALUES (%s, %s, %s) RETURNING "proid";')
sqlarr = (title, pmodid, 0)
cur.execute(sqlstr, sqlarr)
proid = None
for data in cur:
proid = data[0]
if proid == None:
return None
user_idenid = TOJAuth.get_current_iden()['idenid']
with TOJAuth.change_current_iden(self._idendesc):
accessid = TOJAuth.instance.create_access(user_idenid)
sqlstr = ('UPDATE "PROBLEM" SET "accessid" = %s WHERE "proid" = %s;')
sqlarr = (accessid, proid)
cur.execute(sqlstr, sqlarr)
TOJAuth.instance.set_access_list(
accessid, TOJAuth.ROLEID_PROBLEM_ADMIN_GROUP,
TOJAuth.ACCESS_ALL
)
pmodname = self.get_pmodname_by_pmodid(pmodid)
pmod = mod.load_pmod(pmodname)
pmod.create_problem_data(proid)
return proid
def _send_log(self, data):
links = self._client_linkmap.keys()
with TOJAuth.change_current_iden(self._idendesc):
for link in links:
Proxy.instance.call_async(link + 'core/stat/', 'print_log',
10000, None, data)
def _create_problem(self, title, pmodid):
cur = self.db.cursor()
sqlstr = ('INSERT INTO "PROBLEM" ("title", "pmodid", "accessid") '
'VALUES (%s, %s, %s) RETURNING "proid";')
sqlarr = (title, pmodid, 0)
cur.execute(sqlstr, sqlarr)
proid = None
for data in cur:
proid = data[0]
if proid == None:
return None
user_idenid = TOJAuth.get_current_iden()['idenid']
with TOJAuth.change_current_iden(self._idendesc):
accessid = TOJAuth.instance.create_access(user_idenid)
sqlstr = ('UPDATE "PROBLEM" SET "accessid" = %s WHERE "proid" = %s;')
sqlarr = (accessid, proid)
cur.execute(sqlstr, sqlarr)
TOJAuth.instance.set_access_list(accessid,
TOJAuth.ROLEID_PROBLEM_ADMIN_GROUP,
TOJAuth.ACCESS_ALL)
pmodname = self.get_pmodname_by_pmodid(pmodid)
pmod = mod.load_pmod(pmodname)
pmod.create_problem_data(proid)
return proid
def set_testdata(self, testid, info, filekey = None, expire = None):
if expire != None:
expire = com.isoptime(expire)
if expire == None:
return 'Eparameter'
if(
type(testid) != int or
type(info) != str or
(filekey != None and type(filekey) != str)
):
return 'Eparameter'
with TOJAuth.change_current_iden(self._idendesc):
test = mod.TestdataMg.instance._get_testdata(testid)
if test == None:
return 'Etestid'
if test['proid'] != self._proid:
return 'Eother_proid'
result = self._set_testdata(testid, info, filekey, expire)
if result == None:
return 'Efailed'
if result == False:
return 'Eupload'
return 'Success'
def _create_square(self, title, sqmodid, intro, logo):
cur = self.db.cursor()
sqlstr = ('INSERT INTO "SQUARE" ("title", "hidden", "sqmodid", '
'"intro", "logo", "accessid") VALUES (%s, %s, %s, %s, '
'%s, %s) RETURNING "sqid";')
sqlarr = (title, False, sqmodid, intro, logo, 0)
cur.execute(sqlstr, sqlarr)
sqid = None
for data in cur:
sqid = data[0]
if sqid == None:
return None
user_idenid = TOJAuth.get_current_iden()['idenid']
with TOJAuth.change_current_iden(self._idendesc):
accessid = TOJAuth.instance.create_access(user_idenid)
sqlstr = ('UPDATE "SQUARE" SET "accessid" = %s WHERE "sqid" = %s;')
sqlarr = (accessid, sqid)
cur.execute(sqlstr, sqlarr)
TOJAuth.instance.set_access_list(
accessid, TOJAuth.ROLEID_SQUARE_ADMIN_GROUP,
TOJAuth.ACCESS_ALL
)
sqmodname = self.get_sqmodname_by_sqmodid(sqmodid)
sqmod = mod.load_sqmod(sqmodname)
sqmod.create_square_data(sqid)
return sqid;
def get_unseen_count(self):
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Euid'
with TOJAuth.change_current_iden(self._idendesc):
unseen_count = self._get_unseen_count(uid)
return {'unseen_count': unseen_count}
def get_unseen_count(self):
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Euid'
with TOJAuth.change_current_iden(self._idendesc):
unseen_count = self._get_unseen_count(uid)
return {'unseen_count': unseen_count}
def register(
self, username, password, nickname, email, avatar, aboutme, cover
):
if(
type(username) != str or
type(password) != str or
type(nickname) != str or
type(email) != str or
type(avatar) != str or
type(aboutme) != str or
type(cover) != str
):
return 'Eparameter'
if len(username) < self.USERNAME_LEN_MIN:
return 'Eusername_too_short'
elif len(username) > self.USERNAME_LEN_MAX:
return 'Eusername_too_long'
elif len(password) < self.PASSWORD_LEN_MIN:
return 'Epassword_too_short'
elif len(password) > self.PASSWORD_LEN_MAX:
return 'Epassword_too_long'
elif len(nickname) < self.NICKNAME_LEN_MIN:
return 'Enickname_too_short'
elif len(nickname) > self.NICKNAME_LEN_MAX:
return 'Enickname_too_long'
elif len(email) < self.EMAIL_LEN_MIN:
return 'Eemail_too_short'
elif len(email) > self.EMAIL_LEN_MAX:
return 'Eemail_too_long'
elif len(avatar) < self.AVATAR_LEN_MIN:
return 'Eavatar_too_short'
elif len(avatar) > self.AVATAR_LEN_MAX:
return 'Eavatar_too_long'
elif len(aboutme) < self.ABOUTME_LEN_MIN:
return 'Eaboutme_too_short'
elif len(aboutme) > self.ABOUTME_LEN_MAX:
return 'Eaboutme_too_long'
elif len(cover) < self.COVER_LEN_MIN:
return 'Ecover_too_short'
elif len(cover) > self.COVER_LEN_MAX:
return 'Ecover_too_long'
passhash = self._password_hash(password)
with TOJAuth.change_current_iden(self._idendesc):
try:
uid = self._create_user(
username, passhash, nickname, email, avatar, aboutme, cover
)
except psycopg2.IntegrityError:
return 'Eusername_exists'
return {'uid' : uid}
def _list_testdata(self):
TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)
with TOJAuth.change_current_iden(self._idendesc):
testdata_list = mod.TestdataMg.instance._list_testdata(self._proid)
for test in testdata_list:
del test['blobname']
del test['proid']
return testdata_list
def list_auth(self):
uid = self.get_current_uid()
if uid == None:
return 'Euid'
idenid = self.get_idenid_by_uid(uid)
with TOJAuth.change_current_iden(self._idendesc):
auth_list = TOJAuth.instance.get_user_auth_list(idenid)
return auth_list
def list_notice(self, start_index=0, list_num=NOTICE_LIST_NUM):
if (type(start_index) != int or type(list_num) != int):
return 'Eparameter'
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Euid'
with TOJAuth.change_current_iden(self._idendesc):
ret = self._list_notice(uid, start_index, list_num)
return ret
def read_notice(self, noticeid):
if (type(noticeid) != int):
return 'Eparameter'
notice = self.get_notice(noticeid)
if notice == None:
return 'Enoticeid'
with TOJAuth.change_current_iden(self._idendesc):
self.set_notice_unread(noticeid, False)
return 'Success'
def _create_testdata(self, info, filekey, expire):
TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)
# Upload file
blobname = 'TEST_BLOBNAME'
with TOJAuth.change_current_iden(self._idendesc):
testid = mod.TestdataMg.instance._add_testdata(
blobname, expire, self._proid, info)
return testid
def del_notice(self, noticeid):
if (type(noticeid) != int):
return 'Eparameter'
notice = self.get_notice(noticeid)
if notice == None:
return 'Enoticeid'
with TOJAuth.change_current_iden(self._idendesc):
self._del_notice(noticeid)
self.notify_client(notice['uid'])
return 'Success'
def read_notice(self, noticeid):
if(
type(noticeid) != int
):
return 'Eparameter'
notice = self.get_notice(noticeid)
if notice == None:
return 'Enoticeid'
with TOJAuth.change_current_iden(self._idendesc):
self.set_notice_unread(noticeid, False)
return 'Success'
def del_mail(self, mailid):
if(
type(mailid) != int
):
return 'Eparameter'
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Eno_uid'
with TOJAuth.change_current_iden(self._idendesc):
mail = self._get_mail(mailid)
if mail == None:
return 'Eno_such_mailid'
if mail['to_uid'] != uid:
TOJAuth.check_access(
self._accessid, TOJAuth.ACCESS_EXECUTE)(lambda x:x)(0)
with TOJAuth.change_current_iden(self._idendesc):
self._del_mail(mailid)
return 'Success'
def quit_square(self, sqid):
if(
type(sqid) != int
):
return 'Eparameter'
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Euid'
sq = self.get_square_info_by_sqid(sqid)
if sq == None:
return 'Eno_such_sqid'
with TOJAuth.change_current_iden(self._idendesc):
sqobj = self.load_square(sqid)
sqobj.quit_square(uid)
with TOJAuth.change_current_iden(self._idendesc):
self._del_user_square_relation(uid, sqid)
return 'Success'
def get_mail_count(self, mail_type = None):
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Eno_uid'
with TOJAuth.change_current_iden(self._idendesc):
tot_count = self._get_mail_count(uid, None, mail_type)
unread_count = self._get_mail_count(uid, True, mail_type)
ret = {
'tot_count': tot_count,
'unread_count': unread_count
}
return ret
def del_notice(self, noticeid):
if(
type(noticeid) != int
):
return 'Eparameter'
notice = self.get_notice(noticeid)
if notice == None:
return 'Enoticeid'
with TOJAuth.change_current_iden(self._idendesc):
self._del_notice(noticeid)
self.notify_client(notice['uid'])
return 'Success'
def list_notice(self, start_index = 0, list_num = NOTICE_LIST_NUM):
if(
type(start_index) != int or
type(list_num) != int
):
return 'Eparameter'
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Euid'
with TOJAuth.change_current_iden(self._idendesc):
ret = self._list_notice(uid, start_index, list_num)
return ret
def _create_user(
self, username, passhash, nickname, email, avatar, aboutme, cover
):
roleid = TOJAuth.instance.create_role(username, TOJAuth.ROLETYPE_USER)
with TOJAuth.change_current_iden(self._idendesc):
TOJAuth.instance.set_role_relation(
roleid, TOJAuth.ROLEID_USER_GROUP)
cur = self.db.cursor()
sqlstr = ('INSERT INTO "USER" ("username", "passhash", "nickname", '
'"email", "avatar", "aboutme", "cover", "idenid") '
'VALUES (%s, %s, %s, %s, %s, %s, %s, %s) RETURNING "uid";')
sqlarr = (
username, passhash, nickname, email, avatar, aboutme, cover, roleid
)
cur.execute(sqlstr, sqlarr)
for data in cur:
uid = data[0]
with TOJAuth.change_current_iden(self._idendesc):
mod.Notice.create_unseen_count(uid)
return uid
def view(self):
with TOJAuth.change_current_iden(self._idendesc):
mode = self._get_mode_by_modeid(1)
if mode == None:
return 'Emodeid'
testmode = self._get_testmode_info(mode['testmodeid'])
ret = {
'content':mode['content'],
'timelimit':testmode['timelimit'],
'memlimit':testmode['memlimit']
}
return ret
def login(self, username, password):
if(
type(username) != str or
type(password) != str
):
return 'Eparameter'
uid = self.get_uid_by_username(username)
if uid == None:
return 'Elogin_failed'
passhash = self._password_hash(password)
cur = self.db.cursor()
sqlstr = ('SELECT "idenid" FROM "USER" WHERE "uid" = %s '
'AND "passhash" = %s;')
sqlarr = (uid, passhash)
cur.execute(sqlstr, sqlarr)
idenid = None
for data in cur:
idenid = data[0]
if idenid == None:
return 'Elogin_failed'
client_link = TOJAuth.get_current_iden()['link']
with TOJAuth.change_current_iden(self._idendesc):
stat,data = Proxy.instance.call(self.get_link('center') + 'core/',
'create_iden',
10000,
client_link,
idenid,
TOJAuth.ROLETYPE_USER,
{'uid' : uid})
if stat == False:
return 'Einternal'
ret = {
'idendesc' : data,
'uid' : uid,
'hash' : self._uid_passhash_hash(uid, passhash)
}
return ret
def list_mail(
self, mail_type, start_index = 1, end_index = LIST_ITEM_PER_PAGE
):
if(
type(mail_type) != int
):
return 'Eparameter'
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Eno_uid'
with TOJAuth.change_current_iden(self._idendesc):
maillist = self._get_maillist(
uid, mail_type, start_index, end_index)
return maillist
def cookie_login(self, uid, uphash):
if(
type(uid) != int or
type(uphash) != str
):
return 'Eparameter'
idenid = None
real_uphash = None
cur = self.db.cursor()
sqlstr = ('SELECT "idenid", "passhash" FROM "USER" WHERE "uid" = %s;')
sqlarr = (uid, )
cur.execute(sqlstr, sqlarr)
for data in cur:
idenid = data[0]
real_uphash = self._uid_passhash_hash(uid, data[1])
if idenid == None:
return 'Elogin_failed'
if real_uphash != uphash:
return 'Elogin_failed'
client_link = TOJAuth.get_current_iden()['link']
with TOJAuth.change_current_iden(self._idendesc):
stat,data = Proxy.instance.call(self.get_link('center') + 'core/',
'create_iden',
10000,
client_link,
idenid,
TOJAuth.ROLETYPE_USER,
{'uid' : uid})
if stat == False:
return 'Einternal'
ret = {
'idendesc' : data,
'uid' : uid,
'hash' : uphash
}
return ret
def delete_testdata(self, testid):
if(
type(testid) != int
):
return 'Eparameter'
with TOJAuth.change_current_iden(self._idendesc):
test = mod.TestdataMg.instance._get_testdata(testid)
if test == None:
return 'Etestid'
if test['proid'] != self._proid:
return 'Eother_proid'
self._delete_testdata(testid)
return 'Success'
def _delete_problem(self, proid):
accessid = self.get_accessid_by_proid(proid)
TOJAuth.check_access_func(accessid, TOJAuth.ACCESS_DELETE)
proinfo = self.get_problem_info_by_proid(proid)
pmodname = proinfo['pmodname']
pmod = mod.load_pmod(pmodname)
with TOJAuth.change_current_iden(self._idendesc):
self.unload_problem(proid)
pmod.delete_problem_data(proid)
TOJAuth.instance.del_access(accessid)
cur = self.db.cursor()
sqlstr = ('DELETE FROM "PROBLEM" WHERE "proid" = %s;')
sqlarr = (proid, )
cur.execute(sqlstr, sqlarr)
def _delete_problem(self, proid):
accessid = self.get_accessid_by_proid(proid)
TOJAuth.check_access_func(accessid, TOJAuth.ACCESS_DELETE)
proinfo = self.get_problem_info_by_proid(proid)
pmodname = proinfo['pmodname']
pmod = mod.load_pmod(pmodname)
with TOJAuth.change_current_iden(self._idendesc):
self.unload_problem(proid)
pmod.delete_problem_data(proid)
TOJAuth.instance.del_access(accessid)
cur = self.db.cursor()
sqlstr = ('DELETE FROM "PROBLEM" WHERE "proid" = %s;')
sqlarr = (proid, )
cur.execute(sqlstr, sqlarr)
def get_testdata(self, testid):
if(
type(testid) != int
):
return 'Eparameter'
TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)
with TOJAuth.change_current_iden(self._idendesc):
test = mod.TestdataMg.instance._get_testdata(testid)
if test == None:
return 'Etestid'
if test['proid'] != self._proid:
return 'Eother_proid'
del test['blobname']
del test['proid']
return test
def send_mail(self, to_username, title, content):
if(
type(to_username) != str or
type(title) != str or
type(content) != str
):
return 'Eparameter'
if len(title) < self.TITLE_LEN_MIN:
return 'Etitle_too_short'
elif len(title) > self.TITLE_LEN_MAX:
return 'Etitle_too_long'
elif len(content) < self.CONTENT_LEN_MIN:
return 'Econtent_too_short'
elif len(content) > self.CONTENT_LEN_MAX:
return 'Econtent_too_long'
to_uid = mod.UserMg.get_uid_by_username(to_username)
if to_uid == None:
return 'Eto_username'
uid = mod.UserMg.get_current_uid()
if uid == None:
return 'Euid'
with TOJAuth.change_current_iden(self._idendesc):
self._add_mail(
to_uid, uid, self.MAIL_TYPE_INBOX, True, title, content
)
self._add_mail(
uid, to_uid, self.MAIL_TYPE_SENT_BACKUP, False, title, content
)
username = mod.UserMg.get_user_info_by_uid(uid)['username']
mod.Notice.send_notice(
to_uid, 'Mail From ' + username, title, None, '/mail/inbox/'
)
self.notify_client(uid)
self.notify_client(to_uid)
return 'Success'
def _delete_square(self, sqid):
accessid = self.get_accessid_by_sqid(sqid)
TOJAuth.check_access_func(accessid, TOJAuth.ACCESS_DELETE)
sqinfo = self.get_square_info_by_sqid(sqid)
sqmodname = sqinfo['sqmodname']
sqmod = mod.load_sqmod(sqmodname)
with TOJAuth.change_current_iden(self._idendesc):
self.unload_square(sqid)
sqmod.delete_square_data(sqid)
TOJAuth.instance.del_access(accessid)
cur = self.db.cursor()
sqlstr = ('DELETE FROM "SQUARE" WHERE "sqid" = %s;')
sqlarr = (sqid, )
cur.execute(sqlstr, sqlarr)
sqlstr = ('DELETE FROM "SQUARE_USER" WHERE "sqid" = %s;')
sqlarr = (sqid, )
cur.execute(sqlstr, sqlarr)
def pmod_filter(self, res_path, dst_func):
proid = int(res_path[0])
with TOJAuth.change_current_iden(self._idendesc):
self.load_problem(proid)
def _delete_testdata(self, testid):
TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_DELETE)
with TOJAuth.change_current_iden(self._idendesc):
mod.TestdataMg.instance._del_testdata(testid)
def pmod_filter(self, res_path, dst_func):
proid = int(res_path[0])
with TOJAuth.change_current_iden(self._idendesc):
self.load_problem(proid)
def _conn_link(self, link):
def __handle_pend(conn):
try:
retids = self._pend_mainconn_linkmap.pop(worker_link)
except KeyError:
return
for retid in retids:
imc. async .ret(retid, conn)
def __conn_cb():
conn = Proxy.instance.get_conn(worker_link)
if conn != None:
__handle_pend(conn)
main_stream.set_close_callback(None)
main_stream.close()
else:
sock_ip, sock_port = self.sock_addr
netio.send_pack(
main_stream,
bytes(
json.dumps({
'conntype': 'main',
'link': self._link,
'sock_ip': sock_ip,
'sock_port': sock_port
}), 'utf-8'))
netio.recv_pack(main_stream, __recv_cb)
def __recv_cb(data):
stat = json.loads(data.decode('utf-8'))
if stat == True:
conn = SocketConnection(worker_link, main_stream, sock_addr,
self.pend_filestream,
self.del_pend_filestream)
Proxy.instance.add_conn(conn)
__handle_pend(conn)
else:
main_stream.set_close_callback(None)
main_stream.close()
if self.center_conn == None:
return None
with TOJAuth.change_current_iden(self._idendesc):
stat, ret = Proxy.instance.call(self.center_conn.link + 'core/',
'lookup_link', 65536, link)
if stat == False or ret == None:
return None
else:
worker_link = ret['worker_link']
conn = Proxy.instance.get_conn(worker_link)
if conn != None:
return conn
elif worker_link in self._pend_mainconn_linkmap:
self._pend_mainconn_linkmap[worker_link].append(
imc. async .get_retid())
return imc. async .switch_top()
else:
self._pend_mainconn_linkmap[worker_link] = [
imc. async .get_retid()
]
sock_addr = (ret['sock_ip'], ret['sock_port'])
main_stream = SocketStream(
socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0))
main_stream.set_close_callback(
lambda conn: __handle_pend(None))
main_stream.connect(sock_addr, __conn_cb)
return imc. async .switch_top()
def _test_call(self,param):
with TOJAuth.change_current_iden(self._idendesc):
ret = Proxy.instance.call('/backend/3/test/','test_dst',1000,'Hello')
print(ret)
'''
def _call():
with TOJAuth.change_current_iden(self._idendesc):
Proxy.instance.call(self.center_conn.link + 'core/','add_client',10000,link,self._link)
def _call():
with TOJAuth.change_current_iden(self._idendesc):
Proxy.instance.call(self.center_conn.link + 'core/',
'del_client', 10000, link, self._link)
def _set_testdata(self, testid, info, filekey, expire):
TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)
with TOJAuth.change_current_iden(self._idendesc):
test = mod.TestdataMg.instance._get_testdata(testid)
blobname = test['blobname']
if test['proid'] != self._proid:
return None
if filekey != None:
# Upload file
# Update blob 'blobname'
# If failed return False
with TOJAuth.change_current_iden(self._idendesc):
mod.TestdataMg.instance._update_testdata(
testid, blobname, expire, self._proid, info)
return True
@imc.async.caller
def set_testmode_testdata(self, testmodeid, testdata):
if(
type(testmodeid) != int or
type(testdata) != list
):
return 'Eparameter'
for test in testdata:
if type(test) != list:
return 'Eparameter'
if(
'testid' not in test or
type(test['testid']) != int or
'timelimit' not in test or
type(test['timelimit']) != int or
'memlimit' not in test or
type(test['memlimit']) != int or
'subtask' not in test or
type(test['subtask']) != int
):
return 'Eparameter'
if test['timelimit'] != None and test['timelimit'] < 0:
return 'Etimelimit'
if test['memlimit'] != None and test['memlimit'] < 0:
return 'Ememlimit'
if not self._does_testmodeid_exist(testmodeid):
return 'Etestmodeid'
self._set_testdata(testmodeid, testdata)
return 'Success'
def _set_testmode_testdata(self, testmodeid, testdata):
TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)
cur = self.db.cursor()
sqlstr = ('DELETE FROM "PMOD_TEST_TESTDATA" WHERE "proid" = %s AND '
'"testmodeid" = %s;')
sqlarr = (self._proid, testmodeid)
cur.execute(sqlstr, sqlarr)
if len(testdata) == 0:
return
sqltab = ('INSERT INTO "PMOD_TEST_TESTDATA" ("proid", "testmodeid", '
'"order", "testid", "timelimit", "memlimit", "subtask") '
'VALUES')
sqlval = ()
sqlend = (';')
sqlarr = []
cnt = 0
for test in testdata:
if cnt == 0:
sqlval = sqlval + ' '
else:
sqlval = sqlval + ', '
cnt = cnt + 1
sqlval = sqlval + '(%s, %s, %s, %s, %s, %s, %s)'
sqlarr.append(self._proid)
sqlarr.append(testmodeid)
sqlarr.append(cnt)
sqlarr.append(test['testid'])
sqlarr.append(test['timelimit'])
sqlarr.append(test['memlimit'])
sqlarr.append(test['subtask'])
sqlstr = sqltab + sqlval + sqlend
cur.execute(sqlstr, sqlarr)
@imc.async.caller
def get_testmode_testdata(self, testmodeid):
if(
type(testmodeid) != int
):
return 'Eparameter'
if not self._does_testmodeid_exist(testmodeid):
return 'Etestmodeid'
testdata = self._get_testdata(testmodeid)
return testdata
def _get_testmode_testdata(self, testmodeid):
TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)
cur = self.db.cursor()
sqlstr = ('SELECT "order", "testid", "timelimit", "memlimit", '
'"subtask" FROM "PMOD_TEST_TESTDATA" WHERE "proid" = %s AND '
'"testmodeid" = %s ORDER BY "order" ASC;')
sqlarr = (self._proid, testmodeid)
cur.execute(sqlstr, sqlarr)
testdata = []
for data in cur:
obj = {}
obj['order'] = data[0]
obj['testid'] = data[1]
obj['timelimit'] = data[2]
obj['memlimit'] = data[3]
obj['subtask'] = data[4]
testdata.append(obj)
return testdata
def _does_modeid_exist(self, modeid):
mode = self._get_mode_by_modeid(modeid)
return mode != None
def _get_mode_by_modeid(self, modeid):
TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)
cur = self.db.cursor()
sqlstr = ('SELECT "proid", "modeid", "content", "testmodeid" FROM '
'"PMOD_TEST_MODE" WHERE "proid" = %s AND "modeid" = %s;')
sqlarr = (self._proid, modeid)
cur.execute(sqlstr, sqlarr)
mode = None
for data in cur:
mode = {}
mode['proid'] = data[0]
mode['modeid'] = data[1]
mode['content'] = data[2]
mode['testmodeid'] = data[3]
return mode
def _does_testmodeid_exist(self, testmodeid):
testmode_info = self._get_testmode_info(testmodeid)
return testmode_info != None
def _get_testmode_info(self, testmodeid):
TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_WRITE)
cur = self.db.cursor()
sqlstr = ('SELECT "proid", "testmodeid", "testmodename", "timelimit",'
' "memlimit" FROM "PMOD_TEST_TESTMODE" WHERE "proid" = %s '
'AND "testmodeid" = %s;')
sqlarr = (self._proid, testmodeid)
cur.execute(sqlstr, sqlarr)
testmode_info = None
for data in cur:
testmode_info = {}
testmode_info['proid'] = data[0]
testmode_info['testmodeid'] = data[1]
testmode_info['testmodename'] = data[2]
testmode_info['timelimit'] = data[3]
testmode_info['memlimit'] = data[4]
return testmode_info
def _test_call(self, param):
with TOJAuth.change_current_iden(self._idendesc):
ret = Proxy.instance.call('/backend/3/test/', 'test_dst', 1000,
'Hello')
print(ret)
'''
