Пример #1
0
def move_status():
    STATUS_REDIS_KEY = "/status/text/%s"
    RAW_STATUS_REDIS_KEY = "/status/raw/%s"

    start = 3720000
    limit = 100000
    #r =db_conn.execute("select count(1) from status")
    #total = r.fetchone()[0]
    total = 4423725
    print '----total status:', total
    sys.stdout.flush()

    ef = open("error.log", "a")
    #cf = open("cmd.txt", "w")
    while (start <= int(total)):
        f = open("./midfile.txt", "w")
        print '-------start ', start
        sys.stdout.flush()
        cursor = db_conn.execute(
            "select id from status order by id limit %s,%s", (start, limit))
        rows = cursor.fetchall()
        for row in rows:
            text = mongo_conn.get(STATUS_REDIS_KEY % row[0])
            raw = mongo_conn.get(RAW_STATUS_REDIS_KEY % row[0])
            if text and raw:
                text = json_encode(text) if not isinstance(
                    text, basestring) else text
                raw = json_encode(raw) if not isinstance(raw,
                                                         basestring) else raw

                db_conn.execute(
                    '''replace into raw_status (status_id, text, raw) 
                    values(%s,%s,%s)''', (row[0], text, raw))
        db_conn.commit()
        start += limit
def move_status():
    STATUS_REDIS_KEY = "/status/text/%s"
    RAW_STATUS_REDIS_KEY = "/status/raw/%s"

    start = 3720000
    limit = 100000
    #r =db_conn.execute("select count(1) from status")
    #total = r.fetchone()[0]
    total = 4423725
    print '----total status:', total
    sys.stdout.flush()

    ef = open("error.log", "a")
    #cf = open("cmd.txt", "w")
    while (start <= int(total)):
        f = open("./midfile.txt", "w")
        print '-------start ', start
        sys.stdout.flush()
        cursor = db_conn.execute("select id from status order by id limit %s,%s", (start, limit))
        rows = cursor.fetchall()
        for row in rows:
            text = mongo_conn.get(STATUS_REDIS_KEY % row[0])
            raw = mongo_conn.get(RAW_STATUS_REDIS_KEY% row[0])
            if text and raw:
                text = json_encode(text) if not isinstance(text, basestring) else text
                raw = json_encode(raw) if not isinstance(raw, basestring) else raw

                db_conn.execute('''replace into raw_status (status_id, text, raw) 
                    values(%s,%s,%s)''', (row[0], text, raw))
        db_conn.commit()
        start += limit
Пример #3
0
 def remove(self):
     cursor = db_conn.execute(
         """delete from sync_task
             where id=%s""", self.id)
     db_conn.commit()
     cursor and cursor.close()
     return None
Пример #4
0
 def update_session(self, session_id):
     cursor = db_conn.execute(
         """update user set session_id=%s where id=%s""",
         (session_id, self.id))
     cursor and cursor.close()
     db_conn.commit()
     User._clear_cache(self.id)
Пример #5
0
 def remove(self):
     cursor = db_conn.cursor()
     cursor.execute("""delete from sync_task
             where id=%s""", self.id) 
     db_conn.commit()
     cursor.close()
     return None
