def meetings_history(eigs):
    meetings = [
        Meeting(eigs[0], eigs[3], done=True),
        Meeting(eigs[4], eigs[8], done=True),
        Meeting(eigs[6], eigs[10], done=True),
        Meeting(eigs[9], eigs[2], done=True),
    ]
    return MeetingSet(meetings=meetings)
Exemple #2
0
def test_meeting_participate():
    eig_1 = Eig(name="eig 1", project="project 1")
    eig_2 = Eig(name="eig 2", project="project 2")
    eig_3 = Eig(name="eig 3", project="project 3")

    meeting = Meeting(eig_1=eig_1, eig_2=eig_2)
    assert meeting.eig_participate(eig_1)
    assert meeting.eig_participate(eig_2)
    assert not meeting.eig_participate(eig_3)
Exemple #3
0
def test_meeting_set_contains():
    eig_1 = Eig(name="eig 1", project="project 1")
    eig_2 = Eig(name="eig 2", project="project 2")
    eig_3 = Eig(name="eig 3", project="project 3")

    meetings_set = MeetingSet(meetings=[Meeting(eig_1=eig_1, eig_2=eig_2)])
    assert Meeting(eig_1=eig_1, eig_2=eig_2) in meetings_set
    # Reversed meeting
    assert Meeting(eig_1=eig_2, eig_2=eig_1) in meetings_set
    assert Meeting(eig_1=eig_2, eig_2=eig_3) not in meetings_set
Exemple #4
0
 def get(self):
     calendar = ManUpCalendar()
     feed = calendar.get_feed()
     for entry in feed.entry:
         for a_when in entry.when:
             date_string = a_when.start_raw[:19]
             date = datetime.datetime.strptime(date_string, '%Y-%m-%dT%H:%M:%S')
             for where in entry.where:
                 meeting = Meeting(name=entry.title.text, start_date=date, location=where.value)
                 meeting.put()
Exemple #5
0
 def insert(self, meeting):
     logging.debug('inserting meeting: %s' % str(meeting))
     meeting_model = MeetingModel(name=meeting.name,
                                  time=meeting.time,
                                  notes=meeting.notes,
                                  current=meeting.current)
     meeting_key = meeting_model.put()
     logging.debug('successfully inserted meeting, id %d' %
                   meeting_key.id())
     return meeting_key.id()
Exemple #6
0
def test_get_from_hash():
    eig_1 = Eig(name="eig 1", project="project 1")
    eig_2 = Eig(name="eig 2", project="project 2")
    promo = Promo(promo_number=1, eigs=[eig_1, eig_2])
    done = True
    meeting = Meeting(eig_1=eig_1, eig_2=eig_2, done=done)
    hash = f"{eig_1.get_hash()}_{eig_2.get_hash()}"
    meeting_from_hash = Meeting.get_from_hash(meeting_hash=hash,
                                              promo=promo,
                                              done=done)
    assert meeting == meeting_from_hash
Exemple #7
0
def meeting(meeting_id):
    if request.method == 'PUT':
        meeting_data = Meeting(**get_request_data(request),
                               e_tag=request.headers.get('If-Match'))
        if not meeting_data.validate():
            return json_response({"message": "Meeting form is invalid"}, 400)

        return meeting_data.update(db.meetings, meeting_id, db.rooms, g.user)

    elif request.method == 'GET':
        return find_one_response(db.meetings, meeting_id)
    else:
        return delete_one_response(db.meetings, meeting_id)
Exemple #8
0
 def get(self):
     calendar = ManUpCalendar()
     feed = calendar.get_feed()
     for entry in feed.entry:
         for a_when in entry.when:
             date_string = a_when.start_raw[:19]
             date = datetime.datetime.strptime(date_string,
                                               '%Y-%m-%dT%H:%M:%S')
             for where in entry.where:
                 meeting = Meeting(name=entry.title.text,
                                   start_date=date,
                                   location=where.value)
                 meeting.put()
    def save_model(self, request, obj, form, change):
        if change:
            meeting = obj
        else:
            meeting = Meeting(
                date=form.cleaned_data['date'],
                start_time=form.cleaned_data['start_time'],
                end_time=form.cleaned_data['end_time'],
                country=form.cleaned_data['country'],
                short_name=form.cleaned_data['short_name'],
                description=form.cleaned_data['description']
            )

        meeting.save()
        self.meeting = meeting
