def list_reports(page, filter_id):
    context = {'model': model, 'session': model.Session,
                   'user': c.user or c.author, 'auth_user_obj': c.userobj,
                   'for_view': True}
    data_dict = {}
    if db.related_extra_table is None:
        db.init_db(context['model'])
    res = db.RelatedExtra.getALL(**data_dict)

    res = [x for x in res if x.key == 'report']

    if filter_id != '':
        res = [x for x in res if x.related_id == filter_id]
    length = len(res)
    result = []
    try:
        page = int(page)
    except ValueError:
        page = 1
    
    for i in range(page*10-10,page*10):
        try:
            result.append(res[i])
        except IndexError:
            pass
    if page > length//10+1:   
        base.abort(400, ('"page" parameter out of range')) 
    
    #res = res[page-1*10:page*10+4]

    return {'reports': result, 'count': length, 'delall': (length > 0) and (filter_id != ''), 'related_id':filter_id}
Exemple #2
0
def search_add(context, data_dict):
    '''
    Add an item to the search_history for the current user.

    :param content: Search query to add to history
    :type content: string
    '''
    try:
        tk.check_access('ckanext_search_history_add', context, data_dict)
    except tk.NotAuthorized:
        #JOE#
        #tk.abort(401, tk._('Not authorized to add history item'))
        pass
    if db.search_history_table is None:
        db.init_db(context['model'])

    content = tk.get_or_bust(data_dict, 'content')
    username = context.get('user')
    #JOE#
    #user_id = new_authz.get_user_id_for_username(username, allow_none=False)
    user_id = new_authz.get_user_id_for_username(username, allow_none=True)

    search_history = db.SearchHistory()
    search_history.content = content
    search_history.user_id = user_id
    session = context['session']
    session.add(search_history)
    session.commit()
    return db.table_dictize(search_history, context)
Exemple #3
0
def _pages_list(context, data_dict):
    search = {}
    if db.pages_table is None:
        db.init_db(context['model'])
    org_id = data_dict.get('org_id')
    ordered = data_dict.get('order')
    private = data_dict.get('private', True)
    if ordered:
        search['order'] = True
    if not org_id:
        search['group_id'] = None
        try:
            p.toolkit.check_access('ckanext_pages_update', context, data_dict)
            if not private:
                search['private'] = False
        except p.toolkit.NotAuthorized:
            search['private'] = False
    else:
        group = context['model'].Group.get(org_id)
        user = context['user']
        member = new_authz.has_user_permission_for_group_or_org(
            group.id, user, 'read')
        search['group_id'] = org_id
        if not member:
            search['private'] = False
    out = db.Page.pages(**search)
    return [{'title': pg.title,
             'content': pg.content,
             'name': pg.name,
             'group_id': pg.group_id,
            } for pg in out]
def main():
    logger.info('Starting follow neighbour script')
    try:
        db.init_db()
        lat, lon = config.TWEET_HOME_GEO
        radius = '100km'
        geocode = ','.join([str(lat), str(lon), radius])
        registered_users = [
            user.user_id for user in db.session.query(User).all()]
        results = getTweets([config.TWEET_LOCATION.split(',')[0]],
                            result_type='recent')
        near_tweets = []
        for tweet in results:
            if tweet.get('place'):
                if tweet.get('place').get('full_name') == 'San Francisco, CA':
                    near_tweets.append(tweet)
        near_tweets[0]
        authors = [tweet.get('user') for tweet in near_tweets]
        authors_id_list = set([author.get('id_str') for author in authors])
        follow_list = [author for author in authors_id_list
                       if author not in registered_users]
        logger.info('Found %d  new neighbours' % len(follow_list))
        followUsers(follow_list[:30])
    except Exception, err:
        logger.error('%s: %s' % (Exception, err))
Exemple #5
0
def create_application():
	global app, db, UserManager

	if not config.check():
		return None

	if not os.path.exists(config.get('base', 'cache_dir')):
		os.makedirs(config.get('base', 'cache_dir'))

	import db
	db.init_db()

	app = Flask(__name__)
	app.secret_key = '?9huDM\\H'

	if config.get('base', 'log_file'):
		import logging
		from logging.handlers import TimedRotatingFileHandler
		handler = TimedRotatingFileHandler(config.get('base', 'log_file'), when = 'midnight')
		handler.setLevel(logging.WARNING)
		app.logger.addHandler(handler)

	app.teardown_request(teardown)

	import frontend
	import api

	return app
def main():
    logger.info("Starting interventions retweeting (pid %s)" % os.getpid())
    twitter_stream = TwitterStream(domain="stream.twitter.com", app=1)
    db.init_db()
    while 1:
        for tag_date, tag in TAGS:
            retweets = 0
            while tag_date == datetime.datetime.now().date():
                try:
                    for status in twitter_stream.stream.statuses.filter(track=tag):
                        sleep(5)
                        tweet_id = status.get("id_str")
                        retweet_ids = [tweet.tweet_id for tweet in db.session.query(ReTweet).all()]
                        if tweet_id in retweet_ids:
                            continue
                        screen_name = status.get("user").get("screen_name")
                        # Retweet 10 first
                        if retweets < 5:
                            reTweet(tweet_id)
                            logger.info("Retweeted: %s" % tweet_id)
                            retweets += 1
                        # Retweet 50 if not BOT
                        elif retweets <= 16 and screen_name not in BOTS:
                            reTweet(tweet_id)
                            logger.info("Retweeted: %s" % tweet_id)
                            retweets += 1
                        # Favorite tweet
                        favorite(tweet_id)
                        if tag_date != datetime.datetime.now().date():
                            break
                except:
                    print "Stream connection timeout, restarting..."
Exemple #7
0
def page_privacy(context, data_dict):
    if db.pages_table is None:
        db.init_db(context['model'])
    org_id = data_dict.get('org_id')
    page = data_dict.get('page')
    out = db.Page.get(group_id=org_id, name=page)
    if out and out.private == False:
        return {'success':  True}
    # CCG change: permit anonymous listing of available pages
    if page == '' and out is None:
        return {'success':  True}
    # no org_id means it's a universal page
    if not org_id:
        if out and out.private:
            return {'success': False}
        return {'success': True}
    group = context['model'].Group.get(org_id)
    user = context['user']
    authorized = authz.has_user_permission_for_group_or_org(group.id,
                                                                user,
                                                                'read')
    if not authorized:
        return {'success': False,
                'msg': p.toolkit._(
                    'User %s not authorized to read this page') % user}
    else:
        return {'success': True}
