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',
}
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 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
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
def new_location(request):
"""
New Location
"""
data = {}
template = 'itembase/simpleform.djhtml'
data['message'] = None
data['headstring'] = 'New Location'
if request.method == "POST":
form = LocationForm(request.POST)
if form.is_valid():
location = Location(
lc_name=form.cleaned_data['lc_name'],
lc_geo=form.cleaned_data['lc_geo'],
lc_adr=form.cleaned_data['lc_adr'],
lc_city=form.cleaned_data['lc_city'],
lc_www=form.cleaned_data['lc_www'],
lc_mail=form.cleaned_data['lc_mail'],
lc_info=form.cleaned_data['lc_info'],
)
location.save()
print(location)
membership = Membership(
me_user=request.user,
me_location=location,
me_trust1=request.user,
me_trust2=request.user,
)
membership.save()
print membership
return redirect('itembase/home')
return redirect('itembase/home')
else:
data['form'] = LocationForm()
return render(request, template, data)
def create(request):
'''
Sets up a group creation form wherein the user may choose the necessary
criteria for the group they wish to create.
The user may select the name of the group.
'''
if request.method == 'POST':
form = GroupCreationForm(request.POST)
if form.is_valid():
group = form.save()
# Create the default user membership
m = Membership(user=request.user, group=group, is_admin=True)
m.save()
# Send emails to invited members.
_send_email_invites(request, group)
''' Redirect to the new group '''
return HttpResponse(group.json(), mimetype='application/json')
else:
raise Http404
return render(request, 'group_create_modal.html', {
'form': form,
})
def addMembership(membership_dict):
newMembership = Membership(
#id = id,
user_id=membership_dict.get('user_id'),
start_date=membership_dict.get('start_date'),
last_renew_date=membership_dict.get('last_renew_date'),
is_active=membership_dict.get('is_active'))
newMembership.save()
return newMembership
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
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 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'}
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,
},
]
}
def getMember(self, user=''):
if (not user):
user = self.targetUser
if (self.member):
member = self.member
else:
member = Membership.between(user, self.club)
if (not member):
member = Membership(name=user.nickname(),
email=user.email(),
club=self.club,
user=user)
return member
def join_location(request, location_id):
"""
Join a Location
"""
data = {}
location = get_object_or_404(Location, pk=location_id)
membership = Membership(
me_user=request.user,
me_location=location,
)
membership.save()
print membership
return redirect('itembase/home')
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'
def post(self, *args): stat, user = self.accessControl() pathslug=self.analyzePath() clubmd = self.parsePostdata (self.request, pathslug) if (clubmd): #Put valid, then redirect if ( self.editOrCreateRight(user, clubmd) ): self.clubmodel = clubmd isNewClub = not clubmd.is_saved() clubmd.put() if (isNewClub): #Create New Membership For Owner when create the club mem = Membership(user=user, club = clubmd) mem.put() infoPage (self.response, "Successfullyt Saved Club", "Club Saved", urldict['ClubView'].path(clubmd.slug)) else: return else: self.get()
def join_meeting(meeting_uuid: str, user_uuid: str):
validate_meeting_uuid(meeting_uuid)
validate_user_uuid(user_uuid)
check_json_data()
nickname = get_nickname()
meeting = find_meeting(meeting_uuid)
user = find_user(user_uuid)
membership = Membership(user=user, meeting=meeting, nickname=nickname)
db.session.add(membership)
try:
db.session.commit()
except (IntegrityError, FlushError):
raise ApiException('Already a member', 400)
return '', 204
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}'})
def add_users_to_new_groups(users):
groups = [
Group(name='Python'),
Group(name='GraphQL'),
Group(name='SQLAlchemy'),
Group(name='PostgreSQL'),
]
db_session.bulk_save_objects(groups, return_defaults=True)
db_session.flush()
memberships = [
Membership(
user_id=user.id,
group_id=group.id,
is_moderator=user.id == group.id,
creator_username=choice(users).username,
)
for user in users
for group in groups
]
db_session.bulk_save_objects(memberships, return_defaults=True)
db_session.flush()
return groups
def membership():
if request.method == 'GET':
membership_query = Membership.query.all()
membership = list(map(lambda x: x.serialize(), membership_query))
return jsonify(membership), 200
if request.method == 'POST':
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
params = request.get_json()
membership_name = params.get('membership_name', None)
card_holder_name = params.get('card_holder_name', None)
card_number = params.get('card_number', None)
card_expiration_date = params.get('card_expiration_date', None)
card_cvv = params.get('card_cvv', None)
user_id = params.get('user_id', None)
if not membership_name:
return jsonify({"msg": "Missing membership_name parameter"}), 400
if not card_holder_name:
return jsonify({"msg": "Missing card_holder_name parameter"}), 400
if not card_number:
return jsonify({"msg": "Missing card_number parameter"}), 400
if not card_expiration_date:
return jsonify({"msg": "Missing card_expiration_date parameter"}), 400
if not card_cvv:
return jsonify({"msg": "Missing card_cvv parameter"}), 400
new_member = Membership(
membership_name = membership_name,
card_holder_name = card_holder_name,
card_number = card_number,
card_expiration_date = card_expiration_date,
card_cvv = card_cvv,
user_id = params ['user_id'])
db.session.add(new_member)
db.session.commit()
return jsonify(new_member), 200
if request.method == 'PUT':
params = request.get_json()
user_id = params.get('user_id', None)
membership_name = params.get('membership_name', None)
card_holder_name = params.get('card_holder_name', None)
card_number = params.get('card_number', None)
card_expiration_date = params.get('card_expiration_date', None)
card_cvv = params.get('card_cvv', None)
if not user_id:
return jsonify({"msg": "Missing user_id"}), 400
if not membership_name:
return jsonify({"msg": "Missing Membership Name"}), 400
if not card_holder_name:
return jsonify({"msg": "Missing Card Holder Name"}), 400
if not card_number:
return jsonify({"msg": "Missing Card Number"}), 400
if not card_expiration_date:
return jsonify({"msg": "Missing Card Expiration Date"}), 400
if not card_cvv:
return jsonify({"msg": "Missing Card CVV"}), 400
user_member_settings = Membership.query.filter_by(user_id=user_id).first()
if user_member_settings is None:
raise APIException('Member not found', status_code=404)
user_member_settings.membership_name = membership_name
user_member_settings.card_holder_name = card_holder_name
user_member_settings.card_number = card_number
user_member_settings.card_expiration_date = card_expiration_date
user_member_settings.card_cvv = card_cvv
updated_date = datetime.datetime.now()
user_member_settings.updated_date = updated_date
db.session.commit()
response = {
"membership_name": membership_name,
"card_holder_name": card_holder_name,
"card_number": card_number,
"card_expiration_date": card_expiration_date,
"card_cvv": card_cvv,
"currentUserId": user_id,
"updated_date": updated_date
}
return jsonify(response), 200
if request.method == 'DELETE':
membership1 = Membership.query.get(user_id)
if membership1 is None:
raise APIException('Membership not found', status_code=404)
db.session.delete(membership1)
db.session.commit()
return jsonify(user1.serialize()), 200
