class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', backref=db.backref('posts', lazy=True))
title = db.Column(db.String(255))
slug = db.Column(db.String(255))
text = db.Column(db.Text)
html = db.Column(db.Text)
tags = db.relationship('Tag',
secondary=posts_tags_association,
lazy='subquery',
backref=db.backref('posts', lazy=True))
isPrivate = db.Column(db.Boolean, default=False)
createdAt = db.Column(db.DateTime,
default=datetime.utcnow) # auto_now_add=True
updatedAt = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
@validates('title')
def update_slug(self, key, value):
self.slug = slugify(value)
return value
@validates('text')
def update_html(self, key, value):
self.html = markdown.markdown(value)
return value
class User(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.String(80), nullable=False)
items = db.relationship('Item', backref=db.backref('user', lazy=True))
categories = db.relationship('Category',
backref=db.backref('user', lazy=True))
auditLogs = db.relationship('AuditLog',
backref=db.backref('user', lazy=True))
created_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
def __init__(self, user_id):
self.user_id = user_id
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text)
dates = db.relationship("Date",
lazy="select",
backref=db.backref("user", lazy='joined'))
def __repr__(self):
return '<User id={id} name={name}>'.format(id=self.id, name=self.name)
class Startup(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False, default="")
email = db.Column(db.String(50), nullable=False, default="")
startup_date = db.Column(db.Date)
description = db.Column(db.String(300))
password_hash = db.Column(db.String(128))
location = db.Column(db.String(100))
markerText = db.Column(db.String(100))
tags = db.relationship('Tag',
secondary='tag_map',
backref=db.backref('startup', lazy='dynamic'))
job_positions = db.relationship('Job_position',
backref='publishded_by',
lazy=True)
profile_picture = db.Column(db.String(30), default="profile_man.jpg")
def generate_data():
import datetime
db.session.add(
dummydataStartUp("Mesla", "melon_dusk",
"Vi lager biler som kjører på møkk",
"San Fransisco", 1, "Mesla.png"))
db.session.add(
dummydataStartUp("Den Kebabnorske Bank", "bankfloss",
"Whallah, vi låner deg floos brur", "Oslo", 3,
"KebabnorskBank.png"))
db.session.add(
dummydataStartUp("MoTube", "motube", "Forum for kuvideoer",
"San Fransisco", 1, "MoTube.png"))
db.session.add(
dummydataStartUp("KanAkademi", "notkhan",
"Free education 4 stupid people", "San Fransisco",
15, "KanAkademi.png"))
db.session.add(
dummydataStartUp(
"AiDiabitus", "diabetus",
"Vi lager en AI som sier at du er feit og holder på å få diabetes",
"San Fransisco", 6, "AiDiabitus.png"))
db.session.add(
dummydataStartUp(
"IkkeA", "billigmobler",
"Billig møbler om har alt for vanskelige instrukser",
"stockholm", 8, "IkkeA.png"))
try:
db.session.commit()
print("ADDED STARTUPS")
except:
db.session.rollback()
def _repr_(self):
return '<user{}>'.format(self.email)
def __str__(self):
return "Startup: {}".format(self.email)
class Job_applicant(db.Model):
__tablename__ = 'Job_applicant'
id = db.Column(db.Integer, primary_key=True, nullable=False)
first_name = db.Column(db.String(120), nullable=False, default="")
last_name = db.Column(db.String(120), nullable=False, default="")
birth_date = db.Column(db.Date)
email = db.Column(db.String(50))
password_hash = db.Column(db.String(128))
CV = db.Column(db.String(500))
former_jobs = db.Column(db.String(200))
profile_picture = db.Column(db.String(30), default="profile_man.jpg")
tags = db.relationship('Tag',
secondary='tag_map',
backref=db.backref('Job_applicant', lazy='dynamic'))
location = db.Column(db.String(100))
markerText = db.Column(db.String(100))
def generate_data():
job_applicant1 = Job_applicant(first_name="Hanniballer",
last_name="aldri",
birth_date=datetime.datetime.now(),
email="*****@*****.**",
CV="alt",
former_jobs="morendin",
profile_picture="MrGuns.jpeg",
location="høyskoleringen 3",
markerText="P15")
set_password(job_applicant1, "passord123")
job_applicant1.tags.append(Tag.query.first())
job_applicant2 = Job_applicant(first_name="Harald",
last_name="Ødegård",
birth_date=datetime.datetime.now(),
email="*****@*****.**",
CV="Hanniballes kunnskap < Meg",
former_jobs="Sjefen til Asgeir",
profile_picture="Halvor.png",
location="Trondheim",
markerText="Eier alt her")
set_password(job_applicant2, "123")
job_applicant2.tags.append(Tag.query.first())
db.session.add(job_applicant2)
try:
db.session.commit()
print("ADDED JOB APPLICANTS")
except:
db.session.rollback()
def __repr__(self):
return '<User {}>'.format(self.email)
def __str__(self):
return '<User {}>'.format(self.email)
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
name = db.Column(db.String(80), nullable=False)
items = db.relationship('Item', backref=db.backref('category', lazy=True))
created_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
def __init__(self, name, user_id):
self.name = name
self.user_id = user_id
class Design(db.Model):
design_id = db.Column(db.Integer, primary_key=True)
design_name = db.Column(db.String(40))
design_content = db.Column(db.String(200))
date_created = db.Column(db.DateTime, default=datetime.utcnow)
subscriptions = db.relationship('Tag',
secondary=subs,
backref=db.backref('subscribers',
lazy='dynamic'))
def __repr__(self):
return '<Design {}>'.format(self.design_id)
class Timeline(db.Model):
id = db.Column(db.Integer, primary_key=True)
headline = db.Column(db.String(80))
text = db.Column(db.Text)
# text = db.Column(db.String(255), unique=True)
asset_id = db.Column(db.Integer, db.ForeignKey('asset.id'))
asset = db.relationship('Asset',
backref=db.backref('timelines', lazy='dynamic'))
def __init__(self, headline, text, asset):
self.headline = headline
self.text = text
self.asset = asset
def __repr__(self):
return "<Timeline(headline='%s', text='%s')>'" % (self.headline, self.text)
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(120), nullable=False)
body = db.Column(db.Text(), nullable=False)
created = db.Column(db.DateTime(), nullable=False,
server_default=func.now())
author_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
author = db.relationship('User', lazy=True,
backref=db.backref('posts', lazy=True))
def __repr__(self):
return '<Post %r %r %r %r>' % (self.title, self.body, self.created,
self.author.username)
class Location(db.Model):
"""Stores the location & time"""
__tablename__ = 'Locations'
id = db.Column(db.Integer, primary_key=True)
person_id = db.Column(db.Integer, db.ForeignKey('People.id'))
#This stores the long, lat and time.
longitude = db.Column(db.Float)
latitude = db.Column(db.Float)
time = db.Column(db.String(16))
# Relationship store the person's locations as a list in the person's table in the people table.
person = db.relationship('Person',
backref=db.backref('Locations',
lazy='dynamic',
collection_class=list))
class Entry(db.Model):
id = db.Column(db.Integer, primary_key=True)
headline = db.Column(db.String(80))
startDate = db.Column(db.String(80))
endDate = db.Column(db.String(80))
text = db.Column(db.Text)
asset_id = db.Column(db.Integer, db.ForeignKey('asset.id'))
asset = db.relationship('Asset',
backref=db.backref('entries', lazy='dynamic'))
def __init__(self, headline, startDate, endDate, text, asset):
self.headline = headline
self.startDate = startDate
self.endDate = endDate
self.text = text
self.asset = asset
def __repr__(self):
return "<Headline(headline='%s', startDate='%s', endDate='%s', text='%s')>" % (self.headline, self.startDate, self.endDate, self.text)
class User(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
posts = db.relationship('Post', backref='author', lazy='dynamic')
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def __repr__(self):
return '<User {}>'.format(self.username)
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_posts(self):
followed = Post.query.join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
own = Post.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Post.timestamp.desc())
# 添加修改密码，使用jwt生成密钥
def get_reset_password_token(self, expires_in=600):
return jwt.encode(
{
'reset_password': self.id,
'exp': time() + expires_in
},
current_app.config['SECRET_KEY'],
algorithm='HS256').decode('utf8')
@staticmethod
def verify_reset_password_token(token):
try:
id = jwt.decode(token,
current_app.config['SECRET_KEY'],
algorithm=['HS256'])['reset_password']
except:
return
return User.query.get(id)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(64))
email = db.Column(db.String(120), index=True, unique=True)
password = db.Column(db.String(20))
about_me = db.Column(db.String(140))
last_seen = db.Column(db.DateTime)
items_per_page = db.Column(db.Integer, default=4)
avatarPath = db.Column(
db.String(140),
default=
'/home/weijiayun/PycharmProjects/blog/flaskr/static/useravatar/lena.png'
)
posts = db.relationship('Post', backref='author', lazy='dynamic')
comments = db.relationship('Comment', backref='byuser', lazy='dynamic')
likes = db.relationship('Like', backref='byuser', lazy='dynamic')
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
rejected = db.relationship('User',
secondary=rejecters,
primaryjoin=(rejecters.c.rejecter_id == id),
secondaryjoin=(rejecters.c.rejected_id == id),
backref=db.backref('rejecters', lazy='dynamic'),
lazy='dynamic')
def get_items_per_page(self):
return self.items_per_page
def avatar(self, size):
return reduce(self.id, self.avatarPath, size, size)[0]
def is_authenticated(self):
return True
def is_active(self):
return True
def is_anonymous(self):
return False
def get_id(self):
try:
return unicode(self.id) #python 2
except NameError:
return str(self.id) #python 3
def follow(self, user): #if user has been followed by self,return None
if not self.is_following(user):
self.followed.append(user)
return self
def unfollow(self, user): #if user is not followed by self ,return None
if self.is_following(user):
self.followed.remove(user)
return self
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def Followeds(self):
return self.followed.filter(followers.c.followed_id != self.id).all()
def cntFolloweds(self):
return self.followed.filter(followers.c.followed_id != self.id).count()
def Followers(self):
return self.followers.filter(followers.c.follower_id != self.id).all()
def cntFollowers(self):
return self.followers.filter(
followers.c.follower_id != self.id).count()
def reject(self, user):
if self.is_following(user):
if not self.is_rejecting(user):
self.rejected.append(user)
return self
def unreject(self, user):
if self.is_following(user):
if self.is_rejecting(user):
self.rejected.remove(user)
return self
def is_rejecting(self, user):
return self.rejected.filter(
rejecters.c.rejected_id == user.id).count() > 0
def get_followed_posts_count(self):
form1 = db.session.query(Post).join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
form2 = db.session.query(Post.id).join(
rejecters, (rejecters.c.rejected_id == Post.user_id)).filter(
rejecters.c.rejecter_id == self.id)
count = form1.filter(~Post.id.in_(form2)) \
.order_by(Post.timestamp.desc()).count()
return count
def get_followed_posts(self, page):
form1 = db.session.query(Post).join(
followers, (followers.c.followed_id == Post.user_id)).filter(
followers.c.follower_id == self.id)
form2 = db.session.query(Post.id).join(
rejecters, (rejecters.c.rejected_id == Post.user_id)).filter(
rejecters.c.rejecter_id == self.id)
form3 = form1.filter(~Post.id.in_(form2)) \
.order_by(Post.timestamp.desc())
form4 = form3.offset(
(page - 1) * self.items_per_page).limit(self.items_per_page).all()
return form4
def __repr__(self):
return '<User %r>' % (self.nickname)
class Post(db.Model):
__tablename__ = 'post'
id = db.Column(db.Integer, primary_key=True)
slug = db.Column(db.String, unique=True, nullable=False)
title = db.Column(db.String, nullable=False)
byline = db.Column(db.String, nullable=False)
publish_date = db.Column(db.DateTime, nullable=False)
# Image IDs
featured_id = db.Column(db.String, nullable=False)
banner_id = db.Column(db.String, nullable=False)
thumbnail_id = db.Column(db.String, nullable=False)
# MD5 hash of the post's Markdown
hash = db.Column(db.String, nullable=False)
is_featured = db.Column(db.Boolean, nullable=False)
is_published = db.Column(db.Boolean, nullable=False)
# Note: checking for valid hex colors is left to the application
title_color = db.Column(db.String(length=7), nullable=False)
# Tags (Many to Many)
tags = db.relationship(
'Tag',
secondary=relations.posts_to_tags,
# Note: this backref allows us to call Tag.posts on a `Tag` instance
backref=db.backref('posts', lazy='dynamic'),
)
# Images (Many to Many)
images = db.relationship(
'Image',
secondary=relations.posts_to_images,
# Note: this backref allows us to call Image.posts on an `Image` instance
backref=db.backref('images', lazy='dynamic'),
)
def __init__(
self,
slug: str,
title: str,
featured_image: 'Image',
banner_image: 'Image',
thumbnail_image: 'Image',
byline: str = None,
publish_date: dt.datetime = None,
is_featured: bool = None,
is_published: bool = None,
title_color: str = None,
tags: typing.List[Tag] = None,
markdown_text: str = None,
):
self.slug = slug
self.title = title
self.set_featured_image(featured_image)
self.set_banner_image(banner_image)
self.set_thumbnail_image(thumbnail_image)
self.byline = byline if byline else ''
self.publish_date = publish_date if publish_date else dt.datetime.now()
self.is_featured = is_featured if is_featured is not None else False
self.is_published = is_published if is_published is not None else False
self.set_title_color(title_color if title_color else '#FFFFFF')
self.tags = tags if tags else []
self.set_markdown(markdown_text if markdown_text else '')
def get_directory(self) -> pathlib.Path:
"""Return Path object to static folder."""
return pathlib.Path(flask.current_app.static_folder) / self.slug
def get_featured_image(self) -> Image:
return Image.query.filter_by(id=self.featured_id).first()
def get_banner_image(self) -> Image:
return Image.query.filter_by(id=self.banner_id).first()
def get_thumbnail_image(self) -> Image:
return Image.query.filter_by(id=self.thumbnail_id).first()
def get_markdown_path(self) -> pathlib.Path:
return self.get_directory() / 'post.md'
def set_featured_image(self, image: Image):
if (image.width, image.height) != constants.FEATURED_IMG_SIZE:
raise ValueError('Featured image has the wrong dimensions')
if self.featured_id:
curr_featured = Image.query.filter_by(id=self.featured_id).first()
self.images.remove(curr_featured)
self.featured_id = image.id
if image not in self.images:
self.images.append(image)
def set_banner_image(self, image: Image):
if (image.width, image.height) != constants.BANNER_SIZE:
raise ValueError('Banner image has the wrong dimensions')
if self.banner_id:
curr_banner = Image.query.filter_by(id=self.banner_id).first()
self.images.remove(curr_banner)
self.banner_id = image.id
if image not in self.images:
self.images.append(image)
def set_thumbnail_image(self, image: Image):
if (image.width, image.height) != constants.THUMBNAIL_SIZE:
raise ValueError('Thumbnail image has the wrong dimensions')
if self.thumbnail_id:
curr_thumbnail = Image.query.filter_by(
id=self.thumbnail_id).first()
self.images.remove(curr_thumbnail)
self.thumbnail_id = image.id
if image not in self.images:
self.images.append(image)
def set_title_color(self, color: str):
if not re.compile(constants.COLOR_REGEX).match(color):
raise ValueError('Improper HEX color (expects #[A-F]{6})')
self.title_color = color
# TODO: honestly, the image stuff needs some real testing
def set_markdown(self, markdown_text: str):
# Remove all images except for featured, banner, and thumbnail
self.images = [
img for img in self.images if img.id == self.featured_id
or img.id == self.banner_id or img.id == self.thumbnail_id
]
# Look up images referenced in the Markdown and ensure they exist
for image_name in md2.find_images(markdown_text):
found_image = Image.query.filter_by(filename=image_name).first()
if found_image:
self.images.append(found_image)
else:
msg = f'Image file not found on server: {image_name}'
raise ValueError(msg)
# Render HTML to check for errors
try:
md2.render_string(markdown_text)
except Exception as e:
raise ValueError(f'Error processing Markdown: {e}')
# Create directory
# TODO: probably refactor this out and just have a `posts` folder
self.get_directory().mkdir(exist_ok=True)
with open(self.get_markdown_path(), 'w+', encoding='utf-8') as out:
out.write(markdown_text)
self.hash = hashlib.md5(bytes(markdown_text,
encoding='utf8')).hexdigest()
# Add Markdown file to the search engine index
flask.current_app.search_engine.index_string(markdown_text,
self.slug,
allow_overwrite=True)
flask.current_app.search_engine.commit()
def render_html(self) -> str:
"""Retrieve the Markdown file containing the post's contents and render to HTML."""
with open(self.get_markdown_path(), encoding='utf-8',
errors='strict') as f:
markdown = f.read()
# Resolve image URLs. TODO: THIS IS REALLY INEFFICIENT. COULD ALSO ITERATE OVER THE POST'S IMAGES
for image_name in md2.find_images(markdown):
found_image = Image.query.filter_by(
filename=image_name).first()
markdown = md2.replace_image(markdown, image_name,
found_image.get_url())
html = md2.render_string(markdown)
# Render as a template to allow expanding `url_for()` calls (for example)
return flask.render_template_string(html)
def get_prev(self) -> 'Post':
return Post.query\
.filter(Post.publish_date < self.publish_date)\
.order_by(desc(Post.publish_date))\
.first()
def get_next(self) -> 'Post':
return Post.query\
.filter(Post.publish_date > self.publish_date)\
.order_by(asc(Post.publish_date))\
.first()
def to_dict(self) -> dict:
return {
constants.KEY_SLUG: self.slug,
constants.KEY_TITLE: self.title,
constants.KEY_BYLINE: self.byline,
constants.KEY_DATE:
self.publish_date.strftime(constants.DATE_FORMAT),
constants.KEY_IMAGE: self.featured_id,
constants.KEY_BANNER: self.banner_id,
constants.KEY_THUMBNAIL: self.thumbnail_id,
constants.KEY_HASH: self.hash,
constants.KEY_TAGS: [tag.slug for tag in self.tags],
constants.KEY_IMAGES:
{image.id: {
'hash': image.hash
}
for image in self.images},
constants.KEY_FEATURE: self.is_featured,
constants.KEY_PUBLISH: self.is_published,
}
def run_delete_logic(self):
"""
Perform logic to delete the post. The actual database record must
then be deleted via SQLAlchemy.
"""
shutil.rmtree(self.get_directory())
flask.current_app.search_engine.remove_document(self.slug)
def __repr__(self):
return 'Post(title="{}", slug="{}", date={}, tags={})'.format(
self.title,
self.slug,
self.publish_date,
self.tags,
)
class Frontpage_post(db.Model):
__tablename__ = 'frontpage_post'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False, default="")
body_text = db.Column(db.String(300))
author = db.Column(db.Integer,
db.ForeignKey(AdminUser.id),
nullable=False,
default=1)
made = db.Column(db.Date, default=datetime.datetime.now())
image = db.Column(
db.String(100),
default="https://mdbootstrap.com/img/Photos/Others/images/10.jpg")
# legge til img
tags = db.relationship('Tag',
secondary='tag_map',
backref=db.backref('Frontpage_posts',
lazy='dynamic'))
def generate_data():
post1 = Frontpage_post(
title="Velkommen til Momentum!",
body_text=
"Velkommen til Momentum, den nyeste nettsiden for startup-bedrifter og andre startup-interesserte! Lag en bruker som enten startup eller jobbsøker, og kom i kontakt med potensielle arbeidsgivere eller -takere. Som investor kan man søke seg frem til bedrifter eller sektorer man ønsker å investere i.",
author=1,
image=
"https://pilbox.themuse.com/image.jpg?url=https%3A%2F%2Fassets.themuse.com%2Fuploaded%2Fattachments%2F16096.jpg%3Fv%3De7619af4a2d0f77ea20a926ecc96ef3f15bec659f629e29195b8b1abbf5af147&bg=0fff&h=367&mode=fill&prog=1&w=750"
)
post1.tags.append(Tag.query.first())
post2 = Frontpage_post(
title="Trondheim blir første by med 5G",
body_text=
"Telenor lanserte i fjor høst Norges første 5G-pilot i Kongsberg. Siden den gang har det blitt annonsert en pilot til i Elverum og nå har selskapet bestemt hvor 5G-nettet skal skrus på først når det skal bygges ut som et ordinært mobilnett og ikke et testnett. Valget for hvor man først kan ta i bruk neste generasjons mobilnett falt på Trondheim. Fra og med i sommer begynner installasjonen av de første basestasjonene.",
author=1,
image=
"https://www.ntnu.no/documents/1265258993/1265296258/trondheim_eriksson_1200x400.jpg/85607465-6942-441a-9db7-6ce4696cd22e?t=1446629973278"
)
post2.tags.append(Tag.query.filter_by(id=2).one())
post5 = Frontpage_post(
title="du er verdt det",
body_text=
"det er på tide å stå opp, se seg selv i speilet og si 'gjør det heller i morgen, fordi du fortjener det'",
author=1,
image="https://mdbootstrap.com/img/Photos/Others/images/11.jpg")
post6 = Frontpage_post(
title="tingen er å ha det",
body_text=
"mange klager på å ikke ha ting, og det er da såklart et problem som kan påvirke hverdagen fra en tid til en annen når man minst tenker på det. gjerrr det bish",
image="https://mdbootstrap.com/img/Photos/Others/images/12.jpg")
post3 = Frontpage_post(
title="Bergens nye tech-fabrikk: Bygger startups i turbofart",
body_text=
"Startup-fabrikken New ble grunnlagt av flere profilerte tech-personligheter i Bergen i fjor sommer. De siste månedene har New utviklet konsepter på løpende bånd. Blant annet en brennhet transport-startup. Vi har forsøkt å fjerne alt «hazzle» med å ha bil. Vi skal tilby hele bredden av transportmidler, basert på kundenes brukermønster, forteller Hans Kristian Aas, daglig leder av Imove.",
author=1,
image=
"https://www.travelmarket.dk/gfx/tm_2011/flight/big/21-BGO.jpg")
post4 = Frontpage_post(
title="Kahoot på børs før sommeren",
body_text=
"I torsdagens investorpresentasjon varslet edtech-startupen at de kom til å bli notert på Merkur Market i løpet av andre kvartal. Vi velger å gå på børs for å ha muligheten til å hente kapital, for å kunne finansiere den ikke-organiske veksten, som tidvis vil ha et kapitalbehov. I forbindelse med børsnoteringen har vi ikke diskutert hvorvidt vi skal hente mer kapital, sier Furuseth i en artikkel i Finansavisen.",
author=1,
image="https://shifter.no/wp-content/uploads/2017/11/kahoot2.jpg")
db.session.add(post1)
db.session.add(post2)
db.session.add(post3)
db.session.add(post4)
db.session.add(post5)
db.session.add(post6)
db.session.commit()
try:
print("ADDED FRONTPAGE_POSTS")
except:
print("ERROR ADDING TAGS")
db.session.rollback()
def _repr_(self):
return '<{}>'.format(self.title)
def __str__(self):
return '<{}>'.format(self.title)
class Job_position(db.Model):
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(400))
deadline = db.Column(db.DATETIME)
title = db.Column(db.String(32), nullable=False)
contact_mail = db.Column(db.String(32))
tags = db.relationship('Tag',
secondary='tag_map',
backref=db.backref('job_positions', lazy='dynamic'))
startup = db.Column(db.Integer, db.ForeignKey(Startup.id), nullable=False)
profile_picture = db.Column(db.String(30), default="profile_man.jpg")
def generate_data():
job_position1 = Job_position(
description="kjip",
deadline=auth.to_datetimefield("2019-03-15"),
title="Vi trenger en MaskinMøkk designer",
startup=1,
contact_mail="kontakt_oss@melon_dusk.no")
job_position1.tags.append(Tag.query.filter_by(id=1).one())
job_position1.profile_picture = "Mesla.png"
taggers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
job_position2 = Job_position(
description="dette er din jobb, bare føl på den",
deadline=auth.to_datetimefield("1227-08-27"),
title="u the person",
startup=2,
contact_mail="*****@*****.**")
job_position2.tags = (Tag.query.filter(Tag.id.in_(
taggers[0:15:2])).all())
job_position2.profile_picture = "KebabnorskBank.png"
job_position3 = dummydataJobPosition("best", "spør noen andre",
"mhm@krak", "2019-03-15", 3)
job_position3.tags = Tag.query.filter(Tag.id.in_(taggers[1:5])).all()
job_position3.profile_picture = "MoTube.png"
job_position4 = dummydataJobPosition("mindre bra",
"ikke vet jeg da hehe",
"enseriø[email protected]",
"2019-03-15", 3)
job_position4.tags = Tag.query.filter(Tag.id.in_(taggers[15:-5])).all()
job_position4.profile_picture = "MoTube.png"
job_position5 = dummydataJobPosition("senior douche", "ikke min jobb",
"*****@*****.**",
"2019-03-15", 6)
job_position5.tags = Tag.query.filter(Tag.id.in_(
taggers[7:14:2])).all()
job_position5.profile_picture = "IkkeA.png"
job_position6 = dummydataJobPosition("minor bug", "4evaeva",
"*****@*****.**",
"2019-03-15", 5)
job_position6.tags = Tag.query.filter(Tag.id.in_(taggers[::3])).all()
job_position6.profile_picture = "AiDiabitus.png"
job_position7 = dummydataJobPosition("juicepresser",
"grind det shitten der",
"*****@*****.**", "2019-03-15",
4)
job_position7.tags = Tag.query.filter(Tag.id.in_(taggers[::4])).all()
job_position7.profile_picture = "KanAkademi.png"
job_position8 = dummydataJobPosition(
"PT", "Så lenge du er ripped går det fint",
"[email protected]", "2019-03-15", 3)
job_position8.tags = Tag.query.filter(Tag.id.in_(taggers[::15])).all()
job_position8.profile_picture = "MoTube.png"
db.session.add(job_position2)
db.session.add(job_position1)
db.session.add(job_position3)
db.session.add(job_position4)
db.session.add(job_position5)
db.session.add(job_position6)
db.session.add(job_position7)
try:
db.session.commit()
print("ADDED JOB_POSITIONS")
except:
db.session.rollback()
def _repr_(self):
return '<position {}>'.format(self.title)
def __str__(self):
return '<position {}>'.format(self.title)