Exemple #8
0
    def __init__(self):

        self.verify_https = os.environ.get('OAUTHLIB_INSECURE_TRANSPORT', '') == ""
        if self.verify_https and os.environ.get("REQUESTS_CA_BUNDLE", "").strip() != "":
            self.verify_https = os.environ["REQUESTS_CA_BUNDLE"].strip()

        self.jwt_enable = six.text_type(os.environ.get('CKAN_OAUTH2_JWT_ENABLE', toolkit.config.get('ckan.oauth2.jwt.enable',''))).strip().lower() in ("true", "1", "on")

        self.legacy_idm = six.text_type(os.environ.get('CKAN_OAUTH2_LEGACY_IDM', toolkit.config.get('ckan.oauth2.legacy_idm', ''))).strip().lower() in ("true", "1", "on")
        self.authorization_endpoint = six.text_type(os.environ.get('CKAN_OAUTH2_AUTHORIZATION_ENDPOINT', toolkit.config.get('ckan.oauth2.authorization_endpoint', ''))).strip()
        self.token_endpoint = six.text_type(os.environ.get('CKAN_OAUTH2_TOKEN_ENDPOINT', toolkit.config.get('ckan.oauth2.token_endpoint', ''))).strip()
        self.profile_api_url = six.text_type(os.environ.get('CKAN_OAUTH2_PROFILE_API_URL', toolkit.config.get('ckan.oauth2.profile_api_url', ''))).strip()
        self.client_id = six.text_type(os.environ.get('CKAN_OAUTH2_CLIENT_ID', toolkit.config.get('ckan.oauth2.client_id', ''))).strip()
        self.client_secret = six.text_type(os.environ.get('CKAN_OAUTH2_CLIENT_SECRET', toolkit.config.get('ckan.oauth2.client_secret', ''))).strip()
        self.scope = six.text_type(os.environ.get('CKAN_OAUTH2_SCOPE', toolkit.config.get('ckan.oauth2.scope', ''))).strip()
        self.rememberer_name = six.text_type(os.environ.get('CKAN_OAUTH2_REMEMBER_NAME', toolkit.config.get('ckan.oauth2.rememberer_name', 'auth_tkt'))).strip()
        self.profile_api_user_field = six.text_type(os.environ.get('CKAN_OAUTH2_PROFILE_API_USER_FIELD', toolkit.config.get('ckan.oauth2.profile_api_user_field', ''))).strip()
        self.profile_api_fullname_field = six.text_type(os.environ.get('CKAN_OAUTH2_PROFILE_API_FULLNAME_FIELD', toolkit.config.get('ckan.oauth2.profile_api_fullname_field', ''))).strip()
        self.profile_api_mail_field = six.text_type(os.environ.get('CKAN_OAUTH2_PROFILE_API_MAIL_FIELD', toolkit.config.get('ckan.oauth2.profile_api_mail_field', ''))).strip()
        self.profile_api_groupmembership_field = six.text_type(os.environ.get('CKAN_OAUTH2_PROFILE_API_GROUPMEMBERSHIP_FIELD', toolkit.config.get('ckan.oauth2.profile_api_groupmembership_field', ''))).strip()
        self.sysadmin_group_name = six.text_type(os.environ.get('CKAN_OAUTH2_SYSADMIN_GROUP_NAME', toolkit.config.get('ckan.oauth2.sysadmin_group_name', ''))).strip()

        self.redirect_uri = urljoin(urljoin(toolkit.config.get('ckan.site_url', 'http://localhost:5000'), toolkit.config.get('ckan.root_path')), constants.REDIRECT_URL)

        # Init db
        db.init_db(model)

        missing = [key for key in REQUIRED_CONF if getattr(self, key, "") == ""]
        if missing:
            raise ValueError("Missing required oauth2 conf: %s" % ", ".join(missing))
        elif self.scope == "":
            self.scope = None
Exemple #9
0
def setup():
    """Set up the file system, GPG, and database."""
    create_directories()
    init_gpg()
    init_db()
    # Do tests that should always run on app startup
    crypto_util.do_runtime_tests()
def datarequest_comment_show(context, data_dict):
    '''
    Action to retrieve a comment. Access rights will be checked before getting the
    comment and a NotAuthorized exception will be risen if the user is not allowed
    to get the comment

    :param id: The ID of the comment to be retrieved
    :type id: string

    :returns: A dict with the following fields: id, user_id, datarequest_id, time
        and comment
    :rtype: dict
    '''

    model = context['model']
    comment_id = data_dict.get('id', '')

    # Check id
    if not comment_id:
        raise tk.ValidationError(['Comment ID has not been included'])

    # Init the data base
    db.init_db(model)

    # Check access
    tk.check_access(constants.DATAREQUEST_COMMENT_SHOW, context, data_dict)

    # Get comments
    result = db.Comment.get(id=comment_id)
    if not result:
        raise tk.ObjectNotFound('Comment %s not found in the data base' % comment_id)

    return _dictize_comment(result[0])
def datarequest_comment_list(context, data_dict):
    '''
    Action to retrieve all the comments of a data request. Access rights will be checked before
    getting the comments and a NotAuthorized exception will be risen if the user is not
    allowed to read the comments

    :param datarequest_id: The ID of the datarequest whose comments want to be retrieved
    :type id: string

    :returns: A list with all the comments of a data request. Every comment is a dict with the
    following fields: id, user_id, datarequest_id, time and comment
    :rtype: list
    '''

    model = context['model']
    datarequest_id = data_dict.get('datarequest_id', '')

    # Check id
    if not datarequest_id:
        raise tk.ValidationError('Data Request ID has not been included')

    # Init the data base
    db.init_db(model)

    # Check access
    tk.check_access(constants.DATAREQUEST_COMMENT_LIST, context, data_dict)

    # Get comments
    comments_db = db.Comment.get_ordered_by_date(datarequest_id=datarequest_id)

    comments_list = []
    for comment in comments_db:
        comments_list.append(_dictize_comment(comment))

    return comments_list
