def check_col_index_match_xl_title_for_a_field(field_attr, xl_title, col_index,
set_val, key_tram, needdata,
field_name, func):
# if field_attr.get('model'):
# if (xl_title or col_index):
# raise UserError(u'có model thì không cần xl title')
if xl_title and col_index == None and set_val == None:
sheet_allow_this_field_not_has_exel_col = get_key(
field_attr, 'sheet_allow_this_field_not_has_exel_col')
skip_field_if_not_found_column_in_some_sheet = get_key(
field_attr, 'skip_field_if_not_found_column_in_some_sheet')
skip_if_not_match = skip_field_if_not_found_column_in_some_sheet or (
sheet_allow_this_field_not_has_exel_col and needdata['sheet_name']
in sheet_allow_this_field_not_has_exel_col)
if not skip_if_not_match:
# raise UserError(u'có khai báo xl_title nhưng không match với file excel, field: %s, xl_title: %s -- attr%s' %(field_name,xl_title,field_attr))
raise UserError(
_(u'Excel not has column one in %s of %s, please change column name match with them'
) % (xl_title, field_name))
if xl_title == None and col_index == None and set_val == None:
if field_attr.get('model'):
if not func and not field_attr.get('fields'):
raise UserError(u'model thì phải có ít nhất func và fields')
else:
if not func:
raise UserError(
u' sao khong có col_index và không có func luôn field %s attrs %s'
% (field_name, u'%s' % field_attr))
def add_col_index(MODEL_DICT, read_excel_value_may_be_title, col, key_tram):
is_map_xl_title = False
for field, field_attr in MODEL_DICT.get('fields').items():
is_real_xl_match_with_xl_excel = False
xl_title = get_key(field_attr, 'xl_title')
if get_key(field_attr, 'set_val') != None:
continue
if xl_title == None and get_key(field_attr, 'col_index') != None:
continue # cos col_index
elif field_attr.get('fields'):
is_real_xl_match_with_xl_excel = add_col_index(
field_attr, read_excel_value_may_be_title, col, key_tram)
elif xl_title:
if isinstance(xl_title, list):
xl_title_s = xl_title
else:
xl_title_s = [xl_title]
for xl_title in xl_title_s:
xl_title_partern = u'^%s$' % xl_title
# xl_title_partern = xl_title
# xl_title_partern = xl_title_partern.replace('/','//').replace('(','/(').replace(')','/)')
xl_title_partern = xl_title_partern.replace(
'\\', '\\\\').replace('(', '\(').replace(')', '\)')
is_map = re.search(xl_title_partern,
read_excel_value_may_be_title,
re.IGNORECASE)
is_map = is_map or (xl_title == read_excel_value_may_be_title)
if is_map:
field_attr['col_index'] = col
is_real_xl_match_with_xl_excel = True
is_map_xl_title = is_map_xl_title or is_real_xl_match_with_xl_excel
return is_map_xl_title #or is_map_xl_title_foreinkey
def xuat_het_dac_tinh(COPY_MODEL_DICT, key_tram, dac_tinhs={}):
fields = COPY_MODEL_DICT['fields']
for field, field_attr in fields.items():
for attr, val in field_attr.items():
a_dt_list = dac_tinhs.setdefault(attr, [])
val = get_key(field_attr, attr)
if val not in a_dt_list:
a_dt_list.append(val)
if 'fields' in field_attr:
xuat_het_dac_tinh(field_attr, key_tram, dac_tinhs)
def recursive_add_model_name_to_field_attr(self, MODEL_DICT, key_tram=False):
model_name = get_key(MODEL_DICT, 'model')
fields = self.env[model_name]._fields
for f_name, field_attr in MODEL_DICT.get('fields').items():
f_name = get_key(field_attr, 'transfer_name') or f_name
skip_this_field = get_key(field_attr, 'skip_this_field', False)
if callable(skip_this_field):
skip_this_field = skip_this_field(self)
if not skip_this_field:
if f_name not in fields and not field_attr.get(
'for_excel_readonly'):
raise UserError(
u'f_name:"%s" không nằm trong fields, phải thêm thược tính for_excel_readonly-field_attr:%s'
% (f_name, field_attr))
if not field_attr.get(
'for_excel_readonly'): # and not skip_this_field
try:
field = fields[f_name]
except:
raise UserError(
u'field %s không có trong danh sách fields của model %s'
% (f_name, model_name))
field_attr['field_type'] = field.type
if field.comodel_name:
field_attr['model'] = field.comodel_name
if 'required' not in field_attr:
required_from_model = field.required
required_force = field_attr.get('required_force', None)
# bypass_this_field_if_value_equal_False = field_attr.get('bypass_this_field_if_value_equal_False') # nó tự default là gì đó
# if bypass_this_field_if_value_equal_False:
# required = False
# else:
if required_force:
required = True
else:
required = required_from_model
field_attr['required'] = required
if field_attr.get('fields'):
recursive_add_model_name_to_field_attr(self,
field_attr,
key_tram=key_tram)
def check_col_index_match_xl_title(self, COPY_MODEL_DICT, key_tram, needdata):
for field_name, field_attr in COPY_MODEL_DICT.get('fields').items():
skip_this_field = get_key(field_attr, 'skip_this_field', False)
if callable(skip_this_field):
skip_this_field = skip_this_field(self)
if not skip_this_field:
col_index = get_key(field_attr, 'col_index', None)
xl_title = get_key(
field_attr,
'xl_title') #moi them , moi bo field_attr.get('xl_title')
### deal set_val ########
set_val = get_key(field_attr, 'set_val')
if callable(set_val):
set_val = set_val(self)
field_attr['set_val'] = set_val
func = get_key(field_attr, 'func')
check_col_index_match_xl_title_for_a_field(field_attr, xl_title,
col_index, set_val,
key_tram, needdata,
field_name, func)
child_fields = field_attr.get('fields')
if child_fields:
check_col_index_match_xl_title(self, field_attr, key_tram,
needdata)
def write_get_or_create_title(model_dict, sheet, sheet_of_copy_wb, title_row,
key_tram):
fields = model_dict['fields']
# print ('fields',fields)
for fname, attr in fields.items():
# childrend_model_dict = attr
# childrend_fields = attr.get('fields')
if attr.get('fields'):
write_get_or_create_title(attr, sheet, sheet_of_copy_wb, title_row,
key_tram)
offset_write_xl = get_key(attr, 'offset_write_xl')
if offset_write_xl != None:
col = sheet.ncols + offset_write_xl
title = attr.get('string', fname) + u' sẵn hay tạo'
sheet_of_copy_wb.col(col).width = get_width(len(title))
sheet_of_copy_wb.write(title_row, col, title, header_bold_style)
def get_or_create_object_sosanh(self, class_name, search_dict,
write_dict ={},is_must_update=False, noti_dict=None,
inactive_include_search = False,
model_dict = {},
key_tram = None,
# only_search = False,
exist_val=False,
# search_func_para={},
setting = {},
check_file=False,
is_search = True,
is_create = True,
is_write = True,
# instance_some_dict={}
):
search_dict_new = {}
write_dict_new = {}
if noti_dict !=None:
this_model_noti_dict = noti_dict.setdefault(class_name,{})
# is_search = True
# if only_search:
# is_create = False
# is_write = False
#
# else:
# if exist_val:
# is_create = False
# is_write = True
# else:
# is_create = True
# is_write = True
if is_search:
this_model_noti_dict['search'] = this_model_noti_dict.get('search',0) + 1
search_func = model_dict.get('search_func')
if search_func:
searched_object = search_func(model_dict,self,exist_val,setting)
if not searched_object and is_create:
for f_name in search_dict:
field_attr = model_dict['fields'][f_name]
val = search_dict[f_name]
f_name = get_key(field_attr, 'transfer_name') or f_name
search_dict_new[f_name] = val
else:
if inactive_include_search:
domain_not_active = ['|',('active','=',True),('active','=',False)]
else:
domain_not_active = []
domain = []
break_condition = False
for f_name in search_dict:
field_attr = model_dict['fields'][f_name]
val = search_dict[f_name]
# if only_search and val == None:
# return None,None
if val == None:
if check_file:
searched_object,get_or_create = None,False
break_condition = True
break
else:
raise UserError(u'val không thể bằng None')
f_name = get_key(field_attr, 'transfer_name') or f_name
operator_search = field_attr.get('operator_search','=')
tuple_in = (f_name, operator_search, val)
domain.append(tuple_in)
if is_create:
search_dict_new[f_name] = val
if not break_condition:
domain = expression.AND([domain_not_active, domain])
searched_object = self.env[class_name].search(domain)
return_obj = searched_object
get_or_create = bool(searched_object)
if get_or_create:
this_model_noti_dict['search_yes'] = this_model_noti_dict.get('search_yes',0) + 1
else:
this_model_noti_dict['search_no'] = this_model_noti_dict.get('search_no',0) + 1
else:
return_obj = None
get_or_create = None
if is_create:
if not searched_object :#create
only_get = get_key(model_dict,'only_get')
if only_get:
raise UserError(u'Model %s này chỉ được get chứ không được tạo'%class_name)
for f_name,val in write_dict.items():
field_attr = model_dict['fields'][f_name]
f_name = get_key(field_attr, 'transfer_name') or f_name
search_dict_new[f_name]=val
created_object = self.env[class_name].create(search_dict_new)
this_model_noti_dict['create'] = this_model_noti_dict.get('create', 0) + 1
return_obj = created_object
return return_obj,get_or_create
allow_write_all_field = setting['allow_write']
if is_write :
if exist_val:
searched_object = exist_val
if searched_object :# write
if len(searched_object) > 1:
raise UserError (u' exist_val: %s len(searched_object) > 1, searched_object: %s'%(exist_val,searched_object))
for f_name,val in write_dict.items():
field_attr = model_dict['fields'][f_name]
f_name = get_key(field_attr, 'transfer_name') or f_name
if 'write_field' in field_attr and field_attr['write_field'] != None :
write_field = field_attr['write_field']
else:
write_field = allow_write_all_field
# allow_write_from_False_to_not_false = field_attr.get('allow_write_from_False_to_not_false',True)
allow_write_from_False_to_not_false = field_attr.get('allow_write_from_False_to_not_false') if 'allow_write_from_False_to_not_false' in field_attr else setting['allow_write_from_False_to_not_false']
if allow_write_all_field and write_field == False and val ==False:
if allow_write_from_False_to_not_false:
write_field = True
print ('class_name',write_field)
write_func = field_attr.get('write_func')
if write_func:
code = write_func(searched_object=searched_object, f_name=f_name,val=val)
if code =='continue':
continue
raise_if_diff = field_attr.get('raise_if_diff')
if raise_if_diff:
if val==False and allow_write_from_False_to_not_false:
raise_if_diff = False
else:
raise_if_diff_only_write = field_attr.get('raise_if_diff_only_write',True)
if raise_if_diff_only_write:
raise_if_diff = field_attr.get('raise_if_diff') and write_field
if not (write_field or raise_if_diff) :
print ('field_name',f_name,'continue')
continue
if not is_must_update or raise_if_diff :
orm_field_val = getattr(searched_object, f_name)
diff = check_diff_write_val_with_exist_obj(orm_field_val,val)
if diff:
if raise_if_diff:
raise UserError(u'raise_if_diff model:%s-f_name:%s - orm_field_val: %s - val:%s '%(class_name,f_name,orm_field_val,val))
if write_field:
write_dict_new[f_name] = val
else:
write_dict_new[f_name] = val
if write_dict_new:
if model_dict.get('print_write_dict_new',False):
print ('***write_dict_new***',write_dict_new)
searched_object.write(write_dict_new)
this_model_noti_dict['update'] = this_model_noti_dict.get('update',0) + 1
else:#'not update'
this_model_noti_dict['skipupdate'] = this_model_noti_dict.get('skipupdate',0) + 1
return return_obj, get_or_create# bool(searched_object)