Exemple #1
0
def new_meal_save():
	status, msg = True, ''

	b_name = request.args.get('name')

	s = Session()
	b = Meal(b_name)

	for key, val in request.args.items():
		if key == 'name':
			continue
		a = s.query(Product).filter_by(id=key).first()
		b.products.append(a)

	s.add(b)

	try:
		s.commit()
	except IntegrityError:
		status = False
		msg = 'The meal with name %s already exists' % b_name

	s.close()

	return json.dumps({'ok': status, 'msg': msg})
def do_command (task_id) :
    try :
        task_res = get_task_by_id(task_id)
        if task_res["status"] != 0 :
            return {"status":-1 , "val":None}
        task = task_res["val"]["task"]
        group_id = script_group = task_res["val"]["script_group"].id
        server_group = task_res["val"]["server_group"]
        scripts = get_scripts_by_group_id(group_id)["val"]
        script_list = []
        for script in scripts :
            script_list.append(str(script.location))
        server_list = []
        for server in server_group.servers :
            server_list.append(server.dump())
        if script_list == [] or server_list == [] :
            return {"status":-1 , "val":None}
        task_to_do = {"scripts":script_list , "servers":server_list}
        success_array , key_code_list = upload_remotefile.do_task(task_to_do)
        session = Session()
        taskStatus = session.query(TaskStatus).filter(TaskStatus.task_id == task_id).first()
        if taskStatus == None :
            taskStatus = TaskStatus(task_id , json.dumps(success_array) , json.dumps(key_code_list))
            taskStatus_id = taskStatus.save_return_id(session)
        else :
            taskStatus.success_array = json.dumps(success_array)
            taskStatus.key_code_list = json.dumps(key_code_list)
            taskStatus_id = taskStatus.id
            taskStatus.save(session)
        session.close()
        return {"status":0 , "val":taskStatus_id}
    except Exception , msginfo :
        return {"status":-1 , "val":msginfo}
Exemple #3
0
def insert_db_weather(weather_values):
    """Function for inserting scraped data from Weather API into database"""
    session = Session()
    new_data = Weather(
        coord_lon=weather_values["coord"]["lon"],
        coord_lat=weather_values["coord"]["lat"],
        weather_id=weather_values["weather"][0]["id"],
        weather_main=weather_values["weather"][0]["main"],
        weather_description=weather_values["weather"][0]["description"],
        weather_icon=weather_values["weather"][0]["icon"],
        base=weather_values["base"],
        main_temp=weather_values["main"]["temp"],
        main_pressure=weather_values["main"]["pressure"],
        main_humidity=weather_values["main"]["humidity"],
        main_temp_min=weather_values["main"]["temp_min"],
        main_temp_max=weather_values["main"]["temp_max"],
        visibility=weather_values["visibility"],
        wind_speed=weather_values["wind"]["speed"],
        wind_deg=weather_values["wind"]["deg"],
        clouds_all=weather_values["clouds"]["all"],
        dt=datetime.fromtimestamp(weather_values["dt"]),
        sys_type=weather_values["sys"]["type"],
        sys_id=weather_values["sys"]["id"],
        sys_message=weather_values["sys"]["message"],
        sys_country=weather_values["sys"]["country"],
        sys_sunrise=datetime.fromtimestamp(weather_values["sys"]["sunrise"]),
        sys_sunset=datetime.fromtimestamp(weather_values["sys"]["sunset"]),
        city_id=weather_values["id"],
        city_name=weather_values["name"],
        cod=weather_values["cod"])
    session.add(new_data)
    session.commit()
    session.close()
