Пример #1
0
	def delete(self, book_id):
		is_lent = query_db("select recipient from loan where book = ? and status = 2", (book_id,), one=True)
		if is_lent:
			return ('Cannot delete lent book', 403)
		else:
			query_db("delete from book where id = ?", (book_id,))
			return ('', 204)
Пример #2
0
	def get(self, loan_id=None):
		if loan_id:
			loan = query_db("select id, book, recipient, start, span, status from loan where id = ?", (loan_id,), one=True)
			if loan:
				return jsonify({
					"id": loan[0],
					"book": loan[1],
					"recipient": loan[2],
					"start": loan[3],
					"span": loan[4],
					"status": loan[5]
				})
			else:
				return ('', 404)
		else:
			loans = query_db(
				"select id, book, recipient, start, span, status from loan "
				"where book in (select id from book where owner = ?) and status in (0, 2)", (g.user,))
			return jsonify([{
				"id": loan[0],
				"book": {
					field: value
					for (field, value) in zip(
						["id", "owner", "title", "author", "year"],
						query_db("select * from book where id = ?", (loan[1],), one=True))},
				"recipient": loan[2],
				"start": loan[3],
				"span": loan[4],
				"status": loan[5]
			} for loan in loans])
Пример #3
0
	def put(self, book_id):
		updatable_fields = ["title", "author", "year"]
		query = (
			"update book set "
			+ (", ".join([
				"%s = ?" % (field,)
				for (field, value) in request.form.items() if field in updatable_fields and value]))
			+ " where id = ?")
		query_db(query, [value for (field, value) in request.form.items() if field in updatable_fields and value] + [book_id])
		return self.get(book_id)
Пример #4
0
    def test_query_db_exception(self):
        dbconnection = Mock(name="dbconnection")
        mycursor = Mock(name="mycursor")
        mycursor.fetchall.side_effect = Exception
        dbconnection.cursor.return_value = mycursor

        with self.assertRaises(Exception) as cm:
            utils.query_db(dbconnection, 12345)
        self.assertEqual(str(
            cm.exception), 'Error while executing query : 12345. Please check the logs for details')
Пример #5
0
def submitmessage():
    message = request.form.get("message", '')
    if len(message) > 140:
        return "message too long"
    if badword_in_str(message):
        return "forbidden word in message"
    # insert new message in DB
    try:
        query_db("insert into messages values ('%s')" % message)
    except sqlite3.Error as e:
        return str(e)
    return "OK"
def handler():
    global last_msg_name, last_timestamp
    q = json.loads(request.args.get('q'))
    if q['suid'] == '995':
        return '0'

    if tester.finished:
        cprint('wrong, should not receive question', 'red')

    msg_name = get_message_name(q)
    print(msg_name)
    now = datetime.datetime.now()

    enjoyable = 'enjoyable' in last_msg_name
    other_actions = 'timeout' in last_msg_name or \
                    'breathing' in last_msg_name or \
                    'bodyscan' in last_msg_name



    if not tester.at_correct_state(q):
        cprint('state wrong', 'red')

    elif not tester.at_expected_time(now):
        cprint('time wrong', 'red')
        print(tester.expected_time)
        print(now)

    elif enjoyable and \
      not (datetime.timedelta(seconds=35) < now - last_timestamp < datetime.timedelta(seconds=37)):
        cprint('enjoyable time wrong', 'red')

    elif other_actions and \
      not (datetime.timedelta(seconds=17) < now - last_timestamp < datetime.timedelta(seconds=19)):
        cprint('breathing/bodyscan/timeout time wrong', 'red')
    else:
        cprint('right', 'green')

    ans = tester.cur_state_response

    if ans != None:
        primkey = f'{q["id"]}:{q["empathid"]}'
        retrieval_code = get_message_info(q)["retrieval_object"]

        query_db(f'INSERT INTO ema_data(suid, primkey, variablename, answer, language, mode, version, completed) \
            VALUES ("{q["suid"]}", "{primkey}", "{retrieval_code}", "{ans}", 1, 3, 1, 1) ')
    
    tester.increment()
    last_msg_name = msg_name
    last_timestamp = now
   
    return '0'
