def to_company(self, company: Company): """Create a transaction to company""" if self._has_enough_money_to_transfer(): self.from_company.balance -= self.amount company.balance += self.amount self.from_company.save() company.save()
def test_boiler_user_access(self): c1 = Company(company_name="Company1") c2 = Company(company_name="Company2") db.session.add(c1) db.session.add(c2) b1 = Boiler(boiler_name="Boiler1", company=c1) b2 = Boiler(boiler_name="Boiler2", company=c2) b3 = Boiler(boiler_name="Boiler3", company=c2) db.session.add(b1) db.session.add(b2) db.session.add(b3) db.session.commit() r = Role.query.filter_by(name='Repr').first() u1 = User(email='*****@*****.**', password='******', role=r, company=c1) u2 = User(email='*****@*****.**', password='******', role=r, company=c2) db.session.add(u1) db.session.add(u2) db.session.commit() self.assertTrue(u1.boiler_access(b1.id)) self.assertFalse(u1.boiler_access(b2.id)) self.assertFalse(u1.boiler_access(b3.id)) self.assertFalse(u2.boiler_access(b1.id)) self.assertTrue(u2.boiler_access(b2.id)) self.assertTrue(u2.boiler_access(b3.id))
def cleaning(): app.app_context().push() print("Starting cleaning job...") Company.company_cleaning() Announcement.announcement_cleaning() db.session.commit() print("Cleaning job completed...")
def signup(): form = RegisterForm(request.form) if request.method == "POST": if form.validate(): user = User(form.email.data, form.password.data) if user: user.name = form.name.data if user.second_name is not None: user.second_name = form.second_name.data user.lastname = form.lastname.data if user.second_lastname is not None: user.second_lastname = form.second_lastname.data user.rfc = form.rfc.data # add company db.session.add(user) try: db.session.commit() except IntegrityError: db.session.rollback() mess = "Either Email or the RFC exist in the database" flash(mess) return render_template("auth/signup.html", form=form, title="Sign Up") company = Company(form.company.data) company.user_id = user.id db.session.add(company) db.session.commit() flash("%s Signed Up successfuly with your Company %s" % (user.name, company.name)) return redirect(url_for("auth.login")) flash("Something went wrong, please try again.", 'error-message') else: return jsonify(form.errors), 400 return render_template("auth/signup.html", form=form, title="Sign Up")
def test_can_retrieve_a_company_with_founders(self): demo = Company( name=data1['name'], website=data1['website'], bio=data1['bio'], ) demo.save() # Add founders into the database # with reference to the newly created company company_id = Company.query.first().id auth_token = self.get_auth_token(staff=True) for founder in data1['founders']: Founder(company_id=company_id, name=founder['name'], email=founder['email'], role=founder['role']).save() # GET request response = self.client.get( f'/companies/{company_id}', headers=self.get_authorized_header(auth_token)) self.assertEqual(response.status_code, 200) response_ = json.loads(response.data.decode()) self.assertIn('founders', response_) self.assertIn('role', str(response_['founders'])) self.assertIn('@demo.com', str(response_['founders']))
def add_company(): form = CompanyForm() if form.validate_on_submit(): if current_user.is_authenticated: company = Company( company_name=form.company_name.data, company_address=form.company_address.data, company_city=form.company_city.data, company_state=form.company_state.data, company_zipcode=form.company_zipcode.data, company_website=form.company_website.data, company_phone_number=form.company_phone_number.data, company_email=form.company_email.data, author=current_user) else: company = Company( company_name=form.company_name.data, company_address=form.company_address.data, company_city=form.company_city.data, company_state=form.company_state.data, company_zipcode=form.company_zipcode.data, company_website=form.company_website.data, company_phone_number=form.company_phone_number.data, company_email=form.company_email.data) db.session.add(company) db.session.commit() flash('Thank you, the company has been added!') return redirect(url_for('index')) return render_template('report.html', title='Report', form2=form)
def test_post_filter(self): # create company c1 = Company(id=1, company_name='Paint pods', company_address='Boise', company_zipcode='83706', company_website='Paintteam.com', company_phone_number='20867832', company_email='*****@*****.**') c2 = Company(id=2, company_name='Bob Team', company_address='Salt Lake City', company_zipcode='81504', company_website='Paintteam.com', company_phone_number='2086783456', company_email='*****@*****.**') db.session.add(c1) db.session.add(c2) db.session.commit() # create four users u1 = User(username='******', email='*****@*****.**') u2 = User(username='******', email='*****@*****.**') u3 = User(username='******', email='*****@*****.**') u4 = User(username='******', email='*****@*****.**') db.session.add_all([u1, u2, u3, u4]) # create services s1 = Service(parent_id=1, title='plumbing') s2 = Service(parent_id=2, title='electrical') db.session.add(s1) db.session.add(s2) db.session.commit() # create four posts now = datetime.utcnow() p1 = Post(body="post from john", timestamp=now + timedelta(seconds=1), service_id=1, company_id=1) p2 = Post(body="post from john", timestamp=now + timedelta(seconds=1), service_id=1, company_id=1) p3 = Post(body="Test post", timestamp=now + timedelta(seconds=1), service_id=2, company_id=2) p4 = Post(body="test post", timestamp=now + timedelta(seconds=1), service_id=2, company_id=2) db.session.add_all([p1, p2, p3, p4]) db.session.commit() # check service_posts function check1 = u1.filter_posts(1, "Boise", "None", "None") # check that the correct posts are returned self.assertEqual(check1.count(), 2)
def test_company_membership(self): # create companies c1 = Company(company_name='test', email='*****@*****.**') c2 = Company(company_name='test2', email='*****@*****.**') # create employees with memberships e1 = Employee(email='*****@*****.**', first_name='thomas', last_name='mcdonnell', is_admin=True, member_of=c1) e2 = Employee(email='*****@*****.**', first_name='tom', last_name='jones', member_of=c2) # commit to database db.session.add(c1) db.session.add(c2) db.session.add(e1) db.session.add(e2) db.session.commit() # test memberships self.assertEqual(c1.employees.count(), 1) self.assertEqual(c2.employees.count(), 1) # test memberships self.assertEqual(c1.employees.all(), [e1]) self.assertNotEqual(c1.employees.all(), [e2]) self.assertEqual(c2.employees.all(), [e2]) self.assertNotEqual(c2.employees.all(), [e1])
def create_company(cc_code, link="", name=""): company = Company() company.id = cc_code company.name = name company.link = link db.session.add(company) db.session.commit()
def setUp(self): self.app = create_app('testing') self.app_context = self.app.app_context() self.app_context.push() db.create_all() Company.generate_fake(10) Indicators.generate_fake(3)
def test_company_from_json(self): c = Company.from_json({'name': 'ABC Company', 'symbol': 'ABC', 'index': "NYSE"}) self.assertTrue(isinstance(c, Company)) with self.assertRaises(ValueError): c = Company.from_json({'name': '', 'symbol': ''}) c = Company.from_json({'name': 'DEF Company', 'symbol': 'DEF', 'active': False}) self.assertTrue(isinstance(c, Company))
def create(self, user, name=None): if user is None: raise TypeError('user is None.') company = Company(name=name, user=user) company.put() return company
def company_create(): if not request.json or 'name' not in request.json: return json.dumps({'error': 'incorrect_params'}), 400, { 'ContentType': 'application/json' } name = request.json['name'] Company.create(name) return jsonify({'success': True}), 200, {'ContentType': 'application/json'}
def seed_companies(): c1 = Company(userId_fk=10, companyName='Company 1') c2 = Company(userId_fk=11, companyName='Company 2') db.session.add(c1) db.session.add(c2) db.session.commit()
def test_company_inspector_access(self): c1 = Company(company_name="Company1") c2 = Company(company_name="Company2") r = Role.query.filter_by(name='Inspector').first() u1 = User(email='*****@*****.**', password='******', role=r, company=c1) self.assertTrue(u1.company_access(c1.id)) self.assertTrue(u1.company_access(c2.id))
def test_company_admin_access(self): c1 = Company(company_name="Company1") c2 = Company(company_name="Company2") r = Role.query.filter_by(name='Administrator').first() u1 = User(email='*****@*****.**', password='******', role=r, company=c2) self.assertTrue(u1.company_access(c1.id)) self.assertTrue(u1.company_access(c2.id))
def register(): form = RegistrationForm() if form.validate_on_submit(): email = form.email.data username = form.username.data user = User(email=email, username=username) user.password = form.password.data company = Company() company.name = form.company.data db.session.add(user) db.session.add(company) company.set_company_owner(user) company.add_user(user) db.session.commit() company.company_materials_setup() db.session.commit() token = user.generate_confirmation_token() send_email( user.email, "Confirm Your Account", "auth/email/confirm", user=user, token=token, ) flash("A confirmation email has been sent to you by email.") return redirect(url_for("auth.login")) return render_template("auth/register.html", form=form)
def test_create_company(): c = Company() c.name = "test name" db.session.add(c) db.session.commit() db_c = Company.query.filter_by(name="test name").first() assert db_c == c
def addCompany(id): form = CompanyForm() form['csrf_token'].data = request.cookies['csrf_token'] if form.validate_on_submit(): newCompany = Company( userId_fk=id, companyName=form.data['companyName'], ) db.session.add(newCompany) db.session.commit() return newCompany.to_dict() return { 'errors': validation_errors_to_error_messages(form.errors)}
def test_company_description(self): self.app.logger.debug('test_company_description') description = u'Ãœber' user = self.create_default_user() company = Company(user=user, name='A Company') company.description = description db.session.add(company) db.session.commit() company = Company.query.first() assert company is not None assert company.description == description
def handle(self, *args, **options): print('Importing.') Company.objects.all().delete() Person.objects.filter(source='flagma.kz').delete() Person2Company.objects.all().delete() urls = [] for cnt in range(1, 1000): urls.append('https://flagma.kz/kompanii-k-%s.html' % cnt) for url in urls: print("Importing %s" % url) time.sleep(1) i = Import() i.url = url i.save() rez = requests.get(url) soup = bs4.BeautifulSoup(rez.text, 'html.parser') items = soup.findAll('div', {"class": "page-list-item-info"}) for i in items: name = i.find('a').text location = i.find('span', {"itemprop": "location"}).text boss = i.find('span', {"itemprop": "employee"}).text arrboss = boss.split(',') c = Company() c.name_ru = name c.name_kz = name c.faunders_text = boss c.city_text = location c.save() parse_company(c) print('Saving.....%s' % name)
def test_users_company_name(clean_db): company = Company() company.name = "test name" user1 = User() user1.username = "******" db.session.add(user1) db.session.add(company) company.add_user(user1) db.session.commit() assert user1.company.name == company.name
def get_name_from_symbol(symbol): """ Use EDGAR online database to find the company name. """ from flask import current_app import dryscrape from app.models import Company if not Company.validate_symbol(symbol): return None r = requests.get("http://edgaronline.api.mashery.com/v2/companies?primarysymbols={}&appkey={}".format(symbol, current_app.config['EDGAR_APP_KEY'])) try: values = r.json()['result']['rows'][0]['values'] except (KeyError, IndexError) as e: return None companyname = None for value in values: if value.get('field') == "companyname": companyname = value.get('value') break return companyname
def company_list(): try: rows = Company.query.all() for row in rows: db.session.delete(row) db.session.commit() nasdaqURL = 'https://old.nasdaq.com/screening/companies-by-name.aspx?letter=0&exchange=nasdaq&render=download' nyseURL = 'https://old.nasdaq.com/screening/companies-by-name.aspx?letter=0&exchange=nyse&render=download' df1 = pd.read_csv(nasdaqURL, sep=',') df2 = pd.read_csv(nyseURL, sep=',') c_dict = {} for s in df1.values: print(s) c_dict.update({s[0]: s[1]}) for s in df2.values: c_dict.update({s[0]: s[1]}) count = 0 for k, v in c_dict.items(): temp = v if len(temp) > 64: temp = temp[0:60] temp = temp + "..." c = Company(company_symbol=k, company_name=temp) db.session.add(c) db.session.commit() rows = db.session.query(Company).count() return "Committed" + str(rows) except Exception as inst: print(inst) return str(inst)
def create_contact(): form = CreateContact() if form.validate_on_submit(): company = Company.query.filter_by(company_name=form.company_name.data) email = Email.query.filter_by(email=form.email.data) phone = Phone.query.filter_by(phone=form.phone.data) if email.count() == 1: flash('Email already exist') return redirect(url_for('create_contact')) if phone.count() == 1: flash('Phone already exist') return redirect(url_for('create_contact')) if company.count() == 1: contact = Contact(last_name=form.last_name.data, first_name=form.first_name.data, job_position=form.job_position.data, contact_status=form.contact_status.data) company = company.first() company.contacts.append(contact) else: contact = Contact(last_name=form.last_name.data, first_name=form.first_name.data, job_position=form.job_position.data, contact_status=form.contact_status.data) company = Company(company_name=form.company_name.data) company.contacts.append(contact) db.session.add_all([company, contact]) db.session.commit() flash('Congratulations, you have create a new contact !') return render_template('create_contact.html', title='Create contact', form=form)
def create_company(): """ [POST] /company """ response = request.get_json() c = Company(company_status=response['company_status'], company_name=response['company_name'], company_city=response['company_city'], company_state=response['company_state'], company_zip_code=response['company_zip_code'], company_phone=response['company_phone'], company_website=response['company_website'], notes=response['notes'], user_id=response['user_id']) c.create_company() return jsonify([company.to_dict() for company in Company.query.all()])
def manager(mname): form = CompanyForm() if form.validate_on_submit(): company = Company(crypto=form.crypto.data, manager=current_user) db.session.add(company) db.session.commit() flash('Your company is now live!') return redirect(url_for('main.manager', mname=mname)) manager = Manager.query.filter_by(email=mname.lower() + "@getresponse.com").first_or_404() page = request.args.get('page', 1, type=int) if manager == current_user: companies = manager.followed_companies().paginate( page, current_app.config['COMPANIES_PER_PAGE'], False) next_url = url_for('main.index', page=companies.next_num) \ if companies.has_next else None prev_url = url_for('main.index', page=companies.prev_num) \ if companies.has_prev else None return render_template('manager.html', title=mname, manager=manager, companies=companies.items, form=form, next_url=next_url, prev_url=prev_url) else: companies = manager.companies.all() return render_template('manager.html', title=mname, manager=manager, companies=companies)
def company_register(): if current_user.is_authenticated: return redirect(url_for("main.home")) form = RegistrationForm() if form.validate_on_submit(): if not form.validate_email(form.email): flash("Email already being used. Please try again", "danger") elif not form.validate_address(form.address): flash("Address already being used. Please try again", "danger") elif not form.validate_phone_number(form.phone_number): flash("Phone number already being used. Please try again", "danger") elif not form.validate_website(form.website): flash("Website already being used. Please try again", "danger") else: hashed_password = bcrypt.generate_password_hash(form.password.data) user_id = unicode(uuid4()) company = Company(id=user_id, name=form.name.data.lower(), address=form.address.data.lower(), city=form.city.data.lower(), zip_code=form.zip_code.data, state=form.state.data, country=form.country.data, phone_number=form.phone_number.data, email=form.email.data.lower(), website=form.website.data.lower(), password=hashed_password) database.session.add(company) database.session.commit() flash("Your company has been registered! Please sign in!", "success") return redirect(url_for("companies.login")) return render_template("register_company.html", form=form)
def load_companies_data(): with open(COMPANIES_DATA, 'r') as f: companies = json.load(f) for company in companies: db.session.add(Company(id=company['index'], name=company['company'])) db.session.commit()
def create_company(self): Company.query.delete() company = Company(name='abc', transaction_date=datetime(2020, 12, 1), per_share_deal_price=55.55) db.session.add(company) db.session.commit()
def test_get_company_by_created(self, mocker): expected_results = [ Company(name='Inmobiliaria Europa S.A', nif=432827568, created_at=datetime.datetime.now(), last_modified_at=datetime.datetime.now() ) ] date = strftime('%Y-%m-%d') # Se crea la consulta con django-mock-queries para crear el Mock QuerySets # con el cual logramos omitir la consulta a la base de datos qs = MockSet(expected_results[0]) # Patch el metodo qet_queryset para modificar su comportamiento # Se modifica el comportamiento con patch el metodo qet_queryset # para que retorne nuestro queryset y no el da la base de datos mocker.patch.object(Company.objects, 'get_queryset', return_value=qs) result = list(Company.objects.get_company_by_created(date)) assert result == expected_results assert str(result[0]) == expected_results[0].name
def user(username): user = User.query.filter_by(username=username).first_or_404() page = request.args.get('page', 1, type=int) form = CompanyRegistrationForm() if form.validate_on_submit(): company = Company(company_name=form.company_name.data) db.session.add(company) db.session.commit() accept = Affiliates(accepted=True) accept.user_id = current_user.id company.affiliate.append(accept) db.session.commit() return redirect(url_for('user', username=user.username)) my_affiliates = Affiliates.query.filter_by(user_id=user.id, accepted=True).all() #for affiliate in my_affiliates: # affiliate.comp_id = affiliate.company_id #affiliate.company = Company.query.filter_by(id=affiliate.company_id).first() posts = user.posts.order_by(Post.timestamp.desc()).paginate( page, app.config['POSTS_PER_PAGE'], False) next_url = url_for('user', username=user.username, page=posts.next_num) \ if posts.has_next else None prev_url = url_for('user', username=user.username, page=posts.prev_num) \ if posts.has_prev else None return render_template('user.html', title=user.username, user=user, posts=posts.items, prev_url=prev_url, next_url=next_url, form=form, my_affiliates=my_affiliates)
def get_company_list(): params = request.args page, size = get_pagination(params) search = params.get('search') deployment = params.get('deployment') scenario = params.get('scenario') consigner = params.get('consigner') query = Company.query if consigner: query = query.filter_by(consigner=consigner) if search: users = User.query.filter(User.username.contains(search)).all() ids = map(lambda user: getattr(user, 'company_id'), users) query = query.filter( or_(Company.name.contains(search), Company.id.in_(ids))) if deployment and deployment != '0': query = query.filter(Company.deployment == deployment) if scenario: query = query.filter(Company.scenario == scenario) pagination = query.options(db.joinedload('screens')) \ .options(db.joinedload('display_devices')) \ .add_column(Company.subject_count).order_by(Company.id.desc()).paginate(page, size) company_list = [] for company, subject_count in pagination.items: company = company.get_json(with_status=True) company['subject_count'] = subject_count user = User.query.filter_by(company_id=company['id'], role_id=UserRole.ROLE_ADMIN).first() if user: company['username'] = user.username company_list.append(company) deployments = Company.get_deployment_count() deployments['0'] = sum(deployments.values()) data = { 'companies': company_list, 'scenarios': Company.get_scenario_count(), 'deployments': deployments } return success_result(data, page_format(pagination))
def test_service_add_company(self): # create service s1 = Service(parent_id=1, title='plumbing') s2 = Service(parent_id=2, title='electrical') db.session.add(s1) db.session.add(s2) db.session.commit() # create company c1 = Company(company_name='Paint Team', company_address='123 Main St.', company_website='Paintteam.com', company_phone_number='2086783456', company_email='*****@*****.**') c2 = Company(company_name='Bob Team', company_address='123 Main St.', company_website='Paintteam.com', company_phone_number='2086783456', company_email='*****@*****.**') db.session.add(c1) db.session.add(c2) db.session.commit() # add company to service check1 = s1.add_company(c1) db.session.commit() check2 = s2.add_company(c1) db.session.commit() # check that the connection was made self.assertEqual(c1.services.count(), 2) self.assertEqual(s1.companies.first().company_name, 'Paint Team') self.assertEqual(c1.services.first().id, 1) print(c1.services.first().id) # remove companies check3 = s2.remove_company(c1) # check that it was removed self.assertEqual(c1.services.count(), 1) # add services to company check4 = c2.services.append(s1) # check that the connection was made self.assertEqual(c2.services.count(), 1) self.assertEqual(c2.services.first().title, 'plumbing')
def add_company(dataset): companies = [] individuals = list(Individual.query.all()) for i, cmpy in enumerate(dataset): jpindividuals = list(JPInvididual.query.all()) total_capital = 0 cmpny_to_add = Company(name=cmpy['name'], registry_id=cmpy['registry_id'], established=cmpy['established']) if len(dataset) < 11: qty = len(dataset) else: qty = 10 shareholders = random.sample(individuals, random.randint(1, qty)) if len(jpindividuals) < 5: qty = len(jpindividuals) else: qty = 5 if jpindividuals: jp_shareholders = random.sample(jpindividuals, random.randint(1, qty)) for owner in jp_shareholders: print(owner) shares = random.randint(2500, 5000) total_capital += shares a = JpOwnerAssociation(shares=shares, founder=bool(random.getrandbits(1)), owner_id=owner.id) a.companies_jp_owned = owner cmpny_to_add.company_jp_owners.append(a) for owner in shareholders: print(owner) shares = random.uniform(2500, 5000) total_capital += shares a = NpOwnerAssociation(shares=shares, founder=bool(random.getrandbits(1)), owner_id=owner.id) a.companies_np_owned = owner cmpny_to_add.company_owners.append(a) cmpny_to_add.total_capital = total_capital print(cmpny_to_add) db.session.add(cmpny_to_add) db.session.add(apply_jp_values(cmpny_to_add)) new_entries = db.session.commit() return new_entries
def stock_add(request): from app.remote.stocks import StockHistoryClient from app.forms import StockWizardForm from app.models import Company, Stock if request.method == "POST": form = StockWizardForm(request.POST) pprint(form.is_valid()) if form.is_valid(): # save company = Company() company.name = form.cleaned_data['company_name'] company.country = form.cleaned_data['company_country'] company.save() stock = Stock() stock.company = company stock.name = form.cleaned_data['name'] stock.wkn = form.cleaned_data['wkn'] stock.isin = form.cleaned_data['isin'] stock.symbol = form.cleaned_data['symbol'] stock.type = form.cleaned_data['type'] stock.default_stock_exchange = form.cleaned_data['default_stock_exchange'] stock.save() return HttpResponseRedirect(reverse('stock', args=(stock.symbol,))) else: pprint(form.errors) else: data = None if 'wkn_or_isin' in request.GET: shc = StockHistoryClient() data = shc.get_basics_by_wkn_or_isin(wkn_or_isin=request.GET['wkn_or_isin']) data['company_country'] = data['country'] data['company_name'] = data['name'] form = StockWizardForm(initial=data) return render_to_response( 'stock_wizard_add.html', { 'form': form }, context_instance=RequestContext(request) )
def _companies_from_json(app, content=''): if 'companies' in content: for obj in content['companies']: user = User.query.filter_by(email=obj['user']).first() if user is None: app.logger.error('Company: %s, Unknown user: %s' % (obj['name'], obj['user'])) break company = Company.query.filter_by(user=user, name=obj['name']).first() if company is None: company = Company() company.user = user company.name = obj['name'] company.description = obj['description'] app.logger.debug('adding company: %s' % company) db.session.add(company) db.session.commit()
def fetch_and_populate_company(name, linkedin_id, callback_url=None, crunchbase_url=None): print 'TASK! fetch company ' + str(name.encode('utf8')) + ', ' + str(linkedin_id) # 1) Try to find company in database by linkedin id or by name if not linkedin_id: # TODO make intelligent disambiguiation based on name return 'Sorry no linkedin id' company = Company.from_linkedin_id(linkedin_id) if not company: print ' linkedin id not found; fetching by name...' company = Company.from_name(name) # 2) fetch it from crunchbase if it doesn't exist or is outdated company_info = None if company: print ' ...company already exists as ' + str(company.name.encode('utf8')) + ', ' + str(company.linkedin_id) if not company.last_crunchbase_update or company.last_crunchbase_update < datetime.now() - timedelta(days=EXPIRATION_DAYS): print ' crunchbase not updated for ' + str(EXPIRATION_DAYS) + ' days => updating' company_info = fetch_company_info_from_crunchbase.delay(company) elif crunchbase_url and company.crunchbase_url != crunchbase_url: print ' new crunchbase url ' + crunchbase_url.encode('utf8') + ' (old was ' + str(company.crunchbase_url) + ')' company.crunchbase_url = crunchbase_url company_info = fetch_company_info_from_crunchbase.delay(company) else: print ' crunchbase updated recently => no crunchbase update necessary' else: print ' ...' + str(name.encode('utf8')) + ', ' + str(linkedin_id) + ' does not exist => new company' company = Company(name, linkedin_id) company.crunchbase_url = crunchbase_url db.session.add(company) company_info = fetch_company_info_from_crunchbase.delay(company) with allow_join_result(): if company_info: print ' waiting for crunchbase result' company_info = company_info.wait() update_company_with_crunchbase_info(company, company_info) db.session.commit() # 3) send back company to the mother ship print 'callback url = ' + str(callback_url) if callback_url: serialize_and_send_company_to_callback_url(company, callback_url) return 'Done?' # TODO return meaningful result
def create(): form = CreateCompanyForm(request.form) if request.method == 'POST' and form.validate(): user = User(document=form.document.data, name=form.username.data, email=form.email.data, password=form.password.data) company = Company.create(nit=form.nit.data, name=form.name.data, user=user) user.put() company.put() app.logger.debug(company) app.logger.debug(user) return render('companies/create.html', form=form)
def bootstrap(app): from app.models import DBSession, Company, User user = User(document=1128417376, name=u'Willington Vega', email=u'*****@*****.**', password=u'password') company = Company.create(nit=9003671435, name=u'Inv. Sinapsis S.A.S', user=user) DBSession.add(user) DBSession.add(company) DBSession.commit() # environ = { # 'path': '/company/create', # 'method': 'POST', # 'data': { # 'nit': '9003671435', # 'name': 'Inv. Sinapsis S.A.S', # 'document': '1128417376', # 'username': '******', # 'email': '*****@*****.**', # 'password': '******', # 'confirm': 'password' # } # }
def test_validate_symbol(self): self.assertTrue(Company.validate_symbol("GOOD")) self.assertFalse(Company.validate_symbol("Bad"))
def db_rebuild(): """ Destroy and rebuild database with fake data. """ # destroy and rebuild tables db.reflect() db.drop_all() db.create_all() # insert roles as defined in model Role.insert_roles() # insert geos and usertypes as defined in model Geo.insert_geos() UserType.insert_user_types() # insert firm types/tiers as defined in model FirmType.insert_firm_types() FirmTier.insert_firm_tiers() # insert fake admin/test users from random import seed import forgery_py seed() test_user_1 = User( email='*****@*****.**', username='******', password='******', confirmed=True, name='Salim Hamed', location='Seattle, WA', about_me=forgery_py.lorem_ipsum.sentence(), member_since=forgery_py.date.date(True) ) test_user_2 = User( email='*****@*****.**', username='******', password='******', confirmed=True, name='Bryan Davis', location='Seattle, WA', about_me=forgery_py.lorem_ipsum.sentence(), member_since=forgery_py.date.date(True) ) test_user_3 = User( email='*****@*****.**', username='******', password='******', confirmed=True, name='Joe Smith', location='San Francisco, CA', about_me=forgery_py.lorem_ipsum.sentence(), member_since=forgery_py.date.date(True) ) test_user_4 = User( email='*****@*****.**', username='******', password='******', confirmed=True, name='Bill Gates', location='Bellevue, WA', about_me=forgery_py.lorem_ipsum.sentence(), member_since=forgery_py.date.date(True) ) admin_user = User( email='*****@*****.**', username='******', password='******', confirmed=True, name='Bill Gates', location='Seattle, WA', about_me=forgery_py.lorem_ipsum.sentence(), member_since=forgery_py.date.date(True) ) db.session.add_all([test_user_1, test_user_2, test_user_3, test_user_4, admin_user]) db.session.commit() # insert fake user data User.generate_fake(60) # insert fake post data Post.generate_fake(400) # insert fake followers Follow.generate_fake(2000) # insert fake firms Firm.generate_fake(5000) # insert fake companies Company.generate_fake(10000) # insert fake relationships Relationship.generate_fake(60000) # print results inspector = db.inspect(db.engine) print 'The following tables were created.' print '-'*17 for table in inspector.get_table_names(): print table
def make_data(): """ Generate some fake data """ Company.generate_fake(3000) Indicators.generate_fake(500)
def get_company_details(throttle=True, count=0, index="NYSE"): """ throttle: true = 1 second wait between requests Count < 1 implies get all index: NYSE or NASDAQ """ import re import time import requests import string from bs4 import BeautifulSoup from app.models import Company, Indicators, Index from app.utils import cash_to_float, depercentize from app import db # Add the index if it doesn't exist if not Index.query.filter(Index.name == index).first(): db.session.add(Index(name=index)) db.session.commit() curr = 0 if count > 0: print "Attempting to pull", count, "companies" else: print "Pull all companies" break_out = False for c in string.uppercase: r = get_symbol_lists(index, c) soup = BeautifulSoup(r.text, "lxml") table = soup.find_all("table", class_="quotes")[0] trs = table.find_all("tr") trs.pop(0) # remove header row for tr in trs: symbol = tr.td.a.text name = tr.td.next_sibling.text print curr, "Add", symbol, name if symbol and name: try: db.session.add(Company.from_json({"name": name, "symbol": symbol, "index": index})) db.session.commit() except (IntegrityError, UnmappedInstanceError) as e: print "Caught", e db.session.rollback() except ValueError as e: print "Invalid company name or symbol" print e db.session.rollback() curr += 1 if count > 0: if curr >= count: break_out = True break if throttle: time.sleep(1) if break_out: break
def test_validate_name(self): self.assertTrue(Company.validate_name("Good Company")) self.assertFalse(Company.validate_name("Bad Company**!"))