1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
from django.core.management.base import BaseCommand, CommandError
from django.core.files import File
from django.contrib.auth import get_user_model
from dispatch.models import Customer, Load, Identity, Paperwork, Invoice
import datetime
from faker import Faker
from dateutil import rrule
from dispatch.misc import get_week_dates_datetime
import random
from django.db.utils import IntegrityError
# import yaml
User = get_user_model()
class Command(BaseCommand):
help = """Generate fake data.\n
Example usage: \n
./manage.py insert_fake_data --companies 4 --users 3 --loads 800
--start-date='-16w' --end-date '+16w' --attachments=True --invoices=True"""
fake = Faker()
end_date = ""
start_date = ""
def add_arguments(self, parser):
# parser.add_argument('--file', type=str, dest='filename')
parser.add_argument('--companies', type=int, dest='companies', default='0')
parser.add_argument('--attachments', type=bool, dest='attachments', default=False)
parser.add_argument('--invoices', type=bool, dest='invoices', default=False)
parser.add_argument('--users', type=int, dest='users', default='0')
parser.add_argument('--loads', type=int, dest='loads', default='0')
parser.add_argument('--start-date', type=str, dest='startdate', default='-2w')
parser.add_argument('--end-date', type=str, dest='enddate', default='+2w')
def handle(self, *args, **options):
self.end_date = options['enddate']
self.start_date = options['startdate']
# customer_ids = []
# user_ids = []
for i in range(0, options['companies']):
co = self.fake_customer()
# We're going to hold the model IDs in memory to access randomly
# later on
# customer_ids.append(co.pk)
for i in range(0, options['users']):
u = self.fake_user()
# user_ids.append(u.pk)
# We're going to go about getting the list of user and customer IDs
# in a slightly different manner now so that we get _all_ customers
# and _all_ users.
customer_ids = self.get_customer_ids()
user_ids = self.get_user_ids()
for i in range(0, options['loads']):
co_id = customer_ids[random.randint(0, len(customer_ids)-1)]
co = Customer.objects.get(pk=co_id)
u_id = user_ids[random.randint(0, len(user_ids)-1)]
u = User.objects.get(pk=u_id)
l = self.fake_load(u, co, options['attachments'])
if options['invoices']:
# I'm pretty sure this is slow, but it's not run often
# and can/should be fixed later
start_load = Load.objects.order_by('date')[0]
end_load = Load.objects.order_by('-date')[0]
generated_invoices = []
# Use the date of the first load to the date of the last load, and
# iterate over all of the weeks in between
for dt in rrule.rrule(rrule.WEEKLY, dtstart=start_load.date, until=end_load.date):
users = []
wk = get_week_dates_datetime(dt)
loads = Load.objects.filter(date__range=[wk['start_date'], wk['end_date']])
for l in loads:
if l.user not in users:
users.append(l.user)
# print(l.user)
for u in users:
due_date = wk['start_date'] + datetime.timedelta(days=30)
inv = Invoice(user=u, invoice_date=wk['start_date'], due_date=due_date)
inv.setup()
inv.save()
generated_invoices.append(inv.pk)
inv.populate_items(start_date=wk['start_date'], end_date=wk['end_date'])
# Pay for half of the invoices we've generated
generated_invoices = generated_invoices[0:int(len(generated_invoices)/2)]
for pk in generated_invoices:
inv = Invoice.objects.get(pk=pk)
inv.paid = True
inv.payment_identifier = "Check #{}".format(random.randint(1050,10000))
inv.save()
def fake_customer(self):
new_customer = Customer(
name=self.fake.company(),
address=self.fake.address(),
phone_number=self.fake.msisdn(),
email_address=self.fake.company_email(),
contact_name=self.fake.name(),
)
new_customer.save()
return new_customer
def fake_load(self, usr, co, attachments=False):
fake_description = "{}-{} {} {}K".format(
self.fake.month(), self.fake.day_of_month(),
self.fake.license_plate(), random.randint(5, 50))
new_load = Load(
user=usr,
# Because that's going to be random enough
# load_number=self.fake.license_plate(),
# description=self.fake.sentence(nb_words=6),
description=fake_description,
customer=co,
amount=random.randint(150,2500),
delivered_to=self.fake.city(),
)
# Set the date to something random between last week and next week
new_load.date=self.fake.date_between(start_date=self.start_date, end_date=self.end_date)
new_load.save()
if attachments:
self.add_attachment(new_load)
return new_load
def add_attachment(self, load):
p = Paperwork(load=load)
p.document = File(open('chicken.pdf', 'rb'))
p.save()
def fake_user(self):
ffname = self.fake.first_name()
flname = self.fake.last_name()
funame = ffname[0] + flname
funame = '%s.%s' % (ffname, flname)
try:
new_user = User(
first_name=ffname,
last_name=flname,
email=self.fake.email(),
is_active=True
)
new_user.save()
user_ident = Identity(
user=new_user,
name="{} {}".format(ffname, flname),
address=self.fake.address(),
city=self.fake.city(),
state=self.fake.state(),
zip_code=self.fake.zipcode(),
)
user_ident.save()
return new_user
except IntegrityError:
# Around and around we go until we get something new
return self.fake_user()
def get_customer_ids(self):
id_array = []
for cus in Customer.objects.all():
id_array.append(cus.pk)
return id_array
def get_user_ids(self):
id_array = []
for u in User.objects.all():
id_array.append(u.pk)
return id_array
|
