def insert_rows(items): """Insert timeseries data. Args: items: List of IDXTimestampValue objects Returns: result: DataPoint.checksum value """ # Initialize key variables _rows = [] last_timestamps = {} polling_intervals = {} # Fail safe checks if bool(items) is False: return # Update the data for item in sorted(items, key=attrgetter('timestamp')): # Insert data value = round(item.value, 10) _rows.append( Data(idx_datapoint=item.idx_datapoint, timestamp=item.timestamp, value=value)) # Get the most recent timestamp for each idx_datapoint if item.idx_datapoint in last_timestamps: last_timestamps[item.idx_datapoint] = max( item.timestamp, last_timestamps[item.idx_datapoint]) else: last_timestamps[item.idx_datapoint] = item.timestamp polling_intervals[item.idx_datapoint] = item.polling_interval # Update the last_timestamp for idx_datapoint, timestamp in last_timestamps.items(): with db.db_modify(20047, die=False) as session: session.query(DataPoint).filter( and_(DataPoint.idx_datapoint == idx_datapoint, DataPoint.enabled == 1)).update({ 'last_timestamp': timestamp, 'polling_interval': int(polling_intervals[idx_datapoint]) }) # Update after updating the last timestamp. Helps to prevent # 'Duplicate entry' errors in the event you need to re-run the ingester # after a previous crash. if bool(_rows) is True: with db.db_modify(20012, die=True) as session: session.add_all(_rows)
def insert_rows(idx_datapoint, _idx_pairs): """Create db Pair table entries. Args: idx_datapoint: DataPoint.idx_datapoint _idx_pairs: List of Pair.idx_pair values Returns: None """ # Initialize key variables rows = [] # Create a list for processing if not available if isinstance(_idx_pairs, list) is False: _idx_pairs = [_idx_pairs] # Iterate over _idx_pairs for idx_pair in _idx_pairs: pair_exists = glue_exists(idx_datapoint, idx_pair) if bool(pair_exists) is False: # Insert and get the new idx_datasource value row = Glue(idx_pair=idx_pair, idx_datapoint=idx_datapoint) rows.append(row) if bool(rows) is True: with db.db_modify(20002, die=True) as session: session.add_all(rows)
def insert_row(row): """Create a User table entry. Args: row: DbRowUser object Returns: None """ # Verify values if bool(row) is False or isinstance(row, DbRowUser) is False: log_message = 'Invalid user type being inserted' log.log2die(20070, log_message) # Lowercase the name username = row.username.strip()[:MAX_KEYPAIR_LENGTH] password = row.password[:MAX_KEYPAIR_LENGTH] first_name = row.first_name.strip()[:MAX_KEYPAIR_LENGTH] last_name = row.last_name.strip()[:MAX_KEYPAIR_LENGTH] role = int(row.role) password_expired = int(row.password_expired) enabled = int(bool(row.enabled)) # Insert row = _User(username=username.encode(), password=crypt.crypt(password).encode(), first_name=first_name.encode(), last_name=last_name.encode(), role=role, password_expired=password_expired, enabled=enabled) with db.db_modify(20054, die=True) as session: session.add(row)
def mutate(cls, _, info_, Input): data = _input_to_dictionary(Input) user = UserModel(**data) token_username = get_jwt_identity() # Getting current user making request to resource current_user = UserTable(token_username) # Accessing user data person = UserTable(user.username.decode()) # Checking that the user creating the new user is an admin if current_user.role != 0: raise GraphQLError('Only admins can create a new user!') # Checking that a given username is not taken if person.exists: raise GraphQLError('Username already exists!') # Creating new user entry into User table with db.db_modify(20150, close=False) as session: session.add(user) return CreateUser(user=user)
def insert_row(code, name=''): """Create a Language table entry. Args: code: Language code name: Language code name Returns: None """ # Verify values if bool(name) is False or isinstance(name, str) is False: name = 'Change me. Language name not provided.' if bool(code) is False or isinstance(code, str) is False: log_message = 'Language code "{}" is invalid'.format(code) log.log2die(20033, log_message) # Lowercase the code code = code.strip().lower()[:MAX_KEYPAIR_LENGTH] name = name.strip()[:MAX_KEYPAIR_LENGTH] # Insert row = Language(code=code.encode(), name=name.encode()) with db.db_modify(20032, die=True) as session: session.add(row)
def update_row(key, translation, units, idx_language, idx_pair_xlate_group): """Update a database PairXlate.agent row. Args: key: PairXlate key translation: PairXlate translation units: PairXlate units of measure idx_language: Language table index idx_pair_xlate_group: PairXlateGroup table index Returns: None """ # Insert and get the new agent value with db.db_modify(20080, die=False) as session: session.query(PairXlate).filter( and_(PairXlate.key == key.encode(), PairXlate.idx_language == idx_language, PairXlate.idx_pair_xlate_group == idx_pair_xlate_group)).update({ 'translation': translation.strip().encode(), 'units': units.strip().encode() })
def mutate(self, info_, Input): data = _input_to_dictionary(Input) user = UserModel(**data) with db.db_modify(20150, close=False) as session: session.add(user) return CreateUser(user=user)
def mutate(cls, _, info_, Input): data = _input_to_dictionary(Input) chart_datapoint = ChartDataPointModel(**data) with db.db_modify(20147, close=False) as session: session.add(chart_datapoint) return CreateChartDataPoint(chart_datapoint=chart_datapoint)
def mutate(self, info_, Input): data = _input_to_dictionary(Input) chart = ChartModel(**data) with db.db_modify(20142, close=False) as session: session.add(chart) return CreateChart(chart=chart)
def mutate(self, info_, Input): data = _create(Input) favorite = FavoriteModel(**data) with db.db_modify(20149, close=False) as session: session.add(favorite) return CreateFavorite(favorite=favorite)
def mutate(self, info_, Input): data = _input_to_dictionary(Input) user = UserModel(**data) # Create user only if they don't already exist person = UserTable(user.username.decode()) if person.exists is False: with db.db_modify(20150, close=False) as session: session.add(user) return CreateUser(user=user) # Return nothing otherwise return None
def mutate(cls, _, info_, Input): data = _input_to_dictionary(Input) # Update database with db.db_modify(20145) as session: session.query(ChartDataPointModel).filter_by( idx_chart_datapoint=data['idx_chart_datapoint']).update(data) # Get code from database with db.db_query(20146, close=False) as session: chart_datapoint = session.query(ChartDataPointModel).filter_by( idx_chart_datapoint=data['idx_chart_datapoint']).first() return UpdateChartDataPoint(chart_datapoint=chart_datapoint)
def mutate(self, info_, Input): data = _input_to_dictionary(Input) # Update database with db.db_modify(20143) as session: session.query(ChartModel).filter_by( idx_chart=data['idx_chart']).update(data) # Get code from database with db.db_query(20144, close=False) as session: chart = session.query(ChartModel).filter_by( idx_chart=data['idx_chart']).first() return UpdateChart(chart=chart)
def mutate(self, info_, Input): data = _input_to_dictionary(Input) # Update database with db.db_modify(20151) as session: session.query(UserModel).filter_by( idx_user=data['idx_user']).update(data) # Get code from database with db.db_query(20163, close=False) as session: user = session.query(UserModel).filter_by( idx_user=data['idx_user']).first() return UpdateUser(user=user)
def mutate(self, info_, Input): data = _update(Input) # Update database with db.db_modify(20153) as session: session.query(FavoriteModel).filter_by( idx_favorite=data['idx_favorite']).update(data) # Get code from database with db.db_query(20154, close=False) as session: favorite = session.query(FavoriteModel).filter_by( idx_favorite=data['idx_favorite']).first() return UpdateFavorite(favorite=favorite)
def password_expired(self, value): """Set the password_expired flag. Args: value: New value to apply Returns: None """ # Update with db.db_modify(20160, die=True) as session: session.query(_User).filter( _User.username == self._username.encode()).update( {'password_expired': int(bool(value))})
def enabled(self, value): """Modify enabled status. Args: value: New value to apply Returns: None """ # Update with db.db_modify(20161, die=True) as session: session.query(_User).filter( _User.username == self._username.encode()).update( {'enabled': int(bool(value))})
def insert_row(name): """Create the database PairXlateGroup row. Args: name: PairXlateGroup name Returns: None """ # Filter invalid data if isinstance(name, str) is True: # Insert and get the new pair_xlate value with db.db_modify(20063, die=True) as session: session.add(PairXlateGroup(name=name.strip().encode()))
def assign(_idx_agent, _idx_pair_xlate_group): """Assign an agent to an agent group. Args: idx_agent: Agent index _idx_pair_xlate_group: idx_pair_xlate_group for the agent Returns: None """ # Update with db.db_modify(20059, die=False) as session: session.query(Agent).filter(Agent.idx_agent == _idx_agent).update( {'idx_pair_xlate_group': _idx_pair_xlate_group})
def assign(_idx_agent, idx_agent_group): """Assign an agent to an agent group. Args: idx_agent: Agent index idx_agent_group: Agent group index Returns: None """ # Update with db.db_modify(20059, die=False) as session: session.query(Agent).filter(Agent.idx_agent == _idx_agent).update( {'idx_agent_group': idx_agent_group})
def password(self, value): """Modify. Args: value: New value to apply Returns: None """ # Initialize key variables _value = crypt.crypt(value).encode() with db.db_modify(20158, die=True) as session: session.query(_User).filter( _User.username == self._username.encode()).update( {'password': _value})
def remove_test_entry(self, name, target_table): """Removes a given test entry from a target table Args: name: Corresponding name of test entry in target_table target_table: Table to look for entry to be removed Return: None """ with db.db_modify(31003) as session: query = session.query(target_table) entry = query.filter_by(name = name.encode()).first() session.delete(entry) session.commit()
def role(self, value): """Modify. Args: value: New value to apply Returns: None """ # Update _value = int(value) with db.db_modify(20159, die=True) as session: session.query(_User).filter( _User.username == self._username.encode()).update( {'role': _value})
def update_name(code, name): """Upadate a Language table entry. Args: code: Language code name: Language code name Returns: None """ # Update code = code.strip().lower() with db.db_modify(20048, die=False) as session: session.query(Language).filter(Language.code == code.encode()).update( {'name': name.strip().encode()})
def first_name(self, value): """Modify first name. Args: value: New value to apply Returns: None """ # Update _value = value.strip()[:MAX_KEYPAIR_LENGTH].encode() with db.db_modify(20156, die=True) as session: session.query(_User).filter( _User.username == self._username.encode()).update( {'first_name': _value})
def update_name(idx, name): """Upadate a PairXlateGroup table entry. Args: idx: PairXlateGroup idx_pair_xlate_group name: PairXlateGroup idx_pair_xlate_group name Returns: None """ # Filter invalid data if isinstance(name, str) is True: with db.db_modify(20065, die=False) as session: session.query(PairXlateGroup).filter( PairXlateGroup.idx_pair_xlate_group == int(idx)).update( {'name': name.strip().encode()})
def update_row(key, translation, idx_language): """Update a database AgentXlate.agent row. Args: key: AgentXlate key translation: AgentXlate translation idx_language: Language table index Returns: None """ # Insert and get the new agent value with db.db_modify(20131, die=False) as session: session.query(AgentXlate).filter(and_( AgentXlate.agent_program == key.encode(), AgentXlate.idx_language == idx_language)).update( {'translation': translation.strip().encode()} )
def insert_rows(items): """Create db Pair table entries. Args: items: List of lists, or list of key-value pairs Returns: None """ # Initialize key variables _rows = [] uniques = {} all_kvs = [] # Make list if not so if isinstance(items, list) is False: items = [items] # Create a single list of key-value pairs. # Add them to a dict to make the pairs unique. for item in items: if isinstance(item, list): all_kvs.extend(item) else: all_kvs.append(item) for _kv in all_kvs: uniques[_kv] = None # Insert the key-value pairs into the database for (key, value), _ in uniques.items(): # Skip pre-existing pairs if bool(pair_exists(key, value)) is True: continue # Add values to list for future insertion _row = Pair(key=key.encode(), value=value.encode()) _rows.append(_row) if bool(_rows) is True: with db.db_modify(20007, die=True) as session: session.add_all(_rows)
def insert_row(agent_id, agent_target, agent_program): """Create the database Agent.agent value. Args: agent_id: Agent ID value (pattoo_agent_id) agent_target: Agent target (pattoo_agent_polled_target) agent_program: Agent program (pattoo_agent_program) Returns: None """ # Filter invalid data if isinstance(agent_id, str) is True: # Insert and get the new agent value with db.db_modify(20036, die=True) as session: session.add( Agent(agent_id=agent_id.encode(), agent_polled_target=agent_target.encode(), agent_program=agent_program.encode()))
def insert_row(key, translation, idx_language): """Create a database AgentXlate.agent row. Args: key: AgentXlate key translation: AgentXlate translation idx_language: Language table index Returns: None """ # Insert and get the new agent value with db.db_modify(20130, die=True) as session: session.add( AgentXlate( agent_program=str(key).strip().encode(), translation=str(translation).strip().encode(), idx_language=idx_language ) )