Exemplo n.º 1
0
def new_listing_image(listing_id):
    # user_id = request.form['user_id']
    # listing_id = request.form['listing_id']
    userfile = request.files['userfile']
    filename = userfile.filename

    # Check if listing exists
    l = Listing.get_by_id(listing_id)
    if l is None:
        raise InvalidUsage('Listing does not exist!', status_code=400)

    # Create client for interfacing with Cloud Storage API
    client = storage.Client()
    bucket = client.get_bucket(global_vars.LISTING_IMG_BUCKET)

    # Calculating size this way is not very efficient. Is there another way?
    userfile.seek(0, 2)
    size = userfile.tell()
    userfile.seek(0)

    # upload the item image
    path = str(listing_id) + '/' + filename
    image = bucket.blob(blob_name=path)
    image.upload_from_file(file_obj=userfile,
                           size=size,
                           content_type='image/jpeg')

    # Hacky way of making the image public..
    image.acl.all().grant_read()
    image.acl.save()

    resp = jsonify({'image_path': path, 'image_media_link': image.media_link})
    resp.status_code = 201
    return resp
def import_listings():
    listings = pd.read_csv('../../data/listings/nyc_listings.csv')
    failed_import = []
    for idx, listing in listings.iterrows():
        db_item = Listing(airBnbId = listing['id'], url = listing['listing_url'], name = listing['name']
                        , picture_url = listing['picture_url'], host_url = listing['host_url'],
                        host_name = listing['host_name'], latitude = listing['latitude'], longitude = listing['longitude'],
                        room_type = listing['room_type'], price = listing['price'][1:], minimum_nights = listing['minimum_nights'],
                        number_of_reviews = listing['number_of_reviews'], review_scores_rating = listing['review_scores_rating'])
        try:
            db_item.save()
        except:
            failed_import.append(listing['id'])

    with open('../../data/listings/failed_import.json', 'w') as outfile:
        json.dump(failed_import, outfile)
Exemplo n.º 3
0
    def __init__(self, db):
        self._db = db
        self.occupancy = {}
        self.counter = 0

        listings = Listing.get_all(self._db)
        for l in listings:
            self.occupancy[l.id] = {}
Exemplo n.º 4
0
def ParseAirplaneMartSummary(url):
    logger.info('Scraping Airplane Mart Summary: {}'.format(url))

    load_time = time.time()

    request = urllib.request.Request(url, headers=_HEADERS)
    soup = bs4.BeautifulSoup(urllib.request.urlopen(request), 'lxml')
    links = soup.find_all(
        'a', href=re.compile(r'/aircraft-for-sale/Single-Engine-Piston/'))

    logger.info('Found {:d} Airplane Mart listings.'.format(len(links)))

    new_listings = []

    for link in links:
        while time.time() < load_time + _REQ_DELAY:
            time.sleep(0.1)

        listing_url = urllib.parse.urljoin(url, link['href'])
        try:
            Listing.get(Listing.url == listing_url)
            logger.info('Skipping {}.'.format(link.find('b').string.strip()))
            continue
        except peewee.DoesNotExist:
            logger.info('Opening {}.'.format(link.find('b').string.strip()))

        load_time = time.time()

        listing = ParseAirplaneMartListing(listing_url)
        if not listing:
            continue

        if listing.registration:
            try:
                Listing.get(Listing.registration == listing.registration)
                logger.info('Duplicate Registration {}: {}.'.format(
                    listing.registration,
                    link.find('b').string.strip()))
                continue
            except peewee.DoesNotExist:
                pass

        listing.save()
        new_listings.append(listing)

    return new_listings
Exemplo n.º 5
0
def ParseTradeAPlaneSummary(url):
    logger.info('Scraping Trade-A-Plane summary: {}'.format(url))

    load_time = time.time()

    request = urllib.request.Request(url, headers=_HEADERS)
    soup = bs4.BeautifulSoup(urllib.request.urlopen(request), 'lxml')

    result_divs = soup.find_all('div', class_='result')

    logger.info('Found {:d} Trade-A-Plane listings.'.format(len(result_divs)))

    new_listings = []

    for div in result_divs:
        while time.time() < load_time + _REQ_DELAY:
            time.sleep(0.1)

        listing_url = urllib.parse.urljoin(url, div.a['href'])
        try:
            Listing.get(Listing.url == listing_url)
            logger.info('Skipping {}.'.format(div.a.next_element.strip()))
            continue
        except peewee.DoesNotExist:
            logger.info('Opening {}.'.format(div.a.next_element.strip()))

        load_time = time.time()

        listing = ParseTradeAPlaneListing(listing_url)
        if not listing:
            continue

        if listing.registration:
            try:
                Listing.get(Listing.registration == listing.registration)
                logger.info('Duplicate Registration {}: {}.'.format(
                    listing.registration, div.a.next_element.strip()))
                continue
            except peewee.DoesNotExist:
                pass

        listing.save()
        new_listings.append(listing)

    return new_listings
Exemplo n.º 6
0
def ParseAsoSummary(url):
    logger.info('Scraping ASO Summary: {}'.format(url))

    load_time = time.time()

    request = urllib.request.Request(url, headers=_HEADERS)
    soup = bs4.BeautifulSoup(urllib.request.urlopen(request), 'lxml')
    links = soup.find_all('a', class_='photoListingsDescription')
    links = [x for x in links if not x.find('img')]

    logger.info('Found {:d} ASO listings.'.format(len(links)))

    new_listings = []

    for link in links:
        while time.time() < load_time + _REQ_DELAY:
            time.sleep(0.1)

        listing_url = urllib.parse.urljoin(url, link['href'])
        try:
            Listing.get(Listing.url == listing_url)
            logger.info('Skipping {}.'.format(link.string.strip()))
            continue
        except peewee.DoesNotExist:
            logger.info('Opening {}.'.format(link.string.strip()))

        load_time = time.time()

        listing = ParseAsoListing(listing_url)
        if not listing:
            continue

        if listing.registration:
            try:
                Listing.get(Listing.registration == listing.registration)
                logger.info('Duplicate Registration {}: {}.'.format(
                    listing.registration, link.string.strip()))
                continue
            except peewee.DoesNotExist:
                pass

        listing.save()
        new_listings.append(listing)

    return new_listings