Exemple #4
0
def do_command (task_id) :
    try :
        task_res = get_task_by_id(task_id)
        if task_res["status"] != 0 :
            return {"status":-1 , "val":None}
        task = task_res["val"]["task"]
        group_id = script_group = task_res["val"]["script_group"].id
        server_group = task_res["val"]["server_group"]
        scripts = get_scripts_by_group_id(group_id)["val"]
        script_list = []
        for script in scripts :
            script_list.append(str(script.location))
        server_list = []
        for server in server_group.servers :
            server_list.append(server.dump())
        if script_list == [] or server_list == [] :
            return {"status":-1 , "val":None}
        task_to_do = {"scripts":script_list , "servers":server_list}
        success_array , key_code_list = upload_remotefile.do_task(task_to_do)
        session = Session()
        taskStatus = session.query(TaskStatus).filter(TaskStatus.task_id == task_id).first()
        if taskStatus == None :
            taskStatus = TaskStatus(task_id , json.dumps(success_array) , json.dumps(key_code_list))
            taskStatus_id = taskStatus.save_return_id(session)
        else :
            taskStatus.success_array = json.dumps(success_array)
            taskStatus.key_code_list = json.dumps(key_code_list)
            taskStatus_id = taskStatus.id
            taskStatus.save(session)
        session.close()
        return {"status":0 , "val":taskStatus_id}
    except Exception , msginfo :
        return {"status":-1 , "val":msginfo}
Exemple #5
0
    def draw_table(self):
        s = Session()
        self.orders = s.query(Order).all()
        s.close()
        self.ui.orders_table.clear()
        self.ui.orders_table.setRowCount(1)
        self.ui.orders_table.setColumnCount(5)
        self.ui.orders_table.setHorizontalHeaderLabels([QString.fromUtf8('Номер'), QString.fromUtf8('Поломка'),
                                                        QString.fromUtf8('Дата приемки'), QString.fromUtf8('Клиент'),
                                                        QString.fromUtf8('Статус')])
        #self.ui.orders_table.resizeColumnsToContents()

        for order in self.orders:
            data = []
            data.append(str(order.id))
            data.append(QString.fromUtf8(order.device))
            data.append(str(order.get_ordered_date()))
            data.append(QString.fromUtf8(order.get_client().get_fio()))
            data.append(QString.fromUtf8(order.get_status(1).to_string()))
            for i in range(0,5):
                tableitem = QTableWidgetItem()
                tableitem.setText(data[i])
                tableitem.font = QFont("Arial", 10)
                tableitem.font.setBold(True)
                tableitem.textcolor = QColor("black")
                self.ui.orders_table.setItem(self.ui.orders_table.rowCount() - 1,i,tableitem)
            self.ui.orders_table.setRowCount(self.ui.orders_table.rowCount()+1)
        self.ui.orders_table.resizeColumnsToContents()
Exemple #6
0
def create_default_user():
    session = Session()
    default_user = User('admin', 'password1234', '*****@*****.**')
    session.add(default_user)
    session.commit()
    session.close()
    return
Exemple #7
0
def initialize_device():
    """
    Set up the Device info into the database.
    By this time, the HardwareDefinition and SoftwareDefinition
    entries must be entered.
    """
    session = Session()

    hd = session.query(HardwareDefinition).one()
    sd = session.query(SoftwareDefinition).one()

    device = Device(id=hd.serial_number,
                    interior_sensor=hd.interior_sensor,
                    exterior_sensor=hd.exterior_sensor)

    device.hardware_version = hd.hardware_version
    device.software_version = sd.software_version
    device.database_service = True  # database always set to True
    device.device_service = sd.device_service
    device.grainbin_service = sd.grainbin_service
    session.add(device)

    # set grainbin info
    if sd.grainbin_service:
        grainbins = initialize_grainbin(device.id, hd.grainbin_reader_count)
        device.grainbin_count = len(grainbins)
        session.add_all(grainbins)

    session.commit()
    session.close()
    return
Exemple #8
0
    def get(self):
        try:
            session = Session()
            uuid = request.headers["GreenList-User-Id"]
            user = UserController().get_user_by_id(uuid, session)
            if not user:
                abort(401)
            products = (
                SuggestionController().get_suboptimal_products(session))
            result = []
            for product in products:
                product_json = self.product_to_json(product)

                suggestions = SuggestionController().get_suggestions(
                    user, product, session)

                alternatives = [
                    self.suggestion_to_json(suggestion)
                    for suggestion in suggestions
                ]

                product_json.update({'alternatives': alternatives})
                result.append(product_json)
            return result
        finally:
            session.close()
