def get_group_data_permissions(self, group_id, tool_id): """ TEMPRORARY DOESN'T WORK TO DO Method don't return anything Ver.1 - Get data by group Q:Why to put tool_id if data models_managers is fully defined by group_id? :param group_id: :type group_id: :param tool_id: :type tool_id: :return: :rtype: """ # Validate inputs tool_id = _get_id_or_err(tool_id, 'tool_id') group_id = _get_id_or_err(group_id, 'group_id') # Get objects tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) group = a_m.get_user_group_by_id(self.ssn, group_id) if group is None: raise ex.NotExistsError('UserGroup', 'id', group_id) return a_m.get_data_permission(group_id)
def add_user_to_group(self, user_id, group_id): """ TEMPRORARY DOESN'T WORK Add user to group :param user_id: :type user_id: :param group_id: :type group_id: :return: :rtype: """ # Validate inputs user_id = _get_id_or_err(user_id, 'user_id') group_id = _get_id_or_err(group_id, 'group_id') # Get objects user = a_m.get_user_by_id(self.ssn, user_id) if user is None: raise ex.NotExistsError('User', 'id', user_id) group = a_m.get_user_group_by_id(self.ssn, group_id) if group is None: raise ex.NotExistsError('UserGroup', 'id', group_id) if user in group.users: raise ex.AlreadyExistsError('UserGroup', 'users', user.id) return group.users.append(user)
def jj_extract(wb, meta_cols, data_cols, dates_cols): ws = wb.sheet_by_index(0) if ws.nrows <= 1: raise ex.EmptyInputsError('jj_extract') header_row = ws.row(0) last_col = get_last_col(ws, header_row) # Init headers cols: names for key, val in meta_cols.items(): if key >= last_col: raise ex.NotExistsError('DataProcessing', 'column', key) if val == '': meta_cols[key] = header_row[key].value new_val = meta_cols[key] for key, val in data_cols.items(): if key >= last_col: raise ex.NotExistsError('DataProcessing', 'column', key) if val == '': data_cols[key] = header_row[key].value new_val = data_cols[key] for key, val in dates_cols.items(): if key >= last_col: raise ex.NotExistsError('DataProcessing', 'column', key) # Create output: Append data output = [] data = get_cell_range(0, 0, ws.ncols, ws.nrows, ws) for row_index in range(1, ws.nrows): new_row = {'meta': {}, 'data': {}, 'dates': 0} for key, val in meta_cols.items(): new_row['meta'][val] = data[row_index][key].value for key, val in data_cols.items(): new_row['data'][val] = data[row_index][key].value new_row['dates'] = date_func(dates_cols, data[row_index]) output.append(new_row) return output
def add_role(self, name, tool_id): """ Add role is correct :param name: :type name: :param tool_id: :type tool_id: :return: :rtype: """ # Validate inputs name = _get_str_or_err(name, 'name') #tool_id = _get_id_or_err(tool_id, 'tool_id') # Get Objects tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) existing = [role for role in tool.roles if role.name == name] if existing is not None and len(existing) > 0: raise ex.AlreadyExistsError('Role', 'name', name) new_role = self._add_role(self.ssn, name) # a_m.add_role_to_tool(self.ssn, new_role, tool) tool.roles.append(new_role) return new_role
def add_group(self, name, tool_id): """ Add user group to Tool :param name: :type name: :param tool_id: :type tool_id: :return: :rtype: """ # Validate inputs name = _get_str_or_err(name, 'name') tool_id = _get_id_or_err(tool_id, 'tool_id') # Get Objects tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) existing = [ug for ug in tool.user_groups if ug.name == name] # TODO Check if existing is not None and isinstance(existing, list): raise ex.AlreadyExistsError('UserGroup', 'name', name) return self._add_user_group(self.ssn, name, tool)
def add_permission(self, tool_id, node_type, name, parent_id=None): tool_id = _get_id_or_err(tool_id, 'tool_id') node_type = _get_str_or_err(node_type, 'node_type') # Defined string name = _get_str_or_err(name, 'name') tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) parent = None if parent_id is not None: parent_id = _get_id_or_err(parent_id, 'parent_id') parent = a_m.get_perm_node_in_tool(self.ssn, parent_id, tool) if parent is None: raise ex.NotExistsError('PermNode', 'id', parent_id) return a_m.add_perm_node(self.ssn, tool, node_type, name, parent)
def add_permission_value(self, tool_id, perm_node_id, value, user_id): tool_id = _get_id_or_err(tool_id, 'tool_id') perm_node_id = _get_id_or_err(perm_node_id, 'perm_node_id') user_id = _get_id_or_err(user_id, 'user_id') tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) user = a_m.get_user_by_id(self.ssn, user_id) if user is None: raise ex.NotExistsError('User', 'id', user_id) perm_node = a_m.get_perm_node_in_tool(self.ssn, perm_node_id, tool) if perm_node is None: raise ex.NotExistsError('PermNode', 'id', perm_node_id) return a_m.add_perm_value(self.ssn, tool, perm_node, value, user)
def update_role_features(self, role_id, features_id): """ Update role by given list of features. Delete non common features, and add new :param role_id: :type role_id: :param features_id: :type features_id: :return: :rtype: """ # Validate inputs role_id = _get_id_or_err(role_id, 'id') if features_id is None or not isinstance(features_id, list): raise ex.WrongArgEx('features_id', features_id) # Get Objects role = a_m.get_role_by_id(self.ssn, role_id) if role is None: raise ex.NotExistsError('Role', 'id', role_id) new_features = [] for fid in features_id: f = a_m.get_feature_by_id(self.ssn, fid) if f is not None: new_features.append(f) else: raise ex.NotExistsError('Feature', 'id', fid) old_f = [x.id for x in role.features] new_f = features_id to_keep = set(old_f).intersection(new_f) # Delete if len(old_f) > len(to_keep): delete_ids = set(old_f) - set(to_keep) self._del_features_from_role(self.ssn, role, delete_ids) # Add if len(new_f) > len(to_keep): add = set(new_f) - set(to_keep) to_add_features = [x for x in new_features if x.id in add] self._add_features_to_role(self.ssn, role, to_add_features) return role.features
def get_permissions(self, tool_id, user_id): tool_id = _get_id_or_err(tool_id, 'tool_id') user_id = _get_id_or_err(user_id, 'user_id') tool = wha.get_tool_by_id(self.ssn, tool_id) user = wha.get_user_by_id(self.ssn, user_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) if user is None: raise ex.NotExistsError('User', 'id', user_id) # default_perms = wha.get_perms_to_tool(ssn, tool) # wha.get_user_perms_to_tool(sess, tool, user), return { 'permissions': wha.get_perms_to_tool(self.ssn, tool, user), 'features': wha.get_user_features_to_tool(self.ssn, tool, user) }
def init_user_wb(self, user_id, tool_id): # Validate inputs tool_id = _get_id_or_err(tool_id, 'tool_id') user_id = _get_id_or_err(user_id, 'user_id') # Get Objects tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) user = a_m.get_user_by_id(self.ssn, user_id) if user is None: raise ex.NotExistsError('User', 'id', user_id) # Version 2 # Get raw data from table with masks raw_perm_values = a_m.get_raw_perm_values_for_user( self.ssn, tool, None) # Copy/Insert this raw data for specified user # TODO - check if there is no data for this user!!! for per_v in raw_perm_values: perm_node = per_v.perm_node a_m.add_perm_value(self.ssn, tool, perm_node, per_v.value, user) # TODO Fix bug with initialize db # # Get recently created permissions for user iaccess = _IAccess(ssn=self.ssn) u_perms = iaccess.get_permissions(tool_id, user_id) # self.istorage.backup.save(user_id, tool_id, u_perms, 'models_managers') # # Make backup file # dir_path = os.path.dirname(os.path.realpath(__file__)) # file_name = "backup_tool_" + str(tool_id) + "_user_" \ # + str(user_id) + ".json" # file_path = os.path.join(dir_path, file_name) # with open(file_path, "w+") as backup_file: # json.dump(u_perms, backup_file) pass # TODO Confirm This Realization
def get_user_roles(self, user_id): """ Return Users Role's :param user_id: :type user_id: :return: :rtype: """ user_id = _get_id_or_err(user_id, 'user_id') user = a_m.get_user_by_id(self.ssn, user_id) if user is None: raise ex.NotExistsError('User', 'id', user_id) return user.roles
def update_user_data_permissions(self, tool_id, user_id, permissions): """ TEMPRORARY DOESN'T WORK :param tool_id: :type tool_id: :param user_id: :type user_id: :param permissions: :type permissions: :return: :rtype: """ #TODO # Validate inputs tool_id = _get_id_or_err(tool_id, 'user_id') user_id = _get_id_or_err(user_id, 'user_id') # Get objects tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) user = a_m.get_user_by_id(self.ssn, user_id) if user is None: raise ex.NotExistsError('User', 'id', user_id) # TODO Validating paths for nodes # Delete previous permissions for user a_m.del_perm_values_for_user(self.ssn, tool, user) # Get objects storage = {} permissions = sorted(permissions, key=lambda p: len(p['path'])) for perm in permissions: self._add_permission(tool, storage, perm, user)
def get_feature(self, **kwargs): """ Args: **kwargs: id|name & tool_id """ if 'id' in kwargs: feature_id = _get_id_or_err(kwargs['id'], 'id') return a_m.get_feature_by_id(self.ssn, feature_id) elif 'name' in kwargs and 'tool_id' in kwargs: name = _get_str_or_err(kwargs['name'], 'name') tool_id = _get_id_or_err(kwargs['tool_id'], 'tool_id') tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) return a_m.get_feature_by_name_in_tool(self.ssn, name, tool)
def get_role_features(self, role_id): """ Return Features related to Role :param role_id: :type role_id: :return: :rtype: """ # Validate inputs role_id = _get_id_or_err(role_id, 'id') # Get Objects role = a_m.get_role_by_id(self.ssn, role_id) if role is None: raise ex.NotExistsError('Role', 'id', role_id) return role.features
def get_features(self, tool_id): """ Return features related to given tool :param tool_id: :type tool_id: :return: :rtype: """ # Validate inputs #tool_id = _get_id_or_err(tool_id, 'tool_id') # Get Objects tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) return a_m.get_features_by_tool(self.ssn, tool)
def get_users(self, tool_id=None): """ Return user object by given tool :param tool_id: :type tool_id: :return: :rtype: """ # Validate inputs & Get object if tool_id is not None: tool_id = _get_id_or_err(tool_id, 'tool_id') tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) return a_m.get_users_by_tool(self.ssn, tool) return a_m.get_all_users(self.ssn)
def get_group_users(self, group_id): """ Return Get User of Specific Group :param group_id: :type group_id: :return: :rtype: """ # Validate inputs group_id = _get_id_or_err(group_id, 'group_id') # Get objects group = a_m.get_user_group_by_id(self.ssn, group_id) if group is None: raise ex.NotExistsError('UserGroup', 'id', group_id) return group.users
def add_user(self, email, password, roles_id=None): # Validate inputs #email = _get_str_or_err(email, 'email') #password = _get_str_or_err(password, 'password') # TODO Hashing Pass # Get Objects roles = [] if roles_id is not None and isinstance(roles_id, list): for role_id in roles_id: role_id = _get_id_or_err(role_id, 'id') role = a_m.get_role_by_id(self.ssn, role_id) if role is None: raise ex.NotExistsError('Role', 'id', role_id) else: roles.append(role) existing = a_m.get_user_by_email(self.ssn, email) if existing is not None: raise ex.AlreadyExistsError('User', 'email', email) return self._add_user(self.ssn, email, password, roles)
def set_permissions_template(self, tool_id, template): # Validate inputs tool_id = _get_id_or_err(tool_id, 'tool_id') if 'permissions' not in template or \ not isinstance(template['permissions'], list): raise ex.WrongArgEx('permissions', template.get('permissions')) if 'features' not in template or \ not isinstance(template['features'], list): raise ex.WrongArgEx('features', template.get('features')) feats = template['features'] perms = template['permissions'] # Get objects tool = a_m.get_tool_by_id(self.ssn, tool_id) if tool is None: raise ex.NotExistsError('Tool', 'id', tool_id) # Create & validate features dict for adding features_to_add = [] for _f in feats: features_to_add.append({'name': _f.get('name')}) # Add permissions perms = sorted(perms, key=lambda perm: len(perm['path'])) storage = {} for perm in perms: self._add_permission(tool, storage, perm) # Add default features for tool if len(features_to_add) > 0: for f in features_to_add: a_m.add_feature(self.ssn, f['name'], tool) return None
def jj_brand_extract(warehouse, wb, options_list): # t1 = datetime.datetime.now() meta_cols = options_list['meta_cols'] data_cols = options_list['data_cols'] dates_info = options_list['dates_cols'] date_func = options_list['date_func'] date_col = dates_info['date_col'] series_name = dates_info['scale'] ws = wb.sheet_by_index(0) if ws.nrows <= 1: raise ex.EmptyInputsError('jj_extract') data = get_cell_range(0, 0, ws.ncols, ws.nrows, ws) header_row_index = 0 last_col = get_last_col(data, header_row_index) # Init headers cols: names for item in meta_cols: column_number = item['Col_number'] if column_number >= last_col: raise ex.NotExistsError('DataProcessing', 'column', column_number) if item['Dimension_name'] == '': item['Dimension_name'] = data[0][column_number].value for key, val in data_cols.items(): if key[0] >= last_col: raise ex.NotExistsError('DataProcessing', 'column', key) if val == '': data_cols[key] = data[0][key[0]].value if date_col >= last_col: raise ex.NotExistsError('DataProcessing', 'column', key[0]) # Create output: Append data if 'mapping_rule' in options_list: mapping_rule = options_list['mapping_rule'] else: mapping_rule = None date_values = [] for row_index in range(1, len(data)): date_values.append(data[row_index][date_col].value) time_line = get_time_line(date_values) times_series = warehouse.add_time_scale(series_name, time_line) for row_index in range(1, len(data)): # print(row_index) meta = [] for item in meta_cols: copy_item = item.copy() column_index = copy_item['Col_number'] copy_item['Name'] = data[row_index][column_index].value meta.append(copy_item) if mapping_rule is not None: new_meta, is_mapped = mapping(meta, mapping_rule) if is_mapped: meta = new_meta num_of_dates = 1 date_value = data[row_index][date_col].value start_label = date_func(date_value, num_of_dates) path = [x['Name'] for x in meta] item_meta = [(x['Dimension_name'], x['Layer']) for x in meta] entity = warehouse.add_entity(path, item_meta) for key, val in data_cols.items(): value = data[row_index][key[0]].value value = convert_value(value, key[1]) variable = warehouse.force_ent_variable(entity, val, key[1]) time_series = warehouse.force_var_time_series( variable, times_series) history_value = time_series.get_value(start_label) if not history_value: new_value = [value] else: new_value = [history_value + value] time_series.set_values(start_label, new_value)
def jj_oral_care_media_spend(warehouse, wb, options_list): ws = wb.sheet_by_index(0) data = get_cell_range(0, 0, ws.ncols, ws.nrows, ws) meta_cols = options_list['meta_cols'] date_func = options_list['date_func'] header_row_index = options_list['info']['header_row'] name_col = options_list['name_col'] if 'map_names' in options_list: has_map_names = True map_names = options_list['map_names'] else: has_map_names = False series_name = options_list['dates_info']['scale'] start_data_row = options_list['info']['data_row'] start_date_col = options_list['dates_info']['start_column'] last_col = options_list['dates_info']['end_column'] if last_col == '': last_col = get_last_col(data, header_row_index) # Init headers cols: names for item in meta_cols: column_number = item['Col_number'] if column_number >= last_col: raise ex.NotExistsError('DataProcessing', 'column', column_number) if item['Dimension_name'] == '': item['Dimension_name'] = data[header_row_index][column_number]\ .value if 'mapping_rule' in options_list: mapping_rule = options_list['mapping_rule'] else: mapping_rule = None # Data processing date_values = [] date_rows = options_list['dates_info']['dates_rows'] for row_index in date_rows: date_values.append(data[row_index][start_date_col].value) num_of_dates = last_col - start_date_col first_label, time_line = date_func(date_values, num_of_dates) times_series = warehouse.add_time_scale(series_name, time_line) for row_index in range(start_data_row, len(data)): meta = [] for item in meta_cols: copy_item = item.copy() column_index = copy_item['Col_number'] copy_item['Name'] = data[row_index][column_index].value.strip() meta.append(copy_item) if mapping_rule is not None: new_meta, is_mapped = mapping(meta, mapping_rule) if is_mapped: meta = new_meta # Using db interface var_name = data[row_index][name_col].value if has_map_names: if var_name in map_names: var_name = map_names[var_name] entity = warehouse.add_entity(meta) variable = warehouse.force_variable(entity, var_name, 'float') time_series = warehouse.force_time_series(variable, times_series) values = [] for col_index in range(start_date_col, last_col): value = data[row_index][col_index].value if value == '': value = 0.0 values.append(value) time_series.set_values(first_label, values)
def jj_oral_care_sku(warehouse, wb, options_list): t1 = datetime.datetime.now() ws = wb.sheet_by_index(0) data = get_cell_range(0, 0, ws.ncols, ws.nrows, ws) meta_cols = options_list['meta_cols'] date_func = options_list['date_func'] header_row_index = options_list['info']['header_row'] name_col = options_list['name_col'] map_names = options_list['map_names'] series_name = options_list['dates_info']['scale'] start_data_row = options_list['info']['data_row'] start_date_col = options_list['dates_info']['start_column'] last_col = options_list['dates_info']['end_column'] if last_col == '': last_col = get_last_col(data, header_row_index) # Rename headers cols: names for item in meta_cols: column_number = item['Col_number'] if column_number >= last_col: raise ex.NotExistsError('DataProcessing', 'column', column_number) if item['Dimension_name'] == '': item['Dimension_name'] = data[header_row_index][column_number]\ .value if 'mapping_rule' in options_list: mapping_rule = options_list['mapping_rule'] else: mapping_rule = None num_of_dates = last_col - start_date_col first_label, time_line = date_func( data[header_row_index][start_date_col].value, wb.datemode, num_of_dates) times_series = warehouse.add_time_scale(series_name, time_line) for row_index in range(start_data_row, len(data)): meta = [] for item in meta_cols: copy_item = item.copy() column_index = copy_item['Col_number'] copy_item['Name'] = data[row_index][column_index].value.strip() meta.append(copy_item) if mapping_rule is not None: new_meta, is_mapped = mapping(meta, mapping_rule) if is_mapped: meta = new_meta # Using db interface var_name = data[row_index][name_col].value if var_name in map_names: var_name = map_names[var_name] entity = warehouse.add_entity(meta) variable = warehouse.force_variable(entity, var_name, 'float') time_series = warehouse.force_time_series(variable, times_series) values = [] for col_index in range(start_date_col, last_col): value = data[row_index][col_index].value if value == '': value = 0.0 values.append(value) time_series.set_values(first_label, values) t2 = datetime.datetime.now() delta = (t2 - t1) minutes_delta_time = delta.seconds / 60.0 print('Algorithm sku takes minutes:' + str(minutes_delta_time)) print('Algorithm sku takes seconds:' + str(delta.seconds))