def save_post(title, content): # Create the new post new_post = Post(title=title, content=content, date=datetime.datetime.now()) # Add and Save the new post db_session.add(new_post) db_session.commit()
def create_product_from_data(self): """ Creates product and required objects it depends on from data. """ # Normalize field names to system names. self._cleanse_data() # create independent objects first: tags, group (family, range), customer as they do not need # anything to exist. self._create_objects(self.product_config[INDEPENDENT]) # create product dependencies in database (ids will be needed to save the product object in next step) db_session.flush() base_product = self._create_base_product() # now create product dependent objects (those need product_id. self._create_objects(self.product_config[PRODUCT_DEPENDENT]) # create industry specific dependent objects. multi_relations = self.product_config[MULTI_RELATIONS] if self.product_config.get(INDUSTRY_DEPENDENT): industry_dependent_relations = self.product_config[INDUSTRY_DEPENDENT] self._create_objects(industry_dependent_relations) multi_relations.extend(industry_dependent_relations) # append dependent objects to product for relation in multi_relations: # add objects to appropriate fields getattr(base_product, relation).extend(self.objects[relation]) db_session.commit()
def index(): if request.method == 'GET': if 'email' in session: return render_template('home.html') else: return render_template('login.html') if request.method == 'POST': reqData = request.get_data() reqDataJson = json.loads(reqData) sSchema = studentschema() appSchema = studentapplicationschema() studentJson = None applicationJson = None if 'student' in reqDataJson.keys(): studentJson = constructStudent(reqDataJson['student']) if 'application' in reqDataJson.keys(): applicationJson = constructApplication(reqDataJson['application']) stu = sSchema.load(studentJson, session=db_session).data stu.id = session['uid'] stuapp = appSchema.load(applicationJson, session=db_session).data db_session.merge(stu) stuapp.s_id = stu.id db_session.commit() db_session.add(stuapp) db_session.commit() return json.dumps({'status': 'OK'})
def edit_photo(photo_id): """ Updates a photo instance """ photo = Photo.query.get(photo_id) if photo is None: return jsonify(errors="resource not found"), 404 data = request.get_json() headers = request.headers jwt_token = headers['X-Authorization'] message = {} # check for valid token try: decoded = jwt.decode(jwt_token, constants.SECRET_KEY) except jwt.exceptions.InvalidTokenError: message['error'] = 'token is invalid' return jsonify(message), 400 # check to see if user owns photo if decoded['username'] != photo.user.username: return jsonify("You must own a photo to edit it"), 401 if decoded and decoded['username'] == photo.user.username: photo.name = data['name'] photo.description = data['description'] photo.picture = data['url'] photo.category_id = data['categoryId'] db_session.add(photo) db_session.commit() db_session.refresh(photo) photo = photo.serialize return jsonify(photo), 202
def delete_item_list(name): item = Item.query.filter(Item.name == name).first() db_session.delete(item) db_session.commit() return item
def create_post(user_id, lat, lon, body, artist, img_url="null"): p = Post(user_id, lat, lon, body, img_url) db_session.add(p) # make sure we update our database is updated with the id db_session.flush() db_session.commit() return {'success': 1, 'id': p.id, 'msg': 'success'}
def create_source(source_name): logger.debug("### Create source [{}] ###".format(source_name)) source = DataSource(source_name=source_name) db_session.add(source) db_session.commit() return source.source_id
def add_location(): content = request.get_json() r = Restaurant(content['id'], content['title'], content['coords']['latitude'], content['coords']['longitude'], content['google_ratings'], content['types']) db_session.add(r) db_session.commit() db_session.remove() return 'success'
def create_chart(chart_name): logger.debug("### Create chart [{}] ###".format(chart_name)) chart = Chart(chart_name=chart_name) db_session.add(chart) db_session.commit() return chart.chart_id
def crawl_scrape(src_id): source = db_session.query(Source).filter(Source.id == src_id).first() xp = {} f = {} util = {} util['src_id'] = src_id util['dname'] = source.domain xp['title'] = str(source.xp_title) xp['lead'] = source.xp_lead xp['content'] = source.xp_content xp['date'] = source.xp_date xp['author'] = source.xp_author xp['keywords'] = source.xp_keywords f['title'] = source.f_title f['lead'] = source.f_lead f['content'] = source.f_content f['date'] = source.f_date f['author'] = source.f_author f['keywords'] = source.f_keywords source.crawling = True db_session.add(source) db_session.commit() proc = CrawlerProcess({ 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)', 'CLOSESPIDER_PAGECOUNT': 20 }) proc.crawl(MainSpider, xp, f, util) proc.start(stop_after_crawl=False) #d.addBoth(lambda _: reactor.stop()) #reactor.run() current_texts = db_session.query(Text).filter(Text.src_id == src_id).all() c = 0 for t in stored: duplicate = False for at in current_texts: if at.content == t['content']: duplicate = True if not duplicate: c += 1 db_session.add( Text(src_id=t['source'], url=t['url'], title=t['title'], lead=t['lead'], content=t['content'], date=t['date'], author=t['author'], keywords=t['keywords'], lang=t['lang'], num_token=t['num_token'])) source.num_files_html += c source.crawling = False db_session.add(source) db_session.commit() return stored
def signup(): form = request.json new_user = User( civilite=form["civilite"], firstName=form["firstName"], lastName=form["lastName"], birthDate=form["birthDate"], email=form["email"], phone=form["phone"], plastaId=form["plastaId"], pwd=form["password"], group=form["group"], ) try: db_session.add(new_user) db_session.commit() except sqlalchemy.exc.IntegrityError as err: duplicated_key = err.orig.msg.split("'")[-2] return ( jsonify( { "msg": "{} est déja utilisée. Si vous avez déja un compte et oublié votre mot de passe, cliquer sur 'Renvoi du mot de passe' sur la page de login".format( duplicated_key ) } ), 422, ) # Send a verification mail url_conf = generate_confirmation_token(form["email"]) msg = Message( "Validation de votre inscription à J4U", sender="*****@*****.**", recipients=[form["email"]], ) msg.html = """ <p> Bonjour, </p> <p> Nous vous remercions pour votre participation au projet « Job For You » (J4U). </p> <p> Suite à votre inscription, voici un email de confirmation. Afin de valider votre compte, il vous suffit de cliquer sur le lien suivant (qui n’est actif que quelques jours) : </p> <p> <a href="{}">Cliquez ici pour confirmer votre adresse email</a> </p> <p> L’équipe J4U </p> """.format( url_conf ) mail.send(msg) res = jsonify(success=True) return res
def clearOverride(): try: if 'email' not in session: return redirect(url_for('index')) odel = db_session.query(overrides).delete() db_session.commit() except Exception: return json.dumps({'status': 'clear failed'}) return json.dumps({'status': 'OK'})
def fblogin(): """ Handles login requests through facebook login""" data = request.get_json() print "data from request is" print data message = {} message['message'] = "facebook login in received" email = data['email'] print email user = helpers.user_by_email(email) print user if user: # create a JWT token to login token_data = { 'iat': datetime.datetime.utcnow(), 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=30), 'username': user.username, 'userId': user.id, 'isLoggedIn': True, } auth_token = jwt.encode(token_data, constants.SECRET_KEY, algorithm='HS256') # create a JSON message with JWT and send it to client message['auth_token'] = auth_token message['success'] = True print message return jsonify(message), 200 if not user: # create a new User instance from the facebook login credentails, then a JWT login. username = data['name'] new_user = User(username=username, email=email) db_session.add(new_user) db_session.commit() user_with_id = db_session.refresh(new_user) message['user'] = user_with_id token_data = { 'iat': datetime.datetime.utcnow(), 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=30), 'username': user_with_id.username, 'userId': user_with_id.id, 'isLoggedIn': True, } auth_token = jwt.encode(token_data, constants.SECRET_KEY, algorithm='HS256') message['auth_token'] = auth_token message['success'] = True print message return jsonify(message), 200
def sign_s3(): urlSchema = fileurlschema() S3_BUCKET = os.environ.get('S3_BUCKET') file_name = request.args.get('file-name') file_name2 = request.args.get('file-name2') # Initialise the S3 client s3 = boto3.client('s3', 'us-west-2', config=Config(signature_version='s3v4')) name = session['name'] # appending users name before file in order to prevent it from being overwritten by another file with same name. file_name = name + '_' + file_name file_name2 = name + '_' + file_name2 # Generate and return the presigned URL presigned_post = s3.generate_presigned_url('get_object', Params={ 'Bucket': S3_BUCKET, 'Key': file_name }, ExpiresIn=3600, HttpMethod='PUT') presigned_post2 = s3.generate_presigned_url('get_object', Params={ 'Bucket': S3_BUCKET, 'Key': file_name2 }, ExpiresIn=3600, HttpMethod='PUT') result = {} email = session['email'] fr = fileurl.query.filter_by(email_id=email).first() result[ 'resume_url'] = "https://" + S3_BUCKET + ".s3.amazonaws.com/" + file_name result[ 'coverletter_url'] = "https://" + S3_BUCKET + ".s3.amazonaws.com/" + file_name2 result['email_id'] = email # if user has already inserted a resume once - just use existing id if fr: result[u'id'] = fr.id else: result[u'id'] = str(uuid.uuid1()) furl = urlSchema.load(result, session=db_session).data db_session.merge(furl) db_session.commit() return json.dumps({'url1': presigned_post, 'url2': presigned_post2})
def signup(): """ Creates a new User """ data = request.get_json() # make sure all required data is present message = {} success = '' username = data['username'] password = data['password'] email = data['email'] # check for missing data if username == '': message['error_username'] = "******" success = False if password == '': message['error_password'] = "******" success = False if email == '': message['error_email'] = "email is required" success = False if success is False: message['success'] = False return jsonify(errors=message), 200 # check for valid data if not helpers.valid_username(str(username)): message['error_username'] = "******" success = False if helpers.user_by_name(username) is not None: message['error_username'] = "******" success = False if not helpers.valid_password(password): message['error_password'] = "******" success = False if not helpers.valid_email(email): message['error_email'] = "Email is not valid" success = False if helpers.user_by_email(str(email)) is not None: message['error_email'] = "Email already in use" if success is False: message['success'] = False return jsonify(errors=message), 200 # hash the password for db storage pw_hash = helpers.make_pw_hash(username, password) # create new instance of user new_user = User(username, email, pw_hash) db_session.add(new_user) db_session.commit() db_session.refresh(new_user) message['success'] = True message['user'] = new_user.serialize return jsonify(message), 201
def reset_password(): token = request.json.get("token", None) email = confirm_token(token) password = request.json.get("password", None) if password and token and email: user = User.query.filter_by(email=email).first() user.set_password(password) db_session.commit() return jsonify(success=True) return jsonify({"msg": "error"}), 400
def insert_task_data(id, temperature, duration, batch_id): try: data = TaskDataModel(id=id, timestamp=datetime.now(), temperature=temperature, duration=duration, batch_id=batch_id) db_session.add(data) db_session.commit() except Exception as Err: raise Err
def insert_log(log_type, action, message=""): try: data = LogData(id=uuid.uuid1(), timestamp=datetime.now(), log_type=log_type, action=action, message=message) db_session.add(data) db_session.commit() except Exception as Err: raise Err
def verify(): token = request.args.get("token") email = confirm_token(token, expiration=3600 * 24) if email: user = User.query.filter_by(email=email).first() user.verified = True db_session.commit() return redirect("{}/#/verified".format(get_config()["app_url"]), code=302) return jsonify(success=True) return jsonify({"msg": "error"}), 400
def update(): form = request.json current_user = get_current_user() current_user.civilite = form["civilite"] current_user.firstName = form["firstName"] current_user.lastName = form["lastName"] current_user.birthDate = form["birthDate"] current_user.email = form["email"] current_user.phone = form["phone"] current_user.plastaId = form["plastaId"] db_session.add(current_user) db_session.commit() return jsonify(success=True)
def _refreshDividendsDB(self, ticker, force_refresh=False): # 1 Use yahoo reader to scrape res = [] dividends = None try: dividends = yahoo_reader.yahoo_reader.get_dividend( ticker, force_refresh) except Exception as e: logger.exception( "Failed to parse dividends for {ticker}".format(ticker=ticker)) return res # 2 Add to TB and return for index, row in dividends.iterrows(): period = row[0] dividend = row[1] # Check if it exists query = stockdatamodel.Dividend.query.filter( stockdatamodel.Dividend.ticker == ticker).filter( stockdatamodel.Dividend.period == period) if query.count() < 1: logger.debug( "Don't have this dividend yet {ticker} {period} ".format( ticker=ticker, period=period)) d = stockdatamodel.Dividend( ticker=ticker, period=period, dividend=dividend, ) try: db_session.add(d) res.append(d) except Exception as e: logger.exception("Failed to add dividend to DB") else: d = query.first() # logger.debug(d) # If we need to force refresh update it if force_refresh: logger.debug( "We are force refreshing dividend {ticker} {period}". format(ticker=ticker, period=period)) d.dividend = dividend res.append(d) try: db_session.commit() return res except Exception as e: logger.exception("Failed to commit dividend to DB")
def new_photo(): """ Creates a new photo """ headers = request.headers data = request.get_json() # initialze return message message = {} success = '' # check for valid token jwt_token = headers['X-Authorization'] try: jwt.decode(jwt_token, constants.SECRET_KEY) except jwt.exceptions.InvalidTokenError: message['error'] = 'token is invalid' return jsonify(message), 400 name = data['name'] description = data['description'] category_id = data['categoryId'] url = data['url'] user_id = data['userId'] # check for missing data if name == '': message['error_name'] = "you must provide a name" success = False if description == '': message['error_description'] = "you must provide a description" success = False if category_id == '': message['error_category'] = "please choose a cateogry" success = False if url == '': message['error_picture'] = "provide a url for your picture" success = False if success is False: return jsonify(errors=message), 200 # validate data if not helpers.valid_url(url): message['error_picture'] = "you must provide a valid url" success = False if success is False: return jsonify(errors=message), 200 # create a new photo instance newPhoto = Photo(name, description, category_id, url, user_id) db_session.add(newPhoto) db_session.commit() db_session.refresh(newPhoto) photo = newPhoto.serialize return jsonify(photo), 201
def positions(): data = request.json job = request.args.get("avam") oldJobLabel = data["oldJobLabel"] # This parameter is only received by control-group searches # Under the J4U condition, oldJobValue and oldJobLabel are persisted on recom # Since control bypasses recom, this parameter is persisted here if oldJobLabel: oldjob = data["codes"] current_user = get_current_user() current_user.oldJobValue = oldjob[0]["value"] current_user.oldJobLabel = data["oldJobLabel"] db_session.commit() headers = { "Accept": "application/json, text/plain, */*", "Connection": "keep-alive", "Content-Type": "application/json", "Postman-Token": "a22088d4-4d7f-4d72-b14d-bceb48ef23db", "X-Requested-With": "XMLHttpRequest", "cache-control": "no-cache", } # SECO's JobRoom starts pagination from 0, but our pagination component matches page number and navigation items, so we need to decrease its number by one params = (("page", int(data["currentPage"]) - 1), ("size", "10"), ("sort", "score")) if data["cantonCodes"] == [""]: data["cantonCodes"] = [] data = { "permanent": None, "workloadPercentageMin": 0, "workloadPercentageMax": 100, "onlineSince": 30, "displayRestricted": False, "keywords": [], "professionCodes": data["codes"], "communalCodes": [], "cantonCodes": data["cantonCodes"], } response = requests.post( "https://www.job-room.ch/jobadservice/api/jobAdvertisements/_search", headers=headers, params=params, data=json.dumps(data), ) res = response.json() res = {"totalCount": response.headers.get("X-Total-Count", "0"), "positions": res} return jsonify(res)
def overrideMatch(): if 'email' not in session: return redirect(url_for('index')) try: oSchema = overrideschema() oDataS = request.get_data() oDataJ = json.loads(oDataS) oObj = oSchema.load(oDataJ, session=db_session).data oObj.s_id = str(oDataJ['s_id']) oObj.p_id = str(oDataJ['p_id']) db_session.merge(oObj) db_session.commit() except Exception: return json.dumps({'status': 'override failed'}) return json.dumps({'status': 'OK'})
def create_follow(from_id, to_id): # assume my_id and friend_id are valid u = Follow(from_id, to_id) db_session.add(u) db_session.flush() db_session.commit() return { 'success': 1, 'from_id': u.from_id, 'to_id': u.u_id, 'msg': 'success' } #print(create_post(1, 1000, 100, "dsf"))
def retrieve_all(surveyId): df = get_surveys() uois = User.query.filter_by(formDone=False).all() for uoi in uois: if uoi.surveyId in df["ID"].unique(): v = df[df["ID"] == uoi.surveyId][df.columns[1:]].values[0] f = Features(*v) uoi.features = f uoi.formDone = True db_session.add(uoi) db_session.commit() if surveyId in df["ID"].unique(): return True return False
def create_user(username, password, first, last, img_url="null"): if len(password) > 16: return { 'success': 0, 'id': 'null', 'msg': 'password is too long, make less than 16' } u = User(username, password, first, last, img_url) # make sure it is not duplicate if db_session.query(User).filter(User.username == username).first(): return {'success': 0, 'id': 'null', 'msg': 'user already exist'} db_session.add(u) # make sure we update our database is updated with the id db_session.flush() db_session.commit() return {'success': 1, 'id': u.id, 'msg': 'success'}
def worldseatemp_temp(): logging.debug("worldseatemp_temp() started") source_name = "worldseatemp" source_id = DataSource.query.filter(DataSource.source_name == source_name) source_id = source_id.all() if not source_id: source_id = create_source(source_name) else: source_id = source_id[0].source_id temp = get_temp_worldseatemp() data = Data(indicator=temp, chart_id=chart_id, source_id=source_id) db_session.add(data) db_session.commit()
def delete_user(user_id): """ Deletes a User """ user = User.query.get(user_id) headers = request.headers jwt_token = headers['X-Authorization'] # check for valid token try: decoded = jwt.decode(jwt_token, constants.SECRET_KEY) except jwt.exceptions.InvalidTokenError: return jsonify("token is not valid"), 400 if user is None: return jsonify(Message="Not Found"), 404 # check to make sure user names match if decoded['username'] != user.username: return jsonify("you can only delete your own profile"), 401 db_session.delete(user) db_session.commit() return jsonify(success=True)
def before_first_request(): init_db() user_datastore.find_or_create_role(name='admin', description='Administrator') user_datastore.find_or_create_role(name='user', description='User') user_datastore.find_or_create_role(name='operator', description='Operator') encrypted_password = encrypt_password('password') if not user_datastore.get_user('*****@*****.**'): user_datastore.create_user(email='*****@*****.**', username='******', password='******') if not user_datastore.get_user('*****@*****.**'): user_datastore.create_user(email='*****@*****.**', username='******', password='******') db_session.commit() user_datastore.add_role_to_user('*****@*****.**', 'admin') user_datastore.add_role_to_user('*****@*****.**', 'operator') db_session.commit()