Esempio n. 1
0
 def del_setting(self, name):
     settings = json.loads(self.settings)
     try:
         settings.pop(name)
     except KeyError:
         pass
     self.settings = json.dumps(settings)
Esempio n. 2
0
 def save(self, text=None, script=None, settings=None):
     """ save uri(schemes) or script(cron) to mongodb server
         return True if success else False
     """
     if text is not None:
         try:
             schemes = settings.pop('schemes', None)
             assert self.save_text(text, schemes)
         except AssertionError as e:
             content = "%s : Error occured when saving text" % (type(e))
             CrawlerGeneratorErrorLog(name="ERROR_SAVE", content=content, hostname=socket.gethostname()).save()
     elif script is not None:
         if 'cron' not in settings:
             content = "cron is not found in settings"
             CrawlerGeneratorErrorLog(name="ERROR_SAVE", content=content, hostname=socket.gethostname()).save()
             return
         if 'code_type' not in settings:
             content = "code type is not found in settings"
             CrawlerGeneratorErrorLog(name="ERROR_SAVE", content=content, hostname=socket.gethostname()).save()
             return
         try:
             schemes = settings.pop('schemes', None)
             assert self.save_script(script, settings['cron'], settings['code_type'], schemes)
         except AssertionError:
             CrawlerGeneratorErrorLog(name="ERROR_SAVE",
                                      content="Error occured when saving script ",
                                      hostname=socket.gethostname()).save()
     else:
         CrawlerGeneratorErrorLog(name="ERROR_SAVE",
                                  content="No text or script found .",
                                  hostname=socket.gethostname()).save()
Esempio n. 3
0
 def del_setting(self, name):
     settings = json.loads(self.settings)
     try:
         settings.pop(name)
     except KeyError:
         pass
     self.settings = json.dumps(settings)
Esempio n. 4
0
    def pop_settings(self, pop_settings):
        settings = json.loads(self.settings)

        for setting in pop_settings:
            if setting in settings:
                settings.pop(setting)

        self.settings = json.dumps(settings, cls=LazyDateTimeEncoder)
        self.save()
Esempio n. 5
0
    def _prepare_cloned_data(self, original_asset, source_version,
                             partial_update):
        """
        Some business rules must be applied when cloning an asset to another with a different type.
        It prepares the data to be cloned accordingly.

        It raises an exception if source and destination are not compatible for cloning.

        :param original_asset: Asset
        :param source_version: AssetVersion
        :param partial_update: Boolean
        :return: dict
        """
        if self._validate_destination_type(original_asset):
            # `to_clone_dict()` returns only `name`, `content`, `asset_type`,
            # and `tag_string`
            cloned_data = original_asset.to_clone_dict(version=source_version)

            # Allow the user's request data to override `cloned_data`
            cloned_data.update(self.request.data.items())

            if partial_update:
                # Because we're updating an asset from another which can have another type,
                # we need to remove `asset_type` from clone data to ensure it's not updated
                # when serializer is initialized.
                cloned_data.pop("asset_type", None)
            else:
                # Change asset_type if needed.
                cloned_data["asset_type"] = self.request.data.get(
                    ASSET_TYPE_ARG_NAME, original_asset.asset_type)

            cloned_asset_type = cloned_data.get("asset_type")
            # Settings are: Country, Description, Sector and Share-metadata
            # Copy settings only when original_asset is `survey` or `template`
            # and `asset_type` property of `cloned_data` is `survey` or `template`
            # or None (partial_update)
            if cloned_asset_type in [None, ASSET_TYPE_TEMPLATE, ASSET_TYPE_SURVEY] and \
                original_asset.asset_type in [ASSET_TYPE_TEMPLATE, ASSET_TYPE_SURVEY]:

                settings = original_asset.settings.copy()
                settings.pop("share-metadata", None)
                settings.update(cloned_data.get('settings', {}))
                cloned_data['settings'] = json.dumps(settings)

            # until we get content passed as a dict, transform the content obj to a str
            # TODO, verify whether `Asset.content.settings.id_string` should be cleared out.
            cloned_data["content"] = json.dumps(cloned_data.get("content"))
            return cloned_data
        else:
            raise BadAssetTypeException(
                "Destination type is not compatible with source type")
Esempio n. 6
0
    def adjust_content_on_save(self):
        """
        This is called on save by default if content exists.
        Can be disabled / skipped by calling with parameter:
        asset.save(adjust_content=False)
        """
        self._standardize(self.content)

        self._make_default_translation_first(self.content)
        self._strip_empty_rows(self.content)
        self._assign_kuids(self.content)
        self._autoname(self.content)
        self._unlink_list_items(self.content)
        self._remove_empty_expressions(self.content)

        settings = self.content['settings']
        _title = settings.pop('form_title', None)
        id_string = settings.get('id_string')
        filename = self.summary.pop('filename', None)
        if filename:
            # if we have filename available, set the id_string
            # and/or form_title from the filename.
            if not id_string:
                id_string = sluggify_label(filename)
                settings['id_string'] = id_string
            if not _title:
                _title = filename
        if self.asset_type not in [ASSET_TYPE_SURVEY, ASSET_TYPE_TEMPLATE]:
            # instead of deleting the settings, simply clear them out
            self.content['settings'] = {}
            strip_kobo_locking_profile(self.content)

        if _title is not None:
            self.name = _title
 def _update_client_settings(self, settings):
     update_fields = []
     if 'algorithm' in settings:
         algorithm = settings.pop('algorithm')
         if algorithm != self.algorithm:
             self.algorithm = algorithm
             update_fields.append('algorithm')
     
     return update_fields    