def edit_meeting(meeting_id):
    """ Renders the edit meeting page and stores the edited meeting """
    # Get the meeting details based on the supplied ID
    meeting = Meeting.get_meeting_by_id(meeting_id)
    # Check if the current user can edit this meeting
    if meeting.user_id != current_user.id:
        flash(u'Du har ikke tilgang til å endre dette møtet!')
        return redirect(url_for('home'))

    if request.method == 'POST':
        form = forms.MeetingForm(request.form)
        # If valid, store the edited meeting details
        if form.validate():
            form.populate_obj(meeting)
            meeting.store()
            flash(u'Møtet ble endret!')
            return redirect(url_for('home'))
        else:
            flash(u'Feil i skjema!')

    else:  # GET
        # Feed meeting details to meeting form
        form = forms.MeetingForm(obj=meeting)

    return render_template(
        'edit_meeting.html',
        set_tab=1,
        form=form,
        action=url_for('edit_meeting', meeting_id=meeting_id)
    )
def export_calendar_for_user(cal_user_id=None, filename="export"):
    """
    Create and export iCalendar file with the meetings of the chosen user

    :param cal_user_id: User ID to create calendar for
    :param filename: Filename for the ics file
    :return: ics file wrapped in a response
    """
    if cal_user_id is None:
        # Defaults to current user
        cal_user_id = current_user.id

    meeting_list = Meeting.get_user_meetings(cal_user_id)
    tz = timezone(app.config['TIMEZONE'])
    cal = Calendar()
    for meeting in meeting_list:
        event = Event()
        event.add('summary', meeting.title)
        event.add('dtstart', tz.localize(meeting.start_time))
        event.add('dtend', tz.localize(meeting.end_time))
        event.add('description',
                  u'Møte generert av %s. Antall deltakere: %s. ' % (app.config['APP_NAME'],
                                                                    meeting.participant_count))
        cal.add_component(event)

    export = StringIO.StringIO()
    export.writelines(cal.to_ical())
    export.seek(0)
    return send_file(export,
                     attachment_filename=filename + '.ics',
                     as_attachment=True)
Exemple #12
0
def extract_results(html, year, season):
    soup = BeautifulSoup(html, 'html.parser').find_all(id='searchResultsPanel')[0]
    soup = soup.find_all('div', recursive=False)[1].find_all('table', limit=1)[0]
    semester = Semester(year, season)
    for row in soup.find_all('tr', recursive=False):
        tds = row.find_all('td', recursive=False)
        if not tds:
            continue
        department, number, section = extract_text(tds[1]).split()
        course = Course(Department.get(department), number)
        title = extract_text(tds[2])
        units = int(extract_text(tds[3]))
        instructors = []
        for tag in tds[4].find_all('abbr'):
            instructor_str = tag['title']
            if instructor_str == 'Instructor Unassigned':
                instructors.append(None)
            else:
                instructors.append(Faculty(instructor_str, *Faculty.split_name(instructor_str)))
        meetings = []
        for tr in tds[5].find_all('tr'):
            meetings.append(Meeting.from_str(*(extract_text(tag) for tag in tr.find_all('td'))))
        cores = list(set(Core.get(extract_text(tag)) for tag in tds[6].find_all('abbr')))
        if not cores:
            cores = []
        seats = int(extract_text(tds[7]))
        enrolled = int(extract_text(tds[8]))
        reserved = int(extract_text(tds[9]))
        reserved_open = int(extract_text(tds[10]))
        waitlisted = int(extract_text(tds[11]))
        Offering(semester, course, section, title, units, tuple(instructors), tuple(meetings), tuple(cores), seats, enrolled, reserved, reserved_open, waitlisted)
Exemple #13
0
def test_get_meeting_join_info(client: FlaskClient) -> None:
    user1 = User(uuid=example_uuid1)
    user2 = User(uuid=example_uuid2)
    user3 = User(uuid=example_uuid3)
    meeting = Meeting(uuid=example_uuid4,
                      owner=user1,
                      name='Lorem ipsum',
                      description='Lorem ipsum sit dolor amet.',
                      datetime=datetime(2020, 1, 2, 3, 4, 5))
    membership1 = Membership(meeting=meeting, user=user1, nickname='Alice')
    membership2 = Membership(meeting=meeting, user=user2, nickname='Bob')
    membership3 = Membership(meeting=meeting, user=user3, nickname='Charlie')
    db.session.add(membership1)
    db.session.add(membership2)
    db.session.add(membership3)
    db.session.commit()

    response = client.get(f'/api/v1/meetings/{meeting.uuid}')
    assert response.status_code == 200
    assert response.json == {
        'name': 'Lorem ipsum',
        'datetime': '2020-01-02T03:04:05',
        'members_count': 3,
        'owner_nickname': 'Alice',
    }
Exemple #14
0
 def update(self, meeting_id, meeting_name=None, meeting_notes=None):
     meeting = MeetingModel.get_by_id(meeting_id)
     if meeting_name:
         meeting.name = meeting_name
     if meeting_notes:
         meeting.notes = meeting_notes
     meeting.put()
