def run():
"""
Create 4 Event seeds
"""
speak_event = Event()
speak_event.information = 'Speaking about javascript frameworks: Vue, React, and Angular'
speak_event.user_id = 4
speak_event.title = 'Javascript Frameworks'
speak_event.type = 'speaker'
db.session.add(speak_event)
speak_b_event = Event()
speak_b_event.information = 'Speaking about Native Java / Kotlin vs React-native'
speak_b_event.user_id = 4
speak_b_event.title = 'Mobile Software development'
speak_b_event.type = 'speaker'
db.session.add(speak_b_event)
hackaton_a_event = Event()
hackaton_a_event.information = 'PHP Indonesia Group, Contributing library to the world'
hackaton_a_event.title = 'PHP Library Hackaton'
hackaton_a_event.type = 'hackaton'
db.session.add(hackaton_a_event)
booth_event = Event()
booth_event.information = 'Github'
booth_event.title = 'Github Booth'
booth_event.type = 'booth'
db.session.add(booth_event)
db.session.commit()
def check_idea_change_event(idea):
votes = db.session.query(Vote).filter_by(idea_id=idea.id).filter(Vote.user_id != idea.user_id).all()
for vote in votes:
save_event(Event(type=EventType.idea_changed,
user_id=vote.user_id,
idea_name=idea.title,
created=idea.modified))
def check_vote_event(vote):
idea = Idea.query.get(vote.idea_id)
if idea is None:
return
if vote.value > 0 and idea.upvotes % 5 == 0:
save_event(Event(type=EventType.upvotes,
user_id=idea.user_id,
idea_name=idea.title,
data=idea.upvotes,
created=vote.created))
elif idea.votes_count % 10 == 0:
save_event(Event(type=EventType.votes,
user_id=idea.user_id,
idea_name=idea.title,
data=idea.votes_count,
created=vote.created))
def create_event(attributes):
start_at = datetime.strptime(attributes['start_at'], DATETIME_FORMAT) - timedelta(hours=UTC_OFFSET)
room = Room(
name=attributes['name'],
teacher=current_user,
role=Room.CONSULTATION
)
event = Event(
name=attributes['name'],
teacher=current_user,
room=room,
start_at=start_at
)
groups = []
for group_id in attributes['groups']:
groups.append(
Group.query.get(group_id)
)
room.groups = groups
db.session.add(room)
db.session.add(event)
db.session.commit()
_get_events()
def create_event(name='TestEvent', creator_email=None):
"""Creates Event and returns its `id`.
:param creator_email:
:param name Name of Event
"""
event = Event(name=name,
start_time=datetime(2016, 4, 8, 12, 30, 45),
end_time=datetime(2016, 4, 9, 12, 30, 45))
if creator_email:
event.creator = User.query.filter_by(email=creator_email).first()
save_to_db(event, 'Event saved')
copyright = Copyright(holder='copyright holder', event=event)
save_to_db(copyright, "Copyright saved")
if creator_email:
# Add creator as Organizer
data = {
'user_email': creator_email,
'user_role': ORGANIZER,
}
DataManager.add_role_to_event(data, event.id, record=False)
return event.id
def post(self, roomName):
room = Room.query.filter(Room.name == roomName).first()
if not room:
return "Room {} not found.".format(roomName), 404
events = request.get_json()
eventSchema = EventSchema()
Event.begin()
for evt in events:
user = User.query.filter(User.uid == evt['uid']).first()
if (user == None):
#Lucio 20190516: Add unknown users
User.begin()
user = User("UNKNOWN USER", "*****@*****.**", evt['uid'],
UserTypesEnum.STUDENT)
user.add(user)
User.commit()
result = eventSchema.load(evt)
if (len(result.errors) > 0):
return 'Error parsing content:{}.'.format(result.errors), 400
event = Event()
event.roomId = room.id
event.userId = user.id
event.eventType = EventTypesEnum[result.data['eventType']]
event.dateTime = result.data['dateTime']
event.add(event)
Event.commit()
return "All events updated", 200
def event_registrer():
if request.method == 'OPTIONS':
return jsonify({})
if request.json['type_event'] in ['eventos-saude', 'eventos-bem-estar', 'eventos-informativo']:
name = request.json['name']
descripton = request.json['descripton']
date = datetime.strptime(request.json['date'], '%d/%m/%Y').date()
type_event = request.json['type_event']
latitude = request.json['latitude']
longitude = request.json['longitude']
event = Event(
name,
descripton,
date,
type_event,
latitude,
longitude
)
db.session.add(event)
db.session.commit()
result = event_share_schema.dump(
Event.query.filter_by(name=name).first()
)
return jsonify(result)
return jsonify({'error': 'Tipo de evento inválido!'})
def check_idea_delete_event(idea):
votes = db.session.query(Vote).filter_by(idea_id=idea.id).filter(Vote.user_id != idea.user_id).all()
for vote in votes:
save_event(Event(type=EventType.idea_deleted,
user_id=vote.user_id,
idea_name=idea.title,
created=datetime.utcnow()))
def test_init(self):
props = {
'attr1': 'value1',
'attr2': 15
}
event = Event(props)
self.assertEqual(event.attr1, 'value1')
self.assertEqual(event.attr2, 15)
def test_dumps(self):
props = {
"attr1": "value2",
"attr2": 16
}
event = Event(props)
json_str1 = event.dumps()
self.assertEqual(json_str1, json.dumps(props))
def add_new_event():
event_date = request.form['date']
event_name = request.form['name']
event_guest = request.form['number_of_guest']
event_location = request.form['location']
event_desc = request.form['description']
new_event = Event(event_date, event_name, event_guest, event_location, event_desc, False)
add_event(new_event)
return render_template ('index.html', events=events)
def init_event(vote):
idea = Idea.query.get(vote.idea_id)
if vote.value > 0 and idea.upvotes % 5 == 0:
event = (Event(type=EventType.upvotes,
user_id=idea.user_id,
idea_name=idea.title,
data=idea.upvotes,
created=vote.created))
db.session.add(event)
db.session.commit()
elif idea.votes_count % 10 == 0:
event = (Event(type=EventType.votes,
user_id=idea.user_id,
idea_name=idea.title,
data=idea.votes_count,
created=vote.created))
db.session.add(event)
db.session.commit()
def get_event():
return Event(name="event1",
start_time=datetime(2003, 8, 4, 12, 30, 45),
end_time=datetime(2003, 9, 4, 12, 30, 45),
location_name='India',
topic='Travel & Outdoor',
sub_topic='Climbing',
has_session_speakers=True,
type='Camp, Trip, or Retreat')
def add_event(data):
if g.user.admin:
dt = datetime.strptime(data["datetime"], "%Y-%m-%d %H:%M")
t = Event(data["name"], dt)
db.session.add(t)
db.session.commit()
return jsonify({"event_id": t.id}), 200
else:
return jsonify({"message": "unauthorized"}), 401
def test_restore_event_from_trash(self):
with app.test_request_context():
event = Event(name="event1",
start_time=datetime(2003, 8, 4, 12, 30, 45),
end_time=datetime(2003, 9, 4, 12, 30, 45),
in_trash=True)
save_to_db(event, "Event saved")
restore_event(1)
self.assertEqual(event.in_trash, False)
def test_restore_event_from_trash(self):
with app.test_request_context():
event = Event(name="event1",
start_time=datetime(2003, 8, 4, 12, 30, 45),
end_time=datetime(2003, 9, 4, 12, 30, 45),
deleted_at=datetime.now())
save_to_db(event, "Event saved")
restore_event(1)
self.assertEqual(event.deleted_at, None)
def add_event():
event_name = request.form['event_name']
event_date = request.form['event_date']
event_guests = request.form['event_guests']
event_location = request.form['event_location']
event_description = request.form['event_description']
event_recurring = request.form['event_recurring']
new_event = Event(event_date, event_name, event_guests, event_location, event_description, event_recurring)
add_new_event(new_event)
return render_template('events.html', title="Events List", events=events)
def add_event():
"""Add an event to the database
Events are proposed meetings. A date has a specific AG which
it is part of.
:return: JSON object with redirect if successful
or Unauthorized/NotFound
"""
ag_id = request.values.get('ag')
if db.session.query(exists().where(AG.id == ag_id)).scalar():
if db.session.query(exists().where(UserAG.user_id == g.session.user_id and\
UserAG.ag_id == ag_id)).scalar():
user_ag = UserAG.query.filter_by(user_id=g.session.user_id,
ag_id=ag_id).scalar()
if user_ag.role == 'MENTOR':
display_name = request.values.get('display_name')
description = request.values.get('description')
if not display_name or len(display_name) > 48:
return jsonify({'reason': 'display_name'}), 400
if len(description) > 280:
return jsonify({'reason': 'description'}), 400
event = Event()
event.display_name = display_name
event.description = description
event.ag_id = ag_id
event.date = None
db.session.add(event)
dates = request.values.getlist('dates[]')
for _date in dates:
formatted_datetime = datetime.datetime.strptime(
_date, '%a %b %d %Y').date()
if db.session.query(exists().where(
Date.day == formatted_datetime)).scalar():
u_date = Date.query.filter_by(
day=formatted_datetime).scalar()
u_date.users.append(g.user)
u_date.events.append(event)
continue
else:
date_obj: Date = Date()
date_obj.users.append(g.user)
date_obj.events.append(event)
date_obj.day = formatted_datetime
db.session.add(date_obj)
db.session.commit()
return jsonify({'status': 'success', 'redirect': '/'}), 200
return Unauthorized()
return NotFound()
def create():
event_id = len(events) + 1
event_date = request.form['date']
event_name = request.form['name']
no_of_guests = request.form['no_of_guests']
room = request.form['room']
description = request.form['description']
new_event = Event(event_id, event_date, event_name, no_of_guests, room,
description)
add_new_event(new_event)
return redirect('/events')
def post(self):
create_form = CreateEventForm(self.request.POST)
if not create_form.validate():
context = self.get_context()
context.update({'create_form': create_form})
self.render_response('home.html', **context)
else:
event = Event(**({key: value for key, value in create_form.data.iteritems() if key != 'submit'}))
event.put()
self.redirect("%d/" % event.id)
def test_add_event_to_trash(self):
with app.test_request_context():
event = Event(name="event1",
start_time=datetime(2003, 8, 4, 12, 30, 45),
end_time=datetime(2003, 9, 4, 12, 30, 45),
in_trash=False)
save_to_db(event, "Event saved")
DataManager.trash_event(1)
url = url_for('events.index_view')
rv = self.app.get(url)
self.assertFalse('event1' in rv.data)
self.assertEqual(event.in_trash, True)
def create_new_event(self, user, **kwargs):
logging.info(
"Creating a event for user {user_id}".format(user_id=user.id))
group_id = int(kwargs.get('group_id'))
name = kwargs.get('name')
start_date = int(kwargs.get("start_date"))
end_date = int(kwargs.get("end_date"))
location = kwargs.get("location", "")
description = kwargs.get("description", "")
alert_time = kwargs.get("alert_time")
alert_time = int(alert_time) if alert_time else None
verification_code = kwargs.get("verification_code")
group = Group.query.filter(Group.id == group_id,
Group.is_deleted == False).first()
if not group:
e = GROUP_NOT_FOUND_404
e['text'] = e['text'].format(group_id)
return e, 404
if group.creator_id != user.id:
e = USER_NOT_GROUP_CREATOR_301
e['text'] = e['text'].format(user_id=user.id, group_id=group_id)
return e, 301
if start_date > end_date:
return START_DATE_LATER_THAN_END_DATE_400, 400
event = Event(group, name, start_date, end_date, description, location,
alert_time, verification_code)
db.session.add(event)
db.session.commit()
if alert_time:
schedule_event_alert(event)
attendance = Attendance(user, event, 1, "")
db.session.add(attendance)
db.session.commit()
d = dict()
d['event_id'] = event.id
d['name'] = event.name
d['start_date'] = event.start_date
d['end_date'] = event.end_date
d['description'] = event.description
d['location'] = event.location
d['alert_time'] = event.alert_time
d['verification_code'] = event.verification_code
return d, 200
def create():
"""
创建一个事件
:return:
"""
with db.auto_commit():
event = Event()
form = EventForm().validate_for_api()
event.name = form.name.data
event.type = form.type.data
event.create_time = form.create_time.data
event.content = form.content.data
db.session.add(event)
return Success()
def service_connection(gwConnection, gwAddress):
'''
Handles thread data from ingest loop.
'''
app.logger.info('Received from:%s' % str(gwAddress))
# Fetch data from connection, notify for success and close connection
recv_data = gwConnection.recv(2048)
response = b'1'
gwConnection.send(response)
gwConnection.close()
# No recv_data means empty socket body
if recv_data:
# Decode received data with utf-8 and converse string to immutable type - namedtuple
decoded_data = recv_data.decode('utf-8')
# TODO - This step is optional. You may want to proceed with dict type
decoded_event = json.loads(
decoded_data,
object_hook=lambda d: namedtuple('X', d.keys())(*d.values()))
# Create new event on database. Multiple available ways to save event. We just wanted a verbose and
# easy-to-understand way.
event = Event(device_number=decoded_event.device_number,
event_code=decoded_event.event_code,
message_date=decoded_event.message_date,
longitude=decoded_event.longitude,
latitude=decoded_event.latitude)
try:
# There are plenty of options for commiting to db.
db_session = create_session()
db_session.merge(event)
db_session.commit()
# Too many open PostgreSQL connections may give you an error
db_session.close()
app.logger.info('Event %s Pushed Successfully to PostgreSQL' %
(str(gwAddress)))
except Exception as e:
# TODO - Here you can add different actions according to type of error.
# Most common case, PostgreSQL is down. You may have, for example, to restart it
# Our action: Upon save failure publish to rabbitmq
publisher = Publisher()
publisher.init(publisher_conf_dict)
publisher.publish(decoded_data)
app.logger.info('Error: %s' % (str(e)))
app.logger.info('Event Published to RabbitMQ through Publisher')
else:
app.logger.warning('Socket empty. Connection closed')
def add_event():
date = request.form["date"]
name = request.form["name"]
no_of_guests = request.form["no-of-guests"]
room_location = request.form["room-location"]
description = request.form["description"]
is_weekly = False
try:
if request.form["is-weekly"]:
is_weekly = True
except:
pass
new_event = Event(date=date, name=name, num_guests=no_of_guests, room_location=room_location, description=description, is_weekly=is_weekly)
add_new_event(new_event)
return render_template("index.html", title="Home", event_list=event_list)
def add_event():
event_name = request.form['event_name']
event_date = request.form['event_date']
event_location = request.form['location']
event_guest_number = request.form['number']
event_description = request.form['description']
recurring_event = True if 'recurring_event' in request.form else False
new_event = Event(event_date, event_name, event_guest_number,
event_location, event_description, recurring_event)
if recurring_event:
recurring_event_list.append(new_event)
else:
event_list.append(new_event)
return redirect('/')
def create_event(self, name, category, location, date_hosted, description):
"""
Method creates an event by first checking its existence and raising an integrity error if in existence
:param date_hosted:
:param name:
:param category:
:param location:
:param description:
:return:
"""
event = Event.query.filter_by(name=name).filter_by(category=category).filter_by(owner=self.id).filter_by(
date_hosted=date_hosted).first()
if not event:
event = Event(name=name, category=category, location=location, owner=self.id, date_hosted=date_hosted,
description=description, )
db.session.add(event)
db.session.commit()
return event
def event_create(user, user_type, args):
if user_type != 'Organizer':
raise Error(status_code=StatusCode.UNAUTHORIZED,
error_message='Invalid token')
event = Event.query.filter_by(title=args['title']).first()
if event is not None:
raise Error(status_code=StatusCode.BAD_REQUEST,
error_message='Duplicated event')
location = Location.query.filter_by(id=args['location_id'],
owner_id=user.id).first()
if location is None:
raise Error(status_code=StatusCode.BAD_REQUEST,
error_message='Location not belongs to owner')
if args['type'] != 'public' and args['type'] != 'private':
raise Error(status_code=StatusCode.BAD_REQUEST,
error_message='Invalid type of event')
event = Event(
title=args['title'],
description=args['description'],
category=args['category'],
# start_date=datetime.datetime.strptime(args['start_date'], '%d-%m-%Y %H:%M'),
# end_date=datetime.datetime.strptime(args['end_Date'], '%d-%m-%Y %H:%M'),
start_date=args['start_date'],
end_date=args['end_date'],
location_id=location.id,
owner_id=user.id,
type=args['type'],
capacity=args['capacity'])
db.session.add(event)
db.session.commit()
return jsonify({
'message': 'Event created successfully',
'data': event.serialize()
}), 201
def __init__(self, timestamp: int, vehicle_id: str, event_type: str,
lat: float, long: float, user_id: int, session: Session):
# Format input vars
self._timestamp = int(timestamp)
self._event_type = EventType[event_type]
self._lat = float(lat)
self._long = float(long)
self._user_id = (None if user_id == 'NULL' else int(user_id))
self._session = session
# Set User
self.user = DBOperations.find_or_initialize_by(self._session, User,
**{'id': self._user_id})
# Set Location
self.location = Location(lat=self._lat, long=self._long)
# Set Vehicle
self.vehicle = DBOperations.find_or_initialize_by(
self._session, Vehicle, **{'id': vehicle_id})
self.vehicle.update_location(self._event_type, self.location)
# Set Event
self.event = Event(
type=self._event_type,
timestamp=self._timestamp,
location=self.location,
vehicle=self.vehicle,
)
# Set Ride
self.ride = None
if self.event.type is EventType.START_RIDE:
self.ride = Ride(self.user, self.vehicle, self.event)
elif self.event.type is EventType.END_RIDE:
self.ride = self.user.rides[-1]
self.ride.end_ride(self.event)
def create(self, payloads):
response = ResponseBuilder()
try:
information = payloads[
'information'] if 'information' in payloads else None
title = payloads['title'] if 'title' in payloads else None
type = payloads['type'] if 'type' in payloads else None
user_id = payloads['user_id'] if 'user_id' in payloads else None
if type == 'discuss panel':
# nullify user id, move to users and insert to panel_event instead
user_id = None
users = payloads['user_id'] if 'user_id' in payloads else None
self.events_model = Event()
self.events_model.information = information
self.events_model.title = title
self.events_model.type = type
self.events_model.user_id = user_id
db.session.add(self.events_model)
db.session.commit()
if type == 'discuss panel':
# save the users to panel event
for uid in users:
panel_event = PanelEvent()
panel_event.event_id = self.events_model.id
panel_event.user_id = uid
db.session.add(panel_event)
db.session.commit()
data = self.events_model.as_dict()
return response.set_data(data).build()
except SQLAlchemyError as e:
data = e.orig.args
response.set_data(data).set_error(True).build()
