Add notice. Done profile page

author: pzread <netfirewall@gmail.com> 2013-06-22 18:55:10 +0800
committer: pzread <netfirewall@gmail.com> 2013-06-22 18:55:10 +0800
commit: e0043639746fdbbf4958c67a3ef55c63c2fe51a5 (patch)
tree: bf553445c16ad67b56fd26403057428c4e6dd4af /src/py
parent: a66de70527978a4510c6e230fcc56ce890bf20a2 (diff)
download: taiwan-online-judge-e0043639746fdbbf4958c67a3ef55c63c2fe51a5.tar.gz
taiwan-online-judge-e0043639746fdbbf4958c67a3ef55c63c2fe51a5.tar.zst
taiwan-online-judge-e0043639746fdbbf4958c67a3ef55c63c2fe51a5.zip
7 files changed, 698 insertions, 60 deletions
diff --git a/src/py/backend_server.py b/src/py/backend_server.py
index 197d820..b9bb07b 100755
--- a/src/py/backend_server.py
+++ b/src/py/backend_server.py
@@ -14,12 +14,14 @@ import tornado.websocket
 
 from imc import auth
 import imc.async
-from imc.proxy import Proxy,Connection,imc_call,imc_call_async,imc_register_call
+from imc.proxy import Proxy,Connection
 
 import netio
 from netio import SocketStream,SocketConnection,WebSocketConnection
 from tojauth import TOJAuth
-import mod
+from notice import Notice
+from user import UserMg
+from mail import Mail
 
 class BackendWorker(tornado.tcpserver.TCPServer):
     def __init__(self,center_addr,ws_port):
@@ -113,8 +115,15 @@ class BackendWorker(tornado.tcpserver.TCPServer):
                 Proxy.instance.register_call('test/','test_dst',self._test_dst)
                 #Proxy.instance.register_filter('test/',self._test_filter)
 
-                mod.load('core_user','user',self._idendesc,self._get_link)
-                mod.load('core_mail','mail',self._idendesc,self._get_link)
+                try:
+                    Notice(self._idendesc,self._get_link)
+                    UserMg(self._idendesc,self._get_link)
+                    Mail(self._idendesc,self._get_link)
+                except Exception as e:
+                    print(e)
+
+                #mod.load('core_user','user',self._idendesc,self._get_link)
+                #mod.load('core_mail','mail',self._idendesc,self._get_link)
 
                 #if self._link == '/backend/2/':
                 #    self._test_call(None)
@@ -178,6 +187,9 @@ class BackendWorker(tornado.tcpserver.TCPServer):
         with TOJAuth.change_current_iden(self._idendesc):
             stat,ret = Proxy.instance.call(self.center_conn.link,'lookup_link',65536,link)
 
+        print(link)
+        print(ret)
+
         if stat == False or ret == None:
             return None
 
@@ -236,10 +248,15 @@ class BackendWorker(tornado.tcpserver.TCPServer):
         except KeyError:
             pass
 
-    def _get_link(self,linkclass):
+    def _get_link(self,linkclass,uid = None):
         if linkclass == 'center':
             return self.center_conn.link
 
+        elif linkclass == 'client' and uid != None:
+            stat,ret = Proxy.instance.call(self.center_conn.link + 'core/','get_uid_clientlink',10000,uid)
+            print(ret)
+            return ret
+
     @imc.async.caller
     def _test_get_client_list(self,talk,talk2):
         stat,ret = Proxy.instance.call(TOJAuth.get_current_iden()['link'] + 'test/route/','80s',1000,'attation','mega')
@@ -262,18 +279,13 @@ class BackendWorker(tornado.tcpserver.TCPServer):
                     continue
 
                 fileres = Proxy.instance.sendfile(dst,'Fedora-18-x86_64-DVD.iso')
-                ret = imc_call_async(dst + 'test/','test_dst',lambda result: print('ok'),fileres.filekey)
+                ret = Proxy.instance.call_async(dst + 'test/','test_dst',lambda result: print('ok'),fileres.filekey)
                 
                 print(fileres.wait())
 
             print(time.perf_counter() - st)
             print(self._link)
 
-        #imc_call_async(dst,'test_dst',lambda result : print(result),'test',113)
-
-        #ret = imc_call('/center/1/','create_iden','client','1234',1221,TOJAuth.ROLETYPE_USER,{'uid':31})
-        #print(ret)
-
         return
 
         pend = []