def delete_meeting(meeting_id):
    """ Endpoint to asynchronously delete meeting """
    if not meeting_id:
        return jsonify(
            success=False,
            message=u'Ingen møte ID mottatt'
        )

    meeting = Meeting.get_meeting_by_id(meeting_id)
    # Check if user is owner
    if meeting.user_id == current_user.id:
        # Delete meeting from db before deleting world
        meeting.delete()

        # Object still exists in memory after deleting from db
        if meeting.world_id:
            # Also delete world if it's not favoured
            world = World.get_by_id(meeting.world_id)
            if meeting.user_id == world.user_id and not world.favourite:
                if world.delete():  # Will return false if in use by meeting
                    return jsonify(
                        success=True,
                        message=u'Møtet ble slettet',
                        world_id=world.id
                    )
        return jsonify(
            success=True,
            message=u'Møtet ble slettet'
        )
    return jsonify(
        success=False,
        message=u'Du har ikke tilgang til å slette dette møtet'
    )
Exemple #16
0
 def get(self, meeting_id):
     logging.debug('getting meeting %s' % meeting_id)
     meeting_model = MeetingModel.get_by_id(int(meeting_id))
     logging.debug('meeting model: %s' % meeting_model)
     if not meeting_model:
         logging.exception('no meeting with the given ID was found')
         raise Exception("meeting %s not found" % meeting_id)
     return Meeting.deserialize(meeting_model)
Exemple #17
0
    def startCommand(self, meetingDB, meetingInProgress, usernames, shuffle, channel_id):
        if meetingInProgress:
            self.sendSlackMessage("Meeting already in progress")
            return HttpResponse()

        if shuffle:
            random.shuffle(usernames)

        meetingDB = Meeting(channel=channel_id,
                            meetingOrder=json.dumps(usernames),
                            questionNum=1,
                            currentMember=usernames[0])
        meetingDB.save()

        self.sendSlackMessage("Let's get this meeting started! The order today will be: " + ", ".join(usernames))
        self.sendSlackMessage(usernames[0] + ": What did you do since your last standup?")
        return HttpResponse()
Exemple #18
0
 def list_meetings(self, request):
     authorise(request.person, request.token)
     meetings = Meeting.get_meetings(request.person, request.token)
     # meetings = Meeting.query().fetch()
     res = MeetingsCollection()
     for meeting in meetings:
         res.items.append(meeting2Msg(meeting))
     return res
Exemple #19
0
def test_leave_meeting_owner(client: FlaskClient) -> None:
    owner = User(uuid=example_uuid1)
    meeting = Meeting(uuid=example_uuid2, owner=owner)
    membership = Membership(meeting=meeting, user=owner)
    db.session.add(membership)
    db.session.commit()

    response = client.delete(
        f'/api/v1/memberships/{meeting.uuid}/{owner.uuid}')
    assert response.status_code == 403
    assert response.json == {'error': 'Meeting owner cannot leave meeting'}
def read_history(promo: Promo, redis_server: Redis) -> MeetingSet:
    meeting_hashes = redis_server.sinter(
        f"meeting_history:{promo.promo_number}")
    meetings = []
    for meeting_hash in meeting_hashes:
        meeting_hash = meeting_hash.decode()
        meetings.append(
            Meeting.get_from_hash(meeting_hash=meeting_hash,
                                  done=True,
                                  promo=promo))
    return MeetingSet(meetings=meetings)
Exemple #21
0
def get_meeting_from_redis(meeting_hash: str, done: str,
                           promo: Promo) -> Meeting:
    meeting_hash = meeting_hash.decode()
    done = done.decode()
    if done == "0":
        done = False
    else:
        done = True
    return Meeting.get_from_hash(meeting_hash=meeting_hash,
                                 done=done,
                                 promo=promo)
Exemple #22
0
    def update(self, request):
        authorise(request.person, request.token)
        mm = Meeting.get_by_id(request.id)
        if not mm:
            message = 'No meeting with the id "%s" exists.' % request.id
            raise endpoints.NotFoundException(message)

        mm.title = request.title
        mm.startTime = request.startTime
        mm.put()
        res = MeetingMsg(id=mm.put().id(), title=mm.title, startTime=mm.startTime)
        return res
Exemple #23
0
def test_join_meeting_already_a_member(client: FlaskClient) -> None:
    owner = User(uuid=example_uuid1)
    user = User(uuid=example_uuid2)
    meeting = Meeting(uuid=example_uuid3, owner=owner)
    membership = Membership(meeting=meeting, user=user, nickname='Bob')
    db.session.add(membership)
    db.session.commit()

    response = client.put(f'/api/v1/memberships/{meeting.uuid}/{user.uuid}',
                          json={'nickname': 'Bobby'})
    assert response.status_code == 400
    assert response.json == {'error': 'Already a member'}
