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)