Exemplo n.º 7
0
def by_comp(comp_to_pull=None):
    ## display only selected company
    dates = Listing.objects().fields(date_str=1).distinct('date_str')
    return render_template(
        'index-by-comp.html',
        Listing=Listing,
        comp_to_pull=comp_to_pull,
        dates=reversed(sorted(list(dates)))  #latest date on top
    )
Exemplo n.º 8
0
def by_location(loc_to_pull=None):
    ## display only selected location
    dates = Listing.objects().fields(date_str=1).distinct('date_str')
    return render_template(
        'index-by-loc.html',
        Listing=Listing,
        loc_to_pull=loc_to_pull,
        dates=reversed(sorted(list(dates)))  #latest date on top
    )
Exemplo n.º 9
0
def run_scraper(mls=INITIAL_MLS):
    misses = 0
    foundHit = False
    while (MISS_THRESHOLD > misses):
        try:
            existing_listing = Listing.get_listing(mls)
            listing = scrape_listing(mls)

            print 'Fetching Listing ID %s' % mls
            print 'Have existing listing? %s ' % (existing_listing is not None)

            if existing_listing:
                existing_listing.is_new = False
                if int(existing_listing.price) != listing.price:
                    existing_listing.price = listing.price
                    existing_listing.is_updated = True
                else:
                    existing_listing.is_updated = False
                existing_listing.save()
            else:
                if fits_criteria(listing):
                    print '%sHIT%s' % (bcolors.OKGREEN, bcolors.ENDC)
                    foundHit = True
                    listing.is_new = True
                    listing.save()
                else:
                    print '%sMISS. Count: %s%s' % (bcolors.WARNING, misses, bcolors.ENDC)
            mls = mls + 1
            misses = 0
        except ListingNotFound:
            existing_listing = Listing.get_listing(mls)
            mls = mls + 1
            misses = misses + 1
            if existing_listing:
                existing_listing.active = False
                existing_listing.last_scraped = datetime.now()
                existing_listing.save()
            else:
                print 'misses are %s ' % misses

    if foundHit:
        print '%sFound a Hit!%s' % (bcolors.HEADER, bcolors.ENDC)
    else:
        print '%sNo Hits this time.%s' % (bcolors.FAIL, bcolors.ENDC)
Exemplo n.º 10
0
def index():
    db = get_db()
    ## get the last date the webscraper was run
    for listing in Listing.objects().fields(
            date_str=1).order_by('-date_str').limit(1):
        day_to_pull = listing.date_str

    return render_template('index.html',
                           Listing=Listing,
                           day_to_pull=day_to_pull)
Exemplo n.º 11
0
 def get(self):
     id = int(self.request.get('id'))
     item = Listing.get(db.Key.from_path('Listing', id))
     self.response.out.write('<html><body>'
                             '<form method="POST" '
                             'action="/edit">'
                             '<table>')
     self.response.out.write(ListingForm(instance=item))
     self.response.out.write('</table>'
                             '<input type="hidden" name="id" value="%s">'
                             '<input type="submit">'
                             '</form></body></html>' % id)
Exemplo n.º 12
0
 def get(self):
     id = int(self.request.get('id'))
     item = Listing.get(db.Key.from_path('Listing', id))
     self.response.out.write('<html><body>'
                             '<form method="POST" '
                             'action="/edit">'
                             '<table>')
     self.response.out.write(ListingForm(instance=item))
     self.response.out.write('</table>'
                             '<input type="hidden" name="id" value="%s">'
                             '<input type="submit">'
                             '</form></body></html>' % id)
Exemplo n.º 13
0
def add_listing(asin, listing={}):
    # We may need to add a listing with just an asin.
    listing_exists = dbapi.listing_exists(asin)
    if not (listing_exists or listing):
        dbapi.add(Listing(asin=asin))
    elif not listing_exists:
        try:
            fprice = float(listing['lowest_price'])
        except:
            fprice = None
        try:
            l = Listing(asin=asin,
                        manufacturer=listing['manufacturer'],
                        title=listing['title'],
                        part_number=listing['part_number'],
                        price=fprice,
                        upc=listing['upc'])
            dbapi.add(l)
        except:
            print('Unable to add listing to db')
    else:
        print('{0} already exists in db'.format(asin))