Exemple #12
0
def reset(args):
    """Clears the SecureDrop development applications' state, restoring them to
    the way they were immediately after running `setup_dev.sh`. This command:
    1. Erases the development sqlite database file.
    2. Regenerates the database.
    3. Erases stored submissions and replies from the store dir.
    """
    # Erase the development db file
    if not hasattr(config, 'DATABASE_FILE'):
        raise Exception("TODO: ./manage.py doesn't know how to clear the db "
                        'if the backend is not sqlite')
    try:
        os.remove(config.DATABASE_FILE)
    except OSError:
        pass

    # Regenerate the database
    init_db()

    # Clear submission/reply storage
    try:
        os.stat(config.STORE_DIR)
    except OSError:
        pass
    else:
        for source_dir in os.listdir(config.STORE_DIR):
            try:
                # Each entry in STORE_DIR is a directory corresponding
                # to a source
                shutil.rmtree(os.path.join(config.STORE_DIR, source_dir))
            except OSError:
                pass
    return 0
Exemple #13
0
def _pages_update(context, data_dict):
    if db.pages_table is None:
        db.init_db(context['model'])
    org_id = data_dict.get('org_id')
    page = data_dict.get('page')
    # we need the page in the context for name validation
    context['page'] = page
    context['group_id'] = org_id

    data, errors = df.validate(data_dict, schema, context)

    if errors:
        raise p.toolkit.ValidationError(errors)

    out = db.Page.get(group_id=org_id, name=page)
    if not out:
        out = db.Page()
        out.group_id = org_id
        out.name = page
    items = ['title', 'content', 'name', 'private', 'order']
    for item in items:
        setattr(out, item, data.get(item))

    out.modified = datetime.datetime.utcnow()
    out.user_id = p.toolkit.c.userobj.id
    out.save()
    session = context['session']
    session.add(out)
    session.commit()
Exemple #14
0
    def update_db(self):
        tracks = explore.explore_collection(MUSIC_PATH)

        if not os.path.isfile(DBFILE) or os.path.getsize(DBFILE == 0):
            db.init_db(DBFILE)
            db.create_tracks(DBFILE, tracks)
        else:
            db.update_tracks(DBFILE, tracks)
def is_dataset_acquired(pkg_dict):

    db.init_db(model)

    if tk.c.user:
        return len(db.AllowedUser.get(package_id=pkg_dict["id"], user_name=tk.c.user)) > 0
    else:
        return False
Exemple #16
0
def main(sqlite_path):
	if path.exists(db.db_path):
		print(db.db_path, 'already exists')
		return 1

	db.init_db(True)

	csv.register_dialect('wormholes',
			lineterminator='\n', quoting=csv.QUOTE_MINIMAL, skipinitialspace=True, strict=True)
	wormholes = get_wormholes('setup_data/wormholes.csv')

	conn = sqlite3.connect(sqlite_path)
	conn.row_factory = sqlite3.Row
	rows = conn.execute('''
		SELECT solarSystemID, solarSystemName, security, regionName, wormholeClassId FROM mapSolarSystems
		JOIN mapRegions ON mapRegions.regionID = mapSolarSystems.regionID
		JOIN mapLocationWormholeClasses ON mapRegions.regionId = mapLocationWormholeClasses.locationId
	''')
	for row in rows:
		id = int(row['solarSystemID'])
		name = row['solarSystemName']
		security = row['security']
		region = row['regionName']
		wormhole = wormholes.get(id)
		if wormhole:
			assert name == wormhole['name']
			whclass = wormhole['class']
			effect = wormhole['effect']
			static1 = wormhole['static1']
			static2 = wormhole['static2']
		else:
			if security >= 0.45:
				whclass = 'highsec'
			elif security > 0.0:
				whclass = 'lowsec'
			else:
				whclass = 'nullsec'
			effect = static1 = static2 = None
		db.SolarSystem(name, id, region, whclass, effect, static1, static2).save()

	for wh_type in get_wh_types('setup_data/wh_types.csv'):
		"""
		id = wh_type['id']
		name = wh_type['name']
		src = wh_type['src']
		dest = wh_type['dest']
		lifetime = wh_type['lifetime']
		jump_mass = wh_type['jump_mass']
		max_mass = wh_type['max_mass']
		"""
		db.WHType(**wh_type).save()

	username = input('username: '******'password: '******'map', b'[]')
	return 0
def _pages_show(context, data_dict):
    if db.pages_table is None:
        db.init_db(context['model'])
    org_id = data_dict.get('org_id')
    page = data_dict.get('page')
    out = db.Page.get(group_id=org_id, name=page)
    if out:
        out = db.table_dictize(out, context)
    return out
def reports_num(related_id):
    context = {'model': model, 'session': model.Session,
                   'user': c.user or c.author, 'auth_user_obj': c.userobj,
                   'for_view': True}
    data_dict = {'related_id': related_id, 'key':'report'}
    if db.related_extra_table is None:
        db.init_db(context['model'])
    res = db.RelatedExtra.get(**data_dict)
    return len(res)
Exemple #19
0
def get_tag_info(context, data_dict):
    '''
    This function retrieves extra information about given tag_id and
    possibly more filtering criterias. 
    '''
    if db.tag_info_table is None:
        db.init_db(context['model'])
    res = db.TagInfo.get(**data_dict)
    return res
def get_allowed_users(key, data, errors, context):
    pkg_id = data[('id',)]

    db.init_db(context['model'])

    users = db.AllowedUser.get(package_id=pkg_id)

    for i, user in enumerate(users):
        data[(key[0], i)] = user.user_name
Exemple #21
0
def main():
    '''Script is used to post an image from the renvotion of the bot's
    fictional restaurant.'''
    try:
        sleep_time = randrange(120)
        logger.info(
            'Starting post renovation progress script by sleeping %s minutes'
            % sleep_time
            )
        sleep(sleep_time*60)
        logger.info('Waking up post_renovation script.')
        tweets = twitter_api.statuses.user_timeline(screen_name=USER,
                                                    count=200
                                                    )
        filtered_tweets = []
        for tweet in tweets:
            text = tweet.get('text')
            if ('#renovation' in text
                    or '#comingsoon' in text
                    or '#refurbishment' in text):
                if tweet.get('entities').get('media'):
                    for media in tweet.get('entities').get('media'):
                        filtered_tweets.append(tweet)
        # TODO: Check with previous tweets...
        db.init_db()
        filtered_statuses = db.session.query(Status).all()
        # source ids of previously posted statuses
        filtered_statuses = [status.source_id for status in filtered_statuses
                             if status.source_id]
        # ids of found tweets
        filtered_tweet_ids = [tweet.get('id_str') for tweet in filtered_tweets]
        # Removing previously posted source tweets
        possible_statuses = [tweet_id for tweet_id in filtered_tweet_ids
                             if tweet_id not in filtered_statuses]
        # Setting the new tweet id, to the newest possible one
        possible_statuses = sorted(possible_statuses)
        if possible_statuses:
            new_source_id = possible_statuses[0]
        # Getting the source tweet
        new_source = [tweet for tweet in filtered_tweets
                      if tweet.get('id_str') == new_source_id][0]
        # TODO: Find next image to post
        medias = new_source.get('entities').get('media')
        media_url = None
        for media in medias:
            media_url = media.get('media_url')
            break
        image = urlopen(media_url)
        params = {"media[]": image.read(),
                  "status": generate_text(),
                  'source_id': new_source_id
                  }
        # Post tweet
        updateStatus(params)
    except Exception, err:
        logger.error('%s: %s' % (Exception, err))
