def add_response(question_id, responses_id, user_id, text=None):
AnswerRepository = get_repository('AnswerRepository')
AnswerTextRepository = get_repository('AnswerTextRepository')
QuestionRepository = get_repository('QuestionRepository')
qr = QuestionRepository.get_by_id(question_id)
if qr.type == 'text':
answer = AnswerText()
answer.id = str(uuid.uuid4())
answer.question_id = question_id
answer.ids = None
answer.user_id = user_id
answer.date = datetime.datetime.now()
answer.text = text
AnswerTextRepository.save(answer)
else:
for response_id in responses_id:
answer = Answer()
answer.id = str(uuid.uuid4())
answer.ids = None
answer.response_id = response_id
answer.question_id = question_id
answer.user_id = user_id
answer.date = datetime.datetime.now()
AnswerRepository.save(answer)
def register_response(respondent_id, code):
RegistrationsRepository = get_repository('RegistrationsRepository')
ResearchGroupRepository = get_repository('ResearchGroupRepository')
RespondentRepository = get_repository('RespondentRepository')
research_group = ResearchGroupRepository.get_by_code(code)
respondent = RespondentRepository.get_by_id(respondent_id)
RegistrationsRepository.save(research_group.id, respondent.ids)
def get_responses(self, code):
ResearchGroupRepository = get_repository('ResearchGroupRepository')
RegistrationsRepository = get_repository('RegistrationsRepository')
ResponseRepository = get_repository('ResponseRepository')
RespondentRepository = get_repository('RespondentRepository')
SurveyRepository = get_repository('SurveyRepository')
t = self.startdate
one_day = timedelta(days=1)
l = []
research_group = ResearchGroupRepository.get_by_code(code)
registrations = RegistrationsRepository.get_by_research_group_id(
research_group.id)
for registration in registrations:
respondent = RespondentRepository.get_by_ids(
registration.respondent_ids)
t = self.startdate
while t < self.enddate:
for time in self.times:
start_date = datetime(year=t.year,
month=t.month,
day=t.day,
hour=time.time.hour,
minute=time.time.minute)
d = {'date': start_date, 'user-id': respondent.id}
for question in self.questions:
for answer in question.answers:
if start_date <= answer.date < start_date + timedelta(
seconds=self.questiondelta
) and answer.user_id == respondent.id:
if question.id in d:
d[question.
id] += ":" + ResponseRepository.get_by_id(
answer.response_id).value
else:
d[question.
id] = ResponseRepository.get_by_id(
answer.response_id).value
for answer in question.answers_text:
if start_date <= answer.date < start_date + timedelta(
seconds=self.questiondelta
) and answer.user_id == respondent.id:
d[question.id] = answer.text
l.append(d)
t += one_day
return l
def remove_response(self, response_id):
ResponseRepository = get_repository('ResponseRepository')
for response in self.responses:
if response.id == response_id:
response.status = Response.STATUS.DELETED
ResponseRepository.save(response)
break
def update_values(self, data):
SurveyRepository = get_repository('SurveyRepository')
if data.get('status') and data['status'] == Survey.STATUS.STARTED:
self.status = data['status']
if data.get('startdate'):
self.startdate = datetime(year=data.get('startdate').year,
month=data.get('startdate').month,
day=data.get('startdate').day)
if data.get('enddate'):
self.enddate = datetime(year=data.get('enddate').year, month=data.get('enddate').month, day=data.get('enddate').day) + \
timedelta(hours=23, minutes=59)
if data.get('description'):
self.description = data['description']
if data.get('name'):
self.name = data['name']
if data.get('questiondelta'):
self.questiondelta = data['questiondelta']
SurveyRepository.save(self)
def update_values(self, data):
ResearchGroupRepository = get_repository('ResearchGroupRepository')
if data.get('startdate'):
self.startdate = data.get('startdate')
if data.get('enddate'):
self.enddate = data['enddate']
if data.get('description'):
self.description = data['description']
if data.get('name'):
self.name = data['name']
if data.get('code'):
self.code = data['code']
if data.get('license'):
self.license = data['license']
if data.get(
'status') and data['status'] == ResearchGroup.STATUS.STARTED:
self.status = data['status']
self._validate_research_group()
ResearchGroupRepository.save(self)
def create_research_group(self, name, code=None, description=None):
"""
Creates a new research group. The process of creating a new group requires a name.
The name will be visible to participants of the study.
Each research group is recognized by the participants of the study by means of a code.
This code can be given manually, but it can also be generated randomly.
Args:
name (str): The name of new research group. This will be visible for participants
code (str, optional): This code which will be use to join to research group by participants.
description (str, optional): The description of research group. This will be visible for participants.
Returns:
New created research group
Raises:
None
"""
ResearchGroupRepository = get_repository('ResearchGroupRepository')
research_group = ResearchGroup(unit_id=self.id, code=code)
research_group.name = name
research_group.description = description
research_group.user_id = self.user_id
research_group.startdate = None
research_group.enddate = None
research_group.license = None
research_group.ids = None
ResearchGroupRepository.save(research_group)
return research_group
def update_research_group(user_id, unit_id, research_group_id, data):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
rs.update_values(data)
def add_time(self, time):
SurveyTimeRepository = get_repository('SurveyTimeRepository')
surveyTime = SurveyTime()
surveyTime.id = str(uuid.uuid4())
surveyTime.time = time
surveyTime.survey_id = self.id
SurveyTimeRepository.save(surveyTime)
def remove_survey(user_id, unit_id, research_group_id, survey_id):
"""Remove survey from research group id"""
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
research_group = unit.get_research_group(research_group_id)
research_group.remove_survey(survey_id)
def update(user_id, device_id):
RespondentRepository = get_repository('RespondentRepository')
respondents = RespondentRepository.get_by_device_id(device_id)
for r in respondents:
if user_id is not None:
r.id = user_id
r.device_id = device_id
RespondentRepository.save(r)
def create_unit(user_id, data):
UnitRepository = get_repository('UnitRepository')
unit = Unit()
unit.configure(user_id=user_id,
name=data['name'],
description=data['description'])
UnitRepository.save(unit)
return unit
def get_research_groups(user_id, unit_id):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
filtered_research_group = []
for rs in unit.research_groups:
if rs.status != ResearchGroup.STATUS.DELETED:
filtered_research_group.append(rs)
return filtered_research_group
def create_survey_time(user_id, unit_id, research_group_id, survey_id,
survey_time):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
survey = rs.get_survey(survey_id)
survey.add_time(survey_time)
def create_question(user_id, unit_id, research_group_id, survey_id, data):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
survey = rs.get_survey(survey_id)
question = survey.create_question(data['name'], data['type'])
return question
def remove_question(user_id, unit_id, research_group_id, survey_id,
question_id):
"""Remove question from survey"""
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
research_group = unit.get_research_group(research_group_id)
survey = research_group.get_survey(survey_id)
survey.remove_question(question_id)
def get_surveys(user_id, unit_id, research_group_id):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
filtered_surveys = []
for survey in rs.surveys:
if survey.status != Survey.STATUS.DELETED:
filtered_surveys.append(survey)
filtered_surveys.sort(key=lambda x: x.ids)
return filtered_surveys
def create_research_group(user_id, unit_id, data):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
research_group = unit.create_research_group(
data['name'],
code=data.get('code'),
description=data.get('description'))
return research_group
def update_question(user_id, unit_id, research_group_id, survey_id,
question_id, data):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
survey = rs.get_survey(survey_id)
question = survey.get_question(question_id)
question.update_values(data)
def create_response(user_id, unit_id, research_group_id, survey_id,
question_id, data):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
survey = rs.get_survey(survey_id)
question = survey.get_question(question_id)
response_id = question.create_response(data['value'], data['type'])
return response_id
def create_survey(user_id, unit_id, research_group_id, data):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
survey = rs.create_survey(
data['name'],
description=data.get('description'),
)
return survey
def create_new(user_id, device_id):
RespondentRepository = get_repository('RespondentRepository')
respondent = Respondent()
if user_id is not None:
respondent.id = user_id
respondent.device_id = device_id
respondent.ids = None
RespondentRepository.save(respondent)
return respondent
def update_survey(user_id, unit_id, research_group_id, survey_id, data):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
survey = rs.get_survey(survey_id)
survey.update_values(data)
SurveyTimeRepository = get_repository('SurveyTimeRepository')
if 'time' in data:
SurveyTimeRepository.delete_all(survey_id)
if data.get('time'):
SurveyTimeRepository = get_repository('SurveyTimeRepository')
SurveyTimeRepository.delete_all(survey_id)
for survey_time in data.get('time'):
OrganizationService.create_survey_time(user_id, unit_id,
research_group_id,
survey_id, survey_time)
def get_questions(user_id, unit_id, research_group_id, survey_id):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
survey = rs.get_survey(survey_id)
filtered_questions = []
for question in survey.questions:
if question.status != Question.STATUS.DELETED:
filtered_questions.append(question)
filtered_questions.sort(key=lambda x: x.ids)
return filtered_questions
def update_values(self, data):
QuestionRepository = get_repository('QuestionRepository')
if data.get('status') and data['status'] == Question.STATUS.STARTED:
self.status = data['status']
if data.get('type'):
self.type = data['type']
if data.get('name'):
self.name = data['name']
QuestionRepository.save(self)
def update_values(self, data):
ResponseRepository = get_repository('ResponseRepository')
if data.get('status') and data['status'] == Response.STATUS.STARTED:
self.status = data['status']
if data.get('type'):
self.type = data['type']
if data.get('value'):
self.value = data['value']
ResponseRepository.save(self)
def get_units(user_id):
UnitRepository = get_repository('UnitRepository')
units = UnitRepository.get_all_units(user_id)
filtered_units = []
for unit in units:
filtered_research_group = []
for rs in unit.research_groups:
if rs.status != ResearchGroup.STATUS.DELETED:
filtered_research_group.append(rs)
unit.research_groups = filtered_research_group
filtered_units.append(unit)
return filtered_units
def get_responses(user_id, unit_id, research_group_id, survey_id,
question_id):
UnitRepository = get_repository('UnitRepository')
unit = UnitRepository.get_unit(user_id, unit_id)
rs = unit.get_research_group(research_group_id)
survey = rs.get_survey(survey_id)
question = survey.get_question(question_id)
filtered_responses = []
for response in question.responses:
if response.status != Response.STATUS.DELETED:
filtered_responses.append(response)
filtered_responses.sort(key=lambda x: x.ids)
return filtered_responses
def create_response(self, value, type):
ResponseRepository = get_repository('ResponseRepository')
response = Response()
response.id = str(uuid.uuid4())
response.ids = None
response.question_id = self.id
response.value = value
response.type = type
response.status = Question.STATUS.NEW
ResponseRepository.save(response)
return response.id
def create_question(self, name, type):
QuestionRepository = get_repository('QuestionRepository')
question = Question()
question.id = str(uuid.uuid4())
question.ids = None
question.survey_id = self.id
question.unit_id = self.unit_id
question.name = name
question.type = type
question.status = Question.STATUS.NEW
QuestionRepository.save(question)
return question