Exemplo n.º 14
0
def listings(setting = "aaa"):
	allListingsQuery = Listing.query.filter_by(active = True)
	if "b" in setting:
		allListingsQuery = allListingsQuery.filter_by(buysell = True)
	if "s" in setting:
		allListingsQuery = allListingsQuery.filter_by(buysell = False)
	if "l" in setting:
		allListingsQuery = allListingsQuery.filter_by(blockOrDinex = "Block")
	if "d" in setting:
		allListingsQuery = allListingsQuery.filter_by(blockOrDinex = "Dinex")
	if "u" in setting:
		allListingsQuery = allListingsQuery.order_by(Listing.price)
	if "g" in setting:
		allListingsQuery = allListingsQuery.order_by(desc(Listing.price))
	allListings = allListingsQuery.all()
	form = ListingForm()
	if(form.validate_on_submit()):
		newList = Listing(blockOrDinex = form.blockOrDinex.data, timestamp = datetime.now(), price = float(form.price.data), details = form.details.data, location = form.location.data, active = True)
		if form.buysell.data == 'Buy':
			newList.buysell = True
		else:
			newList.buysell = False
		newList.user = g.user
		db.session.add(newList)
		db.session.commit()
		if newList.buysell == True:
			alertuserstup = db.session.query(User.email).filter_by(buyAlert=True).all()
		else:
			alertuserstup = db.session.query(User.email).filter_by(sellAlert=True).all()
		alertusers = [x[0] for x in alertuserstup]
		alertusers = filter (lambda x: ('@' in x) and ('.' in x), alertusers)
		if (len(alertusers) != 0):
			msg = Message('New Post Alert on Dining Exchange',sender='*****@*****.**',recipients=alertusers)
			msg.body = "Hello,\n\n A listing for which you are receiving alerts has been posted to CMU Dining Exchange."
			msg.body += "\n\nThe listing is visible at " + "http://127.0.0.1:5000" + url_for('listings')
			mail.send(msg)
		return redirect(url_for('listings'))
	return render_template("listings.html",title ='Listings',form = form,lists=allListings,
		user=g.user,set = setting, updateFunc = update)
Exemplo n.º 15
0
def create(args):
	try:
		prof = Profile.objects.get(email=args['owner_email'])
	except Profile.DoesNotExist:
		return False, ERROR_NO_SUCH_PROFILE

	if not profile.check_password(args['password'], prof):
		return False, ERROR_INCORRECT_PASSWORD

	dt = datetime.datetime.now()
	time_created = dt.strftime('%m-%d-%Y %I:%M%p')
	encode = '%s%s%s' % (args['job_title'], args['address'], dt)
	listing_id = base64.b64encode(encode, '-_')
	neg = prof.negative_reputation
	pos = prof.positive_reputation
	rep = (pos / (pos + neg)) * 100 if pos + neg != 0 else 0
	owner_name = '%s %s' % (prof.first_name, prof.last_name)

	# Check to see if optional params were given upon creation
	expiration_date = args['expiration_date'].replace('/', '-') if 'expiration_date' in args else None
	min_reputation = args['min_reputation'] if 'min_reputation' in args else None
	job_description = args['job_description'] if 'job_description' in args else None
	# End optional settings

	listing = Listing(job_title=args['job_title'], job_picture='[]', starting_amount=args['starting_amount'],
		current_bid=args['starting_amount'], min_reputation=min_reputation,
		expiration_date=expiration_date, owner_name=owner_name, owner_email=args['owner_email'], listing_id=listing_id,
		time_created=time_created, owner_reputation=rep, status=0, bids='[]', address=args['address'],
		city=args['city'], state=args['state'], lat=args['latitude'], long=args['longitude'], job_description=job_description)

	listing.save()

	owned_listings = json.loads(prof.owned_listings)
	owned_listings.append(listing_id)
	prof.__dict__['owned_listings'] = json.dumps(owned_listings)
	prof.save()
	
	return { 'error': -1, 'listing_id' : listing_id }, None
Exemplo n.º 16
0
def _create_listing(listing_data):
	listing = Listing()
	listing.build(listing_data)

	if 'id' in listing_data:
		listing.external_id = listing_data['id']

	listing.put()
	return listing
Exemplo n.º 17
0
def ListingDetail(listing_id):
    try:
        listing = Listing.get(id=listing_id)
    except peewee.DoesNotExist:
        abort(404)

    if request.method == 'POST':
        form = ListingForm(request.form, obj=listing)
        if form.validate():
            form.populate_obj(listing)
            listing.save()
    else:
        form = ListingForm(obj=listing)

    return render_template('detail.html', form=form, listing=listing)
def import_listings():
    listings = pd.read_csv('../../data/listings/nyc_listings.csv')
    failed_import = []
    for idx, listing in listings.iterrows():
        db_item = Listing(airBnbId=listing['id'],
                          url=listing['listing_url'],
                          name=listing['name'],
                          picture_url=listing['picture_url'],
                          host_url=listing['host_url'],
                          host_name=listing['host_name'],
                          latitude=listing['latitude'],
                          longitude=listing['longitude'],
                          room_type=listing['room_type'],
                          price=listing['price'][1:],
                          minimum_nights=listing['minimum_nights'],
                          number_of_reviews=listing['number_of_reviews'],
                          review_scores_rating=listing['review_scores_rating'])
        try:
            db_item.save()
        except:
            failed_import.append(listing['id'])

    with open('../../data/listings/failed_import.json', 'w') as outfile:
        json.dump(failed_import, outfile)
Exemplo n.º 19
0
    def get(self, currency):
        listings = Listing.select().where(
            Listing.currency == currency).order_by(Listing.date.asc())

        value = 0
        amount = 0
        for listing in listings:
            if listing.type == 'buy':
                amount += listing.amount
                value += listing.price
            elif listing.type == 'sell':
                amount -= listing.amount
                value -= listing.price

        return dict((('value', float(value)), ('amount', float(amount))))
Exemplo n.º 20
0
def create_listing():
    is_valid = True
    date = datetime.strptime(request.form.get("datepicker"), '%Y-%m-%d %I:%M')
    price = request.form.get("price")
    driving_from = request.form.get("from")
    going_to = request.form.get("to")
    description = f"Driving from {driving_from} to {going_to}"
    new_listing = Listing(user_id=session['user_id'],
                          date=date,
                          price=price,
                          location_from=driving_from,
                          location_to=going_to,
                          description=description)
    db.session.add(new_listing)
    db.session.commit()
    return redirect('/profile')
