def build_company_from_dataclass(self, company_dc: CompanyDC) -> Company:
return Company(
name=company_dc.name,
symbol=company_dc.symbol,
info=self._company_info_factory.build_company_info(
company_dc.info),
)
def process_company(self, company_id, company_ipn, company_name):
if not company_ipn and not company_name:
return None
if len(company_name) > 250:
self.stderr.write(
'Company name {} is too long'.format(company_name))
return None
company = None
for k, v in [("pk", company_id), ("edrpou", company_ipn),
("name_uk", company_name)]:
try:
if v:
company = Company.objects.get(**{k: v})
break
except Company.DoesNotExist:
pass
if company is None:
company = Company(state_company=True)
# Set missing params
if not company.name_uk:
company.name_uk = company_name
Ua2EnDictionary.objects.get_or_create(term=lookup_term(company_name))
if not company.edrpou:
company.edrpou = company_ipn
company.save()
return company
def test_company_str(self):
"""Tests the company string representation"""
company = Company(
index=11,
company='ACME Inc'
)
company.save()
assert Company.objects.get(index=11).company == company.company
def setUp(self):
super().setUp()
self.client = Client(schema)
# Populate the test collectiom with person data
with open("core/tests/test_data/employees.json") as employee_json:
employees = json.load(employee_json)
for employee in employees:
employee_obj = Person(**employee)
employee_obj.save()
# Populate the test collection with company data
with open("core/tests/test_data/companies.json") as companies_json:
companies = json.load(companies_json)
for companies in companies:
companies_obj = Company(**companies)
companies_obj.save()
def import_companies(self):
"""
This method is used for read in parser file the fields referring a
companies and create the objects of companies.
"""
csv_file = self.read_file('importer/data/companies.csv')
print('Importing Companies...')
for row in csv_file:
try:
Company.objects.get(name=row[0])
print('Company', row[0], 'already registered.')
except ObjectDoesNotExist:
company = Company()
company.name = row[0]
company.save()
def handle(self, *args, **options):
print('Deleting all existing records')
Company.objects.all().delete()
path = options['dataset']
keys = [f.name for f in Company._meta.fields]
with open(path, mode='r', encoding='utf-8') as file_handler:
for row in csv.DictReader(file_handler):
filtered = {k: v for k, v in row.items() if k in keys}
obj = Company(**filtered)
obj.save()
for ticker in self.extract_tickers(row):
obj.tickers.create(code=ticker)
print('{:,} objects created'.format(Company.objects.count()))
def manage_company(request, company_id=None):
if request.user.is_superuser:
# Try to locate the object to use it as an instance and if not, create
# new one to use it in a new form.
# common_data = common_ticket_data()
if company_id:
actual_company = get_object_or_404(Company, pk=company_id)
else:
actual_company = Company()
# POST mode
if request.method == 'POST':
form = CompanyForm(request.POST, request.FILES, instance=actual_company)
if form.is_valid():
form.save()
return redirect('company-list')
else:
# Non-POST mode, show only
form = CompanyForm(instance=actual_company)
return render(request, 'core/companies/create_edit_company.html', locals())
else:
raise Http404
def bulk_update(self, batch=False):
# ToDo: Benchmarktest, I do not know if that approach scales
# maybe work with batch size, if 500 values in a dict, insert it and clear it
# Either clear & insert the lists if we check for batch size
# or clear & insert the lists if we force it
# Normally a batch run happens during the order check after every order
# so the data does not get to full
# A force insert happens when all orders have been matched
# and we want to insert the rest
if not batch or len(self.depot_positions_create) > self.BATCH:
l = list()
for key in self.depot_positions_create:
v = self.depot_positions_create[key]
l.append(
DepotPosition(depot_of_id=key[0],
company_id=key[1],
amount=v))
DepotPosition.objects.bulk_create(l)
self.depot_positions_create = dict()
if not batch or len(self.depot_positions_update) > self.BATCH:
for key in self.depot_positions_update:
v = self.depot_positions_update[key]
DepotPosition.objects.filter(
depot_of_id=key[0],
company_id=key[1]).update(amount=F("amount") + v)
self.depot_positions_update = dict()
# activity
if not batch or len(self.activity_update) > self.BATCH:
list_ = [v for k, v in self.activity_update.items()]
Activity.objects.filter(id__in=list_).update(
updated=timezone.now())
self.activity_update = dict()
# update cash of companies
if not batch or len(self.companies_cash_update) > self.BATCH:
l = list()
for k, v in self.companies_cash_update.items():
obj = Company(id=k, cash=F("cash") + v)
l.append(obj)
# Company.objects.filter(id=k).update(cash=F("cash")+v)
Company.objects.bulk_update(l, ["cash"])
self.companies_cash_update = dict()
# delete Orders
if not batch or len(self.order_ids_delete) > self.BATCH:
Order.objects.filter(id__in=self.order_ids_delete).delete()
self.order_ids_delete = list()
if not batch or len(self.order_update) > self.BATCH:
l = list()
for k in self.order_update:
obj = Order(id=k, amount=self.order_update[k])
l.append(obj)
Order.objects.bulk_update(l, fields=["amount"])
# delete Positions
if not batch:
DepotPosition.objects.filter(amount=0).delete()
# create trades and statement of acounts
# For performance reason we use bulk_creates to save queries.
# There is just a slight problem regarding the trades and the statement of accounts:
# We want to save the trade id of the related trade in the statement of account.
# So we create the trades first, then retrieve their ids and set them in the statement
# of account objects before inserting them in the database.
#
# As we are using postgresql as our database it supports the setting of the id
# field of objects during bulk_create. Postgresql the greatest database of all time!!!
if not batch or len(self.trades) > self.BATCH or len(
self.statements) > self.BATCH:
Trade.objects.bulk_create(self.trades)
i = 0
for trade in self.trades:
# For every trade there are 2 statement of accounts:
# One for the buyer & one for the seller.
self.statements[i].trade = trade
self.statements[i + 1].trade = trade
fst_statement = self.statements[i]
snd_statement = self.statements[i + 1]
if fst_statement.value != snd_statement.value or fst_statement.amount != snd_statement.amount:
raise ValueError(
f"Statement did not match: {fst_statement} {snd_statement}"
)
if trade.get_value() != fst_statement.value:
raise ValueError(
f"Trade {trade} does not match statement: {fst_statement}"
)
if trade.get_value() != snd_statement.value:
raise ValueError(
f"Trade {trade} does not match statement: {snd_statement}"
)
i += 2
for statement in self.statements:
assert statement.trade is not None
StatementOfAccount.objects.bulk_create(self.statements)
self.statements = list()
self.trades = list()
if not batch or len(self.notifications) > self.BATCH:
Notification.objects.bulk_create(self.notifications)
# for obj in self.notifications:
# e = Event(user_id=obj.user_id, typ="Order", msg=obj.subject)
# store_event(e)
self.notifications = list()
def get_or_create_from_edr_record(self, obj_dict, save=True):
"""
Kind of get_or_create method, to create or update company model
instance using data from EDR.
Returns Company instance and a created flag
"""
created = False
edrpou = unicode(obj_dict["edrpou"]).rjust(8, "0")
if not obj_dict["edrpou"]:
self.logger.error(
"Не можу імпортувати юр. особу без ЄДРПОУ <%s>" %
json.dumps(obj_dict, ensure_ascii=False, default=str))
return None, created
parsed = parse_address(obj_dict["location"])
# Not using get_or_create to avoid situation
# when created object is saved immediately
try:
# Sometime in companies table we have more than one company
# with same edrpou, that usually happens when company got
# reorganized or resurrected or something else strange had
# happened
# Here we'll try to update the most record of the company
# in business first by narrowing down the search by using
# status field
company = Company.objects.get(edrpou=edrpou, status=1)
except Company.DoesNotExist:
try:
company = Company.objects.get(edrpou=edrpou)
except Company.DoesNotExist:
company = Company(edrpou=edrpou,
name_uk=obj_dict["name"].strip(),
short_name_uk=obj_dict.get("short_name",
"").strip())
created = True
except Company.MultipleObjectsReturned:
self.logger.error(
"Не можу імпортувати юр. особу <%s>: в базі таких більше одної"
% json.dumps(obj_dict, ensure_ascii=False, default=str))
return None, created
except Company.MultipleObjectsReturned:
self.logger.error(
"Не можу імпортувати юр. особу <%s>: в базі більше одної в статусі 'зареєстровано'"
% json.dumps(obj_dict, ensure_ascii=False, default=str))
return None, created
if parsed:
zip_code, city_uk, street_uk, appt_uk = parsed
update_dict = {
"zip_code": zip_code,
"city_uk": city_uk,
"street_uk": street_uk,
"appt_uk": appt_uk
}
else:
update_dict = {"raw_address": obj_dict["location"]}
if "founded" in obj_dict:
update_dict = {"founded": obj_dict["founded"]}
for k, v in company._status_choices.items():
if obj_dict["status"].lower() == v:
update_dict["status"] = k
break
merger = st.Merger((
("^status$", st.replace_strategy),
(".*", st.replace_if_empty_strategy),
))
res = merger.merge(company, update_dict)
for k, v in res.items():
if v == st.MergeResult.OLD_VALUE:
self.logger.warning(
"Не замінюю поле %s на %s для компанії %s, %s" %
(k, update_dict[k], company.name, company.id))
if save:
company.save()
return company, created
def get_or_create_from_unified_foreign_registry(self, obj_dict, save=True):
"""
Kind of get_or_create method, to create or update company model
instance using data from spreadsheet rows of unified format below:
owner_name, company_name_declaration, company_name_en, zip, city, street,
appt, country, company_code, status, notes, company_name_orig, link,
founder_1,... founder_N
Lookup for get is made using company_code (if present).
If company_code is absent or no match is found, lookup is made by name
Returns Company instance and a created flag
"""
created = False
company_code = obj_dict["company_code"].strip().replace(" ", "")
company_name_declaration = obj_dict["company_name_declaration"].strip()
company_name_en = obj_dict["company_name_en"].strip()
company_name_orig = obj_dict["company_name_orig"].strip()
if obj_dict["country"].strip().lower() == "кіпр":
company_code = re.sub("^HE\s?", "HE", company_code)
company_code = re.sub("^ΗΕ\s?", "HE", company_code)
company_code = re.sub("^H\.E\.\s?", "HE", company_code)
company_code = re.sub("^Η\.E\.\s?", "HE", company_code)
update_dict = {
"zip_code": obj_dict["zip"].strip(),
"city_uk": obj_dict["city"].strip(),
"street_uk": obj_dict["street"].strip(),
"appt_uk": obj_dict["appt"].strip(),
"city_en": obj_dict["city"].strip(),
"street_en": obj_dict["street"].strip(),
"appt_en": obj_dict["appt"].strip(),
}
if any(v for k, v in obj_dict.items() if k.startswith("founder_")):
update_dict["other_founders_uk"] = "\n".join(
obj_dict[k] for k in sorted(obj_dict.keys())
if k.startswith("founder_"))
if obj_dict["notes"].strip():
update_dict["wiki_uk"] = '<p>%s</p>' % obj_dict["notes"].strip()
if obj_dict["link"].strip():
update_dict["wiki_uk"] = (
update_dict.get("wiki_uk", "") +
'<p><a href="%s" target="_blank">Запис в реєстрі</p>' %
obj_dict["link"].strip())
update_dict["wiki_en"] = (
update_dict.get("wiki_en", "") +
'<p><a href="%s" target="_blank">Registry record</p>' %
obj_dict["link"].strip())
if company_name_orig:
update_dict["also_known_as"] = company_name_orig
if company_name_declaration:
update_dict["name_uk"] = company_name_declaration
if company_name_en:
update_dict["name_en"] = company_name_en
if obj_dict["status"]:
for k, v in Company._status_choices.items():
if obj_dict["status"].lower() == v:
update_dict["status"] = k
break
else:
self.logger.warning(
"Ігноруємо незрозумілий статус для компанії <%s>" %
json.dumps(obj_dict, ensure_ascii=False))
if (not company_code and not company_name_declaration
and not company_name_en and not company_name_orig):
self.logger.error(
"Не можу імпортувати іноземну юр. особу без коду або назви <%s>"
% json.dumps(obj_dict, ensure_ascii=False))
return None, created
# Not using get_or_create to avoid situation
# when created object is saved immediately
try:
# Search by code first
company = Company.objects.deep_get([("edrpou__iexact",
company_code)])
except (Company.DoesNotExist, Company.MultipleObjectsReturned):
try:
# Then refine the search if needed
company = Company.objects.deep_get([
("name_uk__iexact", company_name_declaration),
("name_uk__iexact", company_name_en),
("name_uk__iexact", company_name_orig),
("name_en__iexact", company_name_declaration),
("name_en__iexact", company_name_en),
("name_en__iexact", company_name_orig)
])
if (company.edrpou and company_code
and company.edrpou.lower() != company_code.lower()):
# We found a company by name, but it's probably a wrong one
self.logger.warning((
"Юр. особа що була знайдена для запису %s за іменем має відмінний "
+ "код реєстрації: %s, створюємо нову компанію") %
(json.dumps(obj_dict,
ensure_ascii=False),
company.edrpou))
raise Company.DoesNotExist()
except Company.DoesNotExist:
company = Company(edrpou=company_code)
created = True
except Company.MultipleObjectsReturned:
self.logger.error(
"Не можу імпортувати юр. особу <%s>: в базі таких більше одної"
% json.dumps(obj_dict, ensure_ascii=False))
return None, created
merger = st.Merger((
("name_uk", st.replace_strategy),
("name_en", st.replace_strategy),
(".*", st.replace_if_empty_strategy),
))
res = merger.merge(company, update_dict)
for k, v in res.items():
if v == st.MergeResult.OLD_VALUE:
self.logger.warning(
"Не замінюю поле %s на %s для компанії %s, %s" %
(k, update_dict[k], company.name, company.id))
if save:
company.save()
return company, created
def test_company_required_field(self):
company = Company()
with self.assertRaises(ValidationError):
company.full_clean()
def test_company_name_required_field(self):
company = Company(domain_name='instasalary.app')
with self.assertRaises(ValidationError):
company.full_clean()
def test_company_domain_required_field(self):
company = Company(name='abc')
with self.assertRaises(ValidationError):
company.full_clean()
def post(self, request):
name = request.data.get("name")
description = request.data.get("description")
phone = request.data.get("phone")
address = request.data.get("address")
available_now = request.data.get("availableNow")
photo = request.data.get("image")
limits = request.data.get("limits")
category_description = request.data.get("category")
limits = urllib.parse.unquote(limits.__str__())
category_selected = CompanyCategory.objects.get(
description=category_description)
payment_array = []
delivery_array = []
if available_now.__str__() == "true" or available_now:
available_now = True
else:
available_now = False
try:
payment_methods = request.data.get("paymentMethods").name
payment_methods = payment_methods.replace('[', '')
payment_methods = payment_methods.replace(']', '')
payment_methods = payment_methods.split(',')
except:
payment_methods = request.data.get("paymentMethods")
try:
delivery_methods = request.data.get("deliveryMethods").name
delivery_methods = delivery_methods.replace('[', '')
delivery_methods = delivery_methods.replace(']', '')
delivery_methods = delivery_methods.split(',')
except:
delivery_methods = request.data.get("deliveryMethods")
try:
comapny_from_user = request.user
company = Company.objects.get(id_user=comapny_from_user)
except:
company = Company()
company.account_debit = 0
try:
company.name = name
company.description = description
company.phone = phone
company.address = address
company.available_now = available_now
if photo is not None:
company.photo = photo
company.limits = limits
company.category = category_selected
company.id_user = request.user
company.save()
for method in payment_methods:
method = method.strip()
method_selected = PaymentMethod.objects.get(description=method)
payment_array.append(method_selected)
company.payment_method.set(payment_array)
for method in delivery_methods:
method = method.strip()
delivery_method_selected = DeliveryMethod.objects.get(
description=method)
delivery_array.append(delivery_method_selected)
company.delivery_method.set(delivery_array)
company.save()
except Exception():
return Response({"Error Saving This"}, 400)
return Response(company.pk)
