def add(cls, user_id, balance=0.00):
db = DbManager().db
sql = 'insert into {table} (user_id, balance) values (%s, %s)'.format(
table=cls.table)
account_id = db.execute(sql, user_id, balance)
return account_id and cls(
id=account_id, user_id=user_id, balance=balance)
def add(cls, user_id, withdraw_account, amount, status=WITHDRAW_WAITING):
db = DbManager().db
create_time = datetime.now()
db.execute('begin;')
try:
sql = 'insert into {table} (user_id, withdraw_account, amount, status, create_time) values ' \
'(%s, %s, %s, %s, %s)'.format(table=cls.table)
db.execute(sql, user_id, withdraw_account, amount, status,
create_time)
sql = 'update {table} set balance=balance-%s where user_id=%s'.format(
table=Account.table)
db.execute(sql, amount, user_id)
db.execute('commit;')
except Exception as e:
db.execute('rollback;')
raise
def add(cls, vote_id, content):
db = DbManager().db
create_time = datetime.now()
sql = 'insert into {table} (vote_id, content, create_time) values (%s, %s, %s)'.format(
table=cls.table)
option_id = db.execute(sql, vote_id, content, create_time)
return option_id and cls.get(option_id)
def add(cls, user_id, device_token, os):
db = DbManager().db
create_time = datetime.now()
sql = 'insert into {table} (user_id, device_token, os, create_time) values (%s, %s, %s, %s)'.format(
table=cls.table)
device_id = db.execute(sql, user_id, device_token, os, create_time)
return device_id and cls.get(device_id)
def add(cls, trade_id, pay_method, notify):
db = DbManager().db
create_time = datetime.now()
sql = 'insert into {table} (trade_id, pay_method, notify, create_time) values (%s, %s, %s, %s)'.format(
table=cls.table)
order_pay_notify_id = db.execute(sql, trade_id, pay_method, notify,
create_time)
return order_pay_notify_id
def add(cls, receiver_id, group_id, message_id, liked_amount, reward_type):
db = DbManager().db
sql = 'insert into {table} (receiver_id, group_id, message_id, liked_amount, reward_type) values (%s, %s, %s, %s, %s)'.format(
table=cls.table)
envelope_id = db.execute(sql, receiver_id, group_id, message_id,
liked_amount, reward_type)
return cls(envelope_id, receiver_id, group_id, message_id,
liked_amount, reward_type)
def update(self, **kwargs):
db = DbManager().db
params = ['%s="%s"' % (key, kwargs.get(key)) for key in kwargs]
update_sql = ', '.join(params)
sql = 'update {table} set %s where id=%s'.format(
table=self.table) % (update_sql, self.id)
r = db.execute(sql)
return r
def add(cls, user_id, room_id, content_id, status=ROOM_PUSH_PENDING):
push_time = datetime.now()
db = DbManager().db
sql = 'insert into {table} (user_id, room_id, content_id, push_time, status) values (%s, %s, %s, %s, %s)'.format(
table=cls.table)
room_push_id = db.execute(sql, user_id, room_id, content_id, push_time,
status)
return cls(room_push_id, user_id, room_id, content_id, push_time,
status)
def add(cls, user_id, district, name, telephone, address):
db = DbManager().db
create_time = datetime.now()
sql = 'insert into {table} (user_id, district, name, telephone, address, create_time) values ' \
'(%s, %s, %s, %s, %s, %s)'.format(table=cls.table)
user_address_id = db.execute(sql, user_id, district, name, telephone,
address, create_time)
return user_address_id and cls(user_address_id, user_id, district,
name, telephone, address, create_time,
None)
def add(cls, user_id, group_id, message_id):
db = DbManager().db
cache = CacheManager().cache
create_time = datetime.now()
score = get_int_date(create_time)
redis_key = GROUP_MESSAGE_LIKED_KEY % (group_id, message_id)
group_message_list_key = GROUP_MESSAGE_LIKED_LIST % group_id
if cache.zscore(redis_key, user_id):
sql = 'delete from {table} where user_id=%s and message_id=%s and group_id=%s'.format(
table=cls.table)
db.execute(sql, user_id, message_id, group_id)
cache.zrem(redis_key, user_id)
cache.zincrby(group_message_list_key, message_id, -1)
return cache.zcard(redis_key)
sql = 'insert into {table} (user_id, group_id, message_id, create_time) values' \
' (%s, %s, %s, %s)'.format(table=cls.table)
db.execute(sql, user_id, group_id, message_id, create_time)
cache.zadd(redis_key, score, user_id)
cache.zincrby(group_message_list_key, message_id, 1)
return cache.zcard(redis_key)
def update(self, **kwargs):
db = DbManager().db
if 'update_time' not in kwargs:
kwargs.update({'update_time': datetime.now()})
params = ['%s="%s"' % (key, kwargs.get(key)) for key in kwargs]
update_sql = ', '.join(params)
sql = 'update {table} set %s where id=%s'.format(
table=self.table) % (update_sql, self.id)
r = db.execute(sql)
self.flush_redis_room_info()
return r
def update(self, **kwargs):
db = DbManager().db
if 'status' in kwargs and kwargs['status'] not in VALID_STATUS:
raise InvalidStatusException
invalid_fields = ('id')
for field in invalid_fields:
if field in kwargs:
del kwargs[field]
sql = 'update {table} set '.format(table=self.table) +\
','.join('%s=%s' % (k, kwargs.get(k)) for k in kwargs) + ' where id=%s'
r = db.execute(sql, self.id)
return r
def add(cls,
order_id,
order_type,
amount,
pay_method,
status=STATUS_PENDING):
db = DbManager().db
create_time = datetime.now()
sql = 'insert into {table} (order_id, order_type, amount, pay_method, status, create_time) values ' \
'(%s, %s, %s, %s, %s, %s)'.format(table=cls.table)
trade_id = db.execute(sql, order_id, order_type, amount, pay_method,
status, create_time)
return trade_id
def add(cls, user_id, access_token):
create_time = datetime.now()
db = DbManager().db
sql = 'insert into {table} (user_id, access_token, create_time) values (%s, %s, %s)'.format(
table=cls.table)
try:
user_auth_id = db.execute(sql, user_id, access_token, create_time)
logger.info(u'添加用户access_token成功。user_auth_id:[%s]' % user_auth_id)
return user_auth_id
except Exception as e:
logger.error(u'添加用户access_token失败。user_id:[%s], error:[%s]' %
(user_id, e))
raise
def delete(self):
db = DbManager().db
content_id = self.id
db.execute('begin;')
try:
sql = 'delete from {table} where id=%s'.format(table=self.table)
db.execute(sql, content_id)
db.execute('commit;')
except:
db.execute('rollback;')
raise
cache = CacheManager().cache
posts_cache_key = POSTS_CACHE_KEY % content_id
cache.delete(posts_cache_key)
def add(cls,
user_id,
name,
account_name,
account_type=ALIPAY_ACCOUNT_TYPE):
db = DbManager().db
create_time = datetime.now()
sql = 'insert into {table} (user_id, name, account_type, account_name, create_time) values (%s, %s, %s, %s, %s)'.format(
table=cls.table)
account_id = db.execute(sql, user_id, name, account_type, account_name,
create_time)
if account_id:
return cls(account_id, user_id, name, account_type, account_name,
create_time)
def add(cls, creator_id, proverbs, status=CHECK_STATUS_PENDING):
create_time = datetime.now()
db = DbManager().db
cache = CacheManager().cache
sql = 'insert into {table} (creator_id, proverbs, status, create_time) values (%s, %s, %s, %s)'.format(
table=cls.table)
proverbs_id = db.execute(sql, creator_id, proverbs, status,
create_time)
if proverbs_id:
user_tag_proverbs_limit_key = user_tag_proverbs_24_hours_limit % creator_id
cache.set(user_tag_proverbs_limit_key, 'true')
cache.expire(user_tag_proverbs_limit_key, LIMIT_SECONDS)
return cls(proverbs_id, creator_id, proverbs, status, create_time,
None, None)
def add(cls, creator_id, receiver_id, content_id, room_id, amount, trades_info, type=REWARD_TYPE_CONTENT, status=STATUS_PENDING):
db = DbManager().db
create_time = datetime.now()
db.execute('begin;')
try:
sql = 'insert into {table} (creator_id, receiver_id, type, content_id, room_id, amount, status, create_time) ' \
'values (%s, %s, %s, %s, %s, %s, %s, %s)'.format(table=cls.table)
reward_order_id = db.execute(sql, creator_id, receiver_id, type, content_id, room_id, amount, status, create_time)
for trade_info in trades_info:
trade_id = init_trade_id()
pay_method = trade_info.get('pay_method')
amount = trade_info.get('amount')
sql = 'insert into {table} (id, order_id, order_type, amount, pay_method, status, create_time) values ' \
'(%s, %s, %s, %s, %s, %s, %s)'.format(table=Trade.table)
db.execute(sql, trade_id, reward_order_id, ORDER_REWARD, amount, pay_method, status, create_time)
db.execute('commit;')
return cls(reward_order_id, creator_id, receiver_id, type, content_id, room_id, amount, status, create_time, None)
except Exception:
db.execute('rollback')
raise
def add(cls, user_id, reply_user_id, content_id, text):
db = DbManager().db
create_time = datetime.now()
cache = CacheManager().cache
cache_key = CONTENT_COMMENT_CACHE_KEY % content_id
sql = 'insert into {table} (user_id, reply_user_id, content_id, text, create_time) values ' \
'(%s, %s, %s, %s, %s)'.format(table=cls.table)
comment_id = db.execute(sql, user_id, reply_user_id, content_id, text,
create_time)
if comment_id:
content = Content.get(content_id)
content.update(last_comment_time=create_time)
cache.lpush(cache_key, comment_id)
return cls(comment_id, user_id, reply_user_id, content_id, text,
create_time)
def add(cls,
receiver_id,
group_id,
message_id,
liked_amount,
amount,
status=STATUS_PENDING):
db = DbManager().db
create_time = datetime.now()
sql = 'insert into {table} (receiver_id, group_id, message_id, liked_amount, amount, status, create_time) ' \
'values (%s, %s, %s, %s, %s, %s, %s)'.format(table=cls.table)
envelope_id = db.execute(sql, receiver_id, group_id, message_id,
liked_amount, amount, status, create_time)
return cls(envelope_id, receiver_id, group_id, message_id,
liked_amount, amount, status, create_time, None)
def add(cls,
sender_id,
receiver_id,
action,
target_id,
notify_type=NOTIFY_TYPE_SYSTEM,
extra=None,
extra_info=None,
status=NOTIFY_UNREAD):
db = DbManager().db
create_time = datetime.now()
sql = 'insert into {table} (sender_id, receiver_id, action, target_id, notify_type, extra, extra_info, status, create_time) values ' \
'(%s, %s, %s, %s, %s, %s, %s, %s, %s)'.format(table=cls.table)
notify_id = db.execute(sql, sender_id, receiver_id, action, target_id,
notify_type, extra, extra_info, status,
create_time)
return notify_id
def add(cls, receiver_id, group_id, message_id, liked_amount, amount):
db = DbManager().db
create_time = datetime.now()
try:
db.execute('begin;')
sql = 'insert into {table} (receiver_id, group_id, message_id, liked_amount, amount, create_time) values' \
' (%s, %s, %s, %s, %s, %s)'.format(table=cls.table)
seeds_id = db.execute(sql, receiver_id, group_id, message_id,
liked_amount, amount, create_time)
db.execute('commit;')
except:
db.execute('rollback;')
raise
return cls(seeds_id, receiver_id, group_id, message_id, liked_amount,
amount, create_time)
def add(cls,
creator_id,
amount,
order_type,
pay_method,
status=STATUS_PENDING):
db = DbManager().db
create_time = datetime.now()
db.execute('begin;')
try:
sql = 'insert into {table} (creator_id, amount, status, create_time) ' \
'values (%s, %s, %s, %s)'.format(table=cls.table)
order_id = db.execute(sql, creator_id, amount, status, create_time)
trade_id = init_trade_id()
sql = 'insert into {table} (id, order_id, order_type, amount, pay_method, status, create_time) values ' \
'(%s, %s, %s, %s, %s, %s, %s)'.format(table=Trade.table)
db.execute(sql, trade_id, order_id, order_type, amount, pay_method,
status, create_time)
db.execute('commit;')
return cls.get(order_id)
except:
db.execute('rollback;')
raise
def add(cls,
user_id,
name,
telephone,
id_card,
id_card_front,
id_card_back,
status=VALIDATING_STATUS,
reason=''):
db = DbManager().db
create_time = datetime.now()
sql = 'insert into {table} (user_id, name, telephone, id_card, id_card_front, id_card_back, status, reason, create_time) ' \
'values (%s, %s, %s, %s, %s, %s, %s, %s, %s)'.format(table=cls.table)
user_validate_id = db.execute(sql, user_id, name, telephone, id_card,
id_card_front, id_card_back, status,
reason, create_time)
return user_validate_id and cls(
user_validate_id, user_id, name, telephone, id_card, id_card_front,
id_card_back, status, reason, create_time, None)
def add(cls,
telephone,
password,
name='',
role=USER_DEFAULT_ROLE,
avatar='',
intro='',
city_id=USER_DEFAULT_CITY,
status=USER_NORMAL):
create_time = datetime.now()
db = DbManager().db
sql = 'insert into {table} (telephone, password, name, role, avatar, intro, city_id, status, create_time) values ' \
'(%s, %s, %s, %s, %s, %s, %s, %s, %s)'.format(table=cls.table)
try:
user_id = db.execute(sql, telephone, password, name, role, avatar,
intro, city_id, status, create_time)
logger.info(u'添加用户成功。user_id:[%s]' % user_id)
return user_id
except Exception as e:
logger.error(u'添加用户失败。Error:[%s]' % e)
raise
def delete(self):
db = DbManager().db
sql = 'delete from {table} where id=%s'.format(table=self.table)
db.execute(sql, self.id)
self.flush_comment_cache()
def delete(self):
db = DbManager().db
content_id = self.id
db.execute('begin;')
try:
sql = 'delete from {table} where id=%s'.format(table=self.table)
db.execute(sql, content_id)
sql = 'delete from comment where content_id=%s'
db.execute(sql, content_id)
sql = 'delete from content_liked where content_id=%s'
db.execute(sql, content_id)
db.execute('commit;')
except:
db.execute('rollback;')
raise
cache = CacheManager().cache
cache.zrem(USER_CREATED_CONTENT_KEY % self.creator_id, content_id)
# 删除内容的评论和点赞记录
content_comment_key = CONTENT_COMMENT_CACHE_KEY % content_id
comment_ids = cache.lrange(content_comment_key, 0, -1)
with cache.pipeline() as pipe:
for comment_id in comment_ids:
comment_cache_key = COMMENT_CACHE_KEY % comment_id
pipe.delete(comment_cache_key)
pipe.delete(content_comment_key)
content_liked_key = CONTENT_LIKED_CACHE_KEY % content_id
pipe.delete(content_liked_key)
pipe.zrem(CONTENT_LIKED_RANK_KEY, content_id)
pipe.execute()
ContentTypeMap = getContentTypeMap()
content_model = ContentTypeMap.get(self.content_type)
content_obj = content_model.get(self.id)
content_obj.delete()
def add(cls, user_id, source, order_type, order_id, amount, create_time):
db = DbManager().db
sql = 'insert into {table} (user_id, source, order_type, order_id, amount, create_time) values ' \
'(%s, %s, %s, %s, %s, %s)'.format(table=cls.table)
db.execute(sql, user_id, source, order_type, order_id, amount, create_time)
def update_amount(cls, message_id, liked_amount):
db = DbManager().db
sql = 'update {table} set liked_amount=%s where id=%s'.format(
table=cls.table)
db.execute(sql, liked_amount, message_id)
def receive_trade_payment(self):
db = DbManager().db
trades = self.trades
now = datetime.now()
all_trades_complete = True
for trade in trades:
if trade.status != STATUS_COMPLETE:
return
if all_trades_complete:
try:
db.execute('begin;')
for trade in trades:
if trade.pay_method == PAYMETHOD_ACCOUNT:
sql = 'update {table} set balance=balance-%s where user_id=%s'.format(
table=Account.table)
db.execute(sql, float(trade.amount), self.creator_id)
sql = 'update {table} set balance=balance+%s where room_id=%s'.format(
table=StarFund.table)
db.execute(sql, float(self.amount), self.room_id)
sql = 'update {table} set status=%s, pay_time=%s where id=%s'.format(
table=self.table)
db.execute(sql, STATUS_COMPLETE, now, self.id)
sql = 'insert into {table} (user_id, source, order_type, order_id, amount, create_time) values ' \
'(%s, %s, %s, %s, %s, %s)'.format(table=WalletRecord.table)
db.execute(sql, self.creator_id, WALLET_RECORD_ROOM_RENT,
ORDER_ROOM, self.id, -self.amount, now)
db.execute('commit;')
except:
db.execute('rollback;')
raise
RoomUser.add(self.room_id, self.creator_id)
self.flush_fund_cache()