@@ -284,7 +296,7 @@ class BackendWorker(tornado.tcpserver.TCPServer):
             fileres = Proxy.instance.sendfile('/backend/' + str((i % 16) + 2) + '/','Fedora-18-x86_64-DVD.iso')
             
             dst = '/backend/' + str((i % 16) + 2) + '/'
-            ret = imc_call(self._idendesc,dst,'test_dst',fileres.filekey)
+            ret = Proxy.instance.call(self._idendesc,dst,'test_dst',fileres.filekey)
 
             pend.append(fileres)
 
diff --git a/src/py/center_server.py b/src/py/center_server.py
index 1f67c9d..bed117d 100755
--- a/src/py/center_server.py
+++ b/src/py/center_server.py
@@ -11,7 +11,7 @@ import tornado.httpserver
 import tornado.web
 
 import imc.async
-from imc.proxy import Proxy,Connection,imc_call,imc_call_async,imc_register_call
+from imc.proxy import Proxy,Connection
 
 import netio
 from netio import SocketStream,SocketConnection
@@ -62,6 +62,7 @@ class CenterServer(tornado.tcpserver.TCPServer):
         self._client_linkmap = {}
         self._client_backendmap = {}
         self._backend_workerlist = []
+        self._uid_clientmap = {}
 
         pubkey = open('pubkey.pem','r').read()
         privkey = open('privkey.pem','r').read()
@@ -72,12 +73,13 @@ class CenterServer(tornado.tcpserver.TCPServer):
         self._idendesc = TOJAuth.instance.create_iden(self._link,1,TOJAuth.ROLETYPE_TOJ)
         Proxy(self._link,TOJAuth.instance,self._idendesc)
 
-        imc_register_call('','lookup_link',self._lookup_link)
-        imc_register_call('','create_iden',self._create_iden)
-        imc_register_call('','add_client',self._add_client)
-        imc_register_call('','del_client',self._del_client)
+        Proxy.instance.register_call('','lookup_link',self._lookup_link)
+        Proxy.instance.register_call('','create_iden',self._create_iden)
+        Proxy.instance.register_call('','add_client',self._add_client)
+        Proxy.instance.register_call('','del_client',self._del_client)
+        Proxy.instance.register_call('core/','get_uid_clientlink',self._get_uid_clientlink)
         
-        imc_register_call('test/','get_client_list',self._test_get_client_list)
+        Proxy.instance.register_call('test/','get_client_list',self._test_get_client_list)
 
     def handle_stream(self,stream,addr):
         def _recv_worker_info(data):
@@ -150,18 +152,30 @@ class CenterServer(tornado.tcpserver.TCPServer):
             #else:
             #    worker = self._worker_linkidmap[str(a - 1)]
 
-            linkclass = TOJAuth.get_current_iden()['link'].split('/',2)[1]
-            if linkclass != 'client':
-                worker = self._worker_linkmap[link]
-                
-                sock_ip,sock_port = worker.sock_addr
-                return {
-                    'worker_link':worker.link,
-                    'sock_ip':sock_ip,
-                    'sock_port':sock_port
-                }
+            if TOJAuth.get_current_iden()['link'].split('/')[1] != 'client':
+                linkclass,linkid = link.split('/')[1:3]
+
+                if linkclass == 'client':
+                    backend_link = self._client_linkmap[link]['backend_link']
+                    worker = self._worker_linkmap[backend_link]
+                    
+                    sock_ip,sock_port = worker.sock_addr
+                    return {
+                        'worker_link':worker.link,
+                        'sock_ip':sock_ip,
+                        'sock_port':sock_port
+                    }
+
+                else:
+                    worker = self._worker_linkmap[link]
+                    
+                    sock_ip,sock_port = worker.sock_addr
+                    return {
+                        'worker_link':worker.link,
+                        'sock_ip':sock_ip,
+                        'sock_port':sock_port
+                    }
 
-            else:
                 return None
 
         except KeyError:
@@ -170,13 +184,27 @@ class CenterServer(tornado.tcpserver.TCPServer):
     @imc.async.caller
     @TOJAuth.check_access(1,TOJAuth.ACCESS_EXECUTE)
     def _create_iden(self,link,idenid,roletype,payload):