Exemple #22
0
def command_line():
    if not config.check():
        sys.exit(1)

    db.init_db()

    if len(sys.argv) > 1:
        CLI().onecmd(' '.join(sys.argv[1:]))
    else:
        CLI().cmdloop()    
def reported_id(related_id, user_id):
    context = {'model': model, 'session': model.Session,
                   'user': c.user or c.author, 'auth_user_obj': c.userobj,
                   'for_view': True}
    data_dict = {'related_id': related_id, 'key':'reported_by'}
    if db.related_extra_table is None:
        db.init_db(context['model'])
    res = db.RelatedExtra.get(**data_dict)
    res = [x for x in res if x.value.split('*')[0] == user_id]
    return res[0].value.split('*')[1]
Exemple #24
0
def _pages_delete(context, data_dict):
    if db.pages_table is None:
        db.init_db(context['model'])
    org_id = data_dict.get('org_id')
    page = data_dict.get('page')
    out = db.Page.get(group_id=org_id, name=page)
    if out:
        session = context['session']
        session.delete(out)
        session.commit()
def acquisitions_list(context, data_dict):
    '''
    API to retrieve the list of datasets that have been acquired by a certain user

    :parameter user: The user whose acquired dataset you want to retrieve. This parameter
        is optional. If you don't include this identifier, the system will use the one
        of the user that is performing the request
    :type user: string

    :return: The list of datarequest that has been acquired by the specified user
    :rtype: list
    '''

    if data_dict is None:
        data_dict = {}

    if 'user' not in data_dict and 'user' in context:
        data_dict['user'] = context['user']

    plugins.toolkit.check_access(constants.ACQUISITIONS_LIST, context.copy(), data_dict)

    # Init db
    db.init_db(context['model'])

    # Init the result array
    result = []

    # Check that the user exists
    try:
        plugins.toolkit.get_validator('user_name_exists')(data_dict['user'], context.copy())
    except Exception:
        raise plugins.toolkit.ValidationError('User %s does not exist' % data_dict['user'])

    # Get the datasets acquired by the user
    query = db.AllowedUser.get(user_name=data_dict['user'])

    # Get the datasets
    for dataset in query:
        try:
            dataset_show_func = 'package_show'
            func_data_dict = {'id': dataset.package_id}
            internal_context = context.copy()

            # Check that the the dataset can be accessed and get its data
            # FIX: If the check_access function is not called, an exception is risen.
            plugins.toolkit.check_access(dataset_show_func, internal_context, func_data_dict)
            dataset_dict = plugins.toolkit.get_action(dataset_show_func)(internal_context, func_data_dict)

            # Only packages with state == 'active' can be shown
            if dataset_dict.get('state', None) == 'active':
                result.append(dataset_dict)
        except Exception:
            pass

    return result
Exemple #26
0
def _pages_list(context, data_dict):
    search = {}
    if db.pages_table is None:
        db.init_db(context['model'])
    org_id = data_dict.get('org_id')
    ordered = data_dict.get('order')
    order_publish_date = data_dict.get('order_publish_date')
    page_type = data_dict.get('page_type')
    private = data_dict.get('private', True)
    if ordered:
        search['order'] = True
    if page_type:
        search['page_type'] = page_type
    if order_publish_date:
        search['order_publish_date'] = True
    if not org_id:
        search['group_id'] = None
        try:
            p.toolkit.check_access('ckanext_pages_update', context, data_dict)
            if not private:
                search['private'] = False
        except p.toolkit.NotAuthorized:
            search['private'] = False
    else:
        group = context['model'].Group.get(org_id)
        user = context['user']
        member = authz.has_user_permission_for_group_or_org(
            group.id, user, 'read')
        search['group_id'] = org_id
        if not member:
            search['private'] = False
    out = db.Page.pages(**search)
    out_list = []
    # cdc
    for pg in out:
        parser = HTMLFirstImage()
        parser.feed(pg.content)
        img = parser.first_image
        pg_row = {'title': pg.title,
                  'ename': pg.ename,
                  'cname': pg.cname,
                  'content': pg.content,
                  'econtent': pg.econtent,
                  'name': pg.name,
                  'publish_date': pg.publish_date.isoformat() if pg.publish_date else None,
                  'group_id': pg.group_id,
                  'page_type': pg.page_type,
                 }
        if img:
            pg_row['image'] = img
        extras = pg.extras
        if extras:
            pg_row.update(json.loads(pg.extras))
        out_list.append(pg_row)
    return out_list
def datarequest_close(context, data_dict):
    '''
    Action to close a data request. Access rights will be checked before closing the
    data request. If the user is not allowed, a NotAuthorized exception will be risen.

    :param id: The id of the data request to be closed
    :type id: string

    :param accepted_dataset_id: The ID of the dataset accepted as solution for this
        data request
    :type accepted_dataset_id: string

    :returns: A dict with the data request (id, user_id, title, description,
        organization_id, open_time, accepted_dataset, close_time, closed)
    :rtype: dict

    '''

    model = context['model']
    session = context['session']
    datarequest_id = data_dict.get('id', '')

    # Check id
    if not datarequest_id:
        raise tk.ValidationError('Data Request ID has not been included')

    # Init the data base
    db.init_db(model)

    # Check access
    tk.check_access(constants.DATAREQUEST_CLOSE, context, data_dict)

    # Get the data request
    result = db.DataRequest.get(id=datarequest_id)
    if not result:
        raise tk.ObjectNotFound('Data Request %s not found in the data base' % datarequest_id)

    # Validate data
    validator.validate_datarequest_closing(context, data_dict)

    data_req = result[0]

    # Was the data request previously closed?
    if data_req.closed:
        raise tk.ValidationError(['This Data Request is already closed'])

    data_req.closed = True
    data_req.accepted_dataset_id = data_dict.get('accepted_dataset_id', None)
    data_req.close_time = datetime.datetime.now()

    session.add(data_req)
    session.commit()

    return _dictize_datarequest(data_req)
