def generatorLastName(gend):
person = Person('ru')
if gend == 'M':
name = person.last_name(gender = Gender.MALE)
else:
name = person.last_name(gender = Gender.FEMALE)
return russian_name(name)
def handle(self, *args, **options):
# raise NotImplementedError()
Snippet.objects.all().delete()
users = []
person = Person()
for _ in range(40):
User.objects.create(password=person.password(),
username=person.username(),
first_name=person.name(),
last_name=person.last_name(),
email=person.email())
text = Text()
users = User.objects.all()
for _ in range(30):
language = choice(['python', 'javascript', 'ruby', 'java'])
if language == "java":
content = open(BASE_DIR + "/core/fakecode/file.java").read()
elif language == "python":
content = open(BASE_DIR + "/core/fakecode/python.py").read()
elif language == "javascript":
content = open(BASE_DIR +
"/core/fakecode/javascript.js").read()
else:
content = open(BASE_DIR + "/core/fakecode/ruby.rb").read()
title = text.sentence()
if not Snippet.objects.filter(title=title).exists():
Snippet.objects.create(author=choice(users),
title=title,
language=language,
content=content)
def test_sign_up_user(browser):
person = Person()
TEST_DATA = {
'first_name': person.first_name(),
'last_name': person.last_name(),
'email': person.email(),
'telephone': person.telephone(),
'password': person.password(8)
}
sign_up_page = SignUpPage(browser)
sign_up_page.open()
sign_up_page.fill_user_data(first_name=TEST_DATA['first_name'],
last_name=TEST_DATA['last_name'],
email=TEST_DATA['email'],
telephone=TEST_DATA['telephone'],
password=TEST_DATA['password'])
TopMenu(browser).logout()
sign_in_page = SignInPage(browser)
sign_in_page.confirm_logout()
sign_in_page.open()
sign_in_page.login(TEST_DATA['email'], TEST_DATA['password'])
assert sign_in_page.get_available_actions_header() == 'My Account'
def seed():
# Data
m_datetime = Datetime()
person = Person()
dates_range = dict(start=(datetime.utcnow() -
timedelta(days=366)).year,
end=datetime.utcnow().year)
_role = models.Role.query.filter_by(name="Shopper").first()
accounts = models.Account.query.filter_by(role=_role).all()
for account in accounts:
# only make orders for accounts with at least one campaign
if not account.campaign:
continue
# Generate and save orders
for _ in range(randint(0, 4)):
order = models.Order(
account=account,
campaign=account.campaign,
created_at=m_datetime.datetime(start=dates_range["start"],
end=dates_range["end"]),
checkout_fields={
"First Name": person.name(),
"Last Name": person.last_name()
},
)
db.session.add(order)
db.session.commit()
def run():
person = Person()
text = Text()
internet = Internet()
dateTime = Datetime()
for i in range(100):
User.objects.create(password="******",
username=person.username(),
first_name=person.name(),
last_name=person.last_name(),
email=person.email())
users = User.objects.all()
for i in range(100):
Post.objects.create(author=choice(users),
link=internet.home_page(),
title=text.title(),
description=text.text())
posts = Post.objects.all()
for i in range(100):
Comment.objects.create(author=choice(users),
post=choice(posts),
description=text.text())
def create_human(n):
"""
:param n: язык генерации данных
:return: сгенерированные фейковые данные
"""
log.info("Генерируем тестовые данные")
if n == 1:
person = Person('ru')
else:
person = Person('en')
log.info("person: " + str(person))
client_info = generate_id_passport()
print('\nфамилия:\t', person.last_name())
print('имя:\t\t', person.name())
print('отчество:\t', person.surname(), '\n')
passport = generate_number_passport()
print('личный №:\t', client_info.get('idn'))
print('документ:\t', passport)
print('пол:\t\t', client_info.get('sex'))
print('возраст:\t', person.age(13, 70), '\n')
# print('аватар\t', person.avatar())
print('гражд-во:\t', person.get_current_locale())
print('Нац-сть:\t',person.nationality())
print('телефон:\t', person.telephone('+37529#######'))
print('email:\t\t', person.email())
print('проф-ия:\t', person.occupation(), '\n')
print('обращение:\t', person.title())
print('взгляды:\t', person.views_on())
print('вера:\t\t', person.worldview(), '\n')
def handle(self, *args, **options):
UserProfile.objects.all().delete()
Author.objects.all().delete()
person = Person('en')
for _ in range(COUNT_ELEM):
first_name = person.first_name()
last_name = person.last_name()
login = f'{first_name}.{last_name}'
email = person.email()
birthday_year = datetime.today().year - person.age(minimum=14,
maximum=100)
print(f'Created:{login} - {email}')
user = {
"user_name": login,
"first_name": first_name,
"last_name": last_name,
"gender": person.sex('M', 'F'),
"birthday_year": birthday_year,
"email": email
}
author = {
"first_name": first_name,
"last_name": last_name,
"birthday_year": birthday_year,
}
new_user = UserProfile(**user)
new_user.save()
new_author = Author(**author)
new_author.save()
User.objects.all().delete()
User.objects.create_superuser('admin', 'admin@localhost', 'admin')
def registration_positive_test(self, device: Device) -> None:
generator = Person()
assert "success" in UserRegistration(
Identity(generator.name(), generator.last_name(),
generator.telephone()),
Credentials(generator.email(), generator.password(), "0"),
).registration_response(device)
def create_human(n): # function of creating new client
if n == 1:
person = Person('ru')
else:
person = Person('en')
# Выводим исландские мужские имена.
client_info = generate_id_passport()
print('\nфамилия:\t', person.last_name())
print('имя:\t\t', person.name())
print('отчество:\t', person.surname(), '\n')
passport = generate_number_passport()
print('личный №:\t', client_info.get('idn'))
print('документ:\t', passport)
print('пол:\t\t', client_info.get('sex'))
print('возраст:\t', person.age(13, 70), '\n')
# print('аватар\t', person.avatar())
print('гражд-во:\t', person.get_current_locale())
print('Нац-сть:\t', person.nationality())
print('телефон:\t', person.telephone('+37529#######'))
print('email:\t\t', '*****@*****.**')
# print('email:\t\t', person.email())
print('проф-ия:\t', person.occupation(), '\n')
print('обращение:\t', person.title())
print('взгляды:\t', person.views_on())
print('вера:\t\t', person.worldview(), '\n')
def fake(self):
p = Person()
students = Student.objects.filter(sis_id__isnull=False).all()
for student in tqdm(students, desc="Faking students", leave=False):
student.first_name = p.name()
student.last_name = p.last_name()
student.save()
profiles = UserProfile.objects.filter(sis_id__isnull=False).all()
for profile in tqdm(profiles, desc="Faking users", leave=False):
user = profile.user
user.first_name = p.name()
user.last_name = p.last_name()
user.save()
self.stdout.write(
self.style.SUCCESS(
f'Faked {len(students)} students and {len(profiles)} users.'))
def test(self, grid: str, device: Device) -> None:
chrome: Remote = Chrome(grid)
registration = RegisterAccountPage(chrome)
registration.load(device)
person = Person()
registration.fill_personal_details(person.name(), person.last_name(),
person.email(), person.telephone())
registration.fill_password(person.password())
registration.press_continue()
assert RegistrationSuccessPage(chrome).available()
def create_personalData(): # function of generate new client data
passport = ''
person = Person('ru')
# Выводим исландские мужские имена.
lastname = person.last_name()
personalData['lastname'] = lastname
# print('\nфамилия:\t', personalData['lastname'])
name = person.name()
personalData['name'] = name
# print('имя:\t\t', personalData['name'])
surname = person.surname()
personalData['surname'] = surname
# print('отчество:\t', personalData['surname'])
gender = person.gender()
personalData['gender'] = gender
# print('пол:\t\t', personalData['gender'])
for _ in range(2):
varLet = random.choice(string.ascii_uppercase)
passport += varLet
passport += person.telephone('#######')
personalData['passport'] = passport
# print('паспорт:\t', personalData['passport'])
### birthday
currentDate()
personalData['age'] = age
personalData['age'][2] = str(
int(personalData['age'][2]) - person.age(16, 70))
# print('возраст:\t', personalData['age'], '\n')
###
# print('гражд-во:\t', person.get_current_locale())
# print('Нац-сть:\t',person.nationality())
### mobile
mobile = person.telephone('+37529#######')
personalData['mobile'] = mobile
# print('телефон:\t', personalData['mobile'])
###
### email
# personalData['email'] = person.email()
# print('email:\t\t', personalData['email'])
###
# print('проф-ия:\t', person.occupation(), '\n')
# print('обращение:\t', person.title())
# print('взгляды:\t', person.views_on())
# print('вера:\t\t', person.worldview(), '\n')
return personalData
def handle(self, *args, **options):
person = Person('ru')
for i in range(25):
gender = random.choice([Gender.FEMALE, Gender.MALE])
user = User.objects.create_user(email=person.email(),
password='******')
user.first_name = person.name(gender=gender)
user.last_name = person.last_name(gender=gender)
user.save()
self.stdout.write(self.style.SUCCESS('Пользователи успешно созданы'))
def test(self, grid: str, device: Device) -> None:
chrome: Remote = Chrome(grid)
registration = RegisterAffiliatePage(chrome)
person = Person()
registration.load(device)
registration.fill_personal_details(person.name(), person.last_name(),
person.email(), person.telephone())
registration.press_pay_method()
registration.fill_information(person.full_name(),
f"www.{person.username()}.com",
"2332153467", person.email())
registration.fill_password(person.password())
registration.press_continue()
assert RegAffiliateSuccessPage(chrome).available()
def gen_data_simple_schema(self, data_path, partition_date, num_rows,
file_format):
"""
Input
- data_path: path where the partition will be created (string)
- partition_date: partition date to be created (date)
- num_rows: number of rows to be generated (integer)
- file_format: format of file to be generated (parquet or avro)
This function creates a data sample with a simple schema
"""
person = Person('en')
# Create a simple schema
schema_df = StructType([
StructField('identifier', StringType(), True),
StructField('first_name', StringType(), True),
StructField('last_name', StringType(), True),
StructField('occupation', StringType(), True),
StructField('age', IntegerType(), True),
StructField('date', DateType(), True)
])
# generate data
for _ in range(num_rows):
df_temp = self.spark.createDataFrame([[
person.identifier(),
person.first_name(),
person.last_name(),
person.occupation(),
person.age(), partition_date
]], schema_df)
try:
df = df.union(df_temp)
except:
df = df_temp
df.coalesce(1).write.partitionBy('date').mode('overwrite').format(
file_format).save(data_path)
print('Partition created: {data_path}/date={date}'.format(
data_path=data_path, date=partition_date))
print('# Rows:', df.count())
print('Schema:')
df.printSchema()
print('\n')
return
def handle(self, *args, **kwargs):
person = Person('ru')
total = kwargs['total']
admin = kwargs['admin']
for i in range(total):
password = User.objects.make_random_password()
if admin:
user = User.objects.create_superuser(
username=person.username(),
first_name=person.first_name(),
last_name=person.last_name(),
email=person.email(),
password=password,
)
print(f'Create new Superuser: {user} and password: {password}')
else:
user = User.objects.create_user(
username=person.username(),
first_name=person.first_name(),
last_name=person.last_name(),
email=person.email(),
password=password,
)
print(f'Create new user: {user} and password: {password}')
class CSVData:
def __init__(self):
self.person = Person(locale='zh')
self.address = Address(locale='zh')
self.code = Code()
self.business = Business(locale='zh')
self.text = Text(locale='zh')
self.datetime = Datetime(locale='zh')
self.file = File()
self.path = Path()
self.internet = Internet()
self.structure = Structure()
def mime_data(self):
# col1 = self.person.full_name()
col1 = self.person.last_name() + self.person.first_name()
col2 = self.address.city()
col3 = self.address.street_name()
col4 = self.address.calling_code()
col5 = self.address.longitude()
col6 = self.code.imei()
col7 = self.business.company()
col8 = self.text.hex_color()
col9 = self.datetime.formatted_datetime()
col10 = self.datetime.time()
col11 = self.file.file_name()
col12 = self.path.dev_dir()
col13 = self.internet.ip_v4()
col14 = self.internet.ip_v6()
col15 = self.internet.home_page()
col16 = self.internet.stock_image()
col17 = self.internet.user_agent()
col18 = self.internet.mac_address()
col19 = self.person.email()
col20 = self.person.telephone()
col21 = self.code.issn()
col22 = self.person.social_media_profile()
col23 = self.structure.html()
line = '\"{0}\", \"{1}\", \"{2}\", \"{3}\", {4}, \"{5}\", \"{6}\" , \"{7}\" , \"{8}\" , \"{9}\" , \"{10}\" , \"{11}\" , \"{12}\" , \"{13}\" , \"{14}\" , \"{15}\" , \"{16}\" , \"{17}\" , \"{18}\" , \"{19}\" , \"{20}\" , \"{21}\" , \"{22}\"\n'.format(
col1, col2, col3, col4, col5, col6, col7, col8, col9, col10, col11, col12, col13, col14, col15, col16, col17, col18, col19, col20, col21, col22, col23)
# line = "mime data"
# print(line)
return line
def get_user(number):
"""
Creates random user data
:param number: number of users
:return: user data list
"""
data = []
for i in range(number):
user_gender = random.sample([Gender.MALE, Gender.FEMALE], 1)[0]
person = Person('ru')
data.append(
OrderedDict(first_name=person.first_name(gender=user_gender),
last_name=person.last_name(gender=user_gender),
age=person.age(minimum=18, maximum=66),
email=person.email(domains=('yandex.ru', 'gmail.com')),
username=person.username(template='UU_d')))
return data
def handle(self, *args, **options):
Chilipili.objects.all().delete()
Like.objects.all().delete()
users = []
person = Person()
for _ in range(10):
User.objects.create(password=person.password(), username=person.username(
), first_name=person.name(), last_name=person.last_name(), email=person.email())
# date = Datetime()
text = Text()
users = User.objects.all()
for _ in range(20):
Chilipili.objects.create(author_user=choice(
users), text=text.sentence())
chilipilis = Chilipili.objects.all()
for _ in range(100):
Like.objects.create(like_user=choice(
users), chilipili=choice(chilipilis))
def test_affiliate_reg(self, device: Device) -> None:
urllib3.disable_warnings()
person = Person()
(assert_if_request_contains_success_response_url(
Post(
f"https://{device.connections.main.ip}/index.php?route=affiliate/register",
{
"firstname": person.name(),
"lastname": person.last_name(),
"email": person.email(),
"telephone": person.telephone(),
"company": person.full_name(),
"website": f"www.{person.username()}.net",
"tax": "123456",
"payment": "paypal",
"paypal": person.email(),
"password": person.password(),
"confirm": person.password(),
"agree": 1,
},
)))
def create_app_user(
domains: Optional[List[str]] = None,
organization: Optional[Organization] = None,
) -> AppUser:
"""Опционально можно передать домены, или инстанс организации.
Тогда пользователи будут созданы с emails:
* либо с переданными domains;
* либо с organization.domains.
"""
app_user = Person('ru')
first_name = app_user.first_name()
last_name = app_user.last_name()
if organization:
domains = organization.get_domains()
email = app_user.email(domains=domains)
user = AppUser.objects.create_user(
first_name=first_name,
last_name=last_name,
email=email,
)
return user
for i in range(count_bran):
brabn = Branch(id=i,
organization_id=random.randrange(count_org),
name='Фелиал' + str(i))
session.add(brabn)
session.commit()
for i in range(count_dep):
dep = Department(id=i,
branch_id=random.randrange(count_bran),
name='Отдел' + str(i))
session.add(dep)
session.commit()
for i in range(count_peop):
gender0 = gender[random.randrange(len(gender))]
peop = People(id=i,
first_name=person.first_name(gender=gender0),
last_name=person.last_name(gender=gender0),
department_id=random.randrange(count_dep),
position=positions[random.randrange(len(positions))],
number=gen_number(),
bday=dateTime.date(start=1970, end=2002),
address=address.address(),
gender=gender0.name)
session.add(peop)
session.commit()
session.close()
def gen_data_remove_column(self, data_path, partition_date, num_rows,
file_format):
"""
Input
- data_path: path where the partition will be created (string)
- partition_date: partition date to be created (date)
- num_rows: number of rows to be generated (integer)
- file_format: format of file to be generated (parquet or avro)
This function creates a data sample removing some columns
"""
person = Person('en')
address = Address('en')
schema_street = StructType([
StructField('street_name', StringType(), True)
# StructField('lat', FloatType(), True), #column removed
# StructField('long', FloatType(), True) #column removed
])
schema_address_details = StructType([
StructField('street', schema_street, True),
StructField('number', IntegerType(), True)
])
schema_address = StructType([
StructField('address_details', schema_address_details, True),
StructField('city', StringType(), True),
StructField('country', StringType(), True),
# StructField('country_code', StringType(), True), #column removed
StructField('state', StringType(), True),
StructField('postal_code', IntegerType(), True)
])
schema_df = StructType([
StructField('identifier', StringType(), True),
StructField('first_name', StringType(), True),
StructField('last_name', StringType(), True),
StructField('occupation', StringType(), True),
StructField('age', IntegerType(), True),
StructField('address', schema_address, True),
# StructField('title_name', StringType(), True), #column removed
StructField('date', DateType(), True)
])
for _ in range(num_rows):
df_temp = self.spark.createDataFrame(
[[
person.identifier(),
person.first_name(),
person.last_name(),
person.occupation(),
person.age(),
[
[
[
address.street_name()
#float(address.latitude()),
#float(address.longitude())
],
int(address.street_number())
],
address.city(),
address.country(),
#address.country_code(),
address.state(),
int(address.postal_code())
],
#person.title(),
partition_date
]],
schema_df)
try:
df = df.union(df_temp)
except:
df = df_temp
df.coalesce(1).write.partitionBy('date').mode('overwrite').format(
file_format).save(data_path)
print('Partition created: {data_path}/date={date}'.format(
data_path=data_path, date=partition_date))
print('# Rows:', df.count())
print('Schema:')
df.printSchema()
print('\n')
return
from oxwall_site_model import OxwallSite
from value_models.status import Status
import pytest
from data.status_data import status_data
from mimesis import Person
person = Person("en")
user_info = dict(username=person.last_name(), email=person.email(),password=person.password(),
real_name=person.full_name(), gender='men', birthday = ("1","3","1990"))
print(user_info)
#user_info = dict(username="******", email="*****@*****.**", password="******",
# real_name="Irena Solo", gender="female", birthday = ("1","3","1990"))
#@pytest.mark.skip("doesnt work")
def test_join_user(driver,oxwall_app):
oxwall_app.main_page.sign_in_click()
oxwall_app.sign_in_page.click_to_join()
oxwall_app.wait_until_new_status_appeared()
oxwall_app.join_page.fill_in_join_form(user_info)
actual_text = oxwall_app.dash_page.text_status_new_user
print (actual_text)
print( user_info["real_name"]+" joined our site!")
assert user_info["real_name"]+" joined our site!" == actual_text
err = int(float(sys.argv[3]) * int(sys.argv[1]))
error_list = list()
for i in range(0, err):
error_list.append(random.randint(0, int(sys.argv[1]) - 1))
error_list.sort()
# print(error_list)
if sys.argv[2] == 'ru':
address = Address('ru')
person = Person('ru')
kol = int(sys.argv[1])
for i in range(0, kol):
listok = list()
listok.append(person.last_name() + " ")
listok.append(person.name() + " ")
listok.append(person.name() + "ович ")
listok.append(person.telephone('+7 ### ### ## ##') + " ")
listok.append(address.address())
line = "".join(listok)
line = func(line)
print(line)
elif sys.argv[2] == 'en':
address = Address('en')
person = Person('en')
for i in range(0, int(sys.argv[1])):
listok = list()
listok.append(person.last_name() + " ")
listok.append(person.name() + " ")
listok.append(person.name() + " ")
def main():
try:
num_gen = int(sys.argv[1])
except:
num_gen = -1
if len(sys.argv) < 2 or num_gen == -1:
print(
"Usage: python faker_customers_to_csv.py <INT: Number of Customers to generate>"
)
print("Exymple: python faker_customers_to_csv.py 10000")
return
# Generate Customers that are between 18 and 100 years old
ls_dates = [
fake_de.date_time_between(start_date="-100y",
end_date="-18y",
tzinfo=None) for i in range(0, num_gen)
]
ls_dates.sort()
ls_customer = []
for i in range(0, len(ls_dates)):
s_country = random_country()
address = None
person = None
s_nationality = None
if s_country == 'DE':
address = Address('de')
person = Person('de')
s_nationality = 'Germany'
elif s_country == 'AT':
address = Address('de-at')
person = Person('de-at')
s_nationality = 'Austria'
else:
address = Address('de-ch')
person = Person('de-ch')
s_nationality = 'Switzerland'
s_sex = random_mf_flag()
gender = mimesis.enums.Gender.FEMALE if s_sex == 'F' else mimesis.enums.Gender.MALE
s_first_name = person.name(gender)
s_last_name = person.last_name(gender)
s_marital_status = random_marital_status_flag()
s_job = person.occupation()
s_email = person.email()
s_phone = person.telephone()
i_number_children = random.randint(0, 4)
s_address_street = address.address()
s_address_zip = address.postal_code()
s_address_city = address.city()
t_customer = (customer_number(i), s_sex, s_first_name, s_last_name,
s_job, s_email, s_phone, i_number_children,
s_marital_status, ls_dates[i].replace(hour=0,
minute=0,
second=0,
microsecond=0),
s_address_street, s_address_zip, s_address_city,
s_country, s_nationality)
ls_customer.append(t_customer)
ls_columns = [
'customer_id', 'gender', 'first_name', 'last_name', 'job', 'email',
'phone', 'number_children', 'marital_status', 'date_of_birth',
'street', 'zip', 'city', 'country_code', 'nationality'
]
df_customer = pd.DataFrame(ls_customer, columns=ls_columns)
df_customer.to_csv('output/customers__de_at_ch.csv',
sep=',',
index=False,
header=ls_columns)
class Users:
def __init__(self):
self.person = Person('en')
self.generic = Generic('en')
self.questions = Question.objects.all()
def generate(self):
for i in range(1, 101):
if i % 2 != 0:
user_gender = Gender.MALE
else:
user_gender = Gender.FEMALE
firstname = self.person.first_name(gender=user_gender)
lastname = self.person.last_name(gender=user_gender)
user = User.objects.create_user(self.person.username(),
self.person.email(), 'Qwerty1!')
user.first_name = firstname
user.last_name = lastname
user.is_active = True
self.update_aboutMe(user)
self.update_aboutYou(user)
user.save()
def update_aboutMe(self, user):
user.aboutme.gender = choice(list(commonInfo.GENDER))[0]
randColorHairCount = randrange(1, len(commonInfo.COLOR_HAIR))
user.aboutme.color_hair = sample(
[index[0] for index in list(commonInfo.COLOR_HAIR)],
k=randColorHairCount)
randColorAyeCount = randrange(1, len(commonInfo.COLOR_AYE))
user.aboutme.color_aye = sample(
[index[0] for index in list(commonInfo.COLOR_AYE)],
k=randColorAyeCount)
user.aboutme.activate = True
d1 = datetime.strptime('1/1/1970', '%m/%d/%Y')
d2 = datetime.strptime('1/1/2002', '%m/%d/%Y')
user.aboutme.birthday = self.random_date(d1, d2).strftime('%Y-%m-%d')
user.aboutme.weight = randrange(45, 150)
user.aboutme.growth = randrange(100, 250)
user.aboutme.genres.set(
self.get_random_list_of_multiple_data_from_objects(Genres.objects))
user.aboutme.music_types.set(
self.get_random_list_of_multiple_data_from_objects(
MusicType.objects))
user.aboutme.films.set(
self.get_random_list_of_multiple_data_from_objects(Films.objects))
user.aboutme.books.set(
self.get_random_list_of_multiple_data_from_objects(Books.objects))
user.aboutme.hobbies.set(
self.get_random_list_of_multiple_data_from_objects(
Hobbies.objects))
user.aboutme.foods.set(
self.get_random_list_of_multiple_data_from_objects(Foods.objects))
user.aboutme.country = self.get_random_data_from_objects(
Countries.objects)
user.aboutme.save()
self.save_questionary(user, user.aboutme)
def update_aboutYou(self, user):
user.aboutyou.gender = choice(list(commonInfo.GENDER))[0]
randColorHairCount = randrange(1, len(commonInfo.COLOR_HAIR))
user.aboutyou.color_hair = sample(
[index[0] for index in list(commonInfo.COLOR_HAIR)],
k=randColorHairCount)
randColorAyeCount = randrange(1, len(commonInfo.COLOR_AYE))
user.aboutyou.color_aye = sample(
[index[0] for index in list(commonInfo.COLOR_AYE)],
k=randColorAyeCount)
min_age = randrange(18, 60)
user.aboutyou.min_age = min_age
user.aboutyou.max_age = randrange(min_age, 61)
min_growth = randrange(100, 250)
user.aboutyou.min_growth = min_growth
user.aboutyou.max_growth = randrange(min_growth, 251)
min_weight = randrange(45, 150)
user.aboutyou.min_weight = min_weight
user.aboutyou.max_weight = randrange(min_weight, 151)
user.aboutyou.genres.set(
self.get_random_list_of_multiple_data_from_objects(Genres.objects))
user.aboutyou.music_types.set(
self.get_random_list_of_multiple_data_from_objects(
MusicType.objects))
user.aboutyou.films.set(
self.get_random_list_of_multiple_data_from_objects(Films.objects))
user.aboutyou.books.set(
self.get_random_list_of_multiple_data_from_objects(Books.objects))
user.aboutyou.hobbies.set(
self.get_random_list_of_multiple_data_from_objects(
Hobbies.objects))
user.aboutyou.foods.set(
self.get_random_list_of_multiple_data_from_objects(Foods.objects))
user.aboutyou.countries.set(
self.get_random_list_of_multiple_data_from_objects(
Countries.objects))
user.aboutyou.save()
self.save_questionary(user, user.aboutyou)
def save_questionary(self, user, obj):
for question in self.questions:
question = Question.objects.get(pk=question.pk)
answer = self.get_random_data_from_objects(
Answer.objects.filter(question=question))
obj_type = ContentType.objects.get_for_model(obj)
questionary_obj, is_created = Questionary.objects.get_or_create(
content_type=obj_type,
user=user,
question=question,
defaults={'answer': answer})
questionary_obj.answer = answer
questionary_obj.save()
def random_date(self, start, end):
"""
This function will return a random datetime between two datetime
objects.
"""
delta = end - start
int_delta = (delta.days * 24 * 60 * 60) + delta.seconds
random_second = randrange(int_delta)
return start + timedelta(seconds=random_second)
def get_random_data_from_objects(self, Objects):
modelDataIds = Objects.values_list('id', flat=True)
ChoiceId = choice(list(modelDataIds))
Data = Objects.get(pk=ChoiceId)
return Data
def get_random_list_of_multiple_data_from_objects(self, Objects):
countOfdata = Objects.count()
randDataCount = randrange(1, countOfdata + 1)
modelDataIds = Objects.values_list('id', flat=True)
listOfRandomDataIds = sample(list(modelDataIds), k=randDataCount)
multipleData = Objects.filter(id__in=listOfRandomDataIds)
return multipleData
def person(
cls,
*,
locale=Locales.EN,
qualification=None,
age=None,
blood_type=None,
email=None,
first_name=None,
last_name=None,
gender=None,
height=None,
id=None,
language=None,
nationality=None,
occupation=None,
phone=None,
title=None,
university=None,
weight=None,
work_experience=None,
):
'''
Create an Person Data Entity object.
All individual fields are automatically randomly generated based on locale. If provided, the corresponding values are overriden.
Note:
All individual fields are randomly generated. Don't expect correct correlation e.g. correct postal code for the generated city.
Keyword Arguments:
locale: Approprite Random.locale.<local_name> object. Default is Random.locale.EN
qualification: Educational Qualification
age: Age
blood_type: Blood type
email: Email address
first_name: First name
last_name: Last name
gender: Gender
height: Height
id: Identifier
language: Language
nationality: Nationality
occupation: Occupation
phone: Phone number
title: Title
university: University
weight: Weight
work_experience: Work Experience
'''
person = Person(locale=locale)
from arjuna.engine.data.entity.person import Person as ArjPerson
first_name = first_name is not None and first_name or person.first_name(
)
last_name = last_name is not None and last_name or person.last_name()
return ArjPerson(
qualification=qualification is not None and qualification
or person.academic_degree(),
age=age is not None and age or person.age(),
blood_type=blood_type is not None and blood_type
or person.blood_type(),
email=email is not None and email or person.email(),
first_name=first_name,
last_name=last_name,
name=first_name + " " + last_name,
gender=gender is not None and gender or person.gender(),
height=height is not None and height or person.height(),
id=id is not None and id or person.identifier(),
language=language is not None and language or person.language(),
nationality=nationality is not None and nationality
or person.nationality(),
occupation=occupation is not None and occupation
or person.occupation(),
phone=phone is not None and phone or person.telephone(),
title=title is not None and title or person.title(),
university=university is not None and university
or person.university(),
weight=weight is not None and weight or person.weight(),
work_experience=work_experience is not None and work_experience
or person.work_experience(),
)
year_ob TEXT,
city_ob TEXT,
city TEXT,
address TEXT,
phone TEXT,
email TEXT);
""")
conn.commit()
for i in range(20):
#idd = g.code.imei()
idd = n
gender = random.choice(gen)
if gender == 'Женский':
first_name = p.first_name(gender=Gender.FEMALE)
last_name = p.last_name(gender=Gender.FEMALE)
#self.patron = rus.patronymic(gender = Gender.FEMALE)
elif gender == 'Мужской':
first_name = p.first_name(gender=Gender.MALE)
last_name = p.last_name(gender=Gender.MALE)
#self.patron = rus.patronymic(gender = Gender.MALE)
age = p.age(minimum=18, maximum=70)
month_ob = dt.month()
day_ob = dt.day_of_month()
year_ob = 2020 - age
city_ob = adr.city()
city = adr.city()
address = adr.address()
phone = p.telephone(mask='+7(###)-###-####')
email = p.email(domains=['mimesis.name'])