Exemple #9
0
def main_page():
	s = Session()
	books = s.query(Book).all()
	authors = s.query(Author).all()
	s.close()

	return render_template('beta.html', books=books, authors=authors)
Exemple #10
0
def book_save(_id):
	status, msg = True, ''
	b_name = request.args.get('name')

	s = Session()
	b = s.query(Book).filter_by(id=_id).first()

	del b.authors[:]

	for key, val in request.args.items():
		if key == 'name':
			continue
		a = s.query(Author).filter_by(id=key).first()
		b.authors.append(a)

	b.name = b_name
	try:
		s.commit()
	except IntegrityError:
		status = False
		msg = 'The book with name %s already exists' % b_name

	s.close()

	return json.dumps({'ok': status, 'msg': msg})
Exemple #11
0
def main_page():
	s = Session()
	meals = s.query(Meal).all()
	products = s.query(Product).all()
	s.close()

	return render_template('beta.html', meals=meals, products=products)
Exemple #12
0
def get_station():
    session = Session()
    stations = []
    rows = session.execute("select * from station;")
    for row in rows:
        stations.append(dict(row))
    session.close()
    return jsonify(stations=stations)
Exemple #13
0
 def login(self):
     s = Session()
     res = s.query(Staff).filter_by(login=unicode(self.ui.login.text()),
         passwd=unicode(self.ui.password.text())).all()
     if len(res):
         self.mv = MainWindow(res[0])
         self.mv.show()
         self.close()
     s.close()
Exemple #14
0
 def draw_client_combo(self):
     combo = self.ui.client
     s = Session()
     clients = s.query(Client).all()
     s.close()
     combo.clear()
     for cl in clients:
         combo.addItem('%i %s %s'%(cl.id, cl.surname, cl.name))
     #QObject.connect(self.ui.manufacter_combo, SIGNAL("currentIndexChanged(int)"), self.setManufacter)
     #self.setManufacter(0)
Exemple #15
0
 def save_item(self, item):
     '''写数据库'''
     session = Session()
     try:
         session.add(Item(**item))
         session.commit()
     except Exception as e:
         logger.warning('页面 {} 的数据写入数据库出错,错误原因{}'.format(item['link'], e))
         session.rollback()
     session.close()
Exemple #16
0
def mul():
    session = Session()
    # select the rows that doesn't have result
    for datarow in session.query(ClientData).all():
        if not datarow.result:
            datarow.result = mul_data(
                datarow.rawData)  # add result to the data row
            session.add(datarow)  # update the datarow in the DB
            session.commit()  # commit all changes to DB

    session.close()
Exemple #17
0
def add(proxy):
    session = Session()
    count = session.query(Proxy).filter(Proxy.ip == proxy.ip, Proxy.port == proxy.port).count()
    if 0 == count:
            proxy.createtime = int(time.time())
            session.add(proxy)
            session.commit()
            logger.info("add proxy: %s" % proxy)
    else:
        logger.info("exists proxy: %s" % proxy)
    session.close()
Exemple #18
0
def remove_book():
	b_id   = request.args.get('id')

	s = Session()
	b = s.query(Book).filter_by(id=b_id).first()

	s.delete(b)
	s.commit()
	s.close()

	return json.dumps({'ok': True, 'msg': ''})
Exemple #19
0
    def get_user_by_id(self, user_id, session=None):
        own_session = False
        if not session:
            session = Session()
            own_session = True

        user = session.query(User).filter(
            User.greenlist_uuid == user_id).one_or_none()
        if own_session:
            session.close()
        return user
Exemple #20
0
def get_station_available_info(station_id):
    session = Session()
    available_info = []
    rows = session.execute("select available_bike_stands, available_bikes from bike \
        where station_id = {} and last_update = \
        (select max(last_update) from bike where station_id = {});".format(station_id, station_id))
    for row in rows:
        print(row)
        available_info.append(dict(row))
    session.close()
    return jsonify(available_info=available_info)