Exemple #28
0
def start_standalone_server(host=None, port=None, debug=True):
    if not config.check():
        sys.exit(1)

    if not os.path.exists(config.get('base', 'cache_dir')):
        os.makedirs(config.get('base', 'cache_dir'))

    import db
    from web import app

    db.init_db()
    app.run(host=host, port=port, debug=debug)
Exemple #29
0
    def __init__(self):

        self.authorization_endpoint = config.get('ckan.oauth2.authorization_endpoint', None)
        self.token_endpoint = config.get('ckan.oauth2.token_endpoint', None)
        self.profile_api_url = config.get('ckan.oauth2.profile_api_url', None)
        self.client_id = config.get('ckan.oauth2.client_id', None)
        self.client_secret = config.get('ckan.oauth2.client_secret', None)
        self.scope = config.get('ckan.oauth2.scope', '').decode()
        self.rememberer_name = config.get('ckan.oauth2.rememberer_name', None)

        # Init db
        db.init_db(model)
def datarequest_create(context, data_dict):
    '''
    Action to create a new dara request. The function checks the access rights
    of the user before creating the data request. If the user is not allowed
    a NotAuthorized exception will be risen.

    In addition, you should note that the parameters will be checked and an
    exception (ValidationError) will be risen if some of these parameters are
    not valid.

    :param title: The title of the data request
    :type title: string

    :param description: A brief description for your data request
    :type description: string

    :param organiztion_id: If you want to create the data request in a specific
        organization.
    :type organization_id: string

    :returns: A dict with the data request (id, user_id, title, description,
        organization_id, open_time, accepted_dataset, close_time, closed)
    :rtype: dict
    '''

    model = context['model']
    session = context['session']

    # Init the data base
    db.init_db(model)

    # Check access
    tk.check_access(constants.DATAREQUEST_CREATE, context, data_dict)

    # Validate data
    validator.validate_datarequest(context, data_dict)

    # Store the data
    data_req = db.DataRequest()
    _undictize_datarequest_basic(data_req, data_dict)
    data_req.user_id = context['auth_user_obj'].id if context['auth_user_obj'] else 'anonymous'
    data_req.open_time = datetime.datetime.now()

    data_req.visibility = constants.DataRequestState.visible.value
    context['ignore_auth'] = config.get('ckan.datarequests.ignore_auth', False)
    user = context['user']
    if context['ignore_auth'] == False and not authz.is_sysadmin(user):
        data_req.visibility = constants.DataRequestState.hidden.value

    session.add(data_req)
    session.commit()

    return _dictize_datarequest(data_req)
Exemple #31
0
def listings():
    offersList = []
    init_db()
    #imgresult = Imagesmod.query.first()
    #imgresult.image
    #imgretrieved = image.load_img(BytesIO(imgresult.image))
    #get all ads
    results = OfferModel.query.all()
    #for each ad get all images belonging to it and add as List
    for result in results:
        imagesList = db_session.query(ImagesModel).join(OfferModel).filter(
            OfferModel.id == result.id)
        result.imagesList = list(imagesList)
        offersList.append(result)
    print(offersList)
    return render_template("listings.html", offersList=offersList)
Exemple #32
0
    def __init__(self, bot_key, db_path):

        init_db(db_path)

        self._updater = Updater(bot_key, use_context=True)
        self._dp = self._updater.dispatcher

        self._dp.add_handler(CommandHandler(
            "start",
            self._start,
            pass_user_data=True))
        self._dp.add_handler(MessageHandler(
            Filters.text,
            self._start,
            pass_user_data=True))
        self._dp.add_error_handler(self._error)
Exemple #33
0
def ocr_images(file_id):
    # init db
    conn, c = init_db()
    conn.row_factory = lambda cursor, row: row[0]
    values = (file_id, )

    # only OCR pages with boxes
    results = c.execute(
        """SELECT id, image_path FROM page WHERE box = 1 and file_id = ?""",
        values).fetchall()

    # init pyocr
    tools = pyocr.get_available_tools()
    tool = tools[0]
    langs = tool.get_available_languages()
    lang = langs[0]

    for page_id, image_path in results:
        current_app.logger.info('Running OCR on image id %s (%s)' %
                                (page_id, image_path))

        # load image
        image = cv2.imread(image_path)
        text_image = PIL_Image.fromarray(image)

        # run ocr
        body = tool.image_to_string(text_image,
                                    lang=lang,
                                    builder=pyocr.builders.TextBuilder())

        # save results
        c.execute("""UPDATE page SET body = ? WHERE id = ?""", (body, page_id))

    conn.commit()
    conn.close()
Exemple #34
0
def test_redirect_url():
    db_path = 'test_redirect_url.json'
    remove_path(db_path)
    db = init_db(db_path)

    url_items = [{
        'url': 'https://about.google.com/',  # 301 HTTP code
        'regex': 'Policy',
    }]

    correct_output = {
        'matches': [{
            'text': 'Policy',
            'start': 24355,
            'end': 24361,
        }],
    }

    create_process(url_items, db)

    output_items = db.all()
    assert (len(output_items) > 0)

    item = output_items[0]
    assert (len(correct_output['matches']) == len(item['matches']))

    for i in range(len(item['matches'])):
        for key in item['matches'][i].keys():
            assert (
                correct_output['matches'][i][key] == item['matches'][i][key])

    remove_path(db_path)
Exemple #35
0
def get_most_recent():
    """
    Get the most recent three items that have been analyzed.
    """
    db_recent = DB.init_db(config.get("details_db")).product_details
    res = list(
        db_recent.find({
            "status": "ready"
        }).sort('timestamp', pymongo.DESCENDING))
    items = []
    try:
        for i in range(3):
            obj = res[i]
            title = obj.get("product_name")
            _max_length = config.get("misc").get("max_title_length")
            if len(title) > _max_length:
                title = title[:_max_length]
                title += "..."
            item = {
                "image_url": obj.get("img"),
                "title": title,
                "product_url": obj.get("url"),
                "sku": obj.get("sku")
            }
            items.append(item)
    except IndexError:
        pass
    return items
