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 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 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()),
))
