def testInitialModuleDataInvitedRegistered(self):
self.register()
self.login()
self.client.post('/invites/send/', {'msg' : '1', 'email' : '*****@*****.**'})
self.client.post('/invites/send/', {'msg' : '2', 'email' : '*****@*****.**'})
self.client.post('/invites/send/', {'msg' : '3', 'email' : '*****@*****.**'})
company = Company({'brand_name' : 'new company', 'rek_id' : 'CCCC'})
company.save()
rec_request = RecommendationRequest({'requester' : company._id,
'recipient' : self.company._id,
'status' : RecommendationStatusEnum.ACCEPTED,
'message' : '123',
'requester_email' : '*****@*****.**'})
rec_request.save()
invite = Invite.objects.get_one({'email' : '*****@*****.**'})
invite.rec_request = rec_request._id
invite.save()
data = RecommendInitialsView.generate_data_obj(self.company, self.company, self.employee)
self.assertIsNotNone(data)
self.assertIn('sent_invites', data)
self.assertIn('sent_registered_invites', data)
self.assertEqual(len(data['sent_invites']), 2)
self.assertEqual(len(data['sent_registered_invites']), 1)
invites = {}
for invite_item in data['sent_invites']:
invites[invite_item['email']] = 'exists'
self.assertIn('*****@*****.**', invites)
self.assertIn('*****@*****.**', invites)
def register_companies(self, count = 10, verified = True):
companies = []
for a in xrange(count):
user = User.create_user('*****@*****.**' % a, User.make_random_password())
if not user:
raise Exception('failed to create test user')
User.collection.update({'_id' : user._id}, {'$set' : {'activated' : True}})
employee = CompanyEmployee({'user_id' : user._id,
'first_name' : 'test_user_' + str(a)})
employee.save()
company = Company({'rek_id' : integer_to_code(a + 10000),
'owner_employee_id' : employee._id,
'short_name' : 'tc_' + str(a),
'full_name' : 'OOO Test Company ' + str(a),
'brand_name' : 'Test Company Brand ' + str(a),
'description' : 'Test company ' + str(a),
'category_text' : 'Testing',
'staff_size' : (a + 1) * 3,
'inn' : int(str(a + 1) + '0' * (12 - len(str(a)))) + a + 1,
'kpp' : int(str(a + 1) + '1' * (9 - len(str(a)))) + a + 1,
'is_account_activated' : True,
'account_status' : CompanyAccountStatus.VERIFIED if verified else CompanyAccountStatus.JUST_REGISTERED
})
company.save()
employee.set(company_id = company._id)
companies.append(company)
return companies
def testVerifyRaw(self):
company = Company({'brand_name' : 'Test Company Brand name'})
company.save()
company.change_fsm_state(CompanyAccountStatus.VERIFIED, brand_name='brand name', description='description')
company = Company.objects.get_one({'brand_name' : 'brand name', 'description' : 'description'})
self.assertIsNotNone(company)
self.assertEqual(company.account_status, CompanyAccountStatus.VERIFIED)
def register_companies(self, count=10, verified=True):
companies = []
for a in xrange(count):
user = User.create_user('*****@*****.**' % a,
User.make_random_password())
if not user:
raise Exception('failed to create test user')
User.collection.update({'_id': user._id},
{'$set': {
'activated': True
}})
employee = CompanyEmployee({
'user_id': user._id,
'first_name': 'test_user_' + str(a)
})
employee.save()
company = Company({
'rek_id':
integer_to_code(a + 10000),
'owner_employee_id':
employee._id,
'short_name':
'tc_' + str(a),
'full_name':
'OOO Test Company ' + str(a),
'brand_name':
'Test Company Brand ' + str(a),
'description':
'Test company ' + str(a),
'category_text':
'Testing',
'staff_size': (a + 1) * 3,
'inn':
int(str(a + 1) + '0' * (12 - len(str(a)))) + a + 1,
'kpp':
int(str(a + 1) + '1' * (9 - len(str(a)))) + a + 1,
'is_account_activated':
True,
'account_status':
CompanyAccountStatus.VERIFIED
if verified else CompanyAccountStatus.JUST_REGISTERED
})
company.save()
employee.set(company_id=company._id)
companies.append(company)
return companies
def post(self, request):
target_company_rek_id = request.POST.get('rek_id', '').strip()
try:
target_company = Company.get_active_company_by_rek_id(target_company_rek_id)
if not target_company:
raise Exception
except Exception:
raise Http404()
privacy = request.POST.get('privacy', '').strip()
try:
my_company = request.company
contractor = Contractor.objects.get_one({'status' : ContractorStatusEnum.ACCEPTED,
'$or' : [{'company_1' : my_company._id,
'company_2' : target_company._id},
{'company_2' : my_company._id,
'company_1' : target_company._id}]})
if not contractor:
raise Exception
if privacy not in ContractorPrivacy.ALL:
raise Exception
except Exception:
raise Http404()
if my_company._id == contractor.company_1:
Contractor.objects.collection.update({'_id' : contractor._id},
{'$set' : {'company_2_data.privacy' : privacy}})
else:
Contractor.objects.collection.update({'_id' : contractor._id},
{'$set' : {'company_1_data.privacy' : privacy}})
return HttpResponse("{}", mimetype="application/x-javascript")
def get_contractors(company):
if not (company and hasattr(company, 'contractors') and company.contractors and len(company.contractors)):
return []
return [{'rek_id' : contractor_data['rek_id'],
'brand_name' : contractor_data['brand_name'],
'comment_logo' : Company.get_micro_logo_url(contractor_data['rek_id'],
contractor_data['micro_logo'])} for contractor_data in company.contractors]
def get(self, request):
company_list = []
active_only = request.GET.get('active', '')
search_query = {}
if active_only=='true':
search_query['is_account_activated'] = True
elif active_only=='false':
search_query['is_account_activated'] = False
verified_only = request.GET.get('verified', '')
if verified_only=='true':
search_query['account_status'] = 'verified'
elif verified_only=='false':
search_query['account_status'] = 'just_registered'
companies = Company.objects.collection.find(search_query).sort('date_creation', -1)
total_count = companies.count()
data = {'companies' : company_list,
'total_count' : total_count}
for company_data in companies:
item = Company(company_data)
company_list.append({'rek_id' : item.rek_id,
'brand_name' : item.brand_name,
'short_name' : item.short_name,
'full_name' : item.full_name,
'description' : item.description,
'logo_url' : item.get_logo_url(),
'inc_form_str' : IncFormEnum.type_to_abbr(item.inc_form),
'inn' : item.inn or "",
'kpp' : item.kpp or "",
'category_text' : item.category_text or "",
'date_creation' : item.date_creation,
'date_established' : item.date_established or "",
'staff_size' : StaffSizeEnum.to_string(item.staff_size),
'gen_director' : item.gen_director or "",
'chief_accountant' : item.chief_accountant or "",
'account_status' : item.account_status,
'account_status_color' : STATUS_COLORS.get(item.account_status, 'white'),
'is_account_activated' : item.is_account_activated})
return render_to_response("search/companies/seach_company.html", data, context_instance=RequestContext(request))
def post(self, request):
target_company_rek_id = request.POST.get('rek_id', '').strip()
try:
target_company = Company.get_active_company_by_rek_id(target_company_rek_id)
if not target_company:
raise Exception
if request.company and target_company._id == request.company._id:
raise Exception
except Exception:
raise Http404()
return self.handle_request(target_company, request.company)
def get(self, request, company_rek_id):
my_company = request.company if hasattr(request, 'company') else None
if my_company and my_company.rek_id == company_rek_id:
company = my_company
else:
company = Company.get_active_company_by_rek_id(company_rek_id)
if not company:
raise Http404()
data = self.generate_data_obj(company, my_company)
data.update(portal.get_common_data_for_company(request, company))
response_content = mark_safe(simplejson.dumps(data))
return HttpResponse(response_content, mimetype="application/x-javascript")
def get_contractors(company):
if not (company and hasattr(company, 'contractors') and company.contractors
and len(company.contractors)):
return []
return [{
'rek_id':
contractor_data['rek_id'],
'brand_name':
contractor_data['brand_name'],
'comment_logo':
Company.get_micro_logo_url(contractor_data['rek_id'],
contractor_data['micro_logo'])
} for contractor_data in company.contractors]
def get(self, request, company_rek_id):
my_company = request.company if hasattr(request, 'company') else None
if my_company and my_company.rek_id == company_rek_id:
company = my_company
else:
company = Company.get_active_company_by_rek_id(company_rek_id)
if not company:
raise Http404()
data = self.generate_data_obj(company, my_company)
data.update(portal.get_common_data_for_company(request, company))
response_content = mark_safe(simplejson.dumps(data))
return HttpResponse(response_content,
mimetype="application/x-javascript")
def register_verification_requesters(self, target_company, count = 10, status = RecommendationStatusEnum.RECEIVED):
requesters = []
for a in xrange(count):
user = User.create_user('*****@*****.**' % a, 'aaa')
User.collection.update({'_id' : user._id}, {'$set' : {'activated' : True}})
if not user:
raise Exception('failed to create test user')
employee = CompanyEmployee({'user_id' : user._id,
'first_name' : 'test_user_' + str(a)})
employee.save()
company = Company({'rek_id' : integer_to_code(a + 10000),
'owner_employee_id' : employee._id,
'short_name' : 'tc_' + str(a),
'full_name' : 'OOO Test Company ' + str(a),
'brand_name' : 'Test Company Brand ' + str(a),
'description' : 'Test company ' + str(a),
'category_text' : 'Testing',
'staff_size' : (a + 1) * 3,
'inn' : int(str(a + 1) + '0' * (12 - len(str(a)))) + a + 1,
'kpp' : int(str(a + 1) + '1' * (9 - len(str(a)))) + a + 1,
'account_status' : CompanyAccountStatus.JUST_REGISTERED,
'is_account_activated' : True
})
company.save()
employee.set(company_id = company._id)
request = RecommendationRequest({'requester' : company._id,
'recipient' : target_company._id,
'status' : status,
'message' : 'Please recommend me.',
'requester_email' : user.email})
request.save()
requesters.append((company, employee, user, request))
return requesters
def register_companies(count=1, verified=False):
companies = []
employees = []
users = []
for i in xrange(count):
email = '*****@*****.**' % i
rek_id = 'CCC%i' % i
password = '******'
brand_name = u'Порошки%i' % i
created_user = User.create_user(email, password)
if not created_user:
raise Exception('failed to create user')
new_employee = CompanyEmployee({'user_id':created_user._id,
'timezone' : 'Europe/Moscow'})
new_employee.save()
new_company = Company({'rek_id':rek_id,
'owner_employee_id':new_employee._id,
'brand_name' : brand_name,
'is_account_activated' : True,
'date_creation' : timezone.now() + timedelta(days=i)})
if verified:
new_company.account_status = 'verified'
new_company.save()
new_employee.set(company_id=new_company._id)
users.append(created_user)
employees.append(new_employee)
companies.append(new_company)
User.collection.update({}, {'$set' : {'activated' : True, 'is_active' : True}}, multi=True)
return companies, employees, users
def testVerifyRaw(self):
company = Company({'brand_name': 'Test Company Brand name'})
company.save()
company.change_fsm_state(CompanyAccountStatus.VERIFIED,
brand_name='brand name',
description='description')
company = Company.objects.get_one({
'brand_name': 'brand name',
'description': 'description'
})
self.assertIsNotNone(company)
self.assertEqual(company.account_status, CompanyAccountStatus.VERIFIED)
def post(self, request, code):
try:
rec_message = request.POST['message']
except Exception:
return HttpResponseBadRequest("No message field")
company_to_ask = Company.get_active_company_by_rek_id(code)
if not company_to_ask:
return HttpResponseNotFound("Company with rec id %s can not be found." % code)
my_company = request.company
employee = request.employee
check = CompanyPermission(request.user, employee, my_company)
result_dict = {}
if not check.can_ask_recommendation(company_to_ask, result_dict):
if len(result_dict):
result_dict['error'] = True
return HttpResponse(simplejson.dumps(result_dict), mimetype='application/javascript')
return HttpResponseForbidden("Can't ask for a recommendation")
rec = RecommendationRequest({'requester' : my_company._id,
'recipient' : company_to_ask._id,
'message' : rec_message,
'requester_email' : request.user.email})
rec.save()
if my_company._id not in company_to_ask.rec_requesters:
company_to_ask.rec_requesters.append(my_company._id)
Company.objects.collection.update({'_id' : company_to_ask._id}, {'$push' : {'rec_requesters' : my_company._id} })
admin_user, admin_employee = company_to_ask.get_admin_user()
requester_brand_name = my_company.brand_name
recipient_rek_id = code
self.send_rec_message(admin_user.email, rec_message, rec._id, recipient_rek_id, requester_brand_name)
return HttpResponse(simplejson.dumps({'success' : True,
'max_req_count_reached' : RecommendationRequest.objects.count({'requester' : my_company._id}) >= SettingsManager.get_property('rmax') }),
mimetype='application/javascript')
def testIncorrectTransition(self):
company = Company({'brand_name' : 'Test Company Brand name'})
company.save()
self.assertRaises(StateChangeException, company.change_fsm_state, CompanyAccountStatus.SEMI_VERIFIED)
def testIncorrectTransition(self):
company = Company({'brand_name': 'Test Company Brand name'})
company.save()
self.assertRaises(StateChangeException, company.change_fsm_state,
CompanyAccountStatus.SEMI_VERIFIED)
def generate_data(cls, query="", page=1):
page -= 1
if page < 0 or page > 12344:
page = 0
data = {'query' : query,
'page' : page,
'results' : []}
total = 0
if query and len(query):
no_company_id = False
criteria_main = {'rek_id' : query.upper(),
'is_account_activated' : {'$ne' : False},
'account_status' : {'$in' : CompanyAccountStatus.ACTIVE_ACCOUNT_STATUSES}}
query_result = Company.objects.collection.find(criteria_main)
if query_result.count() != 1:
no_company_id = True
else:
found_company = Company(query_result[0])
if not found_company.is_active():
no_company_id = True
else:
total = 1
criteria_main = {'$or' : []}
if no_company_id:
try:
term_as_integer = int(query)
except ValueError:
term_as_integer = 0
if term_as_integer:
criteria_main['$or'] = [{'inn' : term_as_integer}, {'kpp' : term_as_integer}]
search_dict = {'$regex' : '.*%s.*' % query, '$options' : 'i'}
criteria_main['$or'].extend([
{'brand_name' : search_dict},
{'short_name' : search_dict},
{'full_name' : search_dict},
{'category_text' : search_dict},
{'description' : search_dict}])
criteria_main = {'$and' : [criteria_main,
{'is_account_activated' : {'$ne' : False},
'account_status' : {'$in' : CompanyAccountStatus.ACTIVE_ACCOUNT_STATUSES}}]}
query_result = Company.objects.collection.find(criteria_main).sort('date_creation', -1).skip(page * MAX_PAGE_COUNT).limit(MAX_PAGE_COUNT)
total = Company.objects.count(criteria_main)
else:
query_result = Company.objects.collection.find({
'is_account_activated' : {'$ne' : False},
'account_status' : {'$in' : CompanyAccountStatus.ACTIVE_ACCOUNT_STATUSES}
}).sort('date_creation', -1).skip(page * MAX_PAGE_COUNT).limit(MAX_PAGE_COUNT)
total = Company.objects.count({'is_account_activated' : {'$ne' : False},
'account_status' : {'$in' : CompanyAccountStatus.ACTIVE_ACCOUNT_STATUSES}})
for company_obj in query_result:
found_company = Company(company_obj)
data['results'].append({'bname' : found_company.brand_name,
'logo' : found_company.get_list_logo_url(),
'company_url' : reverse("showCompany", kwargs={'code' : found_company.rek_id}),
'kind_of_activity' : found_company.category_text})
data['pagination'] = {'page' : page + 1,
'count' : total / MAX_PAGE_COUNT + (1 if total % MAX_PAGE_COUNT else 0)}
result_json = simplejson.dumps(data)
return mark_safe(result_json)
def generate_data_obj(cls, query="", start_ts=0, categories = None):
categories = categories or []
if start_ts < 1293829200: # 2011.1.1
start_ts = 2000000000
data = {'query' : query,
'results' : []}
try:
start_date = datetime.fromtimestamp(start_ts, timezone.get_current_timezone())
if not start_date:
raise Exception()
except Exception:
start_date = datetime(2033, 2, 1)
if query and len(query):
criteria_main = {'$or' : []}
try:
term_as_integer = int(query)
except ValueError:
term_as_integer = 0
if term_as_integer:
criteria_main['$or'] = [{'inn' : term_as_integer}, {'kpp' : term_as_integer}]
else:
criteria_main['$or'] = [{'rek_id' : query.upper()}]
search_dict = {'$regex' : '.*%s.*' % query, '$options' : 'i'}
criteria_main['$or'].extend([
{'brand_name' : search_dict},
{'full_name' : search_dict},
{'category_text' : search_dict},
{'description' : search_dict}])
criteria_main = {'$and' : [criteria_main,
{'is_account_activated' : {'$ne' : False},
'account_status' : {'$in' : CompanyAccountStatus.ACTIVE_ACCOUNT_STATUSES},
'date_creation' : {'$lt' : start_date}}]}
if len(categories):
if len(categories) == 1:
criteria_main['$and'].append({'categories' : categories[0]})
else:
criteria_main['$and'].append({'categories' : {'$all' : categories}})
query_result = Company.objects.collection.find(criteria_main).sort('date_creation', -1).limit(MAX_PAGE_COUNT)
else:
criteria_main = {
'is_account_activated' : {'$ne' : False},
'account_status' : {'$in' : CompanyAccountStatus.ACTIVE_ACCOUNT_STATUSES},
'date_creation' : {'$lt' : start_date}
}
if len(categories):
if len(categories) == 1:
criteria_main['categories'] = categories[0]
else:
criteria_main['categories'] = {'$all' : categories}
query_result = Company.objects.collection.find(criteria_main).sort('date_creation', -1).limit(MAX_PAGE_COUNT)
total_count = query_result.count()
limited_count = query_result.count(True)
data['has_more'] = total_count > limited_count
last_date = None
for company_obj in query_result:
found_company = Company(company_obj)
data['results'].append({'bname' : found_company.brand_name,
'logo' : found_company.get_list_logo_url(),
'company_url' : reverse("showCompany", kwargs={'code' : found_company.rek_id}),
'kind_of_activity' : found_company.category_text})
last_date = found_company.date_creation
if last_date:
data['last_ts'] = int(time.mktime(last_date.timetuple()))
return data