+        linkclass = link.split('/')[1]
+        if linkclass == 'client' and roletype == TOJAuth.ROLETYPE_USER:
+            uid = payload['uid']
+            client = self._client_linkmap[link]
+            client['uid'] = uid
+            
+            if uid not in self._uid_clientmap:
+                self._uid_clientmap[uid] = {link:client} 
+
+            else:
+                self._uid_clientmap[uid][link] = client 
+
         return TOJAuth.instance.create_iden(link,idenid,roletype,payload)
         
     @imc.async.caller
     @TOJAuth.check_access(1,TOJAuth.ACCESS_EXECUTE)
     def _add_client(self,client_link,backend_link):
         self._client_linkmap[client_link] = {
-            'backend_link':backend_link
+            'client_link':client_link,
+            'backend_link':backend_link,
+            'uid':None
         }
         self._client_backendmap[backend_link].add(client_link)
         
@@ -188,13 +216,28 @@ class CenterServer(tornado.tcpserver.TCPServer):
     @imc.async.caller
     @TOJAuth.check_access(1,TOJAuth.ACCESS_EXECUTE)
     def _del_client(self,client_link,backend_link):
+        uid = self._client_linkmap[client_link]['uid']
+
+        if uid != None:
+            clients = self._uid_clientmap[uid]
+            del clients[client_link]
+
+            if len(clients) == 0:
+                del self._uid_clientmap[uid]
+        
         del self._client_linkmap[client_link]
         self._client_backendmap[backend_link].remove(client_link)
 
         Proxy.instance.unlink_conn(client_link)
 
+    @imc.async.caller
+    def _get_uid_clientlink(self,uid):
+        if uid in self._uid_clientmap:
+            clients = self._uid_clientmap[uid]
 
+            return list(clients.keys())
 
+        return []
 
     @imc.async.caller
     def _test_get_client_list(self,talk,talk2):
diff --git a/src/py/imc/proxy.py b/src/py/imc/proxy.py
index 8f750c0..da4bfd4 100755
--- a/src/py/imc/proxy.py
+++ b/src/py/imc/proxy.py
@@ -621,12 +621,3 @@ class Proxy:
     def _abort_sendfile(self,filekey):
         if filekey in self._info_filekeymap:
             self._ioloop.add_callback(self._ret_sendfile,filekey,'Eabort')
-
-def imc_call(dst,func_name,*args):
-    return Proxy.instance.call(dst,func_name,65536,*args)
-
-def imc_call_async(dst,func_name,callback,*args):
-    Proxy.instance.call_async(dst,func_name,65536,callback,*args)
-
-def imc_register_call(path,func_name,func):
-    Proxy.instance.register_call(path,func_name,func)
diff --git a/src/py/mail.py b/src/py/mail.py
index d3e2fd6..aa01dd6 100644
--- a/src/py/mail.py
+++ b/src/py/mail.py
@@ -1,6 +1,7 @@
 from tojauth import TOJAuth
 from asyncdb import AsyncDB
 from user import UserMg
+from notice import Notice
 from imc.proxy import Proxy
 import imc.proxy
 import config
@@ -70,7 +71,12 @@ class Mail:
             self._add_mail(
                 uid, to_uid, self.MAIL_TYPE_SENT_BACKUP, False, title, content
             )
-
+            username = UserMg.instance.get_user_info_by_uid(uid)['username']
+            Notice.instance.send_notice(
+                to_uid, 'Mail From ' + username, title, None, '/mail/inbox/'
+            )
+            self.notify_client(uid)
+            self.notify_client(to_uid)
 
     @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
     def _add_mail(self, uid, from_uid, mail_type, unread, title, content):
@@ -254,6 +260,13 @@ class Mail:
             count = data[0]
 
         return count
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
+    def notify_client(self, uid):
+        for link in self.get_link('client', uid = uid):
+            Proxy.instance.call_async(
+                link + 'core/mail/', 'update_mail', 10000, None
+            )
     
 def load(mod_idendesc, get_link_fn):
     Mail(mod_idendesc, get_link_fn)