Exemple #24
0
def test_get_membership_details(client: FlaskClient) -> None:
    user1 = User(uuid=example_uuid1)
    user2 = User(uuid=example_uuid2)
    meeting = Meeting(uuid=example_uuid3,
                      owner=user1,
                      name='Lorem ipsum',
                      description='Lorem ipsum sit dolor amet.',
                      datetime=datetime(2020, 1, 2, 3, 4, 5),
                      stop_name='Czarnowiejska')
    membership1 = Membership(meeting=meeting,
                             user=user1,
                             nickname='Alice',
                             stop_name='Kawiory')
    membership2 = Membership(meeting=meeting,
                             user=user2,
                             nickname='Bob',
                             stop_name='Muzeum Narodowe')
    db.session.add(membership1)
    db.session.add(membership2)
    db.session.commit()

    response = client.get(f'/api/v1/memberships/{meeting.uuid}/{user2.uuid}')
    assert response.status_code == 200
    assert response.json == {
        'uuid':
        meeting.uuid,
        'name':
        'Lorem ipsum',
        'description':
        'Lorem ipsum sit dolor amet.',
        'datetime':
        '2020-01-02T03:04:05',
        'stop_name':
        'Czarnowiejska',
        'members': [
            {
                'nickname': 'Alice',
                'is_owner': True,
                'is_you': False,
                'stop_name': 'Kawiory',
            },
            {
                'nickname': 'Bob',
                'is_owner': False,
                'is_you': True,
                'stop_name': 'Muzeum Narodowe',
            },
        ],
        'membership': {
            'is_owner': False,
            'stop_name': 'Muzeum Narodowe',
        }
    }
def server_list(meeting_id):
    """ Render server list page for specified meeting """
    # TODO handle get servers
    # TODO check if user has access
    meeting = Meeting.get_meeting_by_id(meeting_id)
    return render_template(
            'server_list.html',
            title=u'Liste over tjenere',
            meeting=meeting,
            locale=locale.getpreferredencoding(),
            servers=[{'address': 'test.com', 'status': 'OK'}]
        )
Exemple #26
0
def test_get_user_meetings(client: FlaskClient) -> None:
    user1 = User(uuid=example_uuid1)
    user2 = User(uuid=example_uuid2)
    user3 = User(uuid=example_uuid3)
    meeting1 = Meeting(uuid=example_uuid4, owner=user1, name='Lorem ipsum')
    meeting2 = Meeting(uuid=example_uuid5,
                       owner=user2,
                       datetime=datetime(2020, 1, 2, 3, 4, 5))
    membership1 = Membership(meeting=meeting1, user=user1, nickname='Alice')
    membership2 = Membership(meeting=meeting1, user=user3, nickname='Charlie')
    membership3 = Membership(meeting=meeting2, user=user1, nickname='Ala')
    membership4 = Membership(meeting=meeting2, user=user2, nickname='Bob')
    membership5 = Membership(meeting=meeting2, user=user3, nickname='Charlie')
    db.session.add(membership1)
    db.session.add(membership2)
    db.session.add(membership3)
    db.session.add(membership4)
    db.session.add(membership5)
    db.session.commit()

    response = client.get(f'/api/v1/users/{user1.uuid}/meetings')
    assert response.status_code == 200
    assert response.json == {
        'meetings': [
            {
                'uuid': meeting1.uuid,
                'name': 'Lorem ipsum',
                'nickname': 'Alice',
                'datetime': None,
                'members_count': 2,
            },
            {
                'uuid': meeting2.uuid,
                'name': None,
                'nickname': 'Ala',
                'datetime': '2020-01-02T03:04:05',
                'members_count': 3,
            },
        ]
    }
Exemple #27
0
 def test_meeting_create_fiber_page_method(self):
     """
     Tests the fiber page constructor method. The fiber page method get_absolute_url does
     not work as expected. Not sure why....
     """
     # Create a meeting
     calgary_2014 = Meeting(year=2014, title='Calgary 2014', location='Calgary', associated_with='AAPA')
     calgary_2014.save()
     # Create a default page tree
     create_django_page_tree()
     # Call page constructor method
     calgary_2014.create_fiber_page()
     # Fetch the fiber page we just created
     calgary_2014_fiber_page = Page.objects.get(url__exact='2014')
     # Test the attributes of the fiber page
     self.assertEqual(calgary_2014_fiber_page.parent, Page.objects.get(url__exact='meetings'))
     self.assertEqual(calgary_2014_fiber_page.url, '2014')
     self.assertEqual(calgary_2014_fiber_page.title, 'Calgary 2014')
     #self.assertEqual(calgary_2014_fiber_page.get_absolute_url, '/meetings/2014/') TODO Whys does this test fail?
     # Test that the page renders
     response = self.client.get('/meetings/2014/')
     self.assertEqual(response.status_code, 200)
