def printMovieTimes(self, day_id): dbConn = DBConnection() cur = dbConn.connection() query = "SELECT id,time FROM movie_timings where day_id = ?" for row in cur.execute(query, day_id): print("[" + str(row[0]) + "]", "\t", row[1]) cur.close()
def __init__(self): self.db = DBConnection( 'postgresql://*****:*****@192.168.1.102/controllerdb') self.topology_manager = TopologyManager(self.db) self.ryu = RyuManager(self.db) self._current_mpls_label = 0 self._flows_added = 0
def printMovieDays(self, movie_id): dbConn = DBConnection() cur = dbConn.connection() query = "SELECT id,day FROM movie_days where movie_id = ?" for row in cur.execute(query, movie_id): print("[" + str(row[0]) + "]", "\t", row[1]) cur.close()
def __init__(self, args): self.con = DBConnection(args.uri, args.user, args.password) self.write_prepare() self.write_dict(args.dict) self.write_docs(args.docs) a = time.time() self.write_terms(args.terms) print(time.time() - a)
def get_game_level_info(cls): dbconn = DBConnection(conf.DB_GAME_INFO) cursor = dbconn.get_cursor() if not cursor or 'level_info' not in cursor.keys(): return None return cursor['level_info']
def getBookedSeatNos(self, time_id): dbConn = DBConnection() conn = dbConn.connection() cur = conn.cursor() seat_no = list() query = "SELECT row,col from movie_booking where time_id = ?" for row in cur.execute(query, time_id): seat_no.append(row) return seat_no
def printMovieList(self): dbConn = DBConnection() cur = dbConn.connection() print( "#########################\n#\tMovies \t\t#\n#########################" ) query = "SELECT * FROM movies" for row in cur.execute(query): print("[" + str(row[0]) + "]", "\t", row[1]) cur.close()
def get_game_user_info(cls, username, password): game_user = user.User(username, password) dbconn = DBConnection(conf.DB_USER) cursor = dbconn.get_cursor() uid = game_user.get_uid() if not cursor or uid not in cursor.keys(): return None return cursor[uid]
def getMovieTitle(self, id): dbConn = DBConnection() conn = dbConn.connection() cur = conn.cursor() query = "SELECT title from movies where id = ?" cur.execute(query, id) row = cur.fetchone() if row: return row[0] else: return False
def getMovieTime(self, id, dayID): dbConn = DBConnection() conn = dbConn.connection() cur = conn.cursor() query = "SELECT time from movie_timings where id = {0} and day_id = {1}".format( id, dayID) cur.execute(query) row = cur.fetchone() if row: return row[0] else: return False
def getMovieDay(self, id, movieID): dbConn = DBConnection() conn = dbConn.connection() cur = conn.cursor() query = "SELECT day from movie_days where id = {0} AND movie_id = {1}".format( id, movieID) cur.execute(query) row = cur.fetchone() if row: return row[0] else: return False
def bookTicket(self, time_id, seatnos, name): dbConn = DBConnection() conn = dbConn.connection() cur = conn.cursor() for seat in seatnos: (row, col) = seat query = "INSERT INTO movie_booking(time_id,row,col,username) values({0},{1},{2},'{3}')".format( time_id, row, col, str(name)) if cur.execute(query): conn.commit() else: return False return True
class DBOperation(object): def __init__(self): self.dbc = DBConnection() self.getDate = GetDate() def updateOEMToFacility(self): SQL = """ UPDATE T3 SET T3.ZRMK_0 = T1.ZRMK_0 FROM SORDERQ T1 LEFT JOIN PORDERQ T2 ON T1.SOHNUM_0 = T2.SOHNUM_0 AND T1.SOPLIN_0 = T2.SOPLIN_0 LEFT JOIN SORDERQ T3 ON T2.POHNUM_0 = T3.POHNUM_0 AND T2.POPLIN_0 = T3.POPLIN_0 WHERE T1.ZRMK_0 <> N'' AND T1.SALFCY_0 = N'0101' AND T3.ZRMK_0 = N'' """ self.dbc.execute(SQL)
def init_game_level(cls, max_level=69): dbconn = DBConnection(conf.DB_GAME_INFO) cursor = dbconn.get_cursor() if not cursor: cursor = {} if 'level_info' not in cursor.keys(): cursor['level_info'] = {} level_info = cursor['level_info'] level_info['max_level'] = max_level level_info['levels'] = [] for level in xrange(max_level): level_info['levels'].append(Util.__calc_level_exp(level+1)) dbconn.write_back(cursor)
class CreateCollectionGraph: def __init__(self, args): self.con = DBConnection(args.uri, args.user, args.password) self.write_prepare() self.write_dict(args.dict) self.write_docs(args.docs) a = time.time() self.write_terms(args.terms) print(time.time() - a) def write_prepare(self): qs = [] qs.append("CREATE CONSTRAINT ON (t:Term) ASSERT t.termid IS UNIQUE") qs.append("CREATE CONSTRAINT ON (t:Term) ASSERT t.term IS UNIQUE") qs.append("CREATE CONSTRAINT ON (d:Doc) ASSERT d.docid IS UNIQUE") qs.append( "CREATE CONSTRAINT ON (d:Doc) ASSERT d.collectionid IS UNIQUE") for q in qs: self.con.write(q) def write_dict(self, dict_filename): query = """ USING PERIODIC COMMIT 10000 LOAD CSV FROM 'file:///{}' AS line FIELDTERMINATOR '|' CREATE (:Term {{ termid: toInteger(line[0]), term: line[1], df: toInteger(line[2]) }}) """.format(dict_filename) self.con.write(query) def write_docs(self, docs_filename): query = """ USING PERIODIC COMMIT 10000 LOAD CSV FROM 'file:///{}' AS line FIELDTERMINATOR '|' CREATE (:Doc {{ docid: toInteger(line[1]), collectionid: line[0], len: toInteger(line[2]) }}) """.format(docs_filename) self.con.write(query) def write_terms(self, terms_filename): query = """ USING PERIODIC COMMIT 10000 LOAD CSV FROM 'file:///{}' AS line FIELDTERMINATOR '|' MATCH (d:Doc),(t:Term) WHERE d.docid = toInteger(line[1]) AND t.termid = toInteger(line[0]) CREATE (t)-[a:appearsIn {{count: toInteger(line[2])}}]->(d) """.format(terms_filename) self.con.write(query)
def main(): handle = DBConnection() queries = [ "some", "sql", "queries", "here..." ] for query in queries: handle.add(query) handle.commit() print("\nDone")
def __init__(self, parent=None): super().__init__(parent) self.undoStack = QUndoStack() self.db = DBConnection("172.16.6.137", "root", "password", "wahl") self.gui = Ui_MainWindow() self.gui.setupUi(self) self.gui.actionOpen.triggered.connect(self.open_file) self.gui.actionSave.triggered.connect(self.save_file) self.gui.actionSave_as.triggered.connect(self.save_file_as) self.gui.actionNew.triggered.connect(self.new_file) self.gui.actionCopy.triggered.connect(self.copy_cs) self.gui.actionAdd_Row.triggered.connect(self.add_rows) self.gui.actionSave_DB.triggered.connect(self.open_save_db) self.gui.actionOpen_DB.triggered.connect(self.open_load_db) self.gui.actionPaste.triggered.connect(self.paste) self.gui.actionCut.triggered.connect(self.cut) self.gui.actionDelete_Row.triggered.connect(self.remove_rows) self.gui.actionDuplicate_Row.triggered.connect(self.duplicate) self.gui.actionUndo.triggered.connect(self.undo) self.gui.actionRedo.triggered.connect(self.redo) self.gui.actionCreate_Prediction.triggered.connect(self.open_create_pred) self.gui.actionShow_Prediction.triggered.connect(self.open_choose_pred) self.gui.tableView.setSortingEnabled(True) self.gui.tableView.setItemDelegate(ItemDelegate(self.undoStack, self.set_unrdo_text)) self.tbm = DictTableModel(data=[], header=[], parent=self) self.sdb_dialog = SaveToDBDialog(self) self.ldb_dialog = LoadFromDBDialog(self) self.create_pred_dialog = CreatePredDialog(self) self.choose_pred_dialog = ChoosePredDialog(self) self.show_pred_dialog = ShowPredDialog(self) self.file = "."
def predict_accident(self): insert_into_DB = 1 db = DBConnection() conn = db.get_connection() mycursor = conn.cursor() mycursor.execute("SELECT path FROM buffer") buffer_items = mycursor.fetchall() for path_row in buffer_items: path = path_row[0] clf = Classify(path) class_name, percentage = clf.classify_image() if (class_name[0] is 'a' or class_name[0] is 'A') and (insert_into_DB is 1): insert_into_DB = 0 print('accident detected') Camera_id = 'CAM001' db1 = DBConnection() conn1 = db1.get_connection() mycursor1 = conn1.cursor() mycursor1.execute("SELECT count(path) FROM Accident") count_row = mycursor1.fetchone() new_path = '../accident/Accident' + str(count_row[0]) + '.jpg' copyfile(path, new_path) date_time = datetime.datetime.now().strftime( "%Y-%m-%d %H:%M:%S") timestamp = time.time() sql1 = "insert into Accident(Camera_id,path,date_time,timestampAcc) values(%s,%s,%s,%s);" mycursor1.execute( sql1, [Camera_id, new_path, date_time, int(timestamp)]) conn1.commit() mycursor1.execute( "UPDATE flag set flag_var = 1 where flag_key = 1;") conn1.commit() mycursor1.execute( "UPDATE smbool set continue_buffer = 0 where flag_var = 0") conn1.commit() if (insert_into_DB is 0): print('skipping database entry') sql = "DELETE FROM buffer WHERE path = %s" mycursor.execute(sql, [path]) conn.commit() os.remove(path)
def add_to_buffer(self): count = 0 db = DBConnection() conn = db.get_connection() mycursor = conn.cursor() mycursor.execute("SELECT path FROM vidbuffer") vid_buffer_items = mycursor.fetchall() for row in vid_buffer_items: should_continue = 1 path = row[0] vidcap = cv2.VideoCapture(path) success, image = vidcap.read() while success: img_path = "../buffer/frame" + str(count) + ".jpg" cv2.imwrite(img_path, image) db1 = DBConnection() conn1 = db1.get_connection() mycursor1 = conn1.cursor() mycursor1.execute("INSERT INTO `buffer`(`path`) VALUES (%s);", [img_path]) conn1.commit() count = count + 1 for _ in range(25): success, image = vidcap.read() mycursor1.execute( "SELECT continue_buffer FROM smbool where flag_var = 0") row1 = mycursor1.fetchone() should_continue = row1[0] print("should continue", should_continue) mycursor1.execute( "UPDATE smbool set continue_buffer = 1 where flag_var = 0") conn1.commit() if should_continue is 0: break mycursor1.execute("DELETE FROM `vidbuffer` WHERE `path` = %s", [path]) conn1.commit()
class WahlAnalyse(QMainWindow): def __init__(self, parent=None): super().__init__(parent) self.undoStack = QUndoStack() self.db = DBConnection("172.16.6.137", "root", "password", "wahl") self.gui = Ui_MainWindow() self.gui.setupUi(self) self.gui.actionOpen.triggered.connect(self.open_file) self.gui.actionSave.triggered.connect(self.save_file) self.gui.actionSave_as.triggered.connect(self.save_file_as) self.gui.actionNew.triggered.connect(self.new_file) self.gui.actionCopy.triggered.connect(self.copy_cs) self.gui.actionAdd_Row.triggered.connect(self.add_rows) self.gui.actionSave_DB.triggered.connect(self.open_save_db) self.gui.actionOpen_DB.triggered.connect(self.open_load_db) self.gui.actionPaste.triggered.connect(self.paste) self.gui.actionCut.triggered.connect(self.cut) self.gui.actionDelete_Row.triggered.connect(self.remove_rows) self.gui.actionDuplicate_Row.triggered.connect(self.duplicate) self.gui.actionUndo.triggered.connect(self.undo) self.gui.actionRedo.triggered.connect(self.redo) self.gui.actionCreate_Prediction.triggered.connect(self.open_create_pred) self.gui.actionShow_Prediction.triggered.connect(self.open_choose_pred) self.gui.tableView.setSortingEnabled(True) self.gui.tableView.setItemDelegate(ItemDelegate(self.undoStack, self.set_unrdo_text)) self.tbm = DictTableModel(data=[], header=[], parent=self) self.sdb_dialog = SaveToDBDialog(self) self.ldb_dialog = LoadFromDBDialog(self) self.create_pred_dialog = CreatePredDialog(self) self.choose_pred_dialog = ChoosePredDialog(self) self.show_pred_dialog = ShowPredDialog(self) self.file = "." def open_file(self): self.file = QFileDialog.getOpenFileName(self, "Choose File", filter="CSV-File (*.csv)")[0] if self.file != '': data, header = CSVUtil.read(self.file) self.tbm.set_data(data, header) self.gui.tableView.reset() self.gui.tableView.setModel(self.tbm) def save_file(self): if self.file != '' and self.file is not None: CSVUtil.write(self.file, self.tbm.get_data()) def save_file_as(self): self.file = QFileDialog.getSaveFileName(self, "CSV-Datei speichern", dir=self.file, filter="CSV-Datei (*.csv)")[ 0] if self.file != '': self.save_file() def new_file(self): self.file = "." self.tbm.set_data([], []) self.gui.tableView.reset() self.gui.tableView.setModel(self.tbm) self.undoStack.clear() self.set_unrdo_text() def copy_cs(self): if len(self.gui.tableView.selectionModel().selectedIndexes()) == 0: return clipboard = QApplication.clipboard() selected_index = self.gui.tableView.selectionModel().selectedIndexes()[0] selected_text = str(self.tbm.data(selected_index)) clipboard.setText(selected_text) def save_data_db(self, date): self.db.write_data(self.tbm.get_data(), date) def load_data_db(self, date): data, header = self.db.read_data(date) self.tbm.set_data(data, header) self.gui.tableView.reset() self.gui.tableView.setModel(self.tbm) self.undoStack.clear() self.set_unrdo_text() def create_prediction(self, termin, time): self.db.create_prediction(termin, time) def open_save_db(self): self.setDisabled(True) self.sdb_dialog.setEnabled(True) self.sdb_dialog.show() def open_load_db(self): self.ldb_dialog.update_dates(self.db.get_termine()) self.setDisabled(True) self.ldb_dialog.setEnabled(True) self.ldb_dialog.show() def open_create_pred(self): self.create_pred_dialog.update_dates(self.db.get_termine()) self.setDisabled(True) self.create_pred_dialog.setEnabled(True) self.create_pred_dialog.show() def open_choose_pred(self): self.choose_pred_dialog.update_predictions(self.db.get_predictions()) self.setDisabled(True) self.choose_pred_dialog.setEnabled(True) self.choose_pred_dialog.show() def show_prediction(self, date, time): data, header = self.db.get_prediction_data(date, time) self.show_pred_dialog.update_prediction(data, header, date, time) self.setDisabled(True) self.show_pred_dialog.setEnabled(True) self.show_pred_dialog.show() def set_unrdo_text(self): undo = "Undo" redo = "Redo" undo_txt = self.undoStack.undoText() redo_txt = self.undoStack.redoText() if undo_txt: undo += " \"" + undo_txt + "\"" if redo_txt: redo += " \"" + redo_txt + "\"" self.gui.actionUndo.setText(undo) self.gui.actionRedo.setText(redo) def get_sel_indexes(self): sel_indexes = self.gui.tableView.selectedIndexes() if sel_indexes: return [index for index in sel_indexes if not index.column()] def get_sel(self): sel_indexes = self.get_sel_indexes() if not sel_indexes: return self.tbm.rowCount(self), 1 first_sel_index = sel_indexes[0] sel_indexes = self.get_sel_indexes() if not first_sel_index or not first_sel_index.isValid(): return False startingrow = first_sel_index.row() return startingrow, len(sel_indexes) def remove_rows(self): if len(self.tbm.get_data()) == 0: return start, amount = self.get_sel() if start != len(self.tbm.get_data()): self.undoStack.beginMacro("Remove Rows") self.undoStack.push(RemoveRowsCommand(self.tbm, start, amount)) self.undoStack.endMacro() self.set_unrdo_text() def add_rows(self): if len(self.tbm.get_header()) == 0: return start, amount = self.get_sel() self.undoStack.beginMacro("Add Row") self.undoStack.push(InsertRowsCommand(self.tbm, start, 1)) self.undoStack.endMacro() self.set_unrdo_text() def paste(self): if len(self.gui.tableView.selectionModel().selectedIndexes()) == 0: return clipboard = QApplication.clipboard() index = self.gui.tableView.selectionModel().selectedIndexes()[0] command = EditCommand(self.tbm, index) command.newVal(str(clipboard.text())) self.undoStack.beginMacro("Paste") self.undoStack.push(command) self.undoStack.endMacro() self.set_unrdo_text() self.gui.tableView.reset() def cut(self): self.copy() index = self.gui.tableView.selectionModel().selectedIndexes()[0] command = EditCommand(self.tbm, index) command.newVal("") self.undoStack.beginMacro("Cut") self.undoStack.push(command) self.undoStack.endMacro() self.set_unrdo_text() self.gui.tableView.reset() def duplicate(self): if len(self.gui.tableView.selectionModel().selectedIndexes()) == 0: return start, amount = self.get_sel() self.undoStack.beginMacro("Duplicate Row") self.undoStack.push(DuplicateRowCommand(self.tbm, start)) self.undoStack.endMacro() self.set_unrdo_text() self.gui.tableView.reset() def undo(self): self.undoStack.undo() self.set_unrdo_text() self.gui.tableView.reset() def redo(self): self.undoStack.redo() self.set_unrdo_text() self.gui.tableView.reset()
from django.shortcuts import render # Create your views here. #views.py from login.forms import * from django.contrib.auth.decorators import login_required from django.contrib.auth import logout from django.views.decorators.csrf import csrf_protect from django.shortcuts import render_to_response from django.http import HttpResponseRedirect from django.template import RequestContext from dbconnection import DBConnection from login.forms import PostForm connection = DBConnection() val = connection.select() @csrf_protect def register(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): user = User.objects.create_user( username=form.cleaned_data['username'], password=form.cleaned_data['password1'], email=form.cleaned_data['email']) return HttpResponseRedirect('/register/success/') else: form = RegistrationForm() variables = RequestContext(request, {'form': form})
#!/usr/bin/env python3 import os, sys sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'lib')) import romdb from config import Configuration from dbconnection import DBConnection dbxmlfname = Configuration.xml_dir() + "/db_suitobject.xml" filedbfname = Configuration.data_dir() + "/suitobject.db" conn = DBConnection() cur = conn.cursor() fields = romdb.load_field_xml(dbxmlfname) db_fields = romdb.DBFields(cur, 'suit', fields, [ 'basetype', 'suitlist' ]) db_fields.recreate_table([ ('guid', 'sys_name', 'id') ]) cur.execute('DROP TABLE IF EXISTS suit_bonus') cur.execute("""CREATE TABLE suit_bonus ( guid INTEGER NOT NULL, itemcount INTEGER NOT NULL, ordernum INTEGER NOT NULL, typeid INTEGER NOT NULL, value INTEGER NOT NULL, CONSTRAINT suitbouns_itemcount_range CHECK (itemcount >= 2 AND itemcount <= 9), CONSTRAINT suitbonus_ordernum_range CHECK (ordernum >= 1 AND ordernum <= 3), PRIMARY KEY (guid, itemcount, ordernum), FOREIGN KEY (typeid) REFERENCES sys_weareqtype (id), FOREIGN KEY (guid) REFERENCES suit
class QoSTracker: def __init__(self): self.db = DBConnection( 'postgresql://*****:*****@192.168.1.102/controllerdb') self.topology_manager = TopologyManager(self.db) self.ryu = RyuManager(self.db) self._current_mpls_label = 0 self._flows_added = 0 def start(self): self.db.delete_reservations() self.db.delete_queues() # self.topology_manager.init_db() switches = self.db.get_all_switches() for switch in switches: ryu_response = self.ryu.put_ovsdb_addr(switch.dpid) print "++ Adding ovsdb_addr for dpid:" + str( switch.dpid) + " returned: " + str(ryu_response.text) def generate_mpls_label(self): self._current_mpls_label += 1 return self._current_mpls_label def get_bw_for_src_dst(self, src, dst): src_map = SWITCH_MAP[str(src)] for port in src_map: if str(SWITCH_MAP[str(src)][port]["dpid"]) == str(dst): return SWITCH_MAP[str(src)][port]["bw"] def add_links(self, link_data): # TODO: Not great way to do this for link in link_data: bw = self.get_bw_for_src_dst(link.src.dpid, link.dst.dpid) self.db.add_link({ "src_port": link.src.dpid, "dst_port": link.dst.dpid, "bw": bw }) def add_switches(self, switch_data): for switch in switch_data: s = self.db.add_switch(switch, HOST_MAP[str(switch.dp.id)]) def add_single_switch_rules(self, switch, out_port, reservation): queues = [{"max_rate": "500000"}, {"min_rate": str(reservation.bw)}] response = self.ryu.add_egress_port_queue(switch, out_port.port_no, queues, 1000000) print response.text respone = self.ryu.add_single_switch_packet_checking_flow( switch, reservation.dst) print response.text print "Added single switch_rules" def add_reservation(self, rsv): print "Adding reservation" reservation = self.db.add_reservation(rsv, self.generate_mpls_label()) print "Added" in_port = self.db.get_port_for_id(reservation.in_port) in_switch = self.db.get_switch_for_port(in_port) last_port = self.db.get_port_for_id(reservation.out_port) last_switch = self.db.get_switch_for_port(last_port) path = self.topology_manager.get_route_to_host(rsv["dst"], in_switch) total_bw = self.topology_manager.get_max_bandwidth_for_path(path) print "Total Bandwidth: " + str(total_bw) available_bw = self.topology_manager.get_available_bandwidth_for_path( path) print "Available Bandwidth: " + str(available_bw) if not path: return if len(path) == 1: print "Correct path length" switch = path[0] print "Correct switch" self.add_single_switch_rules(switch, last_port, reservation) else: in_port_reservation = self.db.add_port_reservation( reservation.id, in_port.id) # TODO: this is stupid last_port_reservation = self.db.add_port_reservation( reservation.id, last_port.id) # Get the out port of the first switch and add the ingress rule first_switch_out_port_no = self.db.get_out_port_no_between_switches( in_switch, path[1], SWITCH_MAP) self.add_ingress_rules(in_switch, first_switch_out_port_no, reservation.src, reservation.dst, reservation.bw, total_bw) for i in range(1, len(path) - 1): in_port_no = self.db.get_in_port_no_between_switches_1( path[i - 1], path[i], SWITCH_MAP) in_port = self.db.get_port_for_port_no(in_port_no, path[i].dpid) out_port_no = self.db.get_out_port_no_between_switches( path[i], path[i + 1], SWITCH_MAP) self.add_switch_rules(path[i], out_port_no, reservation.src, reservation.dst, reservation.bw, total_bw) in_port_no = self.db.get_in_port_no_between_switches_1( path[-1], path[-2], SWITCH_MAP) in_port = self.db.get_port_for_port_no(in_port_no, path[i].dpid) out_port = self.db.get_port_for_id(reservation.out_port) self.add_switch_rules(path[-1], out_port.port_no, reservation.src, reservation.dst, reservation.bw, total_bw) def add_ingress_rules(self, switch, out_port_no, src_ip, dst_ip, bw, max_bw): # Add queues queues = [{"max_rate": str(max_bw)}, {"min_rate": str(bw)}] ryu_response = self.ryu.add_egress_port_queue(switch, out_port_no, queues, max_bw) print "++ Adding port queue for dpid:" + str( switch.dpid) + " returned: " + str(ryu_response.text) # Mark the packets on their way in ryu_response = self.ryu.add_packet_marking_flow(switch, src_ip, dst_ip) print "++ Adding packet marking flow for dpid:" + str( switch.dpid) + " returned: " + str(ryu_response.text) def add_switch_rules(self, switch, out_port_no, src_ip, dst_ip, bw, max_bw): # Add queues queues = [{"max_rate": str(max_bw)}, {"min_rate": str(bw)}] ryu_response = self.ryu.add_egress_port_queue(switch, out_port_no, queues, max_bw) print "++ Adding port queue for dpid:" + str( switch.dpid) + " returned: " + str(ryu_response.text) ryu_response = self.ryu.add_packet_checking_flow(switch) print "++ Adding packet checking flow for dpid:" + str( switch.dpid) + " returned: " + str(ryu_response.text)
bot.loading_failure["cache"] = e # ----------------------- START UP ----------------------------------- # load all Discord, MySQL, and API credentials tokenFile = open(AUTH_FILE_PATH, "r", encoding="utf-8") tokenLines = tokenFile.read().splitlines() tokens = {} for line in tokenLines: key_value = line.split(":") tokens[key_value[0]] = key_value[1] credentials.set_tokens(tokens) # Create MySQL connection bot.dbconn = DBConnection(credentials.tokens["MYSQL_USER"], credentials.tokens["MYSQL_PASSWORD"], "suitsBot") bot.loading_failure = {} # Load opus library if not discord.opus.is_loaded(): discord.opus.load_opus('opus') print("\n\n------------") print('Loading Data...') # Load data from database load() print("Loading cogs...") # Load cogs
def loadcache(): """ Load Cache values from database """ global currently_playing, scribble_bank try: currently_playing = utils.load_from_cache(bot.dbconn, "currPlaying", "") scribble_bank = utils.load_from_cache(bot.dbconn, "scribble", "").split(',') except Exception as e: bot.loading_failure["cache"] = e # ----------------------- START UP ----------------------------------- # Create MySQL connection bot.dbconn = DBConnection(tokens["MYSQL_USER"], tokens["MYSQL_PASSWORD"], "suitsBot") bot.loading_failure = {} # Load opus library if not discord.opus.is_loaded(): discord.opus.load_opus('opus') print("\n\n------------") print('Loading Data...') # Load data from database load() print("Loading cogs...") # Load cogs
def __init__(self): self.dbc = DBConnection() self.getDate = GetDate()
return "%d rows modified." % count else: ret = "Results:\n" for entry in rows: for key, val in entry.iteritems(): ret += "%s: %s\n" % (key, val) ret += "\n" return ret except db.IntegrityError: # Nothing changed return "Integrity error - nothing changed." except db.OperationalError, e: code, desc = e return "Database operational error - try again: " + desc except: return "Database operation error. Please try again" finally: if connection: self.disconnect() if __name__ == "__main__": m = MySQL() connection = DBConnection(username='******', password='******', db='otpasswd') print m.execute("insert into test values('a', 4)", connection) # vim:tabstop=4:expandtab
class DBOperation(object): def __init__(self): self.dbc = DBConnection() self.getDate = GetDate() def insertAccessToken(self,accessToken): SQL = """INSERT INTO WECHATACTO(ACCESSTOKEN_0,CREDATTIM_0,UPDDATTIM_0,AUUID_0,CREUSR_0,UPDUSR_0) VALUES(N'{0}',GETDATE(),GETDATE(),NEWID(),N'ADMIN',N'ADMIN')""".format(accessToken) self.dbc.execute(SQL) def getAccessToken(self): SQL = u"SELECT TOP 1 ACCESSTOKEN_0,DATEDIFF(SECOND,CREDATTIM_0,GETDATE()) EXPIRE FROM WECHATACTO ORDER BY CREDATTIM_0 DESC" return self.dbc.Query(SQL) def getUserID(self): SQL = u"SELECT USERID_0 FROM WECHATUSER" return self.dbc.Query(SQL) def getUserName(self, OPENID): SQL = u"""SELECT USERNAME_0 FROM WECHATUSER WHERE USERID_0 = N'{0}'""".format(OPENID) return self.dbc.Query(SQL) def insertUserID(self,ID, userName): SQL = u"""INSERT INTO WECHATUSER(USERID_0,USERNAME_0,CREDATTIM_0,UPDDATTIM_0,AUUID_0,CREUSR_0,UPDUSR_0) VALUES(N'{0}',N'{1}',GETDATE(),GETDATE(),NEWID(),N'ADMIN',N'ADMIN')""".format(str(ID),str(userName)) self.dbc.execute(SQL) def getX3UserInfo(self,X3UserName): SQL = u"SELECT USR_0,NOMUSR_0 FROM AUTILIS WHERE NOMUSR_0 LIKE N'%{0}%'".format(X3UserName) return self.dbc.Query(SQL) def getOEMSaleTodayTotal(self,facility): dateRange = self.getDate.Today() SQL = u""" SELECT T3.TEXTE_0, CONVERT(DECIMAL(18,2),SUM(T1.ORDINVATI_0)) ORDINVATI_0, CONVERT(DECIMAL(18,2),SUM(ISNULL(T1.ORDINVATI_0 * T2.RATE_0,T1.ORDINVATI_0))) PRORATE_0 FROM SORDER T1 LEFT JOIN EXCHANGERATE T2 ON T1.CUR_0 = T2.CURRENCYFROM_0 AND T2.CREDAT_0 BETWEEN N'{1}' AND N'{2}' LEFT JOIN ATEXTRA T3 ON T1.CUR_0 = T3.IDENT1_0 AND T3.LANGUE_0 = N'CHI' AND T3.ZONE_0 = N'INTDES' WHERE T1.SALFCY_0 = N'{0}' AND T1.CREDAT_0 BETWEEN N'{1}' AND N'{2}' GROUP BY T3.TEXTE_0 """.format(facility,dateRange["start"],dateRange["end"]) return self.dbc.Query(SQL) def insertExchangeRate(self,erFrom,erTo,rate): dateRange = self.getDate.Today() SQL = u''' INSERT INTO EXCHANGERATE(CURRENCYFROM_0,CURRENCYTO_0,CREDAT_0,RATE_0,CREDATTIM_0,UPDDATTIM_0,AUUID_0,CREUSR_0,UPDUSR_0) VALUES(N'{0}',N'{1}',N'{2}',N'{3}',GETDATE(),GETDATE(),NEWID(),N'ADMIN',N'ADMIN') '''.format(erFrom,erTo,dateRange["start"],rate) self.dbc.execute(SQL) def getTodayQuantity(self,facility,cur): dateRange = self.getDate.Today() SQL = u""" SELECT T2.ZISPART_0,CONVERT(DECIMAL(18,0),SUM(T1.QTY_0)) QTY_0 FROM SORDERQ T1 LEFT JOIN ITMMASTER T2 ON T1.ITMREF_0 = T2.ITMREF_0 LEFT JOIN SORDER T3 ON T1.SOHNUM_0 = T3.SOHNUM_0 LEFT JOIN ATEXTRA T4 ON T3.CUR_0 = T4.IDENT1_0 AND T4.LANGUE_0 = N'CHI' AND T4.ZONE_0 = N'INTDES' WHERE T1.SALFCY_0 = N'{0}' AND T1.CREDAT_0 BETWEEN N'{1}' AND N'{2}' AND T4.TEXTE_0 = N'{3}' GROUP BY T4.TEXTE_0,T2.ZISPART_0 ORDER BY T4.TEXTE_0 """.format(facility,dateRange["start"],dateRange["end"],cur) return self.dbc.Query(SQL) def selectExchangeRate(self): dateRange = self.getDate.Today() SQL = u""" SELECT CURRENCYFROM_0 FROM EXCHANGERATE WHERE CREDAT_0 BETWEEN N'{0}' AND N'{1}' """.format(dateRange["start"],dateRange["end"]) return self.dbc.Query(SQL) def getTodaySaleOrderDetails(self, facility, dateRange): SQL = """ SELECT T3.BPCNAM_0, T4.BPCNAM_0, T1.ITMREF_0, T2.ITMDES1_0, CONVERT(DECIMAL(18,2),T1.QTY_0), CONVERT(DECIMAL(18,2),T2.GROPRI_0), CONVERT(DECIMAL(18,2),T1.QTY_0 * T2.GROPRI_0), CONVERT(DECIMAL(18,2),ISNULL(T1.QTY_0 * T2.GROPRI_0 * T5.RATE_0,T1.QTY_0 * T2.GROPRI_0)), T3.BPCORD_0, T3.YBPCSHO_0, T1.ZRMK_0, T1.ZCUSNUM_0, T1.ZCUSNUMLIN_0, CONVERT(INT,T1.SOPLIN_0), T1.SOHNUM_0 FROM SORDERQ T1 LEFT JOIN SORDERP T2 ON T1.SOHNUM_0 = T2.SOHNUM_0 AND T1.SOPLIN_0 = T2.SOPLIN_0 LEFT JOIN SORDER T3 ON T1.SOHNUM_0 = T3.SOHNUM_0 LEFT JOIN BPCUSTOMER T4 ON T3.YBPCSHO_0 = T4.BPCNUM_0 LEFT JOIN EXCHANGERATE T5 ON T3.CUR_0 = T5.CURRENCYFROM_0 AND T5.CREDAT_0 = N'{1}' WHERE T1.CREDAT_0 BETWEEN N'{1}' AND N'{1}' AND T1.SALFCY_0 = N'{0}' ORDER BY T1.SOHNUM_0,T1.SOPLIN_0 """.format(facility,dateRange) return self.dbc.Query(SQL) def authorize(self, OPENID, facility): SQL = """ INSERT INTO WECHATAUTH(USERID_0,DIMENSION_0,FCY_0,CREDATTIM_0,UPDDATTIM_0,AUUID_0,CREUSR_0,UPDUSR_0) VALUES(N'{0}',N'SOP',N'{1}',GETDATE(),GETDATE(),NEWID(),N'ADMIN',N'ADMIN') """.format(OPENID, facility) self.dbc.execute(SQL) def deauthorize(self, *args): argsCount = len(args) if argsCount == 0: SQL = "DELETE FROM WECHATAUTH" elif argsCount == 2: OPENID = args[0] facility = args[1] SQL = """ DELETE FROM WECHATAUTH WHERE USERID_0 = N'{0}' AND DEMENSION_0 = N'SOP' AND FCY_0 = N'{1}' """.format(OPENID, facility) self.dbc.execute(SQL) def getAuthList(self,*args): argsCount = len(args) if argsCount == 0: SQL = """ SELECT T1.USERID_0,T2.USERNAME_0,T1.DIMENSION_0,T1.FCY_0 FROM WECHATAUTH T1 LEFT JOIN WECHATUSER T2 ON T1.USERID_0 = T2.USERID_0 """ elif argsCount == 1: SQL = """ SELECT T1.USERID_0,T2.USERNAME_0,T1.DIMENSION_0,T1.FCY_0 FROM WECHATAUTH T1 LEFT JOIN WECHATUSER T2 ON T1.USERID_0 = T2.USERID_0 WHERE T1.USERID_0 = N'{0}' """.format(args[0]) elif argsCount == 2: SQL = """ SELECT T1.USERID_0,T2.USERNAME_0,T1.DIMENSION_0,T1.FCY_0 FROM WECHATAUTH T1 LEFT JOIN WECHATUSER T2 ON T1.USERID_0 = T2.USERID_0 WHERE {} """.format(args[0], args[1]) return self.dbc.Query(SQL)
def __init__(self): self.db = DBConnection('sqlite:///my_db.db') self.topology_manager = TopologyManager(self.db) self.ryu = RyuManager(self.db) self._current_mpls_label = 0 self._flows_added = 0
class CCManagerRoot(Tk): dbifc = DBConnection() user = User.current(dbifc) def __init__(self, **kw): super().__init__(**kw) self.title("CQC - Kontroll diagram modul") self.active_panel = None self.active_toplevel = None self.ccobject = ControlChart() self.menubar = RootMenu(self) self.config(menu=self.menubar) self.menubar.lock() self.chartholder = ChartHolder(self) self.chartholder.update_image(None) self.chartholder.pack(**pkw) self.propspanel = None self.properties_button = Button( self, text="Tulajdonságok megjelenítése", state="disabled", command=lambda: self.launch_propspanel(stage=None)) self.properties_button.pack(**pkw) self.protocol("WM_DELETE_WINDOWS", self.teardown) def launch_propspanel(self, stage=None): if self.propspanel is not None: self.propspanel.destroy() self.propspanel = PropertiesPanel(self, self.ccobject, self.dbifc, stage) def savecc_cmd(self): if self.ccobject.unsaved is None: print("UNSAVED IS NONE! NOT SAVING!") return if self.ccobject.ccrec["id"] is None: self.dbifc.push_object(self.ccobject) else: self.dbifc.update_cc(self.ccobject) def newcc_cmd(self): if self.ccobject.unsaved: msg = ("A jelenlegi állapot nincs elmentve.", "Szeretnéd menteni?") if tkmb.askyesno("Mentetlen adat!", "\n".join(msg)): self.savecc_cmd() wiz = self._build_stage() if wiz is None: return self.launch_propspanel(wiz.stage) self.wait_window(self.propspanel) if self.propspanel.canceled: return self.ccobject.set_upstream_ids() self.propspanel = None IDs = self.dbifc.push_object(self.ccobject) rex = self.ccobject.rec for rectype, ID in IDs.items(): if rex[rectype]["id"] is None: rex[rectype]["id"] = ID else: assert rex[rectype]["id"] == ID self.chartholder.update_image(self.ccobject) self.menubar.unlock() self.properties_button.configure(state="active") def opencc_cmd(self): wiz = SelectionWizard(self, creation_mode=False, skipempties=True, dbifc=self.dbifc) self.wait_window(wiz) if wiz.stage is None: return cc = ControlChart.from_database( dbifc=self.dbifc, ccID=wiz.selection["cc"], ) self.ccobject = cc self.chartholder.update_image(self.ccobject) self.menubar.unlock() self.properties_button.configure(state="active") def deletecc_cmd(self): msg = "Valóban törölni szeretnéd a kontroll diagramot?" if not tkmb.askyesno("Törlés megerősítése", msg): return if self.ccobject.ID is not None: self.dbifc.delete_cc(self.ccobject.ID) path = self.ccobject.pkldump() print("Backed up ControlChart object to", path) self.ccobject = ControlChart() self.chartholder.update_image(None) self.menubar.lock() def newpoints_cmd(self): mtl = NewMeasurements(self, rown=3, title="Pontok bevitele") self.wait_window(mtl) print("VALUES : ", ", ".join(map(str, mtl.measure["value"]))) print("DATES : ", ", ".join(map(str, mtl.measure["date"]))) print("COMMENT: ", ", ".join(map(str, mtl.measure["comment"]))) mtl.measure.setall(cc_id=self.ccobject.ID, staff_id=self.user["id"], reference=False) self.ccobject.meas.incorporate(mtl.measure.data) self.dbifc.push_measurements(mtl.measure) self.chartholder.update_image(self.ccobject) def editpoints_cmd(self): mtl = EditMeasurements(self, self.ccobject.meas, rown=10, title="Pontok szerkesztése") self.wait_window(mtl) def _build_stage(self): wiz = SelectionWizard(self, creation_mode=True, skipempties=False, dbifc=self.dbifc) self.wait_window(wiz) if wiz.stage is None: return self.ccobject = ControlChart.build_stage(wiz.selection, wiz.stage, self.dbifc) return wiz def teardown(self): print("UI nice shutdown") self.destroy()
#!/usr/bin/env python3 import os, sys sys.path.append(os.path.join(os.path.dirname(__file__), "..", "lib")) import romdb from config import Configuration from dbconnection import DBConnection dbxmlfname = Configuration.xml_dir() + "/db_weaponobject.xml" filedbfname = Configuration.data_dir() + "/weaponobject.db" conn = DBConnection() cur = conn.cursor() fields = romdb.load_field_xml(dbxmlfname) # construct db table db_fields = romdb.DBFields(cur, "weapon", fields, ["eqtype", "dropability"]) db_fields.recreate_table([("guid", "sys_name", "id")]) cur.execute("DROP TABLE IF EXISTS weapon_ability") cur.execute( """CREATE TABLE weapon_ability ( guid INTEGER NOT NULL, ordernum INTEGER NOT NULL, abilityid INTEGER NOT NULL, CONSTRAINT weapon_ability_ordernum_range CHECK (ordernum >= 1 AND ordernum <= 6), CONSTRAINT weapon_ability_ability_range CHECK (abilityid / 10000 IN (51, 72)), PRIMARY KEY (guid, ordernum), FOREIGN KEY (guid) REFERENCES weapon
def install(): dbConn = DBConnection() conn = dbConn.connection() cur = conn.cursor() #creating movie table cur.execute( '''CREATE TABLE IF NOT EXISTS movies(ID INTEGER PRIMARY KEY AUTOINCREMENT, TITLE TEXT NOT NULL)''' ) cur.execute("INSERT INTO movies(TITLE) \ VALUES ('Die Hard 4.0')") cur.execute("INSERT INTO movies(TITLE) \ VALUES ('John Wick')") cur.execute("INSERT INTO movies(TITLE) \ VALUES ('John Wick 2')") cur.execute( '''CREATE TABLE IF NOT EXISTS movie_days(ID INTEGER PRIMARY KEY AUTOINCREMENT, movie_id INTEGER NOT NULL, day TEXT)''' ) cur.execute("INSERT INTO movie_days(movie_id,day) \ VALUES (1,'TUE')") cur.execute("INSERT INTO movie_days(movie_id,day) \ VALUES (1,'WED')") cur.execute("INSERT INTO movie_days(movie_id,day) \ VALUES (1,'FRI')") cur.execute("INSERT INTO movie_days(movie_id,day) \ VALUES (2,'MON')") cur.execute("INSERT INTO movie_days(movie_id,day) \ VALUES (2,'WED')") cur.execute("INSERT INTO movie_days(movie_id,day) \ VALUES (2,'THUR')") cur.execute("INSERT INTO movie_days(movie_id,day) \ VALUES (2,'FRI')") cur.execute("INSERT INTO movie_days(movie_id,day) \ VALUES (3,'FRI')") cur.execute( '''CREATE TABLE IF NOT EXISTS movie_timings(ID INTEGER PRIMARY KEY AUTOINCREMENT, day_id INTEGER NOT NULL, time TEXT)''' ) cur.execute( '''CREATE TABLE IF NOT EXISTS movie_booking ( `id` INTEGER PRIMARY KEY AUTOINCREMENT, `time_id` INTEGER NOT NULL, `row` INTEGER NOT NULL, `col` INTEGER NOT NULL, `username` TEXT NOT NULL )''' ) cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (1,'09:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (1,'11:30')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (2,'14:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (2,'20:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (3,'22:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (3,'22:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (4,'22:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (4,'22:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (5,'22:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (6,'22:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (7,'22:00')") cur.execute("INSERT INTO movie_timings(day_id,time) \ VALUES (8,'22:00')") conn.commit() conn.close()
class QoSTracker: def __init__(self): self.db = DBConnection('sqlite:///my_db.db') self.topology_manager = TopologyManager(self.db) self.ryu = RyuManager(self.db) self._current_mpls_label = 0 self._flows_added = 0 def start(self): self.db.delete_reservations() self.db.delete_queues() # self.topology_manager.init_db() switches = self.db.get_all_switches() for switch in switches: ryu_response = self.ryu.put_ovsdb_addr(switch.dpid) print "++ Adding ovsdb_addr for dpid:" + str(switch.dpid) + " returned: " + str(ryu_response.text) def generate_mpls_label(self): self._current_mpls_label += 1 return self._current_mpls_label def get_bw_for_src_dst(self, src, dst): src_map = SWITCH_MAP[str(src)] for port in src_map: if str(SWITCH_MAP[str(src)][port]["dpid"]) == str(dst): return SWITCH_MAP[str(src)][port]["bw"] def add_links(self, link_data): # TODO: Not great way to do this for link in link_data: bw = self.get_bw_for_src_dst(link.src.dpid, link.dst.dpid) self.db.add_link({ "src_port": link.src.dpid, "dst_port": link.dst.dpid, "bw": bw }) def add_switches(self, switch_data): for switch in switch_data: s = self.db.add_switch(switch, HOST_MAP[str(switch.dp.id)]) def add_single_switch_rules(self, switch, out_port, reservation): queues = [{"max_rate": "500000"}, {"min_rate": str(reservation.bw)}] response = self.ryu.add_egress_port_queue(switch, out_port.port_no, queues, 1000000) print response.text respone = self.ryu.add_single_switch_packet_checking_flow(switch, reservation.dst) print response.text print "Added single switch_rules" def add_reservation(self, rsv): print "Adding reservation" reservation = self.db.add_reservation(rsv, self.generate_mpls_label()) print "Added" in_port = self.db.get_port_for_id(reservation.in_port) in_switch = self.db.get_switch_for_port(in_port) last_port = self.db.get_port_for_id(reservation.out_port) last_switch = self.db.get_switch_for_port(last_port) path = self.topology_manager.get_route_to_host(rsv["dst"], in_switch) total_bw = self.topology_manager.get_max_bandwidth_for_path(path) print "Total Bandwidth: " + str(total_bw) available_bw = self.topology_manager.get_available_bandwidth_for_path(path) print "Available Bandwidth: " + str(available_bw) if not path: return if len(path) == 1: print "Correct path length" switch = path[0] print "Correct switch" self.add_single_switch_rules(switch, last_port, reservation) else: in_port_reservation = self.db.add_port_reservation(reservation.id, in_port.id) # TODO: this is stupid last_port_reservation = self.db.add_port_reservation(reservation.id, last_port.id) # Get the out port of the first switch and add the ingress rule first_switch_out_port_no = self.db.get_out_port_no_between_switches(in_switch, path[1], SWITCH_MAP) self.add_ingress_rules(in_switch, first_switch_out_port_no, reservation.src, reservation.dst, reservation.bw, total_bw) for i in range(1, len(path) - 1): in_port_no = self.db.get_in_port_no_between_switches_1(path[i-1], path[i], SWITCH_MAP) in_port = self.db.get_port_for_port_no(in_port_no, path[i].dpid) out_port_no = self.db.get_out_port_no_between_switches(path[i], path[i+1], SWITCH_MAP) self.add_switch_rules(path[i], out_port_no, reservation.src, reservation.dst, reservation.bw, total_bw) in_port_no = self.db.get_in_port_no_between_switches_1(path[-1], path[-2], SWITCH_MAP) in_port = self.db.get_port_for_port_no(in_port_no, path[i].dpid) out_port = self.db.get_port_for_id(reservation.out_port) self.add_switch_rules(path[-1], out_port.port_no, reservation.src, reservation.dst, reservation.bw, total_bw) def add_ingress_rules(self, switch, out_port_no, src_ip, dst_ip, bw, max_bw): # Add queues queues = [{"max_rate": str(max_bw)}, {"min_rate": str(bw)}] ryu_response = self.ryu.add_egress_port_queue(switch, out_port_no, queues, max_bw) print "++ Adding port queue for dpid:" + str(switch.dpid) + " returned: " + str(ryu_response.text) # Mark the packets on their way in ryu_response = self.ryu.add_packet_marking_flow(switch, src_ip, dst_ip) print "++ Adding packet marking flow for dpid:" + str(switch.dpid) + " returned: " + str(ryu_response.text) def add_switch_rules(self, switch, out_port_no, src_ip, dst_ip, bw, max_bw): # Add queues queues = [{"max_rate": str(max_bw)}, {"min_rate": str(bw)}] ryu_response = self.ryu.add_egress_port_queue(switch, out_port_no, queues, max_bw) print "++ Adding port queue for dpid:" + str(switch.dpid) + " returned: " + str(ryu_response.text) ryu_response = self.ryu.add_packet_checking_flow(switch) print "++ Adding packet checking flow for dpid:" + str(switch.dpid) + " returned: " + str(ryu_response.text)