def seed_images(): demo = Image(postId=1, imgUrl="http://fantsy-app.s3.amazonaws.com/EzgdmaCQuT84bgDL4fhXZS.jpg") db.session.add(demo) demo2 = Image(postId=2, imgUrl="http://fantsy-app.s3.amazonaws.com/31531798_10211165893878446_1339226057647063040_n.jpg") db.session.add(demo2) demo3 = Image(postId=3, imgUrl="http://fantsy-app.s3.amazonaws.com/0bvu6xbvqk331.jpg") db.session.add(demo3) demo4 = Image(postId=4, imgUrl="http://fantsy-app.s3.amazonaws.com/13906815_10206659420339424_2444900124464175857_n.jpg") db.session.add(demo4) demo5 = Image(postId=5, imgUrl="http://fantsy-app.s3.amazonaws.com/unnamed.jpg") db.session.add(demo5) db.session.commit() # for i in range(30): # postId = random.randint(1, 30) # imgUrl = fake.image_url() # fakeImages = Image(postId=postId, imgUrl=imgUrl) # db.session.add(fakeImages) db.session.commit()
def seed_images():
demo = Image(
postId=1,
imgUrl="http://fantsy-app.s3.amazonaws.com/EzgdmaCQuT84bgDL4fhXZS.jpg")
db.session.add(demo)
demo2 = Image(
postId=2,
imgUrl=
"http://fantsy-app.s3.amazonaws.com/31531798_10211165893878446_1339226057647063040_n.jpg"
)
db.session.add(demo2)
demo3 = Image(
postId=3,
imgUrl="http://fantsy-app.s3.amazonaws.com/0bvu6xbvqk331.jpg")
db.session.add(demo3)
demo4 = Image(
postId=4,
imgUrl=
"http://fantsy-app.s3.amazonaws.com/13906815_10206659420339424_2444900124464175857_n.jpg"
)
db.session.add(demo4)
demo5 = Image(postId=5,
imgUrl="http://fantsy-app.s3.amazonaws.com/unnamed.jpg")
db.session.add(demo5)
db.session.commit()
db.session.commit()
def test_data_add(self):
admin = User(username='******')
admin.set_password('admin')
user = User(username='******')
user.set_password('user')
db.session.add_all([admin, user])
db.session.commit()
gcs = storage.Client.from_service_account_json(
os.path.join(basedir, GOOGLE_AUTH))
bucket = gcs.bucket(BUCKET_NAME)
now = str(int(time.time()))
filename_01 = 'photo-1555874952-65f9f7004a62.jpeg'
n_filename_01 = now + '_' + filename_01
filename_02 = 'photo-1555874952-2129e5cba057.jpeg'
n_filename_02 = now + '_' + filename_02
bolb_01 = bucket.blob(n_filename_01)
bolb_01.upload_from_filename(
os.path.join(basedir, 'app/static/img/', filename_01))
bolb_01.make_public()
bolb_02 = bucket.blob(n_filename_02)
bolb_02.upload_from_filename(
os.path.join(basedir, 'app/static/img/', filename_02))
bolb_02.make_public()
img_01 = Image(title='imgtest1',
src=n_filename_01,
description='Image Test 01',
user_id=user.id,
created_at=datetime.datetime.now())
img_02 = Image(title='imgtest2',
src=n_filename_02,
description='Image Test 02',
user_id=admin.id,
created_at=datetime.datetime.now())
db.session.add_all([img_01, img_02])
db.session.commit()
comment_01 = Comment(
content='Comment Test 01 on Image Test 01 comment by user',
user_id=user.id,
image_id=img_01.id,
created_at=datetime.datetime.now())
comment_02 = Comment(
content='Comment Test 02 on Image Test 01 comment by admin',
user_id=admin.id,
image_id=img_01.id,
created_at=datetime.datetime.now())
comment_03 = Comment(
content='Comment Test 03 on Image Test 02 comment by user',
user_id=user.id,
image_id=img_01.id,
created_at=datetime.datetime.now())
db.session.add_all([comment_01, comment_02, comment_03])
db.session.commit()
def import_image(guid, path, add_to_class, add_to_id):
try:
# Saving the image to a new file
user = User.get_by_guid_or_404(guid)
image = Image(path)
image.description = 'Image uploaded by {}'.format(user.username)
db.session.add(image)
if add_to_class == 'User':
add_to_user = User.query.get(add_to_id)
add_to_user.profile_picture = image
elif add_to_class == 'Event':
add_to_event = Event.query.get(add_to_id)
add_to_event.image = image
elif add_to_class == 'EventUser':
add_to_eventuser = EventUser.query.get(add_to_id)
add_to_eventuser.profile_picture = image
elif add_to_class == 'Expense':
add_to_expense = Expense.query.get(add_to_id)
add_to_expense.image = image
elif add_to_class == 'Settlement':
add_to_settlement = Settlement.query.get(add_to_id)
add_to_settlement.image = image
db.session.commit()
# Create thumbnails
create_thumbnails(image, update_progress=True)
except:
_set_task_progress(100)
app.logger.error('Unhandled exception', exc_info=sys.exc_info())
def index():
if current_user.is_authenticated:
form = PostForm()
#Đăng post
if form.validate_on_submit():
p = Post(body=form.body.data, author_id = current_user.id)
db.session.add(p)
db.session.commit()
if form.image.data:
i = Image(post_id=p.id)
db.session.add(i)
db.session.commit()
f = form.image.data
filename = secure_filename(str(i.uuid) + '.png')
f.save(os.path.join(current_app.config.get('BASEDIR'), 'app/static/img/post', filename))
pn = PostNoti(user_id=current_user.id, post_id=p.id)
db.session.add(pn)
db.session.commit()
flash('Đăng thành công.')
return redirect(url_for('main.index'))
recommend = ml.recommend(current_user.id)[:4]
for i in range(len(recommend)):
recommend[i] = User.query.get(recommend[i][0])
page = request.args.get('page', 1, type=int)
pagination = current_user.followed_posts.filter(Post.author != current_user).order_by(Post.created.desc()).paginate(page, per_page=20, error_out=False)
posts = pagination.items
return render_template('index.html', form=form, posts=posts, pagination=pagination, recommend=recommend)
else:
return render_template('intro.html')
def addImage(concept, searchWord):
form = AddImage()
if form.validate_on_submit():
user_img = Image.query.filter_by(image=form.image.data).first()
if user_img is None:
image = Image(image=form.image.data)
image.searchWord = searchWord
image.concept = concept
image.verified = '0'
image.deleted = '0'
db.session.add(image)
rel_searchWord = SearchWord.query.filter_by(searchWord=searchWord).first()
rel_searchWord.num_im = int(rel_searchWord.num_im) + 1
rel_concept = Concept.query.filter_by(concept=concept).first()
rel_concept.num_im = int(rel_concept.num_im) + 1
db.session.commit()
return redirect(url_for('addImage', searchWord=searchWord, concept=concept))
else:
if str(user_img.deleted)=='1':
user_img.deleted='0'
user_img.timestamp=datetime.utcnow()
db.session.commit()
images = Image.query.filter_by(concept=concept, searchWord=searchWord, deleted='0').order_by(Image.timestamp.desc())
return render_template("images.html", concept=concept, form=form,
searchWord=searchWord, images=images)
def post(self, request, *args, **kwargs):
if len(Item.objects.filter(user=request.user)) > 500:
return redirect('home')
form = self.form_class(request.POST)
if form.is_valid():
item_data = {
k: v
for k, v in form.cleaned_data.items() if 'image' not in k
}
item_data['user'] = request.user
categories = item_data.pop('categories')
item = Item(**item_data)
item.save()
item.categories = categories
item.save()
images_data = {
k: v
for k, v in form.cleaned_data.items() if 'image' in k
}
for key in sorted(k for k, v in images_data.items() if v):
url = images_data[key]
image = Image(item=item, url=url)
image.save()
send_emails(request, item)
response = redirect('view_item', item.id)
response['Location'] += '?new=true'
return response
else:
return render(request, 'app/add_item.html', {'form': form})
def load_image(image, dataset):
"""Load data of an image to an EXISTING dataset.
Arguments:
image -- path to data file (HOST) of the image to load
dataset -- dataset MODEL that the images pertain to
"""
filename = image.rsplit('/', 1)[-1]
try:
basename, extension = filename.split('.', 1)
if extension.lower() not in current_app.config['DSET_ALLOWED_EXTS']:
raise UnsupportedExtensionError(extension=extension)
if Image.query.filter(Image.name == basename,
Image.dataset == dataset).first():
raise DuplicateImageError(basename)
# Add Image to database
db.session.add(
Image(name=basename,
path=image,
extension=extension,
dataset=dataset))
except ValueError:
# File has no extension (Common in Linux)
raise NoExtensionError(filename=image)
def import_from_directory(path_to_images):
connect('eventum')
creator = User.objects().get(gplus_id='super')
filenames = os.listdir(path_to_images)
filenames = [fn for fn in filenames if not fn.startswith('.')]
failures = []
for filename in filenames:
if Image.objects(filename=filename).count() > 0:
img = Image.objects().get(filename=filename)
img.delete()
old_path = os.path.join(path_to_images, filename)
shutil.copy(old_path, config['UPLOAD_FOLDER'])
default_path = config['RELATIVE_UPLOAD_FOLDER'] + filename
image = Image(filename=filename,
default_path=default_path,
creator=creator)
try:
image.save()
except ValidationError as e:
failures.append(filename)
print "FAIL: %s" % filename
print e
print "Processed %s images." % len(filenames)
print "%s success." % (len(filenames) - len(failures))
print "%s failures." % len(failures)
def get(request):
likeImgPath = []
path=''
if request.method=="POST":
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
img = form.cleaned_data['Img']
uid=uuid.uuid1()
imgObj =Image()
imgObj.uid=uid
imgObj.path=img
imgObj.save()
obj=Image.objects.get(uid=uid)
path= obj.path.url.encode('utf-8')
sys.argv = ['compare.py', '/home/ubuntu/face_search_1/face_search_1/app/src/20170512-110547.pb',
'/home/ubuntu/face_search_1/face_search_1/'+path]
args = search.parse_arguments(sys.argv[1:])
likesImg = search.main(args)
for i in range(10):
filepath = likesImg[i, 0]
likeImgPath.append(filepath)
else:
form = ImageForm()
return render_to_response('get.html', {'form': form,'likesImg':likeImgPath,'path':path})
def create_images_admin():
logger.info("Image uploaded by %s" % g.user.username)
form = validations.CreateImageForm(CombinedMultiDict((request.files, request.form)))
logger.info("known good %s" % form.known_good.data)
logger.info("public %s" % form.public.data)
if form.validate():
f = form.image.data
random_suffix = binascii.hexlify(os.urandom(4)).decode('utf-8')
filename = "%s.%s" % (secure_filename(f.filename), random_suffix)
directory = os.path.join(app.config['TFTP_ROOT'], secure_filename(g.user.username))
if not os.path.exists(directory):
os.makedirs(directory)
path = os.path.join(secure_filename(g.user.username), filename)
logger.info("known good %s" % form.known_good.data)
new_image = Image(description=form.description.data,
filename=path,
file_type=form.file_type.data,
known_good=form.known_good.data,
user_id=g.user.id,
public=form.public.data)
db.session.add(new_image)
try:
db.session.commit()
f.save(os.path.join(app.config['TFTP_ROOT'], path))
flash('File uploaded successfully', 'success')
except IntegrityError as e:
db.session.rollback()
flash("IntegrityError, try again.", 'info')
else:
flash_form_errors(form)
return redirect(url_for('.get_images_admin'))
def icons(overwrite, subfolder):
"""Initialize icons."""
# Update icons
icon_path = os.path.join(app.config['IMAGE_ROOT_PATH'], 'resources',
subfolder)
files = [f for f in os.listdir(icon_path) if f.endswith('.svg')]
for file in files:
url = os.path.join(icon_path, file)
name = os.path.splitext(file)[0]
existing_image = Image.query.filter_by(name=name).first()
if existing_image:
if overwrite:
try:
existing_image.update(url,
keep_original=True,
name=name)
existing_image.description = 'Static image'
if not existing_image.vector:
create_thumbnails(existing_image)
db.session.commit()
except:
print('Updating icon {} failed'.format(file))
db.session.rollback()
else:
try:
image = Image(url, keep_original=True, name=name)
image.description = 'Static image'
if not image.vector:
create_thumbnails(image)
db.session.add(image)
db.session.commit()
except:
print('Adding icon {} failed'.format(file))
db.session.rollback()
def post(self):
# not sure about it
# it could be posted as list
incoming_file = request.files['file']
internal_fname = str(uuid.uuid4())
fname= secure_filename(incoming_file.filename)
if fname == "":
fname = "name_couldnt_detected"
file_ext = os.path.splitext(fname)[1]
if file_ext not in current_app.config['UPLOAD_EXTENSIONS'] or \
file_ext != validate_image(incoming_file.stream):
abort(400)
# user maybe needs to be queried
user = g.current_user
image = Image(internal_fname=internal_fname,
owner=user, fname=fname)
try:
db.session.add(image)
db.session.commit()
except IntegrityError:
return jsonify(message="User with that email already exist"), 409
filepath = os.path.join(basedir, current_app.config["UPLOAD_PATH"] + fname)
incoming_file.save(filepath)
def get_random_event_image(self, event):
"""Return a random event image from the default images
directory.
"""
images_directory = os.path.dirname(
__file__) + "/static/images/default_event_images"
default_event_images = os.listdir(images_directory)
# the while loop is to account for any hidden files in the directory
filename = ""
while not filename:
filename = random.choice(default_event_images)
if not filename.startswith("default_event_image"):
filename = ""
filepath = images_directory + "/" + filename
image = Image.query.filter_by(path=filepath).first()
if image is None:
image = Image(
path=filepath,
event=event,
image_type=ImageType.query.filter_by(
name="Main Event Image").first(),
)
db.session.add(image)
db.session.commit()
return image
def album():
if not current_user.is_authenticated:
return redirect('/')
album_title = request.args.get('title')
images = Image.query.filter_by(album=album_title).all()
form = forms.ImageForm()
if form.validate_on_submit():
f = form.image.data
caption = form.caption.data
filename = secure_filename(f.filename)
image_id = generate_image_id(album_title, filename)
fmt = filename.split('.')[-1].lower()
if fmt not in IMAGE_FORMATS:
return redirect(request.url)
if fmt == 'heic':
fmt = 'jpg'
hashed_file_name = '{}.{}'.format(image_id, fmt)
heic_to_jpg(f, hashed_file_name)
else:
hashed_file_name = '{}.{}'.format(image_id, fmt)
f.save(os.path.join(os.getcwd(), 'app/static/images', hashed_file_name))
image = Image(image_id, fmt, album_title, caption=caption, uploaded_by=current_user.id)
db.session.add(image)
db.session.commit()
return redirect(request.url)
return render_template('album.html', images=images, form=form)
def store_image(request):
# get image from request
img_b64 = json.loads(request.data)["image"]
# decode base64
img_bytes = base64.b64decode(img_b64)
# encode to uint8 to create a numpy array
img_np_array = np.fromstring(img_bytes, np.uint8)
# decode image
img = cv2.imdecode(img_np_array, cv2.IMREAD_COLOR)
# we add the image to the db to obtain the id, so every filename is different
image = Image(img="")
db.session.add(image)
db.session.commit()
# save image to a file
filename = app.config[
"STUDENT_PHOTOS_FOLDER_PATH"] + "unknown-face-{0:0>3}.jpg".format(
image.id)
cv2.imwrite(filename, img)
# update filename of the image
image.img = filename
db.session.commit()
return image
def upload_file(file):
config_upload = current_app.config['UPLOAD']
resp = {'code': 200, 'msg': '操作成功~~', 'data': {}}
filename = file.filename
ext = filename.rsplit(".", 1)[1]
# if ext not in config_upload['ext']:
# resp['code'] = -1
# resp['msg'] = "不允许的扩展类型文件"
# return resp
root_path = current_app.root_path + config_upload['prefix_url']
file_dir = date_to_str(format="%Y%m%d")
save_dir = root_path + file_dir
if not os.path.exists(save_dir):
os.mkdir(save_dir)
os.chmod(save_dir, stat.S_IRWXU | stat.S_IRGRP | stat.S_IRWXO)
file_name = str(uuid.uuid4()).replace("-", "") + "." + ext
file.save("{0}/{1}".format(save_dir, file_name))
with db.auto_commit():
model_image = Image()
model_image.file_key = file_dir + "/" + file_name
db.session.add(model_image)
resp['data'] = {'file_key': model_image.file_key}
return resp
def upload():
"""Upload an image to Eventum
**Route:** ``/admin/media/upload``
**Methods:** ``POST``
"""
form = UploadImageForm(request.form)
uploaded_from = form.uploaded_from.data
if form.validate_on_submit():
f = request.files['image']
if f and allowed_file(f.filename.lower()):
filename = create_filename(f, request.form['filename'])
f.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
image = Image(filename=filename,
default_path=app.config['RELATIVE_UPLOAD_FOLDER']+filename,
creator=g.user)
image.save()
return redirect(url_for('.index'))
flash("Filename {} is invalid".format(f.filename))
if form.errors:
flash(form.errors)
if uploaded_from:
return redirect(uploaded_from)
return render_template('admin/media/upload.html', form=form)
def scrap_img(product):
"""Get all item pictures from VidaXL
Args:
Product (class)
Returns:
[JSON]: vidaxl_id, images quantity, list of images urls
"""
images = Product.query.get(product.id).images
if images:
return [image.url for image in images]
timeout = current_app.config["SLEEP_TIME"]
attempts = int(current_app.config["NUMBER_OF_REPETITIONS"])
for i in range(attempts):
soup = check_soup(product.vidaxl_id)
if soup:
gallery = soup.find("div", class_="media-gallery")
img_container = gallery.findAll("a")
images = [
i.attrs["href"] for i in img_container if "missing_image" not in i
]
for img in images:
Image(product_id=product.id, url=img).save()
return images
log(
log.INFO,
"Scraping pictures: Invalid Response. Attempt: %d(%d) timeout:%s",
i + 2,
attempts,
timeout,
)
time.sleep(timeout)
timeout += timeout/2
return None
def upload_image():
if "image" not in request.files:
return {"errors": "image required"}, 400
image = request.files["image"]
if not allowed_file(image.filename):
return {"errors": "file type not permitted"}, 400
image.filename = get_unique_filename(image.filename)
upload = upload_file_to_s3(image)
if "url" not in upload:
# if the dictionary doesn't have a filename key
# it means that there was an error when we tried to upload
# so we send back that error message
return upload, 400
url = upload["url"]
# we can use the
new_image = Image(user=current_user, url=url)
db.session.add(new_image)
db.session.commit()
return {"url": url}
def upload_categ_BG(id):
if (current_user.role_id != 2):
return json.dumps({'success': False})
categ = Categ.query.get_or_404(id)
if 'file' not in request.files:
return json.dumps({'success1': False})
file = request.files['file']
img = Image(hex_id=id)
img.ext = file.mimetype.replace('image/', '')
if (not img.ext in ['png', 'jpg', 'jpeg', 'gif']):
return json.dumps({'success2': False})
db.session.add(img)
db.session.commit()
try:
file.save(os.getcwd() + f"/app/static/uploadedImgs/{img.id}.{img.ext}")
except BaseException:
db.session.delete(img)
db.session.commit()
return json.dumps({'success3': False})
categ.BG_img = f'{img.id}.{img.ext}'
db.session.add(categ)
db.session.commit()
return json.dumps({'success': True})
def new_listing():
form = ListingForm()
if form.validate_on_submit():
_listing = Listing(title=form.title.data,
body=form.body.data,
condition=form.condition.data,
price=form.price.data,
author=current_user)
db.session.add(_listing)
db.session.commit()
# Image upload
filename = secure_filename(form.image.data.filename)
[filename, ext] = filename.split('.') # ['image', 'png']
instance = 0
db_image = Image.query.filter_by(name=filename).order_by(
Image.instance.desc()).first()
if db_image and db_image.instance is not None:
instance = int(db_image.instance) + 1
location = filename + str(instance) + '.' + ext
form.image.data.save(
os.path.join(app.config['IMAGES_FOLDER'], location))
image = Image(name=filename,
extension=ext,
instance=instance,
src=location,
listing_id=_listing.id)
db.session.add(image)
db.session.commit()
flash('Listing created')
return redirect(url_for('listing', id=_listing.id))
return render_template("new_listing.html",
title='Create New Listing',
form=form)
def handle_request():
if request.method == 'POST':
if request.files:
username = '******'
filename = images.save(request.files['image'])
url = images.url(filename)
#---------------------
result = predict(filename)
#---------------------
user = User.query.filter_by(username=username).first()
if user is None: user = User(username=username)
report = Report(user=user, data=json.dumps(result))
image = Image(report=report)
image.image_filename = filename
image.image_url = url
db.session.add(user)
db.session.add(report)
db.session.add(image)
db.session.commit()
return 'Report Generated'
return 'No Files Recieved'
return 'Method not POST'
def upload_img():
upload_path = os.path.join(Config.FS_ROOT_DIR, Config.FS_ROOT_UPLOAD,
Config.FS_ROOT_IMG_UPLOAD)
abs_up_path = os.path.abspath(upload_path)
if not os.path.exists(abs_up_path):
os.makedirs(abs_up_path)
resp_dict = {'errno': 0, 'data': []}
try:
files = request.files.to_dict()
for filename, file in files.items():
uuid_filename = '{}.{}'.format(
shortuuid.uuid(),
secure_filename(filename).rsplit('.')[-1])
# compress the upload img
compress2png(file, dst=os.path.join(abs_up_path, uuid_filename))
resp_dict['data'].append('/article/img/%s' %
uuid_filename.split('.')[0])
img = Image(id=uuid_filename.split('.')[0],
local_path=os.path.join(abs_up_path, uuid_filename))
db.session.add(img)
db.session.commit()
except Exception as e:
print(e)
resp_dict['errno'] = 1
return jsonify(resp_dict)
def currency_flags(overwrite):
"""Initialize currency flags."""
# Update flags
flag_path = os.path.join(app.config['IMAGE_ROOT_PATH'], 'resources',
'flags')
existing_currencies = Currency.query.all()
for currency in existing_currencies:
country_code = currency.code[0:2].upper()
url = os.path.join(flag_path, country_code + '.svg')
if currency.image:
if overwrite:
try:
currency.image.update(url,
keep_original=True,
name=country_code)
currency.image.description = 'Static image'
if not currency.image.vector:
create_thumbnails(currency.image)
db.session.commit()
except:
print('Adding flag for {} failed'.format(country_code))
db.session.rollback()
else:
try:
image = Image(url, keep_original=True, name=country_code)
image.description = 'Static image'
if not image.vector:
create_thumbnails(image)
currency.image = image
db.session.commit()
except:
print('Adding flag for {} failed'.format(country_code))
db.session.rollback()
def upload_hex_img(id):
hex = Hexagon.query.get(id)
if hex.user_id != current_user.id:
return json.dumps({'success': False})
if 'file' not in request.files:
return json.dumps({'success': False})
file = request.files['file']
img = Image(hex_id=id)
img.ext = file.mimetype.replace('image/', '')
if (not img.ext in ['png', 'jpg', 'jpeg', 'gif'
]): # TODO: создать таблицу с расширениями файлов
return json.dumps({'success': False})
db.session.add(img)
db.session.commit()
categ_name = hex.categ.name
create_dir("/app/static/uploadedImgs/" + categ_name)
create_dir(f"/app/static/uploadedImgs/{categ_name}/{hex.chain.id}")
create_dir(
f"/app/static/uploadedImgs/{categ_name}/{hex.chain.id}/{hex.id}")
filename = f"static/uploadedImgs/{categ_name}/{hex.chain.id}/{hex.id}/{img.id}.{img.ext}"
if 'BG' in file.filename:
hex.BG_img = filename
for img in hex.imgs:
img.is_BG = False
db.session.add(img)
img.is_BG = True
db.session.add_all([hex, img])
db.session.commit()
try:
file.save(os.getcwd() + "/app/" + filename)
except BaseException:
db.session.delete(img)
db.session.commit()
return json.dumps({'success': False})
subs = current_user.subscriptions_to_me
for sub in subs:
create_notification(
sub.subscriber_id,
_('User %(username)s changed his/her hexagon in category %(categname)s',
categname=hex.categ.name,
username=current_user.username), 'change',
url_for('get_hex', id=hex.id))
return json.dumps({
'success': True,
'url': filename,
'uuid': img.id,
"isBG": img.is_BG
})
def take_frame(self):
now = datetime.now()
fileName = filePath + now.strftime('%y%m%d_%H%M%S') + '.png'
print (fileName)
cv2.imwrite(fileName, self.frame)
db = Image(image_name=now.strftime('%y%m%d_%H%M%S'), pub_date=timezone.now())
db.save()
def mutate(self, info, input):
data = utils.input_to_dictionary(input)
print("Updating Recipe")
print("input: %s" % input)
images = []
# Handle recipe images. If it is a list, save all. If singleton, save it.
if ('recipeImages' in data.keys()
and type(data['recipeImages']) is list):
for recipe_image in data['recipeImages']:
if recipe_image:
image_filename = utils.handle_image(recipe_image)
images.append(
Image(filename=image_filename,
date_added=datetime.datetime.now()))
data.pop('recipeImages')
elif ('recipeImages' in data.keys()
and not type(data['recipeImages']) is None):
images.append(
Image(filename=utils.handle_image(data['recipeImages'])))
data.pop('recipeImages')
if ('bookImage' in data.keys() and not data['bookImage'] is None):
data['book_image_path'] = utils.handle_image(data['bookImage'])
data.pop('bookImage')
# Find recipe category and add entry reference
category = None
if ('category' in data.keys() and not data['category'] is None):
category = RecipeCategory.query.filter_by(
name=data['category']).first()
data.pop('category')
data['id_recipe_category'] = category.id
recipe = db.session.query(Recipe).filter_by(id=data['id'])
recipe.update(data)
db.session.commit()
recipe = db.session.query(Recipe).filter_by(id=data['id']).first()
for image in images:
print(image)
recipe.images.append(image)
db.session.commit()
return UpdateRecipe(recipe=recipe)
def save(self):
super(ImageFile, self).save()
img = Image()
img.file_id = self.id
img.image = self.base + '.' + self.ext
img.save()
return self.base
def save_event_main_image(images, event, file_uploader, db_session):
"""Store the given main image for the event in the database."""
filename = file_uploader.save(images)
image_type = ImageType.query.filter_by(name="Main Event Image").first()
image = Image(path=file_uploader.path(filename),
image_type=image_type,
event=event)
db_session.add(image)