Exemplo n.º 21
0
def private_listing(request,board_slug,category_slug,listing_slug=None):
    """Create or edit listing"""
    category = get_object_or_404(Category,slug=category_slug, is_active=True)   
    board = get_object_or_404(Board,slug=board_slug, is_active=True)  
    if listing_slug is not None:
        listing = get_object_or_404(Listing,slug=listing_slug, 
            category=category, board=board, user=request.user)
    else:
        listing = Listing(category=category, board=board, user=request.user)
    if request.method == "POST":
        form = ListingForm(request.POST, instance=listing)
        if form.is_valid():
            form.save()
            form.instance.create_slug()
            args = form.instance.board.slug, form.instance.category.slug, 
                form.instance.slug
            return HttpResponseRedirect(reverse('public_listing', args=args))
Exemplo n.º 22
0
def listing_create():
    """ Create a new listing.
        Takes in { listing: {
                            title,
                            description,
                            photo,
                            price,
                            longitude,
                            latitude,
                            beds,
                            rooms,
                            bathrooms,
                            created_by,
                            }}
        Returns => {
                    listing: {
                                id,
                                title,
                                description,
                                photo,
                                price,
                                longitude,
                                latitude,
                                beds,
                                rooms,
                                bathrooms,
                                created_by,
                                rented_by,
                            }
                    }
    TODO: Auth required: admin or logged in user
    """
    listing_data = request.json.get("listing")
    form = ListingCreateForm(data=listing_data)

    if form.validate():
        listing = Listing.create(form)
        db.session.commit()
        # TODO: reevaluate error with a try and except later
        return (jsonify(listing=listing.serialize(isDetailed=True)), 201)
    else:
        errors = []
        for field in form:
            for error in field.errors:
                errors.append(error)
        return (jsonify(errors=errors), 400)
Exemplo n.º 23
0
def deactivate_user(user_id):  # Edit Datastore entity
    # Get the user
    u = User.get_by_id(user_id)
    if u is None:
        raise InvalidUsage('User ID does not match any existing user', 400)

    if u.status == 'Deactivated':
        raise InvalidUsage('User is already deactivated!', 400)

    # Set user status to 'Deactivated'
    u.status = 'Deactivated'

    # Set all of the user's listings to 'Deactivated'
    u_key = ndb.Key('User', user_id)
    qry = Listing.query(Listing.owner == u_key)
    listings = qry.fetch()
    for l in listings:
        if l.status != 'Deleted':
            l.status = 'Deactivated'
            try:
                l.put()
            except:
                abort(500)

    # Add the updated user status to the Datastore
    try:
        u.put()
    except:
        abort(500)

    # Delete Search App entity
    try:
        index = search.Index(name='User')
        index.delete(str(user_id))
    except:
        abort(500)

    # Return response
    data = {
        'user_id deactivated': user_id,
        'date_deactivated': u.date_last_modified
    }
    resp = jsonify(data)
    resp.status_code = 200
    return resp
def get_listing_snapshot(listing_id):
	l = Listing.get_by_id(listing_id)
	if l is None:
		raise InvalidUsage('Listing does not exist!', status_code=400)

	listing_img_media_links = get_listing_images(listing_id)

	# Add function for related items?

	# Return the attributes of the new item
	# Figure out what we want to send in a snapshot..
	listing_data = {'name':l.name,'rating':l.rating,'hourly_rate':l.hourly_rate,
					'daily_rate':l.daily_rate,'weekly_rate':l.weekly_rate,
					'image_media_links':listing_img_media_links}

	resp = jsonify(listing_data)
	resp.status_code = 200
	return resp
Exemplo n.º 25
0
def get_part_listings(part):
    print('fetching listings for part', part)
    listings = []
    url = 'http://www.bricklink.com/search.asp'
    params = {
        'viewFrom': 'sf',
        'qMin': part.qty,
        'colorID': part.color_id,
        'shipCountryID': 'US',
        'sellerCountryID': 'US',
        'moneyTypeID': 1,
        'w': part.element_id,
        'sellerLoc': 'C',
        'searchSort': 'P',
        'sz': 500
    }
    html = requests.get(url, headers=headers, params=params).text
    if 'Quota Exceeded' in html:
        raise QuotaExceededError()
    results = soup(html, 'html.parser').findAll('td', {'valign' : 'TOP'})
    if len(results) == 0:
        raise PartNotFoundError(part)
    for r in results:
        try:
            link = r.find('a')
            price = r.findAll('b')[1].text
            price = float(price.replace('US $', ''))
            store_id = parse_qs(urlparse(link['href']).query)['p'][0]
            inventory_id = int(parse_qs(urlparse(link['href']).query)['itemID'][0])
            if not price > 0:
                price = 0.01
                print('price: fallback on price 0.01')
            if price is None or link['href'] is None or store_id is None:
                raise ListingParsingError()
            listing = Listing(part.element_id, part.color_id, part.qty, price, link.text, link['href'], store_id, inventory_id)
            if not listing.price > 0:
                raise PriceZeroError(listing)
            listings.append(listing)
        except KeyError as e:
            # Skip the malformed listing
            print('KeyError', e)
    print('Found {} listings'.format(len(listings)))
    return listings
