def like_dynamic(request):
body = json.loads(request.body)
dynamic_id = body.get('id')
operator = body.get('phone_number')
try:
like = Like.objects.get(dynamic_id=dynamic_id, operator=operator)
except Like.DoesNotExist:
like = Like(dynamic_id=dynamic_id, operator=operator, status=1)
like.save()
return util.success_response(status=1)
like.status = not like.status
like.save()
return util.success_response(status=like.status)
def query_note():
query = request.json
if not query:
return util.error_response('bad request')
if 'url' in query:
note = db.get_note_with_url(query['url'])
return util.success_response({'note': note})
if 'alias' in query:
note = db.get_note_with_alias(query['alias'])
return util.success_response({'note': note})
if 'type' in query:
notes = db.query_notes_by_type(query['type'])
return util.success_response({'notes': notes})
else:
return util.error_response('bad request')
def delete_dynamic(request):
body = json.loads(request.body)
id = body.get('id')
dynamic = Dynamic.objects.get(id=id)
dynamic.status = 0
dynamic.save()
return util.success_response()
def comment_dynamic(request):
body = json.loads(request.body)
dynamic_id = body.get('id')
phone_number = body.get('phone_number')
text = body.get('text')
comment = Comment(operator=phone_number, text=text, dynamic_id=dynamic_id)
comment.save()
return util.success_response()
def delete_user(username):
user = User.get_user(username)
if user is None:
raise NotFound(username)
if user.delete():
return util.success_response()
else:
raise Exception('deletion failed')
def put_note(note_id):
note = request.json
print note
note['id'] = note_id
if noter.put_note(note):
return util.success_response()
else:
return util.error_response('put error')
def login(request):
body = json.loads(request.body)
user_info = UserInfo()
user_info.phone_number = body.get("phone_number")
user_info.password = body.get("password")
success = user_info.verify()
if success:
return util.success_response()
else:
return util.exception_response(LOGIN_FAIL)
def get_task(task_id):
user = get_current_user()
task = get_task_by_id(task_id)
if not task:
return failure_response('Task does not exist.', 404)
if task.owner.id != user.id:
return failure_response('Access denied.', 403)
return success_response(get_task_info(task))
def get_file(file_id):
user = get_current_user()
f = get_file_by_id(file_id)
if not f:
return failure_response('File does not exist.', 404)
if f.owner.id != user.id:
return failure_response('Access denied.', 403)
return success_response(get_file_info(f))
def get_notes(q=None):
page = max(int(request.args.get('page', 1)), 1)
size = max(int(request.args.get('size', 20)), 1)
#owner_username = request.args.get('owner')
owner_username = conf.owner
owner = User.get_user(owner_username)
if owner:
visitor = util.get_visitor()
q = q or {}
q.update({
'owner': owner['username'],
})
if not util.is_owner(visitor, owner):
q.update({'tags': {'$not': {'$eq': '.'}}})
r = noter.get_notes({
'skip': (page - 1) * size,
'size': size,
'qs': [q],
})
return util.success_response({
'notes': r['notes'],
'skip': r['skip'],
'total': r['total'],
'pagination': {
'page': page,
'size': size,
'nPages': (r['total'] + size - 1) / size,
}
})
else:
return util.success_response({
'notes': [],
'skip': 0,
'total': 0,
'pagination': {
'page': page,
'size': size,
'nPages': 0,
}
})
def delete_file(file_id):
user = get_current_user()
f = get_file_by_id(file_id)
if not f:
return failure_response('File does not exist.', 404)
if f.owner.id != user.id:
return failure_response('Access denied.', 403)
remove_file(f)
return success_response(status_code=204)
def terminate_running_task():
user = get_current_user()
task = get_running_task()
if not task:
return failure_response('No running tasks.', 404)
if task.owner.id != user.id:
return failure_response('Access denied.', 403)
kill_running_task()
return success_response(status_code=204)
def get_custom_url(path):
if not path:
return error_response('invalid path')
if not path.startswith('/'):
path = '/' + path
doc = mongodb.doc.find_one({'custom_url': path})
if not doc:
return error_response('Oops, not found', 404)
return success_response({
'type': 'blog',
'blog': doc,
})
def check_running_task():
user = get_current_user()
task = get_running_task()
if task:
if task.owner.id == user.id:
response = {'running': True, 'task': get_task_info(task)}
else:
response = {'running': True}
else:
response = {'running': False}
return success_response(response)
def put_user_info(username):
visitor = util.get_visitor()
if not visitor or visitor['username'] != username:
raise Error('you are not {}'.format(username))
user = User.get_user(username)
if user is None:
raise NotFound(username)
user_dict_patch = request.json
if not user_dict_patch:
raise Error('empty update')
if user.update(user_dict_patch):
return util.success_response()
else:
raise Error('update failed')
def login():
username = request.form.get('username')
password = request.form.get('password')
r = validate_not_empty(username, 'username') and \
validate_not_empty(password, 'password')
if not r:
return failure_response(str(r))
if check_credentials(username, password):
session['user'] = get_id_by_username(username)
return success_response()
else:
return failure_response('Wrong credentials.', 401)
def register(request):
body = json.loads(request.body)
user_info = UserInfo()
user_info.user_name = body.get("user_name")
user_info.password = body.get("password")
user_info.phone_number = body.get("phone_number")
exist = UserInfo.objects.filter(phone_number=user_info.phone_number)
if len(exist) != 0:
return util.exception_response(PHONE_NUMBER_EXIST)
try:
user_info.save()
except ValueError or KeyError:
print(traceback)
return util.exception_response(REGISTER_FAIL)
return util.success_response()
def upload_avatar(request):
phone_number = request.POST['phone_number']
avatar = request.FILES.get('avatar')
kind = filetype.guess(avatar)
if kind is None:
return util.exception_response("")
if kind.extension not in ['jpg', 'png', 'gif']:
return util.exception_response(FILE_FORMAT_ERROR)
fs = FileSystemStorage(location=settings.AVATAR_PATH)
file_name = 'avatar.' + kind.extension
new_name = fs.save(file_name, avatar)
try:
UserInfo.objects.get(phone_number=phone_number)
UserInfo.objects.filter(phone_number=phone_number).update(
avatar=new_name)
except UserInfo.DoesNotExist:
return util.exception_response(USER_NOT_EXIST)
return util.success_response()
def upload_file():
user = get_current_user()
f = request.files.get('file')
if not f or not f.filename:
return failure_response('No file uploaded.')
if is_bad_filename(f.filename):
return failure_response('Invalid filename.')
if not f.filename.lower().endswith('.csv'):
return failure_response("File extension should be '.csv'.")
r = upload_source_file(f, user)
if r:
return success_response(r, 201)
else:
return failure_response('Filename already exists.')
def search_read(text, pattern):
if not pattern.strip():
return error_response('invalid pattern')
offsets = [m.start() for m in re.finditer(pattern, text)]
more = False
if len(offsets) > 100:
offsets = offsets[:100]
more = True
return success_response({
'occurrences': [{
'pattern': pattern,
'offset': offset,
'context': text[max(0, offset - 100):offset + 100],
'contextOffset': offset - max(0, offset - 100),
} for offset in offsets],
'more':
more,
})
def get_gallery():
data = flask.request.json
srcs = []
files = [f.encode('utf8') for f in data['files']]
for path in files:
srcs.append(os.path.join('/file', path))
paths = [f.encode('utf8') for f in data['paths']]
for path in paths:
dirpath = util.rooted_path(conf.FILES_ROOT, path)
srcs.extend(
os.path.join('/file', path, fname)
for fname in sorted(os.listdir(dirpath))
if not fname.startswith('tmp-'))
return success_response({
'srcs': srcs,
})
def send(request):
phone_number = request.POST['phone_number']
photo = request.FILES.get('photo')
text = request.POST['text']
dynamic = Dynamic()
if photo is not None:
kind = filetype.guess(photo)
if kind is None:
return util.exception_response("")
if kind.extension not in ['jpg', 'png', 'gif']:
return util.exception_response(FILE_FORMAT_ERROR)
file_path = os.path.join(settings.PHOTO_PATH, phone_number)
fs = FileSystemStorage(location=file_path)
file_name = 'photo.' + kind.extension
new_name = fs.save(file_name, photo)
dynamic.photo = new_name
dynamic.phone_number = phone_number
dynamic.text = text
dynamic.save()
return util.success_response()
def get_statistics():
blogs = db.query('''
match (blog:Blog)-[:has_tag]->(:Tag{content: "leetcode"})
return blog
''',
cols=1)
blogs.sort(key=lambda blog: parse_datetime(blog['ctime']))
blogs_by_day = [{
'blogs': list(g),
'date': date
} for date, g in itertools.groupby(
blogs, lambda blog: ctime_to_date(blog['ctime']))]
blog_links = [[{
'url': '/blog/{}'.format(blog['id']),
'date': blog['ctime'],
'title': json.loads(blog['leetcode'])['title']
} for blog in item['blogs']] for item in blogs_by_day]
date_beg = blogs_by_day[0]['date']
date_end = blogs_by_day[-1]['date']
n_days = (date_end - date_beg).days + 1
all_blogs_by_day = [{
'date': date_beg + timedelta(days=i),
'blogs': [],
} for i in xrange(n_days)]
for item in blogs_by_day:
idx = (item['date'] - date_beg).days
all_blogs_by_day[idx]['date'] = item['date']
all_blogs_by_day[idx]['blogs'] = item['blogs']
dates = [item['date'] for item in all_blogs_by_day]
counts = [len(item['blogs']) for item in all_blogs_by_day]
data = {
'dates': dates,
'counts': counts,
'blog_links': blog_links,
'total': sum(counts),
}
return success_response(data)
def get_read(blog_id):
return error_response('todo')
args = flask.request.args
page = int(args.get('page', 1))
page_size = int(args.get('size', 1000))
offset = int(args.get('offset', '0'))
user = user_util.current_user()
blog = db.query('match (blog:Blog{id: {id}}) return blog', {
'id': blog_id,
},
one=True)
attrs = json.loads(blog['attrs'])
if not blog:
return error_response('not found')
path = blog['path']
if path.startswith('/'):
path = path[1:]
if path.startswith('file'):
path = path[4:]
if path.startswith('/'):
path = path[1:]
fpath = util.rooted_path(conf.FILES_ROOT, path).encode('utf8')
text = load_text(fpath, attrs['encoding'])
if 'search' in args:
return search_read(text, args['search'])
content = get_content(text, page, page_size, offset)
return success_response({
'content': content,
'name': attrs['name'],
'attrs': json.dumps(attrs),
})
def list_all_tasks():
user = get_current_user()
return success_response([get_task_info(t) for t in user.tasks])
def add_task():
user = get_current_user()
tweets_file = request.form.get('tweets_file')
userinfo_file = request.form.get('userinfo_file')
tag = request.form.get('tag')
min_topics = request.form.get('min_topics')
max_topics = request.form.get('max_topics')
iterations = request.form.get('iterations')
keyword = request.form.get('keyword')
r = validate_not_empty(tweets_file, 'tweets_file') and \
validate_positive_integer(tweets_file, 'tweets_file') and \
validate_not_empty(userinfo_file, 'userinfo_file') and \
validate_positive_integer(userinfo_file, 'userinfo_file') and \
validate_not_empty(tag, 'tag') and \
validate_safe_name(tag, 'tag') and \
validate_not_empty(min_topics, 'min_topics') and \
validate_positive_integer(min_topics, 'min_topics') and \
validate_not_empty(max_topics, 'max_topics') and \
validate_positive_integer(max_topics, 'max_topics') and \
validate_not_empty(iterations, 'iterations') and \
validate_positive_integer(iterations, 'iterations') and \
validate_not_empty(keyword, 'keyword')
if not r:
return failure_response(str(r))
tweets_file = int(tweets_file)
userinfo_file = int(userinfo_file)
min_topics = int(min_topics)
max_topics = int(max_topics)
iterations = int(iterations)
tweets_file = get_file_by_id(tweets_file)
if not tweets_file:
return failure_response('tweets_file does not exist.', 404)
if tweets_file.owner.id != user.id:
return failure_response('tweets_file access denied.', 403)
if tweets_file.file_type != 'source':
return failure_response('tweets_file is not a source file')
userinfo_file = get_file_by_id(userinfo_file)
if not userinfo_file:
return failure_response('userinfo_file does not exist.', 404)
if userinfo_file.owner.id != user.id:
return failure_response('userinfo_file access denied.', 403)
if userinfo_file.file_type != 'source':
return failure_response('userinfo_file is not a source file')
if min_topics < 3 or max_topics < 3:
return failure_response('the number of topics should be at least 3')
if min_topics > max_topics:
return failure_response('require min_topics <= max_topics')
params = {
'min_topics': min_topics,
'max_topics': max_topics,
'iterations': iterations,
'keyword': keyword
}
with multiprocessing.Lock():
if get_running_task():
return failure_response('A task is already running on the server.')
r = create_training_task(user, tweets_file, userinfo_file, tag, params)
if r:
return success_response(r, 201)
else:
return failure_response('A task with the same tag already exists.')
def check_login():
return success_response(bool(session.get('user')))
def logout():
session.pop('user', None)
return success_response(status_code=204)
def list_all_files():
user = get_current_user()
return success_response([get_file_info(f) for f in user.files])
def _token_response(token):
r = util.success_response({'token': token})
# cookie should for eno.zone when user visiting e.g. fans656.eno.zone
r.set_cookie('token', token, domain=get_primary_domain())
return r