Exemple #21
0
 def add_order(self):
     s = Session()
     ord = Order()
     ord.manager_id = self.parent.user.id
     ord.device =  unicode(self.ui.device.text())
     ord.description =  unicode(self.ui.description)
     ord.client_id = s.query(Client).filter_by(id=unicode(self.ui.client.itemText(self.ui.client.currentIndex())).split()[0]).one().id
     s.add(ord)
     s.commit()
     s.close()
     self.close()
Exemple #22
0
    def get_suboptimal_products(self, session=None):
        own_session = False
        if not session:
            session = Session()
            own_session = True

        products = (session.query(Product).filter(
            or_(Product.id == 1, Product.id == 3)).all())

        if own_session:
            session.close()
        return products
Exemple #23
0
def remove_author():
	a_id   = request.args.get('id')

	s = Session()
	a = s.query(Author).filter_by(id=a_id).first()

	s.delete(a)
	s.commit()

	s.close()

	return json.dumps({'ok': True, 'msg': ''})
Exemple #24
0
    def add_purchase(self, user, product, quantity, session=None):
        own_session = False
        if not session:
            session = Session()
            own_session = True

        purchase = Purchase(user, product, quantity)
        session.add(purchase)

        if own_session:
            session.commit()
            session.close()
Exemple #25
0
    def get_product(self, product_id, session=None):
        own_session = False
        if not session:
            session = Session()
            own_session = True

        product = (session.query(Product).filter(
            Product.id == product_id).first())

        if own_session:
            session.close()
        return product
Exemple #26
0
 def get_list(uuid):
     session = Session()
     resp = []
     user = session.query(User).filter(User.greenlist_uuid == uuid).one_or_none()
     for elem in session.query(UserList).filter(UserList.user_id == user.id).all():
         resp.append({
             "productId": elem.product.id,
             "name": elem.product.name,
             "footprint": elem.product.footprint,
             "image": elem.product.image
         })
     session.close()
     return resp
Exemple #27
0
 def get_challenge(uuid):
     session = Session()
     user = session.query(User).filter(
         User.greenlist_uuid == uuid).one_or_none()
     if user is None:
         raise Exception("There is no user [id={}]".format(uuid))
     resp = {
         "startTime": str(user.challenge_start_ts),
         "endTime": str(user.challenge_end_ts),
         "score": ChallengeController.score_calc(user)
     }
     session.close()
     return resp
Exemple #28
0
def edit_meal(_id):
	s = Session()
	b = s.query(Meal).filter_by(id=_id).first()

	current_products = b.products
	products = s.query(Product).all()

	other_products = []
	for a in products:
		if a not in b.products:
			other_products.append(a)
	s.close()

	return render_template('edit_meal.html', meal=b, other_products=other_products, current_products=current_products)
Exemple #29
0
def edit_book(_id):
	s = Session()
	b = s.query(Book).filter_by(id=_id).first()

	current_authors = b.authors
	authors = s.query(Author).all()

	other_authors = []
	for a in authors:
		if a not in b.authors:
			other_authors.append(a)
	s.close()

	return render_template('edit_book.html', book=b, other_authors=other_authors, current_authors=current_authors)
Exemple #30
0
 def score_calc(user):
     try:
         session = Session()
         score = 0
         score_product_list = session.query(UserList, Purchase).join(
             Purchase, Purchase.product_id == UserList.product_id).filter(
                 UserList.user_id == user.id).filter(
                     Purchase.user_id == user.id).all()
         for product in score_product_list:
             score += product[0].trees_difference * product[1].quantity
         session.close()
         return round(score)
     except Exception as e:
         return e
