def workshops(db, request, coach):
workshop1 = WorkshopModel(
name="workshop_name_1",
startAt=datetime(2020, 1, 1, 1, 1, 1),
city="city_1",
address="address1",
eventUrl="http://www.example1.com",
coachId=coach.id,
creatorId=coach.id,
model=None,
)
workshop2 = WorkshopModel(
name="workshop_name_2",
startAt=datetime(2020, 2, 2, 2, 2, 2),
city="city_2",
address="address2",
eventUrl="http://www.example2.com",
coachId=coach.id,
creatorId=coach.id,
model=None,
)
workshop1.save()
workshop2.save()
def teardown():
workshop1.delete()
workshop2.delete()
request.addfinalizer(teardown)
return [workshop1, workshop2]
def get_workshop(workshop_id) -> (dict, int):
workshop = WorkshopModel.find_by_id(workshop_id=workshop_id)
# Check if given workshop_id exists in DB
if workshop is None:
raise EntityNotFoundError
# Append action cards to field model
action_cards = ActionCardModel.find_all()
workshop.model.actionCards = action_cards
# Append action card batches from creator to field model
action_cards_batches = ActionCardBatchModel.find_action_card_batches_by_coach(
coach_id=workshop.coachId
)
workshop.model.actionCardBatches = action_cards_batches
# Append carbon form answers
carbon_form_answers = CarbonFormAnswersModel.find_all_by_workshop_id(workshop_id)
carbon_form_answers = {
cfa.participant.pk: cfa.answers for cfa in carbon_form_answers
} # Convert into dict
for wp in workshop.participants:
if wp.user.id in carbon_form_answers:
wp.surveyVariables = carbon_form_answers[wp.user.id]
return WorkshopDetailSchema().dump(workshop), 200
def test_post_workshop_success(client, auth, admin, coach, model, request):
data = dict(
name="Atelier Data 4 Good",
startAt="2020-01-01T01:01:01+01:00",
city="Paris",
address="Avenue Champ Elysee",
eventUrl="http://www.example.com",
coachId=coach.id,
)
headers = auth.login(email="*****@*****.**")
response = client.post("/api/v1/workshops",
headers=headers,
data=json.dumps(data))
response_data, status_code = json.loads(
response.data), response.status_code
assert status_code == 200
assert len(WorkshopModel.objects()) == 1
def teardown():
workshop = WorkshopModel.find_by_id(response_data["id"])
workshop.delete()
request.addfinalizer(teardown)
def test_last_created_model_at_workshop_creation(client, auth, admin, models,
request):
data = dict(
name="Atelier Data 4 Good",
startAt="2020-01-01T01:01:01+01:00",
city="Paris",
address="Avenue Champ Elysee",
eventUrl="http://www.example.com",
coachId=admin.id,
)
headers = auth.login(email="*****@*****.**")
response = client.post("/api/v1/workshops",
headers=headers,
data=json.dumps(data))
workshop = WorkshopModel.find_by_id(json.loads(response.data)["id"])
assert workshop.model.id == models[1].id
def teardown():
workshop.delete()
request.addfinalizer(teardown)
def test_delete_workshop(client, auth, admin, request, workshops):
workshop = workshops[0]
headers = auth.login(email="*****@*****.**")
response = client.delete(f"/api/v1/workshops/{workshop.id}",
headers=headers)
assert response.status_code == 204
assert WorkshopModel.find_by_id(workshop.id) is None
def delete_workshop(workshop_id: str) -> (dict, int):
workshop = WorkshopModel.find_by_id(workshop_id=workshop_id)
# Check if given coach_id exists in DB
if workshop is None:
raise EntityNotFoundError
# Delete user in DB
workshop.delete()
return {}, 204
def add_participant(workshop_id, data) -> (dict, int):
workshop = WorkshopModel.find_by_id(workshop_id=workshop_id)
# Check if given workshop_id exists in DB
if workshop is None:
raise EntityNotFoundError
# Deserialize data
schema = ParticipantSchema()
data, err_msg, err_code = schema.loads_or_400(data)
if err_msg:
return err_msg, err_code
# Check if there is already a participant with this email in DB
user = UserModel.find_by_email(data.get("email"))
if user is None:
participant = UserModel(
email=data.get("email"),
firstName=data.get("firstName"),
lastName=data.get("lastName"),
role=[Roles.PARTICIPANT.value],
workshopParticipations=[workshop_id],
)
status = WorkshopParticipantStatus.CREATED.value
else:
# If user already exists, check if it's a participant
if Roles.PARTICIPANT.value in user.role:
# Raise error if participant already registred in workshop
if user.userId in [p.user.id for p in workshop.participants]:
raise InvalidDataError(
msg="Participant already registered for this workshop"
)
status = WorkshopParticipantStatus.EXISTING.value
else:
# add participant role otherwise
user.add_participant_role()
status = WorkshopParticipantStatus.CREATED.value
participant = user
participant.workshopParticipations.append(workshop_id)
# Append participant to workshop
workshop.participants.append(
WorkshopParticipantModel(user=participant.userId, status=status)
)
# Persist in DB
participant.save()
workshop.save()
return schema.dump(participant), 200
def workshop(db, coach, model, participant, request):
workshop_participant = WorkshopParticipantModel(
user=participant, status=WorkshopParticipantStatus.CREATED.value)
workshop = WorkshopModel(
name="workshop_name_1",
startAt=datetime(2020, 1, 1, 1, 1, 1),
city="city_1",
address="address1",
eventUrl="http://www.example1.com",
coachId=coach.id,
creatorId=coach.id,
model=model,
participants=[workshop_participant],
)
workshop.save()
participant.workshopParticipations.append(workshop.id)
participant.save()
def teardown():
workshop.delete()
request.addfinalizer(teardown)
return workshop
def test_post_workshops_with_inexisting_coach(client, auth, admin):
headers = auth.login(email="*****@*****.**")
data = dict( # inexisting coach id
name="Atelier Data 4 Good",
startAt="2020-01-01T01:01:01+01:00",
city="Paris",
address="Avenue Champ Elysee",
eventUrl="http://www.example.com",
coachId="inexisting_id",
)
response = client.post("/api/v1/workshops",
headers=headers,
data=json.dumps(data))
assert response.status_code == 400
assert len(WorkshopModel.objects()) == 0
def remove_participant(workshop_id, participant_id) -> (dict, int):
workshop = WorkshopModel.find_by_id(workshop_id=workshop_id)
user = UserModel.find_by_id(participant_id)
# Check if given workshop_id exists in DB
if workshop is None or user is None:
raise EntityNotFoundError
updated_participants = []
for participant in workshop.participants:
if participant.user.userId != participant_id:
updated_participants.append(participant)
workshop.participants = updated_participants
updated_workshop = []
for registered in user.workshopParticipations:
if registered != workshop_id:
updated_workshop.append(registered)
user.workshopParticipations = updated_workshop
workshop.save()
user.save()
return None, 204
def create_carbon_form_answers(workshop_id: str, data: bytes) -> (dict, int):
# Check existence of given workshop id
workshop = WorkshopModel.find_by_id(workshop_id)
if workshop is None:
raise EntityNotFoundError
# Deserialize data
schema = CarbonFormAnswersSchema()
data, err_msg, err_code = schema.loads_or_400(data)
if err_msg:
return err_msg, err_code
# Check existence of given email and make sure it belongs to one of
# the workshop's participants
user = UserModel.find_participant_by_email(data["email"])
if user is None or user.id not in workshop.get_participant_ids():
raise InvalidDataError(
"This email does not belong to one of the workshop's participants")
# Check if participant has already answered the carbon form or not
if (CarbonFormAnswersModel.find_by_workshop_id_and_participant_id(
workshop_id, user.id) is not None):
raise InvalidDataError(
"Participant has already answered to the carbon form for this workshop"
)
# Update participant status
wp = workshop.get_workshop_participant(participant_id=user.id)
wp.status = WorkshopParticipantStatus.TOCHECK.value
# Save data
carbon_form_answers = CarbonFormAnswersModel(
workshop=workshop.id,
participant=user.id,
answers=data["answers"],
)
carbon_form_answers.save()
workshop.save()
carbon_form_answers.reload()
return schema.dump(carbon_form_answers), 200
def create_workshop(data: bytes) -> (dict, int):
# Deserialize data
schema = WorkshopSchema()
data, err_msg, err_code = schema.loads_or_400(data)
if err_msg:
return err_msg, err_code
# Check existence of given coachId
coach_id = data["coachId"]
coach = UserModel.find_by_id(coach_id)
if coach is None:
raise InvalidDataError("Coach does not exist : {}".format(coach_id))
workshop = WorkshopModel(**data)
# Append creator id
workshop.creatorId = get_jwt_identity()
# Append last created model id
model = Model.find_last_created_model()
workshop.model = model
workshop.save()
workshop.reload()
return schema.dump(workshop), 200
def get_workshops() -> (dict, int):
# Get all workshop from a given coach
workshops = WorkshopModel.objects()
return WorkshopSchema(many=True).dump(workshops), 200
def teardown():
workshop = WorkshopModel.find_by_id(response_data["id"])
workshop.delete()