def fields_view_get(self,
view_id=None,
view_type='form',
toolbar=False,
submenu=False):
""" Generate view dynamically using attributes stored on the
product.template"""
res = super(ProductConfigurator,
self).fields_view_get(view_id=view_id,
view_type=view_type,
toolbar=toolbar,
submenu=submenu)
wizard_id = self.env.context.get('wizard_id')
if res.get('type') != 'form' or not wizard_id:
return res
wiz = self.browse(wizard_id)
# Get updated fields including the dynamic ones
fields = self.fields_get()
dynamic_fields = {
k: v
for k, v in fields.items() if k.startswith(self.field_prefix)
or k.startswith(self.custom_field_prefix)
}
res['fields'].update(dynamic_fields)
mod_view = self.add_dynamic_fields(res, dynamic_fields, wiz)
# Update result dict from super with modified view
res.update({'arch': etree.tostring(mod_view)})
# set any default values
wiz_vals = wiz.read(dynamic_fields.keys())[0]
dynamic_field_vals = {
k: wiz_vals.get(k, [] if v['type'] == 'many2many' else False)
for k, v in fields.items() if k.startswith(self.field_prefix)
}
domains = {
k: dynamic_fields[k]['domain']
for k in dynamic_field_vals.keys()
}
try:
cfg_step_id = int(wiz.state)
cfg_step = wiz.product_tmpl_id.config_step_line_ids.filtered(
lambda x: x.id == cfg_step_id)
except:
cfg_step = self.env['product.config.step.line']
vals = wiz.get_form_vals(dynamic_field_vals, domains, cfg_step)
if vals:
wiz.write(vals)
return res
def __validate_update_fields(self, fields, product_type):
"""
:param fields:
:param product_type:
:return: results dict with updatable fields filtered and fields analysis results
:rtype: dict
"""
invalid_types = list()
filtered_fields = dict()
if product_type == 'product':
updatable_fields = self.__update_product_fields
else:
updatable_fields = self.__update_variation_fields
for field, value in fields.items():
if field in updatable_fields:
field_type = updatable_fields[field]
if not isinstance(value, field_type):
invalid_types.append(field)
else:
filtered_fields[field] = value
if not fields:
return results.error_result('nothing_to_update')
if invalid_types:
return results.error_result('invalid_field_type',
', '.join(invalid_types))
return results.success_result(filtered_fields)
def run(self, external_id, binding, mapper=None):
self.external_id = external_id
default_lang = self.backend_record.default_lang_id
storeviews = self.env['magento.storeview'].search([
('backend_id', '=', self.backend_record.id),
('lang_id', '!=', False), ('lang_id', '!=', default_lang.id)
])
if not storeviews:
return
lang2storeview = dict(
(storeview.lang_id, storeview) for storeview in storeviews)
# find the translatable fields of the model
fields = self.model.fields_get()
translatable_fields = [
field for field, attrs in list(fields.items())
if attrs.get('translate')
]
if mapper is None:
mapper = self.mapper
else:
mapper = self.component_by_name(mapper)
for storeview in lang2storeview.values():
lang_record = self._get_magento_data(storeview)
map_record = mapper.map_record(lang_record)
record = map_record.values()
data = dict((field, value) for field, value in list(record.items())
if field in translatable_fields)
binding.with_context(connector_no_export=True,
lang=storeview.lang_id.code).write(data)
def create_partner(self, message_id, relation, partner_id,
message_name_from, message_email_from):
model = self.env[relation]
message = self.env['mail.message'].browse(message_id)
if not partner_id and message_name_from:
partner_id = self.env['res.partner'].with_context({
'update_message_author':
True
}).create({
'name': message_name_from,
'email': message_email_from
}).id
context = {'partner_id': partner_id}
if model._rec_name:
context.update({'default_%s' % model._rec_name: message.subject})
fields = model.fields_get()
contact_field = False
for n, f in fields.items():
if f['type'] == 'many2one' and f['relation'] == 'res.partner':
contact_field = n
break
if contact_field:
context.update({'default_%s' % contact_field: partner_id})
return context
def fields_view_get(self,
view_id=None,
view_type='form',
toolbar=False,
submenu=False):
""" Generate view dynamically using attributes stored on the
product.template"""
res = super(ProductConfigurator,
self).fields_view_get(view_id=view_id,
view_type=view_type,
toolbar=toolbar,
submenu=submenu)
wizard_id = self.env.context.get('wizard_id')
if res.get('type') != 'form' or not wizard_id:
return res
wiz = self.browse(wizard_id)
# Get updated fields including the dynamic ones
fields = self.fields_get()
dynamic_fields = {
k: v
for k, v in fields.items() if k.startswith(self.field_prefix)
or k.startswith(self.custom_field_prefix)
}
res['fields'].update(dynamic_fields)
mod_view = self.add_dynamic_fields(res, dynamic_fields, wiz)
# Update result dict from super with modified view
res.update({'arch': etree.tostring(mod_view)})
return res
def _update_res_partner_fields(self):
fields = self.env['res.partner'].fields_get()
for k, v in fields.items():
name = v.get('string', None)
field = k
if name:
exists = self.env['res.partner.fields'].search([('name', '=', name), ('field', '=', field)])
if not exists:
self.env['res.partner.fields'].create({'name': name, 'field': field})
def get_fields(self):
context = self.env.context
if 'active_id' in context:
id_num = context['active_id']
conf = self.env['brdc.transaction.acct.conf'].search([('id', '=',
id_num)])
model = conf[0].model_reference
fields = self.env[model].fields_get()
return [(k, v['string']) for k, v in fields.items()]
def prop_to_exp(self):
fields = self.env['pie.build.draft'].fields_get()
sorted_x = sorted(fields.items(), key=operator.itemgetter(1))
res=[]
blacklisted = ['create_date','write_uid','id','supplier_id','current_user','create_uid','is_secondary','write_date','active','is_primary','__last_update','has_errors','import_id','sharing_level','name','supplier']
for k, v in sorted_x:
if not k in blacklisted:
res.append((k, v['string']))
_logger.warn(res)
#sorted_x = sorted(res.items(), key=operator.itemgetter(1))
return res
def fields_view_get(self,
view_id=None,
view_type="form",
toolbar=False,
submenu=False):
"""Generate view dynamically using attributes stored on the
product.template"""
if view_type == "form" and not view_id:
view_ext_id = "product_configurator.product_configurator_form"
view_id = self.env.ref(view_ext_id).id
res = super(ProductConfigurator, self).fields_view_get(
view_id=view_id,
view_type=view_type,
toolbar=toolbar,
submenu=submenu,
)
wizard_id = self.env.context.get("wizard_id")
if res.get("type") != "form" or not wizard_id:
return res
wiz = self.browse(wizard_id)
# Get updated fields including the dynamic ones
fields = self.fields_get()
# Include all dynamic fields in the view
dynamic_field_prefixes = tuple(self._prefixes.values())
dynamic_fields = {
k: v
for k, v in fields.items() if k.startswith(dynamic_field_prefixes)
}
res["fields"].update(dynamic_fields)
mod_view = self.add_dynamic_fields(res, dynamic_fields, wiz)
# Update result dict from super with modified view
res.update({"arch": etree.tostring(mod_view)})
return res
def on_change_partner(self):
domain = {"res_id": [("id", "!=", self.message_id.res_id)]}
if self.model and self.filter_by_partner and self.partner_id:
fields = self.env[self.model].fields_get(False)
contact_field = False
for n, f in fields.items():
if f["type"] == "many2one" and f["relation"] == "res.partner":
contact_field = n
break
if contact_field:
domain["res_id"].append(
(contact_field, "=", self.partner_id.id))
if self.model:
res_id = self.env[self.model].search(domain["res_id"],
order="id desc",
limit=1)
self.res_id = res_id and res_id[0].id
else:
self.res_id = None
return {"domain": domain}
def on_change_partner(self):
domain = {'res_id': [('id', '!=', self.message_id.res_id)]}
if self.model and self.filter_by_partner and self.partner_id:
fields = self.env[self.model].fields_get(False)
contact_field = False
for n, f in fields.items():
if f['type'] == 'many2one' and f['relation'] == 'res.partner':
contact_field = n
break
if contact_field:
domain['res_id'].append(
(contact_field, '=', self.partner_id.id))
if self.model:
res_id = self.env[self.model].search(domain['res_id'],
order='id desc',
limit=1)
self.res_id = res_id and res_id[0].id
else:
self.res_id = None
return {'domain': domain}
def validate_address(self):
self.validated_dir = True # Validate the address to not break with flow
listFields = [] # Dictionary to control all fields of address
fields = {
'Street': self.partner_shipping_id.street,
'Zip': self.partner_shipping_id.zip,
'City': self.partner_shipping_id.city,
'State': self.partner_shipping_id.state_id.id,
'Country': self.partner_shipping_id.country_id.id
}
if not all(fields.values()):
warning = _(
'The address is incorrect, the following fields are empty:\n'
) # warning message
for key, value in fields.items(): # Rebuilt the list of fields
if not value:
listFields.append(_(key))
warning += ', '.join(listFields) # Separate by commas
self.env.user.notify_warning(message=warning, sticky=True)
def getDomain(self, fields, action):
domains = [(k, '=', v.id) for k, v in fields.items() if v]
if domains:
action['domain'] = domains
return action