Пример #6
0
    def add(cls, user_id, origin_id, create_time, site, category, title, text=None, raw=None):
        status = None
        cursor = None
        try:
            cursor = db_conn.execute(
                """insert into status 
                    (user_id, origin_id, create_time, site, category, title)
                    values (%s,%s,%s,%s,%s,%s)""",
                (user_id, origin_id, create_time, site, category, title),
            )
            db_conn.commit()
            status_id = cursor.lastrowid
            if text is not None:
                mongo_conn.set(cls.STATUS_REDIS_KEY % status_id, json_encode(text))
            if raw is not None:
                mongo_conn.set(cls.RAW_STATUS_REDIS_KEY % status_id, raw)
            cls._clear_cache(user_id, None, cate=category)
            status = cls.get(status_id)
        except IntegrityError:
            # log.warning("add status duplicated, ignore...")
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return status
Пример #7
0
    def update_uid(self, uid):
        assert isinstance(uid, basestring)
        if self.id != self.uid:
            return False, "already_set"

        if uid == self.uid:
            return True, "same_with_old"

        if len(uid) > User.UID_MAX_LEN:
            return False, u"太长了,不能超过%s" %User.UID_MAX_LEN
        if len(uid) < User.UID_MIN_LEN:
            return False, u"太短了,不能小于%s" %User.UID_MIN_LEN
        uid_re = re.compile(User.UID_RE)
        if not uid_re.match(uid):
            return False, u"只能包括字母数字和.-_"
        
        uid = uid.lower()
        if uid in ["user", "pdf", "explore", "home", "visual", "settings", "admin", "past", "connect", "bind",
            "i", "notes", "note", "status", "share", "timeline", "post", "login", "logout", "sync", "about", 
            "connect", "dev", "api", "thepast", "thepast.me", ]:
            return False, u"被系统占用了:)"
            
        try:
            cursor = db_conn.execute("""update user set uid=%s where id=%s""", 
                    (uid, self.id))
            db_conn.commit()
            User._clear_cache(self.id)
            return True, u"设置成功"
        except IntegrityError:
            db_conn.rollback()
            return False, u"被别人占用了:)"
        finally:
            cursor and cursor.close()

        return False, "fail"
Пример #8
0
    def add(cls,
            user_id,
            origin_id,
            create_time,
            site,
            category,
            title,
            text=None,
            raw=None):
        status = None
        cursor = None
        try:
            cursor = db_conn.execute(
                """insert into status 
                    (user_id, origin_id, create_time, site, category, title)
                    values (%s,%s,%s,%s,%s,%s)""",
                (user_id, origin_id, create_time, site, category, title))
            status_id = cursor.lastrowid
            if status_id > 0:
                text = json_encode(text) if text is not None else ""
                raw = json_encode(raw) if raw is not None else ""
                RawStatus.set(status_id, text, raw)
                db_conn.commit()
                status = cls.get(status_id)
        except IntegrityError:
            log.warning(
                "add status duplicated, uniq key is %s:%s:%s, ignore..." %
                (origin_id, site, category))
            db_conn.rollback()
        finally:
            cls._clear_cache(user_id, None, cate=category)
            cursor and cursor.close()

        return status
Пример #9
0
 def delete_by_random_id(cls, random_id):
     db_conn.execute(
         """delete from confirmation 
             where random_id=%s""",
         random_id,
     )
     db_conn.commit()
Пример #10
0
 def update_session(self, session_id):
     cursor = db_conn.cursor()
     cursor.execute("""update user set session_id=%s where id=%s""", 
             (session_id, self.id))
     cursor.close()
     db_conn.commit()
     User._clear_cache(self.id)
Пример #11
0
    def update_uid(self, uid):
        assert isinstance(uid, basestring)
        if self.id != self.uid:
            return False, "already_set"

        if uid == self.uid:
            return True, "same_with_old"

        if len(uid) > User.UID_MAX_LEN:
            return False, u"太长了,不能超过%s" % User.UID_MAX_LEN
        if len(uid) < User.UID_MIN_LEN:
            return False, u"太短了,不能小于%s" % User.UID_MIN_LEN
        uid_re = re.compile(User.UID_RE)
        if not uid_re.match(uid):
            return False, u"只能包括字母数字和.-_"

        uid = uid.lower()
        if uid in [
                "user",
                "pdf",
                "explore",
                "home",
                "visual",
                "settings",
                "admin",
                "past",
                "connect",
                "bind",
                "i",
                "notes",
                "note",
                "status",
                "share",
                "timeline",
                "post",
                "login",
                "logout",
                "sync",
                "about",
                "connect",
                "dev",
                "api",
                "thepast",
                "thepast.me",
        ]:
            return False, u"被系统占用了:)"

        try:
            cursor = db_conn.execute("""update user set uid=%s where id=%s""",
                                     (uid, self.id))
            db_conn.commit()
            User._clear_cache(self.id)
            return True, u"设置成功"
        except IntegrityError:
            db_conn.rollback()
            return False, u"被别人占用了:)"
        finally:
            cursor and cursor.close()

        return False, "fail"
