def find_or_create_thumbnail(self, width=None, height=None):
"""
Creates a thumbnail image from the original if one of the same size
does not already exist. Width OR height must be provided. It is not
necessary to provide both.
Default Image (We should act on this in the future)
http://affimg.tfaw.com/covers_tfaw/400/no/nocover.jpg
:param issue: :class:`Issue` object class
:param width: Width of desired thumbnail image
:param height: Height of desired thumbnail image
"""
assert width is not None or height is not None
image = None
if self.cover_image:
with store_context(store):
try:
image = self.cover_image.find_thumbnail(
width=width,
height=height)
except NoResultFound:
image = self.cover_image.generate_thumbnail(
width=width,
height=height)
self.save()
return image
def delete_category(category_id):
if 'username' not in login_session:
return redirect('/login')
delete_me = db_session.query(
Category).filter_by(id=category_id).one()
if delete_me.user_id != login_session['user_id']:
return """<script>function myFunction() {
alert('You are not authorized to edit this category.
Please create your own category in order to edit.');
} </script><body onload='myFunction()''>"""
if request.method == 'POST':
with store_context(local_storage):
db_session.delete(delete_me)
flash('%s Successfully Deleted' % delete_me.name)
db_session.commit()
return redirect(url_for('show_categories',
category_id=category_id,
username=login_session["username"],
categories=db_session.
query(Category).order_by(asc(Category.name))))
else:
return render_template('delete_category.html',
category=delete_me,
username=login_session["username"],
categories=db_session.
query(Category).order_by(asc(Category.name)))
def to_dict(self):
with store_context(fs_store):
return dict(
created_time = self.created_time.isoformat(),
updated_time = self.updated_time.isoformat(),
id = self.id
)
def create_news():
entity = news.News(
title = request.json['title']
, content = request.json['content']
, news_language = request.json['news_language']
)
entity.is_draft = False
entity.update_time = datetime.datetime.now()
entity.create_time = datetime.datetime.now()
entity.author = '管理员'
entity.view_count = 0
entity.awesome_count = 0
if(len(request.json['video_link']) != 0):
entity.has_video = True
entity.video_link = request.json['video_link']
else:
entity.has_video = False
try:
with store_context(fs_store):
if(request.json['temp_image'] is not None):
with open(files.path(request.json['temp_image'])) as f:
entity.icon.from_file(f)
db.session.add(entity)
db.session.commit()
return jsonify(entity.to_dict()), 201
else:
abort(500)
except Exception, e:
raise e
abort(500)
def make_test_data():
categories = ['Popular', 'Health Diet', 'Train plans', 'Habits', 'Learning']
for cat in categories:
db.session.add(Category(cat, ''))
goals = [
['Drink water','description','Popular'],
['Make love Every Day','description','Popular'],
['Write article ','description','Popular'],
['Do fitness','description','Health Diet'],
['Watch Movie','description','Train plans']
]
db.session.commit()
c = Category.query.filter(Category.category_name=='Popular').first()
g_list = []
with store_context(fs_store):
for g in goals:
goal = Goal(g[0], g[1])
with open('pic1.jpg','rb') as f:
goal.image.from_blob(f.read())
g_list.append(goal)
db.session.add(goal)
c.goals = g_list
db.session.add(c)
db.session.commit()
def new_item(category_id):
if 'username' not in login_session:
return redirect('/login')
category = db_session.query(Category).filter_by(id=category_id).one()
all_categories = db_session.query(Category).order_by(asc(Category.name))
if request.method == 'POST':
try:
photo = request.files.get('photo')
new_item = CategoryItem(name=request.form['name'],
description=request.
form['description'],
category_id=category_id)
with store_context(local_storage):
new_item.picture.from_file(photo)
new_item.picture.generate_thumbnail(width=300)
db_session.add(new_item)
db_session.commit()
except:
flash("Item creation failed")
return redirect(url_for('show_items',
category_id=category_id,
categories=all_categories))
flash('New %s Item Successfully Created' % (new_item.name))
return redirect(url_for('show_items',
category_id=category_id,
categories=all_categories))
else:
return render_template('new_item.html',
category_id=category_id,
categories=all_categories)
def update_news(id):
entity = news.News.query.get(id)
if not entity:
abort(404)
entity.title = request.json['title']
entity.content = request.json['content']
entity.news_language = request.json['news_language']
if(request.json['video_link'] is not None and len(request.json['video_link']) > 0):
entity.has_video = True
entity.video_link = request.json['video_link']
else:
entity.has_video = False
entity.video_link = None
entity.update_time = datetime.datetime.now()
try:
with store_context(fs_store):
if('temp_image' in request.json.keys() and request.json['temp_image'] is not None):
with open(files.path(request.json['temp_image'])) as f:
entity.icon.from_file(f)
db.session.merge(entity)
db.session.commit()
else:
db.session.merge(entity)
db.session.commit()
return jsonify(entity.to_dict()), 200
except Exception, e:
raise e
abort(500)
def get(self, goal_id):
g = Goal.query.filter(Goal.goal_id==goal_id).first()
if g:
with store_context(fs_store):
return {'image': g.image.locate()}, 200
else:
abort(404, message="Image not found")
def delete(goal_id):
goal = Goal.query.filter(Goal.goal_id==goal_id).first()
if goal:
with store_context(fs_store):
db.session.delete(goal)
db.session.commit()
return redirect('/backend/goal')
def register():
"""
User registeration
#TODO duplicative code
"""
if user.User.query.filter(user.User.name == request.json['name']).count() > 0:
abort(500)
if user.User.query.filter(user.User.account == request.json['account']).count() > 0:
abort(500)
entity = user.User(
account = request.json['account']
, password = request.json['password']
, name = request.json['name']
, company = request.json['company']
, nickname = request.json['company']
, phone_number = request.json['phone_number']
, email = request.json['email']
, title = request.json['title']
)
entity.registered_time = datetime.datetime.now().date();
entity.lastlogin_time = datetime.datetime.now().date();
entity.myattr = '' #无用字段
entity.is_active = True
entity.is_vip = False
entity.role = 'user'
try:
with store_context(fs_store):
with open('app/static/image/default_header.png') as f:
entity.generate_token()
entity.header_icon.from_file(f)
db.session.add(entity)
db.session.commit()
return jsonify(entity.to_dict()), 201
except Exception, e:
abort(500)
def to_dict(self):
with store_context(fs_store):
header_large_url = ''
header_small_url = ''
try:
header_large_url = find_or_create_thumbnail(self, self.header_icon, HEADER_SIZE_LARGE).locate()
header_small_url = find_or_create_thumbnail(self, self.header_icon, HEADER_SIZE_SMALL).locate()
except Exception, e:
pass
return dict(
account = self.account,
name = self.name,
role = self.role,
email = self.email,
password = '',
nickname=self.nickname,
registered_time = self.registered_time.isoformat(),
is_active = self.is_active,
phone_number = self.phone_number,
description = self.description,
lastlogin_time = self.lastlogin_time.isoformat(),
myattr = self.myattr,
token = self.token,
id = self.id,
is_vip = self.is_vip,
zone = self.zone,
work_phone = self.work_phone,
title = self.title,
department = self.department,
company = self.company,
header_large = header_large_url,
header_small = header_small_url
)
def header_json(self):
with store_context(fs_store):
return {
'user_id' : self.user_id,
'header' : _find_or_create_thumbnail(self, self.header_icon,48).locate(),
'user_name' : self.name
}
def create_user():
if user.User.query.filter(user.User.name == request.json['name']).count() > 0:
abort(500)
if user.User.query.filter(user.User.account == request.json['account']).count() > 0:
abort(500)
entity = user.User(
account = request.json['account']
, password = request.json['password']
, name = request.json['name']
, is_vip = request.json['is_vip']
, nickname = request.json['nickname']
, company = request.json['nickname']
, description = request.json['description']
)
entity.registered_time = datetime.datetime.now().date();
entity.lastlogin_time = datetime.datetime.now().date();
entity.myattr = ''
entity.is_active = True
entity.role = 'user'
entity.company = ''
#header = get('http://ww3.sinaimg.cn/mw690/63ea4d33gw1ejhpwui71sj20u00k045s.jpg').content
try:
with store_context(fs_store):
with open('app/static/image/default_header.png') as f:
entity.generate_token()
entity.header_icon.from_file(f)
db.session.add(entity)
db.session.commit()
return jsonify(entity.to_dict()), 201
except Exception, e:
abort(500)
def edit(goal_id):
if request.method == 'POST':
gf = GoalForm()
names = gf.category_name.data.split(",")
g = Goal.query.filter(Goal.goal_id==goal_id).first()
g = gf.to_goal(g)
for c in g.categories:
g.categories.remove(c)
categorys = Category.query.filter(Category.category_name.in_(names)).all()
if len(categorys) > 0:
for c in categorys:
g.categories.append(c)
with store_context(fs_store):
if gf.validate():
g.image.from_file(request.files['image'])
db.session.add(g)
db.session.commit()
return redirect(url_for('goal.edit', goal_id=goal_id))
elif request.method == 'GET':
form = GoalForm()
categorys = Category.query.all()
names = ",".join([c.category_name for c in categorys])
goal = Goal.query.filter(Goal.goal_id==goal_id).first()
form.set_by_goal(goal)
return render_template('backend/goal-edit.html', goal=goal, category_names=names, form=form)
def show_items(category_id):
if 'username' in login_session:
username = login_session["username"]
else:
username = None
category = db_session.query(Category).filter_by(id=category_id).one()
items = db_session.query(CategoryItem).filter_by(
category_id=category_id).all()
with store_context(local_storage):
if username is not None and \
category.user_id == login_session['user_id']:
return render_template('owner_items.html',
items=items,
category=category,
username=username,
categories=db_session.
query(Category).
order_by(asc(Category.name)))
else:
return render_template('items.html',
items=items,
category=category,
username=username,
categories=db_session.
query(Category).
order_by(asc(Category.name)))
def set_cover_image_from_url(self, url, overwrite=False, comparison=None,
timeout=5):
"""
Downloads a jpeg file from a url and stores it in the image store.
:param issue: :class:`Issue` object class
:param url: URL to download the jpeg cover image format
:param overwrite: Boolean flag that overwrites an existing image
"""
created_flag = False
try:
if not self.cover_image.original or overwrite:
r = requests.get(url, timeout=timeout)
if r.status_code==200 and r.headers['content-type']=='image/jpeg':
if comparison:
with open(comparison) as f:
comparison_byte_string = f.read()
if compare_images(r.content, comparison_byte_string):
message = '%s is missing a cover image' % self.complete_title
raise MissingCoverImageError(message)
else:
print 'Unique Image found for %s' % self.complete_title
with store_context(store):
self.cover_image.from_blob(r.content)
self.save()
self.cover_image.generate_thumbnail(height=600)
self.save()
created_flag = True
except Exception, err:
print 'Exception caught in set_cover_image_from_url', err
def delete_news(id):
entity = news.News.query.get(id)
if not entity:
abort(404)
with store_context(fs_store):
db.session.delete(entity)
db.session.commit()
return '', 204
def delete_user(id):
entity = user.User.query.get(id)
if not entity:
abort(404)
with store_context(fs_store):
entity.is_active = False
db.session.merge(entity)
db.session.commit()
return '', 204
def set_splash(self, image, overwrite=False):
if not self.splash.original or overwrite:
try:
print 'Setting splash image for %s...' % self.name
with store_context(store):
self.splash.from_file(image)
self.save()
except Exception:
print 'Could not set %s splash rolling back session' % self.name
db.session.rollback()
def to_json(self):
with store_context(fs_store):
return {
'goal_id' : self.goal_id,
'goal_name' : self.goal_name,
'description' : self.description + '',
'joins' : self.goal_joins.count(),
'image' : self.image.locate(),
'joins' : self.participation
}
def serialize(self):
"""Return object data in easily serializable format"""
with store_context(local_storage):
return {
'name': self.name,
'description': self.description,
'id': self.id,
'picture': self.picture.locate(),
'thumbnail': self.picture.find_thumbnail(width=300).locate()
}
def add_topic_image(id):
image = get('http://ww3.sinaimg.cn/mw690/63ea4d33gw1ejhpwui71sj20u00k045s.jpg').content
with store_context(fs_store):
t_image = news.TopicImage(
topic_id=entity.id
)
t_image.image.from_blob(image)
db.session.add(t_image)
db.session.commit()
return jsonify(dict(result='success'))
def to_json(self):
with store_context(fs_store):
return {
'goal_id' : self.goal_id,
'goal_name' : self.goal_name,
'description' : self.description + '',
'joins' : self.goal_joins.count(),
'image' : self.image.locate(),
'joins' : self.goal_joins.count() + random.randint(1000,2000)
}
def to_dict(self):
with store_context(fs_store):
return dict(
id=self.id,
order=self.order,
name=self.name,
link=self.link,
news_id=self.news_id,
visiable = self.visiable
)
def to_json_with_header(self):
with store_context(fs_store):
return {
'goal_id' : self.goal_id,
'goal_name' : self.goal_name,
'description' : self.description + '',
'joins' : self.goal_joins.count(),
'image' : self.image.locate(),
'joins' : self.participation,
'joined_users' : [ghj.user.header_json() for ghj in self.goal_history_joins.limit(5)]
}
def to_details_json(self):
with store_context(fs_store):
return {
'goal_id' : self.goal_id,
'goal_name' : self.goal_name,
'description' : self.description + '',
'joins' : self.goal_joins.count(),
'goal_records': [gr.to_preview_json() for gr in self.goal_records.limit(5)],
'image' : self.image.locate(),
'joins' : self.goal_history_joins.count()
}
def to_details_json(self):
with store_context(fs_store):
return {
'goal_id' : self.goal_id,
'goal_name' : self.goal_name,
'description' : self.description + '',
'joins' : self.goal_joins.count(),
'goal_records': [gr.to_preview_json() for gr in self.goal_records],
'image' : self.image.locate(),
'joins' : self.goal_joins.count() + random.randint(1000,2000)
}
def to_preview_json(self, user=None):
with store_context(fs_store):
return {
'goal_record_id': self.goal_record_id,
'goal_id' : self.goal_id,
'content' : self.content,
'comments' : [c.to_json() for c in self.comments.limit(5)],
'awesomes' : [a.to_preview_json() for a in self.awesomes.limit(5)],
'goal_name' : self.parent_goal.goal_name,
"publisher" : self.publisher.header_json(),
'create_time': stime.mktime(self.create_time.timetuple())
}
def to_json(self, user):
with store_context(fs_store):
return {
'goal_record_id': self.goal_record_id,
'goal_id' : self.goal_id,
'content' : self.content,
#'image' : self.image.locate(),
'comments' : [c.to_json() for c in self.comments.all()],
'awesomes' : [a.to_json() for a in self.awesomes.all()],
'can_awesome' : self.__can_awesome(user),
'create_time': stime.mktime(self.create_time.timetuple())
}
def check_cover_image(self, image1, image2=None):
if not image2:
try:
with store_context(store):
if self.cover_image.original:
return compare_images(image1, self.cover_image.make_blob())
else:
return False
except IOError:
print 'IOError: Missing image - deleting...'
self.cover_image.delete()
self.save()
else:
return compare_images(image1, image2)
def remove_cover_image(self, thumb_dimensions=[]):
with store_context(store):
for width in thumb_dimensions:
try:
print 'Removing %i thumbnail' % width
image = self.cover_image.find_thumbnail(width=width)
store.delete(image)
except NoResultFound:
print 'Failed to remove %i image, no thumbnail found...' % width
try:
print "Removing original image..."
store.delete(self.cover_image.original)
self.cover_image.delete()
self.save()
except NoResultFound:
print 'Failed to remove cover image, no original image...'
return
def set_logo_bw(self, image, thumb_dimensions=[512, 256], overwrite=False):
if not self.logo_bw.original or overwrite:
try:
print 'Setting b&w logo image for %s...' % self.name
with store_context(store):
self.logo_bw.from_file(image)
self.save()
if self.logo_bw.original.height > self.logo_bw.original.width:
for height in thumb_dimensions:
print ' Generating h%i px thumbnail...' % height
self.logo_bw.generate_thumbnail(height=height)
else:
for width in thumb_dimensions:
print ' Generating w%i px thumbnail...' % width
self.logo_bw.generate_thumbnail(width=width)
self.save()
except Exception, err:
print 'Could not set %s logo, rolling back session' % self.name
print ' Error: %s' % err
db.session.rollback()
def get_cover_image_file(self):
f = None
if self.cover_image.original:
with store_context(store):
f = self.cover_image.open_file()
return f