diff --git a/src/py/notice.py b/src/py/notice.py
new file mode 100644
index 0000000..3a0a988
--- /dev/null
+++ b/src/py/notice.py
@@ -0,0 +1,236 @@
+from tojauth import TOJAuth
+from asyncdb import AsyncDB
+
+from imc.proxy import Proxy
+import imc.proxy
+import config
+
+class Notice:
+    _accessid = 5
+
+    NOTICE_LIST_NUM = 10
+
+    def __init__(self, mod_idendesc, get_link_fn):
+        Notice.instance = self
+        Notice.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER, 
+                            config.CORE_DBPASSWORD)
+        Notice._idendesc = mod_idendesc
+        self.get_link = get_link_fn
+
+        Proxy.instance.register_call(
+            'core/notice/', 'list_notice', self.list_notice)
+        Proxy.instance.register_call(
+            'core/notice/', 'read_notice', self.read_notice)
+        Proxy.instance.register_call(
+            'core/notice/', 'del_notice', self.del_notice)
+        Proxy.instance.register_call(
+            'core/notice/', 'get_unseen_count', self.get_unseen_count)
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
+    def send_notice(self, uid, title, content, noticemod_path, metadata):
+        cur = self.db.cursor()
+
+        noticemodid = None
+
+        if noticemod_path != None: 
+            sqlstr = ('SELECT "noticemodid" FROM "NOTICEMOD" WHERE "path" '
+                      '= %s;')
+            sqlarr = (noticemod_path, )
+            cur.execute(sqlstr, sqlarr)
+
+            for data in cur:
+                noticemodid = data[0]
+
+            if noticemodid == None:
+                sqlstr = ('INSERT INTO "NOTICEMOD" ("path") VALUES (%s) '
+                          'RETURNING "noticemodid";')
+                sqlarr = (noticemod_path, )
+                cur.execute(sqlstr, sqlarr)
+                for data in cur:
+                    noticemodid = data[0]
+
+        sqlstr = ('INSERT INTO "NOTICE" ("uid", "title", "content", '
+                  '"noticemodid", "metadata") VALUES (%s, %s, %s, %s, %s) '
+                  'RETURNING "noticeid";')
+        sqlarr = (uid, title, content, noticemodid, metadata)
+        cur.execute(sqlstr, sqlarr)
+
+        noticeid = None
+        for data in cur:
+            noticeid = data[0]
+
+        unseen_count = self._get_unseen_count(uid)
+        self.set_unseen_count(uid, unseen_count + 1)
+
+        return noticeid
+
+    @imc.async.caller
+    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'])
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
+    def _del_notice(self, noticeid):    
+        cur = self.db.cursor()
+        sqlstr = ('DELETE FROM "NOTICE" WHERE "noticeid" = %s;')
+        sqlarr = (noticeid, )
+        cur.execute(sqlstr, sqlarr)
+    
+    @imc.async.caller
+    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 = 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
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
+    def _list_notice(self, uid, start_index, list_num):
+        cur = self.db.cursor()
+        sqlstr = ('SELECT "noticeid", "title", "content", "time", '
+                  '"noticemodid", "metadata", "unread" FROM "NOTICE" WHERE '
+                  '"uid" = %s ORDER BY "noticeid" DESC LIMIT %s OFFSET %s;')
+        sqlarr = (uid, list_num, start_index)
+        cur.execute(sqlstr, sqlarr)
+
+        ret = []
+        for data in cur:
+            obj = {}
+            obj['noticeid'] = data[0]
+            obj['title'] = data[1]
+            obj['content'] = data[2]
+            obj['time'] = data[3]
+            obj['noticemodid'] = data[4]
+            obj['metadata'] = data[5]
+            obj['unread'] = data[6]
+            ret.append(obj)
+
+        self.set_unseen_count(uid, 0)
+
+        return ret
+
+    @imc.async.caller
+    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)
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
+    def set_notice_unread(self, noticeid, unread):
+        cur = self.db.cursor()
+        sqlstr = ('UPDATE "NOTICE" SET "unread" = %s WHERE "noticeid" = %s;')
+        sqlarr = (unread, noticeid)
+        cur.execute(sqlstr, sqlarr)
+
+    @imc.async.caller
+    def get_unseen_count(self):
+        uid = 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}
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
+    def _get_unseen_count(self, uid):
+        cur = self.db.cursor()
+        sqlstr = ('SELECT "unseen_count" FROM "NOTICE_UNSEEN" WHERE '
+                  '"uid" = %s;')
+        sqlarr = (uid, )
+        cur.execute(sqlstr, sqlarr)
+
+        unseen_count = None
+        for data in cur:
+            unseen_count = data[0]
+
+        return unseen_count
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
+    def set_unseen_count(self, uid, unseen_count):
+        old_unseen_count = self._get_unseen_count(uid)
+
+        cur = self.db.cursor()
+        sqlstr = ('UPDATE "NOTICE_UNSEEN" SET "unseen_count" = %s WHERE '
+                  '"uid" = %s;')
+        sqlarr = (unseen_count, uid)
+        cur.execute(sqlstr, sqlarr)
+
+        if old_unseen_count != unseen_count:
+            self.notify_client(uid)
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
+    def create_unseen_count(self, uid):
+        cur = self.db.cursor()
+        sqlstr = ('INSERT INTO "NOTICE_UNSEEN" ("uid", "unseen_count") '
+                  'VALUES (%s, %s);')
+        sqlarr = (uid, 0)
+        cur.execute(sqlstr, sqlarr)
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
+    def notify_client(self, uid):
+        unseen_count = self._get_unseen_count(uid)
+
+        for link in self.get_link('client', uid = uid):
+            Proxy.instance.call_async(
+                link + 'core/notice/', 'update_notice', 10000, None, unseen_count
+            )
+
+    def get_notice(self, noticeid):
+        cur = self.db.cursor()
+        sqlstr = ('SELECT "noticeid", "uid", "title", "content", "time", '
+                  '"noticemodid", "metadata", "unread" FROM "NOTICE" WHERE '
+                  '"noticeid" = %s;')
+        sqlarr = (noticeid, )
+        cur.execute(sqlstr, sqlarr)
+
+        ret = None
+        for data in cur:
+            ret = {}
+            ret['noticeid'] = data[0]
+            ret['uid'] = data[1]
+            ret['title'] = data[2]
+            ret['content'] = data[3]
+            ret['time'] = data[4]
+            ret['noticemodid'] = data[5]
+            ret['metadata'] = data[6]
+            ret['unread'] = data[7]
+
+        if ret == None:
+            return None
+
+        uid = UserMg.get_current_uid()
+        if uid != ret['uid']:
+            TOJAuth.check_access_func(self._accessid, TOJAuth.ACCESS_EXECUTE)
+
+        return ret
+
+from user import UserMg
diff --git a/src/py/square.py b/src/py/square.py
new file mode 100644
index 0000000..68f1be4
--- /dev/null
+++ b/src/py/square.py
@@ -0,0 +1,311 @@
+from tojauth import TOJAuth
+from asyncdb import AsyncDB
+from user import UserMg
+import imc.proxy
+import config
+
+class SquareMg:
+    _accessid = 4
+
+    TITLE_LEN_MIN = 1
+    TITLE_LEN_MAX = 100
+
+    SQUARE_CATE_NUM_MAX = 50
+
+    def __init__(self, mod_idendesc, get_link_fn):
+        SquareMg.instance = self
+        SquareMg.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER, 
+                config.CORE_DBPASSWORD)
+        SquareMg._idendesc = mod_idendesc
+        self.get_link = get_link_fn
+
+    @imc.async.caller
+    def create_square(self, title, hidden, sqmodid, category = []):
+        if(
+            type(title) != str or
+            type(hidden) != bool or
+            type(sqmodid) != int or
+            type(category) != list
+        ):
+            return 'Eparameter'
+
+        for cateid in category:
+            if(
+                type(cateid) != int
+            ):
+                return 'Eparameter'
+
+        if len(title) < self.TITLE_LEN_MIN:
+            return 'Etitle_too_short'
+        elif len(title) > self.TITLE_LEN_MAX:
+            return 'Etitle_too_long'
+
+        if len(category) > self.SQUARE_CATE_NUM_MAX:
+            return 'Etoo_many_category'
+
+        category = list(set(category))
+
+        for cateid in category:
+            if not self.does_cateid_exist(cateid):
+                return 'Eno_such_cateid'
+
+        sqid = self._create_square(title, hidden, sqmodid)
+        self._set_square_category(sqid, category)
+        return {'sqid': sqid}
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_CREATE)
+    def _create_square(self, title, hidden, sqmodid):
+        cur = self.db.cursor()
+        sqlstr = ('INSERT INTO "SQUARE" ("title", "hidden", "sqmodid", '
+                  '"accessid") VALUES (%s, %s, %s, %s) RETURNING "sqid";')
+        sqlarr = (title, hidden, sqmodid, 0)
+        cur.execute(sqlstr, sqlarr)
+
+        sqid = None
+        for data in cur:
+            sqid = data[0]
+
+        if sqid != 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)
+
+            with TOJAuth.change_current_iden(self._idendesc):
+                TOJAuth.instance.set_access_list(
+                    accessid, TOJAuth.ROLEID_SQUARE_ADMIN_GROUP, 
+                    TOJAuth.ACCESS_ALL
+                )
+
+            # sqmod.create_square_data(sqid)
+
+        return sqid;
+
+    @imc.async.caller
+    def delete_square(self, sqid):
+        if(
+            type(sqid) != int
+        ):
+            return 'Eparameter'
+
+        if not self.does_sqid_exist(sqid):
+            return 'Eno_such_sqid'
+
+        self._delete_square(self, sqid)
+    
+    def _delete_square(self, sqid):
+        accessid = self.get_accessid_by_sqid(sqid)
+        TOJAuth.check_access_func(accessid, TOJAuth.ACCESS_DELETE)
+
+        # sqmod.delete_square_data(sqid)
+
+        with TOJAuth.change_current_iden(self._idendesc):
+            TOJAuth.instance.del_access(accessid)
+
+        cur = self.db.cursor()
+        sqlstr = ('DELETE FROM "SQUARE" WHERE "sqid" = %s;')
+        sqlarr = (sqid, )
+        cur.execute()
+
+    @imc.async.caller
+    def list_square(self, cateid = None):
+        if(
+            cateid != None and type(cateid) != int
+        ):
+            return 'Eparameter'
+
+        ret = None
+        if cateid == None:
+            ret = self._list_square_all()
+        else:
+            if not self.does_cateid_exist(cateid):
+                return 'Eno_such_cateid'
+            ret = self._list_square_category(cateid)
+
+        return ret
+
+    def _list_square_category(self, cateid):
+        cur = self.db.cursor()
+        sqlstr = ('SELECT "sqid", "title", "start_time", "end_time", "hidden",'
+                  ' "sqmodid" FROM "SQUARE" WHERE %s = ANY ("cateid");')
+        sqlarr = (cateid, )
+        cur.execute(sqlstr, sqlarr)
+
+        ret = []
+        for data in cur:
+            obj = {}
+            obj['sqid'] = data[0]
+            obj['title'] = data[1]
+            obj['start_time'] = data[2]
+            obj['end_time'] = data[3]
+            obj['hidden'] = data[4]
+            obj['sqmodid'] = data[5]
+            ret.append(obj)
+
+        return ret
+
+    def _list_square_all(self):
+        cur = self.db.cursor()
+        sqlstr = ('SELECT "sqid", "title", "start_time", "end_time", "hidden",'
+                  ' "sqmodid" FROM "SQUARE";')
+        cur.execute(sqlstr)
+
+        ret = []
+        for data in cur:
+            obj = {}
+            obj['sqid'] = data[0]
+            obj['title'] = data[1]
+            obj['start_time'] = data[2]
+            obj['end_time'] = data[3]
+            obj['hidden'] = data[4]
+            obj['sqmodid'] = data[5]
+            ret.append(obj)
+
+        return ret
+
+    @imc.async.caller
+    def create_group():
+        pass
+
+    @imc.async.caller
+    def del_group():
+        pass
+
+    @imc.async.caller
+    def list_group():
+        pass
+
+    @imc.async.caller
+    def group_create_square():
+        pass
+    
+    @imc.async.caller
+    def group_remove_square():
+        pass
+
+    @imc.async.caller
+    def group_list_square():
+        pass
+
+    @imc.async.caller
+    def create_category(self, catename):
+        if(
+            type(catename) != str
+        ):
+            return 'Eparameter'
+
+        cateid = self._create_category(catename)
+        return cateid
+
+    @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_CREATE)
+    def _create_category(self, catename):
+        cur = self.db.cursor()
+        sqlstr = ('INSERT INTO "CATEGORY" ("catename") VALUES (%s) RETURNING '
+                  '"cateid";')
+        sqlarr = (catename, )
+        cur.execute(sqlstr, sqlarr)
+
+        cateid = None
+        for data in cur:
+            cateid = data[0]
+
+        return cateid
+
+    @imc.async.caller
+    def set_square_category(self, sqid, category):
+        if(
+            type(sqid) != int or
+            type(category) != list
+        ):
+            return 'Eparameter'
+
+        for cateid in category:
+            if(
+                type(cateid) != int
+            ):
+                return 'Eparameter'
+
+        if len(category) > self.SQUARE_CATE_NUM_MAX:
+            return 'Etoo_many_category'
+
+        category = list(set(category))
+        
+        if not self.does_sqid_exist(sqid):
+            return 'Eno_such_sqid'
+
+        for cateid in category:
+            if not self.does_cateid_exist(cateid):
+                return 'Eno_such_cateid'
+
+        self._set_square_category(sqid, category)
+        
+    def _set_square_category(self, sqid, category):
+        sq_accessid = self.get_accessid_by_sqid(sqid)
+        TOJAuth.check_access_func(sq_accessid, TOJAuth.ACCESS_WRITE)
+
+        cur = self.db.cursor()
+        sqlstr = ('UPDATE "SQUARE" SET "cateid" = %s WHERE "sqid" = %s;')
+        sqlarr = (category, sqid)
+        cur.execute(sqlstr, sqlarr)
+
+    def get_square_info_by_sqid(self, sqid):
+        cur = self.db.cursor()
+        sqlstr = ('SELECT "sqid", "title", "start_time", "end_time", '
+                  '"hidden", "sqmodid", "cateid" FROM "SQUARE" WHERE '
+                  '"sqid" = %s;')
+        sqlarr = (sqid, )
+        cur.execute(sqlstr, sqlarr)
+
+        ret = None
+        for data in cur:
+            ret = {}
+            ret['sqid'] = data[0]
+            ret['title'] = data[1]
+            ret['start_time'] = data[2]
+            ret['end_time'] = data[3]
+            ret['hidden'] = data[4]
+            ret['sqmodid'] = data[5]
+            ret['cateid'] = data[6]
+
+        return ret
+
+    def does_sqid_exist(self, sqid):
+        ret = self.get_square_info_by_sqid(sqid)
+        return ret != None
+
+    def get_accessid_by_sqid(self, sqid):
+        cur = self.db.cursor()
+        sqlstr = ('SELECT "accessid" FROM "SQUARE" WHERE "sqid" = %s;')
+        sqlarr = (sqid, )
+        cur.execute(sqlstr, sqlarr)
+
+        accessid = None
+        for data in cur:
+            accessid = data[0]
+
+        return accessid
+
+    def get_catename_by_cateid(self, cateid):
+        cur = self.db.cursor()
+        sqlstr = ('SELECT "catename" FROM "CATEGORY" WHERE "cateid" = %s;')
+        sqlarr = (cateid, )
+        cur.execute(sqlstr, sqlarr)
+
+        catename = None
+        for data in cur:
+            catename = data[0]
+
+        return catename
+
+    def does_cateid_exist(self, cateid):
+        catename = self.get_catename_by_cateid(cateid)
+        return catename != None
+
+class Square:
+    pass
+
+class Group:
+    pass
diff --git a/src/py/user.py b/src/py/user.py
index 3c58c03..33c2c6c 100755
--- a/src/py/user.py
+++ b/src/py/user.py
@@ -22,6 +22,8 @@ class UserMg:
     AVATAR_LEN_MAX = 200
     ABOUTME_LEN_MIN = 0
     ABOUTME_LEN_MAX = 1000