Пример #12
0
    def add(cls, name=None, uid=None, session_id=None):
        cursor = None
        user = None

        name = "" if name is None else name
        uid = "" if uid is None else uid
        session_id = session_id if session_id else randbytes(8)

        try:
            cursor = db_conn.execute("""insert into user (uid, name, session_id) 
                values (%s, %s, %s)""", 
                (uid, name, session_id))
            user_id = cursor.lastrowid
            if uid == "":
                cursor = db_conn.execute("""update user set uid=%s where id=%s""", 
                    (user_id, user_id), cursor=cursor)
            db_conn.commit()
            cls._clear_cache(None)
            user = cls.get(user_id)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return user
Пример #13
0
    def add(cls, name=None, uid=None, session_id=None):
        cursor = None
        user = None

        name = "" if name is None else name
        uid = "" if uid is None else uid
        session_id = session_id if session_id else randbytes(8)

        try:
            cursor = db_conn.execute(
                """insert into user (uid, name, session_id) 
                values (%s, %s, %s)""", (uid, name, session_id))
            user_id = cursor.lastrowid
            if uid == "":
                cursor = db_conn.execute(
                    """update user set uid=%s where id=%s""",
                    (user_id, user_id),
                    cursor=cursor)
            db_conn.commit()
            cls._clear_cache(None)
            user = cls.get(user_id)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return user
Пример #14
0
 def remove(self):
     cursor = db_conn.execute(
         """delete from task_queue
             where id=%s""",
         self.id,
     )
     db_conn.commit()
     cursor and cursor.close()
Пример #15
0
 def remove(cls, status_id):
     cursor = None
     try:
         cursor = db_conn.execute('''delete from raw_status where status_id = %s''', status_id )
         db_conn.commit()
         cls.clear_cache(status_id)
     except IntegrityError:
         db_conn.rollback()
     cursor and cursor.close()
Пример #16
0
 def remove(cls, user_id):
     cursor = None
     try:
         cursor = db_conn.execute('''delete from user_profile where user_id= %s''', user_id)
         db_conn.commit()
         cls.clear_cache(user_id)
     except IntegrityError:
         db_conn.rollback()
     cursor and cursor.close()
Пример #17
0
 def remove(cls, key_):
     cursor = None
     try:
         cursor = db_conn.execute('''delete from kv where `key` = %s''', key_)
         db_conn.commit()
         cls.clear_cache(key_)
     except IntegrityError:
         db_conn.rollback()
     cursor and cursor.close()
Пример #18
0
 def add(cls, random_id, text):
     cursor = None
     try:
         cursor = db_conn.execute("""insert into confirmation (random_id, text) values(%s, %s)""", (random_id, text))
         db_conn.commit()
         return True
     except IntegrityError:
         db_conn.rollback()
     finally:
         cursor and cursor.close()
Пример #19
0
 def add_user_id(cls, user_id):
     cursor = None
     try:
         cursor = db_conn.execute('''insert into pdf_settings (user_id) values (%s)''', user_id)
         db_conn.commit()
         cls._clear_cache(user_id)
         return True
     except IntegrityError:
         db_conn.rollback()
     finally:
         cursor and cursor.close()
Пример #20
0
 def set_email(self, email):
     cursor = None
     try:
         cursor = db_conn.execute("""replace into passwd (user_id, email) values (%s,%s)""", (self.id, email))
         db_conn.commit()
         return True
     except IntegrityError:
         db_conn.rollback()
         return False
     finally:
         mc.delete("user_email:%s" % self.id)
         cursor and cursor.close()
Пример #21
0
 def add(cls, user_id, weixin_name):
     cursor = None
     try:
         cursor = db_conn.execute('''insert into user_weixin (user_id, weixin_name)
                 values (%s, %s) on duplicate key update user_id=%s''', (user_id, weixin_name, user_id))
         db_conn.commit()
         cls.clear_cache(user_id, weixin_name)
         return cls.get_by_weixin(weixin_name)
     except IntegrityError:
         db_conn.rollback()
     finally:
         cursor and cursor.close()