Exemple #31
0
def add_provider(db_enabled, lastname, firstname, credentials, addr1, addr2, city, zipcode, state,latitude, longitude):

    # if db is enabled, then open a session with the database
    if db_enabled:
        session = Session()

        # create an instance of the Provider type
        provider = Provider(lastname=lastname, firstname=firstname,
                            credentials=credentials, addr1=addr1, addr2=addr2,
                            city=city, zipcode=zipcode,state=state,
                            latitude=latitude, longitude=longitude)


    #To check if the record already exists in database 
    p = select([Provider.firstname]).where(Provider.firstname+Provider.lastname+Provider.credentials
                                           +Provider.addr1+Provider.addr2 == firstname+lastname+credentials+addr1+addr2)

    res = session.execute(p)
    prov_data = res.fetchone()
    session.close()    

    #To check if record exists, then this step will be skipped
    if not(prov_data):
        session = Session()
        # To fetch the Geographical coordinates from Zip_geotable 
        z = select([Zip_geo.latitude, Zip_geo.longitude]).where(Zip_geo.zipcode == zipcode)
        result = session.execute(z)
        geo_data = result.fetchone()

        if geo_data:
            latitude = geo_data.latitude
            longitude= geo_data.longitude
            #print db_enabled, lastname, firstname, credentials, addr1, addr2, city, zipcode, state,latitude, longitude
            
            
            # create an instance of the Provider type
            provider = Provider(lastname=lastname, firstname=firstname,
                                credentials=credentials, addr1=addr1, addr2=addr2,
                                city=city, zipcode=zipcode,state=state,
                                latitude=latitude, longitude=longitude)            
            

            # if db is enabled, then add to the recordset and commit the txn
            session.add(provider)
            session.commit()
            session.close()
                
    return provider
Exemple #32
0
def add_zipdata(db_enabled, zipcode, latitude, longitude):
    
    # if db is enabled, then open a session with the database
    if db_enabled:
        session = Session()

    # create an instance of the Zip_Geo type
    zip_geo= Zip_geo(zipcode=zipcode, latitude=latitude, longitude=longitude)

    # if db is enabled, then add to the recordset and commit the txn
    if db_enabled:
        session.add(zip_geo)
        session.commit()
        session.close()
                  
    return zip_geo
def rep_generacional():
    session = Session()
    representantes = [
        as_dict(representante)
        for representante in session.query(Representante).all()
    ]
    for indice, representante in enumerate(representantes):
        asistencias = limpiar_asistencias(
            session.query(Asistencias).filter(
                Asistencias.nombre_representante ==
                representante["nombre"]).all())
        representantes[indice]["asistencias"] = asistencias

    session.close()

    return representantes
Exemple #34
0
 def add_to_list(uuid, product_id, trees_difference):
     msg = "Success"
     try:
         session = Session()
         user = session.query(User).filter(User.greenlist_uuid == uuid).one_or_none()
         if session.query(UserList).filter(
                 UserList.user_id == user.id).filter(UserList.product_id == product_id).first() is None:
             product = session.query(Product).filter(Product.id == product_id).one_or_none()
             product_to_user = UserList(user, product, trees_difference)
             session.add(product_to_user)
             session.commit()
         session.close()
     except Exception as e:
         msg = e
     finally:
         return msg
Exemple #35
0
 def create_challenge(uuid, duration):
     msg = "Success"
     try:
         session = Session()
         user = User(greenlist_uuid=uuid,
                     challenge_start_ts=datetime.utcnow(),
                     challenge_end_ts=datetime.utcnow() +
                     timedelta(days=duration * 30),
                     challenge_score=0)
         session.add(user)
         session.commit()
         session.close()
     except Exception as e:
         msg = e
     finally:
         return msg