Пример #7
0
def debts():
	debts = query_db("select id, book, start, span, status from loan where recipient = ? and status = 2", (g.user,))
	return jsonify([{
		"id": debt[0],
		"book": {
			field: value
			for (field, value) in zip(
				["id", "owner", "title", "author", "year"],
				query_db("select * from book where id = ?", (debt[1],), one=True))},
		"lender": query_db("select owner from book where id = ?", (debt[1],), one=True)[0],
		"start": debt[2],
		"span": debt[3],
		"status": debt[4]
	} for debt in debts])
Пример #8
0
def get_token():
	username = request.form['username']
	password = request.form['password']
	hashed_password = query_db("select password from user where username = ?", (username,), one=True)
	if (
		hashed_password is not None
		and bcrypt.checkpw(password.encode("utf-8"), hashed_password[0].encode("utf-8"))
	):
		token = query_db("select token from user_token where username = ?", (username,), one=True)
		if token is None:
			token = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(40))
			query_db("insert into user_token (username, token) values (?, ?)", (username, token))
		return jsonify({"token": token})
	else:
		return jsonify({"error": "Bad credentials"}), 401
Пример #9
0
def test(args):
    import sqlite3

    # Create the test db in RAM
    db = sqlite3.connect(":memory:")
    #db.text_factory = str

    # Create the whitelist to be tested
    whitelist = Whitelist(db)

    # Add a record
    call_record = {
        "NAME": "Bruce",
        "NMBR": "1234567890",
        "DATE": "1012",
        "TIME": "0600"
    }
    whitelist.add_caller(call_record)

    # List the records
    query = 'SELECT * from Whitelist'
    results = utils.query_db(db, query)
    print "Query results:"
    print results

    number = "1234567890"
    print "Check number: " + number
    print whitelist.check_number(number)
    print "Check wrong number:"
    print whitelist.check_number("1111111111")
    print "Get number:"
    print whitelist.get_number(number)

    return 0
