def edit_song():
matched_song = Song.query.get(request.form['SongId'])
url_image = None
url_song = None
if "image" in request.files:
image = request.files["image"]
image.filename = get_unique_filename(image.filename)
upload = upload_file_to_s3(image)
url_image = upload["url"]
if "audio" in request.files:
song_file = request.files["audio"]
song_file.filename = get_unique_filename(song_file.filename)
upload = upload_file_to_s3(song_file)
url_song = upload["url"]
matched_song.title = request.form['title']
matched_song.description = request.form['description']
matched_song.genre = request.form['genre']
matched_song.image_url = url_image
matched_song.artist = request.form['artist']
matched_song.audio_file = url_song
db.session.commit()
data = matched_song.to_dict()
return data
def edit_song():
matched_song = Song.query.get(request.form['id'])
url_image = None
url_song = None
if "song" in request.files:
song_file = request.files["song"]
song_file.filename = get_unique_filename(song_file.filename)
upload = upload_file_to_s3(song_file)
url_song = upload["url"]
else:
url_song = matched_song.song
if "image_url" in request.files:
image = request.files["image_url"]
image.filename = get_unique_filename(image.filename)
upload = upload_file_to_s3(image)
url_image = upload["url"]
else:
url_image = matched_song.image_url
matched_song.name = request.form['name']
matched_song.description = request.form['description']
matched_song.album = request.form['album']
matched_song.image_url = url_image
matched_song.category = request.form['category']
matched_song.song = url_song
db.session.commit()
data = matched_song.to_dict()
return data
def add_song():
url_image = None
url_song = None
if "image_url" in request.files:
image = request.files["image_url"]
image.filename = get_unique_filename(image.filename)
upload = upload_file_to_s3(image)
url_image = upload["url"]
else:
url_image = 'https://i.stack.imgur.com/l60Hf.png'
if "song" in request.files:
song_file = request.files["song"]
song_file.filename = get_unique_filename(song_file.filename)
upload = upload_file_to_s3(song_file)
url_song = upload["url"]
print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
print(url_song)
form = SongForm()
form['csrf_token'].data = request.cookies['csrf_token']
new_song = Song(
artist_id=request.form['artist_id'],
name=request.form['name'],
description=request.form['description'],
category=request.form['category'],
album=request.form['album'],
image_url=url_image,
song=url_song,
# public=request.form['public'],
)
db.session.add(new_song)
db.session.commit()
data = new_song.to_dict()
return data
def upload_image(id):
if "image" not in request.files:
return print("no image")
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 url 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"]
# flask_login allows us to get the current user from the request
new_image = MyAWS(spot_id=id,
aws_url=url,
rss_feed_url="arn:aws:s3:::captain-hagi")
db.session.add(new_image)
db.session.commit()
return {"url": url}
def edit_user():
# """
# Creates a new user and logs them in
# """
# user = request.form['id']
# matched_user = User.query.get(user)
# 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 = None
# matched_user.profile_URL = url
# db.session.commit()
# return matched_user.to_dict()
matched_user = User.query.get(request.form['id'])
url_image = None
if "profile_URL" in request.files:
image = request.files["profile_URL"]
image.filename = get_unique_filename(image.filename)
upload = upload_file_to_s3(image)
url_image = upload["url"]
else:
url_image = matched_user.profile_URL
matched_user.username = request.form['username']
matched_user.email = request.form['email']
matched_user.password = request.form['password']
matched_user.profile_URL = url_image
db.session.commit()
data = matched_user.to_dict()
return data
def sign_up():
"""
Creates a new user and logs them in
"""
url = None
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 = 'https://i.stack.imgur.com/l60Hf.png'
form = SignUpForm()
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
user = User(
username=request.form['username'],
email=request.form['email'],
password=request.form['password'],
profile_URL=url,
)
db.session.add(user)
db.session.commit()
login_user(user)
return user.to_dict()
return {'errors': validation_errors_to_error_messages(form.errors)}
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 url 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"]
# flask_login allows us to get the current user from the request
remove_image = delete(UserImage).where(
UserImage.user_id == current_user.id).execution_options(
synchronize_session="fetch")
db.session.execute(remove_image)
db.session.commit()
new_image = UserImage(user_id=current_user.id, img_url=url)
db.session.add(new_image)
db.session.commit()
return {"url": url}
def add_server():
url = None
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"]
# print(upload)
new_server = Server(
admin_id=request.form['admin_id'],
name=request.form['name'],
description=request.form['description'],
category=request.form['serverCategory'],
public=(bool(request.form['isPublic'])),
image_url=url,
)
user = User.query.get(request.form['admin_id'])
user.servers.append(new_server)
db.session.add(new_server)
db.session.commit()
data = new_server.to_dict()
data['channels'] = []
return data
def add_activity():
url = ''
if "image" in request.files:
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 url 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"]
form = NewActivityForm(request.form)
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate():
actDate = datetime.datetime.strptime(request.form.get("date"),
'%m/%d/%Y, %I:%M:%S %p')
print(actDate)
newActivity = DogActivity(dog_id=form.data["dog_id"],
name=form.data['name'],
activityType_id=form.data["activityType_id"],
activity_img=url,
minutes=form.data["minutes"],
route_id=form.data["route_id"],
date=request.form.get("date"))
db.session.add(newActivity)
db.session.commit()
return newActivity.to_dict()
return {"errors": validation_errors_to_error_messages(form.errors)}, 401
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 edit_dog(dog_id):
dog = Dog.query.filter(Dog.id == dog_id).first()
if 'image' in request.files:
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 url key
# it means that there was an error when we tried to upload
# so we send back that error message
return upload, 400
dog.dog_img = url
if 'daily_goal' in request.form:
dog.daily_goal = request.form['daily_goal']
if "weight" in request.form:
dog.weight = request.form['weight']
if "description" in request.form:
dog.description = request.form['description']
db.session.commit()
return {"dog": dog.to_dict()}
def add_song():
url_image = None
url_song = None
if "image" in request.files:
image = request.files["image"]
image.filename = get_unique_filename(image.filename)
upload = upload_file_to_s3(image)
url_image = upload["url"]
if "audio" in request.files:
song_file = request.files["audio"]
# content = request.files["audio"].read()
song_file.filename = get_unique_filename(song_file.filename)
upload = upload_file_to_s3(song_file)
url_song = upload["url"]
print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
print(url_song)
# Convert song file to binary
# audio_binary = convertToBinaryData(content)
# print('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
# print(audio_binary)
# Convert audio file into Numpy array
# AudioNumpyArray = read(song_file, normalized=False)
# numpyData = {"array": AudioNumpyArray}
# # Serialization
# numpyData = {"array": AudioNumpyArray}
# # use dump() to write array into file
# encodedNumpyData = json.dumps(numpyData, cls=NumpyArrayEncoder)
form = UploadForm()
form['csrf_token'].data = request.cookies['csrf_token']
new_song = Song(
user_id=request.form['id'],
title=request.form['title'],
description=request.form['description'],
image_url=url_image,
audio_file=url_song,
artist=request.form['artist'],
genre_id=1,
)
db.session.add(new_song)
db.session.commit()
data = new_song.to_dict()
return data
def uploadTrackVersion(artistId, projectId, trackId):
'''
Posts a new mix version to AWS [X]
Updates on database [X]
Updates on AWS [X]
'''
user = current_user
artist = User.query.get(artistId)
project = Project.query.get(projectId)
track = Track.query.get(trackId)
if user.superUser:
if track:
if track.projectId == project.id:
if project.artistId == artist.id:
if project.engineerId == user.id:
if "file" not in request.files:
return {"errors": "file required"}, 400
file = request.files["file"]
if not allowed_file(file.filename):
return {"errors": "file type not permitted"}, 400
file.filename = get_unique_filename(file.filename)
upload = upload_file_to_s3(file)
db.session.flush()
if "url" not in upload:
return upload, 400
url = upload["url"]
data = Version(url=upload["url"],
length=3,
trackId=track.id)
db.session.add(data)
db.session.commit()
return data.to_dict()
else:
return {
"Errors":
f"{user.firstName} {user.lastName} cannot delete '{project.name}' because they are not on the project"
} # noqa
else:
return {
"Errors":
f"'{project.name}' does not belong to {artist.firstName} {artist.lastName}"
} # noqa
else:
return {
"Errors":
f"'{track.name}' does not belong to {project.name}"
} # noqa
else:
return {"Errors": f"Track does not exist!"}
else:
return {
"Errors":
f"{user.firstName} {user.lastName} is not authorized to perform this action."
} # noqa
def edit_user():
"""
Creates a new user and logs them in
"""
user = request.form['id']
matched_user = User.query.get(user)
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 = None
matched_user.profile_URL = url
db.session.commit()
return matched_user.to_dict()
def upload_file():
if "file" not in request.files:
return {"errors": "file required"}, 400
file = request.files["file"]
if not allowed_file(file.filename):
return {"errors": "file type not permitted"}, 400
file.filename = get_unique_filename(file.filename)
upload = upload_file_to_s3(file)
if "url" not in upload:
return upload, 400
url = upload["url"]
return {"url": url}
def profile_pic_submit(user_id):
form = ProfPicForm()
file = request.files.get("profile_photo_file")
print("this is to see what file is", file)
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
file = form.data['profile_photo_file']
if file:
file.filename = secure_filename(file.filename)
s3_pic_url = upload_file_to_s3(file)
profpic = Profpic.query.filter(Profpic.user_id == user_id).first()
if profpic:
profpic.pic_url = s3_pic_url['url']
else:
profpic = Profpic(pic_url=s3_pic_url['url'], user_id=user_id)
db.session.add(profpic)
db.session.commit()
return profpic.to_dict()
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 url 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"]
name = request.form['name']
birthday = request.form['birthday']
weight = int(request.form['weight'])
description = request.form["description"]
breed_id = int(request.form['breed_id'])
# flask_login allows us to get the current user from the request
new_dog = Dog(user_id=current_user.id,
dog_img=url,
name=name,
breed_id=breed_id,
birthday=birthday,
weight=weight,
description=description)
db.session.add(new_dog)
db.session.commit()
return {"url": url}
def edit_server():
matched_server = Server.query.get(request.form['id'])
url = None
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"]
matched_server.name = request.form['name']
matched_server.description = request.form['description']
matched_server.public = bool(request.form['isPublic'])
matched_server.image_url = url
matched_server.category = request.form['serverCategory']
db.session.commit()
formattedChannels = [
channel.to_dict() for channel in matched_server.channels
]
data = matched_server.to_dict()
data['channels'] = formattedChannels
return data
def add_activity_image(activity_id):
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 url 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"]
updatedActivity = DogActivity.query.filter(
DogActivity.id == activity_id).first()
updatedActivity.activity_img = url
db.session.commit()
return updatedActivity.to_dict()
def create_character():
form = CharacterForm()
form['csrf_token'].data = request.cookies['csrf_token']
# if form.validate_on_submit():
if form.validate_on_submit():
# s3 image helper functions. Steps: test if image is in files,
# grab image, check if it is required type,
# give it a unique name so aws does not overwrite,
# then upload to aws, returning any errors if upload fails.
if "image" not in request.files:
return {"errors": ["image required"]}
image = request.files["image"]
if not allowed_file(image.filename):
return {"errors": ["file type not permitted"]}
image.filename = get_unique_filename(image.filename)
upload = upload_file_to_s3(image)
if "url" not in upload:
return {"errors": [upload['errors']]}
url = upload["url"]
# create a new instance of the character class
character = Character()
# populate character instance with data from form & aws url
character = Character(userId=form.data['userId'],
name=form.data['name'],
level=form.data['level'],
race=form.data['race'],
characterClass=form.data['characterClass'],
subclass=form.data['subclass'],
hitpoints=form.data['hitpoints'],
speed=form.data['speed'],
imgURL=url,
proficiencies=form.data['proficiencies'],
background=form.data['background'],
alignment=form.data['alignment'],
attributes=form.data['attributes'],
traits=form.data['traits'],
ideals=form.data['ideals'],
bonds=form.data['bonds'],
flaws=form.data['flaws'],
inventory=form.data['inventory'],
description=form.data['description'],
languages=form.data['languages'],
tools=form.data['tools'])
# Take care of tag creation
# grab tags and query to check if they are created already
if len(form.data['tags']) > 0:
tagsFormatted = [
tag.strip() for tag in form.data['tags'].split(",")
]
for tag in tagsFormatted:
queriedTag = Tag.query.filter(Tag.name == tag).first()
if (queriedTag):
character.tags.append(queriedTag)
else:
tag = Tag(name=tag)
character.tags.append(tag)
classTag = Tag.query.filter(
Tag.name == form.data['characterClass']).first()
raceTag = Tag.query.filter(Tag.name == form.data['race']).first()
character.tags.append(classTag)
character.tags.append(raceTag)
# Take care of abilites and ability appending
for feature in json.loads(form.data['features']):
feature_to_add = (Ability.query.filter(
Ability.name == feature['name']).first())
if (feature_to_add):
character.abilities.append(feature_to_add)
else:
return {"errors": "Failed to add ability"}
# add and commit character
db.session.add(character)
db.session.commit()
return character.to_dict()
return {'errors': validation_errors_to_error_messages(form.errors)}
