def delete(id):
entity = Company.get(id)
if(entity is None):
raise ValueError("Company does not exists")
else:
entity.active = False
Company.save(entity)
def extract_info_from_document(self, document):
for item in document.xpath('.//div[@id="resultList"]/div[@class="el"]'):
job_id = get_simple_dom(item, './/input[@name="delivery_jobid"]/@value')
try:
Job.get(Job.uniqueId == job_id)
continue
except Job.DoesNotExist:
pass
job_url = get_simple_dom(item, './/p[contains(@class, "t1")]/span/a/@href')
company_url = get_simple_dom(item, './/span[contains(@class, "t2")]/a/@href')
company_unique_id = self.get_company_unique_id(company_url)
if not company_unique_id:
continue
try:
company = Company.get(Company.uniqueId == company_unique_id)
company_id = company.id
except Company.DoesNotExist:
company_name = get_simple_dom(item, './/span[@class="t2"]/a/@title')
position = get_simple_dom(item, './/span[@class="t3"]/text()')
try:
company_id = self.extract_company_info(company_url, company_name, position)
except:
print('Company解析error，companyURL为' + company_url)
continue
try:
self.extract_job_info(job_url, job_id, company_id)
except Exception as e:
# import traceback
# traceback.print_exc(e)
# import ipdb;ipdb.set_trace()
print('Job解析error，jobURL为' + job_url)
def get(self, company_id):
parser = reqparse.RequestParser()
parser.add_argument('page_number', type=int)
parser.add_argument('number_of_jobs_per_page', type=int)
parser.add_argument('type')
args = parser.parse_args()
# check company exists
try:
company = Company.get(id=company_id)
except DoesNotExist:
error_dict = {
'error_message':
f'Company with id {company_id} does not exist',
}
LOGGER.error(error_dict)
return error_dict, 400
jobs = company.jobs.where(Job.state != 'DELETED')
if args.get('type') is not None:
if args.get('type') not in JOB_TYPES:
error_dict = {
'error_message': f'Unknown type: {args.get("type")}',
}
LOGGER.error(error_dict)
return error_dict, 400
jobs = jobs.where(Job.type == args.get('type'))
total_jobs = len(jobs)
if args.get('page_number') is not None and args.get(
'number_of_jobs_per_page') is not None:
jobs = jobs.paginate(args.get('page_number'),
args.get('number_of_jobs_per_page'))
return {'total_jobs': total_jobs, 'jobs': jobs}
def get(self, company_id):
try:
return Company.get(id=company_id)
except DoesNotExist:
error_dict = {
'error_message': f'Company with id {company_id} does not exist',
}
LOGGER.error(error_dict)
return error_dict, 400
def get(self, company_id, job_id):
# check company exists
try:
Company.get(id=company_id)
except DoesNotExist:
error_dict = {
'error_message':
f'Company with id {company_id} does not exist',
}
LOGGER.error(error_dict)
return error_dict, 400
try:
return Job.get(id=job_id, company=company_id)
except DoesNotExist:
error_dict = {
'error_message':
f'Job with id `{job_id}` does not exist for company with id {company_id}',
}
LOGGER.error(error_dict)
return error_dict, 400
def test_connection():
"""
Test the connection to database.
:returns: Does the software have access to the database at this time.
:rtype: Boolean
"""
try:
count = Company.get('count')
LOGGER.debug('Company count: {0}'.format(count))
return count > 0
except Exception as excp:
LOGGER.exception('FAILED CONNECTION: {0!s}'.format(excp))
return False
def test_connection():
"""
Test the connection to database.
:returns: Does the software have access to the database at this time.
:rtype: Boolean
"""
try:
count = Company.get('count')
LOGGER.debug('Company count: {0}'.format(count))
return count > 0
except Exception as excp:
LOGGER.exception('FAILED CONNECTION: {0!s}'.format(excp))
return False
def get_company(company_id):
""" Gets a company with the given id
:param company_id: The ID of the company
:type company_id: int
:return: The company if exists
:rtype: Company
:raises: CompanyNotFound
"""
res = Company.get(Company.id == company_id)
if res is None:
raise CompanyNotFound
return res
def add_project(data):
"""
Adds a project to database and returns a project instance
:param data: Project information
:type data: A dictionary
:rtype: an instance of :class:`models.Project`
"""
if 'project' not in data:
return None
if 'company' not in data:
return None
project_data = data['project']
company_data = data['company']
if ('name' not in project_data) or ('name' not in company_data):
return None
project_name = project_data['name']
exists = Project.get('exists', Project.name == project_name)
if exists:
raise ItemAlreadyExistsException('The project exists already!')
company = Company.get('one', Company.name == company_data['name'])
# Parse data.
name = project_data['name']
directory = ''
directory_set = False
if 'dir' in project_data:
directory = project_data['dir']
directory_set = True
password = ''
if 'password' in project_data:
password = project_data['password']
if password:
password = utils.hash_password(password)
directory = utils.get_encrypted_directory_name(name, password)
directory_set = True
project = Project(name, '', company, password)
if directory_set:
project.dir = filesystem.create_project_directory(directory)
else:
project.dir = filesystem.create_project_directory(str(project.id))
if not project.dir:
project.delete()
return None
Project.update(project)
return project
def extract_info_from_document(self, document):
for item in document.xpath('.//div[@id="newlist_list_content_table"]/table[@class="newlist"]'):
job_url = get_simple_dom(item, './/td[@class="zwmc"]/div/a/@href')
job_unique_id = self.get_job_id(job_url)
try:
Job.get(uniqueId=job_unique_id)
continue
except Job.DoesNotExist:
pass
company_url = get_simple_dom(item, './/td[@class="gsmc"]/a/@href')
company_unique_id = self.get_company_unique_id(company_url)
if not company_unique_id:
continue
try:
company = Company.get(Company.uniqueId == company_unique_id, Company.site == self.task.site)
company_id = company.id
except Company.DoesNotExist:
company_name = get_simple_dom(item, './/td[@class="gsmc"]/a/text()')
position = get_simple_dom(item, './/td[@class="gzdd"]/text()')
company_id = self.extract_company_info(company_url, company_name, position)
def test_create_1(self):
test_company_1 = {
'company_name': 'test',
'email': '*****@*****.**',
'password': '******',
'state': 'TEST',
'address_1': 'test',
'city': 'toronto',
'province': 'ON',
'zipcode': 'xxxxxx',
'country': 'canada',
'phone': '123456789'
}
return_result = Company.create(**test_company_1)
self.assertEqual(test_company_1.get('company_name'), return_result.company_name)
self.assertEqual(test_company_1.get('email'), return_result.email)
self.assertEqual(test_company_1.get('password'), return_result.password)
self.assertEqual(test_company_1.get('state'), return_result.state)
self.assertEqual(test_company_1.get('address_1'), return_result.address_1)
self.assertEqual(test_company_1.get('address_2'), return_result.address_2)
self.assertEqual(test_company_1.get('city'), return_result.city)
self.assertEqual(test_company_1.get('province'), return_result.province)
self.assertEqual(test_company_1.get('zipcode'), return_result.zipcode)
self.assertEqual(test_company_1.get('country'), return_result.country)
self.assertEqual(test_company_1.get('phone'), return_result.phone)
get_result = Company.get(id=return_result.id)
self.assertEqual(test_company_1.get('company_name'), get_result.company_name)
self.assertEqual(test_company_1.get('email'), get_result.email)
self.assertEqual(test_company_1.get('password'), get_result.password)
self.assertEqual(test_company_1.get('state'), get_result.state)
self.assertEqual(test_company_1.get('address_1'), get_result.address_1)
self.assertEqual(test_company_1.get('address_2'), get_result.address_2)
self.assertEqual(test_company_1.get('city'), get_result.city)
self.assertEqual(test_company_1.get('province'), get_result.province)
self.assertEqual(test_company_1.get('zipcode'), get_result.zipcode)
self.assertEqual(test_company_1.get('country'), get_result.country)
self.assertEqual(test_company_1.get('phone'), get_result.phone)
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('email', required=True)
parser.add_argument('password', required=True)
login_args = parser.parse_args()
try:
company = Company.get(email=login_args.get('email'))
except DoesNotExist:
error_dict = {
'error_message': 'No company with this email exists',
}
LOGGER.error(error_dict)
return error_dict, 404
is_password_correct = verify_password(company.password, login_args.get('password'))
if is_password_correct:
return company
else:
error_dict = {
'error_message': 'Incorrect password',
}
LOGGER.error(error_dict)
return error_dict, 401
def patch(self, company_id):
parser = reqparse.RequestParser()
parser.add_argument('company_name')
parser.add_argument('email')
parser.add_argument('password')
parser.add_argument('address_1')
parser.add_argument('address_2')
parser.add_argument('city')
parser.add_argument('province')
parser.add_argument('zipcode')
parser.add_argument('country')
parser.add_argument('phone')
parser.add_argument('state')
company_args = {key: val for key, val in parser.parse_args().items() if val is not None}
if len(company_args) == 0:
error_dict = {
'error_message': f'Empty payload',
}
LOGGER.error(error_dict)
return error_dict, 400
if 'state' in company_args and company_args.get('state') not in COMPANY_STATES:
error_dict = {
'error_message': f'Invalid state {company_args.get("state")}',
}
LOGGER.error(error_dict)
return error_dict, 400
try:
company = Company.get(id=company_id)
for key, val in company_args.items():
setattr(company, key, val)
company.save()
return company
except DoesNotExist:
error_dict = {
'error_message': f'Company with id {company_id} does not exist',
}
LOGGER.error(error_dict)
return error_dict, 400
def post(self, company_id):
parser = reqparse.RequestParser()
parser.add_argument('title', required=True)
parser.add_argument('description', required=True)
parser.add_argument('category')
parser.add_argument('state', default='NEW')
parser.add_argument('type', required=True)
parser.add_argument('n_positions', required=True, type=int)
parser.add_argument('duration', required=True)
parser.add_argument('start_date', type=int)
parser.add_argument('expiry_date', type=int)
parser.add_argument('compensation', required=True)
parser.add_argument('city')
job_args = parser.parse_args()
# check company exists
try:
company = Company.get(id=company_id)
except DoesNotExist:
error_dict = {
'error_message':
f'Company with id {company_id} does not exist',
}
LOGGER.error(error_dict)
return error_dict, 400
if company.has_address() is False:
error_dict = {
'error_message':
f'Account for company with id {company_id} does not have an address.',
}
LOGGER.error(error_dict)
return error_dict, 403
if company.is_active() is False:
error_dict = {
'error_message':
f'Account for company with id {company_id} is not active.',
}
LOGGER.error(error_dict)
return error_dict, 403
# check type is valid
if job_args.get('type') not in JOB_TYPES:
error_dict = {
'error_message': f'Unknown type: {job_args.get("type")}',
}
LOGGER.error(error_dict)
return error_dict, 400
# convert timestamps to datetime
# job_args['start_date'] = datetime.datetime.fromtimestamp(job_args.get('start_date'))
# job_args['expiry_date'] = datetime.datetime.fromtimestamp(job_args.get('expiry_date'))
# if city is none use city in address by default
if job_args.get('city') is None or job_args.get('city') == '':
job_args['city'] = company.city
try:
return Job.create(company=company_id, **job_args)
except IntegrityError as e:
error_dict = {
'error_message': e,
}
LOGGER.error(error_dict)
return error_dict, 400
def test_create_2(self):
test_company_1 = {
'company_name': 'test_1',
'email': '*****@*****.**',
'password': '******',
'state': 'TEST',
'address_1': 'test_1',
'city': 'toronto',
'province': 'ON',
'zipcode': 'xxxxxx',
'country': 'canada',
'phone': '123456789'
}
test_company_2 = {
'company_name': 'test_2',
'email': '*****@*****.**',
'password': '******',
'state': 'TEST',
'address_1': 'test_2',
'city': 'waterloo',
'province': 'ON',
'zipcode': 'xxxxxx',
'country': 'canada',
'phone': '987654321'
}
return_result_1 = Company.create(**test_company_1)
self.assertEqual(test_company_1.get('company_name'), return_result_1.company_name)
self.assertEqual(test_company_1.get('email'), return_result_1.email)
self.assertEqual(test_company_1.get('password'), return_result_1.password)
self.assertEqual(test_company_1.get('state'), return_result_1.state)
self.assertEqual(test_company_1.get('address_1'), return_result_1.address_1)
self.assertEqual(test_company_1.get('address_2'), return_result_1.address_2)
self.assertEqual(test_company_1.get('city'), return_result_1.city)
self.assertEqual(test_company_1.get('province'), return_result_1.province)
self.assertEqual(test_company_1.get('zipcode'), return_result_1.zipcode)
self.assertEqual(test_company_1.get('country'), return_result_1.country)
self.assertEqual(test_company_1.get('phone'), return_result_1.phone)
return_result_2 = Company.create(**test_company_2)
self.assertEqual(test_company_2.get('company_name'), return_result_2.company_name)
self.assertEqual(test_company_2.get('email'), return_result_2.email)
self.assertEqual(test_company_2.get('password'), return_result_2.password)
self.assertEqual(test_company_2.get('state'), return_result_2.state)
self.assertEqual(test_company_2.get('address_1'), return_result_2.address_1)
self.assertEqual(test_company_2.get('address_2'), return_result_2.address_2)
self.assertEqual(test_company_2.get('city'), return_result_2.city)
self.assertEqual(test_company_2.get('province'), return_result_2.province)
self.assertEqual(test_company_2.get('zipcode'), return_result_2.zipcode)
self.assertEqual(test_company_2.get('country'), return_result_2.country)
self.assertEqual(test_company_2.get('phone'), return_result_2.phone)
get_result_1 = Company.get(id=return_result_1.id)
self.assertEqual(test_company_1.get('company_name'), get_result_1.company_name)
self.assertEqual(test_company_1.get('email'), get_result_1.email)
self.assertEqual(test_company_1.get('password'), get_result_1.password)
self.assertEqual(test_company_1.get('state'), get_result_1.state)
self.assertEqual(test_company_1.get('address_1'), get_result_1.address_1)
self.assertEqual(test_company_1.get('address_2'), get_result_1.address_2)
self.assertEqual(test_company_1.get('city'), get_result_1.city)
self.assertEqual(test_company_1.get('province'), get_result_1.province)
self.assertEqual(test_company_1.get('zipcode'), get_result_1.zipcode)
self.assertEqual(test_company_1.get('country'), get_result_1.country)
self.assertEqual(test_company_1.get('phone'), get_result_1.phone)
get_result_2 = Company.get(id=return_result_2.id)
self.assertEqual(test_company_2.get('email'), get_result_2.email)
self.assertEqual(test_company_2.get('password'), get_result_2.password)
self.assertEqual(test_company_2.get('state'), get_result_2.state)
self.assertEqual(test_company_2.get('address_1'), get_result_2.address_1)
self.assertEqual(test_company_2.get('address_2'), get_result_2.address_2)
self.assertEqual(test_company_2.get('city'), get_result_2.city)
self.assertEqual(test_company_2.get('province'), get_result_2.province)
self.assertEqual(test_company_2.get('zipcode'), get_result_2.zipcode)
self.assertEqual(test_company_2.get('country'), get_result_2.country)
self.assertEqual(test_company_2.get('phone'), get_result_2.phone)
def get(id):
return Company.get(id)
def save(entity, logo_name, logo_data):
if logo_name:
if logo_name.lower().endswith(('.png')):
pass
else:
raise ValueError("The logo only supports .png extension")
if entity.key is None:
entity.active=True
entity = Company.save(entity)
'''Create Asset Inventory'''
from models import AssetSize
from random import randint
for e in AssetSize:
inventory = AssetInventory()
inventory.populate(
asset_size = AssetSize(int(e)),
company_key = entity.key,
count = randint(1, 10)
)
AssetInventoryService.AssetInventoryInstance.save(inventory)
else:
current = Company.get(entity.key.urlsafe())
if current is not None:
current.name = entity.name
current.domain = entity.domain
current.state = entity.state
current.city = entity.city
current.zipcode = entity.zipcode
current.contact_phone = entity.contact_phone
current.contact_email = entity.contact_email
current.address = entity.address
current.vendor_notes = entity.vendor_notes
current.active = entity.active
current.latitude = entity.latitude
current.longitude = entity.longitude
entity = Company.save(entity)
else:
raise ValueError("Company does not exists")
if logo_name and logo_data:
bucket_name = os.environ.get('BUCKET_NAME', app_identity.get_default_gcs_bucket_name())
path = "/" + bucket_name + "/" + entity.key.urlsafe() + "/" + logo_name
write_retry_params = gcs.RetryParams(backoff_factor=1.1)
gcs_file = gcs.open(path,
'w',
content_type='image/png',
options={'x-goog-meta-foo':'foo',
'x-goog-acl':'public-read',
'x-goog-meta-bar':'bar'},
retry_params=write_retry_params)
gcs_file.write(base64.b64decode(logo_data))
gcs_file.close()
entity.logo_url = config.GOOGLE_CLOUD_STORAGE_BASE_ADDRESS_TO_DOWNLOAD + "/" + bucket_name + "/" + entity.key.urlsafe() + "/" + logo_name
entity = Company.save(entity)
return entity