Exemplo n.º 26
0
def get_property_id(listing_id):
    """
    by taking agent listing id,returing rex property id
    form listing  address we are building rex compatable  address, with that address we are searching for rex property, if property found, returning that property id
    else  creating property and  returing new property id
    """
    listing = Listing.get(listing_id)
    rex_property_id = None
    try:
        full_address = listing.address.unit_number
        if full_address is None:
            full_address = ""

        if listing.address.address_low is not None:
            if listing.address.unit_number is not None:
                full_address += " /" + str(listing.address.address_low)
            else:
                full_address += str(listing.address.address_low)

        full_address += (
            listing.address.street_name
            + " "
            + listing.address.suburb
            + " "
            + listing.address.state
            + " "
            + listing.address.postcode
        )
        rex_property_id = p_api.get_property_id(full_address)
    except:
        traceback.print_exc()
    if rex_property_id is None:
        property = properties.Property(
            unit_number=listing.address.unit_number,
            street_number=listing.address.address_low,
            street_name=listing.address.street_name,
            suburb=listing.address.suburb,
            state=listing.address.state,
            postcode=listing.address.postcode,
        )
        rex_property_id = p_api.create(property)["_id"]
    return rex_property_id
Exemplo n.º 27
0
def get_matched_listings(user, radius_miles, results):
	matched_listings = []
	for matched_listing in results:
		try:
			l = Listing.get_by_id(int(matched_listing.doc_id))
		except:
			abort(500)
		if l is None:
			# If there is an inconsistency and item is not found in Datastore, raise some error here...
			# raise InvalidUsage('Inconsistency in databases. Item not found in Datastore.', status_code=400)
			continue
		# FIXME: send only what's needed..
		distance 		= haversine(l.location.lat,l.location.lon,user.last_known_location.lat,user.last_known_location.lon)
		listing_data	= {'listing_id':l.key.id(), 'name':l.name, 'rating':l.rating, 
							'daily_rate':l.daily_rate, 'distance':distance,
							'score':item_score(distance, radius_miles, l.total_value, global_vars.MAX_PRICE, l.category, user.category_weights), 
							'image_media_links':get_listing_images(l.key.id())}
		matched_listings += [listing_data]

	return matched_listings
Exemplo n.º 28
0
def check_market():
    push_context()
    log.info('Checking market prices')

    psa = PixelStarshipsApi()
    market_data = psa.get_market_data()
    for k, v in market_data.items():
        listing = Listing(id=k,
                          sale_at=v['sale_at'],
                          item_name=v['item_name'],
                          item_id=v['item_id'],
                          amount=v['amount'],
                          currency=v['currency'],
                          price=v['price'],
                          user_id=v['user_id'],
                          modification=v['modification'])
        db.session.merge(listing)

    log.info('{} listings updated'.format(len(market_data)))
    db.session.commit()
Exemplo n.º 29
0
 def post(self):
   id = int(self.request.get('id'))
   item = Listing.get(db.Key.from_path('Listing', id))
   data = ListingForm(data=self.request.POST, instance=item)
   if data.is_valid():
       # Save the data, and redirect to the view page
       entity = data.save(commit=False)
       entity.added_by = users.get_current_user()
       entity.put()
       self.redirect('/list')
   else:
       # Reprint the form
       self.response.out.write('<html><body>'
                               '<form method="POST" '
                               'action="/edit">'
                               '<table>')
       self.response.out.write(data)
       self.response.out.write('</table>'
                               '<input type="hidden" name="id" value="%s">'
                               '<input type="submit">'
                               '</form></body></html>' % id)
Exemplo n.º 30
0
 def post(self):
     id = int(self.request.get('id'))
     item = Listing.get(db.Key.from_path('Listing', id))
     data = ListingForm(data=self.request.POST, instance=item)
     if data.is_valid():
         # Save the data, and redirect to the view page
         entity = data.save(commit=False)
         entity.added_by = users.get_current_user()
         entity.put()
         self.redirect('/list')
     else:
         # Reprint the form
         self.response.out.write('<html><body>'
                                 '<form method="POST" '
                                 'action="/edit">'
                                 '<table>')
         self.response.out.write(data)
         self.response.out.write(
             '</table>'
             '<input type="hidden" name="id" value="%s">'
             '<input type="submit">'
             '</form></body></html>' % id)
Exemplo n.º 31
0
    def balance(self):
        print('----WALLET----')
        listing_currencies = Listing.select().group_by(Listing.currency)
        ids = ''
        for currency in listing_currencies:
            ids += '{},'.format(currency.currency)

        profit_loss = 0
        total_wallet_value = 0
        total_spent = 0

        if len(listing_currencies) > 0:
            data = self.api.live(ids)

        for i in range(len(listing_currencies)):
            currency = listing_currencies[i]
            for item in data:
                if item['id'] == currency.currency:
                    live_value = float(item['price'])
                    balance = self.get(currency.currency)
                    current_value = balance['amount'] * live_value
                    diff = current_value - balance['value']

                    print('{}{} \t= ${} \tProfit/Loss: ${} \t\tSpent: ${}'.
                          format(round(balance['amount'], 2),
                                 currency.currency, round(current_value, 6),
                                 round(diff, 6), round(balance['value'], 6)))

                    profit_loss += diff
                    total_wallet_value += current_value
                    total_spent += balance['value']

        print('----BALANCE----')
        print('Total wallet value: ${} \tSpent: ${}'.format(
            total_wallet_value, total_spent))
        profit_loss_pct = total_spent / profit_loss
        print('Total profit/loss: %{} ==> ${}'.format(profit_loss_pct,
                                                      profit_loss))
Exemplo n.º 32
0
def list_book():
    form = ListBook()
    msg = ""
    if request.method == "POST":
        isbn = clean_isbn(form.isbn.data)
        if valid_isbn(isbn):
            book = get_book_by_isbn(isbn)
            print book
            if book is not None:
                listing = Listing(user_id=g.user.id,
                                  listing_ref=book.id,
                                  course=form.course.data.replace(" ",
                                                                  "").upper(),
                                  notes=form.notes.data,
                                  cost=form.cost.data)
                db.session.add(listing)
                db.session.commit()
                msg = "Listing added successfully!"
            else:
                msg = "Book not found!"
        else:
            msg = "ISBN was not 10 or 13 characters long!"

    return render_template("list_book.html", form=form, msg=msg)