Пример #22
0
 def add(cls, random_id, text):
     cursor = None
     try:
         cursor = db_conn.execute(
             '''insert into confirmation (random_id, text) values(%s, %s)''',
             (random_id, text))
         db_conn.commit()
         return True
     except IntegrityError:
         db_conn.rollback()
     finally:
         cursor and cursor.close()
Пример #23
0
 def add_user_id(cls, user_id):
     cursor = None
     try:
         cursor = db_conn.execute(
             '''insert into pdf_settings (user_id) values (%s)''', user_id)
         db_conn.commit()
         cls._clear_cache(user_id)
         return True
     except IntegrityError:
         db_conn.rollback()
     finally:
         cursor and cursor.close()
Пример #24
0
def merge_a2b(del_uid, merged_uid):
    
    
    print "-------update status:%s 2 %s" % (del_uid, merged_uid)
    db_conn.execute("update status set user_id=%s where user_id=%s", (merged_uid, del_uid))

    print "-------update alias:%s 2 %s" % (del_uid, merged_uid)
    db_conn.execute("update user_alias set user_id=%s where user_id=%s", (merged_uid, del_uid))
    
    print "-------update synctask:%s 2 %s" % (del_uid, merged_uid)
    db_conn.execute("update sync_task set user_id=%s where user_id=%s", (merged_uid, del_uid))

    db_conn.commit()
Пример #25
0
    def set(cls, user_id, val):
        cursor = None
        val = json_encode(val) if not isinstance(val, basestring) else val

        try:
            cursor = db_conn.execute('''replace into user_profile (user_id, profile) 
                values(%s,%s)''', (user_id, val))
            db_conn.commit()
            cls.clear_cache(user_id)
        except IntegrityError:
            db_conn.rollback()

        cursor and cursor.close()
Пример #26
0
 def update(self, title, content, fmt):
     if title and title != self.title or fmt and fmt != self.fmt or content and content != self.content:
         _fmt = fmt or self.fmt
         _title = title or self.title
         _content = content or self.content
         db_conn.execute('''update note set title = %s, content = %s, fmt = %s where id = %s''', 
                 (_title, _content, _fmt, self.id))
         db_conn.commit()
         self.flush_note()
         
         if title != self.title:
             from past.model.status import Status
             Status._clear_cache(None, self.get_status_id(), None)
Пример #27
0
 def add(cls, user_id, token, device=""):
     cursor = None
     try:
         cursor = db_conn.execute(
             '''insert into user_tokens (user_id, token, device)
                 values (%s, %s, %s)''', (user_id, token, device))
         id_ = cursor.lastrowid
         db_conn.commit()
         return cls.get(id_)
     except IntegrityError:
         db_conn.rollback()
     finally:
         cursor and cursor.close()
Пример #28
0
def remove_status(uid):
    cursor = db_conn.execute("select id from status where user_id=%s", uid)
    if cursor:
        rows = cursor.fetchall()
        for row in rows:
            sid = row[0]
            print "---- delete mongo text, sid=", sid
            RawStatus.remove(sid)

    print "---- delete from status, uid=", uid
    db_conn.execute("delete from status where user_id=%s", uid)
    db_conn.commit()
    Status._clear_cache(uid, None)
Пример #29
0
 def update(self, title, content, fmt, privacy):
     if title and title != self.title or fmt and fmt != self.fmt or content and content != self.content or privacy and privacy != self.privacy:
         _fmt = fmt or self.fmt
         _title = title or self.title
         _content = content or self.content
         _privacy = privacy or self.privacy
         db_conn.execute('''update note set title = %s, content = %s, fmt = %s, privacy = %s where id = %s''', 
                 (_title, _content, _fmt, _privacy, self.id))
         db_conn.commit()
         self.flush_note()
         
         if title != self.title:
             from past.model.status import Status
             Status._clear_cache(None, self.get_status_id(), None)
Пример #30
0
 def set_email(self, email):
     cursor = None
     try:
         cursor = db_conn.execute(
             '''replace into passwd (user_id, email) values (%s,%s)''',
             (self.id, email))
         db_conn.commit()
         return True
     except IntegrityError:
         db_conn.rollback()
         return False
     finally:
         mc.delete("user_email:%s" % self.id)
         cursor and cursor.close()