Exemple #36
0
def weather_to_db(data):
    session = Session()
    weather = json.loads(data)
    print(weather)
    print(type(weather), len(weather))

    timestamp_dt = weather.get('dt')
    print(timestamp_dt)
    time_standard_dt = timestamp_convert(timestamp_dt)
    timestamp_sunrise = weather.get('sys').get('sunrise')
    time_standard_surise = timestamp_convert(timestamp_sunrise)
    timestamp_sunset = weather.get('sys').get('sunset')
    time_standard_sunset = timestamp_convert(timestamp_sunset)
    kwargs ={
        'coord_lon':weather.get('coord').get('lon'),
        'coord_lat':weather.get('coord').get('lat'),
        'weather_id':weather.get('weather')[0]['id'],
        'weather_main':weather.get('weather')[0]['main'],
        'weather_description': weather.get('weather')[0]['description'],
        'weather_icon':weather.get('weather')[0]['icon'],
        'base':weather.get('base'),
        'main_temp': weather.get('main').get('temp'),
        'main_feels_like':weather.get('main').get('feels_like'),
        'main_temp_max':weather.get('main').get('temp_max'),
        'main_temp_min': weather.get('main').get('temp_min'),
        'main_pressure':weather.get('main').get('pressure'),
        'main_humidity': weather.get('main').get('humidity'),
        'visibility': weather.get('visibility'),
        'wind_speed': weather.get('wind').get('speed'),
        'wind_deg': weather.get('wind').get('speed'),
        'clouds_all': weather.get('clouds').get('all'),
        'dt':time_standard_dt,
        'sys_type':weather.get('sys').get('type'),
        'sys_id': weather.get('sys').get('id'),
        'sys_country': weather.get('sys').get('country'),
        'sys_sunrise':time_standard_surise,
        'sys_sunset':time_standard_sunset,
        'timezone':weather.get('timezone'),
        'city_id':weather.get('id'),
        'name': weather.get('name'),
        'cod':weather.get('cod'),
    }
    row_weather = Weather(**kwargs)
    session.add(row_weather)
    session.commit()
    session.close()
    return
Exemple #37
0
def count_distinct(db_enabled):

    # if db is enabled, then open a session with the database
    if db_enabled:
        session = Session()

        # if db is enabled, then query the database and w
        results = session.query(label ('Zipcode', Provider.zipcode),
            label('Count', func.count(Provider.firstname+Provider.lastname+Provider.credentials))).group_by(Provider.zipcode).order_by('"Count" desc').all()    
    
        session.close()
        
        # Write the output to CSV file
        for result in results:
            write_csv(result)
            
        print 'Data saved to output.csv'
Exemple #38
0
def new_author_save():
	status, msg = True, ''

	a_name = request.args.get('name')

	s = Session()
	s.add(Author(a_name))

	try:
		s.commit()
	except IntegrityError:
		status = False
		msg = 'The author with name %s already exists' % a_name

	s.close()

	return json.dumps({'ok': status, 'msg': msg})
Exemple #39
0
    def post(self):
        try:
            req = request.get_json()
            user_id = req['userId']
            product_id = req['productId']
            quantity = req['quantity']

            session = Session()

            user = UserController().get_user_by_id(user_id, session)
            product = ProductController().get_product(product_id, session)

            PurchasesController().add_purchase(user, product, quantity,
                                               session)
        finally:
            session.commit()
            session.close()
Exemple #40
0
    def co2_difference_to_trees(self,
                                user,
                                original,
                                alternative,
                                session=None):
        own_session = False
        if not session:
            session = Session()
            own_session = True

        challenge_months = (
            UserController().get_challenge_duration_in_months(user))
        tree_co2_equivalent = TREE_CO2_GRAMS_PER_MONTH * challenge_months
        saved_trees = (original - alternative) / tree_co2_equivalent

        if own_session:
            session.close()
        return saved_trees
Exemple #41
0
def insert_db_bikes(values):
    """Function for inserting scraped data from Bikes API into database"""
    fields = [
        'status', 'bike_stands', 'available_bike_stands', 'available_bikes'
    ]

    session = Session()

    for data in values:
        station = session.query(Station).get(data['number'])
        # checking if the timestamp is greater than the last update to ensure no duplicates are added to the DB
        if datetime.fromtimestamp(
                data['last_update'] / 1000) > station.last_updated:
            new_data = UsageData(**{field: data[field] for field in fields})
            new_data.dt_last_update = data['last_update']
            station.station_usage.append(new_data)
    session.commit()
    session.close()