Exemplo n.º 33
0
    def perform(self, vendor_id=None, order_id=None, items=None):
        amazon = Vendor.query.filter_by(name='Amazon').one()
        vendor = Vendor.query.filter_by(id=vendor_id).one()

        for item_doc in items:
            sku = item_doc['sku']
            amz_listing = Listing.query.filter_by(vendor_id=amazon.id, sku=sku).first() \
                          or Listing(vendor=amazon, sku=sku)

            item = OrderItem.query.filter(
                OrderItem.order_id == order_id,
                OrderItem.extra['order_item_id'].astext
                == item_doc['order_item_id']).first() or OrderItem(
                    order_id=order_id)

            item.quantity = item_doc.pop('qty_shipped')
            item.received = item.quantity
            item.source = Inventory.query.filter_by(owner_id=vendor.id, listing_id=amz_listing.id).first() \
                          or Inventory(owner=vendor, listing=amz_listing)
            item.destination = None
            item.update(item_doc)

            db.session.add(item)
            db.session.commit()
Exemplo n.º 34
0
    def perform(self, listing=None):
        # Do some basic cleaning
        for field, value in listing.items():
            if isinstance(value, str):
                listing[field] = value.strip()

        # Try to locate the listing in the database
        sku = listing.pop('sku')
        vendor_id = listing.pop('vendor_id', None)

        if vendor_id is None:
            netloc = urlparse(listing['detail_url'])[1]
            vendor = Vendor.query.filter(Vendor.url.ilike(f'%{netloc}%')).one()
            vendor_id = vendor.id

        model = Listing.query.filter_by(vendor_id=vendor_id, sku=sku).one_or_none()\
                    or Listing(vendor_id=vendor_id, sku=sku)

        # Update and commit
        model.update(listing)
        db.session.add(model)
        db.session.commit()

        return model.id
Exemplo n.º 35
0
def updateDBTickets(eventId, listings):
  try:
    e = Event.objects.get(id=eventId)
  except Event.DoesNotExist:
    # User queried an event not in the database, probably search by modifying url
    logging.info('event ' + str(eventId) + ' not in db yet')
    if int(eventId) == 1: # for testing only
      e = Event(id=1)
      e.save()
    else:
      event = getEvent(eventId)
      logging.info(event)
      if not event.get('error'):
        e = storeEvent(event)
      else:
        return {'error': 'event does not exist'}

  oldListings = dict((l.id,l) for l in e.listing_set.all())
  newListings = dict((l['listingId'], l) for l in listings)

  for lid in oldListings:
    oldListing = oldListings[lid]
    if lid not in newListings.keys():
      # if the listing in database is not in the latest listings, then it is sold
      logging.info("All tickets in the listing " + str(lid) + " have been sold out!")
      if(oldListing.quantity > 0):
        # insert all tickets into SoldTicket
        seats = [seat.strip() for seat in oldListing.seatNumbers.split(',')]
        for seat in seats:
          t = SoldTicket(listingId=lid, event=e, zoneId=oldListing.zoneId, zoneName=oldListing.zoneName, 
            sectionId=oldListing.sectionId, sectionName=oldListing.sectionName, row=oldListing.row,
            seatNumber=seat, currentPrice=oldListing.currentPrice)
          t.save()
        remaining = oldListing.quantity - len(seats)
        if remaining > 0: # mainly caused by seatNumbers == "General Admission"
          for i in xrange(0, remaining):
            t = SoldTicket(listingId=lid, event=e, zoneId=oldListing.zoneId, zoneName=oldListing.zoneName, 
            sectionId=oldListing.sectionId, sectionName=oldListing.sectionName, row=oldListing.row,
            seatNumber=None, currentPrice=oldListing.currentPrice)
            t.save()

      # Delete the empty listing
      Listing.objects.filter(id=lid).delete()
    else:
      # the listing is still active, then check its quantity
      curListing = newListings[lid]
      if curListing['quantity'] < oldListing.quantity:
        # Some tickets are sold but not all of them
        # find out which seats were sold, update listing and insert into sold tickets
        oldSeats = [seat.strip() for seat in oldListing.seatNumbers.split(',')]
        newSeats = [seat.strip() for seat in curListing['seatNumbers'].split(',')]
        missingSeats = [seat for seat in oldSeats if seat not in newSeats]
        for seat in missingSeats:
          t = SoldTicket(listingId=lid, event=e, zoneId=oldListing.zoneId, zoneName=oldListing.zoneName, 
            sectionId=oldListing.sectionId, sectionName=oldListing.sectionName, row=oldListing.row,
            seatNumber=seat, currentPrice=oldListing.currentPrice)
          t.save()
        remaining = oldListing.quantity - curListing['quantity'] - len(missingSeats)
        if remaining > 0: # mainly caused by seatNumbers == "General Admission"
          for i in xrange(0, remaining):
            t = SoldTicket(listingId=lid, event=e, zoneId=oldListing.zoneId, zoneName=oldListing.zoneName, 
            sectionId=oldListing.sectionId, sectionName=oldListing.sectionName, row=oldListing.row,
            seatNumber=None, currentPrice=oldListing.currentPrice)
            t.save()

        oldListing.seatNumbers = curListing['seatNumbers']
        oldListing.quantity = curListing['quantity']
        oldListing.save()

  for lid in newListings:
    if lid not in oldListings.keys():
      # Someone has posted a new listing that is not in the database, put it into database
      newListing = newListings[lid]
      l = Listing(id=newListing['listingId'], event=e, quantity=newListing['quantity'],
                zoneId=newListing['zoneId'], zoneName=newListing['zoneName'], sectionId=newListing['sectionId'], 
                sectionName=newListing['sectionName'], row=newListing['row'], seatNumbers=newListing['seatNumbers'],
                currentPrice=newListing['currentPrice']['amount'])
      l.save()
