def put(self, provider):
""" Create auth details for a provider """
backend = self.get_backend(provider)
parser = reqparse.RequestParser()
for f in backend.setupFields:
parser.add_argument(f[0], type=f[1])
args = parser.parse_args()
try:
key, details = backend().setup(**args)
except AuthSetupMissingInfo:
abort(400, message="Missing data for auth provider")
ua = UserAuthentication()
ua.user = g.user
ua.provider = backend.provider
ua.key = key
ua.provider_details = details
try:
crud.add(ua)
except IntegrityError:
abort(400, message="Authentication provider and details already exist")
return '', 201
def post(self):
""" Create new user """
parser = reqparse.RequestParser()
parser.add_argument('email', type=str)
parser.add_argument('display_name', type=str)
args = parser.parse_args()
if args.email is None or not args.email:
abort(400, message="An e-mail address must be provided")
if args.display_name is None or not args.display_name:
abort(400, message="An display name must be provided")
user = User_model()
user.email = args.email
user.display_name = args.display_name
try:
crud.add(user)
except IntegrityError:
abort(400, message="User %s already exists" % args.email)
data = dict()
data['user'] = user
data['token'] = generate_user_token(user)
ret_fields = {
'token': fields.String,
'user': fields.Nested({
'id': fields.Integer,
'email': fields.String,
'display_name': fields.String
})
}
return marshal(data, ret_fields), 201
def setUp(self):
super(AuthTest, self).setUp()
self.u = User()
self.u.email = "*****@*****.**"
self.u.display_name = "AuthTest"
crud.add(self.u)
def post(self, auction_id):
""" Post a bid to an auction """
auction = get_auction_by_id_or_abort(auction_id)
if auction.creator == g.user:
abort(400, message='Auction owners cannot bid on their own auctions')
if auction.has_ended:
abort(400, message='Auction has not started')
if not auction.has_started:
abort(404, message='Auction not found')
parser = reqparse.RequestParser()
parser.add_argument('price', type=Decimal, help="Bid must be of decimal type")
args = parser.parse_args()
if args.price is None or args.price <= 0:
abort(400, message='Bid price must be positive')
bid = Bid_model()
bid.price = args.price
bid.user = g.user
bid.auction = auction
fixed_bid, msg = auction.create_bid(bid)
if fixed_bid is None:
abort(400, message=msg)
crud.add(fixed_bid)
ret_fields = {
'id': fields.Integer,
'auction': fields.Nested({
'id': fields.Integer,
'tite': fields.String
}),
'bid_time': fields.DateTime,
'price': fields.Fixed(decimals=2)
}
return marshal(fixed_bid, ret_fields), 200
def test_pwd_auth(self):
from penelophant.auth.backends.PasswordAuth import PasswordAuth
p = PasswordAuth()
password = '******'
self.assertEqual(p.provider, 'password')
ua = UserAuthentication()
ua.user = self.u
ua.provider = p.provider
key, details = p.setup(password)
self.assertIsNotNone(key)
self.assertIsNotNone(details)
ua.key = key
ua.provider_details = details
crud.add(ua)
self.assertEqual(p.getUser(self.u.email, password), self.u)
def auction_completion():
""" Check if auction is complete
If it is, generate an invoice.
"""
session = db.session
# get all completed auctions
auctions = session.query(Auction_model)\
.filter(Auction_model.end_time < datetime.utcnow())
for auction in auctions:
inv = Invoice_model()
inv.bid, inv.amount = auction.find_winner()
inv.payer = inv.bid.user
inv.payee = auction.creator
# add the invoice if it does not exist
if session.query(Invoice_model).filter(Invoice_model.bid_id == inv.bid_id).count() == 0:
crud.add(inv)
return
def setUp(self):
super(InvoiceTest, self).setUp()
self.u = User()
self.u.email = "*****@*****.**"
self.u.display_name = "InvoiceTest"
crud.add(self.u)
user2 = User()
user2.email = "*****@*****.**"
user2.display_name = "InvoiceTest2"
crud.add(user2)
self.auction = Auction()
self.auction.title = "InvoiceTest"
self.auction.type = "doubleblind"
self.auction.creator = user2
crud.add(self.auction)
self.bid = Bid()
self.bid.price = 50
self.bid.user = self.u
self.bid.auction = self.auction
crud.add(self.bid)
self.invoice = Invoice()
self.invoice.bid = self.bid
self.invoice.payer = self.u
self.invoice.payee = user2
self.invoice.amount = self.bid.price
crud.add(self.invoice)
def run(self):
""" Execute command """
from faker import Factory
from penelophant.fakers.products import Provider as ProductProvider
self.f = Factory.create('en_US')
self.f.add_provider(ProductProvider)
n = 20 # number of users/auctions
users = [] # list of users
auctions = [] # list of auctions
bids = [] # list of bids
for i in range(n):
user = User()
profile = self.f.simple_profile()
user.email = profile['mail']
user.display_name = profile['username']
crud.add(user)
users.append(user)
for i in range(n):
start_price = randint(0, 150)
auction = Auction()
auction.title = self.f.product()
auction.creator = users[randint(1, len(users))-1]
auction.end_time = datetime.utcnow() + timedelta(minutes=randint(20, 14400))
auction.start_price = start_price
auction.reserve = start_price+randint(0, 50)
auction.type = 'doubleblind'
crud.add(auction)
auctions.append(auction)
for i in range(len(auctions)):
last_price = auctions[i].start_price
last_user = None
for dummy in range(randint(0, 5)):
user = users[randint(1, len(users))-1]
while user == auctions[i] and user != last_user:
user = users[randint(1, len(users))-1]
last_user = user
bid = Bid()
bid.user = user
bid.auction = auctions[i]
bid.price = last_price+randint(1, 50)
crud.add(bid)
bids.append(bid)
def post(self):
""" Handle auction creation """
parser = reqparse.RequestParser()
parser.add_argument('title', type=str, required=True)
parser.add_argument('description', type=str)
parser.add_argument('type', type=str, required=True)
parser.add_argument('start_time', type=int) # Must be a UNIX timestamp
parser.add_argument('end_time', type=int, required=True) # Must be a UNIX timestamp
parser.add_argument('reserve', type=Decimal)
parser.add_argument('start_price', type=Decimal)
args = parser.parse_args()
print(args.title)
start_time = datetime.utcnow()
if args.start_time:
start_time = datetime.utcfromtimestamp(args.start_time)
end_time = datetime.utcfromtimestamp(args.end_time)
if args.title is None:
abort(400, message="You need a title for this auction!")
if args.type is None:
abort(400, message="You need a type for this auction!")
if not end_time > start_time:
abort(400, message="End time cannot before the start time")
if not start_time >= datetime.utcnow()-timedelta(minutes=5):
abort(400, message="Start time cannot be in the past")
else:
if start_time < datetime.utcnow():
start_time = datetime.utcnow()
if args.start_price is None:
args.start_price = 0
if args.reserve is None:
args.reserve = 0
if args.reserve < 0:
abort(400, message="Reserve price must be positive")
if args.start_price < 0:
abort(400, message="Start price must be positive")
if args.start_price > args.reserve:
args.reserve = 0
auction = find_auction_type(args.type)()
auction.title = args.title
auction.description = args.description
auction.start_time = start_time
auction.end_time = end_time
auction.reserve = args.reserve
auction.start_price = args.start_price
auction.creator = g.user
crud.add(auction)
return marshal(auction, auction_fields), 201