Exemple #28
0
def test_edit_membership_details(client: FlaskClient) -> None:
    user = User(uuid=example_uuid1)
    meeting = Meeting(uuid=example_uuid2, owner=user)
    membership = Membership(meeting=meeting, user=user)
    db.session.add(membership)
    db.session.commit()

    response = client.patch(f'/api/v1/memberships/{meeting.uuid}/{user.uuid}',
                            json={'stop_name': 'Chopina'})
    assert response.status_code == 204
    assert response.data == b''

    membership = Membership.query.get((meeting.uuid, user.uuid))
    assert membership.stop_name == 'Chopina'
Exemple #29
0
def test_delete_outdated_meetings(session: Session, dt: Optional[datetime], should_be_deleted: bool):
    owner = User(uuid=example_uuid1)
    user = User(uuid=example_uuid2)
    meeting = Meeting(uuid=example_uuid3, owner=owner, datetime=dt)
    membership1 = Membership(meeting=meeting, user=owner, nickname='Alice')
    membership2 = Membership(meeting=meeting, user=user, nickname='Bob')
    db.session.add(membership1)
    db.session.add(membership2)
    db.session.commit()

    delete_outdated_meetings(session)

    assert (Meeting.query.get(example_uuid3) is None) is should_be_deleted
    assert (Membership.query.get((example_uuid3, example_uuid1)) is None) is should_be_deleted
    assert (Membership.query.get((example_uuid3, example_uuid2)) is None) is should_be_deleted
Exemple #30
0
def test_leave_meeting(client: FlaskClient) -> None:
    owner = User(uuid=example_uuid1)
    user = User(uuid=example_uuid2)
    meeting = Meeting(uuid=example_uuid3, owner=owner)
    membership1 = Membership(meeting=meeting, user=owner)
    membership2 = Membership(meeting=meeting, user=user)
    db.session.add(membership1)
    db.session.add(membership2)
    db.session.commit()

    response = client.delete(f'/api/v1/memberships/{meeting.uuid}/{user.uuid}')
    assert response.status_code == 204
    assert response.data == b''

    assert Membership.query.get((meeting.uuid, user.uuid)) is None
Exemple #31
0
def fixtures_load():
    User.query.delete()

    users = [
        {
            'full_name': 'Максим Скочинский',
            'email': '*****@*****.**',
            'role': User.ROLE_MANAGER,
            'username': '******',
            'password': '******'
        },
        {
            'full_name': 'Максим Скочинский',
            'email': '*****@*****.**',
            'role': User.ROLE_ADMINISTRATOR,
            'username': '******',
            'password': '******'
        },

    ]

    for user in users:
        manager = User()
        manager.full_name = user.get('full_name')
        manager.email = user.get('email')
        manager.role = user.get('role')
        manager.username = user.get('username')
        manager.set_password(user.get('password'))
        manager.generate_token()
        db.session.add(manager)

        for i in range(10):
            client = Client()
            client.full_name = fake.name()
            client.user = manager
            client.organization_name = fake.company()
            client.address = fake.address()
            client.phone_number = fake.phone_number()
            db.session.add(client)

            meeting = Meeting()
            meeting.user = manager
            meeting.client = client
            meeting.datetime = datetime.today() - timedelta(minutes=30)
            meeting.goal = 'Договор'
            meeting.address = client.address
            db.session.add(meeting)

    db.session.commit()
    pass
Exemple #32
0
def test_meeting_overlap():
    eig_1 = Eig(name="eig 1", project="project 1")
    eig_2 = Eig(name="eig 2", project="project 2")
    eig_3 = Eig(name="eig 3", project="project 3")
    eig_4 = Eig(name="eig 4", project="project 3")

    meeting_1 = Meeting(eig_1=eig_1, eig_2=eig_2)
    meeting_2 = Meeting(eig_1=eig_1, eig_2=eig_3)
    meeting_3 = Meeting(eig_1=eig_3, eig_2=eig_4)
    assert meeting_1.overlap(meeting_2)
    assert not meeting_1.overlap(meeting_3)
Exemple #33
0
def test_join_meeting(client: FlaskClient) -> None:
    owner = User(uuid=example_uuid1)
    user = User(uuid=example_uuid2)
    meeting = Meeting(uuid=example_uuid3, owner=owner)
    db.session.add(meeting)
    db.session.add(user)
    db.session.commit()

    response = client.put(f'/api/v1/memberships/{meeting.uuid}/{user.uuid}',
                          json={'nickname': 'Bob'})
    assert response.status_code == 204
    assert response.data == b''

    membership = Membership.query.get((meeting.uuid, user.uuid))
    assert membership is not None
    assert membership.nickname == 'Bob'
    assert membership.stop_name is None