Esempio n. 8
0
    def _update_client_settings(self, settings):
        update_fields = []
        if 'algorithm' in settings:
            algorithm = settings.pop('algorithm')
            if algorithm != self.algorithm:
                self.algorithm = algorithm
                update_fields.append('algorithm')

        return update_fields
	def __init__(self, *args, **settings):
		self.shib_idp_attrib_name = settings.pop('shib_idp_attrib_name', app_settings.SHIB_IDP_ATTRIB_NAME)
		self.shib_authorized_idps = settings.pop('shib_authorized_idps', app_settings.SHIB_AUTHORIZED_IDPS)
		self.shib_attribute_map = settings.pop('shib_attribute_map', app_settings.SHIB_ATTRIBUTE_MAP)
		self.shib_mock = settings.pop('shib_mock', app_settings.SHIB_MOCK)
		self.shib_mock_attributes = settings.pop('shib_mock_attributes', app_settings.SHIB_MOCK_ATTRIBUTES)
		self.shib_username_attrib_name = settings.pop('shib_username_attrib_name', app_settings.SHIB_USERNAME_ATTRIB_NAME)
		self.shib_group_attributes = settings.pop('shib_group_attributes', app_settings.SHIB_GROUP_ATTRIBUTES)
		self.shib_groups_by_idp = settings.pop('shib_groups_by_idp', app_settings.SHIB_GROUPS_BY_IDP)

		super().__init__(*args, **settings)
Esempio n. 10
0
    def _update_setting_string(self, app, group):
        settings = {
            setting.code: None
            for setting in Settings.objects.filter(compact=True, app=app)
        }
        settings_string = ''
        #Force QuerySet evaltion so the database is only hit once for user defaults
        user_settings = list(
            UserDefault.objects.filter(user=self, setting__app=app))

        while group != None:
            #Apply user defaults for this group context
            for default in user_settings.filter(group=group):
                code = default.setting.code
                if code in settings:
                    settings_string += '&' + code + '=' + default.settingVal.value
                    #Remove the setting from dict, so new value cannot be set
                    settings.pop(code)

            #Find group-level defaults for setttings that have not been set yet
            for default in GroupDefault.objects.filter(group=group,
                                                       setting__app=app):
                code = default.setting.code
                if code in settings and settings[code] == None:
                    settings[code] = default.settingVal.value

            #Move up to next group in the hierarchy
            group = group.parent

        #Add all group defaults that had no user defaults
        for code, value in settings.iteritems():
            if value == None:
                value = Setting.objects.get(app=app, code=code).default.value
            settings_string += '&' + code + '=' + value

        #Set the value in the corresonding CompactSettings, remove the first '&'
        compact, c = CompactSettings.objects.get_or_create(user=self,
                                                           group=group,
                                                           app=app)
        compact.string = settings_string[1:]
        compact.save()
Esempio n. 11
0
    def _update_setting_string(self, app, group):
        settings = {setting.code: None for setting in
                Settings.objects.filter(compact=True, app=app)}
        settings_string = ''
        #Force QuerySet evaltion so the database is only hit once for user defaults
        user_settings = list(UserDefault.objects.filter(user=self, setting__app=app))

        while group != None:
            #Apply user defaults for this group context
            for default in user_settings.filter(group=group):
                code = default.setting.code
                if code in settings:
                    settings_string += '&'+ code +'='+ default.settingVal.value
                    #Remove the setting from dict, so new value cannot be set
                    settings.pop(code)

            #Find group-level defaults for setttings that have not been set yet
            for default in GroupDefault.objects.filter(group=group, setting__app=app):
                code = default.setting.code
                if code in settings and settings[code] == None:
                    settings[code] = default.settingVal.value

            #Move up to next group in the hierarchy
            group = group.parent

        #Add all group defaults that had no user defaults
        for code, value in settings.iteritems():
            if value == None:
                value = Setting.objects.get(app=app, code=code).default.value
            settings_string += '&'+ code +'='+ value

        #Set the value in the corresonding CompactSettings, remove the first '&'
        compact, c = CompactSettings.objects.get_or_create(user=self,
                group=group, app=app)
        compact.string = settings_string[1:]
        compact.save()
Esempio n. 12
0
 def pop(name, default=None):
     return settings.pop(name) or default
Esempio n. 13
0
 def pop(name, default=None):
     return settings.pop(name) or default
Esempio n. 14
0
 def pop(name, default=None):
     try:
         return settings.pop(name) or default
     except KeyError:
         return default;