def clean_expired_leases(event_id):
event_data, error = models.Event(event_id).get()
expired_leases = []
for lease in event_data['orderLeases']:
logging.warn(event_data['orderLeases'][lease])
if is_date_in_past(
from_datestring(
event_data['orderLeases'][lease]['leaseExpiresAt'])):
expired_leases.append(lease)
event_data['remainingAttendeeCapacity'] = event_data[
'remainingAttendeeCapacity'] + event_data['orderLeases'][
lease]['places']
if len(expired_leases) > 0:
for lease in expired_leases:
del event_data['orderLeases'][lease]
event = models.Event(event_id)
event.update(event_data)
pass
def add():
form = forms.AddEventForm()
if form.validate_on_submit():
event = models.Event(title=form.title.data, date=datetime.utcnow())
db1.session.add(event)
db1.session.commit()
flash('Event added')
print("Added Event", form.title.data, event.title, event.date)
return redirect(url_for('index'))
return render_template('add.html', form=form)
def get(self):
self.FirstInit()
template_values = {}
lat = self.request.get('lat')
old_event = None
temp_place = None
user = models.get_current_user()
if user:
if not user.username:
self.redirect('/profile')
return
old_event = models.Event.all().filter(
"user ="******"-when_end").get()
if old_event == None:
old_event = models.Event()
temp_place = models.Place()
temp_place.put()
old_event.place = temp_place.key()
if len(lat) > 0:
old_event.place.place_name = self.request.get('name')
old_event.place.lat = float(lat)
old_event.place.lon = float(self.request.get('lon'))
old_event.lat = float(lat)
old_event.lon = float(self.request.get('lon'))
old_event.where_addr = self.request.get('addr')
if old_event.who_name == "None" or old_event.who_name == None:
old_event.who_name = ""
if old_event.what == "None" or old_event.what == None:
old_event.what = ""
if old_event.skill == "None" or old_event.skill == None:
old_event.skill = ""
if old_event.skill_neighbor == "None" or old_event.skill_neighbor == None:
old_event.skill_neighbor = ""
if old_event.where_detail == "None" or old_event.where_detail == None:
old_event.where_detail = ""
logging.info("----> %s " % old_event.what)
if old_event:
template_values.update({"old_event": old_event})
self.AddUserInfo(template_values)
path = os.path.join(os.path.dirname(__file__),
'templates/add_event2.htm')
self.response.out.write(template.render(path, template_values))
if temp_place:
temp_place.delete()
def userevents(userid):
# POST /events (new event creation info submitted here)
if request.method == 'POST':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
username = session['username']
if 'username' not in session:
return render_template('login.html', error=error)
#import pdb; pdb.set_trace()
#import dateutil.parser
if ((request.form["Submit"] == "Submit Query")
or (request.form["Submit"] == "Submit")):
if (request.form["title"] and request.form["preeventtxt"] and \
request.form["prefearfactor"] and request.form["datetime"]):
title = request.form['title']
preeventtxt = request.form['preeventtxt']
prefearfactor = request.form[
'prefearfactor'] #no rating fear out of 10
datetime = request.form['datetime']
#datetime = dateutil.parser.parse(datetimefield)
#if isinstance(request.form['datetime'],dt.datetime):
# datetime=request.form['datetime']
#else:
# import re
# datetime = dt.datetime(re.split('[\s,:,am,pm]+',request.form['datetime'])) #time of future event given by user
#else:
#error= "All fields are mandatory!"
#return render_template('dashboard.html', error=error), 400
#else:
#error= "Need to submit after form entry!"
#return render_template('dashboard.html', error=error), 400
users = models.User.query.filter_by(username=username).all()
userid = users[0].userid
status = 0
models.db.session.add(
models.Event(title, datetime, preeventtxt, "",
prefearfactor, 0, status, 0, userid))
models.db.session.commit()
location = "/users/" + str(userid) + "/dashboard"
code = 303
response = make_response()
response.location = location
response.status_code = code
return response
def setUp(self):
super(EventInstanceTest, self).setUp()
service = models.Service(name="Foo", slug="foo", description="Hello")
service.put()
self.status = models.Status(name="Up", slug="up", default=True,
description="bar", image="cross-circle")
self.status.put()
self.event = models.Event(service=service, status=self.status,
message="Foo")
self.event.put()
def test_get_wrong_event(self):
service = models.Service(name="Bar", slug="bar", description="Hello")
service.put()
event = models.Event(service=service,
status=self.status,
message="foo")
event.put()
url = "/admin/api/v1/services/foo/events/{}".format(event.key())
response = self.get(url)
self.assertEquals(response.status_code, 404)
def addEvent(eventTitle, targetAudience, eventDate, startTime, stopTime,
eventVenue, category, eventDomain, eventDescription):
row = models.Event()
row.event_title = eventTitle
row.target_audience = targetAudience
row.event_date = eventDate
row.start_time = startTime
row.stop_time = stopTime
row.event_venue = eventVenue
row.category = category
row.event_domain = eventDomain
row.event_description = eventDescription
row.put()
def create_new_event():
logging.info("creating new food event")
logging.info(request.json)
event = models.Event(
foodType=request.json.get('food'),
address=request.json.get('address'),
image64=request.json.get('image'),
time=request.json.get('time'),
contact=request.json.get('contact')
# time = datetime.datetime.strptime(request.json.get('time'), '%m-%d-%y-%H-%M').date(),
)
event.put()
response.content_type = 'application/json'
return models.event_to_json(event)
def event():
# todo: check role of user to see if they are an organizer or admin
if request.method == "POST":
r = request.get_json()
required_fields = ["name", "date", "url"]
for field in required_fields:
if not r.get(field):
return {"error": "missing {} field".format(field)}, 400
name = r.get("name")
time = r.get("date")
url = r.get("url")
e = models.Event(name, time, url)
db.session.add(e)
db.session.commit()
return {"event_id": e.id}
def insert(event, message):
with db_session(message) as db:
if event.start_time and event.end_time:
new_event = models.Event(name=event.name,
description=event.description,
start_date=event.start_date,
_start_time=event.start_time,
end_date=event.end_date,
_end_time=event.end_time,
user_id=event.user_id,
activity_id=event.activity_id)
elif event.start_time:
new_event = models.Event(name=event.name,
description=event.description,
start_date=event.start_date,
_start_time=event.start_time,
end_date=event.end_date,
user_id=event.user_id,
activity_id=event.activity_id)
elif event.end_time:
new_event = models.Event(name=event.name,
description=event.description,
start_date=event.start_date,
end_date=event.end_date,
_end_time=event.end_time,
user_id=event.user_id,
activity_id=event.activity_id)
else:
new_event = models.Event(name=event.name,
description=event.description,
start_date=event.start_date,
end_date=event.end_date,
user_id=event.user_id,
activity_id=event.activity_id)
db.add(new_event)
db.commit()
def addEvent(self, day, name, when, desc):
"""Add event to the calendar. For now change is sync to db at once."""
if not self.db_cal:
# we are adding event to a month where no event exist, hence
# finally we need a EventCalendar record for the month in database
self.db_cal = models.EventCalendar(owner=self.curr.owner,
year=self.curr.year,
month=self.curr.month)
self.db_cal.save()
db_e = models.Event(name=name, when=when, desc=desc, cal=self.db_cal)
db_e.save()
# should have check the return above
e = eventCalBase.event(db_e.id, db_e.name, db_e.when, db_e.desc)
self.curr.addEvent(e, db_e.when.day)
def post(self):
""" Process the Event data to store in the database """
name = cgi.escape(self.request.get('name'))
start_date = self.request.get('start_date')
start_time = self.request.get('start_time')
end_date = self.request.get('end_date')
end_time = self.request.get('end_time')
calendar = db.Key(self.request.get('calendar'))
location = cgi.escape(self.request.get('location'))
notes = cgi.escape(self.request.get('notes'))
sharing = self.request.get('sharing')
if self.request.get('all_day') == "1":
all_day = True
start = start_date
end = end_date
time_format = "%d/%m/%Y"
else:
all_day = False
start = "%s %s" % (start_date, start_time)
end = "%s %s" % (end_date, end_time)
time_format = "%d/%m/%Y %I:%M%p"
# Change strings into datetime for database
start_dt = datetime.strptime(start, time_format)
end_dt = datetime.strptime(start, time_format)
# Store the event in the database
event = models.Event()
event.name = name #db.StringProperty()
event.start_time = start_dt #db.DateTimeProperty()
event.end_time = end_dt #db.DateTimeProperty()
event.all_day = all_day #db.BooleanProperty()
event.calendar = calendar #db.ReferenceProperty()
event.location = location #db.StringProperty(multiline=True)
event.notes = notes #db.TextProperty()
event.sharing = sharing #db.StringProperty()
event.put()
#self.response.out.write(start_dt)
#self.response.out.write(" , ")
#self.response.out.write(end_dt)
#self.response.out.write("<br /><br />")
#self.response.out.write((name, start_date, start_time, end_date, end_time))
#self.response.out.write(str(all_day))
# Redirect user to Calendar page after saving the event
self.redirect('/calendar')
def setUp(self):
super(EditHandlerTest, self).setUp()
# Make an event for us to edit.
event_start = datetime.datetime.now() + datetime.timedelta(days=1)
event_end = datetime.datetime.now() + datetime.timedelta(days=1,
hours=2)
self.event = models.Event(name="Test Event",
start_time=event_start,
end_time=event_end,
type="Meetup",
estimated_size="10",
setup=15,
teardown=15,
details="This is a test event.")
self.event.put()
def _make_events(self, events, offset=1):
start = datetime.datetime.now() + datetime.timedelta(days=offset)
made_events = []
for i in range(0, events):
event = models.Event(name="Test Event",
start_time=start,
end_time=start + datetime.timedelta(hours=1),
type="Meetup",
estimated_size="10",
setup=15,
teardown=15,
details="This is a test event.")
event.put()
made_events.append(event)
return made_events
def create_event(event: EventCreate,
db: Session = Depends(get_db),
current_user: User = Depends(get_current_user)):
if not current_user.isadmin:
raise HTTPException(
status_code=401,
detail="You have to be an admin to perform this action.")
if not event.start_date < event.end_date:
raise HTTPException(status_code=400,
detail="start_date must be before end_date")
event_dict = event.dict()
db_event = models.Event(**event_dict)
db.add(db_event)
db.commit()
db.refresh(db_event)
return db_event
def addEvent(request):
'''
takes {
name: string,
start: string,
end: string
}
returns {
id: string
}
'''
data = json.loads(request.POST['data'])
existing_names = []
exists = False
names = [data['name']] + data.get('alternativeNames', [])
for name in names:
name = ox.decode_html(name)
if models.Event.objects.filter(
defined=True,
name_find__icontains=u'|%s|' % name).count() != 0:
exists = True
existing_names.append(name)
if not exists:
models.Event.objects.filter(defined=False, name__in=names).delete()
data['name'] = ox.escape_html(data['name'])
event = models.Event(name=data['name'])
for key in ('start', 'startTime', 'end', 'endTime', 'duration',
'durationTime', 'type', 'alternativeNames'):
if key in data and data[key]:
value = data[key]
if isinstance(value, basestring):
value = ox.escape_html(value)
if key == 'alternativeNames':
value = tuple([ox.escape_html(v) for v in value])
setattr(event, key, value)
if 'nameSort' in data:
value = ox.escape_html(data['nameSort'])
event.set_name_sort(value)
event.matches = 0
event.save()
event.update_matches()
response = json_response(status=200, text='created')
response['data'] = event.json()
else:
response = json_response(status=409, text='name exists')
response['data']['names'] = existing_names
return render_to_json_response(response)
def __create_event(self, pid, name):
result = ProcessAnalyzer.analyze(pid)
category_id = None
if result is not None and 'name' in result:
category_id = self.__connection_manager.get_category(result['name'])
if name is not None and name.replace(' ', '') is not '':
time_now = time.time()
event = models.Event(name, pid, time_now, time_now)
if category_id is not None:
event.category = {'name': result['name'], 'id': category_id}
event.save()
self.__last_updated_event_id = event.id
self.__connection_manager.post_event(event.json_representation())
def run2(db):
events = get_all_users_new_events(db)
p = db.session.query(models.Reminder).count() + 1
for (user, new_events_list) in events:
add_new_events_to_calendar(db, user, new_events_list)
for new_event in new_events_list:
newEvent = models.Event(new_event['name'],
new_event['rsvp_status'], user.fb_id,
new_event['id'], new_event['start_time'],
new_event['end_time'])
db.session.add(newEvent)
db.session.commit()
if user.remind_by_default == True:
r = models.Reminder(get_reminder_time(user, newEvent), p,
new_event['id'], user.fb_id,
user.remind_type)
db.session.add(r)
db.session.commit()
def index():
events = gcal_client.get_cal_details()
gevents=[]
for event in events:
ge = gevent(event)
db_event = models.Event(ge.name)
db.session.merge(db_event)
db.session.commit()
playing = db.session.query(models.Player.name)\
.join(models.Event_Player, models.Player.id == models.Event_Player.player_id)\
.filter(models.Event_Player.event_name == ge.name, models.Event_Player.is_playing)
#flatten the list of tuple names
ge.players = list(itertools.chain(*playing.all()))
ge.count = len(ge.players)
gevents.append(ge)
players = models.Player.query.all()
return render_template("index.html", events=gevents,players=players)
def add_event_to_db(event): #event is a dictionary of event info
"""adding an event to the databse"""
att_list = []
att_list.append(event['host'])
# print(att_list)
new_event = models.Event(host=event['host'],
event_name=event['event_name'],
event_description=event['event_description'],
restaurant=event['restaurant'],
location=event['location'],
event_date=event['event_date'],
event_time=event['event_time'],
attendees=att_list)
DB.session.add(new_event)
DB.session.commit()
return new_event
def _make_events(self, events, offset=1, time=12):
start = utils.local_now() + timedelta(days=2)
start = start.replace(hour=time, minute=0)
made_events = []
for i in range(0, events):
start += datetime.timedelta(days=offset)
event = models.Event(name="Test Event",
start_time=start,
end_time=start + datetime.timedelta(hours=1),
type="Meetup",
estimated_size="10",
setup=15,
teardown=15,
details="This is a test event.",
rooms=[models.ROOM_OPTIONS[0][0]])
event.put()
made_events.append(event)
return made_events
def save(self):
"""save current calendar to database"""
# there are no edit screen so far. Hence nothing to save.
# i.e. not tested.
# insert or update EventCalendar
db_c = models.EventCalendar(owner=self.curr.owner,
year=self.curr.year,
month=self.curr.month)
db_c.id = sself.curr.id
db_c.save()
# insert or update Events
for d in self.curr.events:
for e in self.curr[d]:
db_e = models.Event(cal=db_c,
name=e.name,
desc=e.desc,
when=e.start)
db_e.id = e.id
db_e.save()
def userevents(userid):
# POST /events (new event creation info submitted here)
if request.method == 'POST':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
username = session['username']
if 'username' not in session:
return render_template('login.html', error=error)
if (request.form["Submit"] == "Submit"):
if (request.form["title"] and request.form["preeventtxt"] and \
request.form["prefearfactor"] and request.form["datetime"]):
title = request.form['title']
preeventtxt = request.form['preeventtxt']
prefearfactor = request.form[
'prefearfactor'] #no rating fear out of 10
datetime = request.form[
'datetime'] #time of future event given by user
else:
error = "All fields are mandatory!"
return render_template('dashboard.html', error=error), 400
users = models.User.query.filter_by(username=username).all()
userid = users[0].userid
status = 0
models.db.session.add(
models.Event(title, datetime, preeventtxt, "", prefearfactor,
0, status, 0, userid))
models.db.session.commit()
location = "/users/" + str(userid) + "/dashboard"
code = 303
response = make_response()
response.location = location
response.status_code = code
return response
def test_feed_does_not_exceed_max(self):
for _ in xrange(settings.RSS_NUM_EVENTS_TO_FETCH + 20):
event = models.Event(start=datetime.datetime.now(),
message="test hello",
service=random.choice(self.services),
status=random.choice(self.statuses))
event.put()
response = self.get("/rss")
self.assertTrue(
"application/rss+xml" in response.headers["Content-Type"])
self.assertEquals(response.status_code, 200)
result = xml.etree.ElementTree.fromstring(response.content)
self.assertEquals(len(result), 1)
self.assertEquals(result[0].tag, 'channel')
channel = result[0]
# assert that response does not have more than RSS_NUM_EVENTS_TO_FETCH events.
self.assertEquals(len(channel.findall('item')),
settings.RSS_NUM_EVENTS_TO_FETCH)
def main(): global src_count, number_of_sources, total_pkt_in_queue, sources validate() for i in range(number_of_sources): start_time = uniform(0., 10.) new_src = models.Source(i, start_time) sources.append(new_src) pkt_id, gen_time = new_src.generatePacket() # print "Source ", i, "at ", start_time, pkt_id, gen_time ev = models.Event(i, pkt_id, gen_time, 0) pushEvent(ev) for i in range(1000): global events keys = events.keys() keys.sort() key = keys[0] values = events[key] del events[key] values.sort() for evv in values: processEvent(evv) global delay for src in sources: packets = src.packets for pkt_id in packets.keys(): if packets[pkt_id].status < 2: continue pkt = packets[pkt_id] delay += pkt.switchLeavingTime - pkt.switchReachingTime print delay
def post(self):
'''
Create the event
'''
p = self.request.get
event_id = cutils.generate_event_id()
# self.say(event_id)
event = models.Event(id=event_id)
event.populate(venue_name=p('venue_name'),
venue_location=p('venue_location'),
event_date=p('event_date'),
min_age=int(p('min_age')),
max_tickets=int(p('max_tickets')),
min_tickets=int(p('min_tickets')),
available_positions=int(p('available_positions')),
tickets_per_band=int(p('tickets_per_band')),
base_ticket_price=float(p('base_ticket_price')),
radius_fee=float(p('radius_fee')))
event.put()
self.say(event)
self.say(
'\n\n\n PLEASE CLOSE THE TAB SO THAT YOU DONT CREATE DUPLICATE EVENTS BY REFRESHING'
)
def post_new_event():
event_json = request.get_json() or {}
for field in schema.events:
if field not in event_json and field not in ('datetime', 'date',
'event_target'):
return 'Missing at least one field: ' + repr(field), 400
session = database.get_session()
new_event = models.Event(
date=datetime.datetime.utcnow().date().isoformat(),
datetime=datetime.datetime.utcnow().isoformat(),
event_type=event_json['event_type'],
event_target=event_json.get('event_target'),
user_id=event_json['user_id'],
path=event_json['path'],
referrer=event_json['referrer'],
email=event_json['email'],
handle=event_json['handle'],
platform=event_json['platform'],
)
session.add(new_event)
session.commit()
session.close()
return '', 200
def getEventsFromTitle(domain, eventTitle):
q = models.Event().all().filter('event_domain =',
domain).filter('event_title =', eventTitle)
rows = q.fetch(10)
return rows
def test_conflict_detection(self):
# To begin with, create a new event that we can make things conflict with.
start_time = datetime.datetime(month=1,
day=1,
year=2015,
hour=10,
minute=0)
end_time = start_time + datetime.timedelta(hours=2)
event = models.Event(name="Test Event",
start_time=start_time,
end_time=end_time,
type="Meetup",
estimated_size="10",
setup=15,
teardown=15,
details="This is a test event.",
rooms=["Classroom"])
event.put()
# Putting an event a safe distance before should not conflict.
new_start_time = start_time - datetime.timedelta(hours=1, minutes=30)
new_end_time = new_start_time + datetime.timedelta(hours=1)
self.assertEqual([],
models.Event.check_conflict(new_start_time,
new_end_time, 15, 15,
["Classroom"]))
# Putting an event a safe distance after should not conflict.
new_start_time = end_time + datetime.timedelta(minutes=30)
new_end_time = new_start_time + datetime.timedelta(hours=1)
self.assertEqual([],
models.Event.check_conflict(new_start_time,
new_end_time, 15, 15,
["Classroom"]))
# Increasing the setup time should be okay until it starts to get into the
# time alloted for the actual event before it.
self.assertEqual([],
models.Event.check_conflict(new_start_time,
new_end_time, 30, 15,
["Classroom"]))
conflicts = models.Event.check_conflict(new_start_time, new_end_time,
60, 15, ["Classroom"])
self.assertEqual(event.key().id(), conflicts[0].key().id())
# We also need at least 30 minutes between consecutive events.
new_start_time = end_time + datetime.timedelta(minutes=15)
new_end_time = new_start_time + datetime.timedelta(hours=1)
conflicts = models.Event.check_conflict(new_start_time, new_end_time,
15, 15, ["Classroom"])
self.assertEqual(event.key().id(), conflicts[0].key().id())
# If an event is completely encompassed by another event it should get
# detected.
new_start_time = start_time + datetime.timedelta(minutes=30)
new_end_time = new_start_time + datetime.timedelta(hours=1)
conflicts = models.Event.check_conflict(new_start_time, new_end_time,
15, 15, ["Classroom"])
self.assertEqual(event.key().id(), conflicts[0].key().id())
# If an event exactly overlaps another event, it should get detected.
conflicts = models.Event.check_conflict(start_time, end_time, 15, 15,
["Classroom"])
self.assertEqual(event.key().id(), conflicts[0].key().id())
# If an event overlaps another event not just in setup and teardown on
# either end, it should get detected.
new_start_time = start_time - datetime.timedelta(minutes=30)
new_end_time = new_start_time + datetime.timedelta(hours=1)
conflicts = models.Event.check_conflict(new_start_time, new_end_time,
15, 15, ["Classroom"])
self.assertEqual(event.key().id(), conflicts[0].key().id())
new_start_time = end_time - datetime.timedelta(minutes=30)
new_end_time = new_start_time + datetime.timedelta(hours=1)
conflicts = models.Event.check_conflict(new_start_time, new_end_time,
15, 15, ["Classroom"])
self.assertEqual(event.key().id(), conflicts[0].key().id())
def test_one_per_day(self):
start = datetime.datetime.now() + datetime.timedelta(days=1)
# For this test to work, the event initially has to be scheduled on a
# weekday.
if start.weekday() > 4:
start += datetime.timedelta(days=2)
self.assertLess(start.weekday(), 5)
start = start.replace(hour=11)
event = models.Event(name="Test Event",
start_time=start,
end_time=start + datetime.timedelta(minutes=30),
type="Meetup",
estimated_size="10",
setup=15,
teardown=15,
details="This is a test event.")
event.put()
params = self.params.copy()
params["start_date"] = "%d/%d/%d" % (start.month, start.day,
start.year)
params["end_date"] = params["start_date"]
# That should be our one event for that day. It should complain if we try to
# create another one.
response = self.test_app.post("/new", params, expect_errors=True)
self.assertEqual(400, response.status_int)
self.assertIn("coworking hours", response.body)
# It should ignore the event if it doesn't have the right status.
event.status = "not_approved"
event.put()
response = self.test_app.post("/new", params)
self.assertEqual(200, response.status_int)
# Another status that should trigger it is approved.
event.status = "approved"
event.put()
response = self.test_app.post("/new", params, expect_errors=True)
self.assertEqual(400, response.status_int)
self.assertIn("coworking hours", response.body)
# If the event we are making is not during these hours, it should not have a
# problem.
new_params = params.copy()
new_params["start_time_hour"] = "6"
new_params["end_time_hour"] = "7"
response = self.test_app.post("/new", new_params)
self.assertEqual(200, response.status_int)
# If we schedule it on a weekend, however, we should have no such problems.
days_to_weekend = 6 - datetime.datetime.today().weekday()
start = datetime.datetime.now() + datetime.timedelta(
days=days_to_weekend)
self.assertGreater(start.weekday(), 4)
event.start_time = start
event.end_time = start + datetime.timedelta(minutes=30)
event.put()
params["start_date"] = "%d/%d/%d" % (start.month, start.day,
start.year)
params["end_date"] = params["start_date"]
response = self.test_app.post("/new", params)
self.assertEqual(200, response.status_int)