Exemple #34
0
 def get_meeting_values(self):
     if not self.meet:
         self.meet = Meeting()
         self.meet.id = 0
     validator = Valid()
     self.meet.main_referee_id = self.main_referee.id
     self.meet.main_clerk_id = self.main_clerk.id
     self.meet.name = validator.escape(self.ui.nameEdit.text())
     self.meet.start_date = self.ui.startDate.date().toPyDate().strftime(
         '%Y-%m-%d')
     self.meet.end_date = self.ui.endDate.date().toPyDate().strftime(
         '%Y-%m-%d')
     self.meet.city = validator.escape(self.ui.cityEdit.text())
     self.meet.meetcount = self.ui.meetCountEdit.text()
     self.meet.main_referee_id = self.main_referee.id
     self.meet.main_clerk_id = self.main_clerk.id
     return self.meet
Exemple #35
0
 def test_meeting_has_detail_method(self):
     """
     Tests the has_detail method
     """
     # Create a meeting
     calgary_2014 = Meeting(year=2014, title='Calgary 2014', location='Calgary', associated_with='AAPA')
     calgary_2014.save()
     # Create a default page tree
     create_django_page_tree()
     # IF no fiber page then has_detail should be false
     self.assertEqual(calgary_2014.has_detail(), False)
     # Call page constructor method
     calgary_2014.create_fiber_page()
     # If fiber page then has_detail should be true
     self.assertEqual(calgary_2014.has_detail(), True)
     cfp = Page.objects.get(url__exact=2014)  # get tha page instance
     cfp.is_public = False  # set to not public
     cfp.save()  # save the change
     self.assertEqual(calgary_2014.has_detail(), False)  # Now has detail should return false
def generate_random_meetings(promo: Promo,
                             meetings_history: MeetingSet) -> List[Meeting]:
    potential_meetings = []
    for eig_1, eig_2 in itertools.combinations(promo.eigs, 2):
        meeting = Meeting(eig_1=eig_1, eig_2=eig_2, done=False)
        if (meeting
                not in meetings_history) and (eig_1.project != eig_2.project):
            potential_meetings.append(meeting)
    n_sample = int(len(promo.eigs) / 2)
    sampling_done = False
    n_max_try = 10
    n_try = 0
    while (not sampling_done) and (n_try < n_max_try):
        sampling_done, meetings = sample_meetings(potential_meetings, n_sample)
        n_try += 1
    print("Number of try: ", n_try)

    return meetings
Exemple #37
0
def test_delete_meeting(client: FlaskClient) -> None:
    owner = User(uuid=example_uuid1)
    user = User(uuid=example_uuid2)
    meeting = Meeting(uuid=example_uuid3, owner=owner)
    membership1 = Membership(meeting=meeting, user=owner, nickname='Alice')
    membership2 = Membership(meeting=meeting, user=user, nickname='Bob')
    db.session.add(membership1)
    db.session.add(membership2)
    db.session.commit()

    response = client.delete(f'/api/v1/meetings/{meeting.uuid}',
                             json={'owner_uuid': owner.uuid})
    assert response.status_code == 204
    assert response.data == b''

    assert Meeting.query.get(meeting.uuid) is None
    assert Membership.query.get((meeting.uuid, owner.uuid)) is None
    assert Membership.query.get((meeting.uuid, user.uuid)) is None
Exemple #38
0
def minutes():
    form = forms.AddMeetingForm()
    if request.method == 'POST' and form.validate_on_submit():
        if Meeting.query.filter_by(date=form.date.data).first():
            form.date.errors.append(
                "Meeting Minutes for this date already exist.")
            return redirect(url_for('minutes'))

        try:
            pdf_src = save_uploaded_pdf(form.pdf.data)
        except Exception:
            form.pdf.errors.append("Error saving submitted PDF")
            return redirect(url_for('minutes'))

        meeting = Meeting(form.date.data, pdf_src)
        db.session.add(meeting)
        db.session.commit()

    meetings = Meeting.query.order_by(db.desc(Meeting.date)).all()
    return render_template('main/minutes.html', form=form, meetings=meetings)
Exemple #39
0
def test_edit_meeting(client: FlaskClient) -> None:
    owner = User(uuid=example_uuid1)
    meeting = Meeting(uuid=example_uuid2, owner=owner)
    db.session.add(meeting)
    db.session.commit()

    response = client.patch(f'/api/v1/meetings/{meeting.uuid}',
                            json={
                                'owner_uuid': owner.uuid,
                                'name': 'Lorem ipsum',
                                'description': 'Lorem ipsum sit dolor amet.',
                                'datetime': '2020-01-02T03:04:05',
                                'stop_name': 'Czarnowiejska',
                            })
    assert response.status_code == 204

    meeting = Meeting.query.get(meeting.uuid)
    assert meeting.name == 'Lorem ipsum'
    assert meeting.description == 'Lorem ipsum sit dolor amet.'
    assert meeting.datetime == datetime(2020, 1, 2, 3, 4, 5)
    assert meeting.stop_name == 'Czarnowiejska'
