def handle(self, *args, **options): disable_dlu = settings.get('DISABLE_USER_REGISTRATION_LIMIT', False) limit = settings.get('MAX_USER_REGISTRATIONS') if not disable_dlu: limit = limit - User.objects.all().count() if disable_dlu or limit > 0: # Get the oldest registered users that are disabled disabled = DisabledUser.objects.all().order_by('user__created') # If disabled, don't limit, and so just enable ALL of them if not disable_dlu: disabled = disabled[:(limit - 1)] users = disabled.user_set user_set.update(disabled=False) if options['comma']: sep = "," else: sep = "\n" emails = [] if options['emails']: print "IDs:" print sep.join(email for obj.email in users.all()) ids = [] if options['ids']: print "Emails:" print sep.join(id for obj.id in users.all()) disabled.delete() print "%d users enabled." % (limit, ) else: print "No users to enable.\nEither all users are enabled, or settings.MAX_USER_REGISTRATIONS is too low."
def regenerate_css(event): settings = event.settings._cache() # ignore organizer settings # main.scss css, checksum = compile_scss(event) fname = 'pub/{}/{}/presale.{}.css'.format(event.organizer.slug, event.slug, checksum[:16]) if settings.get('presale_css_checksum', '') != checksum: old_fname = settings.get('presale_css_file') newname = default_storage.save(fname, ContentFile(css.encode('utf-8'))) event.settings.set('presale_css_file', newname) event.settings.set('presale_css_checksum', checksum) if old_fname and old_fname != newname: delete_old_file(old_fname) # widget.scss css, checksum = compile_scss(event, file='widget.scss', fonts=False) fname = 'pub/{}/{}/widget.{}.css'.format(event.organizer.slug, event.slug, checksum[:16]) if settings.get('presale_widget_css_checksum', '') != checksum: old_fname = settings.get('presale_widget_css_file') newname = default_storage.save(fname, ContentFile(css.encode('utf-8'))) event.settings.set('presale_widget_css_file', newname) event.settings.set('presale_widget_css_checksum', checksum) if old_fname and old_fname != newname: delete_old_file(old_fname)
def handle(self, *args, **options): disable_dlu = settings.get('DISABLE_USER_REGISTRATION_LIMIT', False) limit = settings.get('MAX_USER_REGISTRATIONS') if not disable_dlu: limit = limit - User.objects.all().count() if disable_dlu or limit > 0: # Get the oldest registered users that are disabled disabled = DisabledUser.objects.all().order_by('user__created') # If disabled, don't limit, and so just enable ALL of them if not disable_dlu: disabled = disabled[:(limit-1)] users = disabled.user_set user_set.update(disabled=False) if options['comma']: sep = "," else: sep = "\n" emails = [] if options['emails']: print "IDs:" print sep.join(email for obj.email in users.all()) ids = [] if options['ids']: print "Emails:" print sep.join(id for obj.id in users.all()) disabled.delete() print "%d users enabled." % (limit,) else: print "No users to enable.\nEither all users are enabled, or settings.MAX_USER_REGISTRATIONS is too low."
def install(self, args): node_settings = self._collect_settings(args) if not os.path.isdir(NODEBOW_ROOT): raise CommandError("The folder '{0}' does not exists") self.stdout.write("Installing into {0}".format( os.path.join(NODEBOW_ROOT, 'node_modules'))) curdir = os.getcwd() os.chdir(NODEBOW_ROOT) for app, settings in node_settings.items(): dependencies = [ '{0}#{1}'.format(p, v) for p, v in settings.get('dependencies', {}).items() ] if self.verbosity > 0: self.stdout.write("Packages for {0}: {1}".format( app, ', '.join(dependencies))) retval = self.npm('install', dependencies) print retval if self.development: dependencies = [ '{0}#{1}'.format(p, v) for p, v in settings.get('devDependencies', {}).items() ] retval = self.npm('install', dependencies) print retval os.chdir(curdir)
def setupTransform(request, response, runtrace=False): # Obtain settings. Do nothing if not found settings = getSettings() # Apply theme transform = None if not DevelopmentMode: transform = CACHE.get(0) if transform is None: transform = compileThemeTransform( rules=settings.get('rules'), absolutePrefix=settings.get('prefix') or None, read_network=settings.get('read_network'), parameterExpressions=settings.get('parameter_expressions'), runtrace=runtrace ) if transform is None: return None if not DevelopmentMode: CACHE[0] = transform return transform
def _get_application(self, version, app): settings = self.settings[version] settings_exclude = settings.get('exclude', {}) if app in settings_exclude: raise NotRegistered("No such application label: %s" % app) settings_app = settings.get('apps', {}).get(app, {}) ret = {} try: config = apps.get_app_config(app) ret = { 'label': config.label, 'verbose_name': config.verbose_name, } except LookupError: pass for n in settings_app: ret[n] = settings_app[n] ret['label'] = app if not ret: raise NotRegistered("No such application label: %s" % app) ret['models'] = self._get_application_models(version, app) return ret
def handle_settings(self, settings): """ Handle setting results Args: (String) name - unique name for switch. Returns: (Bool) - True, if a setting had an effect, False otherwise """ currency_settings = settings.get("api", {}).get("settings", {}).get("currency", None) currency_change = self._currency_handler(currency_settings) cost_type_settings = settings.get("api", {}).get("settings", {}).get("cost_type", None) cost_type_change = self._cost_type_handler(cost_type_settings) tg_mgmt_settings = settings.get("api", {}).get("settings", {}).get("tag-management", {}) tags_change = self._tag_key_handler(tg_mgmt_settings) if tags_change or currency_change or cost_type_change: return True return False
def load_settings(self, settings): try: self.period = int(settings.get('period')) except TypeError: self.period = 0 self.credential = settings.get('credential') self.storage = ModuleCredentialStorage(self.model) self.counter = settings.get('counter')
def load_settings(self, settings): try: self.period = int(settings.get("period")) except TypeError: self.period = 0 self.credential = settings.get("credential") self.storage = ModuleCredentialStorage(self.model) self.counter = settings.get("counter")
def load_settings(self, settings): try: self.period = int(settings.get('period')) except TypeError: self.period = 0 self.access_token = settings.get('access_token') self.expires_in = settings.get('expires_in') self.token_type = settings.get('token_type') self.counter = settings.get('counter')
def get_db_settings(): settings = ogc_server_settings.datastore_db return { 'db_name': settings.get('NAME'), 'user': settings.get('USER'), 'password': settings.get('PASSWORD'), 'host': settings.get('HOST', 'localhost'), 'port': settings.get('PORT', 5432), }
def load_settings(self, settings): try: self.period = int(settings.get("period")) except TypeError: self.period = 0 self.access_token = settings.get("access_token") self.expires_in = settings.get("expires_in") self.token_type = settings.get("token_type") self.counter = settings.get("counter")
def load_settings(self, settings): try: self.period = int(settings.get('period')) except TypeError: self.period = 0 self.access_token = settings.get('access_token') self.expires_in = settings.get('expires_in') self.token_type = settings.get('token_type') self.counter = settings.get('counter')
def __init__(self, settings, attrs=None, using=None, **js_options): self.settings = settings self.db = using self.js_options = { 'source': settings.get('source'), 'multiple': settings.get('multiple', False), 'force_selection': settings.get('force_selection', True), } self.js_options.update(js_options) super(AutocompleteWidget, self).__init__(attrs)
def _issue_system_tweet(self, event, settings, site_profile): kind = event.kind tweet = None append_url = bool(settings.get('append_url')) if kind == 'drink_poured': if not settings.get('tweet_drink_events'): self.logger.info('Skipping system tweet for drink event %s: disabled by settings.' % event.id) return elif not event.user and not settings.get('include_guests'): self.logger.info('Skipping system tweet for event %s: guest pour.' % event.id) return template = settings.get('drink_poured_template') elif kind == 'session_started': if not settings.get('tweet_session_events'): self.logger.info('Skipping system tweet for session start event %s: disabled by settings.' % event.id) return template = settings.get('session_started_template') elif kind == 'session_joined': if not settings.get('tweet_session_events'): self.logger.info('Skipping system tweet for session join event %s: disabled by settings.' % event.id) return template = settings.get('session_joined_template') append_url = bool(settings.get('append_url')) tweet = self._compose_tweet(event, template, append_url) if tweet: self._schedule_tweet(tweet, site_profile)
def update_settings(self, settings, update_club=False): """ 更新设置 :param settings dict like object :param update_club Boolean, whether to update the club object """ if update_club: self.club.update_settings(settings) self.show_nick_name = settings.get("show_nick_name", self.show_nick_name) != u"0" self.no_disturbing = settings.get("no_disturbing", self.no_disturbing) != u"0" self.always_on_top = settings.get("always_on_top", self.always_on_top) != u"0" self.nick_name = settings.get("nick_name", self.nick_name) self.save()
def populate_settings(self, settings): project_settings = self.project.settings project_settings.team_communication = settings.get( 'team_communication') project_settings.ask_to_ecosystem = settings.get('ask_to_ecosystem') project_settings.launch['send_welcome_consultant'] = settings.get( 'send_welcome_consultant') project_settings.launch['send_welcome_participant'] = settings.get( 'send_welcome_participant') project_settings.launch['default_password'] = get_user_model( ).objects.make_random_password() project_settings.save()
def create_new_discovered_dongle(address, settings): logger.info("going to setup as scanner") priority = settings.get('value', 1) enabled = settings.get('enable', True) name = settings.get('name', _("Auto Discovered Dongle")) obj, created = ScannerBluetoothDongle.objects.get_or_create( address=address, defaults={ 'priority': priority, 'enabled': enabled, 'name': name }) logger.debug("%s %s[%s]" % (address, name, priority))
def create_new_discovered_dongle(address, settings): logger.info("going to setup as scanner") priority = settings.get('value', 1) enabled = settings.get('enable', True) name = settings.get('name', _("Auto Discovered Dongle")) obj, created = ScannerBluetoothDongle.objects.get_or_create( address=address, defaults={ 'priority': priority, 'enabled': enabled, 'name': name }) logger.debug("%s %s[%s]" % (address, name, priority))
def render(self, context): if settings.get("DISABLE_TRACKING_CODE", False): return "" html = SETUP_CODE.format(property_id=self.property_id, ) if is_internal_ip(context, 'GOOGLE_ANALYTICS'): html = disable_html(html, 'Google Analytics') return html
def get_success_url(self): """ After logout, determine where to send the user afterwards. this isn't as simple as it seems. If success_url is set on the class, then you're getting sent their no matter what. Otherwise, see if it's in the query string. If not in the query string, attempt to reverse the LoginView, Finally, go to the settings to find the logout url. @note: urlparse is used to ensure no redirect to a different host @return: The url to redirect to. @rtype: C{str} """ redirect_to = getattr(self, 'success_url', None) if not redirect_to: redirect_to = self.request.REQUEST.get(self.redirect_field_name, None) if not redirect_to: redirect_to = reverse(LoginView.__name__) # Security Check -- don't allow redirection to a different host netloc = urlparse.urlparse(redirect_to)[1] if not redirect_to: redirect_to = settings.get(LOGOUT_REDIRECT_URL, None) elif netloc and netloc != request.get_host(): redirect_to = settings.LOGOUT_REDIRECT_URL return redirect_to
def languages(request): try: # A user needs to be authenticated to be able to contribute a record the DataFinder # Test if the user is now a university authenticated user if 'DF_USER_SSO_ID' not in request.session: return redirect("/login?redirectPath=contribute") #context = {} languages = [] tmp=[] languages_xml_file_path = settings.get("main:granary.languages_path") languages_xml_filename = os.path.join(languages_xml_file_path, 'languages-iso-639.xml') tree = ET.parse(languages_xml_filename) for elem in tree.iter(): if request.GET['lang'].lower() in elem.text.lower(): if elem.text[:len(request.GET['lang'])].lower() == request.GET['lang'].lower() : languages.append(elem.text) else: tmp.append(elem.text) languages.sort(); tmp.sort(); languages = languages + tmp; return HttpResponse(json.dumps(languages), mimetype="application/json") #return render_to_response('contribute.html', context, context_instance=RequestContext(request)) # elif http_method == "POST": # return render_to_response('contribute.html', context, context_instance=RequestContext(request)) except Exception, e: raise
def handle_new_event(self, event): self.logger.info('Handling new event: %s' % event.id) user = event.user if event.kind != 'drink_poured': self.logger.info('Ignoring event: not session_joined.') return if not user: self.logger.info('Ignoring event: anonymous.') return if util.is_stale(event.time): self.logger.info('Ignoring event: stale.') return token = self.get_user_token(user) if not token: self.logger.info('Ignoring event: no token for user %s.' % user.username) return settings = self.get_user_settings(user) if not settings or not settings.get('enable_checkins'): self.logger.info('Ignoring event: not enabled.') return venue_id = self.get_site_settings().get('venue_id') if not venue_id: self.logger.info('Ignoring event: no venue id.') return tasks.checkin.delay(token, venue_id)
def _make_expanded_field_serializer(self, name, nested_expand, nested_fields, nested_omit): """ Returns an instance of the dynamically created nested serializer. """ field_options = self._expandable_fields[name] if isinstance(field_options, tuple): serializer_class = field_options[0] settings = copy.deepcopy( field_options[1]) if len(field_options) > 1 else {} else: serializer_class = field_options settings = {} if name in nested_expand: settings["expand"] = nested_expand[name] if name in nested_fields: settings["fields"] = nested_fields[name] if name in nested_omit: settings["omit"] = nested_omit[name] if settings.get("source") == name: del settings["source"] if type(serializer_class) == str: serializer_class = self._import_serializer_class(serializer_class) return serializer_class(**settings)
def render(self, context): if settings.get("DISABLE_TRACKING_CODE", False): return "" widget_key = context.get('uservoice_widget_key') if not widget_key: widget_key = self.default_widget_key if not widget_key: return '' # default options = {} options.update(getattr(settings, 'USERVOICE_WIDGET_OPTIONS', {})) options.update(context.get('uservoice_widget_options', {})) identity = get_identity(context, 'uservoice', self._identify) if identity: identity = IDENTITY % {'options': json.dumps(identity, sort_keys=True)} trigger = context.get('uservoice_add_trigger', getattr(settings, 'USERVOICE_ADD_TRIGGER', True)) html = TRACKING_CODE % {'widget_key': widget_key, 'options': json.dumps(options, sort_keys=True), 'trigger': TRIGGER if trigger else '', 'identity': identity if identity else ''} return html
def render(self, context): if settings.get("DISABLE_TRACKING_CODE", False): return "" commands = [] identity = get_identity(context, 'mixpanel') if identity is not None: if isinstance(identity, dict): commands.append(IDENTIFY_CODE % identity.get('id', identity.get('username'))) commands.append(IDENTIFY_PROPERTIES % json.dumps(identity, sort_keys=True)) else: commands.append(IDENTIFY_CODE % identity) try: name, properties = context[EVENT_CONTEXT_KEY] commands.append( EVENT_CODE % { 'name': name, 'properties': json.dumps(properties, sort_keys=True), }) except KeyError: pass html = TRACKING_CODE % { 'token': self._token, 'commands': " ".join(commands), } if is_internal_ip(context, 'MIXPANEL'): html = disable_html(html, 'Mixpanel') return mark_safe(html)
def get_builtin(cls, name): m = import_module('okerrui.models') codes = settings.get('BONUS_CODES', {}) #codes = { # 'ReleasePromo2019': { # 'group': 'AlcorPromo', # 'time': 86400 * 365, # 'expires': datetime.datetime.strptime("2020-12-31", "%Y-%m-%d") # } #} if not name in codes: return None c = codes[name] expiration = c['expires'] expiration = expiration.replace(tzinfo=pytz.UTC) bc = BonusCode() bc.group = m.Group.objects.get(name=c['group']) bc.name = name bc.time = c['time'] bc.expires = expiration bc.builtin = True return bc
def send_email(to, subject, content): try: sg = sendgrid.SendGridAPIClient( api_key=settings.get('SENDGRID_API_KEY')) from_email = Email(settings.get('DEFAULT_FROM_EMAIL')) to_email = To(to) html_content = HtmlContent(content) mail = Mail(from_email, to_email, subject, html_content) response = sg.client.mail.send.post(request_body=mail.get()) if response.status_code == 200: return True return False except Exception as e: raise SendEmailError(e)
def post(self, request, user, user_social_auth): if request.is_ajax(): profile = user.profile access_token = user_social_auth.tokens.get("access_token") uid = user_social_auth.uid fields = ",".join(VK_DEFAULT_DATA + settings.get("VK_EXTRA_DATA", [])) params = {"access_token": access_token, "fields": fields, "uids": uid} raw_data = vk_api("users.get", params).get("response") if not raw_data: return HttpResponse(content=json.dumps({"ok": True}), content_type="text/javascript") data = raw_data[0] field = request.POST.get("field") if field == "first_name": field_value = data.get("first_name") if field_value and not (profile.first_name or profile.last_name or profile.middle_name): profile.first_name = field_value elif field == "phone_number": field_value = data.get("home_phone") if not profile.phone_number: profile.phone_number = field_value elif not profile.mobile_number: profile.mobile_number = field_value elif field == "skype": field_value = data.get("skype") profile.skype = field_value else: return HttpResponse(content=json.dumps({"ok": False}), content_type="text/javascript") profile.save() return HttpResponse( content=json.dumps({"ok": True, "field_value": field_value}), content_type="text/javascript" ) else: return HttpResponseBadRequest()
def _get_applications(self, version): settings = self.settings[version] settings_apps = settings.get('apps', {}) settings_exclude = settings.get('exclude', {}) ret = set([]) for config in apps.get_app_configs(): if config.label in settings_exclude: continue ret.add(config.label) for s in settings_apps: if not s in ret: ret.add(s) return list(ret)
def handle_event(self, event): self.logger.info('Handling new event: %s' % event.id) user = event.user if event.kind != event.DRINK_POURED: self.logger.info('Ignoring event: not %s.' % event.DRINK_POURED) return if user.is_guest(): self.logger.info('Ignoring event: guest.') return if util.is_stale(event.time): self.logger.info('Ignoring event: stale.') return token = self.get_user_token(user) if not token: self.logger.info('Ignoring event: no token for user %s.' % user.username) return settings = self.get_user_settings(user) if not settings or not settings.get('enable_checkins'): self.logger.info('Ignoring event: not enabled.') return venue_id = self.get_venue_id() if not venue_id: self.logger.info('Ignoring event: no venue id.') return with SuppressTaskErrors(self.logger): tasks.foursquare_checkin.delay(token, venue_id)
def handle_new_event(self, event): self.logger.info('Handling new event: %s' % event.id) user = event.user if event.kind != 'drink_poured': self.logger.info('Ignoring event: not session_joined.') return if not user: self.logger.info('Ignoring event: anonymous.') return if util.is_stale(event.time): self.logger.info('Ignoring event: stale.') return token = self.get_user_token(user) if not token: self.logger.info('Ignoring event: no token for user %s.' % user.username) return settings = self.get_user_settings(user) if not settings or not settings.get('enable_checkins'): self.logger.info('Ignoring event: not enabled.') return venue_id = self.get_site_settings().get('venue_id') if not venue_id: self.logger.info('Ignoring event: no venue id.') return tasks.checkin.delay(token, venue_id)
def authentication_classes(self): """ List of authentication classes to check for this view. """ if settings.get("TOKEN_AUTH_DISABLED", False): return [RegistryAuthentication] return [TokenAuthentication]
def render(self, context): if settings.get("DISABLE_TRACKING_CODE", False): return "" custom_variables = context.get('matomo_vars', ()) complete_variables = (var if len(var) >= 4 else var + (DEFAULT_SCOPE, ) for var in custom_variables) variables_code = (VARIABLE_CODE % MatomoVar(*var)._asdict() for var in complete_variables) commands = [] if getattr(settings, 'MATOMO_DISABLE_COOKIES', False): commands.append(DISABLE_COOKIES_CODE) userid = get_identity(context, 'matomo') if userid is not None: variables_code = chain(variables_code, (IDENTITY_CODE % { 'userid': userid }, )) html = TRACKING_CODE % { 'url': self.domain_path, 'siteid': self.site_id, 'variables': '\n '.join(variables_code), 'commands': '\n '.join(commands) } if is_internal_ip(context, 'MATOMO'): html = disable_html(html, 'Matomo') return html
def authenticate(self, request): """ Check that the provided Bearer token specifies access. """ if settings.get("TOKEN_AUTH_DISABLED", False): return (AnonymousUser(), True) try: authorization_header = request.headers["Authorization"] except KeyError: # No authorization return None if not authorization_header.lower().startswith(self.keyword.lower() + " "): # Not our type of authorization return None token = authorization_header[len(self.keyword) + 1:] try: decoded_token = _decode_token(token) except jwt.exceptions.InvalidTokenError: raise AuthenticationFailed( detail="Access to the requested resource is not authorized. " "A provided Bearer token is invalid.", ) username = decoded_token.get("sub") if username: try: user = User.objects.get(username=username) except User.DoesNotExist: raise AuthenticationFailed("No such user") else: user = AnonymousUser() return (user, decoded_token)
def render(self, context): if settings.get("DISABLE_TRACKING_CODE", False): return "" html = TRACKING_CODE % {'site_id': self.site_id} if is_internal_ip(context, 'GAUGES'): html = disable_html(html, 'Gauges') return html
def permission_classes(self): """ List of permission classes to check for this view. """ if settings.get("TOKEN_AUTH_DISABLED", False): return [IsAuthenticated] return [TokenPermission]
def render(self, context): if settings.get("DISABLE_TRACKING_CODE", False): return "" html = TRACKING_CODE % {'tracker_id': self.tracker_id} if is_internal_ip(context, 'CLICKMAP'): html = disable_html(html, 'Clickmap') return html
def handle_new_events(self, events): for event in events: self.logger.info('Handling new event: %s' % event.id) user = event.user if event.kind != event.DRINK_POURED: self.logger.info('Ignoring event: not %s.' % event.DRINK_POURED) return if user.is_guest(): self.logger.info('Ignoring event: guest.') return if util.is_stale(event.time): self.logger.info('Ignoring event: stale.') return token = self.get_user_token(user) if not token: self.logger.info('Ignoring event: no token for user %s.' % user.username) return settings = self.get_user_settings(user) if not settings or not settings.get('enable_checkins'): self.logger.info('Ignoring event: not enabled.') return venue_id = self.get_venue_id() if not venue_id: self.logger.info('Ignoring event: no venue id.') return with SuppressTaskErrors(self.logger): tasks.foursquare_checkin.delay(token, venue_id)
def get_fields(self): settings = self.get_settings() default_fields = [ 'id', 'email', 'name', 'first_name', 'last_name', 'verified', 'locale', 'timezone', 'link', 'gender', 'updated_time' ] return settings.get('FIELDS', default_fields)
def render(self, context): if settings.get("DISABLE_TRACKING_CODE", False): return "" html = TRACKING_CODE % {'portal_id': self.portal_id} if is_internal_ip(context, 'HUBSPOT'): html = disable_html(html, 'HubSpot') return html
def post(self, request, *args, **kwargs): form = self.form_class(request.POST) if form.is_valid(): cd = form.cleaned_data if form.check_md5(cd): payment = self.get_payment(cd) if payment: try: self.validate(cd, payment) except YandexValidationError as exc: params = exc.params else: params = self.get_response_params(payment, cd) self.mark_payment(payment, cd) payment.send_signals() else: params = {'code': '1000'} else: params = {'code': '1'} else: params = {'code': '200'} self.logging(request, params) content = self.get_xml(params) if ( settings.get('YANDEX_MONEY_MAIL_ADMINS_ON_PAYMENT_ERROR', True) and params.get('code') != '0' ): mail_admins('yandexmoney_django error', u'post data: {post_data}\n\nresponse:{response}'.format( post_data=request.POST, response=content, )) return HttpResponse(content, content_type='application/xml')
def recipients(self): emails = [] for subscription in self.project.subscriptions.all(): if subscription.notification_strategy == Subscription.NOTIFY_ON_CHANGE: if not self.previous_build or not self.diff: continue elif subscription.notification_strategy == Subscription.NOTIFY_ON_REGRESSION: if not self.previous_build or \ len(self.comparison.regressions) == 0: continue elif subscription.notification_strategy == Subscription.NOTIFY_ON_ERROR: if not self.project.project_settings: logger.warn( 'CI_LAVA_JOB_ERROR_STATUS not set in project settings. Notification will not be sent for project %s, build %s.' % (self.project.full_name, self.build.version)) continue settings = yaml.safe_load(self.project.project_settings) or {} error_status = settings.get('CI_LAVA_JOB_ERROR_STATUS', None) if not error_status: logger.warn( 'CI_LAVA_JOB_ERROR_STATUS not set in project settings. Notification will not be sent for project %s, build %s.' % (self.project.full_name, self.build.version)) continue if len(self.build.test_jobs.filter( job_status=error_status)) == 0: continue email = subscription.get_email() if email: emails.append(email) return emails
def clippy(htmlElementId, bgcolor='#ffffff'): static_url = settings.STATIC_URL if not bgcolor: bgcolor = settings.get('CLIPPY_BGCOLOR', '#ffffff') return\ """<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="14" height="14" id="clippy_%(htmlElementId)s" > <param name="movie" value="%(static_url)sswf/clippy.swf"/> <param name="allowScriptAccess" value="always" /> <param name="quality" value="high" /> <param name="scale" value="noscale" /> <param NAME="FlashVars" value="id=%(htmlElementId)s"> <param name="bgcolor" value="%(bgcolor)s"> <embed src="%(static_url)sswf/clippy.swf?x=23" width="14" height="14" name="clippy" quality="high" allowScriptAccess="always" type="application/x-shockwave-flash" pluginspage="http://www.macromedia.com/go/getflashplayer" FlashVars="id=%(htmlElementId)s" bgcolor="%(bgcolor)s" /> </object>""" % locals()
def handle_new_events(self, events): for event in events: self.logger.info('Handling new event: %s' % event.id) settings = self.get_site_settings() urls = settings.get('webhook_urls', '').strip().split() for url in urls: with SuppressTaskErrors(self.logger): tasks.webhook_post.delay(url, event)
def _get_locale_callable(self): settings = self.get_settings() f = settings.get('LOCALE_FUNC') if f: f = import_callable(f) else: f = get_default_locale_callable() return f
def get_init_params(self, request, app): init_params = { 'appId': app.client_id, 'version': GRAPH_API_VERSION } settings = self.get_settings() init_params.update(settings.get('INIT_PARAMS', {})) return init_params
def api(request): app = request.REQUEST.get("app") client = request.REQUEST.get("client") operation = request.REQUEST.get("op") mode = request.REQUEST.get("mode") data = request.REQUEST.get("data", {"none":None}) if not all([app,client,operation, mode, data]): return MyApi = OsmApi.OsmApi(username = settings.get("osm_user"), password = settings.get("osm_pass")) if operation == "write": MyApi.ChangesetCreate({u"comment": u"OsmApp Upload"}) MyApi.ChangesetClose() else: OVERPASS_STRING=""" <osm-script output="json" timeout="25"> <!-- gather results --> <union> <!-- query part for: "vending=condoms" --> <query type="node"> <has-kv k="vending" v="condoms"/> <bbox-query {{bbox}}/> </query> <query type="way"> <has-kv k="vending" v="condoms"/> <bbox-query {{bbox}}/> </query> <query type="relation"> <has-kv k="vending" v="condoms"/> <bbox-query {{bbox}}/> </query> </union> <!-- print results --> <print mode="body"/> <recurse type="down"/> <print mode="skeleton" order="quadtile"/> </osm-script> """ pass
def get_wksetting(self, setting): """ returns the value of a well-known setting """ try: settings = json.loads(self.settings) except ValueError as ex: logger.warn("Decoding settings failed: {msg}".format(msg=str(ex))) return None return settings.get(setting.name, setting.default)
def install(self, args): node_settings = self._collect_settings(args) if not os.path.isdir(NODEBOW_ROOT): raise CommandError("The folder '{0}' does not exists") self.stdout.write("Installing into {0}".format(os.path.join(NODEBOW_ROOT, 'node_modules'))) curdir = os.getcwd() os.chdir(NODEBOW_ROOT) for app, settings in node_settings.items(): dependencies = ['{0}#{1}'.format(p, v) for p, v in settings.get('dependencies', {}).items()] if self.verbosity > 0: self.stdout.write("Packages for {0}: {1}".format(app, ', '.join(dependencies))) retval = self.npm('install', dependencies) print retval if self.development: dependencies = ['{0}#{1}'.format(p, v) for p, v in settings.get('devDependencies', {}).items()] retval = self.npm('install', dependencies) print retval os.chdir(curdir)
def get_fields(self): settings = self.get_settings() default_fields = [ 'id', 'email', 'name', 'first_name', 'last_name'] return settings.get('FIELDS', default_fields)
def make_connection_string(settings): db_name = settings['NAME'].strip() db_host = settings['HOST'] or '127.0.0.1' db_port = settings['PORT'] db_user = settings['USER'] db_password = settings['PASSWORD'] options = settings.get('OPTIONS', {}) if len(db_name) == 0: raise ImproperlyConfigured( "You need to specify a DATABASE NAME in your Django settings file.") # Connection strings courtesy of: # http://www.connectionstrings.com/?carrier=sqlserver # If a port is given, force a TCP/IP connection. The host should be an IP # address in this case. if db_port: if not is_ip_address(db_host): raise ImproperlyConfigured( "When using DATABASE PORT, DATABASE HOST must be an IP address.") try: db_port = int(db_port) except ValueError: raise ImproperlyConfigured("DATABASE PORT must be a number.") db_host = '{0},{1};Network Library=DBMSSOCN'.format(db_host, db_port) # If no user is specified, use integrated security. if db_user != '': auth_string = 'UID={0};PWD={1}'.format(db_user, db_password) else: auth_string = 'Integrated Security=SSPI' parts = [ 'DATA SOURCE={0};Initial Catalog={1}'.format(db_host, db_name), auth_string ] if not options.get('provider', None): options['provider'] = 'sqlncli10' parts.append('PROVIDER={0}'.format(options['provider'])) extra_params = options.get('extra_params', '') if 'sqlncli' in options['provider'].lower() and 'datatypecompatibility=' not in extra_params.lower(): # native client needs a compatibility mode that behaves like OLEDB parts.append('DataTypeCompatibility=80') if options.get('use_mars', True) and 'mars connection=' not in extra_params.lower(): parts.append('MARS Connection=True') if extra_params: parts.append(options['extra_params']) return ";".join(parts)
def handle_new_events(self, events): for event in events: self.logger.info('Handling new event: %s' % event.id) user = event.user if event.kind != event.DRINK_POURED: self.logger.info('Ignoring event: %s' % event.kind) return if user.is_guest(): self.logger.info('Ignoring event: anonymous.') return if util.is_stale(event.time): self.logger.info('Ignoring event: stale.') return token = self.get_user_token(user) if not token: self.logger.info('Ignoring event: no token for user %s.' % user.username) return settings = self.get_user_settings(user) if not settings or not settings.get('enable_checkins'): self.logger.info('Ignoring event: not enabled.') return beer_id = event.drink.keg.type.untappd_beer_id if not beer_id: self.logger.info('Ignoring event: no untappd beer id.') return shout = None if event.drink.shout: shout = event.drink.shout foursquare_venue_id = foursquare_client_id = foursquare_client_secret = None foursquare = plugin_util.get_plugins().get('foursquare') if foursquare: foursquare_client_id, foursquare_client_secret = foursquare.get_credentials() foursquare_venue_id = foursquare.get_venue_id() if foursquare_venue_id: self.logger.info('Adding location info, foursquare venue id: {}'.format(foursquare_venue_id)) else: self.logger.info('No Foursquare venue id, not adding location info.') else: self.logger.info('Foursquare not available, not adding location info.') timezone_name = timezone.get_current_timezone_name() with SuppressTaskErrors(self.logger): tasks.untappd_checkin.delay(token, beer_id, timezone_name, shout=shout, foursquare_client_id=foursquare_client_id, foursquare_client_secret=foursquare_client_secret, foursquare_venue_id=foursquare_venue_id)
def get_redirect_url(self, *args, **kwargs): if self.request.user.is_authenticated(): # user is already authenticated return getattr(settings, 'LOGIN_REDIRECT_URL', '/') elif not set(self.request.GET.keys()).intersection(['oauth_callback_confirmed', 'oauth_verifier']): # first step: redirect to Twitter auth URL client = UserClient( settings.CONSUMER_KEY, settings.CONSUMER_SECRET, ) token = client.get_signin_token( callback_url=settings.CALLBACK_URL ) self.request.session['temp_token'] = token.oauth_token self.request.session['temp_token_secret'] = token.oauth_token_secret return token.auth_url elif self.request.GET.get('oauth_callback_confirmed') and self.request.GET.get('oauth_callback_confirmed') != 'true': # user did not authorize the app messages.add_message( self.request, messages.WARNING, "<b>C'mon!</b>" ) elif self.request.GET.get('oauth_verifier'): # user authorized the app client = UserClient( settings.CONSUMER_KEY, settings.CONSUMER_SECRET, self.request.session['temp_token'], self.request.session['temp_token_secret'], ) token = client.get_access_token(self.request.GET.get('oauth_verifier')) user, created = User.objects.get_or_create( username=token['screen_name'], ) if created: app_name = settings.get('TWITTER_DEFAULT_APP') app = None if app_name: app, c = Application.objects.get_or_create(name=app_name) Token.objects.create( user=user, data=token, app=app, ) user.backend = 'django.contrib.auth.backends.ModelBackend' login(self.request, user) if getattr(settings, 'LOGIN_REDIRECT_URL'): return reverse(getattr(settings, 'LOGIN_REDIRECT_URL')) else: return '/'
def get_products(self): """ Return initial product queryset of products eligible for discount. Default implementation returns al products. Subclasses can override this method to filter products further, ie by category or exclude products that are on sale. """ product_class_string = settings.get('SHOP_PRODUCT_MODEL') product_class = __import__(product_class_string) return product_class.objects.all()
def isThemeEnabled(request, response, settings=None): """Determine if a theme is enabled for the given request """ # Disable theming if the response sets a header if response.get('X-Theme-Disabled', None): return False # Disable theming subrequest if getattr(request, 'diazo_subrequest', False): return False # Check for diazo.off request parameter if (DevelopmentMode and request.GET.get(u'diazo.off', u'').lower() in TRUE): return False if not settings.get('enabled') or not settings.get('rules'): return False return True
def __init__(self, request=None): # Only do webauth and issue cud-requests if the session variable not found if not request.session.has_key('DF_USER_SSO_ID'): user_logged_in_name = None df_user_sso_id = None if os.environ.has_key('DF_REMOTE_USER'): df_user_sso_id = os.environ.get('DF_REMOTE_USER') cud_authenticator = settings.get('main:cud_proxy.host') cudReq = CUDRequest(cud_proxy_host=cud_authenticator,filter= {'sso_username':df_user_sso_id}) user_logged_in_name = str(cudReq.get_fullName()) user_email = str(cudReq.get_email()) if not request.session.exists(request.session.session_key): request.session.create() #set up the session variables request.session['DF_USER_SSO_ID'] = df_user_sso_id request.session['DF_USER_FULL_NAME'] = user_logged_in_name request.session['DF_USER_EMAIL'] = user_email #Add the user to the database if already not registered try: users = Users.objects.filter(sso_id=df_user_sso_id) if len(users) == 0: request.session['DF_USER_ROLE'] = "user" newuser = Users() newuser.sso_id = request.session['DF_USER_SSO_ID'] newuser.username = request.session['DF_USER_FULL_NAME'] newuser.role = request.session['DF_USER_ROLE'] newuser.email = request.session['DF_USER_EMAIL'] newuser.save() else: for user in users: request.session['DF_USER_ROLE'] = user.role except Exception: self.authenticated=False request.session.modified = True # Save the session key in DFSessions try: usersession= DFSessions.objects.get(session_id=request.session.session_key) #usersession.session_id = request.session.session_key #usersession.save() except DFSessions.DoesNotExist,e: usersession = DFSessions() usersession.sso_id= request.session['DF_USER_SSO_ID'] usersession.session_id = request.session.session_key usersession.save() except Exception,e: logger.error("User session could not be saved in DF.")
def _toc(depth, toc_items, parent=None, toc_setting=None): items = [] sec_count = 1 for toc_item in toc_items: if isinstance(toc_item[1], list): section_title, chapters = toc_item url_title = booktype_slugify(section_title) key = 'section_%s_%s' % (url_title, sec_count) section_settings = json.loads(settings.get(key, '{}')) toc_setting = section_settings.get('toc', {}).get(self.name, '') # continue if the whole section should be hidden show_in_outputs = section_settings.get('show_in_outputs', {}) if show_in_outputs.get(self.name, 'true') == 'false': continue items += [{ 'type': 'section', 'level': depth, 'title': section_title, 'url_title': url_title, 'show_in_toc': 'hide_section' not in toc_setting }] items += _toc(depth + 1, chapters, section_title, toc_setting) sec_count += 1 else: chapter_title, chapter_href = toc_item chapter_item = book.get_item_with_href(chapter_href) content = self._get_chapter_content(chapter_item) content = self._fix_horrible_mpdf(content) href_filename, file_extension = os.path.splitext(chapter_href) if not parent: toc_setting = '' items.append({ 'type': 'chapter', 'level': depth, 'title': chapter_title, 'url_title': booktype_slugify(chapter_title), 'href': chapter_href, 'href_filename': href_filename, 'content': content, 'show_in_toc': 'hide_chapters' not in toc_setting }) return items
def get_fields(self): settings = self.get_settings() default_fields = [ 'id', 'email', 'name', 'first_name', 'last_name', 'verified', 'locale', 'timezone', 'link', 'gender', 'updated_time'] return settings.get('FIELDS', default_fields)