Exemple #42
0
def get_coordinates(zipcode , miles):
        session = Session()
        # To fetch the Geographical coordinates from Zip_geotable 
        z = select([Zip_geo.latitude, Zip_geo.longitude]).where(Zip_geo.zipcode == zipcode)
        result = session.execute(z)
        #print result
        geo_data = result.fetchone()
        
        #If zipcode exists in database
        if geo_data:
            latitude = geo_data.latitude
            longitude= geo_data.longitude
            patient_loc = geopy.Point(latitude,longitude )
            #print latitude,longitude
            find_distance(patient_loc, miles)
        else:
            print 'Zipcode not found. Please enter a valid zipcode'
        session.close()
Exemple #43
0
def suvan():
	s = Session()
	try:
		pictures = s.query(Picture).order_by(desc(Picture.date_uploaded)).all()
		d = OrderedDict()
		for p in pictures:
			dstr = p.date_uploaded.strftime('%B %d, %Y')
			if not d.has_key(dstr):
				d[dstr] = {}
				d[dstr]['date'] = dstr
				d[dstr]['age'] = getAge(p.date_uploaded)
				d[dstr]['pictures'] = []

			d[dstr]['pictures'].append(p)

		return render_template('suvan.html', pictures=d.values())
	finally:
		s.close()
Exemple #44
0
def get_coordinates(zipcode, miles):
    session = Session()
    # To fetch the Geographical coordinates from Zip_geotable
    z = select([Zip_geo.latitude,
                Zip_geo.longitude]).where(Zip_geo.zipcode == zipcode)
    result = session.execute(z)
    #print result
    geo_data = result.fetchone()

    #If zipcode exists in database
    if geo_data:
        latitude = geo_data.latitude
        longitude = geo_data.longitude
        patient_loc = geopy.Point(latitude, longitude)
        #print latitude,longitude
        find_distance(patient_loc, miles)
    else:
        print 'Zipcode not found. Please enter a valid zipcode'
    session.close()
Exemple #45
0
def stations_to_db(data):
    session = Session()
    stations = json.loads(data)
    print(type(stations), len(stations))
    for station in stations:
        timestamp = station.get('last_update')
        time_standard = timestamp_convert(timestamp)
        kwargs = {'station_id': int(station.get('number')),
                  'bike_stands': int(station.get('bike_stands')),
                  'available_bike_stands': int(station.get('available_bike_stands')),
                  'available_bikes': int(station.get('available_bikes')),
                  'status': station.get('status'),
                  'last_update': time_standard
                  }
        row_bike = Bike(**kwargs)
        session.add(row_bike)
    session.commit()
    session.close()
    return
Exemple #46
0
def search_meal_go():
	b_pattern = request.args.get('meal_pattern')
	a_pattern = request.args.get('product_pattern')

	s = Session()

	if not a_pattern:
		meals = s.query(Meal).filter(Meal.name.like('%' + b_pattern + '%'))
	else:
		meals = s.query(Meal).filter(and_(Meal.name.like('%' + b_pattern + '%'), \
		       Meal.products.any(Product.name.like('%' + a_pattern + '%'))))

	out = []
	for b in meals:
		out.append({'id': b.id, 'name': b.name})

	s.close()

	return json.dumps(out)
Exemple #47
0
def author_save(_id):
	status, msg = True, ''

	a_name = request.args.get('name')

	s = Session()
	a = s.query(Author).filter_by(id=_id).first()

	a.name = a_name

	try:
		s.commit()
	except IntegrityError:
		status = False
		msg = 'The author with name %s already exists' % a_name

	s.close()

	return json.dumps({'ok': status, 'msg': msg})
Exemple #48
0
def search_book_go():
	b_pattern = request.args.get('book_pattern')
	a_pattern = request.args.get('author_pattern')

	s = Session()

	if not a_pattern:
		books = s.query(Book).filter(Book.name.like('%' + b_pattern + '%'))
	else:
		books = s.query(Book).filter(and_(Book.name.like('%' + b_pattern + '%'), \
		       Book.authors.any(Author.name.like('%' + a_pattern + '%'))))

	out = []
	for b in books:
		out.append({'id': b.id, 'name': b.name})

	s.close()

	return json.dumps(out)