Exemple #40
0
def create_meeting():
    check_json_data()
    owner_uuid = get_owner_uuid()
    name = get_meeting_name()
    description = get_meeting_description()
    dt = get_datetime()
    nickname = get_nickname()

    owner = find_user(owner_uuid)

    meeting = Meeting(name=name,
                      description=description,
                      datetime=dt,
                      owner=owner)
    membership = Membership(meeting=meeting, user=owner, nickname=nickname)
    db.session.add(membership)
    db.session.commit()

    return make_response({
        'uuid': meeting.uuid,
    }, 201, {'Location': f'/api/v1/meetings/{meeting.uuid}'})
Exemple #41
0
    def trackEvents(self):
        logging.info('Tracking Events')
        date = datetime.datetime.now()
        logging.info(date)
        immediate = Meeting.query(ndb.AND(Meeting.startTime >= date + datetime.timedelta(minutes=50)),
                                Meeting.startTime < date + datetime.timedelta(hours=1)).fetch()
        logging.info('Found {} meetings'.format(len(immediate)))
        for meeting in immediate:
            self.processMeeting(meeting)
#Sample POST Data -->  message={"request":{"data":{"custom": "json data"},"platforms": [1,2], "ios_message":"This is a test","ios_button_text":"yeah!","ios_badge": -1, "ios_sound": "soundfile", "android_collapse_key": "collapsekey"}}
        msg = {
            "request":
                {
                    "data":{"custom": "json data"},
                    "platforms": [1,2], 
                    "ios_message":"This is a test",
                    "ios_button_text":"yeah!",
                    "ios_badge": -1,
                    "ios_sound": "soundfile",
                    "android_collapse_key": "collapsekey"}
        }
        BroadcastMessageToTag(msg, meeting.key.id())
Exemple #42
0
    def post(self):
        args = post_sched_parser.parse_args()

        meeting = Meeting(meeting_time=args['meeting_time'],
                          location=args['location'],
                          course_id=args['course_id'],
                          conversation_id=args['conversation_id'],
                          requestor_id=args['requestor_id'],
                          group_requestor_id=args['group_requestor_id'])
        if meeting == None:
            return 401

        convo = Conversation.query.filter_by(
            id=args['conversation_id']).first()
        if convo == None:
            return 401

        if convo.group_id == None:
            if convo.student_id == int(args["requestor_id"]):
                meeting.tutor_id = convo.tutor_id
            else:
                meeting.student_id = convo.student_id
        elif convo.student_id == None:
            if convo.tutor_id == int(args["requestor_id"]):
                meeting.group_id = convo.group_id
            else:
                meeting.tutor_id = convo.tutor_id
        else:
            if convo.student_id == int(args["requestor_id"]):
                meeting.group_id = convo.group_id
            else:
                meeting.student_id = convo.student_id

        db.session.add(meeting)
        db.session.commit()
        return 201
Exemple #43
0
    def render_template(self, template_name, template_dict=None):
        next_meeting = Meeting.get_next_meeting()
        if next_meeting:
            tag_line = '%s: %s, %s' % (next_meeting.name,
                                       next_meeting.start_date,
                                       next_meeting.location)
        else:
            tag_line = 'Evening Hack: 14/4/2011 5pm LF15'

        if template_dict is None:
            template_dict = {}

        user = Hacker.get_current_hacker()

        if user:
            if self.login_required:
                redirect_target = '/'
            else:
                redirect_target = self.request.path
            url_creator = users.create_logout_url
        else:
            redirect_target = '/login?url=%s' % self.request.path
            url_creator = users.create_login_url

        defaults = {
            'user': user,
            'log_url': url_creator(redirect_target),
            'tag_line': tag_line,
            'title': self.title
        }

        for key in defaults:
            if key not in template_dict:
                template_dict[key] = defaults[key]

        template_path = get_path(
            os.path.join('templates', '%s.html' % template_name))
        self.response.out.write(template.render(template_path, template_dict))
Exemple #44
0
 def render_template(self, template_name, template_dict=None):
     next_meeting = Meeting.get_next_meeting()
     if next_meeting:
         tag_line = '%s: %s, %s' % (next_meeting.name, next_meeting.start_date, next_meeting.location)
     else:
         tag_line = 'Evening Hack: 14/4/2011 5pm LF15'
 
     if template_dict is None:
         template_dict = {}
     
     user = Hacker.get_current_hacker()
     
     if user:
         if self.login_required:
             redirect_target = '/'
         else:
             redirect_target = self.request.path
         url_creator = users.create_logout_url
     else:
         redirect_target = '/login?url=%s' % self.request.path
         url_creator = users.create_login_url
         
     defaults = {
         'user': user,
         'log_url': url_creator(redirect_target),
         'tag_line': tag_line,
         'title': self.title
     }
     
     for key in defaults:
         if key not in template_dict:
             template_dict[key] = defaults[key]
     
     template_path = get_path(
         os.path.join('templates', '%s.html' % template_name))
     self.response.out.write(
         template.render(template_path, template_dict))
