def seed_all():
db.create_all()
# Categories
sport = CategoryModel(name="Sport")
politics = CategoryModel(name="Politics")
db.session.add(sport)
db.session.add(politics)
db.session.commit()
# Posts
post1 = PostModel(title="Some post about sport")
post1.category = sport
post2 = PostModel(title="Politics sucks etc")
post2.category = politics
db.session.add(post1)
db.session.add(post2)
db.session.commit()
# Tags
tag1 = TagModel(name="Trump")
tag2 = TagModel(name="Real Madrid")
tag3 = TagModel(name="Champtions League")
tag4 = TagModel(name="World Affairs")
db.session.add(tag1)
db.session.add(tag2)
db.session.add(tag3)
db.session.add(tag4)
db.session.commit()
def post(self):
data = self.parser.parse_args()
new_tag = TagModel(**data)
try:
db.session.add(new_tag)
db.session.commit()
except exc.IntegrityError as e:
return {"message": e.args[0]}, 500
except:
return {"message": "Something went wrong"}, 500
return {"data": new_tag.json()}, 201
def populate():
if UserModel.query.count() == 0:
user1 = UserModel(public_id=str(uuid.uuid4()),
username="******",
email="[email protected]",
password=generate_password_hash("aaaaaa",
method='sha256'),
is_admin=False)
user2 = UserModel(public_id=str(uuid.uuid4()),
username="******",
email="[email protected]",
password=generate_password_hash("bbbbbb",
method='sha256'),
is_admin=True)
[user.save_to_db() for user in [user1, user2]]
tag1 = TagModel(name="war")
tag2 = TagModel(name="peace")
tag3 = TagModel(name="fantasy")
tag4 = TagModel(name="dummyTag")
[tag.save_to_db() for tag in [tag1, tag2, tag3, tag4]]
quote1 = QuoteModel(creator_id=1,
text="Alea iacta est",
author="Julius Caesar",
book="Da vita Caesarum",
creation_date=datetime.datetime.now())
quote1.tags = [tag1, tag2]
quote2 = QuoteModel(creator_id=1,
text="Dummy 1",
author="User 1",
book="Quotes, vol 1",
creation_date=datetime.datetime.now())
quote2.tags = [tag3]
quote3 = QuoteModel(creator_id=2,
text="Dummy 2",
author="User 2",
book="Quotes, vol 2",
creation_date=datetime.datetime.now())
quote3.tags = [tag4]
[quote.save_to_db() for quote in [quote1, quote2, quote3]]
def delete(self, name):
quote = TagModel.find_by_name(name)
if quote:
quote.delete_from_db()
return {'message': 'tag deleted.'}
return {'message': 'tag not found.'}, 404
def get_tags(tag_names):
tags = []
for name in tag_names:
tag = TagModel.find_by_name(name)
if tag:
tags.append(tag)
else:
return {'message': 'There is no such tag: \'{}\''.format(name)}
return tags
def post(self):
iKwargs = request.form.to_dict()
tag = TagModel()
# data = {
# 'name': iKwargs['name'],
# 'articleList': {}
# }
iKwargs["articleList"] = {}
tag.create(iKwargs)
return {}
def get(self):
args = TagSaver.get_parser.parse_args()
url = URL_Model.find_by_url(args['url'])
if (url is None):
return {"message": "URL is not stored in database"}
tags = TagModel.find_all_by_url_id(url.uid)
return {"tags": [t.json() for t in tags]}
def put(self, name):
data = Tag.parser.parse_args()
tags = TagModel.find_all_by_name(name)
if not tags:
return {"message": f"There is no tag name with {name}"}, 400
for tag in tags:
machine = MachineModel.query.filter_by(id=tag.id).first()
machine.delete_from_db()
return {"message": "respective machines has been removed."}
def delete(self, isbn, name):
try:
book = BookModel.find_by_isbn(isbn)
if book is None:
return {'message': 'Book not found'}, 404
tag = TagModel.find_by_name(name)
if tag in book.tag_list:
book.tag_list.remove(tag)
book.save_to_db()
except:
return {'message': 'An error occured in the server.'}, 500
return {'message': 'Tag deleted from book'}
def delete(self):
data = Tag.parser.parse_args()
name = data['name']
tag = TM.find_by_name(name)
if tag:
try:
tag.delete_from_db()
except SQLAlchemyError as e:
err = str(e.__class__.__name__)
return {'message': '{}'.format(err)}, 500
return {'message': 'Tag was deleted'}
return {'message': 'Tag with name: \'{}\' was not found'.format(name)}
def post(self):
data = Tag.parser.parse_args()
name = data['name']
if len(name) > Configuration.MAX_TAG_NAME_SIZE:
return {
'message':
'A name\'s length is more than {}'.format(
Configuration.MAX_TAG_NAME_SIZE)
}
if TM.query.filter(TM.name == name).first():
return {'message': 'Tag \'{}\' already exists'.format(name)}
tag = TM(name=name)
try:
tag.save_to_db()
except SQLAlchemyError as e:
err = str(e.__class__.__name__)
return {'message': '{}'.format(err)}, 500
return tag.get_json(), 201
def __init__(self,
creator_id: int,
creation_date: datetime.datetime,
text: str,
author: str = None,
book: str = None,
tags: List[str] = None):
self.creator_id = creator_id
self.creation_date = creation_date
self.text = text
self.author = author
self.book = book
self.tags = [TagModel(name=tag) for tag in (tags or [])]
def post(self):
args = TagSaver.post_parser.parse_args()
url = URL_Model.find_by_url(args['url'])
if (url is None):
URL_Model(args['url']).save_to_db()
url = URL_Model.find_by_url(args['url'])
models = []
for t in args['tags']:
if (TagModel.find_tag(url.uid, t['tag_name'], t['tag_key']) is
None):
models.append(
TagModel(url.uid, t['tag_name'], t['tag_data'],
t['tag_key']))
else:
return {"message": "tag already in database"}
try:
TagModel.save_list_to_db(models)
except Exception as e:
return {'message': "Error saving data"}, 500
return {'message': 'Data saved successfully'}
def __init__(self, name, description, capacity, organizer_id, start_time,
end_time, location_id, is_published, pub_date, tags_list):
self.name = name
self.description = description
self.capacity = capacity
self.organizer_id = organizer_id
self.start_time = start_time
self.end_time = end_time
self.location_id = location_id
self.is_published = is_published
self.pub_date = pub_date
self.tags = []
if tags_list:
for tag_name in tags_list:
tag = TagModel.find_tag_by_name(tag_name)
if tag:
self.tags.append(tag)
def put(self, _id: str = None):
_id = int(_id)
data = Quote.parser.parse_args()
if _id is not None and _id > 0:
quote = QuoteModel.find_by_id(_id)
if quote:
quote.text = data['text']
quote.author = data["author"]
quote.book = data["book"]
quote.tags = [TagModel(tag) for tag in (data.get("tags", []))]
else:
return {
'message': 'quote not found, provide ID 0 to create quote'
}, 404
else:
data['creation_date'] = datetime.datetime.now()
quote = QuoteModel(**data)
quote.save_to_db()
return quote.json(), 200
def put(self, name):
data = Tag.parser.parse_args()
quote = TagModel.find_by_name(name)
if quote:
quote.text = data['text']
else:
quote = TagModel(name)
quote.save_to_db()
return quote.json()
def post(self, isbn):
try:
book = BookModel.find_by_isbn(isbn)
if book is None:
return {'message': 'Book not found'}, 404
data = TagList.parser.parse_args()
tagName = data['name'].lower()
tag = TagModel.find_by_name(tagName)
if tag is None:
tag = TagModel(tagName)
tag.save_to_db()
else:
if TagModel.find_by_isbn_and_name(isbn, tagName):
return {'message': 'the tag already added'}, 400
book.tag_list.append(tag)
book.save_to_db()
except:
return {'message': 'An error occured.'}, 500
return {'tag': tag.json()}
def post(self, name):
if TagModel.find_by_name(name):
return {
'message': "A tag with name '{}' already exists.".format(name)
}, 400
data = Tag.parser.parse_args()
quote = TagModel(name)
try:
quote.save_to_db()
except:
return {"message": "An error occurred inserting the tag."}, 500
return quote.json(), 201
def post(self, name):
if TagModel.find_by_name(name):
return {
"message": f"An machine with name {name} already exists"
}, 400
data = Tag.parser.parse_args()
data.update({'name': name})
tag = TagModel(**data)
try:
tag.save_to_db()
except:
return {"message": "An error occurred inserting the Tag."}, 500
return tag.json(), 201
def post(self, name):
data = Tag.parser.parse_args()
if TagModel.find_tag_by_name(name):
return {
"message":
"A tag with name '{}' already exists. Please try to use another name"
.format(name)
}, 400
tag = TagModel(name=name, priority=data['priority'])
try:
tag.save_to_db()
except:
return {
"message": "An error ocurred inserting the organizer."
}, 500
return {"tag_result": tag.json()}, 201
def get(self, name):
quote = TagModel.find_by_name(name)
if quote:
return quote.json()
return {'message': 'tag not found'}, 404
def delete(self, name):
tag = TagModel.find_by_name(name)
if tag:
tag.delete_from_db()
return {"message": "tag deleted."}
def get(self, name):
tag = TagModel.find_by_name(name)
if tag:
return tag.json()
return {'message': 'Tag not found'}, 404
