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)
