def create_proc():
"""Create new Procedure."""
form = CreateProcedureForm(request.form)
validated = form.validate_on_submit()
if validated:
kwargs = {
'name': form.name.data,
'owner': form.owner.data,
'project': form.project.data
}
procedure = Procedure.create(**kwargs)
part_ids = [] if request.form['parts'] == '' else request.form[
'parts'].split(',')
vendor_part_ids = [] if request.form[
'vendor_parts'] == '' else request.form['vendor_parts'].split(',')
for part_id in part_ids:
part = Part.get_by_id(part_id)
procedure.parts.append(part)
for vendor_part_id in vendor_part_ids:
part = VendorPart.get_by_id(vendor_part_id)
procedure.vendor_parts.append(part)
procedure.save()
jsonData = {'success': True, 'url': procedure.get_url()}
return jsonify(jsonData), 200, {'ContentType': 'application/json'}
else:
part_ids = [] if request.form['parts'] == '' else request.form[
'parts'].split(',')
vendor_part_ids = [] if request.form[
'vendor_parts'] == '' else request.form['vendor_parts'].split(',')
parts = []
vendor_parts = []
for part_id in part_ids:
part = Part.get_by_id(part_id)
parts.append(part)
for vendor_part_id in vendor_part_ids:
part = VendorPart.get_by_id(vendor_part_id)
vendor_parts.append(part)
variables = {
'vendor_parts': vendor_parts,
'parts': parts,
'current_part_ids': request.form['parts'],
'current_vendor_part_ids': request.form['vendor_parts'],
'form': form
}
return make_response(
render_template('procedure/create_procedure.html', **variables),
500)
def add_extra_product_component():
form = AddExtraProductComponentForm(request.form)
validated = form.validate_on_submit()
if validated:
quantity = form.quantity.data
part_group = form.part_group.data
part_id = form.part_id.data
product_id = form.product_id.data
product = Product.get_by_id(product_id)
ordering = len(product.extra_components) + 1
if part_group == 'Part': # part_group from typeahead group, not class name
part = Part.get_by_id(part_id)
for i in range(quantity):
epc = ExtraProductComponent.create(parent=product, part=part, ordering=ordering)
elif part_group == 'Vendor Part': # part_group from typeahead group, not class name
vendor_part = VendorPart.get_by_id(part_id)
for i in range(quantity):
epc = ExtraProductComponent.create(parent=product, vendor_part=vendor_part, ordering=ordering)
components_array = arrange_product_components(product)
extra_components_array = arrange_extra_product_components(product)
variables = {
'success': True,
'product': product,
'components_array': components_array,
'extra_components_array': extra_components_array
}
new_value = '{0} - Quantity: {1}'.format(epc.get_part().get_descriptive_url(), quantity)
product.add_change_log_entry(action='Add', field='Extra Component', new_value=new_value)
return render_template('product/as-built/component_list.html', **variables)
else:
product_id = form.product_id.data
product = Product.get_by_id(product_id)
part = None
if form.part_id.data:
part_group = form.part_group.data
part_id = form.part_id.data
if part_group == 'Part': # part_group from typeahead, not class name
part = Part.get_by_id(part_id)
elif part_group == 'Vendor Part': # part_group from typeahead, not class name
part = VendorPart.get_by_id(part_id)
variables = {
'form': form,
'product': product,
'part': part
}
response = make_response(render_template('product/add_product_component_modal.html', **variables), 500)
return response
def get_anomaly_modal():
form = CreateAnomalyForm(request.form)
variables = {
'form': form,
'designs': [],
'vendor_parts': [],
'as_runs': []
}
record_id = request.form.get('record_id', None)
record_class = request.form.get('record_class', None)
if record_id:
if record_class == Design.get_class_name():
variables['designs'] = [Design.get_by_id(record_id)]
form.affected.data = 'design'
elif record_class == VendorPart.get_class_name():
variables['vendor_parts'] = [VendorPart.get_by_id(record_id)]
form.affected.data = 'design'
elif record_class == AsRun.get_class_name():
variables['as_runs'] = [AsRun.get_by_id(record_id)]
form.affected.data = 'asrun'
return render_template('anomaly/create_anomaly.html', **variables)
def remove_design():
anomaly_id = request.values['anomaly_id']
anomaly = Anomaly.get_by_id(anomaly_id)
design_id = request.values['design_id']
design_class = request.values['design_class']
record = None
if design_class == 'design':
record = Design.get_by_id(design_id)
anomaly.designs.remove(record)
elif design_class == 'vendorpart':
record = VendorPart.get_by_id(design_id)
anomaly.vendor_parts.remove(record)
anomaly.add_change_log_entry(action='Remove', field='Design/Part', original_value=record.get_descriptive_url())
anomaly.save()
return jsonify({'success': True}), 200, {'ContentType': 'application/json'}
def remove_part():
procedure_id = request.form.get('procedure_id')
part_type = request.form.get('part_type')
part_id = request.form.get('part_id')
proc = Procedure.get_by_id(procedure_id)
part = None
if part_type == "designs":
part = Part.get_by_id(part_id)
proc.parts.remove(part)
elif part_type == "vendor_parts":
part = VendorPart.get_by_id(part_id)
proc.vendor_parts.remove(part)
proc.add_change_log_entry(action='Remove',
field='Part',
original_value=part.get_descriptive_url())
proc.save()
jsonData = {'success': True, 'partId': part_id}
return jsonify(jsonData), 200, {'ContentType': 'application/json'}
def get_record_by_id_and_class(record_id, record_class):
# TODO: Try to find a better way that doesn't involve so much dynamic loading
record = None
record_class = record_class.lower() # Just in case
if record_class == 'anomaly':
from pid.anomaly.models import Anomaly
record = Anomaly.get_by_id(record_id)
elif record_class == 'asrun':
from pid.asrun.models import AsRun
record = AsRun.get_by_id(record_id)
elif record_class == 'build':
from pid.product.models import Build
record = Build.get_by_id(record_id)
elif record_class == 'design':
from pid.design.models import Design
record = Design.get_by_id(record_id)
elif record_class == 'eco':
from pid.eco.models import ECO
record = ECO.get_by_id(record_id)
elif record_class == 'part':
from pid.part.models import Part
record = Part.get_by_id(record_id)
elif record_class == 'procedure':
from pid.procedure.models import Procedure
record = Procedure.get_by_id(record_id)
elif record_class == 'product':
from pid.product.models import Product
record = Product.get_by_id(record_id)
elif record_class == 'specification':
from pid.specification.models import Specification
record = Specification.get_by_id(record_id)
elif record_class == 'task':
from pid.task.models import Task
record = Task.get_by_id(record_id)
elif record_class == 'vendorbuild':
from pid.vendorproduct.models import VendorBuild
record = VendorBuild.get_by_id(record_id)
elif record_class == 'vendorpart':
from pid.vendorpart.models import VendorPart
record = VendorPart.get_by_id(record_id)
elif record_class == 'vendorproduct':
from pid.vendorproduct.models import VendorProduct
record = VendorProduct.get_by_id(record_id)
return record
def add_design():
anomaly_id = request.values['anomaly_id']
design_id = request.values['design_id']
vendor_part_id = request.values['vendor_part_id']
anomaly = Anomaly.get_by_id(anomaly_id)
record = None
if design_id:
record = Design.get_by_id(design_id)
anomaly.designs.append(record)
elif vendor_part_id:
record = VendorPart.get_by_id(vendor_part_id)
anomaly.vendor_parts.append(record)
anomaly.add_change_log_entry(action='Add', field='Design/Part', new_value=record.get_descriptive_url())
anomaly.save()
variables = {
'anomaly': anomaly,
'design': record
}
return render_template('anomaly/anomaly_design_row.html', **variables)
def add_part():
procedure_id = request.form.get('procedure_id')
record_id = request.form.get('record_id')
record_class = request.form.get('record_class')
proc = Procedure.get_by_id(procedure_id)
part = None
if record_class == "part":
part = Part.get_by_id(record_id)
proc.parts.append(part)
elif record_class == "vendorpart":
part = VendorPart.get_by_id(record_id)
proc.vendor_parts.append(part)
proc.add_change_log_entry(action='Add',
field='Part',
new_value=part.get_descriptive_url())
proc.save()
return render_template('procedure/procedure_part.html',
part=part,
proc=proc)
def get_procedure_modal():
form = CreateProcedureForm(request.form)
vendor_parts = []
parts = []
table = request.form.get('table', None)
part_id = request.form.get('part_id', None)
if table:
if table == 'vendor_parts':
vendor_parts.append(VendorPart.get_by_id(part_id))
elif table == 'designs':
parts.append(Part.get_by_id(part_id))
variables = {
'vendor_parts': vendor_parts,
'parts': parts,
'current_part_ids': ','.join([str(x.id) for x in parts]),
'current_vendor_part_ids': ','.join([str(x.id) for x in vendor_parts]),
'form': form
}
return render_template('procedure/create_procedure.html', **variables)
def dashboard():
user = current_user
# TODO: Add prefix option to forms so form field ids are unique
anomalies_for_user = Anomaly.find_all_anomalies_for_user(user)
as_runs_for_user = AsRun.find_all_as_runs_for_user(user)
designs_for_user = Design.find_all_designs_for_user(user)
ecos_for_user = ECO.find_all_ecos_for_user(user)
products_for_user = Product.find_all_products_for_user(user)
vendor_products_for_user = VendorProduct.find_all_vendor_products_for_user(
user)
vendor_parts_for_user = VendorPart.find_all_vendor_parts_for_user(user)
procedures_for_user = Procedure.find_all_distinct_procedures_for_user(user)
specifications = Specification.find_all_distinct_specifications()
records_awaiting_approval = []
for record_list in [
anomalies_for_user, as_runs_for_user, designs_for_user,
ecos_for_user, procedures_for_user, products_for_user,
specifications, vendor_parts_for_user, vendor_products_for_user
]:
for record in record_list:
if record.state == record.workflow.get_approval_state():
records_awaiting_approval.append(record)
variables = {
'anomalies_for_user': anomalies_for_user,
'designs_for_user': designs_for_user,
'ecos_for_user': ecos_for_user,
'products_for_user': products_for_user,
'vendor_products_for_user': vendor_products_for_user,
'vendor_parts_for_user': vendor_parts_for_user,
'procedures_for_user': procedures_for_user,
'specifications': specifications,
'users': User.query.all(),
'bookmarks': process_bookmarks(user),
'saved_searches': user.saved_searches,
'settings': Settings.get_settings(),
'approvals': Approver.get_open_approvals_for_user(user),
'records_awaiting_approval': records_awaiting_approval
}
return render_template('backend/dashboard.html', **variables)
def validate(self):
"""Validate the form."""
initial_validation = super(CreateVendorBuildForm, self).validate()
errors = False
data = {}
if not initial_validation:
errors = True
vendor_part = VendorPart.get_by_id(self.vendor_part_id.data)
existing_serial_numbers = VendorProduct.get_serial_numbers_for_vendor_part(vendor_part)
if self.product_type.data == 's/n':
# TODO: Try to move some of this to an external function, very messy now
return_serial_numbers = []
# TODO: Improve these replaces
serial_numbers = self.serial_numbers.data.strip().replace(' , ', ',').replace(', ', ',').replace(' ,', ',').replace(' ', ',') # In case user uses space instead of comma
if len(serial_numbers) == 0:
self.serial_numbers.errors.append('No S/N(s) entered')
errors = True
else:
# First check for comma separated serial_numbers
if ',' in serial_numbers:
serial_numbers_array = serial_numbers.split(',')
for sn in serial_numbers_array:
if sn in existing_serial_numbers:
self.serial_numbers.errors.append('S/N {0} already exists'.format(sn))
errors = True
else:
return_serial_numbers.append(sn)
# Only one S/N present most likely, just append it
else:
if serial_numbers in existing_serial_numbers:
self.serial_numbers.errors.append('S/N {0} already exists'.format(serial_numbers))
errors = True
else:
return_serial_numbers.append(serial_numbers)
data['serial_numbers'] = return_serial_numbers
elif self.product_type.data == 'lot':
return_lot_record = None
lot_record = self.lot_record.data.strip()
if len(lot_record) == 0:
self.lot_record.errors.append('No LOT record entered')
errors = True
else:
return_lot_record = lot_record
if lot_record in existing_serial_numbers:
self.lot_record.errors.append('LOT record {0} already exists'.format(lot_record))
errors = True
else:
data['lot_record'] = return_lot_record
elif self.product_type.data == 'stock':
# TODO: Check if STCK already exists
if 'STCK' in existing_serial_numbers:
self.product_type.errors.append('STCK already exists')
errors = True
else:
data['is_stock'] = True
if errors:
return False, None
return True, data
def create_anomaly():
"""Create new anomaly."""
form = CreateAnomalyForm(request.form)
validated = form.validate_on_submit()
if validated:
variables = {
'name': form.name.data,
'criticality': form.criticality.data,
'owner': form.owner.data,
'anomaly_type': form.affected.data
}
anomaly = Anomaly.create(**variables)
if form.affected.data == 'design':
for design_id in form.designs.data.split(','):
design = Design.get_by_id(design_id)
if design != None:
anomaly.designs.append(design)
design.anomalies.append(anomaly)
design.save()
for vendor_part_id in form.vendor_parts.data.split(','):
vendor_part = VendorPart.get_by_id(vendor_part_id)
if vendor_part != None:
anomaly.vendor_parts.append(vendor_part)
vendor_part.anomalies.append(anomaly)
vendor_part.save()
anomaly.save()
elif form.affected.data == 'asrun':
for as_run_id in form.as_runs.data.split(','):
as_run = AsRun.get_by_id(as_run_id)
if as_run != None:
anomaly.as_runs.append(as_run)
as_run.anomalies.append(anomaly)
as_run.save()
anomaly.save()
jsonData = {
'success': True,
'url': anomaly.get_url()
}
return jsonify(jsonData), 200, {'ContentType': 'application/json'}
else:
designs = []
vendor_parts = []
as_runs = []
print(form.designs.data)
for design_id in form.designs.data.split(','):
design = Design.get_by_id(design_id)
if design != None:
designs.append(design)
for vendor_part_id in form.vendor_parts.data.split(','):
vendor_part = VendorPart.get_by_id(vendor_part_id)
if vendor_part != None:
vendor_parts.append(vendor_part)
for as_run_id in form.as_runs.data.split(','):
as_run = AsRun.get_by_id(as_run_id)
if as_run != None:
as_runs.append(as_run)
variables = {
'form': form,
'designs': designs,
'vendor_parts': vendor_parts,
'as_runs': as_runs
}
return make_response(render_template('anomaly/create_anomaly.html', **variables), 500)
def create_vendor_build():
"""Create new VendorBuild. Also creates one or more VendorProducts."""
form = CreateVendorBuildForm(request.form)
if request.method == 'GET':
vendor_part = VendorPart.get_by_id(request.args.get('vendor_part_id'))
existing_build_id = request.args.get('existing_build_id')
if existing_build_id:
existing_build = VendorBuild.get_by_id(existing_build_id)
build_identifier = existing_build.build_identifier
else:
build_identifier = VendorBuild.get_next_build_identifier_for_vendor_part(vendor_part)
lot_identifier = VendorProduct.get_next_lot_number_for_vendor_part(vendor_part)
existing_serial_numbers = ','.join(VendorProduct.get_serial_numbers_for_vendor_part(vendor_part))
# Pre-populate with values from vendor_part
form.project.data = vendor_part.project
form.vendor.data = vendor_part.vendor
form.manufacturer.data = Company.get_company_by_name('N/A')
variables = {
'form': form,
'vendor_part': vendor_part,
'build_identifier': build_identifier,
'lot_identifier': lot_identifier,
'existing_serial_numbers': existing_serial_numbers,
'existing_build_id': existing_build_id
}
return render_template('vendorproduct/create_vendor_build_modal.html', **variables)
validated, data = form.validate_on_submit()
if validated:
vendor_part = VendorPart.get_by_id(form.vendor_part_id.data)
vendor = vendor_part.vendor
manufacturer = form.manufacturer.data
owner = form.owner.data
build_identifier = form.build_identifier.data
# Create build
if form.existing_build_id.data:
build = VendorBuild.get_by_id(form.existing_build_id.data)
else:
build = VendorBuild.create(vendor_part=vendor_part, vendor=vendor, manufacturer=manufacturer,
owner=owner, build_identifier=build_identifier)
# For each s/n in s/n, create product
summary = vendor_part.summary
hardware_type = form.hardware_type.data
project = form.project.data
# Create serial numbers
serial_numbers = data.get('serial_numbers', [])
for sn in serial_numbers:
product = VendorProduct.create(serial_number=sn, vendor_part=vendor_part, vendor_build=build,
summary=summary, hardware_type=hardware_type,
project=project, owner=owner)
# Or create LOT product
lot_record = data.get('lot_record', None)
if lot_record:
product = VendorProduct.create(serial_number=lot_record, vendor_part=vendor_part, vendor_build=build,
summary=summary, hardware_type=hardware_type, product_type='LOT',
project=project, owner=owner)
# Or create STOCK product
is_stock = data.get('is_stock', False)
if is_stock:
product = VendorProduct.create(serial_number='STCK', vendor_part=vendor_part, vendor_build=build,
summary=summary, hardware_type=hardware_type, product_type='STOCK',
project=project, owner=owner)
jsonData = {
'success': True,
'product_number': product.product_number.replace(' ', '-'), # Slugify product_number
'url': product.get_url()
}
return jsonify(jsonData), 200, {'ContentType': 'application/json'}
else:
vendor_part = VendorPart.get_by_id(request.form['vendor_part_id'])
build_identifier = VendorBuild.get_next_build_identifier_for_vendor_part(vendor_part)
lot_identifier = VendorProduct.get_next_lot_number_for_vendor_part(vendor_part)
existing_serial_numbers = ','.join(VendorProduct.get_serial_numbers_for_vendor_part(vendor_part))
variables = {
'form': form,
'vendor_part': vendor_part,
'build_identifier': build_identifier,
'lot_identifier': lot_identifier,
'existing_serial_numbers': existing_serial_numbers
}
response = make_response(render_template('vendorproduct/create_vendor_build_modal.html', **variables), 500)
return response