Пример #10
0
    def log_caller(self, callerid):
        query = """INSERT INTO CallLog(
            Name,
            Number,
            Date,
            Time,
            SystemDateTime)
            VALUES(?,?,?,?,?)"""
        arguments = [
            callerid['NAME'], callerid['NMBR'],
            datetime.strptime(callerid['DATE'], '%m%d').strftime('%d-%b'),
            datetime.strptime(callerid['TIME'], '%H%M').strftime('%I:%M %p'),
            (datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
        ]

        self.db.execute(query, arguments)
        self.db.commit()

        query = "select last_insert_rowid()"
        result = utils.query_db(self.db, query, (), True)
        call_no = result[0]

        if self.config["DEBUG"]:
            print("> New call log entry #{}".format(call_no))
            pprint(arguments)

        return call_no
Пример #11
0
def keywords_cases(keywords):
    keywords = keywords.split(',')
    query_str = query_str_start() + 'WHERE '
    for keyword in keywords:
        query_str += '"' + keyword + '" IN case.keywords AND '
    query_str += '1 = 1' + query_str_end()
    return form_json(query_db(query_str))
Пример #12
0
def appeal(reference_p1, reference_p2, reference_p3):
	reference_p1 = str(reference_p1)
	reference_p2 = str(reference_p2)
	reference_p3 = str(reference_p3)
	query_str = query_str_start(True) + 'WHERE appeal.reference = "' + reference_p1 + '/' + reference_p2 + '/' + reference_p3 + '"' + query_str_end(True) + ' LIMIT 1'
	result = query_db(query_str)
	return form_json(result)
Пример #13
0
def test(args):
    import sqlite3
    import utils

    # Create the test db in RAM
    db = sqlite3.connect(":memory:")

    # Create the logger to be tested
    logger = CallLogger(db)

    # Add a record
    callerid = {
        "NAME": "Bruce",
        "NMBR": "1234567890",
        "DATE": "1012",
        "TIME": "0600"
    }
    logger.log_caller(callerid)

    # List the records
    query = "SELECT * FROM CallLog"
    results = utils.query_db(db, query)
    print "Query results:"
    print results

    return 0
Пример #14
0
def keywords_cases(keywords):
	keywords = keywords.split(',')
	query_str = query_str_start() + 'WHERE '
	for keyword in keywords:
		query_str += '"' + keyword + '" IN case.keywords AND '
	query_str += '1 = 1' + query_str_end()
	return form_json(query_db(query_str))
Пример #15
0
def case(reference_p1, reference_p2):
    reference_p1 = str(reference_p1)
    reference_p2 = str(reference_p2)
    query_str = query_str_start(
    ) + 'WHERE case.reference = "' + reference_p1 + '/' + reference_p2 + '"' + query_str_end(
    ) + ' LIMIT 1'
    result = query_db(query_str)
    return form_json(result)
Пример #16
0
	def get(self):
		profile = query_db("select username, first_name, last_name from user where username = ?", (g.user,), one=True)
		if profile is not None:
			username, first_name, last_name = profile
		return jsonify({
			"username": username,
			"first_name": first_name,
			"last_name": last_name
		})
Пример #17
0
def appeal(reference_p1, reference_p2, reference_p3):
    reference_p1 = str(reference_p1)
    reference_p2 = str(reference_p2)
    reference_p3 = str(reference_p3)
    query_str = query_str_start(
        True
    ) + 'WHERE appeal.reference = "' + reference_p1 + '/' + reference_p2 + '/' + reference_p3 + '"' + query_str_end(
        True) + ' LIMIT 1'
    result = query_db(query_str)
    return form_json(result)
Пример #18
0
    def test_get_client_object(self):
        dbconnection = Mock(name="dbconnection")
        mycursor = Mock(name="mycursor")
        mycursor.fetchall.return_value = "testing_return_value"
        dbconnection.cursor.return_value = mycursor

        self.assertEqual("testing_return_value",
                         utils.query_db(dbconnection, 12345))
        dbconnection.cursor.assert_called_once()
        mycursor.execute.assert_called_once_with(12345)
        mycursor.fetchall.assert_called_once()
Пример #19
0
def book_search():
	query = request.args["q"]
	page = int(request.args.get("page", 1))
	size = int(request.args.get("size", 10))
	book_count = int(query_db(
		"select count(*) from book where title like ? or author like ?",
		("%" + query + "%", "%" + query + "%"), one=True)[0])
	books = query_db(
		"select id, owner, title, author, year from book where title like ? or author like ? limit ? offset ?",
		("%" + query + "%", "%" + query + "%", size, (page - 1) * size))
	response = jsonify([{
		"id": id,
		"owner": owner,
		"title": title,
		"author": author,
		"year": year,
		"bearer": (
			query_db("select recipient from loan where book = ? and status = 2", (id,), one=True)[0]
			if query_db("select recipient from loan where book = ? and status = 2", (id,), one=True) else None),
	} for (id, owner, title, author, year) in books])
	response.headers["page-count"] = math.ceil(book_count / size)
	return response
Пример #20
0
	def get(self, book_id=None):
		if not book_id:
			page = int(request.args.get("page", 1)) - 1
			size = int(request.args.get("size", 10))
			book_count = int(query_db("select count(*) from book where owner = ?", (g.user,), one=True)[0])
			books = query_db(
				"select id, title, author, year "
				"from book where owner = ? "
				"order by title collate nocase "
				"limit ? offset ?", (g.user, size, page * size))
			response = jsonify([{
				"id": id,
				"title": title,
				"owner": g.user,
				"author": author,
				"year": year,
				"bearer": (
					query_db("select recipient from loan where book = ? and status = 2", (id,), one=True)[0]
					if query_db("select recipient from loan where book = ? and status = 2", (id,), one=True)
					else None),
			} for (id, title, author, year) in books])
			response.headers["page-count"] = math.ceil(book_count / size)
			return response
		else:
			try:
				id_, owner, title, author, year = query_db(
					"select id, owner, title, author, year from book where id = ?", (book_id,), one=True)
			except TypeError:
				return ('', 404)
			return jsonify({
				"id": id_,
				"owner": owner,
				"title": title,
				"author": author,
				"year": year
			})
Пример #21
0
def processFailedJobs(jobs, conn):
    finishedJobs = query_db(conn, "SELECT * FROM jobs  WHERE status='FAILED'")
    for finishedJob in finishedJobs:
        c = conn.cursor()
        c.execute(
            "UPDATE jobs SET status='ERROR', lastchange=? WHERE id=? and status='FAILED'",
            (time.time(), finishedJob['id']))
        conn.commit()
        if c.rowcount:
            nextJobID = finishedJob['next_job']
            c = conn.cursor()
            c.execute(
                "UPDATE requests SET status='ERROR', lastchange=? WHERE uuid=?",
                (time.time(), finishedJob['uuid']))
            conn.commit()
Пример #22
0
def test(db, config):
    """ Unit Tests """

    print("*** Running Blacklist Unit Tests ***")

    # Create the blacklist to be tested
    blacklist = Blacklist(db, config)

    # Add a record
    callerid = {
        "NAME": "Bruce",
        "NMBR": "1234567890",
        "DATE": "1012",
        "TIME": "0600",
    }
    blacklist.add_caller(callerid, "Test")

    # List the records
    query = 'select * from Blacklist'
    results = utils.query_db(db, query)
    print(query + " results:")
    pprint(results)

    try:
        number = "1234567890"
        print("Assert is blacklisted: " + number)
        assert blacklist.check_number(
            number), number + " should be blacklisted"

        number = "1111111111"
        print("Assert not blacklisted: " + number)
        assert not blacklist.check_number(
            number), number + " should not be blacklisted"

        number = "1234567890"
        print("Get number: " + number)
        caller = blacklist.get_number(number)
        pprint(caller)
        assert caller[0][
            0] == number, number + " should match get_number " + caller[0][0]

    except AssertionError as e:
        print("*** Unit Test FAILED ***")
        pprint(e)
        return 1

    print("*** Unit Tests PASSED ***")
    return 0
def generate_recs_from_model(meta_path, tfidf_path, model_path):
    print("Generating Recommendations...")
    sqldb = connect_db(db_path)
    records = query_db(
        sqldb,
        '''select feedurl, author, id, title, content, flags from rss_item order by pubDate DESC LIMIT 200;'''
    )
    content_list = []
    outcome_list = []
    id_list = []
    title_list = []
    for record in records:
        # We should not judge the book by it's cover
        content_list.append('||' + record['feedurl'] + '|| \n ||' +
                            record['author'] + '|| \n ||' + record['title'] +
                            '|| \n' + record['content'])
        outcome_list.append(
            (record['flags'] is not None and 'r' not in record['flags']
             and 's' in record['flags']) * 1)
        id_list.append(record['id'])
        # Yes, we are judging the book by it's cover but we are using the cool NLP model to judge
        title_list.append(record['title'])
    print("Total %d feed items found" % (len(content_list)))
    print(content_list[0])
    #Loading the pickle files
    meta = pickle.load(open(meta_path, 'rb'))
    out = pickle.load(open(tfidf_path, 'rb'))
    model = pickle.load(open(model_path, 'rb'))
    v = out['v']
    print("Projecting them to a mathematical space..")
    X_tfidf = v.transform(content_list)
    X_smart = cool_nlp_model.encode(title_list)
    clf = model['clf']
    beclf = model['beclf']
    y = out['y']
    X_tfidf = X_tfidf.todense().astype(np.float32)
    y = np.array(y).astype(np.float32)
    print("Recommending...")
    s_tfidf = clf.decision_function(X_tfidf)
    s_smart = beclf.decision_function(X_smart)
    s = s_smart * 0.65 + s_tfidf * 0.35
    sortix = np.argsort(-s)
    recs = sortix[y[sortix] == 0]
    recs = recs[:max_recommendations]
    print(recs)
    print([id_list[x] for x in recs])
    return [id_list[x] for x in recs]
Пример #24
0
def processNewRequests(jobs, conn):
    pendingRequests = query_db(
        conn, "SELECT * FROM requests  WHERE status='INSERTED'")
    for pendingRequest in pendingRequests:
        c = conn.cursor()
        c.execute(
            "UPDATE requests SET status='PROCESSING', lastchange=? WHERE uuid=? and status='INSERTED'",
            (time.time(), pendingRequest['uuid']))
        conn.commit()

        if c.rowcount:
            jobID = jobs.keys()[0]
            insertJOB(conn,
                      jobID=jobID,
                      next_job=jobs[jobID][1],
                      jobCommand=jobs[jobID][0],
                      requestUUID=pendingRequest['uuid'])
Пример #25
0
def user_login():
    params = request.form
    user_name = params.get('username')
    passwd = params.get('pwd')
    query_res = query_db("SELECT * FROM userinfo WHERE username=?",
                         args=(user_name, ),
                         one=True)
    if query_res is not None and query_res['pwd'] == passwd:
        response = {'code': 0, 'msg': 'success!'}
        session['username'] = user_name
        logger.info('{} log in success!'.format(user_name))
    else:
        response = {'code': 1, 'msg': 'user does not exist!'}
        logger.warning(
            '{} attempt to log in the system with the wrong password!'.format(
                user_name))
    return jsonify(response)
def generate_tfidf_pickles():
    """Gets all the read articles and considers those articles flagged as 's' as 1 and rest as 0 
    and produces the embeddings
    """
    sqldb = connect_db(db_path)
    records = query_db(sqldb, '''select feedurl, author, id, title, content, flags from rss_item where unread=0 order by pubDate DESC;''')
    content_list = []
    outcome_list = []
    id_list = []
    title_list = []
    for record in records:
        # We should not judge the book by it's cover
        content_list.append('||'+ record['feedurl'] + '|| \n ||' + record['author'] + '|| \n ||' + record['title'] + '|| \n' + record['content'])
        outcome_list.append((record['flags'] is not None and 'r' not in record['flags'] and 's' in record['flags']) * 1)
        id_list.append(record['id'])
        # Yes, we are judging the book by it's cover but we are using the cool NLP model to judge
        title_list.append(record['title']) 
    print("Total %d feed items found" %(len(content_list)))
    print(content_list[0])
    # compute tfidf vectors with scikits
    v = TfidfVectorizer(input='content', 
            encoding='utf-8', decode_error='replace', strip_accents='unicode', 
            lowercase=True, analyzer='word', stop_words='english', 
            token_pattern=r'(?u)\b[a-zA-Z_][a-zA-Z0-9_]+\b',
            ngram_range=(1, 2), max_features = max_features, 
            norm='l2', use_idf=True, smooth_idf=True, sublinear_tf=True,
            max_df=1.0, min_df=1)
    v.fit(content_list)
    print("Projecting them to a mathematical space..")
    X_tfidf = v.transform(content_list)
    X_smart = cool_nlp_model.encode(title_list)
    out = {}
    out['X_tfidf'] = X_tfidf
    out['X_smart'] = X_smart
    out['y'] = outcome_list
    out['v'] = v
    #print("writing", tfidf_path)
    safe_pickle_dump(out, tfidf_path)
    out = {}
    out['vocab'] = v.vocabulary_
    out['idf'] = v._tfidf.idf_
    out['ids'] = id_list
    out['idtoi'] = {x:i for i,x in enumerate(id_list)}
    #print("Writing Meta Data")
    safe_pickle_dump(out, meta_path)
Пример #27
0
def get_data():
    query = "SELECT top 1000 * FROM obsPointing WHERE obs_collection='K2' AND dataproduct_type='image'"
    df = query_db(CAOM, query)
    if len(df) == 0:
        return None

    df['coords'] = df.apply(lambda x: parse_s_region(x['s_region']), axis=1)

    # Generate MOC
    results = [get_polygon_moc(row) for _, row in df.iterrows()]

    # Union of MOCs
    if len(results) > 1:
        moc = MOC.union(*results)
    else:
        moc = results

    return moc
Пример #28
0
def create_resource(ontology_):
    ont = query_db('select * from ontologies where prefix = ?', [ontology_], one=True)
    # if this is a post, call the "autosave" function and redirect to the resource uri
    if request.method == 'POST':
        uri = request.form.get('uri')
        autosave()
        return redirect(url_for('ontology', ontology_=ontology_, resource_=uri))
    properties = {}
    properties[RDF.type] = {'value': [{'type':"URI", 'value':"", 'class':'added'}],
                            'qname': 'rdf:type', 
                            'label': 'type'}
    properties[RDFS.label] = {'value': [{'type':"Literal", 'value':"", 'class':'added'}],
                              'qname': 'rdfs:label', 
                              'label': 'label'}
    return render_template('resource.html', ontology_=ont, 
                           properties_=properties,
                           uri=ont['context'],
                           name='Create New Resource',
                           is_new=True,
                           auto_save=False)
Пример #29
0
def test(db, config):
    ''' Unit Tests '''
    print("*** Running Whitelist Unit Tests ***")

    import utils

    # Create the logger to be tested
    logger = CallLogger(db, config)

    # Caller to be added
    callerid = {
        "NAME": "Bruce",
        "NMBR": "1234567890",
        "DATE": "1012",
        "TIME": "0600"
    }

    print("Adding caller:")
    pprint(callerid)

    try:
        print("Assert log_caller returns #1")
        assert logger.log_caller(callerid) == 1, "call # should be 1"

        print("Assert log_caller returns #2")
        assert logger.log_caller(callerid) == 2, "call # should be 2"

        # List the records
        query = "SELECT * FROM CallLog"
        results = utils.query_db(db, query)
        print(query + " results:")
        pprint(results)

    except AssertionError as e:
        print("*** Unit Test FAILED ***")
        pprint(e)
        return 1

    print("*** Unit Tests PASSED ***")
    return 0
Пример #30
0
def processFinishedJobs(jobs, conn):
    finishedJobs = query_db(conn,
                            "SELECT * FROM jobs  WHERE status='FINISHED'")
    for finishedJob in finishedJobs:
        print('HAVE')
        c = conn.cursor()
        c.execute(
            "UPDATE jobs SET status='DONE', lastchange=? WHERE id=? and status='FINISHED'",
            (time.time(), finishedJob['id']))
        conn.commit()
        if c.rowcount:
            nextJobID = finishedJob['next_job']
            if nextJobID != 'DONE':
                insertJOB(conn,
                          jobID=nextJobID,
                          next_job=jobs[nextJobID][1],
                          jobCommand=jobs[nextJobID][0],
                          requestUUID=finishedJob['uuid'])
            else:
                c = conn.cursor()
                c.execute(
                    "UPDATE requests SET status='DONE', lastchange=? WHERE uuid=?",
                    (time.time(), finishedJob['uuid']))
                conn.commit()
Пример #31
0
def main():
    print "START"
    sys.stdout.flush()

    while True:
        job = query_db(
            conn,
            "SELECT * FROM jobs  WHERE status='PENDING' ORDER BY lastchange ASC",
            one=True)
        if job:
            c = conn.cursor()
            c.execute(
                "UPDATE jobs SET status='RUNNING', lastchange=? WHERE uuid=? and status='PENDING'",
                (time.time(), job['uuid']))
            conn.commit()

            if c.rowcount:
                result = runScript(job['command'])
                status = 'FINISHED' if result else 'FAILED'
                c.execute("UPDATE jobs SET status=?, lastchange=? WHERE id=?",
                          (status, time.time(), job['id']))
                conn.commit()

        time.sleep(0.2)
Пример #32
0
 def get_number(self, number):
     query = "SELECT * FROM Whitelist WHERE PhoneNo = ?"
     args = (number, )
     results = utils.query_db(self.db, query, args, False)
     return results
Пример #33
0
def ontology(ontology_):
    ont = query_db('select * from ontologies where prefix = ?', [ontology_], one=True)
    # get the graph for the relevant ontology
    graph = get_graph(ontology_)
    if graph is None:
        # TODO: 404
        return redirect(url_for('index'))
    resource_ = request.args.get('resource_', None)
    errors = []
    # for recreating a page if there are errors
    changes = {'addition':[], 'removal':[]}

    # if ?resource_=xxx is present and xxx is not None then go into "resource viewing mode"
    if resource_ is not None:
        properties = {}
        # get the label of the resource
        res_name = get_label(resource_)

        # force the resource to a URIRef
        uri2res = lambda uri: uri if isinstance(uri, rdflib.URIRef) else rdflib.URIRef(uri)
        r = uri2res(resource_)

        # build list of (type,predicate,object)s, using an empty string for the type of original triples
        tpos = [('', p, o) for p, o in graph.predicate_objects(subject=r)]
        # include additions/removals from uncommited proposal
        if session.get('logged_in', False):
            tpos.extend([(s['type'], uri2res(s['predicate']), parse_string_rdfobject(s['object'])) for s in get_uncommited_quads(g.userid, resource_)])

        # TODO: these 2 lines may be redundant now as most form validation is done in the UI, remove them  completely when this is confirmed
        # include additions from changes (only present if errors in form submission)
        tpos.extend([('addition', uri2res(stmt['pred']), parse_string_rdfobject(stmt['val'])) for stmt in changes['addition']])
        # include removals from changes (only present if errors in form submission)
        tpos.extend([('removal', uri2res(stmt['pred']), parse_string_rdfobject(stmt['val'])) for stmt in changes['removal']])
        # TODO: add "modified" type (maybe)
        for t,p,o in tpos:
            # get existing values for this predicate
            item = properties.get(p,
                                  {'value': [],
                                   'qname': get_qname(p), 
                                   'label': get_label(p)})
            # convert rdf object to a dict
            v = rdfobject2dict(o)
            # add 'deleted' or 'added' 'class' value (used by templates)
            if t == 'removal':
                try:
                    # if it's a removal, it should already exist in the values list
                    # find it and add the class to the existing entry
                    idx = item['value'].index(v)
                    v['class'] = 'deleted'
                    item['value'][idx] = v
                except ValueError:
                    pass # caused when .index fails
            else:
                if t == 'addition':
                    v['class'] = 'added'
                item['value'].append(v)

            # update the changes
            properties[p] = item

            # TODO: this may be redundant with the get_label call above
            # simply sets the resource name variable to the value of the RDFS.label predicate
            if res_name is '' and p == RDFS.label:
                res_name = v['value']

        # if there were no predicates, consider this a "new resource" and present the "create resource" view
        # with the URI already filled in
        # TODO: a lot of this is duplicate code from the create_resource function
        is_new = False
        if len(properties) == 0:
            # create new resource
            properties = {}
            properties[RDF.type] = {'value': [{'type':"URI", 'value':"", 'class':'added'}],
                                    'qname': 'rdf:type',
                                    'label': 'type'}
            properties[RDFS.label] = {'value': [{'type':"Literal", 'value':"", 'class':'added'}],
                                      'qname': 'rdfs:label', 
                                      'label': 'label'}
            res_name='Create New Resource'
            is_new=True

        # TODO: proposal/history stuff
        proposals = []
        history = []
        return render_template('resource.html',
                               ontology_=ont,
                               uri=resource_,
                               name=res_name,
                               properties_=properties,
                               proposals=proposals,
                               history=history,
                               is_new=is_new,
                               auto_save=False)

    # if no resource is requested, go to the ontology view, retrieving a list of all the subjects in the ontology
    resources = [{'uri':s[0], 'qname':get_qname(s[0]), 'label':get_label(s[0])} for s in graph.triples((None, RDF.type, None))]
    proposals = None #[s for s,_ in groupby(pgraph.subjects()) if isinstance(s, rdflib.URIRef)] # TODO and not s.startswith(changeset_base_uri)
    return render_template('ontology.html', ontology_=ont, resources=resources, proposals=proposals)
Пример #34
0
 def check_number(self, number):
     query = "SELECT COUNT(*) FROM Whitelist WHERE PhoneNo=:number"
     args = {"number": number}
     result = utils.query_db(self.db, query, args, True)
     return result[0] > 0
Пример #35
0
def case(reference_p1, reference_p2):
	reference_p1 = str(reference_p1)
	reference_p2 = str(reference_p2)
	query_str = query_str_start() + 'WHERE case.reference = "' + reference_p1 + '/' + reference_p2 + '"' + query_str_end() + ' LIMIT 1'
	result = query_db(query_str)
	return form_json(result)
Пример #36
0
def date_cases(date):
	query_str = query_str_start() + 'WHERE case.date = "' + date + '"' + query_str_end()
	result = query_db(query_str)
	return form_json(result)
Пример #37
0
def appeals():
	result = query_db(query_str_start(True) + query_str_end(True))
	return form_json(result)
Пример #38
0
def appeals_by_case_reference(reference_p1, reference_p2):
	query_str = query_str_start(True) + 'WHERE case.reference = "' + str(reference_p1) + '/' + str(reference_p2) + '"' + query_str_end(True) + ' LIMIT 1'
	result = query_db(query_str)
	return form_json(result)