+    COVER_LEN_MIN = 0
+    COVER_LEN_MAX = 200
 
     def __init__(self, mod_idendesc, get_link_fn):
         UserMg.instance = self
@@ -40,16 +42,21 @@ class UserMg:
             'core/user/', 'get_user_info', self.get_user_info)
         Proxy.instance.register_call(
             'core/user/', 'set_user_info', self.set_user_info)
+        Proxy.instance.register_call(
+            'core/user/', 'change_user_password', self.change_user_password)
 
     @imc.async.caller
-    def register(self, username, password, nickname, email, avatar, aboutme):
+    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
+            type(aboutme) != str or 
+            type(cover) != str
         ):
             return 'Eparameter'
 
@@ -77,32 +84,44 @@ class UserMg:
             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)
+                    username, passhash, nickname, email, avatar, aboutme, cover
+                )
             except psycopg2.IntegrityError:
                 return 'Eusername_exists'
 
         return {'uid' : uid}
 
     @TOJAuth.check_access(_accessid, TOJAuth.ACCESS_EXECUTE)
-    def _create_user(self, username, passhash, nickname, email, avatar, 
-            aboutme):
+    def _create_user(
+        self, username, passhash, nickname, email, avatar, aboutme, cover
+    ):
         roleid = TOJAuth.instance.create_role(username, TOJAuth.ROLETYPE_USER)
 
         cur = self.db.cursor()
         sqlstr = ('INSERT INTO "USER" ("username", "passhash", "nickname", '
-                '"email", "avatar", "aboutme", "idenid") '
-                'VALUES (%s, %s, %s, %s, %s, %s, %s) RETURNING "uid";')
-        sqlarr = (username, passhash, nickname, email, avatar, aboutme, roleid)
+                '"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):
+            Notice.instance.create_unseen_count(uid)
+
         return uid
 
     @imc.async.caller