Exemple #36
0
def get_answer(question, sku):
    """
    Open a websocket and keep the connection alive for the duration 
    of the session so that the sku model is loaded only once. 
    """
    response = {"status": __error__}
    try:
        db_votes = DB.init_db(config.get("votes_db"))
        inf = inference.Inference(sku)
        answer, confidence = inf.infer(question)
        cluster = qna_clustering.Cluster({
            "question": question,
            "answer": answer,
            "sku": sku
        })
        votes = cluster.get_votes(db_votes)
        response = {
            "confidence": confidence,
            "answer": answer,
            "status": "OK",
        }
        response.update(votes)
    except Exception as e:
        msg = '{}'.format(type(e).__name__, e.args[0])
        logger.exception(msg)
    return response
Exemple #37
0
def get_status(sku):
    response = {"status": __in_queue__}
    status = None
    try:
        status = list(db_status.find({"sku": sku}))[0]
        status = status.get("msg")
        db_details = DB.init_db(config.get("details_db")).product_details
        product = list(db_details.find({"sku": sku}))
        product_url, product_name, image_url = "", "", ""
        if product:
            product_name = product[0].get("product_name")
            product_url = product[0].get("url")
            image_url = product[0].get("img")
        logger.info("Status for {}: {}".format(sku, status))
        return {
            "status": status,
            "product_name": product_name,
            "product_url": product_url,
            "image_url": image_url,
        }
    except IndexError:
        # this happens due to a race condition because the sku hasn't been
        # added to the database yet or because it simply doesn't exist. The
        # second case only true if the URL has been typed in manually or
        # bookmarked but the sku is missing from the URL.
        logger.warning(
            "Product status not yet available for sku {}".format(sku))
        _set_status(__in_queue__, sku)
        response = {"status": status}
    except Exception as e:
        logger.exception(e)
        response = {"status": __error__}
    return response
Exemple #38
0
def run(script, debug):
    _, session = init_db()
    command_obj = get_command(session, script)
    lines = load_file(command_obj.filepath)
    header, content = separate_headers(lines)
    if header_check(session, header, script, content):
        command_traitement(content, debug=debug)
Exemple #39
0
def _get_product_details(source, url, sku):
    """
    Scrape product metadata.

    :param url: canonical product url
    :return number of reviews and product name
    """
    sc = scraper.Scraper(source=source)
    response = sc.get_request(url)
    pr = parser.Parser(sku=sku, source=source)
    res = pr.parse(response, init=True)
    if res:
        # Save it to the database
        db_details = DB.init_db(config.get("details_db"))
        db_details = db_details.product_details
        record = {
            "status": "processing",
            "url": url,
            "product_name": res.get("product_name"),
            "review_count": res.get("review_count"),
            "review_page_count": res.get("page_count"),
            "source": source,
            "sku": sku,
            "img": res.get("img_url"),
            "timestamp": time.time(),
        }
        db_details.insert_one(record)
        logger.info("Saved new product details: ")
        logger.info(record)
    return res
Exemple #40
0
def startup():
    err = init_db(app)
    if err:
        app.logger.error(f'DB: {err}')
        sys.exit(1)
    app.logger.info('DB connect')
    proc.start()
Exemple #41
0
def _db_product_details(sku):
    """
    Return product details from the database.
    """
    db_details = DB.init_db(config.get("details_db")).product_details
    product = list(db_details.find({"sku": sku}))
    if product:
        product_name = product[0].get("product_name")
        product_url = product[0].get("url")
        image_url = product[0].get("img")
        review_count = product[0].get("review_count")
        page_count = product[0].get("review_page_count")
        valid = all(
            [product_name, product_url, image_url, review_count, page_count])
        if valid:
            return {
                "product_name": product_name,
                "review_count": review_count,
                "page_count": page_count,
            }
        else:
            logger.info(
                "Unable to validate product details for {}. Deleting entry".
                format(sku))
            db_details.delete_one({"sku": sku})
    return {}
Exemple #42
0
def home():
    conn, c = init_db()
    conn.row_factory = lambda cursor, row: row[0]
    files = c.execute(
        """SELECT pdf_path, xlsx_path, title, subject, author FROM file"""
    ).fetchall()
    return render_template('home.html', files=files)
Exemple #43
0
def _update_details_db(sku):
    """
    Update the status field of 
    """
    db_details = DB.init_db(config.get("details_db")).product_details
    record = {"status": "ready"}
    db_details.update_one({"sku": sku}, {"$set": record})
Exemple #44
0
def main():
    mydb = db.init_db()
    s = db.select(mydb.curs)
    products = p.list_of_products()
    v = view.view(s)
    c = controller(v, s, mydb, products)
    c.main_menu_loop()
Exemple #45
0
def _pages_update(context, data_dict):
    if db.pages_table is None:
        db.init_db(context['model'])
    org_id = data_dict.get('org_id')
    page = data_dict.get('page')
    # we need the page in the context for name validation
    context['page'] = page
    context['group_id'] = org_id

    data, errors = df.validate(data_dict, schema, context)

    if errors:
        raise p.toolkit.ValidationError(errors)

    out = db.Page.get(group_id=org_id, name=page)
    if not out:
        out = db.Page()
        out.group_id = org_id
        out.name = page
    items = [
        'title',
        'content',
        'name',
        'private',
        'order',
        'page_type',
        'publish_date',
        'image_url',
    ]
    for item in items:
        # backward compatible with older version where page_type does not exist
        setattr(out, item,
                data.get(item, 'page' if item == 'page_type' else None))

    extras = {}
    extra_keys = set(schema.keys()) - set(items + ['id', 'created'])
    for key in extra_keys:
        if key in data:
            extras[key] = data.get(key)
    out.extras = json.dumps(extras)

    out.modified = datetime.datetime.utcnow()
    out.user_id = p.toolkit.c.userobj.id
    out.save()
    session = context['session']
    session.add(out)
    session.commit()
def update_datarequest_comment(context, data_dict):
    '''
    Action to update a comment of a data request. Access rights will be checked
    before updating the comment and a NotAuthorized exception will be risen if
    the user is not allowed to update the comment

    :param id: The ID of the comment to be updated
    :type id: string

    :param comment: The updated comment
    :type comment: string

    :returns: A dict with the data request comment (id, user_id, datarequest_id,
        time and comment)
    :rtype: dict
    '''

    model = context['model']
    session = context['session']
    comment_id = data_dict.get('id', '')

    if not comment_id:
        raise tk.ValidationError([tk._('Comment ID has not been included')])

    # Init the data base
    db.init_db(model)

    # Check access
    tk.check_access(constants.UPDATE_DATAREQUEST_COMMENT, context, data_dict)

    # Get the data request
    result = db.Comment.get(id=comment_id)
    if not result:
        raise tk.ObjectNotFound(tk._('Comment %s not found in the data base') % comment_id)

    comment = result[0]

    # Validate data
    validator.validate_comment(context, data_dict)

    # Set the data provided by the user in the data_red
    _undictize_comment_basic(comment, data_dict)

    session.add(comment)
    session.commit()

    return _dictize_comment(comment)
