def check_col_index_match_xl_title_for_a_field(field_attr, xl_title, col_index,
set_val, needdata, field_name,
func):
# if col_index or set_val or func:
# pass
if xl_title and set_val:
raise UserError("xl_title and set_val")
if set_val == None:
if col_index == None:
if xl_title: # không match
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'Excel not has column one in %s of %s, please change column name match with them'
) % (xl_title, field_name))
else:
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 replace_val_for_ci(field_attr, val, needdata):
#### deal replace string ####
replace_string = get_key(field_attr, 'replace_string')
if replace_string and check_is_string_depend_python_version(val):
for pattern, repl in replace_string:
pattern = pattern.replace('(', '\(').replace(')', '\)')
val = re.sub(pattern, repl, val)
#### end deal replace string ####
#### deal empty val ###
empty_val = get_key(field_attr, 'empty_val')
if empty_val and val in empty_val:
val = False
#### !!!deal empty val ###
#### deal replace val#####
replace_val = get_key(field_attr, 'replace_val')
if replace_val:
replace_val_tuple = replace_val.get(
needdata['sheet_name']) or replace_val.get('all')
if replace_val_tuple:
for k, v in replace_val_tuple:
if val == k:
val = v
break
#### !!!deal replace val#####
### deal defautl ###
### !!!!deal defautl ###SS
return val
def write_get_or_create_title(MD,
sheet,
sheet_of_copy_wb,
title_row,
fname=None):
offset_write_xl = get_key(MD, 'offset_write_xl')
offset_write_xl_diff = get_key(MD, 'offset_write_xl_diff')
offset_write_xl_for_searched_obj = get_key(
MD, 'offset_write_xl_for_searched_obj')
check_file_write_more = get_key(MD, 'check_file_write_more')
fname = fname or MD.get('model')
sheet_ncols = sheet.ncols
for k, v in [(offset_write_xl, u' có sẵn hay phải tạo'),
(offset_write_xl_for_searched_obj, u'theo cách tìm'),
(offset_write_xl_diff,
u'ở excel giống hay khác trong database')]:
asmall_func(MD, fname, sheet_ncols, k, sheet_of_copy_wb, title_row, v)
if check_file_write_more:
for more_offset, func, more_title in check_file_write_more:
col = sheet.ncols + more_offset
title = more_title
sheet_of_copy_wb.col(col).width = get_width(len(title))
sheet_of_copy_wb.write(title_row, col, title, header_bold_style)
if MD.get('fields'):
for fname, field_MD in MD.get('fields').items():
write_get_or_create_title(field_MD, sheet, sheet_of_copy_wb,
title_row, fname)
def add_col_index(MD, read_excel_value_may_be_title, col):
is_map_xl_title = False
for fname, field_MD in MD.get('fields').items():
is_real_xl_match_with_xl_excel = False
xl_title = get_key(field_MD, 'xl_title')
if get_key(field_MD, 'set_val') != None:
continue
if xl_title == None and get_key(field_MD, 'col_index') != None:
continue # cos col_index
elif field_MD.get('fields'):
is_real_xl_match_with_xl_excel = add_col_index(
field_MD, read_excel_value_may_be_title, col)
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_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_MD['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 check_compatible_col_index_and_xl_title_for_a_field(
field_attr, xl_title, col_index, set_val, needdata, field_name, func):
# if col_index or set_val or func:
# pass
if xl_title and set_val:
raise UserError("xl_title and set_val")
if set_val != None:
return True
if col_index == None:
if xl_title: # có kê xl_title nhưng mà không match
sheet_allow_this_field_not_has_exel_col = get_key(
field_attr, 'sheet_allow_this_field_not_has_exel_col')
allow_not_match_xl_title = get_key(field_attr,
'allow_not_match_xl_title')
skip_if_not_match = allow_not_match_xl_title 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'Excel has not column in "[%s]" of %s, please change column name match with them'
) % (xl_title, field_name))
else:
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: %s-%s' %
(field_name, field_attr))
else:
if not func:
raise UserError(
u'Sao không có col_index và không có func luôn field %s attrs %s'
% (field_name, u'%s' % field_attr))
def add_more_attrs_to_field_MD(self,
MD,
field_stt=0,
setting={}): # add x2m_fields
model_name = get_key(MD, 'model')
OBJ = self.env[model_name]
fields = OBJ._fields
default_dict = OBJ.default_get(fields)
for f_name, field_MD in MD.get('fields').items():
field_stt += 1
f_name = get_key(field_MD, 'transfer_name') or f_name
skip_this_field = get_key(field_MD, 'skip_this_field', False)
if not skip_this_field:
if f_name not in fields and not field_MD.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_MD))
st_write_false = setting['st_write_false']
write_false = field_MD[
'write_false'] if 'write_false' in field_MD else st_write_false
field_MD['write_false'] = write_false
field_MD['field_stt'] = field_stt
write_field = field_MD.get(
'write_field',
DEFAULT_VAL_DICT_OF_ATTR.get('write_field').get(
'default_value'))
field_MD['write_field'] = write_field
if not field_MD.get(
'for_excel_readonly'): # and not skip_this_field
field = fields[f_name]
field_MD['field_type'] = field.type
if field.comodel_name:
field_MD['model'] = field.comodel_name
if 'required' not in field_MD:
required_from_model = field.required
required_force = field_MD.get('required_force', None)
required = required_force or required_from_model
field_MD['required'] = required
if f_name in default_dict and field_MD.get('default_val') == None:
default_val = default_dict[f_name]
field_MD['default_val'] = default_val
if field_MD.get('empty_val'):
partern_empty_val = '^(' + '|'.join(
field_MD.get('empty_val')) + ')$'
field_MD['partern_empty_val'] = partern_empty_val
if 'st_is_x2m_field' in field_MD:
x2m_fields = MD.setdefault('x2m_fields', [])
x2m_fields.append(f_name)
if field_MD.get('fields'):
field_stt = add_more_attrs_to_field_MD(self,
field_MD,
field_stt=field_stt,
setting=setting)
return field_stt
def check_compatible_col_index_and_xl_title(self, MD, needdata):
for fname, field_MD in MD.get('fields').items():
skip_this_field = get_key(field_MD, 'skip_this_field', False)
if not skip_this_field:
col_index = get_key(field_MD, 'col_index', None)
xl_title = get_key(field_MD, 'xl_title')#moi them , moi bo field_attr.get('xl_title')
set_val = get_key( field_MD,'set_val')
func = field_MD.get('func')
check_compatible_col_index_and_xl_title_for_a_field( field_MD, xl_title, col_index, set_val, needdata, fname, func)
if field_MD.get('fields'):
check_compatible_col_index_and_xl_title(self, field_MD, needdata)
def search_handle(self, model_dict, search_dict, model_name, setting,
needdata):
search_func = model_dict.get('search_func')
if search_func:
searched_obj = search_func(self, model_dict, setting, needdata)
else:
if search_dict:
pass
else:
raise UserError(u'Không có search dict, model_name: %s-MD: %s' %
(model_name, model_dict))
if model_dict.get('inactive_include_search'):
domain_not_active = [
'|', ('active', '=', True), ('active', '=', False)
]
else:
domain_not_active = []
domain = []
has_none_val_search_field = False
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
operator_search = field_attr.get('operator_search', '=')
tuple_in = (f_name, operator_search, val)
domain.append(tuple_in)
if not has_none_val_search_field:
domain = expression.AND([domain_not_active, domain])
searched_obj = self.env[model_name].search(domain)
return searched_obj
def after_ci(setting, exist_val, field_attr, check_file, sheet_of_copy_wb, row,
sheet, get_or_create, obj, noti_dict):
if exist_val:
func_check_if_excel_is_same_existence = setting.get(
'st_allow_check_if_excel_is_same_existence') and field_attr.get(
'func_check_if_excel_is_same_existence')
if func_check_if_excel_is_same_existence: # and not get_or_create:,not st_is_allow_write_existence and
func_check_if_excel_is_same_existence(get_or_create, obj,
exist_val)
val = exist_val.id
obj = exist_val
get_or_create = True
this_model_notice = noti_dict.setdefault(field_attr.get('model'), {})
this_model_notice['exist_val'] = this_model_notice.get('exist_val',
0) + 1
field_attr['get_or_create'] = get_or_create
if check_file:
# if val ==False or val ==None:
# val = None
offset_write_xl = get_key(field_attr, 'offset_write_xl')
if offset_write_xl != None:
if get_or_create:
get_or_create_display = u'Đã Có'
else:
if field_attr['fields']['name']['val'] != False:
get_or_create_display = u'Chưa'
else:
get_or_create_display = u'empty cell'
sheet_of_copy_wb.write(row, sheet.ncols + offset_write_xl,
get_or_create_display,
wrap_center_vert_border_style)
def write_handle(self,
return_obj,
MD,
write_dict,
new_noti_dict,
f_name_call=False):
write_dict_new = {}
writed_object = return_obj
for key_f_name, val in write_dict.items():
field_MD = MD['fields'][key_f_name]
if field_MD.get('val_goc') != False or field_MD.get(
'write_false', False):
f_name = get_key(field_MD, 'transfer_name') or key_f_name
is_write_this_field = field_MD['write_field']
if is_write_this_field:
orm_field_val = getattr(writed_object, f_name)
func_in_write_handle = field_MD.get('func_in_write_handle')
if func_in_write_handle:
val = func_in_write_handle(orm_field_val, val)
is_x2m = field_MD.get('x2m_fields', False)
diff = check_diff_write_val_with_exist_obj(
orm_field_val, val, field_MD, is_x2m)
if diff:
if is_write_this_field:
write_dict_new[f_name] = val
if write_dict_new:
writed_object.write(write_dict_new)
new_noti_dict['update'] = 1
if f_name_call == 'main_call':
print('**write_dict_new', write_dict_new)
else: #'not update'
new_noti_dict['skipupdate'] = 1
def add_more_attrs_to_field_MD_after_add_col_index(self, MD, field_stt = 0, setting={}):# add x2m_fields
for f_name, field_MD in MD.get('fields').items():
# f_name = get_key(field_MD, 'transfer_name') or f_name
skip_this_field = get_key(field_MD, 'skip_this_field',False)
if not skip_this_field:
set_col_index = field_MD.get('set_col_index')
if set_col_index != None:
field_MD['col_index'] = set_col_index
if field_MD.get('fields'):
field_stt = add_more_attrs_to_field_MD(self, field_MD, field_stt = field_stt, setting=setting)
def write_get_or_create_title(MD, sheet, sheet_of_copy_wb, title_row):
fields = MD['fields']
for fname, field_MD in fields.items():
offset_write_xl = get_key(field_MD, 'offset_write_xl')
if offset_write_xl != None:
col = sheet.ncols + offset_write_xl
title = field_MD.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)
if field_MD.get('fields'):
write_get_or_create_title(field_MD, sheet, sheet_of_copy_wb,
title_row)
def gen_first_last_row(self, MD, row_title_index, nrows, dong_test_in_MD):
off_set_row = get_key(MD, 'begin_data_row_offset_with_title_row', 1)
min_row = row_title_index + off_set_row
first_row = min_row + getattr(self, 'begin_row', 0)
print('first_row', 'min_row', first_row, min_row)
dong_test = getattr(self, 'dong_test', None) or dong_test_in_MD
if not dong_test:
last_row = nrows
else:
last_row = first_row + dong_test
if last_row > nrows:
last_row = nrows
if first_row > last_row:
raise UserError(u'first_row > last_row')
return first_row, last_row
def gen_sheet_names(self, MD, xl_workbook, gen_model_dict_kargs):
sheet_names = get_key(MD, 'sheet_names')
if callable(sheet_names):
try:
sheet_names = sheet_names(self)
except TypeError as e:
if 'required positional argument' in u'%s' % e:
try:
sheet_names = sheet_names(self, xl_workbook)
except TypeError as e:
if 'required positional argument' in u'%s' % e:
sheet_names = sheet_names(self, xl_workbook,
gen_model_dict_kargs)
else:
raise UserError(u'có 1 lỗi ở hàm sheet_names: %s ' % e)
else:
raise UserError(u'có 1 lỗi ở hàm sheet_names: %s ' % e)
return sheet_names
def create_handle(self, search_dict, write_dict, MD, model_name, f_name_call):
search_dict_new = {}
allow_create = MD.get('allow_create', True)
if not allow_create:
if MD.get('BreakRowException_if_raise_allow_create'):
raise BreakRowException(
u'Model %s này với giá trị f_name_call:%s, name: "%s" chỉ được get chứ không được tạo, hãy tạo tay hoặc chọn thuộc tính BreakRowException_if_raise_allow_create để bỏ qua thông báo này'
% (model_name, f_name_call, MD['fields']['name']['val']))
else:
raise UserError(
u'Model %s này với giá trị f_name_call:%s, name: "%s" chỉ được get chứ không được tạo, hãy tạo tay hoặc chọn thuộc tính BreakRowException_if_raise_allow_create để bỏ qua thông báo này'
% (model_name, f_name_call, MD['fields']['name']['val']))
search_dict.update(write_dict)
for f_name, val in search_dict.items():
field_attr = MD['fields'][f_name]
f_name = get_key(field_attr, 'transfer_name') or f_name
search_dict_new[f_name] = val
created_object = self.env[model_name].create(search_dict_new)
return_obj = created_object
return return_obj
def xac_dinh_title_rows(self, MD, set_is_largest_map_row_choosing, nrows,
sheet_name):
range_1 = getattr(self, 'range_1', None)
range_2 = getattr(self, 'range_2', None)
if range_1 or range_2:
title_rows = range(range_1, range_2)
else:
if set_is_largest_map_row_choosing:
title_rows = range(0, nrows)
else:
title_rows_some_sheets = MD.get('title_rows_some_sheets', {})
if title_rows_some_sheets:
title_rows_some_sheets = title_rows_some_sheets.get(sheet_name)
if title_rows_some_sheets:
title_rows = title_rows_some_sheets
else:
title_rows = get_key(MD,
'title_rows') # MODEL_DICT['title_rows']
return title_rows
def create_handle(self, search_dict, write_dict, MD, model_name, f_name_call,
is_x2m_fields):
search_dict_new = {}
context = MD.get('context', {})
allow_create = MD.get('allow_create', True)
if not allow_create:
if getattr(self, 'BreakRowException_if_raise_allow_create'):
raise BreakRowException(
u'Model %s này với giá trị f_name_call:%s, name: "%s" chỉ được get chứ không được tạo'
% (model_name, f_name_call, MD['fields']['name']['val']))
else:
raise UserError(
u'Model %s này với giá trị f_name_call:%s, name: "%s" chỉ được get chứ không được tạo, hãy tạo tay hoặc chọn thuộc tính BreakRowException_if_raise_allow_create để bỏ qua thông báo này'
% (model_name, f_name_call, MD['fields']['name']['val']))
# search_dict.update(write_dict)
write_dict.update(search_dict)
for f_name, val in write_dict.items():
field_attr = MD['fields'][f_name]
f_name = get_key(field_attr, 'transfer_name') or f_name
delete_when_return_x2m_create_if_false = field_attr.get(
'delete_when_return_x2m_create_if_false', False)
if not delete_when_return_x2m_create_if_false:
search_dict_new[f_name] = val
if is_x2m_fields and not CREATE_IN_M2X:
# for i in search_dict:
# delete_when_return_x2m_create_if_false = MD.get('delete_when_return_x2m_create_if_false',False)
# if delete_when_return_x2m_create_if_false:
return search_dict_new
created_object = self.env[model_name].sudo().with_context(
**context).create(search_dict_new)
return_obj = created_object
return return_obj
def get_or_create_object_sosanh(self,
class_name,
search_dict,
write_dict={},
noti_dict=None,
inactive_include_search=False,
model_dict={},
exist_val=False,
setting={},
check_file=False,
is_search=True,
is_create=True,
is_write=True,
sheet_of_copy_wb_para=None):
search_dict_new = {}
write_dict_new = {}
if noti_dict != None:
this_model_noti_dict = noti_dict.setdefault(class_name, {})
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(self, model_dict, 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 search_dict:
pass
else:
raise UserError(
u'Không có Key search dict, model_name%s----MD%s' %
(class_name, model_dict))
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 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 or check_file:
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_MD = model_dict['fields'][f_name]
if check_file and field_MD.get('offset_write_xl') == None:
continue
if not check_file and (field_attr.get('val_goc') == False
and not field_attr.get('write_false')):
continue
f_name = get_key(field_attr, 'transfer_name') or f_name
if check_file:
is_write_this_field = False
else:
is_write_this_field = field_attr.get('write_field')
is_write_this_field = allow_write_all_field if is_write_this_field == None else is_write_this_field
if not check_file and not is_write_this_field:
continue
orm_field_val = getattr(searched_object, f_name)
diff = check_diff_write_val_with_exist_obj(
orm_field_val, val, field_attr)
if diff:
if is_write_this_field:
write_dict_new[f_name] = val
if check_file:
diff_show = 'Khac orm:%s-dict:%s' % (orm_field_val,
val)
else:
if check_file:
diff_show = 'Giong orm:%s-dict:%s' % (orm_field_val,
val)
if check_file:
sheet_of_copy_wb = sheet_of_copy_wb_para[
'sheet_of_copy_wb']
sheet_of_copy_wb.write(
sheet_of_copy_wb_para['row'],
sheet_of_copy_wb_para['sheet'].ncols +
field_MD.get('offset_write_xl'), diff_show,
wrap_center_vert_border_style)
if 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)
def add_model_n_type_n_required_to_fields(self,
MD,
field_stt=0,
setting={}): # add x2m_fields
model_name = get_key(MD, 'model')
OBJ = self.env[model_name]
fields = OBJ._fields
default_dict = OBJ.default_get(fields)
for f_name, field_MD in MD.get('fields').items():
field_stt += 1
f_name = get_key(field_MD, 'transfer_name') or f_name
skip_this_field = get_key(field_MD, 'skip_this_field', False)
if not skip_this_field:
if f_name not in fields and not field_MD.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_MD))
# bypass_this_field_if_value_equal_False = field_MD.get('bypass_this_field_if_value_equal_False',False)
# key = field_MD.get('key', False)
# if key and bypass_this_field_if_value_equal_False:
# raise UserError(u'key and bypass_this_field_if_value_equal_False')
st_write_false = setting['st_write_false']
write_false = field_MD[
'write_false'] if 'write_false' in field_MD else st_write_false
field_MD['write_false'] = write_false
field_MD['field_stt'] = field_stt
if not field_MD.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_MD['field_type'] = field.type
if field.comodel_name:
field_MD['model'] = field.comodel_name
if 'required' not in field_MD:
required_from_model = field.required
required_force = field_MD.get('required_force', None)
required = required_force or required_from_model
field_MD['required'] = required
default_val = field_MD.get('default_val')
if f_name in default_dict and default_val == None:
default_val = default_dict[f_name]
field_MD['default_val'] = default_val
if field_MD.get('empty_val'):
partern_empty_val = '^(' + '|'.join(
field_MD.get('empty_val')) + ')$'
field_MD['partern_empty_val'] = partern_empty_val
if field_MD.get('fields'):
field_stt = add_model_n_type_n_required_to_fields(
self, field_MD, field_stt=field_stt, setting=setting)
if 'st_is_x2m_field' in field_MD:
x2m_fields = MD.setdefault('x2m_fields', [])
x2m_fields.append(f_name)
return field_stt
def create_instance(
self,
MD,
sheet,
row,
merge_tuple_list,
needdata,
noti_dict,
# main_call_create_instance_model = False,
check_file=False,
sheet_of_copy_wb=False,
setting={},
sheet_of_copy_wb_para=None,
# exist_val = False,
# is_search = True,
# is_create = True,
# is_write = True,
):
key_search_dict = {}
update_dict = {}
model_name = MD.get('model')
collection_dict = {}
is_create, is_write, is_search, exist_val, is_go_loop_fields = before_ci(
self, MD, setting, check_file, needdata)
if is_go_loop_fields:
for field_name, field_attr in MD['fields'].items():
a_field_code = get_a_field_val(
self, field_name, field_attr, needdata, row, sheet, check_file,
sheet_of_copy_wb, merge_tuple_list, model_name, noti_dict,
key_search_dict, update_dict, collection_dict, setting,
sheet_of_copy_wb_para)
if a_field_code == 'break_out_a_row_because_a_required':
if field_attr.get('raise_if_False') and not check_file:
raise UserError('raise_if_False field: %s' % field_name)
break
if a_field_code == 'break_out_a_row_because_a_required':
# if main_call_create_instance_model:
break_condition_func_for_main_instance = get_key(
MD, 'break_condition_func_for_main_instance')
if break_condition_func_for_main_instance:
break_condition_func_for_main_instance(needdata)
obj = False
obj_val = False
get_or_create = None
elif collection_dict.get(
'instance_false'
): # có 1 field = false and required ==> instance đó = False
obj, obj_val, get_or_create = False, False, None
else:
obj, obj_val, get_or_create = get_or_create_instance_from_key_search_and_update_dict(
self,
model_name,
key_search_dict,
update_dict,
check_file,
noti_dict,
MD,
exist_val=exist_val,
setting=setting,
is_search=is_search,
is_create=is_create,
is_write=is_write,
sheet_of_copy_wb_para=sheet_of_copy_wb_para)
# after_ci(exist_val,func_check_if_excel_is_same_existence, field_attr, check_file, sheet_of_copy_wb, row, sheet, get_or_create, obj, noti_dict)
if exist_val:
func_check_if_excel_is_same_existence = setting.get(
'st_allow_check_if_excel_is_same_existence') and MD.get(
'func_check_if_excel_is_same_existence')
if func_check_if_excel_is_same_existence: # and not get_or_create:,not st_is_allow_write_existence and
func_check_if_excel_is_same_existence(get_or_create, obj,
exist_val)
obj_val = exist_val.id
obj = exist_val
get_or_create = True
this_model_notice = noti_dict.setdefault(MD.get('model'), {})
this_model_notice['exist_val'] = this_model_notice.get('exist_val',
0) + 1
MD['get_or_create'] = get_or_create
if check_file:
# if val ==False or val ==None:
# val = None
offset_write_xl = get_key(MD, 'offset_write_xl')
if offset_write_xl != None:
if get_or_create:
get_or_create_display = u'Đã Có'
elif get_or_create == None:
get_or_create_display = u'None'
else:
if 'name' not in MD['fields']:
get_or_create_display = u'Chưa'
else:
if MD['fields']['name']['val'] != False:
get_or_create_display = u'Chưa'
else:
get_or_create_display = u'empty cell'
sheet_of_copy_wb.write(row, sheet.ncols + offset_write_xl,
get_or_create_display,
wrap_center_vert_border_style)
# if check_file:
# if obj_val == False:
# obj_val = None
# last_record_function = get_key(MD, 'last_record_function')
# if last_record_function:
# last_record_function(needdata, self)
return obj, obj_val, get_or_create
def get_a_field_val(
self,
field_name,
field_attr,
needdata,
row,
sheet,
check_file,
sheet_of_copy_wb,
merge_tuple_list,
model_name,
noti_dict,
key_search_dict,
update_dict,
# x2m_fields,
collection_dict,
setting,
sheet_of_copy_wb_para):
skip_this_field = get_key(field_attr, 'skip_this_field', False)
if callable(skip_this_field):
skip_this_field = skip_this_field(self)
if skip_this_field:
return 'continue'
col_index = get_key(field_attr, 'col_index')
func = get_key(field_attr, 'func')
#F11
obj, val = read_val_for_ci(self,
field_attr,
check_file,
needdata,
noti_dict,
setting,
excel_para={
'col_index': col_index,
'sheet': sheet,
'row': row,
'merge_tuple_list': merge_tuple_list,
'sheet_of_copy_wb': sheet_of_copy_wb
},
for_print_para={
'model_name': model_name,
'field_name': field_name
},
sheet_of_copy_wb_para=sheet_of_copy_wb_para)
field_attr['before_func_val'] = val
# func
karg = get_key(field_attr, 'karg', {})
if karg == None:
karg = {}
func_pre_func = field_attr.get('func_pre_func')
if func_pre_func:
val = func_pre_func(val, needdata, self)
if func:
try:
val = func(val, needdata, **karg)
except TypeError:
try:
val = func(val, needdata, self, **karg)
except TypeError:
val = func(val, **karg)
# print ('func read model_name:%s field_name:%s'%(model_name,field_name),'val',val)
val = replace_val_for_ci(field_attr, val, needdata)
field_attr['val_goc'] = val
if val == False:
default_val = field_attr.get('default_val')
if default_val != None:
val = default_val
if field_attr.get('field_type') == 'float':
val = float_round(val, precision_rounding=0.01)
field_attr['val'] = val
field_attr['obj'] = obj
if check_file:
required_when_normal = get_key(field_attr, 'required', False)
required = get_key(field_attr, 'required_when_check_file',
required_when_normal)
if (required_when_normal and val == False) and required == False:
collection_dict['instance_false'] = True
else:
required = get_key(field_attr, 'required', False)
key_or_not = field_attr.get('key')
if '2many' in field_attr.get('field_type', '') and val == False:
a_field_code = 'continue'
return a_field_code
if required and (val == False and isinstance(
val, bool)): # val ==False <==> val ==0, val ==0 <==> val =False
this_model_notice = noti_dict.setdefault(model_name, {})
skip_because_required = this_model_notice.setdefault(
'skip_because_required', 0)
this_model_notice['skip_because_required'] = skip_because_required + 1
a_field_code = 'break_out_a_row_because_a_required'
return a_field_code #sua 5
elif not field_attr.get('for_excel_readonly'):
if key_or_not == True:
key_search_dict[field_name] = val
elif key_or_not == 'Both':
key_search_dict[field_name] = val
update_dict[field_name] = val
else:
update_dict[field_name] = val
valid_field_func = field_attr.get('valid_field_func')
if valid_field_func:
valid_field_func(val, obj, needdata, self)
print("row: ", row, 'model_name: ', model_name, '-field: ', field_name,
'-val: ', val)
check_type_of_val(field_attr, val, field_name, model_name)
a_field_code = False
return a_field_code
def read_val_for_ci(self,
field_attr,
check_file,
needdata,
noti_dict,
setting,
excel_para={},
for_print_para={},
sheet_of_copy_wb_para=None):
col_index = excel_para['col_index']
sheet = excel_para['sheet']
row = excel_para['row']
merge_tuple_list = excel_para['merge_tuple_list']
sheet_of_copy_wb = excel_para['sheet_of_copy_wb']
val = False
obj = False
set_val = get_key(field_attr, 'set_val')
if set_val != None:
val = set_val
elif col_index != None: # đọc file exc
xl_val = read_excel_cho_field(sheet, row, col_index, merge_tuple_list)
xl_val = empty_string_to_False(xl_val)
field_attr['excel_val'] = xl_val
val = empty_string_to_False(xl_val)
if field_attr.get('partern_empty_val'):
val = empty_string_to_False(val,
pt=field_attr.get('partern_empty_val'))
if val != False and field_attr.get('st_is_x2m_field'):
val = val.split(',')
val = list(map(lambda i: empty_string_to_False(i.strip()), val))
if False in val:
raise UserError(u'Không được có phần tử = False')
print(
'excel read model_name:%s field_name:%s' %
(for_print_para['model_name'], for_print_para['field_name']),
'xl_val', xl_val, 'val', xl_val)
elif field_attr.get('fields'):
# before_ci()
obj, val, get_or_create = create_instance(
self,
field_attr,
sheet,
row,
merge_tuple_list,
needdata,
noti_dict,
check_file=check_file,
sheet_of_copy_wb=sheet_of_copy_wb,
# exist_val = exist_val,
setting=setting,
sheet_of_copy_wb_para=sheet_of_copy_wb_para
# is_search = is_search,
# is_create = is_create,
# is_write = is_write,
)
# after_ci()
return obj, val
