def save(self, *args, **kwargs): """Populate these settings for the current MailingList instance.""" if self.pk is None: # Save the list super(CoreListMixin, self).save(*args, **kwargs) # Make sure settings are present if self.settings is None: settings = ListSettings(fqdn_listname=self.fqdn_listname) settings.save() self.settings = settings super(CoreListMixin, self).save(*args, **kwargs) # Populate if not self.settings.join_address: self.settings.join_address = u'{0}-join@{1}'.format(self.list_name, self.mail_host) if not self.settings.bounces_address: self.settings.bounces_address = u'{0}-bounces@{1}'.format(self.list_name, self.mail_host) if not self.settings.leave_address: self.settings.leave_address = u'{0}-leave@{1}'.format(self.list_name, self.mail_host) if not self.settings.no_reply_address: self.settings.no_reply_address = u'noreply@{0}'.format(self.mail_host) if not self.settings.owner_address: self.settings.owner_address = u'{0}-owner@{1}'.format(self.list_name, self.mail_host) if not self.fqdn_listname: self.fqdn_listname = u'{0}@{1}'.format(self.list_name, self.mail_host) if not self.settings.request_address: self.settings.request_address = u'{0}-request@{1}'.format(self.list_name, self.mail_host) # Postorius is inconsistent in using these via settings or directly self.settings.fqdn_listname = self.fqdn_listname self.settings.mail_host = self.mail_host self.settings.display_name = self.display_name self.settings.save() super(CoreListMixin, self).save(*args, **kwargs)
def update_clamav(): LOG.info('Updating ClamAV signatures') # Don't judge me for this :P it works! freshclam_run = subprocess.run(['freshclam'], stdout=subprocess.PIPE) freshclam_out = freshclam_run.stdout.decode('utf-8').split('\n')[1:-1] _main = [line for line in freshclam_out if "main.c" in line][0] _daily = [line for line in freshclam_out if "daily.c" in line][0] _bytecode = [line for line in freshclam_out if "bytecode.c" in line][0] _main = _main[_main.index('version'):].split(', ') _daily = _daily[_daily.index('version'):].split(', ') _bytecode = _bytecode[_bytecode.index('version'):].split(', ') main_ver, main_sigs = _main[0].split(': ')[1], _main[1].split(': ')[1] daily_ver, daily_sigs = _daily[0].split(': ')[1], _daily[1].split(': ')[1] bytecode_ver, bytecode_sigs = _bytecode[0].split(': ')[1], _bytecode[1].split(': ')[1] # Glad that ugliness is over settings = Settings.objects.get(pk=1) settings.clamav_main_sigs = int(main_sigs) settings.clamav_main_ver = int(main_ver) settings.clamav_daily_sigs = int(daily_sigs) settings.clamav_daily_ver = int(daily_ver) settings.clamav_bytecode_sigs = int(bytecode_sigs) settings.clamav_bytecode_ver = int(bytecode_ver) settings.clamav_last_updated = timezone.now() settings.save() LOG.info('Updated ClamAV signatures')
def create_settings_with_homepage(self, page): settings = get_settings_model()() settings.homepage = page settings.save() page.is_homepage = True page.save() return settings
def __init__(self, request): super(SettingsForm, self).__init__() if request.method == 'POST': self.email = request.POST.get('email', None) self.email_sec = request.POST.get('email_sec', None) if self.email != self.email_sec: setup = True else: settings = Settings.objects.get(user=request.user) if request.POST.get('privacy', 'off') == 'on': settings.geolocation = True else: settings.geolocation = False settings.uses_map = request.POST.get('display', 'OSM') settings.save() setup = False user = User.objects.get(username=request.user) user.email = self.email user.save() if request.method == 'GET' or setup: choices = [] for api in Api.objects.all(): if str(request.user) == str(getattr(api, 'user')): choices.append( (getattr(api, 'api'), getattr(api, 'api')), ) self.fields['apis'].choices = choices settings = Settings.objects.get(user=request.user) if settings.geolocation: self.fields['privacy'].initial = True self.fields['display'].initial = settings.uses_map
def settings(self): try: return self.blogsettings_set.all()[0] except IndexError: settings = BlogSettings(blog=self) settings.save() return settings
def save(self, user): settings = user.settings settings.language = self.cleaned_data["language"] settings.save() return settings
def setup_view(request): # if this is a POST request we need to process the form data if request.method == 'POST': # create a form instance and populate it with data from the request: form = SetupForm(request.POST) # check whether it's valid: if form.is_valid(): hosting_service = form.cleaned_data['hosting_service'] api_key = form.cleaned_data['api_key'] settings = request.user.settings settings.api_key = api_key settings.hosting_service = hosting_service settings.is_setup_done = True settings.save() # redirect to a new URL: return HttpResponseRedirect(reverse('alias-list')) # if a GET (or any other method) we'll create a blank form else: settings = request.user.settings form = SetupForm(initial={ 'api_key': settings.api_key, 'hosting_service': settings.hosting_service }) return render(request, 'webapp/setup.html', {'form': form})
def test_photo_review_upload_ignore_privileged(self, mock_send_mail): settings = get_current_usersettings() settings.DEFAULT_FROM_EMAIL = '*****@*****.**' settings.save() review_url = reverse('photo-review', kwargs={'queued_image_id': self.q1.id}) review_page_response = self.app.get(review_url, user=self.test_reviewer) form = review_page_response.forms['photo-review-form'] form['decision'] = 'ignore' response = form.submit(user=self.test_reviewer) self.assertEqual(response.status_code, 302) split_location = urlsplit(response.location) self.assertEqual('/moderation/photo/review', split_location.path) self.assertEqual(mock_send_mail.call_count, 0) self.assertEqual( QueuedImage.objects.get(pk=self.q1.id).decision, 'ignore') las = LoggedAction.objects.all() self.assertEqual(1, len(las)) la = las[0] self.assertEqual(la.user.username, 'jane') self.assertEqual(la.action_type, 'photo-ignore') self.assertEqual(la.person.id, 2009)
def __init__(self, request): super(SettingsForm, self).__init__() if request.method == 'POST': self.email = request.POST.get('email', None) self.email_sec = request.POST.get('email_sec', None) if self.email != self.email_sec: setup = True else: settings = Settings.objects.get(user=request.user) if request.POST.get('privacy', 'off') == 'on': settings.geolocation = True else: settings.geolocation = False settings.uses_map = request.POST.get('display', 'OSM') settings.save() setup = False user = User.objects.get(username=request.user) user.email = self.email user.save() if request.method == 'GET' or setup: choices = [] for api in Api.objects.all(): if str(request.user) == str(getattr(api, 'user')): choices.append((getattr(api, 'api'), getattr(api, 'api')),) self.fields['apis'].choices = choices settings = Settings.objects.get(user=request.user) if settings.geolocation: self.fields['privacy'].initial = True self.fields['display'].initial = settings.uses_map
def post(self, request): experiment = Experiments.objects.get(pk=request.data['id']) default_transition_settings = DefaultTransitionProcessingSettings.objects.get( parser=experiment.parser) default_transition_settings_dict = { k: v for k, v in default_transition_settings.__dict__.items() if k not in [ '_state', 'id', 'parser_id', 'default_settings', 'data_types_available' ] } settings = TransitionProcessingSettings.objects.get( experiment=experiment) for key, value in default_transition_settings_dict.items(): setattr(settings, key, value) settings.save() if settings.has_changed: processed_data = ProcessedTransitionData.objects.filter( experiment=experiment).all() processed_data.delete() return Response({'update_status': 'success'}, status=200)
def user_settings(request, template_name="settings.html"): """ Add/Edit a setting """ user = get_object_or_404(User, username=request.user.username) try: settings = Setting.objects.get(user=user) except Setting.DoesNotExist: settings = None form = SettingForm(instance=settings) if request.method == "POST": form = SettingForm(request.POST, instance=settings) if form.is_valid(): msg = "Edited settings successfully." messages.info(request, msg, extra_tags="alert-success") settings = form.save(commit=False) settings.user = user settings.save() # clear settings cache cache_key = "%s_user_settings" % user.pk cache.set(cache_key, None) return render(request, template_name, {"form": form})
def settings(request, filename): if request.is_ajax(): #Get the RRi user = request.user rri_file = Tachogram.objects.get(owner=user, filename=filename) rri = get_file_information(rri_file) method = request.POST['method'] #TODO: Create function to do everything for each method. Instead of #letting the code here directly. if method == 'timevarying': segment_size = int(request.POST['segmentsize']) overlap_size = int(request.POST['overlapsize']) error_msg = validate_timevarying_parameters( rri, segment_size, overlap_size) time_varying = hrv.hrv.time_varying(rri, segment_size, overlap_size) #Save the parameters in the databse settings = Settings.objects.get(signal=rri_file) settings.tv_segment_size = segment_size settings.tv_overlap_size = overlap_size settings.save() results = { 'time_varying_index': zip(time_varying[0], time_varying[1]), 'time_varying_name': 'rmssd' } return HttpResponse(json.dumps(results), content_type='application/json')
def user_settings(request, template_name="settings.html"): """ Add/Edit a setting """ user = get_object_or_404(User, username=request.user.username) try: settings = Setting.objects.get(user=user) except Setting.DoesNotExist: settings = None form = SettingForm(instance=settings) if request.method == 'POST': form = SettingForm(request.POST, instance=settings) if form.is_valid(): msg = "Edited settings successfully." messages.info(request, msg, extra_tags='alert-success') settings = form.save(commit=False) settings.user = user settings.save() # clear settings cache cache_key = '%s_user_settings' % user.pk cache.set(cache_key, None) return render(request, template_name, { 'form': form, })
def form_valid(self, form): settings = SiteSettings.objects.get_current() note = '' for field in form.fields: if form.cleaned_data[field] != getattr(settings, field): note += _( 'Changed {field_name} from "{old_value}" to "{new_value}"' ).format( field_name=field, old_value=getattr(settings, field), new_value=form[field].value() ) + "\n" setattr(settings, field, form[field].value()) settings.user = self.request.user # n.b. saving the settings object automatically clears the # cache of current UserSettings. settings.save() request = self.request if note != '': LoggedAction.objects.create( user=request.user, action_type='settings-edited', ip_address=get_client_ip(request), popit_person_new_version='', person=None, source='', note=note ) return HttpResponseRedirect(reverse('settings'))
def barter_settings(request, template="core/barter_settings.html"): settings, created = Settings.objects.get_or_create(user=request.user) errors = [] if request.method == "POST": form = SettingsForm(request.POST, instance=settings) form.is_valid() checked = True if form.cleaned_data["new_q_notification_txt"] and \ not parse_phone_number(form.cleaned_data["mobile"]): checked = False errors.append( _("A correct mobile phone number is required if 'iKnow SMS' is enabled" )) if form.cleaned_data["mobile"].strip( ) != "" and not parse_phone_number(form.cleaned_data["mobile"]): checked = False errors.append(_("The phone number you input is not recognized")) if form.is_valid() and checked: form.save() if form.cleaned_data["mobile"].strip( ) != "" and parse_phone_number(form.cleaned_data["mobile"]): settings.mobile = parse_phone_number(settings.mobile) settings.save() return HttpResponseRedirect( reverse("egghead_detail", args=[request.user.username])) else: form = SettingsForm(instance=settings) return render_to_response(template, { "form": form, "errors": errors, }, context_instance=RequestContext(request))
def create_class_settings(sender, instance, **kwargs): try: class_settings = instance.class_settings except ClassSettings.DoesNotExist: settings = ClassSettings(classgroup=instance, access_key=make_random_key()) settings.save()
def test_get_upcoming_updates(self): def test(first_date, last_date, result): result = list(result) self.assertEqual(first_date, result[0][0]) self.assertEqual(last_date, result[-1][0]) site = Site.objects.get() self.assertEquals( [], list(get_upcoming_dates(datetime(2010, 10, 1, 15, 0, 0)))) settings = ReminderSettings.objects.create( site=site, send_reminders=False, begin_date=datetime(2010, 9, 1, 14, 0, 0), interval=14, ) self.assertEquals( [], list(get_upcoming_dates(datetime(2010, 10, 1, 15, 0, 0)))) settings.send_reminders = True settings.save() test(datetime(2010, 9, 15, 14, 0), datetime(2010, 12, 8, 14, 0), get_upcoming_dates(datetime(2010, 10, 1, 15, 0, 0)))
def test_get_prev_reminder_date(self): site = Site.objects.get() self.assertEquals(None, get_prev_reminder_date(datetime(2010, 12, 12))) settings = ReminderSettings.objects.create( site=site, send_reminders=False, begin_date=datetime(2010, 9, 1, 14, 0, 0), interval=7, ) self.assertEquals(None, get_prev_reminder_date(datetime(2010, 12, 12))) settings.send_reminders = True settings.save() self.assertEquals( None, get_prev_reminder_date(datetime(2010, 9, 1, 13, 0, 0))) self.assertEquals( datetime(2010, 9, 1, 14, 0, 0), get_prev_reminder_date(datetime(2010, 9, 1, 14, 0, 0))) self.assertEquals( datetime(2010, 9, 1, 14, 0, 0), get_prev_reminder_date(datetime(2010, 9, 8, 13, 0, 0))) self.assertEquals( datetime(2010, 9, 8, 14, 0, 0), get_prev_reminder_date(datetime(2010, 9, 8, 15, 0, 0)))
def settings_common(request): set_1 = Settings_common.objects.filter(owner=request.user).first() if set_1: set_info = Settings_common.objects.filter(owner=request.user).get( id=set_1.id) if request.method != 'POST': form = SettingsForm(instance=set_info) else: form = SettingsForm(instance=set_info, data=request.POST) if form.is_valid(): form.save() return HttpResponseRedirect(reverse('users:individual')) context = {'form': form, 'set_info': set_info} return render(request, 'send_email/settings_common.html', context) else: if request.method != 'POST': form = SettingsForm() else: form = SettingsForm(request.POST) if form.is_valid(): settings = form.save(commit=False) settings.owner = request.user settings.save() return HttpResponseRedirect(reverse('users:individual')) context = {'form': form} return render(request, 'send_email/settings_common.html', context)
def set_last_seen_id(self, username, last_seen_id): try: settings = UserSettings.objects.get(username=username) except UserSettings.DoesNotExist: settings = UserSettings.objects.create(username=username) settings.last_seen_msg_id = last_seen_id settings.save()
def test_photo_review_upload_ignore_privileged( self, mock_send_mail ): settings = get_current_usersettings() settings.DEFAULT_FROM_EMAIL = '*****@*****.**' settings.save() review_url = reverse( 'photo-review', kwargs={'queued_image_id': self.q1.id} ) review_page_response = self.app.get( review_url, user=self.test_reviewer ) form = review_page_response.forms['photo-review-form'] form['decision'] = 'ignore' response = form.submit(user=self.test_reviewer) self.assertEqual(response.status_code, 302) split_location = urlsplit(response.location) self.assertEqual('/moderation/photo/review', split_location.path) self.assertEqual(mock_send_mail.call_count, 0) self.assertEqual(QueuedImage.objects.get(pk=self.q1.id).decision, 'ignore') las = LoggedAction.objects.all() self.assertEqual(1, len(las)) la = las[0] self.assertEqual(la.user.username, 'jane') self.assertEqual(la.action_type, 'photo-ignore') self.assertEqual(la.person.id, 2009)
def preferences(request): if request.method.upper() == 'GET': try: data = { 'facility' : models.Settings.objects.all()[0].facility.id } except: facility = Facility.objects.all()[0] data = { 'facility' : facility.id } form = forms.SettingsForm(data) return render_to_response('catalpa/relatori/settings.html',{ 'form' : form, 'user' : request.user, 'context_instance' : RequestContext(request),}) if request.method.upper() == 'POST': form = forms.SettingsForm(request.POST) if form.is_valid(): submit = request.POST.get('submit') if submit==u'Save': facility = form.cleaned_data['facility'] try: settings = models.Settings.objects.all()[0] except: settings = models.Settings() #settings.creator = request.user settings.facility = facility settings.save() messages.success(request, _('Thank you %s, you successfully saved settings.' % (request.user))) return render_to_response('catalpa/relatori/index.html',{ 'user' : request.user, 'context_instance' : RequestContext(request),})
def begin_recovering_erred_service_settings(settings_uuid, transition_entity=None): settings = models.ServiceSettings.objects.get(uuid=settings_uuid) try: backend = settings.get_backend() is_active = backend.ping() except ServiceBackendNotImplemented: is_active = False if is_active: settings.set_in_sync() settings.error_message = '' settings.save() logger.info('Service settings %s successfully recovered.' % settings.name) try: spl_model = SupportedServices.get_service_models()[settings.type]['service_project_link'] erred_spls = spl_model.objects.filter(service__settings=settings, state=SynchronizationStates.ERRED) recover_erred_services.delay([spl.to_string() for spl in erred_spls]) except KeyError: logger.warning('Failed to recover service project links for settings %s', settings) else: settings.set_erred() settings.error_message = 'Failed to ping service settings %s' % settings.name settings.save() logger.info('Failed to recover service settings %s.' % settings.name)
def test_photo_review_upload_undecided_privileged( self, mock_send_mail ): settings = get_current_usersettings() settings.DEFAULT_FROM_EMAIL = '*****@*****.**' settings.save() review_url = reverse( 'photo-review', kwargs={'queued_image_id': self.q1.id} ) review_page_response = self.app.get( review_url, user=self.test_reviewer ) form = review_page_response.forms['photo-review-form'] form['decision'] = 'undecided' form['rejection_reason'] = 'No clear source or copyright statement' response = form.submit(user=self.test_reviewer) self.assertEqual(response.status_code, 302) split_location = urlsplit(response.location) self.assertEqual('/moderation/photo/review', split_location.path) self.assertEqual(mock_send_mail.call_count, 0) self.assertEqual(QueuedImage.objects.get(pk=self.q1.id).decision, 'undecided')
def saveUESettings(request): try: iSession = request.session['interactives']['unemployment'] param = iSession.getLaunchParam() roles = param['roles'] if 'Learner' in roles: raise Exception except: return HttpResponse('{}', status=401) rawData = request.body newSettings = json.loads(rawData) work = InteractiveState.objects.filter( iSession__resource_id=iSession.resource_id, iSession__target_app=iSession.target_app).count() if (work > 0): work = True else: work = False print 'ue/views.py saveUESettings work = ', str(work) #the class id is actually the resource_id (assignment) try: settings = UESettings.objects.get(class_id=iSession.resource_id) except: settings = UESettings() settings.class_id = iSession.resource_id if work: return HttpResponse('{}', status=401) settings.settings = json.dumps(newSettings) settings.save() return HttpResponse('{}', 'application/json')
def laudio_settings(request): """Site where the configuration happens""" config = LaudioSettings() users = User.objects.all() if request.method == 'POST': settingsForm = SettingsForm(request.POST) if settingsForm.is_valid(): # get the first setting in the db try: settings = Settings.objects.get(pk=1) except Settings.DoesNotExist: settings = Settings() fields = ("requireLogin", "debugAudio", "collection", "showLib", "hideSidebar", "hidePlaylist") # write data into db for key in fields: setattr(settings, key, settingsForm.cleaned_data[key]) settings.save() # set symlink config.setCollectionPath(settingsForm.cleaned_data['collection']) else: try: settings = Settings.objects.get(pk=1) settingsForm = SettingsForm(instance=settings) except Settings.DoesNotExist: settingsForm = SettingsForm(initial={'cacheSize': 100}) # get javascript js = JavaScript("settings", request) return render(request, 'settings/settings.html', { "collection": config.collectionPath, "settingsForm": settingsForm, "users": users, "js": js, } )
def _setup_badge_settings(self): """ Set up badges for all jobs and helpers (called from post_save handler). It adds the badge settings if badge creation is enabled and it is not there already. It also adds badge defaults to all jobs and badges to all helpers and coordinators if necessary. """ # badge settings for event if not self.badge_settings: settings = BadgeSettings() settings.event = self settings.save() # badge defaults for jobs for job in self.job_set.all(): if not job.badge_defaults: defaults = BadgeDefaults() defaults.save() job.badge_defaults = defaults job.save() # badge for helpers for helper in self.helper_set.all(): if not hasattr(helper, 'badge'): badge = Badge() badge.event = self badge.helper = helper badge.save()
def site_settings_set(key, val): if not SiteSettings.objects.filter(key=key).exists(): SiteSettings.objects.create(key=key, val=val) else: settings = SiteSettings.objects.get(key=key) settings.val = val settings.save(update_fields=['val']) cache.set('site_settings_' + key, val, 300)
def setUp(self): self.client.get('/app/OpenScenario/Roundtrip_test.sqlite3/') settings = OutputSettings.objects.first() settings.stop_criteria = 'stop-days' settings.days = 10 settings.save() close_old_connections()
def setUp(self): #pass settings = OPSettings(opId=self.opId, displayName=self.displayName, issuer=self.issuer, redirect_url=self.redirect_url, scope=self.scope) settings.save()
def toggle_rush_signin(request): """ activates rush signin """ settings = getSettings() if settings.rush_signin_active: settings.rush_signin_active = False else: settings.rush_signin_active = True settings.save() return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def test_photo_review_upload_approved_privileged( self, mock_send_mail ): settings = get_current_usersettings() settings.DEFAULT_FROM_EMAIL = '*****@*****.**' settings.site_id = self.site.id settings.save() with self.settings(SITE_ID=self.site.id): review_url = reverse( 'photo-review', kwargs={'queued_image_id': self.q1.id} ) review_page_response = self.app.get( review_url, user=self.test_reviewer ) form = review_page_response.forms['photo-review-form'] form['decision'] = 'approved' form['moderator_why_allowed'] = 'profile-photo' response = form.submit(user=self.test_reviewer) # FIXME: check that mocked_person_put got the right calls self.assertEqual(response.status_code, 302) split_location = urlsplit(response.location) self.assertEqual('/moderation/photo/review', split_location.path) mock_send_mail.assert_called_once_with( 'YNR image upload approved', "Thank-you for submitting a photo to YNR; that's been uploaded\nnow for the candidate page here:\n\n http://localhost:80/person/2009/tessa-jowell\n\nMany thanks from the YNR volunteers\n", '*****@*****.**', ['*****@*****.**'], fail_silently=False ) person = Person.objects.get(id=2009) image = person.extra.images.last() self.assertTrue(image.is_primary) self.assertEqual( 'Uploaded by john: Approved from photo moderation queue', image.source ) self.assertEqual(427, image.image.width) self.assertEqual(639, image.image.height) self.q1.refresh_from_db() self.assertEqual('public-domain', self.q1.why_allowed) self.assertEqual('approved', self.q1.decision) las = LoggedAction.objects.all() self.assertEqual(1, len(las)) la = las[0] self.assertEqual(la.user.username, 'jane') self.assertEqual(la.action_type, 'photo-approve') self.assertEqual(la.person.id, 2009) self.assertEqual(QueuedImage.objects.get(pk=self.q1.id).decision, 'approved')
def clear_base_folder(request): settings = UserSettings.objects.get(id=1) try: settings.base_folder = '' settings.save() return HttpResponse('SUCCESS') except Exception as error: print('Error writing to database: ' + str(error)) return HttpResponse('FAILURE')
def init_settings(house): dinner = HMUtility.objects.get(name="Dinner") settings = DinnerHouseSettings() settings.utility = dinner settings.house = house settings.active = False settings.push_hour = 12 settings.push_minute = 00 settings.template = "alpha/utilities/dinner/settings/house_settings.html" settings.save() return settings
def init_settings(house): dinner = HMUtility.objects.get(name="Dinner") settings = DinnerHouseSettings() settings.utility = dinner settings.house = house settings.active=False settings.push_hour = 12 settings.push_minute = 00 settings.template = "alpha/utilities/dinner/settings/house_settings.html" settings.save() return settings
def deactivate(request): house = House.objects.get(id=request.POST['house_id']) dinner = HMUtility.objects.get(name="Dinner") try: settings = DinnerHouseSettings.objects.filter(utility=dinner).filter(house=house)[0] settings.active= False settings.save() except: settings = init_settings(house) settings.active=False settings.save() return redirect('%ssettings/' % house.get_absolute_url())
def house_settings_handler(request): house = House.objects.get(id=request.POST['house_id']) dinner = HMUtility.objects.get(name="Dinner") try: settings = DinnerHouseSettings.objects.filter(utility=dinner).filter(house=house)[0] settings.push_hour= request.POST['push_hour'] settings.save() except: settings = define_house_settings(house) settings.push_hour= request.POST['push_hour'] settings.save() return redirect('%ssettings/' % house.get_absolute_url())
def collect_usage(request): response = {'status': -1, 'data': ''} if request.method == 'POST': try: settings = Settings.get_settings() settings.collect_usage = request.POST.get('collect_usage', False) settings.save() response['status'] = 0 response['collect_usage'] = settings.collect_usage except Exception, e: response['data'] = str(e)
def update_preferences(request): response = {'status': -1, 'data': ''} if request.method == 'POST': try: settings = Settings.get_settings() settings.tours_and_tutorials = request.POST.get('tours_and_tutorials', False) settings.save() response['status'] = 0 response['tours_and_tutorials'] = settings.tours_and_tutorials except Exception, e: response['data'] = str(e)
def test_maintenance_mode_redirection(self): validation_params = { 'datasets-TOTAL_FORMS': 1, 'datasets-INITIAL_FORMS': 1, 'datasets-MIN_NUM_FORMS': 1, 'datasets-MAX_NUM_FORMS': 5, 'datasets-0-dataset': Dataset.objects.get(short_name=globals.C3S).id, 'datasets-0-version': DatasetVersion.objects.get(short_name=globals.C3S_V201706).id, 'datasets-0-variable': DataVariable.objects.get(short_name=globals.C3S_sm).id, 'ref-dataset': Dataset.objects.get(short_name=globals.ISMN).id, 'ref-version': DatasetVersion.objects.get( short_name=globals.ISMN_V20180712_MINI).id, 'ref-variable': DataVariable.objects.get(short_name=globals.ISMN_soil_moisture).id, 'scaling_method': ValidationRun.MEAN_STD, #'scaling_ref': ValidationRun.SCALE_REF, } # store state to revert back at the end of the test settings = Settings.load() orig_mm = settings.maintenance_mode url = reverse('admin:system-settings') validation_url = reverse('validation') # switch on maint mode maint_params = { 'maintenance_mode': True, } self.client.login(**self.admin_credentials) self.client.post(url, maint_params, follow=True) self.client.logout() # try to run a validation as a regular user self.client.login(**self.user_credentials) result = self.client.post(validation_url, validation_params) # check that we're redirected back to the validation page self.assertRedirects(result, validation_url) settings.maintenance_mode = orig_mm settings.save()
def my_callback(sender, instance, created, raw, using, **kwargs): if created: user_lang = None try: user_lang = Language.objects.get(code=get_language()) except Language.DoesNotExist: user_lang = Language.objects.get(code='ar') profile = Profile.objects.create(user=instance, lang=user_lang) settings = AccountSettings.objects.create(user=instance) profile.save() settings.save() return True return False
def my_callback(sender, instance, created, raw, using, **kwargs): if created: user_lang = None try : user_lang = Language.objects.get(code=get_language()) except Language.DoesNotExist : user_lang = Language.objects.get(code='ar') profile = Profile.objects.create(user= instance, lang = user_lang) settings = AccountSettings.objects.create(user= instance) profile.save() settings.save() return True return False
def test_map_zip_no_output(self): settings = OutputSettings.objects.first() settings.save_map_output = False settings.save() close_old_connections() file_name = os.path.join(self.scenario_directory, 'Roundtrip_test Map Output.zip') folder_name = os.path.join(self.scenario_directory, 'Map') sim = Simulation(1, testing=True) sim.start() sim.join() self.assertFalse(os.access(file_name, os.F_OK))
def update_preferences(request): response = {'status': -1, 'data': ''} if request.method == 'POST': try: settings = Settings.get_settings() settings.tours_and_tutorials = request.POST.get( 'tours_and_tutorials', False) settings.save() response['status'] = 0 response['tours_and_tutorials'] = settings.tours_and_tutorials except Exception, e: response['data'] = str(e)
def test_settings(self): settings = Settings.load() assert settings settings.save() # delete should have no effect settings.delete() settings = Settings.load() assert settings s = str(settings) self.__logger.info(s)
def get_current_group(): ''' Get the group pointed to by the settings object. Settings is a singleton. If settings doesn't exist, create settings and group. ''' if not Settings.objects.count(): # create settings and group if no settings object exists group = Group() group.save() settings = Settings(group=group) settings.save() return group settings = Settings.objects.all()[0] group = get_object_or_404(Group, id=settings.current_group_id) return group
def test_map_zip_with_output(self): settings = OutputSettings.objects.first() settings.save_daily_unit_states = True settings.save_map_output = True settings.save() close_old_connections() file_name = os.path.join(self.scenario_directory, 'Roundtrip_test Map Output.zip') folder_name = os.path.join(self.scenario_directory, 'Map') sim = Simulation(1, testing=True) sim.start() sim.join() self.assertTrue(os.access(file_name, os.F_OK)) with zipfile.ZipFile(file_name, 'r') as zf: self.assertListEqual(zf.namelist(), os.listdir(folder_name))
def test_supplemental_output_created(self): """ Ensures that prepare_supplemental_output_directory is being called, and that the directory created is being passed to adsm properly """ settings = OutputSettings.objects.first() settings.save_daily_unit_states = True settings.save() close_old_connections() output_file = os.path.join(self.scenario_directory, 'states_1.csv') sim = Simulation(1, testing=True) sim.start() sim.join() self.assertTrue(os.access(output_file, os.F_OK))
def settings(request): if check_login(request) == False: return redirect('login') current_user = User.objects.get(id=request.session[SESSION_KEY]) settings_form = SettingsForm() if request.method == 'POST': settings_form = SettingsForm(request.POST, request.FILES) if settings_form.is_valid(): settings = Settings.objects.get_or_create(user=current_user)[0] settings.profile_pic = settings_form.cleaned_data['image'] settings.save() messages.add_message(request, messages.SUCCESS, 'Profile image updated') user_settings = current_user.settings.all() user_settings = user_settings[:1].get() if user_settings.exists() else None return render(request, 'settings.html', { 'user': current_user, 'form': settings_form, 'settings' : user_settings})
def post(self, request): """ Set user settings for file manager """ try: home_directory = request.POST["home_directory"] theme = request.POST["theme"] font_size = request.POST["font_size"] settings = FileManagerSettings.objects.get(User=request.user) settings.HomeDirectory = home_directory settings.AceTheme = theme settings.FontSize = font_size settings.save() return Response() except Exception, ex: return Response(str(ex), status=400)
def test_photo_review_upload_rejected_privileged( self, mock_send_mail ): settings = get_current_usersettings() settings.DEFAULT_FROM_EMAIL = '*****@*****.**' settings.SUPPORT_EMAIL = '*****@*****.**' settings.site_id = self.site.id settings.save() with self.settings(SITE_ID=self.site.id): review_url = reverse( 'photo-review', kwargs={'queued_image_id': self.q1.id} ) review_page_response = self.app.get( review_url, user=self.test_reviewer ) form = review_page_response.forms['photo-review-form'] form['decision'] = 'rejected' form['rejection_reason'] = 'There\'s no clear source or copyright statement' response = form.submit(user=self.test_reviewer) self.assertEqual(response.status_code, 302) split_location = urlsplit(response.location) self.assertEqual('/moderation/photo/review', split_location.path) las = LoggedAction.objects.all() self.assertEqual(1, len(las)) la = las[0] self.assertEqual(la.user.username, 'jane') self.assertEqual(la.action_type, 'photo-reject') self.assertEqual(la.person.id, 2009) self.assertEqual(la.source, 'Rejected a photo upload from john') self.assertEqual(la.note, 'There\'s no clear source or copyright statement') mock_send_mail.assert_called_once_with( 'YNR image moderation results', "Thank-you for uploading a photo of Tessa Jowell to YNR, but\nunfortunately we can't use that image because:\n\n There\'s no clear source or copyright statement\n\nYou can just reply to this email if you want to discuss that\nfurther, or you can try uploading a photo with a different\nreason or justification for its use using this link:\n\n http://localhost:80/moderation/photo/upload/2009\n\nMany thanks from the YNR volunteers\n\n-- \nFor administrators' use: http://localhost:80/moderation/photo/review/{0}\n".format(self.q1.id), '*****@*****.**', ['*****@*****.**', '*****@*****.**'], fail_silently=False ) self.assertEqual(QueuedImage.objects.get(pk=self.q1.id).decision, 'rejected')
def account_settings(request): context = RequestContext(request) profile = fbutil.profile_for_user(request.user) if not profile: return render_to_response('contrib/facebook/link.html', context) settings = profile.settings.all()[0] form = forms.FacebookSettingsForm(instance=settings) if request.method == 'POST': form = forms.FacebookSettingsForm(request.POST, instance=settings) if form.is_valid(): profile = fbutil.profile_for_user(request.user) if not profile: raise ValueError, "Bad profile" settings = form.save(commit=False) settings.profile = profile settings.save() context['settings_form'] = form return render_to_response('contrib/facebook/settings.html', context)
def user_settings(request): settings = False if request.user.is_active: # check if the user has settings try: settings = request.user.settings except: settings = UserSettings() settings.user = request.user settings.save() print settings return { 'user_settings':settings }
def test_get_prev_reminder_date(self): site = Site.objects.get() self.assertEquals(None, get_prev_reminder_date(datetime(2010, 12, 12))) settings = ReminderSettings.objects.create( site=site, send_reminders=False, begin_date=datetime(2010, 9, 1, 14, 0, 0), interval=7, ) self.assertEquals(None, get_prev_reminder_date(datetime(2010, 12, 12))) settings.send_reminders = True settings.save() self.assertEquals(None, get_prev_reminder_date(datetime(2010, 9, 1, 13, 0, 0))) self.assertEquals(datetime(2010, 9, 1, 14, 0, 0), get_prev_reminder_date(datetime(2010, 9, 1, 14, 0, 0))) self.assertEquals(datetime(2010, 9, 1, 14, 0, 0), get_prev_reminder_date(datetime(2010, 9, 8, 13, 0, 0))) self.assertEquals(datetime(2010, 9, 8, 14, 0, 0), get_prev_reminder_date(datetime(2010, 9, 8, 15, 0, 0)))
def test_get_upcoming_updates(self): def test(first_date, last_date, result): result = list(result) self.assertEqual(first_date, result[0][0]) self.assertEqual(last_date, result[-1][0]) site = Site.objects.get() self.assertEquals([], list(get_upcoming_dates(datetime(2010, 10, 1, 15, 0, 0)))) settings = ReminderSettings.objects.create( site=site, send_reminders=False, begin_date=datetime(2010, 9, 1, 14, 0, 0), interval=14, ) self.assertEquals([], list(get_upcoming_dates(datetime(2010, 10, 1, 15, 0, 0)))) settings.send_reminders = True settings.save() test(datetime(2010, 10, 13, 14, 0), datetime(2010, 12, 8, 14, 0), get_upcoming_dates(datetime(2010, 10, 1, 15, 0, 0)))
def commtrack_settings(request, domain): domain = Domain.get_by_name(domain) settings = domain.commtrack_settings if request.POST: from corehq.apps.commtrack.models import CommtrackActionConfig, LocationType payload = json.loads(request.POST.get('json')) settings.multiaction_keyword = payload['keyword'] def make_action_name(caption, actions): existing = filter(None, [a.get('name') for a in actions]) name = ''.join(c.lower() if c.isalpha() else '_' for c in caption) disambig = 1 def _name(): return name + ('_%s' % disambig if disambig > 1 else '') while _name() in existing: disambig += 1 return _name() def mk_action(action): action['action_type'] = action['type'] del action['type'] if not action.get('name'): action['name'] = make_action_name(action['caption'], payload['actions']) return CommtrackActionConfig(**action) def mk_loctype(loctype): loctype['allowed_parents'] = [p or '' for p in loctype['allowed_parents']] return LocationType(**loctype) #TODO add server-side input validation here (currently validated on client) settings.actions = [mk_action(a) for a in payload['actions']] settings.location_types = [mk_loctype(l) for l in payload['loc_types']] settings.requisition_config.enabled = payload['requisition_config']['enabled'] settings.requisition_config.actions = [mk_action(a) for a in payload['requisition_config']['actions']] settings.save() def settings_to_json(config): return { 'keyword': config.multiaction_keyword, 'actions': [action_to_json(a) for a in config.actions], 'loc_types': [loctype_to_json(l) for l in config.location_types], 'requisition_config': { 'enabled': config.requisition_config.enabled, 'actions': [action_to_json(a) for a in config.requisition_config.actions], } } def action_to_json(action): return { 'type': action.action_type, 'keyword': action.keyword, 'name': action.action_name, 'caption': action.caption, } def loctype_to_json(loctype): return { 'name': loctype.name, 'allowed_parents': [p or None for p in loctype.allowed_parents], 'administrative': loctype.administrative, } def other_sms_codes(): for k, v in all_sms_codes(domain.name).iteritems(): if v[0] == 'product': yield (k, (v[0], v[1].name)) return render(request, 'domain/admin/commtrack_settings.html', dict( domain=domain.name, settings=settings_to_json(settings), other_sms_codes=dict(other_sms_codes()), ))