def remove_todo():
params = request.values or request.get_json() or {}
todo_id = params.get("todo_id")
result = set_todo_state(todo_id, 3)
if not result:
return CommonError.get_error(40000)
return response_succ(body=result)
def add_todo():
""" add todo by parameters
try to add a todo to todolist,you can just set the todo title.
Args:
title: title of the todo item
Returns:
a dict mapping keys to the index of the todo item just added.
example:
{"todo_id": 6}
"""
params = request.values or request.get_json() or {}
title = params.get("title")
todo = TodoModel()
todo.todo_title = title
todo.add_time = get_unix_time_tuple()
todo.todo_state = 1
todo.bind_user_id = g.current_user.id
db.session.add(todo)
db.session.commit()
result = {"todo_id": todo.todo_id}
return response_succ(body=result)
def rss_record():
"""
记录rss的阅读记录
"""
params = request.values or request.get_json() or {}
url = str(params.get('url'))
if not url:
return CommonError.get_error(40000)
bind_user_id = g.current_user.id
sql = """
SELECT bao_rss_user.user_id, bao_rss.rss_id, bao_rss_content.content_id FROM bao_rss_content, bao_rss, bao_rss_user
WHERE bao_rss_content.content_link='{content_link}'
AND bao_rss_content.content_base=bao_rss.rss_link
AND bao_rss.rss_id=bao_rss_user.rss_id
AND bao_rss_user.user_id={user_id};
""".format(content_link=url, user_id=bind_user_id)
data_query = db.session.execute(sql).fetchone()
if not data_query:
return CommonError.error_toast('no match data')
sql = """
INSERT INTO bao_rss_read_record(read_url_id, read_user_id, read_time) VALUES ({read_url_id}, {read_user_id}, '{read_time}');
""".format(read_url_id=data_query['content_id'],
read_user_id=data_query['user_id'],
read_time=get_unix_time_tuple())
data_query = db.session.execute(sql)
db.session.commit()
return response_succ(body=boolValue(True))
def upload():
# 如果是单个文件
# file = request.files["files"]
files: list = request.files.getlist("files")
if len(files) == 0:
return CommonError.get_error(40000)
resp = []
for file in files:
file: FileStorage = file
extension = file.filename.split('.')
ext: str = extension[1]
identifier = str(uuid.uuid4()).replace("-", "") + "." + ext.lower()
try:
rec = fileStorage.save(file, name=identifier)
fileObj = FileModel(file_hash=identifier,
file_name=file.filename,
file_type=file.mimetype)
fileObj.save()
db.session.flush()
fileId = fileObj.file_id
userId = g.current_user.id
relationObj = FileUserModel(user_id=userId, file_id=fileId)
relationObj.save(commit=True)
resp.append({
"origin": file.filename,
"fileName": fileStorage.url(rec)
})
except Exception as e:
current_app.logger.error(e)
print(e)
return CommonError.get_error(9999)
return response_succ(body=resp)
def list_rss():
""" 查看订阅列表 """
params = request.values or request.get_json() or {}
bind_user_id = g.current_user.id
# pages
pages = params.get('pages') or 0
limit = params.get('limit') or 10
sql = ''
sql += """
SELECT bao_rss.rss_id, bao_rss.rss_link, bao_rss.add_time FROM bao_rss
WHERE bao_rss.rss_id IN (
SELECT rss_id FROM bao_rss_user WHERE bao_rss_user.user_id={user_id}
)
ORDER BY add_time DESC LIMIT {limit} OFFSET {offset};
""".format(user_id=bind_user_id, limit=limit, offset=pages * limit)
# sqlalchemy执行sql
data_query = db.session.execute(sql)
total = data_query.rowcount
payload = {}
payload['total'] = total
payload['pages'] = pages
payload['limit'] = limit
payload['list'] = [{
'link': item['rss_link'],
'add_time': item['add_time'],
'id': item['rss_id'],
} for item in data_query.fetchall()]
return response_succ(body=payload)
def encryption(encrypt_type: str = "md5"):
"""
指定加密方式
:param encrypt_type: encryption type default is "md5"...
support
'sha1','md5', 'sha256', 'sha224', 'sha512', 'sha384', 'blake2b',
'blake2s', 'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512',
'shake_128', 'shake_256'
:return:
"""
params = request.values or request.get_json() or {}
print("p = " + str(params))
source = params.get("source")
if not source:
return CommonError.get_error(40000)
code: str = source
encrypt_func = getattr(hashlib, encrypt_type, None) or None
if not encrypt_func:
return CommonError.get_error(40000)
result = encrypt_func(code.encode('utf-8')).hexdigest()
result_map = dict()
result_map["source"] = source
result_map["target"] = result
result_map["type"] = encrypt_type
return response_succ(body=result_map)
def test_f():
params = request.values
payload = {}
payload['rec'] = request.url
payload['params'] = params
payload['host'] = request.host
payload['scheme'] = request.scheme
payload['url'] = url_for('api.task_parser_backend')
return response_succ(body=payload)
def set_nickname():
user: User = g.current_user
params = request.values or request.get_json() or {}
if request.method == "GET":
return response_succ(body={"nickname": user.nickname or ""})
new_name = params.get("nickname") or ''
user.nickname = new_name
db.session.commit()
return user_info()
def parser_rss():
""" 开启解析任务 """
params = request.values or request.get_json() or {}
source = params.get("source")
bind_user_id = g.current_user.id
from celery_tasks.tasks import async_parser_feed
task = async_parser_feed.delay(source, bind_user_id)
result = {}
result['task_id'] = task.id
return response_succ(body=result)
def task_parser_backend():
""" 用于接受解析回调，暂时无用 """
params = request.values or request.get_json() or {}
status = params.get('status')
result = params.get('result')
task_id = params.get('task_id')
payload = {}
payload['status'] = status
payload['result'] = result
payload['task_id'] = task_id
payload['trackback'] = trackback
return response_succ(body=payload)
def query_task():
params = request.values or request.get_json() or {}
key: str = params.get('key') or 'celery*'
if not key:
return CommonError.get_error(40000)
result = redisClient.get('celery-task-meta-'+str(key))
if isinstance(result, bytes):
reuslt = str(result, encoding='utf-8')
result = json.loads(result)
else:
return CommonError.error_toast('no task')
return response_succ(body=result)
def user_info():
user: User = g.current_user
info = {
"nickname":
user.nickname or "",
"email":
user.email,
"token":
user.token,
"background_image":
"http://pic1.nipic.com/2008-08-14/2008814183939909_2.jpg",
}
return response_succ(body=info)
def filter_todo(filter: str = None):
params = request.values or request.get_json() or {}
option_filter = filter or "all"
todos = db.session.query(TodoModel).filter(
TodoModel.bind_user_id == g.current_user.id)
if option_filter == "undo":
todos = todos.filter(TodoModel.todo_state == 1).all()
if option_filter == "done":
todos = todos.filter(TodoModel.todo_state == 2).all()
if option_filter == "all":
todos = todos.filter(TodoModel.todo_state != 3).all()
result = list()
if not todos or len(todos) == 0:
response_succ(body=())
for todo in todos:
result.append({
"todo_id": todo.todo_id,
"todo_title": todo.todo_title,
"todo_state": todo.todo_state
})
return response_succ(body=result)
def delete():
file_id = request.args.get('file_id')
item = db.session.query(FileModel).filter(file_id == file_id).first()
if item:
path = fileStorage.path(item.file_hash)
try:
os.remove(path)
except:
return CommonError.get_error(9999)
item: FileModel = item
item.delete(logic=False)
return response_succ()
return CommonError.get_error(40400)
def add_rss_source():
""" 添加一个订阅源
try add a url to rss list
"""
params = request.values or request.get_json() or {}
source = params.get("source")
if not source:
return CommonError.get_error(40000)
bind_user_id = g.current_user.id
try:
query = """
SELECT * FROM bao_rss WHERE rss_link = '{}';
""".format(source)
exists = db.session.execute(query).fetchone()
rss_id = None
if exists:
rss_id = exists.rss_id
else:
# 查看是否可用
regex = r'(https?)://[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#/%=~_|]'
result = re.match(regex, source)
if not result:
return CommonError.error_toast("wrong link")
rss = RssModel(source)
db.session.add(rss)
db.session.flush() # flush预提交，等于提交到数据库内存
rss_id = rss.rss_id
query = """
SELECT * FROM bao_rss_user WHERE user_id = {} and rss_id = {};
""".format(bind_user_id, rss_id)
relation_id = db.session.execute(query).fetchone()
result = {}
if relation_id:
result["rss_id"] = rss_id
else:
rss_user_relationship = RssUserModel(bind_user_id, rss_id)
db.session.add(rss_user_relationship)
db.session.commit()
result["rss_id"] = rss_id
from celery_tasks.tasks import async_parser_feed
async_parser_feed.delay(source)
return response_succ(body=result)
except Exception as e:
db.session.rollback()
print(e)
return CommonError.get_error(9999)
def listall():
userId = g.current_user.id
allFiles = db.session.query(FileModel).\
filter(FileModel.file_id==FileUserModel.file_id).\
filter(FileUserModel.user_id==userId).all()
payload = []
for file in allFiles:
f: FileModel = file
payload.append({
"name": f.file_name,
"id": f.file_id,
"mimetype": f.file_type,
"hash": f.file_hash,
"url": fileStorage.url(f.file_hash)
})
return response_succ(body=payload)
def register():
params = request.values or request.get_json() or {}
email = params.get("email")
password = params.get("password")
if len(password) != 32:
return CommonError.get_error(40000)
exsist_user = db.session.query(User).filter_by(email=email).first()
if exsist_user:
return UserError.get_error(40200)
salt = current_app.config['SECURITY_PASSWORD_SALT'] or 'token'
token = getmd5("{}{}{}".format(salt, email, get_random_num(5)))
user = User(email=email, password=password, status=1)
user.token = token
db.session.add(user)
db.session.commit()
payload = {}
payload['user_id'] = user.id
return response_succ(body=payload)
def login():
params = request.values or request.get_json() or {}
email = params.get("email")
password = params.get("password")
exsist_user: User = db.session.query(User).filter_by(
email=email, password=password).first()
if exsist_user:
# update token
salt = current_app.config['SECURITY_PASSWORD_SALT'] or 'token'
token = getmd5("{}{}{}".format(salt, email, get_random_num(5)))
exsist_user.token = token
# update log time
record = LoginRecord()
record.user_id = exsist_user.id
record.login_time = get_unix_time_tuple()
record.log_ip = request.args.get("user_ip") or request.remote_addr
db.session.add(record)
db.session.commit()
return response_succ(body={'token': token})
else:
return UserError.get_error(40203)
def email_to():
params = request.values or request.get_json() or {}
subject = params.get('subject')
body = params.get('body')
recs = params.get('recipients')
files = params.get('fileIds')
if not subject or not body or not recs:
return CommonError.get_error(40000)
from celery_tasks.tasks import async_email_to
receivers = []
if isinstance(recs, str):
receivers.append(recs)
elif isinstance(recs, list):
receivers.extend(recs)
fileIds = []
if isinstance(files, str):
fileIds.append(files)
elif isinstance(files, list):
fileIds.extend(files)
result = {}
result['recipients'] = receivers
task = async_email_to.delay(subject=subject, body=body, recipients=receivers, attaches=fileIds)
result['task_id'] = task.id
return response_succ(body=result)
def rss_content_list():
""" 获取可读内容的列表 """
params = request.values or request.get_json() or {}
limit: int
pages: int
offset: int
if g.pageinfo:
limit = g.pageinfo['limit']
offset = g.pageinfo['offset']
pages = g.pageinfo['pages']
time_desc = bool(params.get('time_desc') or 1) # 0 升序 1 降序
filter_rss_ids = params.get('filter_rss_ids')
bind_user_id = g.current_user.id
# query rss_ids
if filter_rss_ids:
filter_rss_ids = [
ids.strip() for ids in str(filter_rss_ids).split(',')
]
filter_rss_ids = ', '.join(filter_rss_ids)
sql = """
SELECT bao_rss_user.rss_id FROM bao_rss_user WHERE bao_rss_user.user_id={user_id} AND bao_rss_user.rss_id IN ( # 筛选选择的rss_id
{filter}
);
""".format(user_id=bind_user_id, filter=filter_rss_ids)
else:
sql = """
SELECT bao_rss_user.rss_id FROM bao_rss_user WHERE bao_rss_user.user_id={user_id}
""".format(user_id=bind_user_id)
# 获得当前当前用户所有订阅的rss_id
data_query = db.session.execute(sql)
all_rss_ids = [str(item['rss_id']) for item in data_query.fetchall()]
if len(all_rss_ids) == 0:
return response_succ(body=[])
query_rss_ids = ', '.join(all_rss_ids)
# 查询 content
sql = """
SELECT * FROM bao_rss_content
WHERE bao_rss_content.content_base IN ( # rss网址
SELECT bao_rss.rss_link FROM bao_rss WHERE bao_rss.rss_id IN ( # 筛选当前用户订阅的地址
{rss_ids}
)
)
AND bao_rss_content.content_title != ''
ORDER BY add_time {order} limit {limit} offset {offset};
""".format(rss_ids=query_rss_ids,
order='DESC' if time_desc else 'ASC',
limit=limit,
offset=offset,
user_id=bind_user_id)
# sqlalchemy执行sql
data_query = db.session.execute(sql)
total = data_query.rowcount
payload = {}
payload['total'] = total
payload['pages'] = pages
payload['limit'] = limit
payload['list'] = [{
'link': item['content_link'],
'base': item['content_base'],
'domain': get_domain(item['content_base']),
'add_time': item['add_time'],
'published_time': float(item['published_time']),
'title': item['content_title'],
'id': item['content_id'],
'cover_img': item['content_image_cover'],
} for item in data_query.fetchall()]
return response_succ(body=payload)
def index():
return response_succ(body="hahaha")
def logout():
return response_succ(body="loged out")