Exemple #45
0
    def delete(self, request):
        authorise(request.person, request.token)
        try:
            meeting = Meeting.get_by_id(request.id)
            if meeting.originator == request.person:
                persons = Person.query(Person.parentId==request.id).fetch()
                for person in persons:
                    roles = Role.query(Role.parentId==person.key.id()).fetch()
                    for role in roles:
                        role.key.delete()
                    person.key.delete()
                meeting.key.delete()
            else: # just remove the person from the meeting
                persons = Person.query(Person.parentId==request.id).fetch()
                for person in persons:
                    if(person.email == request.person):
                        roles = Role.query(Role.parentId==person.key.id()).fetch()
                        for role in roles:
                            role.key.delete()
                        person.key.delete()

            return message_types.VoidMessage()
        except (IndexError, TypeError):
            raise endpoints.NotFoundException('Role %s not found.' % (request.id,))
def home():
    """ Renders the home page """
    # Meeting list will be shown at the bottom of the page
    meeting_list = Meeting.get_user_meetings(current_user.id)
    # Selected world (in meeting tab) defaults to None and gets overridden if there is a world selected
    world = None
    # Default to world selection tab
    # 0 is world selection tab and 1 is meeting details tab
    set_tab = 0
    # Locale encoding used for day names
    # preferred_encoding = locale.getpreferredencoding()
    preferred_encoding = 'UTF-8'

    # A form is posted
    if request.method == 'POST':
        # If request is a redirect from map page, we will have a WorldForm
        world_form = forms.WorldForm(request.form)
        if world_form.validate():
            # Go to meeting details tab
            set_tab = 1
            # Show empty meeting form
            meeting_form = forms.MeetingForm()
            try:
                world_id = int(world_form.world_id.data)
                description = world_form.description.data
                world = World.get_by_id(world_id)
                if world:
                    # Update description if changed
                    if world.description != description:
                        world.description = description
                        world.store()
                    # Put world ID in meeting form for reference
                    meeting_form.world_id.process_data(str(world_id))
                else:  # World does not exist
                    flash(u'Den valgte Minecraft verdenen eksisterer ikke')
                    set_tab = 0

            except ValueError:
                # A number was not supplied as world ID
                flash(u'world_id ValueError')

            return render_template(
                'index.html',
                set_tab=set_tab,
                title=u'Hjem',
                meetings=meeting_list,
                form=meeting_form,
                world=world,
                action=url_for('home'),
                locale=preferred_encoding
            )

        # Check if a meeting form is posted
        form = forms.MeetingForm(request.form)
        if form.validate():
            # If valid, put data from form into Meeting object
            meeting = Meeting(user_id=current_user.id)
            form.populate_obj(meeting)
            if meeting.world_id:  # World ID will be none if the posted value is not an integer
                if World.exists(meeting.world_id):  # Check that the world exists in the database
                    meeting.store()

                    # Celery stuff
                    # tasks.meeting_test.apply_async()
                    tasks.meeting_test.apply_async(eta=meeting.start_time, expires=meeting.end_time)

                    flash(u'Nytt møte lagt til')
                    return redirect(url_for('home'))

                else:  # World does not exist
                    flash(u'Den valgte Minecraft verdenen eksisterer ikke')
                    set_tab = 1

            else:  # World probably not chosen
                flash(u'Ingen Minecraft verden valgt')
                set_tab = 0

        else:  # Form not valid
            flash(u'Feil i skjema!')
            set_tab = 1
            try:  # Insert world info
                world_id = int(form.world_id.data)
                world = World.get_by_id(world_id)
            except ValueError:
                pass

    else:  # If not POST
        # Serve blank form
        form = forms.MeetingForm()

    return render_template(
        'index.html',
        set_tab=set_tab,
        title=u'Hjem',
        meetings=meeting_list,
        form=form,
        world=world,
        action=url_for('home'),
        locale=preferred_encoding
    )
Exemple #47
0
def create_three_meetings_with_pages():
    # Create home fiber tree
    create_django_page_tree()
    # Create meeting instances
    calgary = Meeting(year=2014, title='Calgary 2014', location='Calgary, AB', associated_with='AAPA')
    calgary.create_fiber_page()
    calgary.save()
    san_francisco = Meeting(year=2015, title='San Francisco 2015', location='San Francisco, CA', associated_with='SAA')
    san_francisco.create_fiber_page()
    san_francisco.save()
    atlanta = Meeting(year=2016, title='Atlanta 2016', location='Atlanta, GA', associated_with='AAPA')
    atlanta.create_fiber_page()
    atlanta.save()