def upload_file():
print(
current_user.roles
) #returns either admin or end-user but next line always goes through?
# if current_user.roles is 'admin':
form = UploadForm()
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
name = request.form['text']
user = current_user.id
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and not allowed_file(file.filename):
flash('Unsupported File Type')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
resstr, fileLOC = upload_file_to_s3(file, 'laneck')
# print(type(fileLOC))
fileLOC = ', '.join(fileLOC)
# print(fileLOC)
if store_fileInfo(fileLOC, name,
user): #creates db entry for song e
print('succesful upload')
return redirect(url_for('music'))
else:
flash('Song already exists in the database')
return redirect(request.url)
return render_template('upload.html', form=form)
def post_by_id(post_id):
post = Post.query.get(post_id)
if request.method == "GET":
return post.to_dict()
elif request.method == "PUT":
form = CreatePost()
if form.validate_on_submit():
form.populate_obj(post)
db.session.commit()
if "images" in request.files:
images = request.files.getlist("images")
for image in images:
if allowed_file(image.filename):
image.filename = get_unique_filename(image.filename)
image_url = upload_file_to_s3(image, Config.S3_BUCKET)
image = PostsImage(post_id=post.id,
image_url=image_url)
db.session.add(image)
db.session.commit()
return post.to_dict()
return {"errors": validation_errors_to_error_messages(form.errors)}
elif request.method == "DELETE":
post.title = "[DELETED]"
post.body = "[DELETED]"
posts_images = PostsImage.query.filter(
PostsImage.post_id == post_id).all()
for image in posts_images:
db.session.delete(image)
db.session.commit()
return post.to_dict()
return post.to_dict()
def create_user_page():
form = CreateUserPage()
form['csrf_token'].data = request.cookies['csrf_token']
profileImg = ""
image = ""
date = ""
if form.data['profileImg'] is not None:
image = form.data['profileImg']
if image != "":
if type(image) == str:
profileImg = image
elif allowed_file(image.filename):
image.filename = secure_filename(image.filename)
profileImg = upload_file_to_s3(image, Config.S3_BUCKET)
try:
userPage = User_page.query.filter(
User_page.userId == form.userId.data).first()
if not profileImg:
profileImg = userPage.profileImg
form.populate_obj(userPage)
userPage.weddingDateTime = request.form.get("weddingDateTime")
userPage.profileImg = profileImg
db.session.commit()
return userPage.to_dict()
except Exception as e:
userPage = User_page()
form.populate_obj(userPage)
userPage.profileImg = profileImg
db.session.add(userPage)
db.session.commit()
return userPage.to_dict()
def update_pet(petId):
"""
Update pet
"""
form = CreatePetForm()
form["csrf_token"].data = request.cookies["csrf_token"]
image_error = []
image = request.files.get("image", None)
pet_to_update = Pet.query.get(petId)
print("pet to update ------------------ ", pet_to_update.to_dict())
pet_to_update.name = form.data["name"]
pet_to_update.petType = form.data["petType"]
pet_to_update.age = form.data["age"]
pet_to_update.energy = form.data["energy"]
pet_to_update.social = form.data["social"]
pet_to_update.behaved = form.data["behaved"]
pet_to_update.size = form.data["size"]
pet_to_update.env = form.data["env"]
pet_to_update.description = form.data["description"]
if image is not None:
image.filename = secure_filename(image.filename)
pattern = re.compile(".*(apng|avif|jpe?g|png|svg|webp)$",
re.IGNORECASE)
is_image = bool(pattern.match(image.mimetype))
if not is_image:
image_error.append(
"Upload must be an image (apng, avif, jpeg/jpg, png, svg, webp)."
)
if form.validate_on_submit() and not image_error:
output_link = upload_file_to_s3(image) if image else None
if output_link:
pet_to_update.imageURL = output_link
print("updated pet ------------------ ", pet_to_update.to_dict())
db.session.add(pet_to_update)
db.session.commit()
return pet_to_update.to_dict()
errors = validation_errors_to_error_messages(form.errors)
errors += image_error
return {"errors": errors}
def create_pet():
"""
Create new pet
"""
form = CreatePetForm()
form["csrf_token"].data = request.cookies["csrf_token"]
image_error = []
image = request.files.get("image", None)
if image != None:
image.filename = secure_filename(image.filename)
pattern = re.compile(".*(apng|avif|jpe?g|png|svg|webp)$",
re.IGNORECASE)
is_image = bool(pattern.match(image.mimetype))
if not is_image:
image_error.append(
"Upload must be an image (apng, avif, jpeg/jpg, png, svg, webp)."
)
if form.validate_on_submit() and not image_error:
output_link = (
upload_file_to_s3(image) if image else
"https://pair-yo-pet-aws.s3-us-west-1.amazonaws.com/default-dog.png"
)
new_pet = Pet(
userId=form.data["userId"],
name=form.data["name"],
petType=form.data["petType"],
age=form.data["age"],
imageURL=output_link,
energy=form.data["energy"],
social=form.data["social"],
behaved=form.data["behaved"],
size=form.data["size"],
env=form.data["env"],
description=form.data["description"],
)
db.session.add(new_pet)
db.session.commit()
return new_pet.to_dict()
errors = validation_errors_to_error_messages(form.errors)
errors += image_error
return {"errors": errors}
def update_joke(jokeId):
"""
Update joke
"""
form = CreateJokeForm()
form["csrf_token"].data = request.cookies["csrf_token"]
image_error = []
image = request.files.get("image", None)
joke_to_update = Joke.query.get(jokeId)
print("joke to update ------------------ ", joke_to_update.to_dict())
joke_to_update.joke = form.data["joke"]
joke_to_update.jokeType = form.data["jokeType"]
if image is not None:
image.filename = secure_filename(image.filename)
pattern = re.compile(".*(apng|avif|jpe?g|png|svg|webp)$",
re.IGNORECASE)
is_image = bool(pattern.match(image.mimetype))
if not is_image:
image_error.append(
"Upload must be an image (apng, avif, jpeg/jpg, png, svg, webp)."
)
if form.validate_on_submit() and not image_error:
output_link = upload_file_to_s3(image) if image else None
if output_link:
joke_to_update.imageURL = output_link
print("updated joke ------------------ ", joke_to_update.to_dict())
db.session.add(joke_to_update)
db.session.commit()
return joke_to_update.to_dict()
errors = validation_errors_to_error_messages(form.errors)
errors += image_error
return {"errors": errors}
def create_post():
form = CreatePost()
if form.validate_on_submit():
post = Post()
form.populate_obj(post)
db.session.add(post)
db.session.commit()
if "images" in request.files:
images = request.files.getlist("images")
for image in images:
if allowed_file(image.filename):
image.filename = get_unique_filename(image.filename)
image_url = upload_file_to_s3(image, Config.S3_BUCKET)
image = PostsImage(post_id=post.id, image_url=image_url)
db.session.add(image)
db.session.commit()
return post.to_dict()
return {"errors": validation_errors_to_error_messages(form.errors)}
def create_server():
form = ServerForm()
# form['csrf_token'].data = request.cookies['csrf_token']
if form.is_submitted():
if ("image" in request.files):
image = request.files["image"]
image.filename = get_unique_filename(image.filename)
upload = upload_file_to_s3(image)
url = upload["url"]
else:
url = ""
server = Server(admin_id=form.data['admin_id'],
name=form.data['name'],
image=url,
public=form.data['public'],
created_at=form.data['created_at'])
db.session.add(server)
db.session.commit()
return server.to_dict()
return "did not go thru", 401
def create_joke():
"""
Create new joke
"""
form = CreateJokeForm()
form["csrf_token"].data = request.cookies["csrf_token"]
image_error = []
image = request.files.get("image", None)
if image is not None:
image.filename = secure_filename(image.filename)
pattern = re.compile(".*(apng|avif|jpe?g|png|svg|webp)$",
re.IGNORECASE)
is_image = bool(pattern.match(image.mimetype))
if not is_image:
image_error.append(
"Upload must be an image (apng, avif, jpeg/jpg, png, svg, webp)."
)
if form.validate_on_submit() and not image_error:
output_link = (
upload_file_to_s3(image) if image else
"https://pair-yo-pet-aws.s3-us-west-1.amazonaws.com/default-dog.png"
)
new_joke = Joke(
userId=form.data["userId"],
joke=form.data["joke"],
imageURL=output_link,
jokeType=form.data["jokeType"],
)
db.session.add(new_joke)
db.session.commit()
return new_joke.to_dict()
errors = validation_errors_to_error_messages(form.errors)
errors += image_error
return {"errors": errors}
def sign_up():
"""
Creates a new user and logs them in
"""
form = SignUpForm()
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
if ("image" in request.files):
image = request.files["image"]
image.filename = get_unique_filename(image.filename)
upload = upload_file_to_s3(image)
url = upload["url"]
else:
url = ""
user = User(username=form.data['username'],
email=form.data['email'],
password=form.data['password'],
profile_picture=url,
created_at=form.data['created_at'])
db.session.add(user)
db.session.commit()
login_user(user)
return user.to_dict()
return {'errors': validation_errors_to_error_messages(form.errors)}, 401