Пример #31
0
    def set(cls, status_id, text, raw):
        cursor = None
        text = json_encode(text) if not isinstance(text, basestring) else text
        raw = json_encode(raw) if not isinstance(raw, basestring) else raw

        try:
            cursor = db_conn.execute('''replace into raw_status (status_id, text, raw) 
                values(%s,%s,%s)''', (status_id, text, raw))
            db_conn.commit()
            cls.clear_cache(status_id)
        except IntegrityError:
            db_conn.rollback()

        cursor and cursor.close()
Пример #32
0
def merge_a2b(del_uid, merged_uid):

    print "-------update status:%s 2 %s" % (del_uid, merged_uid)
    db_conn.execute("update status set user_id=%s where user_id=%s",
                    (merged_uid, del_uid))

    print "-------update alias:%s 2 %s" % (del_uid, merged_uid)
    db_conn.execute("update user_alias set user_id=%s where user_id=%s",
                    (merged_uid, del_uid))

    print "-------update synctask:%s 2 %s" % (del_uid, merged_uid)
    db_conn.execute("update sync_task set user_id=%s where user_id=%s",
                    (merged_uid, del_uid))

    db_conn.commit()
Пример #33
0
    def add(cls, task_id, task_kind):
        task = None
        cursor = None
        try:
            cursor = db_conn.execute("""insert into task_queue
                    (task_id, task_kind) values (%s,%s)""",
                    (task_id, task_kind))
            db_conn.commit()
            task = cls.get(cursor.lastrowid)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return task
Пример #34
0
    def add(cls, task_id, task_kind):
        task = None
        cursor = None
        try:
            cursor = db_conn.execute("""insert into task_queue
                    (task_id, task_kind) values (%s,%s)""",
                    (task_id, task_kind))
            db_conn.commit()
            task = cls.get(cursor.lastrowid)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return task
Пример #35
0
 def add(cls, user_id, token, device=""):
     cursor = None
     try:
         cursor = db_conn.execute(
             """insert into user_tokens (user_id, token, device)
                 values (%s, %s, %s)""",
             (user_id, token, device),
         )
         id_ = cursor.lastrowid
         db_conn.commit()
         return cls.get(id_)
     except IntegrityError:
         db_conn.rollback()
     finally:
         cursor and cursor.close()
Пример #36
0
    def add(cls, alias_id, access_token, refresh_token):
        ot = None
        cursor = None
        try:
            cursor = db_conn.execute("""replace into oauth2_token 
                    (alias_id, access_token, refresh_token)
                    values (%s, %s, %s)""", 
                    (alias_id, access_token, refresh_token))
            db_conn.commit()
            ot = cls.get(alias_id)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return ot
Пример #37
0
    def add(cls, category, user_id):
        task = None
        cursor = None
        try:
            cursor = db_conn.execute("""insert into sync_task
                    (category, user_id) values (%s,%s)""",
                    (category, user_id))
            db_conn.commit()
            task_id = cursor.lastrowid
            task = cls.get(task_id)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return task
Пример #38
0
    def add(cls, category, user_id):
        task = None
        cursor = None
        try:
            cursor = db_conn.execute("""insert into sync_task
                    (category, user_id) values (%s,%s)""",
                    (category, user_id))
            db_conn.commit()
            task_id = cursor.lastrowid
            task = cls.get(task_id)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return task
Пример #39
0
    def add(cls, alias_id, access_token, refresh_token):
        ot = None
        cursor = None
        try:
            cursor = db_conn.execute(
                """replace into oauth2_token 
                    (alias_id, access_token, refresh_token)
                    values (%s, %s, %s)""",
                (alias_id, access_token, refresh_token))
            db_conn.commit()
            ot = cls.get(alias_id)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return ot
Пример #40
0
    def bind_to_exists_user(cls, user, type_, alias):
        ua = cls.get(type_, alias)
        if ua:
            return None

        ua = None
        cursor = None
        try:
            cursor = db_conn.execute("""insert into user_alias (`type`,alias,user_id) 
                    values (%s, %s, %s)""", (type_, alias, user.id))
            db_conn.commit()
            ua = cls.get(type_, alias)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return ua