Exemplo n.º 36
0
def newListing():
    categories = session.query(Category).all()
    if request.method == 'POST':
        if checkIfExists(request.form['name'],Listing):
            existingListing = session.query(Listing).filter_by(name=request.form['name']).one()
            flash('A listing called "%s" already exists. Please re-name your listing.' % existingListing.name)
            return render_template('newListing.html', categories=categories)
        elif request.form['name'] == '':
            flash('Please enter a name for your listing.')
            return render_template('newListing.html', categories=categories)
        elif request.form['new-category'] == '' and request.form['category'] == 'False':
            flash('You must select or create a category')
            return render_template('newListing.html', categories=categories)
        elif request.form['description'] == '':
            flash('You must fill out a description')
            return render_template('newListing.html', categories=categories)
        else:
            imagename = ''
            # check if user uploaded an image
            if request.files['image']:
                if 'image' not in request.files:
                    flash('No file part')
                    return render_template('newListing.html', categories=categories)
                image = request.files['image']
                # if user does not select file, browser also
                # submits an empty part without the filename
                if image.filename == '':
                    flash('No selected image')
                    return redirect(request.url)
                if image and allowed_file(image.filename):
                    imagename = secure_filename(image.filename)
                    image.save(os.path.join(app.config['UPLOAD_FOLDER'], imagename))
            if request.form['new-category']:
                if checkIfExists(request.form['new-category'],Category):
                    flash('A category with that name already exists. Please re-name your category.')
                    return render_template('newListing.html', categories=categories)
                else:
                    newCategory = Category(name=request.form['new-category'])
                    session.add(newCategory)
                    session.commit()
                newListing = Listing(
                    name=request.form['name'], 
                    description=request.form['description'], 
                    image=imagename,
                    category_id=getCategoryID(request.form['new-category']),
                    user_id=login_session['user_id'])
                session.add(newListing)
                flash('New Listing "%s" Successfully Created' % newListing.name)
                session.commit()
                return redirect(url_for('showListings'))
            else:
                newListing = Listing(
                    name=request.form['name'], 
                    description=request.form['description'], 
                    image=imagename,
                    category_id=getCategoryID(request.form['category']), 
                    user_id=login_session['user_id'])
                session.add(newListing)
                flash('New Listing "%s" Successfully Created' % newListing.name)
                session.commit()
                return redirect(url_for('showListings'))   
    else:
        return render_template('newListing.html', categories=categories)
Exemplo n.º 37
0
 def get (self):
     id = int(self.request.get('id'))
     item = Listing.get(db.Key.from_path('Listing', id))
     self.response.out.write('Listing: %s' % vars(item));
Exemplo n.º 38
0
  def get(self):
    def _simple_error(message, code=400):
      self.error(code)
      self.response.out.write(simplejson.dumps({
        'status': 'error',
        'error': { 'message': message },
        'results': []
      }))
      return None
      
    
    self.response.headers['Content-Type'] = 'application/json'
    query_type = self.request.get('type')
    user = self.request.get('user');
    
    if not query_type in ['proximity', 'bounds', 'user', 'default']:
      return _simple_error('type parameter must be '
                           'one of "proximity", "bounds", "user".',
                           code=400)
    
    if query_type == 'proximity':
      try:
        center = geotypes.Point(float(self.request.get('lat')),
                                float(self.request.get('lon')))
      except ValueError:
        return _simple_error('lat and lon parameters must be valid latitude '
                             'and longitude values.')
    elif query_type == 'bounds':
      try:
        bounds = geotypes.Box(float(self.request.get('north')),
                              float(self.request.get('east')),
                              float(self.request.get('south')),
                              float(self.request.get('west')))
      except ValueError:
        return _simple_error('north, south, east, and west parameters must be '
                             'valid latitude/longitude values.')
    
    max_results = 100
    if self.request.get('maxresults'):
      max_results = int(self.request.get('maxresults'))
    
    max_distance = 8000000 # 80 km ~ 50 mi
    if self.request.get('maxdistance'):
      max_distance = float(self.request.get('maxdistance'))

      
    results = []
    try:
      # Can't provide an ordering here in case inequality filters are used.
      base_query = Listing.all()
      
      #if property_type:
        #base_query.filter('property_type =', property_type)
      
      # Natural ordering chosen to be public school enrollment.
      #base_query.order('-')
      
      # Perform proximity or bounds fetch.
      if query_type == 'proximity':
        results = Listing.proximity_fetch(base_query, center, max_results=max_results, max_distance=max_distance)
      
      elif query_type == 'bounds':
        results = Listing.bounding_box_fetch(base_query, bounds, max_results=max_results)
        
      elif query_type == 'user':
          limit = self.request.get("limit")
          offset = self.request.get("offset")
          if not limit:
              limit = 1000
          else:
              limit = int(limit)
          if not offset:
              offset = 0
          else:
              offset = int(offset)
          results = base_query.fetch(limit, offset);
      
      public_attrs = Listing.public_attributes()
      
      results_obj = [
          _merge_dicts({
            'lat': result.location.lat,
            'lng': result.location.lon,
            },
            dict([(attr, getattr(result, attr))
                  for attr in public_attrs]))
          for result in results]

      self.response.out.write(simplejson.dumps({
        'status': 'success',
        'results': results_obj,
      }))
    except:
      return _simple_error(str(sys.exc_info()[1]), code=500)