def datarequest_create(context, data_dict):
    '''
    Action to create a new dara request. The function checks the access rights
    of the user before creating the data request. If the user is not allowed
    a NotAuthorized exception will be risen.

    In addition, you should note that the parameters will be checked and an
    exception (ValidationError) will be risen if some of these parameters are
    not valid.

    :param title: The title of the data request
    :type title: string

    :param description: A brief description for your data request
    :type description: string

    :param organiztion_id: If you want to create the data request in a specific
        organization.
    :type organization_id: string

    :returns: A dict with the data request (id, user_id, title, description,
        organization_id, open_time, accepted_dataset, close_time, closed)
    :rtype: dict
    '''

    model = context['model']
    session = context['session']

    # Init the data base
    db.init_db(model)

    # Check access
    tk.check_access(constants.DATAREQUEST_CREATE, context, data_dict)

    # Validate data
    validator.validate_datarequest(context, data_dict)

    # Store the data
    data_req = db.DataRequest()
    _undictize_datarequest_basic(data_req, data_dict)
    data_req.user_id = context['auth_user_obj'].id
    data_req.open_time = datetime.datetime.now()

    session.add(data_req)
    session.commit()

    return _dictize_datarequest(data_req)
Exemple #48
0
def _pages_show(context, data_dict):
    if db.pages_table is None:
        db.init_db(context['model'])
    org_id = data_dict.get('org_id')
    page = data_dict.get('page')
    order = data_dict.get('order')
    lang = data_dict.get('lang')

    out = None
    if page or org_id:
        out = db.Page.get(group_id=org_id, name=page)
    elif lang and order:
        out = db.Page.get(order=order, lang=lang)

    if out:
        out = db.table_dictize(out, context)
    return out
Exemple #49
0
def datarequest_comment(context, data_dict):
    '''
    Action to create a comment in a data request. Access rights will be checked
    before creating the comment and a NotAuthorized exception will be risen if
    the user is not allowed to create the comment

    :param datarequest_id: The ID of the datarequest to be commented
    :type id: string

    :param comment: The comment to be added to the data request
    :type comment: string

    :returns: A dict with the data request comment (id, user_id, datarequest_id,
       time and comment)
    :rtype: dict

    '''

    model = context['model']
    session = context['session']
    datarequest_id = data_dict.get('datarequest_id', '')

    # Check id
    if not datarequest_id:
        raise tk.ValidationError(
            [tk._('Data Request ID has not been included')])

    # Init the data base
    db.init_db(model)

    # Check access
    tk.check_access(constants.DATAREQUEST_COMMENT, context, data_dict)

    # Validate comment
    validator.validate_comment(context, data_dict)

    # Store the data
    comment = db.Comment()
    _undictize_comment_basic(comment, data_dict)
    comment.user_id = context['auth_user_obj'].id
    comment.time = datetime.datetime.now()

    session.add(comment)
    session.commit()

    return _dictize_comment(comment)
Exemple #50
0
def init_db():
    # Make sure we have the tables up-to-date in the DB
    db.init_db()

    SITE_ROOT = os.path.realpath(os.path.dirname(__file__))
    main_dir = os.path.join(SITE_ROOT, "views", "resources", "GEOJSON")
    # Some GeoJSON files are not meant to be used in the graph, and thus should not be imported in
    # the DB. Don't even try, this will raise an error
    excluded_filenames = ['CONTOUR.geojson']
    filenames = [
        filename for filename in os.listdir(main_dir)
        if filename.endswith('.geojson') and filename not in excluded_filenames
    ]
    for filename in filenames:
        with open(os.path.join(main_dir, filename)) as file:
            insert_features_in_db(filename, json.loads(file.read()))
            print(f"Inserted features of {filename}")
Exemple #51
0
def app():
    db_fd, db_path = tempfile.mkstemp()

    app = create_app({
        'TESTING': True,
        'DATABASE': db_path,
        # Set the folder path for testing. All uploaded files will be saved here
        'UPLOAD_FOLDER': './testing_files'
    })

    with app.app_context():
        init_db()

    yield app

    os.close(db_fd)
    os.unlink(db_path)
 def approve_worker(self, worker, force=False):
     ''' Approve worker '''
     assignment_id = worker['assignmentId']
     init_db()
     found_worker = False
     parts = Participant.query.\
            filter(Participant.assignmentid == assignment_id).\
            filter(Participant.status.in_([3, 4])).\
            all()
     # Iterate through all the people who completed this assignment.
     # This should be one person, and it should match the person who
     # submitted the HIT, but that doesn't always hold.
     status_report = ''
     for part in parts:
         if part.workerid == worker['workerId']:
             found_worker = True
             success = self.amt_services.approve_worker(assignment_id)
             if success:
                 part.status = 5
                 db_session.add(part)
                 db_session.commit()
                 status_report = 'approved worker {} for assignment {}'.format(part.workerid, assignment_id)
             else:
                 error_msg = '*** failed to approve worker {} for assignment {}'.format(part.workerid, assignment_id)
                 raise Exception(error_msg)
         else:
             status_report = 'found unexpected worker {} for assignment {}'.format(part.workerid, assignment_id)
     if not found_worker:
         # approve workers not found in DB if the assignment id has been specified
         if force:
             success = self.amt_services.approve_worker(assignment_id)
             if success:
                 _status_report = 'approved worker {} for assignment {} but not found in DB'.format(worker['workerId'], assignment_id)
                 status_report = '\n'.join([status_report,_status_report])
             else:
                 error_msg = '*** failed to approve worker {} for assignment {}'.format(worker['workerId'], assignment_id)
                 raise Exception(error_msg)
         # otherwise don't approve, and print warning
         else:
             _status_report = 'worker {} not found in DB for assignment {}. Not automatically approved. Use --force to approve anyway.'.format(worker['workerId'], assignment_id)
             if status_report:
                 status_report = '\n'.join([status_report,_status_report])
             else:
                 status_report = _status_report
     return status_report