@@ -130,13 +149,14 @@ class UserMg:
             idenid = data[0]
 
         if idenid == None:
-            return 'Elogin_faild'
+            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'),
                                             'create_iden',
                                             10000,
-                                            TOJAuth.get_current_iden()['link'],
+                                            client_link,
                                             idenid,
                                             TOJAuth.ROLETYPE_USER,
                                             {'uid' : uid})
@@ -178,11 +198,12 @@ class UserMg:
         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'),
                                             'create_iden',
                                             10000,
-                                            TOJAuth.get_current_iden()['link'],
+                                            client_link,
                                             idenid,
                                             TOJAuth.ROLETYPE_USER,
                                             {'uid' : uid})
@@ -212,13 +233,14 @@ class UserMg:
         return ret
 
     @imc.async.caller
-    def set_user_info(self, uid, nickname, email, avatar, aboutme):
+    def set_user_info(self, uid, nickname, email, avatar, aboutme, cover):
         if(
             type(uid) != int or
             type(nickname) != str or
             type(email) != str or
             type(avatar) != str or
-            type(aboutme) != str
+            type(aboutme) != str or
+            type(cover) != str
         ):
             return 'Eparameter'
 
@@ -238,6 +260,10 @@ class UserMg:
             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'
 
         idenid = self.get_idenid_by_uid(uid)
         if idenid == None:
