def setUp(self):
car = Car()
car.make = "Avensis"
car.save()
self.car = car
self.id = car.pk
def save_data_in_db(data_list):
"""将数据保持到数据库中"""
_befor_str = "productPriceReadable-"
for data in data_list:
# 获取汽车详情url
url = data.find_all('a', href=True)[0]['href']
link = 'http://mall.autohome.com.cn' + url
# 获取汽车价格信息
__tag = url.split('/')[2].split('-')[0]
befor_price = data.find(id=_befor_str+__tag)
if data.find(id=_befor_str+__tag):
befor_price = data.find(id=_befor_str+__tag).text
else:
befor_price = ''
after_price = _get_after_price(link)
# 获取汽车产品名和规格
car_title = data.find('div', class_='carbox-title')['title'].split(' ', 1)
logo = car_title[0]
model = car_title[1]
# 获取汽车购买方案
plan = data.find('div', class_='carbox-tip')['title']
# 获取汽车购买次数
purchased = data.find('div', class_='carbox-number').span.text
# 开始保存数据
car = Car(logo, model, befor_price, after_price, plan, purchased, link)
car.save()
return True
def store_car_data(cars):
"""Stores information of all cars into car table."""
# Create a MySQL database connector object and connect
mysql_db = MySQLDatabase(database=s.SCHEMA,
user=s.USER,
password=s.PASSWORD,
host=s.HOST,
port=s.PORT)
mysql_db.connect()
for car in cars:
# create new car record
new_car = Car(brand=car.get("brand"),
model=car.get("model"),
year=car.get("year"),
price=car.get("price"),
ext_color=car.get("ext_color"),
int_color=car.get("int_color"),
transmission=car.get("transmission"),
phone=car.get("phone"))
new_car.save() # car is stored into database
mysql_db.close()
print("All data saved successfully.")
async def cars_list(request):
try:
result = Car(**await request.json())
result.save()
return web.json_response({'msg': 'Saved'}, status=201)
except Exception as e:
return web.json_response({'msg': str(e)}, status=400)
def process_item(self, item, spider):
print 'PROCESSING ITEM {}'.format(item.get('ref'))
c = Car(**item)
try:
c.save()
except IntegrityError as ex:
pass
return item
def mutate(root, info, car):
if not car.car_id:
car.car_id = len(CarModel.objects) + 1
brand = BrandModel.objects.get(brand_id=car.brand)
car_model = CarModel(
name = car.name,
brand = brand.id,
car_id = car.car_id
)
car_model.save()
return createModel(car=car_model)
def addNewCar(request):
try:
model = request.GET.get('model')
maker = request.GET.get('maker')
manufYear = request.GET.get('manuf_year')
car = Car(carModel=model, carMaker=maker, carManufactureYear=manufYear)
car.save()
info = {}
info['success'] = True
return HttpResponse(json.dumps(info), content_type="application/json")
except Exception as e:
err = {}
err['success'] = False
err['message'] = str(e.message) + str(e)
return HttpResponseBadRequest(json.dumps(err), content_type="application/json")
def add_some_stuff_logic():
# data = data_manager.load_data(Person)
# print (data)
p1 = Person('james', 'jackson')
p2 = Person('Joan', 'Simpson')
Person.add(p1)
Person.add(p2)
Person.save()
c1 = Car('Ferrari', 'Sedan')
c2 = Car('Peugeot', 'Station')
Car.add(c1)
Car.add(c2)
Car.save()
print(Car.show())
def post(self):
user = get_jwt_identity()
data = parser.parse_args()
logger = logging.getLogger('app.add-car-get')
car = Car()
car.name = data['name']
car.price = data['price']
car.description = data['description']
car.brand = data['brand']
car.model = data['model']
d = data['year'].split(',')
car.year = date(int(d[0]), int(d[1]), int(d[2]))
car.transmission = data['transmission']
car.engine = data['engine']
car.mileage = data['mileage']
car.fuel = data['fuel']
car.drive_train = data['drive_train']
car.car_type = data['type']
print "[*] Add Car: "
print data
try:
car.owner = int(user) #User.get(id=int(user)) #int(data['user']))
car.save()
car.add_search()
return {
'data': car.dictionary(),
'message': 'Posting saved',
'status': 'success'
}
except Exception as e:
#logger.error(str(e))
traceback.print_exc(file=sys.stdout)
return {
'data': '',
'message': 'And error occur please check your fields',
'status': 'error'
}
def save_data_in_db(data_list):
"""将数据保持到数据库中"""
_befor_str = "productPriceReadable-"
for data in data_list:
# 获取汽车详情url
url = data.find_all('a', href=True)[0]['href']
link = 'http://mall.autohome.com.cn' + url
# 获取汽车价格信息
__tag = url.split('/')[2].split('-')[0]
befor_price = data.find(id=_befor_str + __tag)
if data.find(id=_befor_str + __tag):
befor_price = data.find(id=_befor_str + __tag).text
else:
befor_price = ''
after_price = _get_after_price(link)
# 获取汽车产品名和规格
car_title = data.find('div',
class_='carbox-title')['title'].split(' ', 1)
logo = car_title[0]
model = car_title[1]
# 获取汽车购买方案
plan = data.find('div', class_='carbox-tip')['title']
# 获取汽车购买次数
purchased = data.find('div', class_='carbox-number').span.text
# 开始保存数据
car = Car(logo, model, befor_price, after_price, plan, purchased, link)
car.save()
return True
def test_basic(self):
# Save up the number of connected signals so that we can check at the
# end that all the signals we register get properly unregistered (#9989)
pre_signals = (
len(signals.pre_save.receivers),
len(signals.post_save.receivers),
len(signals.pre_delete.receivers),
len(signals.post_delete.receivers),
)
data = []
def pre_save_test(signal, sender, instance, **kwargs):
data.append(
(instance, kwargs.get("raw", False))
)
signals.pre_save.connect(pre_save_test)
def post_save_test(signal, sender, instance, **kwargs):
data.append(
(instance, kwargs.get("created"), kwargs.get("raw", False))
)
signals.post_save.connect(post_save_test)
def pre_delete_test(signal, sender, instance, **kwargs):
data.append(
(instance, instance.id is None)
)
signals.pre_delete.connect(pre_delete_test)
post_delete_test = PostDeleteHandler(data)
signals.post_delete.connect(post_delete_test)
# throw a decorator syntax receiver into the mix
@receiver(signals.pre_save)
def pre_save_decorator_test(signal, sender, instance, **kwargs):
data.append(instance)
@receiver(signals.pre_save, sender=Car)
def pre_save_decorator_sender_test(signal, sender, instance, **kwargs):
data.append(instance)
p1 = Person(first_name="John", last_name="Smith")
self.assertEqual(data, [])
p1.save()
self.assertEqual(data, [
(p1, False),
p1,
(p1, True, False),
])
data[:] = []
p1.first_name = "Tom"
p1.save()
self.assertEqual(data, [
(p1, False),
p1,
(p1, False, False),
])
data[:] = []
# Car signal (sender defined)
c1 = Car(make="Volkswagon", model="Passat")
c1.save()
self.assertEqual(data, [
(c1, False),
c1,
c1,
(c1, True, False),
])
data[:] = []
# Calling an internal method purely so that we can trigger a "raw" save.
p1.save_base(raw=True)
self.assertEqual(data, [
(p1, True),
p1,
(p1, False, True),
])
data[:] = []
p1.delete()
self.assertEqual(data, [
(p1, False),
(p1, False),
])
data[:] = []
p2 = Person(first_name="James", last_name="Jones")
p2.id = 99999
p2.save()
self.assertEqual(data, [
(p2, False),
p2,
(p2, True, False),
])
data[:] = []
p2.id = 99998
p2.save()
self.assertEqual(data, [
(p2, False),
p2,
(p2, True, False),
])
data[:] = []
p2.delete()
self.assertEqual(data, [
(p2, False),
(p2, False)
])
self.assertQuerysetEqual(
Person.objects.all(), [
"James Jones",
],
unicode
)
signals.post_delete.disconnect(post_delete_test)
signals.pre_delete.disconnect(pre_delete_test)
signals.post_save.disconnect(post_save_test)
signals.pre_save.disconnect(pre_save_test)
signals.pre_save.disconnect(pre_save_decorator_test)
signals.pre_save.disconnect(pre_save_decorator_sender_test, sender=Car)
# Check that all our signals got disconnected properly.
post_signals = (
len(signals.pre_save.receivers),
len(signals.post_save.receivers),
len(signals.pre_delete.receivers),
len(signals.post_delete.receivers),
)
self.assertEqual(pre_signals, post_signals)
def test_basic(self):
# Save up the number of connected signals so that we can check at the
# end that all the signals we register get properly unregistered (#9989)
pre_signals = (
len(signals.pre_save.receivers),
len(signals.post_save.receivers),
len(signals.pre_delete.receivers),
len(signals.post_delete.receivers),
)
data = []
def pre_save_test(signal, sender, instance, **kwargs):
data.append((instance, kwargs.get("raw", False)))
signals.pre_save.connect(pre_save_test)
def post_save_test(signal, sender, instance, **kwargs):
data.append(
(instance, kwargs.get("created"), kwargs.get("raw", False)))
signals.post_save.connect(post_save_test)
def pre_delete_test(signal, sender, instance, **kwargs):
data.append((instance, instance.id is None))
signals.pre_delete.connect(pre_delete_test)
post_delete_test = PostDeleteHandler(data)
signals.post_delete.connect(post_delete_test)
# throw a decorator syntax receiver into the mix
@receiver(signals.pre_save)
def pre_save_decorator_test(signal, sender, instance, **kwargs):
data.append(instance)
@receiver(signals.pre_save, sender=Car)
def pre_save_decorator_sender_test(signal, sender, instance, **kwargs):
data.append(instance)
p1 = Person(first_name="John", last_name="Smith")
self.assertEqual(data, [])
p1.save()
self.assertEqual(data, [
(p1, False),
p1,
(p1, True, False),
])
data[:] = []
p1.first_name = "Tom"
p1.save()
self.assertEqual(data, [
(p1, False),
p1,
(p1, False, False),
])
data[:] = []
# Car signal (sender defined)
c1 = Car(make="Volkswagon", model="Passat")
c1.save()
self.assertEqual(data, [
(c1, False),
c1,
c1,
(c1, True, False),
])
data[:] = []
# Calling an internal method purely so that we can trigger a "raw" save.
p1.save_base(raw=True)
self.assertEqual(data, [
(p1, True),
p1,
(p1, False, True),
])
data[:] = []
p1.delete()
self.assertEqual(data, [
(p1, False),
(p1, False),
])
data[:] = []
p2 = Person(first_name="James", last_name="Jones")
p2.id = 99999
p2.save()
self.assertEqual(data, [
(p2, False),
p2,
(p2, True, False),
])
data[:] = []
p2.id = 99998
p2.save()
self.assertEqual(data, [
(p2, False),
p2,
(p2, True, False),
])
data[:] = []
p2.delete()
self.assertEqual(data, [(p2, False), (p2, False)])
self.assertQuerysetEqual(Person.objects.all(), [
"James Jones",
], unicode)
signals.post_delete.disconnect(post_delete_test)
signals.pre_delete.disconnect(pre_delete_test)
signals.post_save.disconnect(post_save_test)
signals.pre_save.disconnect(pre_save_test)
signals.pre_save.disconnect(pre_save_decorator_test)
signals.pre_save.disconnect(pre_save_decorator_sender_test, sender=Car)
# Check that all our signals got disconnected properly.
post_signals = (
len(signals.pre_save.receivers),
len(signals.post_save.receivers),
len(signals.pre_delete.receivers),
len(signals.post_delete.receivers),
)
self.assertEqual(pre_signals, post_signals)
def save(self):
data = self.cleaned_data
car_data = Car(name = data['name'], image= data['image'])
car_data.save()
return True
