def create_superuser_and_provision_device(self, username, dataset_id):
# Prompt user to pick a superuser if one does not currently exist
while not DevicePermissions.objects.filter(is_superuser=True).exists():
# specify username of account that will become a superuser
if not username:
username = input(
"Please enter username of account that will become the superuser on this device: "
)
if not FacilityUser.objects.filter(username=username).exists():
self.stderr.write(
"User with username {} does not exist".format(username)
)
username = None
continue
# make the user with the given credentials, a superuser for this device
user = FacilityUser.objects.get(username=username, dataset_id=dataset_id)
# create permissions for the authorized user
DevicePermissions.objects.update_or_create(
user=user, defaults={"is_superuser": True, "can_manage_content": True}
)
# if device has not been provisioned, set it up
if not device_provisioned():
provision_device()
def provisiondevice(self, request):
"""
After importing a Facility and designating/creating a super admins,
provision the device using that facility
"""
# TODO validate the data
device_name = request.data.get("device_name", "")
language_id = request.data.get("language_id", "")
# Get the imported facility (assuming its the only one at this point)
the_facility = Facility.objects.get()
# Use the facility's preset to determine whether to allow guest access
allow_guest_access = the_facility.dataset.preset != "formal"
# Finally: Call provision_device
provision_device(
device_name=device_name,
language_id=language_id,
default_facility=the_facility,
allow_guest_access=allow_guest_access,
)
return Response({})
def create_device_settings(language_id=None, facility=None, interactive=False):
if language_id is None and interactive:
language_id = get_user_response(
"Enter a default language code [{langs}]: ".format(
langs=",".join(languages.keys())),
valid_answers=languages,
)
provision_device(language_id=language_id, default_facility=facility)
def provision_single_user_device(user_id):
user = FacilityUser.objects.get(id=user_id)
# if device has not been provisioned, set it up
if not device_provisioned():
provision_device(default_facility=user.facility)
DevicePermissions.objects.get_or_create(user=user,
defaults={
"is_superuser": False,
"can_manage_content": True
})
def create(self, validated_data):
"""
Endpoint for initial setup of a device.
Expects a value for:
default language - the default language of this Kolibri device
facility - the required fields for setting up a facility
facilitydataset - facility configuration options
superuser - the required fields for a facilityuser who will be set as the super user for this device
"""
with transaction.atomic():
facility = Facility.objects.create(
**validated_data.pop("facility"))
preset = validated_data.pop("preset")
dataset_data = mappings[preset]
for key, value in dataset_data.items():
setattr(facility.dataset, key, value)
# overwrite the settings in dataset_data with validated_data.settings
custom_settings = validated_data.pop("settings")
for key, value in custom_settings.items():
if value is not None:
setattr(facility.dataset, key, value)
facility.dataset.save()
superuser_data = validated_data.pop("superuser")
superuser_data["facility"] = facility
superuser = FacilityUserSerializer(
data=superuser_data).create(superuser_data)
superuser.set_password(superuser_data["password"])
superuser.save()
facility.add_role(superuser, ADMIN)
DevicePermissions.objects.create(user=superuser, is_superuser=True)
language_id = validated_data.pop("language_id")
allow_guest_access = validated_data.pop("allow_guest_access")
if allow_guest_access is None:
allow_guest_access = preset != "formal"
provision_device(
device_name=validated_data["device_name"],
language_id=language_id,
default_facility=facility,
allow_guest_access=allow_guest_access,
)
return {
"facility": facility,
"preset": preset,
"superuser": superuser,
"language_id": language_id,
"settings": custom_settings,
"allow_guest_access": allow_guest_access,
}
def create_superuser_and_provision_device(username,
dataset_id,
noninteractive=False):
facility = Facility.objects.get(dataset_id=dataset_id)
# if device has not been provisioned, set it up
if not device_provisioned():
provision_device(default_facility=facility)
# Prompt user to pick a superuser if one does not currently exist
while not DevicePermissions.objects.filter(is_superuser=True).exists():
# specify username of account that will become a superuser
if not username:
if (
noninteractive
): # we don't want to setup a device without a superuser, so create a temporary one
superuser = FacilityUser.objects.create(username="******",
facility=facility)
superuser.set_password("password")
superuser.save()
DevicePermissions.objects.create(user=superuser,
is_superuser=True,
can_manage_content=True)
print(
"Temporary superuser with username: `superuser` and password: `password` created"
)
return
username = input(
"Please enter username of account that will become the superuser on this device: "
)
if not FacilityUser.objects.filter(username=username).exists():
print(
"User with username `{}` does not exist on this device".format(
username))
username = None
continue
# make the user with the given credentials, a superuser for this device
user = FacilityUser.objects.get(username=username,
dataset_id=dataset_id)
# create permissions for the authorized user
DevicePermissions.objects.update_or_create(user=user,
defaults={
"is_superuser": True,
"can_manage_content":
True
})
def create(self, validated_data):
"""
Endpoint for initial setup of a device.
Expects a value for:
default language - the default language of this Kolibri device
facility - the required fields for setting up a facility
facilitydataset - facility configuration options
superuser - the required fields for a facilityuser who will be set as the super user for this device
"""
with transaction.atomic():
facility = Facility.objects.create(
**validated_data.pop("facility"))
preset = validated_data.pop("preset")
facility.dataset.preset = preset
facility.dataset.reset_to_default_settings(preset)
# overwrite the settings in dataset_data with validated_data.settings
custom_settings = validated_data.pop("settings")
for key, value in custom_settings.items():
if value is not None:
setattr(facility.dataset, key, value)
facility.dataset.save()
# Create superuser
superuser = create_superuser(validated_data["superuser"],
facility=facility)
# Create device settings
language_id = validated_data.pop("language_id")
allow_guest_access = validated_data.pop("allow_guest_access")
if allow_guest_access is None:
allow_guest_access = preset != "formal"
provision_device(
device_name=validated_data["device_name"],
language_id=language_id,
default_facility=facility,
allow_guest_access=allow_guest_access,
)
return {
"facility": facility,
"preset": preset,
"superuser": superuser,
"language_id": language_id,
"settings": custom_settings,
"allow_guest_access": allow_guest_access,
}
def create_device_settings(language_id=None,
facility=None,
interactive=False,
new_settings={}):
if language_id is None and interactive:
language_id = get_user_response(
"Enter a default language code [{langs}]: ".format(
langs=",".join(languages.keys())),
valid_answers=languages,
)
# Override any settings passed in
for key in new_settings:
check_device_setting(key)
settings_to_set = dict(new_settings)
settings_to_set["language_id"] = language_id
settings_to_set["default_facility"] = facility
provision_device(**settings_to_set)
logger.info("Device settings updated with {}".format(settings_to_set))
def test_extract_facility_statistics(self):
provision_device(allow_guest_access=True)
facility = self.facilities[0]
actual = extract_facility_statistics(facility)
facility_id_hash = actual.pop("fi")
birth_year_list_learners = [
int(year) for year in FacilityUser.objects.filter(
roles__isnull=True).values_list("birth_year", flat=True)
]
# just assert the beginning hex values of the facility id don't match
self.assertFalse(facility_id_hash.startswith(facility.id[:3]))
demo_stats = calculate_list_stats(birth_year_list_learners)
expected = {
"s": {
"preset": facility_presets.default,
"learner_can_edit_username": True,
"learner_can_edit_name": True,
"learner_can_edit_password": True,
"learner_can_sign_up": True,
"learner_can_delete_account": True,
"learner_can_login_with_no_password": False,
"show_download_button_in_learn": True,
"allow_guest_access": True,
"registered": False,
},
"lc": 20, # learners_count
"llc": 20, # learner_login_count
"cc": 1, # coaches_count
"clc": 1, # coach_login_count
"f": "2018-10-11", # first interaction
"l": "2019-10-11", # last interaction
"ss": 20, # summarylog_started
"sc": 20, # summarylog_complete
"sk": {
content_kinds.EXERCISE: 20,
content_kinds.VIDEO: 20
}, # sess_kinds
"lec": 1, # lesson_count
"ec": 1, # exam_count
"elc": 20, # exam_log_count
"alc": 20, # att_log_count
"ealc": 20, # exam_att_log_count
"suc": 20, # sess_user_count
"sac": 20, # sess_anon_count
"sut": 20, # sess_user_time
"sat": 20, # sess_anon_time
"dsl": {
"bys": {
"a": demo_stats["mean"],
"sd": demo_stats["std"],
"ts": 20,
"d": 0,
"ns": 0,
},
"gc": {
gender: FacilityUser.objects.filter(gender=gender).count()
for (gender, _) in demographics.choices
if FacilityUser.objects.filter(gender=gender).exists()
},
}, # demographic_stats_learner
"dsnl": {}, # demographic_stats_non_learner
"crc": 1, # class_count
"grc": 0, # group_count
"sacnv": 20, # sess_anon_count_no_visitor_id
"uwl": 20, # users_with_logs
"vwl": 0, # anon_visitors_with_logs
"dis": {
"Android,9/Chrome Mobile,86": 20
}, # device info
}
assert actual == expected
def setup_device():
# Test helper to return a facility and superuser
facility = Facility.objects.create(name="Test")
superuser = create_superuser(facility)
provision_device()
return facility, superuser