Exemplo n.º 39
0
def dict_to_listing(d):
    """
    Convert dictionary to listing object
    :param d: dictionary
    :return: listing object
    """
    ls = Listing()
    ls.title = d['title'] if 'title' in d else ''
    ls.description = d['description'] if 'description' in d else ''
    ls.employer = d['employer'] if 'employer' in d else ''
    ls.student_matches = d['student_matches'] if 'student_matches' in d else []
    ls.salary = float(d['salary']) if 'salary' in d else 0
    ls.location = d['location'] if 'location' in d else ''
    if 'desired_skills' in d:
        if type(d['desired_skills']) == 'str':
            skills = d['desired_skills'].strip().split(',')
            ls.desired_skills = [i.strip() for i in skills]
        else:
            ls.desired_skills = d['desired_skills']
    else:
        ls.desired_skills = []
    ls.job_type = d['job_type'] if 'job_type' in d else [
        'Internship', 'Full-Time'
    ]
    return ls
Exemplo n.º 40
0
        except CapabilityDisabledError:
            flash(u'The database is currently in read-only mode. We apologize for the inconvenience. Please try again later', 'info')
            logging.error(traceback.extract_stack())
        except TransactionFailedError:
            logging.error(traceback.extract_stack())
            flash(u'Error saving item to database', 'error')
        finally:
            return redirect(url_for('all_listings'))
    else:
        return render_template('add_listing.html', form=form)

@account_required
def manage_listings():
    '''Manage listings'''
    '''Get all listings in database'''
    listings = Listing.get_by_user(users.get_current_user())
    return render_template('manage_listings.html', listings=listings)

@account_required
def manage_listing(id):
    listing = Listing.get_by_id(id)
    if listing is None:
        flash(u'No listing with that ID in database')
        return redirect(url_for('manage_listings'))
    form = EditListingForm(obj=listing)
    if form.validate_on_submit():
        try:
            persist_listing(form, listing)
            flash(u'Listing %s successfully updated' % listing.key().id(), 'success')
        except CapabilityDisabledError:
            flash(u'The database is currently in read-only mode. We apologize for the inconvenience. Please try again later', 'info')
Exemplo n.º 41
0
def manage_listing(id):
    listing = Listing.get_by_id(id)
    if listing is None:
Exemplo n.º 42
0
    def get(self):
        def _simple_error(message, code=400):
            self.error(code)
            self.response.out.write(
                simplejson.dumps({
                    'status': 'error',
                    'error': {
                        'message': message
                    },
                    'results': []
                }))
            return None

        self.response.headers['Content-Type'] = 'application/json'
        query_type = self.request.get('type')
        user = self.request.get('user')

        if not query_type in ['proximity', 'bounds', 'user', 'default']:
            return _simple_error(
                'type parameter must be '
                'one of "proximity", "bounds", "user".',
                code=400)

        if query_type == 'proximity':
            try:
                center = geotypes.Point(float(self.request.get('lat')),
                                        float(self.request.get('lon')))
            except ValueError:
                return _simple_error(
                    'lat and lon parameters must be valid latitude '
                    'and longitude values.')
        elif query_type == 'bounds':
            try:
                bounds = geotypes.Box(float(self.request.get('north')),
                                      float(self.request.get('east')),
                                      float(self.request.get('south')),
                                      float(self.request.get('west')))
            except ValueError:
                return _simple_error(
                    'north, south, east, and west parameters must be '
                    'valid latitude/longitude values.')

        max_results = 100
        if self.request.get('maxresults'):
            max_results = int(self.request.get('maxresults'))

        max_distance = 8000000  # 80 km ~ 50 mi
        if self.request.get('maxdistance'):
            max_distance = float(self.request.get('maxdistance'))

        results = []
        try:
            # Can't provide an ordering here in case inequality filters are used.
            base_query = Listing.all()

            #if property_type:
            #base_query.filter('property_type =', property_type)

            # Natural ordering chosen to be public school enrollment.
            #base_query.order('-')

            # Perform proximity or bounds fetch.
            if query_type == 'proximity':
                results = Listing.proximity_fetch(base_query,
                                                  center,
                                                  max_results=max_results,
                                                  max_distance=max_distance)

            elif query_type == 'bounds':
                results = Listing.bounding_box_fetch(base_query,
                                                     bounds,
                                                     max_results=max_results)

            elif query_type == 'user':
                limit = self.request.get("limit")
                offset = self.request.get("offset")
                if not limit:
                    limit = 1000
                else:
                    limit = int(limit)
                if not offset:
                    offset = 0
                else:
                    offset = int(offset)
                results = base_query.fetch(limit, offset)

            public_attrs = Listing.public_attributes()

            results_obj = [
                _merge_dicts(
                    {
                        'lat': result.location.lat,
                        'lng': result.location.lon,
                    },
                    dict([(attr, getattr(result, attr))
                          for attr in public_attrs])) for result in results
            ]

            self.response.out.write(
                simplejson.dumps({
                    'status': 'success',
                    'results': results_obj,
                }))
        except:
            return _simple_error(str(sys.exc_info()[1]), code=500)
Exemplo n.º 43
0
from models import Listing

MISS_THRESHOLD = 50
ZIPS = ['84121']
MAX_PRICE = 350000
CITY1 = 'cottonwood'
CITY2 = 'salt'

# INITIAL_MLS = 1239271, 1206693, 1204927
INITIAL_MLS = Listing.get_last_mls()