Exemple #53
0
def telephone_n(message: Message):
    global telephone
    telephone = int(message.text)
    init_db()
    add_reg_info_in_db(chat_id=message.chat.id, company_id=CompanyID, name=name, surname=surname,
                       telephone=telephone, day=day, start_time=start_time, end_time=end_time)
    bot.send_message(message.from_user.id, "Ձեր անձնական տվյալներն են \n\n Անուն : " + name + "\n Ազգանուն : " +
                     surname + "\n Կազմակերպության ID : " + str(CompanyID) + "\n Աշխատանքային գրաֆիկ : " + day + " " +
                     start_time + "-" + end_time +
                     "\n Հեռախոսահամար ։ 0" + str(telephone))


    whole_info = "Նոր գրանցում \n\n Անուն : " + name + "\n Ազգանուն : " + surname + "\n Կազմակերպության ID : " + str(CompanyID) + "\n Աշխատանքային գրաֆիկ : " + "\n Հեռախոսահամար ։ 0" + str(telephone)
    mail = fromCompanyId_adminCheck(company_id=CompanyID)
    if(mail):
        sendMailAfterRegister(mail, whole_info)
    else:
        print("something happened, we didn't send")
Exemple #54
0
def command(value, vars):
    from lmparser import load_file, header_check, separate_headers, command_traitement
    _, session = init_db()
    command_obj = get_command(session, value)
    lines = load_file(command_obj.filepath)
    header, content = separate_headers(lines)
    if header_check(session, header, value, content):
        command_traitement(content)
    return
Exemple #55
0
def telephone_n(message: Message):
    global telephone
    telephone = int(message.text)
    init_db()
    add_reg_info_in_db(chat_id=message.chat.id,
                       company_id=CompanyID,
                       name=name,
                       surname=surname,
                       telephone=telephone,
                       day=day,
                       start_time=start_time,
                       end_time=end_time)
    bot.send_message(
        message.from_user.id, "Ձեր անձնական տվյալներն են \n\n Անուն : " +
        name + "\n Ազգանուն : " + surname + "\n Կազմակերպության ID : " +
        str(CompanyID) + "\n Աշխատանքային գրաֆիկ : " + day + " " + start_time +
        "-" + end_time + "\n Հեռախոսահամար ։ 0" + str(telephone))
    """քոմենտել եմ որտև Էռոռա տալիս """
Exemple #56
0
def _nlp_reset(sku):
    """
    Clear the database of any existing sentences for sku.

    :param sku: product sku
    """
    db_sents = DB.init_db(config.get("sent_db")).sentences
    db_sents.delete_many({"sku": sku})
    logger.info("Cleared sentence table for " + sku)
Exemple #57
0
def create_app():
    """
    Initialize Flask and setup database

    """
    app = CustomFlask(__name__)
    app.config.from_mapping(SECRET_KEY=os.urandom(16),
                            CACHED_TIME=time.time(),
                            THEME_DIR="./data/theme.json")

    # Init database
    import db
    db.init_db()

    # Init github cache
    from utils.github import update_public_repos
    db_conn = db.get_db()
    update_public_repos(db_conn)

    # Init meidum cache
    db_conn = db.get_db()
    with open(app.config["THEME_DIR"], "r") as f:
        data = json.load(f)
        medium_url = data["medium_url"]
    from utils.medium import update_articles
    update_articles(db_conn, medium_url)

    # Register blueprints
    import home
    app.register_blueprint(home.bp)

    import auth
    app.register_blueprint(auth.bp)

    # Initialize login manager
    login_manager = LoginManager()
    login_manager.init_app(app)

    @login_manager.user_loader
    def user_loader(username):
        db_conn = db.get_db()
        return get_user(db_conn, username)

    return app
def unfollow_datarequest(context, data_dict):
    '''
    Action to unfollow a data request. Access rights will be cheked before
    unfollowing a datarequest and a NotAuthorized exception will be risen if
    the user is not allowed to unfollow the given datarequest. ValidationError
    will be risen if the datarequest ID is not included in the request.
    ObjectNotFound will be risen if the user is not following the given
    datarequest.

    :param id: The ID of the datarequest to be unfollowed
    :type id: string

    :returns: True
    :rtype: bool
    '''

    model = context['model']
    session = context['session']
    datarequest_id = data_dict.get('id', '')

    if not datarequest_id:
        raise tk.ValidationError(
            [tk._('Data Request ID has not been included')])

    # Init the data base
    db.init_db(model)

    # Check access
    tk.check_access(constants.UNFOLLOW_DATAREQUEST, context, data_dict)

    # Is already following?
    user_id = context['auth_user_obj'].id
    result = db.DataRequestFollower.get(datarequest_id=datarequest_id,
                                        user_id=user_id)
    if not result:
        raise tk.ObjectNotFound(
            [tk._('The user is not following the given Data Request')])

    follower = result[0]

    session.delete(follower)
    session.commit()

    return True
Exemple #59
0
def slack_channels_show(context, data_dict):
    '''
    Action to retrieve the slack notification channels. The only required
    parameter is the name of the organization passed as id. A NotFound
    exception will be risen if the organization id is not found.
    Access rights will be checked before returning the information and an
    exception will be risen (NotAuthorized) if the user is not authorized.
    :param context: the context of the request
    :type context: dict
    :param data_dict: Contains the following
    organization_id: The ID of the organization
    :type data_dict: dict
    :returns: A list of the slack notification details(id,
        organization_id, webhook_url, slack_channel)
    :rtype: list
    '''

    model = context['model']
    organization_id = data_dict.get('organization_id')
    success = data_dict.get('success', False)

    if not organization_id and not success:
        raise toolkit.ValidationError(
            toolkit._('Organization ID has not been included'))

    # Init the data base
    db.init_db(model)

    # Check access
    if not success:
        toolkit.check_access(constants.MANAGE_NOTIFICATIONS, context,
                             data_dict)

    # Get the available slack channels
    result = db.Org_Slack_Details.get(organization_id=organization_id)
    if result:
        slack_channels = [
            _dictize_slack_details(channel) for channel in result
        ]
    else:
        slack_channels = []

    return slack_channels
Exemple #60
0
def search_list(context, data_dict):
    '''
    List the search history

    :param limit: The number of items to show (optional, default: 10)
    :type limit: int
    '''
    tk.check_access('ckanext_search_history_list', context, data_dict)
    if db.search_history_table is None:
        db.init_db(context['model'])
    username = context.get('user')
    user = new_authz.get_user_id_for_username(username, allow_none=False)
    limit = data_dict.get('limt')
    history = db.SearchHistory.search_history(user_id=user, limit=limit)
    result = []
    if history:
        for item in history:
            result.append(db.table_dictize(item, context))
    return result