Пример #41
0
    def bind_to_exists_user(cls, user, type_, alias):
        ua = cls.get(type_, alias)
        if ua:
            return None

        ua = None
        cursor = None
        try:
            cursor = db_conn.execute(
                """insert into user_alias (`type`,alias,user_id) 
                    values (%s, %s, %s)""", (type_, alias, user.id))
            db_conn.commit()
            ua = cls.get(type_, alias)
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()

        return ua
Пример #42
0
    def add(cls, user_id, title, content, fmt=consts.NOTE_FMT_PLAIN, privacy=consts.STATUS_PRIVACY_PUBLIC):
        cursor = None
        try:
            cursor = db_conn.execute('''insert into note (user_id, title, content, create_time, fmt, privacy) 
                    values (%s, %s, %s, %s, %s, %s)''',
                    (user_id, title, content, datetime.datetime.now(), fmt, privacy))
            db_conn.commit()

            note_id = cursor.lastrowid
            note = cls.get(note_id)
            from past.model.status import Status
            Status.add(user_id, note_id, 
                    note.create_time, config.OPENID_TYPE_DICT[config.OPENID_THEPAST], 
                    config.CATE_THEPAST_NOTE, "")
            cls._clear_cache(user_id, None)
            return note
        except IntegrityError:
            db_conn.rollback()
        finally:
            cursor and cursor.close()
Пример #43
0
def remove_user(uid):
    user = User.get(uid)
    if not user:
        print '---no user:%s' % uid

    print "---- delete from user, uid=", uid
    db_conn.execute("delete from user where id=%s", uid)
    db_conn.commit()
    User._clear_cache(uid)

    cursor = db_conn.execute("select id from status where user_id=%s", uid)
    if cursor:
        rows = cursor.fetchall()
        for row in rows:
            sid = row[0]
            print "---- delete mongo text, sid=", sid
            RawStatus.remove(sid)

    print "---- delete from status, uid=", uid
    db_conn.execute("delete from status where user_id=%s", uid)
    db_conn.commit()
    Status._clear_cache(uid, None)

    print "---- delete from passwd, uid=", uid
    db_conn.execute("delete from passwd where user_id=%s", uid)
    print "---- delete from sync_task, uid=", uid
    db_conn.execute("delete from sync_task where user_id=%s", uid)
    print "---- delete from user_alias, uid=", uid
    db_conn.execute("delete from user_alias where user_id=%s", uid)
    db_conn.commit()
Пример #44
0
def remove_user(uid, clear_status=True):
    user = User.get(uid)
    if not user:
        print "---no user:%s" % uid

    suicide_log.info("---- delete from user, uid=%s" % uid)
    db_conn.execute("delete from user where id=%s", uid)
    db_conn.commit()
    User._clear_cache(uid)

    if clear_status:
        cursor = db_conn.execute("select id from status where user_id=%s", uid)
        if cursor:
            rows = cursor.fetchall()
            for row in rows:
                sid = row[0]
                suicide_log.info("---- delete status text, sid=%s" % sid)
                RawStatus.remove(sid)

        suicide_log.info("---- delete from status, uid=" % uid)
        db_conn.execute("delete from status where user_id=%s", uid)
        db_conn.commit()
        Status._clear_cache(uid, None)

    suicide_log.info("---- delete from passwd, uid=%s" % uid)
    db_conn.execute("delete from passwd where user_id=%s", uid)
    suicide_log.info("---- delete from sync_task, uid=%s" % uid)
    db_conn.execute("delete from sync_task where user_id=%s", uid)
    suicide_log.info("---- delete from user_alias, uid=%s" % uid)
    db_conn.execute("delete from user_alias where user_id=%s", uid)
    db_conn.commit()