@@ -249,8 +275,9 @@ class UserMg:
 
         cur = self.db.cursor()
         sqlstr = ('UPDATE "USER" SET "nickname" = %s, "email" = %s, '
-                  '"avatar" = %s, "aboutme" = %s WHERE "uid" = %s;')
-        sqlarr = (nickname, email, avatar, aboutme, uid)
+                  '"avatar" = %s, "aboutme" = %s, "cover" = %s WHERE '
+                  '"uid" = %s;')
+        sqlarr = (nickname, email, avatar, aboutme, cover, uid)
         cur.execute(sqlstr, sqlarr)
 
     @imc.async.caller
@@ -310,7 +337,8 @@ class UserMg:
 
     def get_user_info_by_uid(self, uid):
         cur = self.db.cursor()
-        sqlstr = ('SELECT * FROM "USER" WHERE "uid" = %s;')
+        sqlstr = ('SELECT "uid", "username", "nickname", "email", "avatar", '
+                  '"aboutme", "cover" FROM "USER" WHERE "uid" = %s;')
         sqlarr = (uid, )
         cur.execute(sqlstr, sqlarr)
 
@@ -319,10 +347,11 @@ class UserMg:
             ret = {}
             ret['uid'] = data[0]
             ret['username'] = data[1]
-            ret['nickname'] = data[3]
-            ret['email'] = data[4]
-            ret['avatar'] = data[5]
-            ret['aboutme'] = data[6]
+            ret['nickname'] = data[2]
+            ret['email'] = data[3]
+            ret['avatar'] = data[4]
+            ret['aboutme'] = data[5]
+            ret['cover'] = data[6]
 
         return ret
 
@@ -374,3 +403,6 @@ def load(mod_idendesc, get_link_fn):
 
 def unload():
     pass
+
+from notice import Notice
+
author	pzread <netfirewall@gmail.com>	2013-06-22 18:55:10 +0800
committer	pzread <netfirewall@gmail.com>	2013-06-22 18:55:10 +0800
commit	e0043639746fdbbf4958c67a3ef55c63c2fe51a5 (patch)
tree	bf553445c16ad67b56fd26403057428c4e6dd4af /src/py
parent	a66de70527978a4510c6e230fcc56ce890bf20a2 (diff)
download	taiwan-online-judge-e0043639746fdbbf4958c67a3ef55c63c2fe51a5.tar.gz taiwan-online-judge-e0043639746fdbbf4958c67a3ef55c63c2fe51a5.tar.zst taiwan-online-judge-e0043639746fdbbf4958c67a3ef55c63c2fe51a5.zip