def signup(ctx, args_str):
"""Sign up for an event."""
user = ctx.message.author
args = args_str.split(DELIMITER)
print(args)
eid = args[0]
if (len(args) == 2):
print("2")
m_status = args[1]
else:
m_status = 1
db_user = session.query(MeetupUser).filter_by(userid=user.id,
event_id=eid).first()
if db_user:
print("if:" + str(db_user.id))
m_user = db_user
m_user.status = m_status
else:
m_user = MeetupUser(userid=user.id, event_id=eid, status=m_status)
m_event = session.query(MeetupEvent).filter_by(id=eid).first()
if not m_event:
return "No event found with ID " + eid
session.add(m_user)
session.commit()
retstring = "<@" + user.id + "> signed up for event ["
retstring += str(m_event.id) + "]: \n"
retstring += "Status: " + str(m_user.status)
return retstring
def create_tool(self):
# validate the data
validators = True
all_inputs = [
self.name_input.get(),
self.description_input.get('1.0', END),
self.daily_price_input.get(),
self.half_day_price_input.get(),
self.delivery_price_input.get()
]
for field in all_inputs:
if field == "":
self.error_label.config(text="Please fill all fields")
validators = False
if validators:
new_tool = Tools()
new_tool.name = self.name_input.get()
new_tool.description = self.description_input.get('1.0', END)
new_tool.daily_price = self.daily_price_input.get()
new_tool.half_day_price = self.half_day_price_input.get()
new_tool.delivery_cost = self.delivery_price_input.get()
new_tool.owner_id = self.CURRENT_USER
new_tool.availability = True
session.add(new_tool)
session.commit()
self.error_label.config(text="New tool successfully added",
fg="green")
def edit_mooc(field_id, mooc_id):
"""Edit a MOOC"""
field = session.query(Field).filter_by(id=field_id).first()
mooc = session.query(MOOC).filter_by(id=mooc_id, field_id=field_id).first()
# Verify if he is the user who created it
if mooc.user_id == login_session['user_id']:
if request.method == 'POST':
if request.form.get('title'):
mooc.title = request.form.get('title')
if request.form.get('provider'):
mooc.provider = request.form.get('provider')
if request.form.get('creator'):
mooc.creator = request.form.get('creator')
if request.form.get('level'):
mooc.level = request.form.get('level')
if request.form.get('url'):
mooc.url = request.form.get('url')
if request.form.get('description'):
mooc.description = request.form.get('description')
if request.form.get('image'):
mooc.image = request.form.get('image')
session.add(mooc)
session.commit()
flash('MOOC {} Successfully Edited'.format(mooc.title))
return redirect(url_for('mooc.show_moocs', field_id=field_id))
return render_template('edit_mooc.html', mooc=mooc, field=field)
else:
return jsonify(error={'msg': "You are not the owner of that!!"}), 401
def insert_user(user_id, password, name):
user = UserModel(user_id, password, name)
session.add(user)
session.commit()
session.close()
def insert_friend(owner_user_id, other_user_id):
friendship = FriendModel(user_id=owner_user_id, friend_user_id=other_user_id)
additional_friendship = FriendModel(user_id=other_user_id, friend_user_id=owner_user_id)
session.add(friendship)
session.add(additional_friendship)
session.commit()
def meetup(ctx, args_str):
"""Creates an event for people to sign up to.
At least that is the plan."""
print("Bla!" + args_str)
if not args_str:
print("empty string")
return show_meetups()
args_str = args_str.replace("; ", ";")
print("check:" + args_str)
user = ctx.message.author
date, title, event_descr = args_str.split(DELIMITER)
event_date = datetime.strptime(date, "%d.%m.%Y %H:%M")
m_event = MeetupEvent(date=event_date,
title=title,
description=event_descr,
created_by=str(user.id))
session.add(m_event)
session.commit()
retstring = "**<@" + user.id + "> created an Event:**" + "\n"
retstring += "Date: " + m_event.date.strftime("%d.%m.%Y") + "\n"
retstring += "Time: " + m_event.date.strftime("%H:%M") + "\n"
retstring += "Title: **" + m_event.title + "**\n"
retstring += "Description: " + m_event.description + "\n"
retstring += "--------------" + "\n"
retstring += "You can sign up for this event by typing *'!signup "
retstring += str(m_event.id) + "'*."
return retstring
def insert_message(user_id, room_id, content, type):
message = MessageModel(user_id=user_id,
room_id=room_id,
content=content,
type=type)
session.add(message)
session.commit()
def insert_room():
room = Room(name="")
session.add(room)
session.commit()
room_id = session.query(Room.id).first()
return room_id
def create_user(login_session):
"""Create a new user when logged in by oauth2 and Return user id"""
new_user = User(name=login_session['username'],
email=login_session['email'],
picture=login_session['picture'])
session.add(new_user)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).one()
return user.id
def return_tool(self):
if self.feedback.get('1.0', END) == "":
self.error_label.config(text="Please fill all fields")
return_tool = Returns(returned=True, booking_id=self.booking_id,
tool_condition=self.feedback.get('1.0', END), date=str(date.today()))
session.add(return_tool)
session.commit()
self.error_label.config(text="Item returned successfully")
def insert(uid):
try:
query = session.query(User).filter(User.uid == uid).first()
logging.error('exists '+str(query.uid))
return 'exists'
except AttributeError:
session.add(User(uid,0,0,1,0,'0',0,0,0,0,datetime.datetime.now().date(),'',0,0,0,0))
session.commit()
logging.error('ok')
return 'ok'
def addpost(self, user_id, nickname, post_body):
post = Posts()
post.user_id = user_id
post.body = post_body
post.timestamp = datetime.utcnow()
session.add(post)
session.commit()
# 建立全文检索索引
create_index(user_id=user_id, post_id=post.id, nickname=nickname, post_body=post_body)
return post
def insert_user(user_id, user_password, user_name):
user = User(id=user_id,
password=user_password,
name=user_name,
img=UserDefaultValue.image,
introduction=UserDefaultValue.introduction)
session.add(user)
session.commit()
session.close()
def book_tool(self):
validators = {"days": False, "availability": True}
# validation
if self.how_many_days.get() == 0:
self.validation_label.config(
text="You have to select a period of time for your booking")
validators['days'] = False
else:
validators["days"] = False
# check the availability of the tool
# grab all the bookings for the selected tool
_bookings = session.query(Booking).filter(
Booking.tool_id == self.tool_id).all()
already_booked = False
for booking in _bookings:
their_booking_day = booking.booked_date
their_period_of_time = booking.duration_of_booking
their_deltatime = datetime.datetime.strptime(their_booking_day, '%Y-%m-%d') +\
datetime.timedelta(days=float(their_period_of_time))
my_booking_day = datetime.datetime.combine(
self.calendar.get_date(), datetime.time.min)
my_period_of_time = self.period_of_time.get()
my_deltatime = my_booking_day + datetime.timedelta(
days=float(my_period_of_time))
if their_deltatime > my_booking_day:
# the tool is booked in that daterange
self.validation_label.config(
text=f"Somebody booked that tool in that daterange "
f"{their_booking_day} - {their_deltatime}")
break
else:
validators["days"] = True
if validators['days'] == True and validators["availability"] == True:
order = Checkout()
order.user_id = self.CURRENT_USER
order.tool_id = self.tool_id
order.duration_of_booking = self.how_many_days.get()
order.booked_date = self.calendar.get_date()
if self.delivery.get() == 1:
order.delivery = True
else:
order.delivery = False
session.add(order)
session.commit()
self.validation_label.config(text="Item added to basked")
def new_field():
"""Add a new CS field"""
if request.method == 'POST':
if request.form.get('name'):
field = Field(name=request.form.get('name'),
user_id=login_session.get('user_id'))
session.add(field)
session.commit()
flash('New Field {} Successfully Created'.format(field.name))
return redirect(url_for('field.index'))
return render_template('new_field.html')
def add():
uid = int(request.args.get('user_id'))
refer = str(request.args.get('refer'))
try:
query = session.query(User).filter(User.uid == uid).first()
logging.error(query.timezone)
return 'exists'
except AttributeError:
session.add(User(uid,0,15,1,0,refer,0,0,0,0,datetime.datetime.now().date(),'',0,0,0,0))
session.commit()
return 'ok'
def position(terminal_request):
# Load the field which your need to save!
content = terminal_request["client_content"]
# Do some Resolution according your need!
position_instance = PositionSplit(content)
# Get the attribute of the PositionSplit and you'll got a Dict type
result_dict = position_instance.result
# Convert the client request data to the new type if you need!
ConvertBaseRegister(result_dict)
# Get the data with Dict format!
position_info = position_instance.result
print "position_info", position_info
# Send to ORM & Save it to Data Base!
p_i = PositionTable(**position_info)
session.add(p_i)
session.commit()
def add(self, username, password, nickname, description):
user = Users()
user.username = username
user.password = password
user.nickname = nickname
user.description = description
user.email = ''
user.imgpath = 'default.jpg'
session.add(user)
session.commit()
#
user.follow(user)
session.add(user)
session.commit()
return user
def test_follow(self):
u1 = Users()
u1.username = '******'
u1.password = '******'
u1.nickname = 'Json'
u1.description = 'This is Json'
u1.email = '*****@*****.**'
u1.imgpath = 'default.jpg'
u1.last_seen = datetime.utcnow()
u2 = Users()
u2.username = '******'
u2.password = '******'
u2.nickname = 'Kathy'
u2.description = 'This is Kathy'
u2.email = '*****@*****.**'
u2.imgpath = 'default.jpg'
u2.last_seen = datetime.utcnow()
session.add(u1)
session.add(u2)
session.commit()
self.assertNotEqual(u1.unfollow(u2), None)
u = u1.follow(u2)
print(u1)
print(u2)
print(u)
session.add(u)
session.commit()
self.assertEqual(u1.is_following(u2), True)
self.assertEqual(u1.followed.count(), 1)
self.assertEqual(u2.followed.count(), 0)
async def post(self, request: Request) -> Response:
data = await request.json()
post = Post(title=data["title"],
body=data['body'],
created_at=datetime.datetime.now(),
created_by=data['created_by'])
session.add(post)
session.commit()
return Response(status=201,
body=self.resource.encode({
"posts": [{
'id': post.id,
'title': post.title,
'body': post.body,
'created_at': str(post.created_at),
'created_by': post.created_by
} for post in session.query(Post)]
}),
content_type="application/json")
def new_mooc(field_id):
"""Add new MOOC"""
field = session.query(Field).filter_by(id=field_id).first()
if request.method == 'POST':
if request.form.get('title') and request.form.get('provider') \
and request.form.get('url'):
mooc = MOOC(title=request.form.get('title'),
provider=request.form.get('provider'),
creator=request.form.get('creator'),
level=request.form.get('level'),
url=request.form.get('url'),
description=request.form.get('description'),
image=request.form.get('image'),
field=field,
user_id=login_session.get('user_id'))
session.add(mooc)
session.commit()
flash('New MOOC {} Successfully Created'.format(mooc.title))
return redirect(url_for('mooc.show_moocs', field_id=field_id))
return render_template('new_mooc.html', field=field)
def load_csv(table, csv_file, **kwargs):
"""loads a csv into a database table, must share the same schema.
:param table: sqlalchemy.Base Table object
:param csv_file: path to csv file
:return: None
"""
with open(csv_file, 'r') as csvfile:
for row in csv.DictReader(csvfile):
# convert date string to datetime() object
if 'last_mod' in row:
row['last_mod'] = timestamp_to_date(row['last_mod'])
# add any additional key word arguments
for k,v in six.iteritems(kwargs):
row[k] = v
# write row, unpack dict to key word arguments
record = table(**row)
session.add(record)
print('loaded "{}" into SQLite database'.format(csv_file))
def save(self):
self.updated_at = datetime.now()
session.add(self)
session.commit()
def save(self):
session.add(self)
session.commit()
def add_city():
city = request.args.get('city')
offset = int(request.args.get('offset'))
session.add(Cities(city,offset))
session.commit()
return 'ok'