Exemple #49
0
        def __save_exercicio(mdex, id_parlamentar, id_mandato):

            exercicio = Exercicio()

            exercicio.codigo = mdex['CodigoExercicio']
            exercicio.parlamentar_id = id_parlamentar
            exercicio.mandato_id = id_mandato
            exercicio.inicio = datetime.strptime(mdex['DataInicio'],
                                                 self.__fmt)

            if 'DataFim' in mdex.keys():
                exercicio.fim = datetime.strptime(mdex['DataFim'], self.__fmt)
                exercicio.sigla_afastamento = mdex['SiglaCausaAfastamento']
                exercicio.causa_afastamento = mdex['DescricaoCausaAfastamento']

            session = Session()
            session.add(exercicio)
            session.commit()
            session.close()
Exemple #50
0
def main():
    logger.setLevel(logging.INFO)
    handler = logging.FileHandler('../log/crawler.log')
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)

    contest_list = ['abc002']
    with Crawler() as crawler:
        scraper = Scraper(crawler)
        for contest in contest_list:
            db_session = Session()
            try:
                # scraper.crawl_results(contest, db_session)
                scraper.crawl_contest_by_id(contest, db_session)
            except Exception as e:
                db_session.rollback()
                raise e
            finally:
                db_session.commit()
                db_session.close()
Exemple #51
0
def system_setup_init(status):
    """
    Create a SystemSetup entry in the database.
    Specify if the device is standalone configuration
    (status=True) or alongside a FarmMonitor (status=False)
    """
    session = Session()
    system_setup = SystemSetup()
    if status == 'True':
        system_setup.standalone_configuration = True
    else:
        system_setup.standalone_configuration = False

    session.add(system_setup)
    session.commit()

    initialize_routes(session)

    session.close()

    return
Exemple #52
0
    def get_suggestions(self, user, product, session=None):
        own_session = False
        if not session:
            session = Session()
            own_session = True

        already_in_list = (session.query(UserList).filter(
            UserList.user_id == user.id).all())
        already_in_list = set(p.product_id for p in already_in_list)

        results = []

        bigger_sizes = (session.query(
            Product,
            ProductSize).filter(ProductSize.smallest_id == product.id).filter(
                Product.id == ProductSize.product_id).filter(
                    Product.id != product.id).all())
        for alternative, product_size in bigger_sizes:
            multiplier = product_size.multiplier
            trees_difference = (TreesController().co2_difference_to_trees(
                user, product.footprint * multiplier, alternative.footprint))
            if alternative.id not in already_in_list:
                suggestion = Suggestion(alternative, trees_difference,
                                        multiplier)
                results.append(suggestion)

        same_class = (session.query(Product).filter(
            Product.product_cl_id == product.product_cl_id).filter(
                Product.id != product.id).all())

        for alternative in same_class:
            trees_difference = (TreesController().co2_difference_to_trees(
                user, product.footprint, alternative.footprint))
            if alternative.id not in already_in_list:
                suggestion = Suggestion(alternative, trees_difference)
                results.append(suggestion)

        if own_session:
            session.close()
        return results
Exemple #53
0
def new_meal():
	s = Session()
	products = s.query(Product).all()
	s.close()

	return render_template('edit_meal.html', other_products=products)
Exemple #54
0
def edit_author(_id):
	s = Session()
	a = s.query(Author).filter_by(id=_id).first()
	s.close()

	return render_template('edit_author.html', author=a)
Exemple #55
0
def edit_product(_id):
	s = Session()
	a = s.query(Product).filter_by(id=_id).first()
	s.close()

	return render_template('edit_product.html', product=a)
Exemple #56
0
def new_book():
	s = Session()
	authors = s.query(Author).all()
	s.close()

	return render_template('edit_book.html', other_authors=authors)