Пример #45
0
def remove_user(uid, clear_status=True):
    user = User.get(uid)
    if not user:
        print '---no user:%s' % uid

    suicide_log.info("---- delete from user, uid=%s" % uid)
    db_conn.execute("delete from user where id=%s", uid)
    db_conn.commit()
    User._clear_cache(uid)

    if clear_status:
        cursor = db_conn.execute("select id from status where user_id=%s", uid)
        if cursor:
            rows = cursor.fetchall()
            for row in rows:
                sid = row[0]
                suicide_log.info("---- delete status text, sid=%s" % sid)
                RawStatus.remove(sid)

        suicide_log.info("---- delete from status, uid=" % uid)
        db_conn.execute("delete from status where user_id=%s", uid)
        db_conn.commit()
        Status._clear_cache(uid, None)

    suicide_log.info("---- delete from passwd, uid=%s" % uid)
    db_conn.execute("delete from passwd where user_id=%s", uid)
    suicide_log.info("---- delete from sync_task, uid=%s" % uid)
    db_conn.execute("delete from sync_task where user_id=%s", uid)
    suicide_log.info("---- delete from user_alias, uid=%s" % uid)
    db_conn.execute("delete from user_alias where user_id=%s", uid)
    db_conn.commit()
Пример #46
0
    def add(cls, user_id, origin_id, create_time, site, category, title, 
            text=None, raw=None):
        status = None
        cursor = None
        try:
            cursor = db_conn.execute("""insert into status 
                    (user_id, origin_id, create_time, site, category, title)
                    values (%s,%s,%s,%s,%s,%s)""",
                    (user_id, origin_id, create_time, site, category, title))
            status_id = cursor.lastrowid
            if status_id > 0:
                text = json_encode(text) if text is not None else ""
                raw = json_encode(raw) if raw is not None else ""
                RawStatus.set(status_id, text, raw)
                db_conn.commit()
                status = cls.get(status_id)
        except IntegrityError:
            #log.warning("add status duplicated, ignore...")
            db_conn.rollback()
        finally:
            cls._clear_cache(user_id, None, cate=category)
            cursor and cursor.close()

        return status
Пример #47
0
 def delete_by_random_id(cls, random_id):
     db_conn.execute(
         '''delete from confirmation 
             where random_id=%s''', random_id)
     db_conn.commit()
Пример #48
0
 def remove_user_id(cls, user_id):
     cursor = db_conn.execute(
         '''delete from pdf_settings where user_id=%s''', user_id)
     db_conn.commit()
     cls._clear_cache(user_id)
Пример #49
0
 def remove(self):
     cursor = db_conn.execute("""delete from task_queue
             where id=%s""", self.id) 
     db_conn.commit()
     cursor and cursor.close()
Пример #50
0
sys.path.append('../')

import datetime
import past
from past.store import db_conn
from past.utils.escape import json_decode
from past.model.kv import RawStatus

cursor = db_conn.execute("select id from status where category=200")
rows = cursor.fetchall()
cursor and cursor.close()
ids = [x[0] for x in rows]

for x in ids:
    try:
        r = RawStatus.get(x)
        raw = r.raw if r else ""
        if raw:
            print x
            data = json_decode(raw)
            t = data.get("created_at")
            created_at = datetime.datetime.strptime(
                t, "%a %b %d %H:%M:%S +0800 %Y")
            db_conn.execute("update status set create_time = %s where id=%s",
                            (created_at, x))
            db_conn.commit()
    except:
        import traceback
        print traceback.format_exc()
        sys.stdout.flush()
Пример #51
0
        try:
            cursor = db_conn.execute("""insert into status 
                    (user_id, origin_id, create_time, site, category, title)
                    values (%s,%s,%s,%s,%s,%s)""",
                    (user_id, origin_id, create_time, site, category, title))
            status_id = cursor.lastrowid
            try:
                if text is not None:
                    mongo_conn.set(cls.STATUS_REDIS_KEY %status_id, json_encode(text))
                if raw is not None:
                    mongo_conn.set(cls.RAW_STATUS_REDIS_KEY %status_id, raw)
            except Exception, e:
                log.warning('ERROR_MONGODB:%s' % e)
                db_conn.rollback()
            else:
                db_conn.commit()
                status = cls.get(status_id)
        except IntegrityError:
            #log.warning("add status duplicated, ignore...")
            db_conn.rollback()
        finally:
            cls._clear_cache(user_id, None, cate=category)
            cursor and cursor.close()

        return status

    @classmethod
    def add_from_obj(cls, user_id, d, raw=None):
        origin_id = d.get_origin_id()
        create_time = d.get_create_time()
        title = d.get_title()