def _plain_send_mail(sender, recipient, subject, body): header_charset = 'ISO-8859-1' for body_charset in 'US-ASCII', 'ISO-8859-1', 'UTF-8': try: body.encode(body_charset) except UnicodeError: pass else: break sender_name, sender_addr = parseaddr(sender) recipient_name, recipient_addr = parseaddr(recipient) sender_name = str(Header(unicode(sender_name), header_charset)) recipient_name = str(Header(unicode(recipient_name), header_charset)) sender_addr = sender_addr.encode('ascii') recipient_addr = recipient_addr.encode('ascii') msg = MIMEText(body.encode(body_charset), 'plain', body_charset) msg['From'] = formataddr((sender_name, sender_addr)) msg['To'] = formataddr((recipient_name, recipient_addr)) msg['Subject'] = Header(unicode(subject), header_charset) smtp = SMTP(config.get('registration.smtp_host', 'localhost')) if config.get('registration.smtp_login'): try: smtp.starttls() except: pass smtp.login(config.get('registration.smtp_login'), config.get('registration.smtp_passwd')) smtp.sendmail(sender, recipient, msg.as_string()) smtp.quit()
def command(self): config=load_config(self.args) if self.options.export: f = open(config.get('starlogic.out'),'w') fs = open(config.get('starlogic.sincro')) sincro = 0 for i in fs.readlines(): sincro = i.strip() sincro = int(sincro) fs.close() ps = DBSession.query(Eanprodotti) if not self.options.all: ps = ps.filter(Eanprodotti.sincrofield>sincro) ps = ps.order_by(Eanprodotti.sincrofield).all() for p in ps: codart = p.prodotto.eans[0].ean desc = p.prodotto.prodotto.encode('ascii', 'ignore') prezzo = p.prodotto.prezzo sincro = p.sincrofield print >> f, "%s;%s;%s;%s;%s"%(codart, p.ean, desc, prezzo,0) if len(p.aliases)>0: for alias in p.aliases: print >> f, "%s;%s;%s;%s;%s"%(codart, alias.alias, desc, prezzo,1) f.close() f = open(config.get('starlogic.sincro'),'w') print >> f, sincro f.close()
def _toPrintshop( self, hdr, subject, content, files = [] ): defaultsendto = config.get( "default_email_sendto", "" ).split( ";" ) if hdr.printShopId and hdr.printShop.email: to = hdr.printShop.email else: to = [] sendto = defaultsendto + to cc = config.get( "default_email_cc", "" ).split( ";" ) if config.get( "sendout_email", None ) != 'F': sendEmail( DEFAULT_SENDER, sendto, subject, '\n'.join( content ), cc, files )
def _toVendor( self, hdr , subject, content, files = [] ): defaultsendto = config.get( "default_email_sendto", "" ).split( ";" ) if hdr.createBy.email_address: to = hdr.createBy.email_address.split( ";" ) else: to = [] sendto = defaultsendto + to cc = config.get( "default_email_cc", "" ).split( ";" ) if config.get( "sendout_email", None ) != 'F': sendEmail( DEFAULT_SENDER, sendto, subject, '\n'.join( content ), cc, files )
def grid(self, cls, **params): rp = get_paramw(params, 'rp', int, opcional=True, por_defecto=int(config.get('grid.default_rp', 10))) pag_n = get_paramw(params, 'pag_n', int, opcional=True, por_defecto=1) ds = self.grid_data(cls, **params) # Reading global settings ds.date_fmt = date_fmt ds.time_fmt = config.get('formats.time', default='%H:%M') ds.datetime_fmt = config.get('formats.datetime', default='%m/%d/%Y %H:%M') ds.true_const = _('Yes') ds.false_const = _('No') ds.float_fmt = app_cfg.format_float cols = [] for col in ds.labels: w = 850 / len(ds.labels) if col == 'id': w = 60 cols.append(dict(title=col, width=w, align='center')) this_page, total_pag = pagination(rp, pag_n, ds.count) return dict(status=True, cols=cols, data=ds.to_data(), this_page=this_page, total_count=ds.count, total_pag=total_pag)
def __init__(self, *args, **kw): super(ChatController, self).__init__(*args, **kw) self.config = {} backend = config.get('chat.backend') if not backend: log.info('No `chat.backend` defined; disabling chat functionality') return backend = urlparse.urlparse(backend) if hasattr(backend, 'scheme'): # Python 2.5+ self.config['backendProtocol'] = backend.scheme self.config['backendAddr'] = [backend.hostname, backend.port] else: # Python 2.4 self.config['backendProtocol'] = backend[0] host, port = backend[1].split(':') self.config['backendAddr'] = [host, port] self.config['startBuiltin'] = config.get('chat.builtin', False) self.config['rooms'] = {} display_opts = { 'floating': True, 'floatingToggle': False, 'width': 400 , 'height': 300, 'theme': 'simple', 'resizable': True, 'greeting': 'Moksha Chat', } for room in config['chat.rooms'].replace(',', ' ').split(): self.config['rooms'][room] = {'display': {}} for display_opt, default in display_opts.items(): self.config['rooms'][room]['display'][display_opt] = \ config.get('chat.%s.display.%s' % (room, display_opt), default) self.config['rooms'][room]['roomAssignmentMode'] = \ config.get('chat.%s.roomAssignmentMode' % room, 'static') self.config['rooms'][room]['staticRoomName'] = \ config.get('chat.%s.staticRoomName' % room, room) log.debug('Chat config = %r' % self.config)
def export(self, **kw): try: current = dt.now() dateStr = current.strftime("%Y%m%d") fileDir = os.path.join(config.get("public_dir"), "report", 'ci', dateStr) if not os.path.exists(fileDir): os.makedirs(fileDir) templatePath = os.path.join(config.get("public_dir"), 'TEMPLATE', "CI_TEMPLATE.xlsx") tempFileName = os.path.join(fileDir, "tmp_%s.xlsx" % current.strftime("%Y%m%d%H%M%S")) realFileName = os.path.join(fileDir, "inventory_report_%s.xlsx" % current.strftime("%Y%m%d%H%M%S")) shutil.copy(templatePath, tempFileName) report_xls = InventoryExcel(templatePath=tempFileName, destinationPath=realFileName) data = [] if kw: data = self._query_ci_result(kw) report_xls.inputData(data=data) report_xls.outputData() try: os.remove(tempFileName) except: pass return serveFile(unicode(realFileName)) except: traceback.print_exc() flash("Export Fail.") redirect("/cireport/index")
def after_init_config(self): from tg import config as tgconf if tgconf.get('debug', False): # Always show warnings for the sauce module import warnings warnings.filterwarnings(action='once', module='sauce') warnings.filterwarnings(action='once', module='.*mak') _locale = tgconf.get('locale') try: locale.setlocale(locale.LC_ALL, _locale) except Exception: # pragma: no cover log.exception('Could not set locale: %s', _locale) else: log.debug('Locale set to: %s', _locale) for fmt in ('D_FMT', 'T_FMT', 'D_T_FMT'): fmtstr = tgconf.get(fmt, None) if fmtstr: # Self-baked %-escaping fmtstr = fmtstr.replace('%%', '%') if not fmtstr: fmtstr = locale.nl_langinfo(getattr(locale, fmt)) log.debug('Format string for %s read from locale: %s', (fmt, fmtstr)) setattr(tgconf, fmt, fmtstr)
def _check_context(self, parsed_args): if config.get('auth_type') == LDAPAuth.name: auth_instance = config.get('auth_instance') if not auth_instance.ldap_auth.user_exist(parsed_args.login): raise LDAPUserUnknown( "LDAP is enabled and user with login/email \"%s\" not found in LDAP" % parsed_args.login )
def register(cls): cls._base_url = config.get('fedoracommunity.connector.kojihub.baseurl', 'http://koji.fedoraproject.org/kojihub') cls._koji_url = config.get('fedoracommunity.connector.koji.baseurl', 'http://koji.fedoraproject.org/koji') cls._koji_pkg_url = config.get( 'fedoracommunity.connector.koji.pkgurl', 'http://koji.fedoraproject.org/packages') cls._rpm_cache = config.get('fedoracommunity.rpm_cache', None) if not cls._rpm_cache: print "You must specify fedoracommunity.rpm_cache in you .ini file" exit(-1) cls.register_query_builds() cls.register_query_packages() cls.register_query_changelogs() cls.register_query_provides() cls.register_query_requires() cls.register_query_conflicts() cls.register_query_obsoletes() cls.register_method('get_error_log', cls.call_get_error_log) cls.register_method( 'get_latest_changelog', cls.call_get_latest_changelog) cls.register_method('get_file_tree', cls.call_get_file_tree)
def sendmail(to_addrs, subject, text): server = config.get('smtp_server') use_tls = asbool(config.get('smtp_use_tls')) username = config.get('smtp_username') password = config.get('smtp_password') from_addr = config.get('admin_email_from') log.debug('Sending mail via %s' % server) if use_tls: s = SMTP_SSL() else: s = SMTP() s.connect(server) if username: s.login(username, password) msg = MIMEText(text, _charset='utf-8') msg['From'] = from_addr msg['Reply-To'] = from_addr if isinstance(to_addrs, basestring): msg['To'] = to_addrs else: msg['To'] = ', '.join(to_addrs) msg['Subject'] = subject s.sendmail(from_addr, to_addrs, msg.as_string()) s.quit()
def export(self, **kw): try: current = dt.now() dateStr = current.strftime("%Y%m%d") fileDir = os.path.join(config.get("public_dir"), "report", 'ir', dateStr) if not os.path.exists(fileDir): os.makedirs(fileDir) templatePath = os.path.join(config.get("public_dir"), 'TEMPLATE', "IR_TEMPLATE.xlsx") tempFileName = os.path.join(fileDir, "tmp_%s.xlsx" % current.strftime("%Y%m%d%H%M%S")) realFileName = os.path.join(fileDir, "item_received_report_%s.xlsx" % current.strftime("%Y%m%d%H%M%S")) shutil.copy(templatePath, tempFileName) report_xls = InventoryExcel(templatePath=tempFileName, destinationPath=realFileName) data = [] if kw: rItems = self._query_ir_result(kw) for rItem in rItems: data.append((rItem.warehouse.name, rItem.createTime, rItem.item.item_number, rItem.qty, rItem.issuedBy.__unicode__())) report_xls.inputData(data=data) report_xls.outputData() try: os.remove(tempFileName) except: pass return serveFile(unicode(realFileName)) except: traceback.print_exc() flash("Export Fail.") redirect("/irreport/index")
def recover_user_password(user): key = user.generate_recover_key(request.remote_addr) text = u"""Hi %s, you have asked to recover your password (from IP %s). To enter a new password, click on the following link: http://skylines.xcsoar.org/users/recover?key=%x The SkyLines Team """ % (unicode(user), request.remote_addr, key) msg = email.mime.text.MIMEText(text.encode('utf-8'), 'plain', 'utf-8') msg['Subject'] = 'SkyLines password recovery' msg['From'] = config.get('email_from', '*****@*****.**') msg['To'] = user.email_address.encode('ascii') msg['Date'] = email.Utils.formatdate(localtime=1) try: smtp = smtplib.SMTP(config.get('smtp_server', 'localhost')) smtp.ehlo() smtp.sendmail(config.get('email_from', '*****@*****.**').encode('ascii'), user.email_address.encode('ascii'), msg.as_string()) smtp.quit() except: raise HTTPServiceUnavailable(explanation=_( "The mail server is currently not reachable. " "Please try again later or contact the developers."))
def export(page, plugins_data): buf = StringIO() quoting = config.get('csv_quoting', 'ALL').upper() if quoting not in ('ALL', 'MINIMAL', 'NONNUMERIC', 'NONE'): quoting = 'ALL' csv_writer = csv.DictWriter(buf, config['csv_columns'], extrasaction='ignore', delimiter=config.get("csv_delimiter_char", ';'), escapechar=config.get("csv_escape_char", '\\'), quotechar=config.get("csv_quote_char", '"'), quoting=getattr(csv, 'QUOTE_%s' % quoting)) csv_writer.writerow(dict(zip(config['csv_columns'], config['csv_columns']))) for item in page.items: values = {} for plugin_name, plugin_instance in config['columns_plugins']: if plugins_data[plugin_name]: values[plugin_name] = repr(plugins_data[plugin_name]) else: for data_key, data_value in \ plugin_instance.get_data(item).iteritems(): # Pour les valeurs en unicode, on convertit en UTF-8. if isinstance(data_value, unicode): values[data_key] = data_value.encode('utf-8') # Pour le reste, on suppose qu'on peut en obtenir une # représentation adéquate dont l'encodage ne posera pas # de problème. else: values[data_key] = data_value csv_writer.writerow(values) return buf.getvalue()
def nav_logo(self): logo = dict( redirect_link=config.get('logo.link', False), image_path=config.get('logo.path', False), image_width=config.get('logo.width', False), image_height=config.get('logo.height', False) ) if not logo['redirect_link']: logo['redirect_link'] = '/' if not logo['image_path']: log.warning('Image path not set for nav_logo') return False allura_path = os.path.dirname(os.path.dirname(__file__)) image_full_path = '%s/public/nf/images/%s' % ( allura_path, logo['image_path']) if not os.path.isfile(image_full_path): log.warning('Could not find logo at: %s' % image_full_path) return False path = 'images/%s' % logo['image_path'] return { "image_path": self.forge_static(path), "redirect_link": logo['redirect_link'], "image_width": logo['image_width'], "image_height": logo['image_height'] }
def load_results_page(self, beg_date, end_date): log.debug("Trying to load page 1 of ??") # Login page # TODO -- there are about 6 other counties we can scrape here. url = '%s/NY-Monroe/' % self.base self.browser.open(url) self.browser.follow_link(url_regex=re.compile('.*loginForm.*')) self.browser.select_form(nr=0) self.browser.form['txtUserName'] = config.get('propertyinfo.username') self.browser.form['txtPassword'] = config.get('propertyinfo.password') self.browser.submit() # Load search page and input criteria self.browser.follow_link(url_regex=re.compile('.*=2004.*')) self.browser.select_form(name='frmSavedCriteria') self.set_hidden_form_value('SearchbyDateFrom', beg_date) self.set_hidden_form_value('SearchbyDateTo', end_date) # TODO -- there are lots of other doc types we can get here. self.set_hidden_form_value('SearchDocType', "NOTICE OF PENDENCY MORTGAGE FORECLOSURE") self.browser.form.action = '%s/wam3/SearchSummary.asp' % self.apps_base self.browser.submit() # Follow an implicit redirect try: # which, however, will shit the bed if there are no results self.browser.select_form(name='frmResult') self.browser.submit() except mechanize._mechanize.FormNotFoundError: log.debug("No results found for %s to %s" % (beg_date, end_date)) return None
def _generator(): while True: from pymongo import MongoClient from tg import config client = MongoClient("%s%s" % (config.get('ming.url'), config.get('ming.db'))) db = client.spacehackaton ''' data_to_deactivate = db.node.find( { 'update_time': { '$lt': datetime.datetime.utcnow()-datetime.timedelta(seconds=10) } } ) for item_to_deactivate in data_to_deactivate: db.node.update({'name': item_to_deactivate.get('name')}, {'$set': {'status': 'INACTIVE'}}) ''' data_to_return = db.node.find() json_data = json.dumps([self.to_json(x) for x in data_to_return], sort_keys=True, indent=4, default=json_util.default) event = "data: %s\n\n" % json.loads(json_data) sleep(1) #print "Nodes", event.replace("u'", "'").replace("'", "\"") client.close() yield event.replace("u'", "'").replace("'", "\"").encode('utf-8')
def __call__(self): lang = init_lang() vars_ = dict(display_name=self.u.display_name, user_name=self.u.user_name, new_password=self.new_password, app_title=config.get('mail.name').decode('utf-8'), ) asunto = self.env.get_template('sapns/users/forgot_password/%s/subject.txt' % lang) asunto = asunto.render(**vars_).encode('utf-8') mensaje = self.env.get_template('sapns/users/forgot_password/%s/message.txt' % lang) mensaje = mensaje.render(**vars_).encode('utf-8') mensaje_html = self.env.get_template('sapns/users/forgot_password/%s/message.html' % lang) mensaje_html = mensaje_html.render(**vars_).encode('utf-8') email_login = config.get('mail.user') email_password = config.get('mail.password') # send e-mail send_mail(self.remitente, self.dst, asunto, mensaje, config.get('mail.smtp'), email_login, email_password, html=mensaje_html)
def zarkov_event(self, event_type, user=None, neighborhood=None, project=None, app=None, extra=None): context = dict(user=None, neighborhood=None, project=None, tool=None, mount_point=None, is_project_member=False) if not config.get("zarkov.host"): return user = user or getattr(c, "user", None) project = project or getattr(c, "project", None) app = app or getattr(c, "app", None) if user: context["user"] = user.username if project: context.update(project=project.shortname, neighborhood=project.neighborhood.url_prefix.strip("/")) if user: cred = Credentials.get() if cred is not None: for pr in cred.user_roles(user._id, project._id).reaching_roles: if pr.get("name") and pr.get("name")[0] != "*": context["is_project_member"] = True if app: context.update(tool=app.config.tool_name, mount_point=app.config.options.mount_point) try: if self._zarkov is None: self._zarkov = ZarkovClient(config.get("zarkov.host", "tcp://127.0.0.1:6543")) self._zarkov.event(event_type, context, extra) except Exception, ex: self._zarkov = None log.error("Error sending zarkov event(%r): %r", ex, dict(type=event_type, context=context, extra=extra))
def test_register_private_ok(self): r = self.app.post( '/p/register', params=dict( project_unixname='mymoz', project_name='My Moz', project_description='', neighborhood='Projects', private_project='on', tools='wiki'), antispam=True, extra_environ=dict(username='******'), status=302) assert config.get('auth.login_url', '/auth/') not in r.location, r.location r = self.app.get( '/p/mymoz/wiki/', extra_environ=dict(username='******')).follow(extra_environ=dict(username='******'), status=200) r = self.app.get( '/p/mymoz/wiki/', extra_environ=dict(username='******'), status=302) assert config.get('auth.login_url', '/auth/') in r.location, r.location self.app.get( '/p/mymoz/wiki/', extra_environ=dict(username='******'), status=403)
def _sendEmail(self, subject, to, content): defaultsendto = config.get("default_email_sendto", "").split(";") sendto = defaultsendto + to cc = config.get("default_email_cc", "").split(";") content.extend(EMAIL_SUFFIX) if config.get("sendout_email", None) != 'F': sendEmail(EMAIL_SENDFROM, sendto, subject, '\n'.join(content), cc)
def production_export( self, **kw ): ws = [Item.active == 0, Item.status == STATUS_APPROVE, ] if kw.get( "jobNo", False ) : ws.append( Item.jobNo.op( "ilike" )( "%%%s%%" % kw["jobNo"] ) ) if kw.get( "systemNo", False ) : ws.append( Item.systemNo.op( "ilike" )( "%%%s%%" % kw["systemNo"] ) ) if kw.get( "desc", False ) : ws.append( Item.desc.op( "ilike" )( "%%%s%%" % kw["desc"] ) ) if kw.get( "approve_time_from", False ) : ws.append( Item.approveTime >= kw["approve_time_from"] ) if kw.get( "approve_time_to", False ) : ws.append( Item.approveTime <= kw["approve_time_to"] ) result = qry( Item ).filter( and_( *ws ) ).order_by( desc( Item.createTime ) ).all() data = [] for h in qry( Item ).filter( and_( *ws ) ).order_by( desc( Item.createTime ) ): data.append( map( unicode, [ h.systemNo, h.jobNo, h.desc, h.createTime.strftime( "%Y/%m/%d %H:%M" ), h.showStatus(), h.approveTime.strftime( "%Y/%m/%d %H:%M" ) if h.approveTime else '', ] ) ) try: v = getExcelVersion() if not v : raise ReportGenerationException() if v <= "2003" : # version below 2003 templatePath = os.path.join( config.get( "public_dir" ), "TEMPLATE", "CAB_PRODUCTION_REPORT_TEMPLATE.xls" ) else : # version above 2003 templatePath = os.path.join( config.get( "public_dir" ), "TEMPLATE", "CAB_PRODUCTION_REPORT_TEMPLATE.xlsx" ) tempFileName, realFileName = self._getReportFilePath( templatePath ) sdexcel = CABItemReport( templatePath = tempFileName, destinationPath = realFileName ) sdexcel.inputData( data ) sdexcel.outputData() except: traceback.print_exc() logError() if sdexcel:sdexcel.clearData() raise ReportGenerationException() else: return serveFile( realFileName )
def get_form(): registration_form = config.get('registration.form_instance') if not registration_form: form_path = config.get('registration.form', 'registration.lib.forms.RegistrationForm') root_module, path = form_path.split('.', 1) form_class = reduce(getattr, path.split('.'), sys.modules[root_module]) registration_form = config['registration.form_instance'] = form_class() return registration_form
def __init__(self, hub): enabled = asbool(config.get('moksha.feedaggregator', False)) if not enabled: log.info('Moksha Feed Aggregator disabled') return else: self.frequency = int(config.get('feed.poll_frequency', 900)) super(MokshaFeedStream, self).__init__(hub)
def __init__(self): """Initialize global variables""" here = config.get('here', '') cache_dir = config.get('cache.dir', '') self.upload_dir = config.get('upload_dir', '%s/upload' % cache_dir) self.upload_prefix = config.get('upload_prefix', 'upload') themes_dir = os.path.join(here, 'tagger', 'public', 'themes') self.themes = [d for d in os.listdir(themes_dir)]
def email_address(self): if self.discussion_disabled: return tg_config.get("forgemail.return_path") if c.app.config.options.get("AllowEmailPosting", True): domain = self.email_domain return "%s@%s%s" % (self.ticket_num, domain, config.common_suffix) else: return tg_config.get("forgemail.return_path")
def register(cls): cls._base_url = config.get('fedoracommunity.connector.bodhi.baseurl', 'https://admin.fedoraproject.org/updates') check_certs = asbool(config.get('fedora.clients.check_certs', True)) cls._insecure = not check_certs cls.register_query_updates() cls.register_query_active_releases()
def _check_security(self): require_authenticated() enable_editing = config.get('trovecategories.enableediting', 'false') if enable_editing == 'admin': with h.push_context(config.get('site_admin_project', 'allura'), neighborhood=config.get('site_admin_project_nbhd', 'Projects')): require_access(c.project, 'admin') elif enable_editing != 'true': raise HTTPForbidden()
def create_comment(self, **kw): try: #check if this user can create a comment in this topic #for now every member of the topic can create a comment creator = DBSession.query(MemberTopic).\ filter(MemberTopic.topic_id==kw['topic_id'], MemberTopic.member_id==request.identity['user'].user_id).\ first() if not creator: #TODO: this should never happen, log this event and return only False return dict(success=False, error_code=ErrorCode.UNAUTHORIZED) comment = Comment() comment.subject_id = kw['subject_id'] comment.creator_id = request.identity['user'].user_id comment.content = kw['content'] DBSession.add(comment) DBSession.flush() #TODO: should not query then update, should only update topic = DBSession.query(Topic).\ filter(Topic.uid==kw['topic_id']).first() #TODO: need to rethink this time var, how about subject update_time topic.update_time = comment.time log.info("User %s creates comment %s"%(comment.creator_id, comment)) subject_title = DBSession.query(Subject.title).\ filter(Subject.uid==kw['subject_id']).first()[0] members = DBSession.query(User.email_address).\ filter(MemberTopic.topic_id==kw['topic_id'], MemberTopic.member_id!=creator.member_id, MemberTopic.deleted==False, MemberSubject.subject_id==kw['subject_id'], MemberSubject.muted==False).\ join(MemberTopic,MemberSubject).\ all() member_emails = [member[0] for member in members] #send notification to users notif=dict(type='new_comment',topic=topic.title,subject=subject_title,comment=comment.content, registered_users=member_emails,user_name=request.identity['user'].user_name) log.info('Sending SNS notification: %s'%notif) sns=SNSConnection(config.get('AWS_ACCESS_KEY_ID'), config.get("AWS_SECRET_ACCESS_KEY")) sns.publish(config.get('sqs_user_notification'),js.dumps(notif)) return dict(success=True, comment=dict(uid=comment.uid, time=comment.time)) except Exception as e: log.exception('Got exception %s'%e) #traceback.print_exc(file=sys.stdout) return dict(success=False)
def oauth_callback(self, **kw): client_id = config.get("github_importer.client_id") secret = config.get("github_importer.client_secret") if not client_id or not secret: return # GitHub app is not configured oauth = OAuth2Session(client_id, state=session.get("github.oauth.state")) token = oauth.fetch_token( "https://github.com/login/oauth/access_token", client_secret=secret, authorization_response=request.url ) c.user.set_tool_data("GitHubProjectImport", token=token["access_token"]) redirect(session.get("github.oauth.redirect", "/"))
def handle_paging(self, limit, page, default=25): limit = self.manage_paging_preference(limit, default) limit = max(int(limit), 1) limit = min(limit, asint(config.get('limit_param_max', 500))) page = max(int(page), 0) start = page * int(limit) return (limit, page, start)
def enforce_limit(self, project): """ Enforce rate limiting of tool imports on a given project. Returns False if limit is met / exceeded. Otherwise, increments the count of pending / in-progress imports and returns True. """ limit = config.get('tool_import.rate_limit', 1) pending_key = 'tool_data.%s.pending' % self.classname modified_project = M.Project.query.find_and_modify( query={ '_id': project._id, '$or': [ { pending_key: None }, { pending_key: { '$lt': limit } }, ], }, update={'$inc': { pending_key: 1 }}, new=True, ) return modified_project is not None
def __init__(self): engine = sqlalchemy.engine.create_engine(config.get('sqlalchemy.url')) engine.connect() model.init_model(engine) self._repo = None self._logger = logging.getLogger(__name__)
def warn_externalauth(self, *args, **kw): if config.get('externalauth', False): s = request.controller_state.controller if s.model == User: flash( 'Profile changes are not possible because external authentication is used!', 'error')
def render_bars(self, response): page = response.get('response') if (not page or not isinstance(page, unicode_text) or 'text/html' not in response['content_type'] or request.headers.get('X-Requested-With') == 'XMLHttpRequest'): if config.get('debugbar.enable_logs', False): for section in __sections__: if hasattr(section, 'log_content'): section.log_content() return pos_head = page.find('</head>') if pos_head > 0: pos_body = page.find('</body>', pos_head + 7) if pos_body > 0: response['response'] = ''.join([ page[:pos_head], Markup(self.css_link % url(self.css_path)), page[pos_head:pos_body], Markup( render( dict(sections=__sections__), config['debugbar.engine'], self.template, ).split('\n', 1)[-1]), page[pos_body:] ])
def load_default_drivers(): stores = OrderedDict() store_list = [ x.strip() for x in config.get('bisque.blob_service.stores','').split(',') ] log.debug ('requested stores = %s' , store_list) for store in store_list: # pull out store related params from config params = dict ( (x[0].replace('bisque.stores.%s.' % store, ''), x[1]) for x in config.items() if x[0].startswith('bisque.stores.%s.' % store)) if 'mounturl' not in params: if 'path' in params: path = params.pop ('path') params['mounturl'] = string.Template(path).safe_substitute(OLDPARMS) log.warn ("Use of deprecated path (%s) in %s driver . Please change to mounturl and remove any from %s", path, store, OLDPARMS.keys()) log.info ("using mounturl = %s", params['mounturl']) else: log.error ('cannot configure %s without the mounturl parameter' , store) continue #if 'top' not in params: # params['top'] = params['mounturl'].split ('$user')[0] # log.warn ("top for %s was not set. Using %s", params['mounturl'], params['top']) log.debug("params = %s" , params) #driver = make_storage_driver(params.pop('path'), **params) #if driver is None: # log.error ("failed to configure %s. Please check log for errors " , str(store)) # continue stores[store] = params return stores
def icon_url(self, gravatar_default_url=None, return_more=False): icon_url = None try: private_project = self.private_project() except: log.warn('Error getting/creating user-project for %s', self.username, exc_info=True) private_project = None icon_source = None if private_project and private_project.icon: icon_url = self.url() + 'user_icon' icon_source = 'local' elif self.preferences.email_address: gravatar_args = {} if gravatar_default_url: gravatar_args['d'] = gravatar_default_url icon_url = g.gravatar(self.preferences.email_address, **gravatar_args) icon_source = 'gravatar' elif config.get('default_avatar_image'): icon_url = config['default_avatar_image'] icon_source = 'default' if return_more: return icon_url, private_project, icon_source else: return icon_url
def add_sentry_middleware(app, error_middleware=False): '''Add Sentry middleware no matter what In full stack mode, it wraps just before the ErrorMiddleware, else it wraps in the after_config hook. ''' from tg import config as tgconf fullstack = asbool(tgconf.get('fullstack')) if error_middleware or not fullstack: try: if tgconf.get('sentry.dsn', None): # pragma: no cover from raven.contrib.pylons import Sentry as SentryMiddleware app = SentryMiddleware(app, tgconf) except ImportError: # pragma: no cover pass return app
def __init__(self): logger.info('Loading settings...') # postgresql://postgres:mypassword@localhost:5432/mydb m_session = re.search(r'://(\w+):(\w+)@(\w+)(:\d+)?/(\w+)', unicode(config.get('sqlalchemy.url'))) if m_session: self.user = m_session.group(1) self.password = m_session.group(2) self.host = m_session.group(3) self.port = m_session.group(4) self.db = m_session.group(5) self.pg_path = config.get('pg_path', '/usr/bin/') else: raise Exception('It was not possible to get connection data')
def writeSummary(self, flist, archiver): summary = etree.Element('resource', type='bisque_package') etree.SubElement(summary, 'tag', name='origin', value=config.get('bisque.root', request.host)) etree.SubElement(summary, 'tag', name='version', value=__VERSION__) etree.SubElement(summary, 'tag', name='datetime', value=str(datetime.datetime.now())) index = 0 for f in flist: log.debug('writeSummary: %s', f) if f.get('dataset') is None and f.get('path') is None: log.debug('writeSummary Adding: %s', f) v = etree.SubElement(summary, 'value', index='%s' % index, type='object') v.text = f.get('outpath') index += 1 flist.append( dict(name='.bisque.xml', content=etree.tostring(summary), outpath='.bisque.xml')) return flist
def prepare(self): super(ReleaseFilter, self).prepare() releases = [] top_repo = os.path.join(config.get('git_repo_path'), self.package) pkgdb = get_connector('pkgdb') collections = pkgdb.get_collection_table(active_only=True) for id, collection in collections.iteritems(): name = collection['name'] ver = collection['version'] label = "%s %s" % (name, ver) value = "" branchname = collection['branchname'] if branchname: repo_path = os.path.join(top_repo, branchname) if not os.path.isdir(repo_path): continue value = branchname if label != 'Fedora devel' and name in ('Fedora', 'Fedora EPEL'): releases.append({ 'label': label, 'value': value, 'version': ver, }) self.releases_table = sorted(releases, reverse=True, cmp=lambda x, y: cmp(x['version'], y['version'])) self.releases_table.insert(0, {'label': 'Rawhide', 'value': 'master'})
def director(self): """Return activitystream director""" if asbool(config.get('activitystream.recording.enabled', False)): return activitystream.director() else: class NullActivityStreamDirector(object): def connect(self, *a, **kw): pass def disconnect(self, *a, **kw): pass def is_connected(self, *a, **kw): return False def create_activity(self, *a, **kw): pass def create_timeline(self, *a, **kw): pass def create_timelines(self, *a, **kw): pass def get_timeline(self, *a, **kw): return [] return NullActivityStreamDirector()
def patch_global_registration(): global Registration use_sqlalchemy = config.get('use_sqlalchemy') if use_sqlalchemy: from .sqla_models import Registration else: from .ming_models import Registration
def overview(self, **kw): c.markdown_editor = W.markdown_editor c.metadata_admin = W.metadata_admin c.explain_export_modal = W.explain_export_modal show_export_control = asbool(config.get('show_export_control', False)) allow_project_delete = asbool(config.get('allow_project_delete', True)) explain_export_text = '''The purpose of this section is to determine whether your project is subject to the provisions of the US Export Administration Regulations. You should consult section 734.4 and Supplement 2 to Part 734 for information on such items and the calculation of U.S. controlled content. <a href="http://www.bis.doc.gov/encryption/default.htm" target="_blank">http://www.bis.doc.gov/encryption/default.htm</a>''' if 'us_export_contact' in config: explain_export_text += 'If you have additional questions, please contact <a href="mailto:{contact}">{contact}</a>.'.format( contact=config['us_export_contact']) return dict(show_export_control=show_export_control, allow_project_delete=allow_project_delete, explain_export_text=explain_export_text)
def fields(self): username = ew.TextField(name='username', label='Desired Username', validator=fev.Regex(h.re_project_name)) username.validator._messages['invalid'] = ( 'Usernames must include only small letters, numbers, and dashes.' ' They must also start with a letter and be at least 3 characters' ' long.') fields = [ ew.TextField(name='display_name', label='Displayed Name', validator=fev.UnicodeString(not_empty=True)), username, ] if asbool(config.get('auth.require_email_addr', False)): fields.append( ew.TextField(name='email', label='Your e-mail', validator=fev.Email(not_empty=True))) fields += [ ew.PasswordField( name='pw', label='New Password', validator=fev.UnicodeString( not_empty=True, min=asint(tg.config.get('auth.min_password_len', 6)), max=asint(tg.config.get('auth.max_password_len', 30)))), ew.PasswordField(name='pw2', label='New Password (again)', validator=fev.UnicodeString(not_empty=True)), ] return fields
def fields(self): username = ew.TextField( name='username', label='Desired Username', validator=plugin.AuthenticationProvider.get(None).username_validator(), ) fields = [ ew.TextField( name='display_name', label='Displayed Name', validator=V.UnicodeString(not_empty=True)), username, ] if asbool(config.get('auth.require_email_addr', False)): fields.append(ew.TextField( name='email', label='Your e-mail', validator=fev.Email(not_empty=True))) fields += [ ew.PasswordField( name='pw', label='New Password', attrs=dict(minlength=asint(tg.config.get('auth.min_password_len', 6)), maxlength=asint(tg.config.get('auth.max_password_len', 30))), validator=V.UnicodeString( not_empty=True, min=asint(tg.config.get('auth.min_password_len', 6)), max=asint(tg.config.get('auth.max_password_len', 30)))), ew.PasswordField( name='pw2', label='New Password (again)', validator=V.UnicodeString(not_empty=True)), ] return fields
class MailFooter(object): view = jinja2.Environment( loader=jinja2.PackageLoader('allura', 'templates'), auto_reload=asbool(config.get('auto_reload_templates', True)), ) @classmethod def _render(cls, template, **kw): return cls.view.get_template(template).render(kw) @classmethod def standard(cls, notification, allow_email_posting=True, **kw): return cls._render('mail/footer.txt', domain=config['domain'], notification=notification, prefix=config['forgemail.url'], allow_email_posting=allow_email_posting, **kw) @classmethod def monitored(cls, toaddr, app_url, setting_url): return cls._render('mail/monitor_email_footer.txt', domain=config['domain'], email=toaddr, app_url=app_url, setting_url=setting_url)
def _rewrite(self, tag, attr): val = tag.get(attr) if val is None: return if ' ' in val: # Don't urllib.quote to avoid possible double-quoting # just make sure no spaces val = val.replace(' ', '%20') tag[attr] = val if '://' in val: for domain in re.split(r'\s*,\s*', config.get('nofollow_exempt_domains', '')): if domain and domain in val: return tag['rel'] = 'nofollow' return if val.startswith('/'): return if val.startswith('.'): return if val.startswith('mailto:'): return if val.startswith('#'): return tag[attr] = '../' + val
def prepare(self): super(ReleaseFilter, self).prepare() releases = [] top_repo = os.path.join(config.get('git_repo_path'), self.package) bodhi = get_connector('bodhi') for collection in bodhi.get_all_releases(): if collection['state'] != 'current': continue name = collection['id_prefix'] ver = collection['version'] label = collection['long_name'] value = "" branchname = collection['branch'] if branchname: repo_path = os.path.join(top_repo, branchname) if not os.path.isdir(repo_path): continue value = branchname if label != 'Fedora devel' and name in ('FEDORA', 'FEDORA-EPEL'): releases.append({ 'label': label, 'value': value, 'version': ver, }) self.releases_table = sorted(releases, reverse=True, cmp=lambda x, y: cmp(x['version'], y['version'])) self.releases_table.insert(0, {'label': 'Rawhide', 'value': 'master'})
def __init__(self): if not asbool(config.get('moksha.metrics_stream', False)): log.info('Moksha Metrics Stream disabled') return self.programs = self._find_programs() self.processors = self._find_processors() super(MokshaMetricsDataStream, self).__init__()
def get(cls): ''' :rtype: RecoveryCodeService ''' method = config.get('auth.multifactor.recovery_code.service', 'mongodb') return g.entry_points['multifactor_recovery_code'][method]()
def complete_registration(cls, registration): # Force resolution of lazy property registration.activation_link registration_config = config.get('_pluggable_registration_config') mail_body = registration_config.get( 'mail_body', _('Please click on this link to confirm your registration')) if '%(activation_link)s' not in mail_body: mail_body += '\n \n %(activation_link)s' email_data = { 'sender': config['registration.email_sender'], 'subject': registration_config.get('mail_subject', _('Please confirm your registration')), 'body': mail_body, 'rich': registration_config.get('mail_rich', '') } hooks.notify('registration.on_complete', (registration, email_data)) email_data['body'] = email_data['body'] % registration.dictified email_data['rich'] = email_data['rich'] % registration.dictified send_email(registration.email_address, **email_data) return email_data
def oauth_callback(self, **kw): client_id = config.get('github_importer.client_id') secret = config.get('github_importer.client_secret') if not client_id or not secret: return # GitHub app is not configured oauth = OAuth2Session( client_id, state=session.get('github.oauth.state')) token = oauth.fetch_token( 'https://github.com/login/oauth/access_token', client_secret=secret, authorization_response=request.url ) c.user.set_tool_data('GitHubProjectImport', token=token['access_token']) self.oauth_callback_complete() redirect(session.get('github.oauth.redirect', '/'))
def main(options): log.addHandler(logging.StreamHandler(sys.stdout)) log.setLevel(getattr(logging, options.log_level.upper())) log.debug(options) nbhd = M.Neighborhood.query.get(name=options.neighborhood) if not nbhd: return 'Invalid neighborhood "%s".' % options.neighborhood admin = M.User.query.get( username=config.get('sfx.api.siteadmin', 'sf-robot')) data = json.load(open(options.file, 'r')) project = Project() project.add( col.SchemaNode(col.Sequence(), col.SchemaNode(Award(nbhd)), name='awards', missing=[])) schema = col.SchemaNode(col.Sequence(), project, name='project') projects = schema.deserialize(data) log.debug(projects) chunks = [projects[i::options.nprocs] for i in range(options.nprocs)] jobs = [] for i in range(options.nprocs): p = multiprocessing.Process(target=create_projects, args=(chunks[i], nbhd, admin, options), name='worker-' + str(i + 1)) jobs.append(p) p.start() for j in jobs: j.join() if j.exitcode <> 0: return j.exitcode return 0
def checkout_url(self): return dict( app=self.app, merge_allowed=not asbool( config.get('scm.merge.{}.disabled'.format( self.app.config.tool_name))), )
def email_address(self): if self.config.options.get('AllowEmailPosting', True): domain = self.email_domain return '%s@%s%s' % (self.title.replace( '/', '.'), domain, config.common_suffix) else: return tg_config.get('forgemail.return_path')
class SiteNotification(MappedClass): """ Storage for site-wide notification. """ class __mongometa__: session = main_orm_session name = str('site_notification') indexes = [ ('active', '_id'), ] _id = FieldProperty(S.ObjectId) content = FieldProperty(str, if_missing='') active = FieldProperty(bool, if_missing=True) impressions = FieldProperty( int, if_missing=lambda: config.get('site_notification.impressions', 0)) user_role = FieldProperty(str, if_missing=None) page_regex = FieldProperty(str, if_missing=None) page_tool_type = FieldProperty(str, if_missing=None) def __json__(self): return dict( _id=str(self._id), content=self.content, active=self.active, impressions=self.impressions, user_role=self.user_role if self.user_role else '', page_regex=self.page_regex if self.page_regex else '', page_tool_type=self.page_tool_type if self.page_tool_type else '') @classmethod def actives(cls): return cls.query.find({'active': True}).sort('_id', -1).all()
def oauth_begin(self, scope=None): client_id = config.get('github_importer.client_id') secret = config.get('github_importer.client_secret') if not client_id or not secret: return # GitHub app is not configured if c.user.get_tool_data('GitHubProjectImport', 'token'): return # token already exists, nothing to do redirect_uri = request.url.rstrip('/') + '/oauth_callback' oauth = OAuth2Session(client_id, redirect_uri=redirect_uri, scope=scope) auth_url, state = oauth.authorization_url( 'https://github.com/login/oauth/authorize') # Used in callback to prevent CSRF session['github.oauth.state'] = state session['github.oauth.redirect'] = request.url session.save() redirect(auth_url)
def email_address(self): if c.app.config.options.get('AllowEmailPosting', True): domain = self.email_domain local_part = self.shortname.replace('/', '.') return '%s@%s%s' % (local_part, domain, config.common_suffix) else: return tg_config.get('forgemail.return_path')
def add_global_template_variables(): return dict(today=JalaliDate.today().strftime('%A %d %B %Y'), session=session, base_url=config.get('base_url'), pictures=DBSession.query(Picture).all(), categories=DBSession.query(Category).options( joinedload('subcategory')).all())