def fillJobList(self):
manager = DBManager()
listJobs = manager.run(
"SELECT JOBNAME, DESCRIPTION FROM JOBS WHERE POSTERID = %s",
(self.user.posterid, ))
manager.close()
filledRow = 4
for job in listJobs:
jobName = job[0]
jobDesc = job[1]
self.root.grid_rowconfigure(filledRow, minsize=20)
self.root.grid_rowconfigure(filledRow + 1, minsize=20)
jobNameLabel = Label(self.root, text=jobName, justify=LEFT)
jobNameLabel.config(font=('Calibri', 15))
jobNameLabel.grid(row=filledRow, sticky=W, padx=2)
jobDescLabel = Label(self.root, text=jobDesc, justify=LEFT)
jobDescLabel.config(font=('Calibri', 10))
jobDescLabel.grid(row=filledRow + 1,
sticky=W,
padx=2,
columnspan=2)
filledRow = filledRow + 2
def __init__(self, windowSize):
self.windowSize = windowSize
self.dbManager = DBManager()
self.dictionary = self.dbManager.selectDictionaryDB()
self.isWindowValid = self.dbManager.isWindowValid(self.windowSize)
self.analyzer = Analyzer(self.windowSize, self.dictionary)
self.analyzer.fillMatrixSearch(self.dbManager.coocToDictWindow(self.windowSize))
def __init__(self):
self.db = DBManager.DBManager()
self.mapped_sections = {
'BACKGROUND': 0,
'OBJECTIVE': 1,
'METHODS': 2,
'RESULTS': 3,
'CONCLUSIONS': 4
}
self.mapped_sections_num = {
'0': 'BACKGROUND',
'1': 'OBJECTIVE',
'2': 'METHODS',
'3': 'RESULTS',
'4': 'CONCLUSIONS'
}
self.sentences_count_original = {}
self.sentences_count_mapped = {
'BACKGROUND': 0,
'OBJECTIVE': 0,
'METHODS': 0,
'RESULTS': 0,
'CONCLUSIONS': 0,
'-': 0
}
def addUserToDB():
messages = getMessages()
list_usernames = list(map(lambda m: (m['user_code'], m['username']), messages))
list_unique_usernames = list(set(list_usernames))
dbm = DBManager.DBManager('localhost', '27017', 'chatdb')
usermap = {}
for e in list_unique_usernames:
res = dbm.create_user(e[1])
usermap[e[0]] = str(res)
list_chats = list(map(lambda m: m['chat_code'], messages))
list_unique_chats = list(set(list_chats))
chatmap = {}
for e in list_unique_chats:
chat_messages = filter(lambda m: m['chat_code'] == e, messages)
list_users_code = list(map(lambda m: m['user_code'], chat_messages))
list_unique_users_code = list(set(list_users_code))
list_unique_users_id = list(map(lambda c: usermap[c], list_unique_users_code))
res = dbm.create_chat(list_unique_users_id)
chatmap[e] = str(res)
for m in messages:
message = {'user_id': usermap[m['user_code']], 'text': m['text']}
dbm.chat_add_message(chatmap[m['chat_code']], message)
def __init__(self):
self.db = DBManager.DBManager()
if self.db == None:
Log.error("dbManager is None!")
else:
if self.db.DBconnect():
self.dbSwitch = self.db.dbSwitch
else:
pass
self.SSdb = SensorsanalyticsDdManger.SensorsanalyticsDdManger()
if self.SSdb == None:
Log.error("SSdbManager is None!")
else:
self.SSdb.SSDBconnect()
self.ssSwich = self.SSdb.ssSwitch
config = Config.Config()
if config == None:
Log.error("Config is None!")
else:
config.SetConfigPath("")
constconfig = config.loadConstConfig()
self.logPath = constconfig["log_path"]
self.backupPath = constconfig["backup_path"]
self.errPath = constconfig["err_path"]
pass
def applyJob(self, jobid, jobname):
result = messagebox.askquestion(
"Applying for job: " + jobname,
"Your resume will be shared to the poster. Apply?")
if result == 'yes':
db = DBManager()
try:
userInfo = db.run(
"SELECT * FROM APPLICANT WHERE USERNAME = %s;",
(self.user.username, ))
db.run(
"INSERT INTO APPLICATIONS VALUES(%s, %s, %s, %s, %s, %s);",
(
int(jobid),
userInfo[0][2],
userInfo[0][0],
userInfo[0][1],
userInfo[0][3],
userInfo[0][4],
))
db.close()
messagebox.showinfo("APPLIED",
"Your application has been sent.")
except Exception as e:
print(e)
db.close()
messagebox.showerror("ERROR", e)
def EditProduct(self, productId, name, prace, url, note):
DBManager.DBManager().ExecuteSQL('UPDATE wishlistDB.PRODUCTS SET ' +
' NAME = \'' + name + '\', ' +
' PRACE = ' + str(prace) + ', ' +
' URL = \'' + url + '\', ' +
' NOTE = \'' + note + '\' ' +
' WHERE ID = ' + str(productId) + ';')
return True
def set_veiculo(self):
data = datetime.today()
banco = DBManager()
banco.inserir_veiculo(self.__edPlaca.get().upper(), data, self.__tipo)
messagebox.showinfo('Aviso', 'Veículo inserido com sucesso!')
self.__edPlaca.focus_force()
self.__edPlaca.delete(0, END)
def __init__(self, db_file="temp.db", db_manager=None):
self.url = "https://www.protestchicago.com/"
self.db_file = db_file
if db_manager is None:
self.db_manager = DBManager(self.db_file)
else:
self.db_manager = db_manager
def lista_insert(self):
banco = DBManager()
listabanco = banco.consulta_tabela()
for pos, linha in enumerate(listabanco):
self.__lista_listbox[0].insert(END, listabanco[pos][0])
self.__lista_listbox[1].insert(END, listabanco[pos][1])
self.__lista_listbox[2].insert(END, listabanco[pos][2])
self.__lista_listbox[3].insert(END, listabanco[pos][4])
def __init__(self):
self._DBHandle = DBManager()
self._DBCur = self._DBHandle.getDBCur()
self._DBCon = self._DBHandle.getDBCon()
self._URLInstance = URLBuilder()
self._code = ""
self._Component = ""
self._fileSet = set()
pass
def get(self):
query = self.get_query_argument("index")
if query:
db = DBManager()
q = getList(db, query)
record = str(q)
record = record[1:len(record) - 1]
self.content_type = 'application/json'
self.write(json_encode(json.loads("[" + record + "]")))
def pagar(self):
banco = DBManager()
# recupera a id do usuário do banco em forma de tupla
id_usuario = banco.consulta_tabela_funcionarioid(self.__usuario)
#registra no banco os dados do pagamento
banco.pagar(Calcular.__placa, self.setPlaca(), id_usuario[0])
#limpa a caixa de texto edplaca
self.__edplaca.delete(0, END)
#mensagem de aviso para pagamento realizado
messagebox.showinfo("Aviso", "Pagamento registrado!")
def __get_hora_entrada(self, placa):
try:
banco = DBManager()
entrada = banco.consulta_placa(placa)
Calcular.__entrada = datetime.strptime(entrada[0], '%Y-%m-%d %H:%M:%S.%f')
return Calcular.__entrada
except TypeError:
messagebox.showinfo("Aviso", "Placa não consta no sistema")
self.__edplaca.delete(0, END)
self.__edplaca.focus_force()
def __init__(self):
self.janela = Tk()
self.banco = DBManager()
self.config()
self.listaNome()
self.lista()
Button(self.janela, text="Voltar", command=self.voltar).grid(row=0,
column=2)
self.janela.mainloop()
def cadastrar(self):
banco = DBManager()
banco.popular_tabela(self.__ednome.get(), self.__edturno.get(),
self.__edsenha.get(), self.__edcpf.get())
banco.consulta_tabela()
self.__ednome.delete(0, END)
self.__edturno.delete(0, END)
self.__edcpf.delete(0, END)
self.__edsenha.delete(0, END)
messagebox.showinfo("Aviso", "Usuário cadastrado com sucesso")
self.__lbnome.focus_force()
def main():
bearer_token = ""
user_id = 0
connection_string = ""
database_name = ""
collection_name = ""
bot = tb.TwitterBot(bearer_token, user_id)
manager = db.DBManager(connection_string, database_name, collection_name)
manager.connect()
busy_loop(bot, manager)
def __init__(self, pythonServer, clientSock, addr, sym_key):
threading.Thread.__init__(self)
self.security = Security()
# reference to parent server
self.pythonServer = pythonServer
# new open socket for client
self.clientSock = clientSock
# address connection : IP and Port
self.addr = addr
self.sym_key = None
# Dictionary of ptotocols functions : Key - level Value - referance to function
# self.operFnPtrDict = { 1 : self.oper1Fun, 2 : self.oper1Fun }
self.AES = AESCrypt()
self.DBManager = DBManager()
def login(self):
enteredUsername = self.usernameEntry.get()
enteredPassword = self.passwordEntry.get()
if enteredUsername == "" or enteredPassword == "":
messagebox.showerror("ERROR", "Fill all of the information")
else:
db = DBManager()
try:
outputUserPass = db.run(
"SELECT * FROM USERPASS WHERE USERNAME = %s;",
(enteredUsername, ))
registeredPassword = outputUserPass[0][1]
isPoster = (outputUserPass[0][2] == 1)
if enteredPassword == registeredPassword:
if not isPoster:
outputUserDetails = db.run(
"SELECT FNAME, SNAME, ADDRESS FROM APPLICANT WHERE USERNAME = %s",
(enteredUsername, ))
self.forget_widgets()
UserHome(
User(outputUserDetails[0][0],
outputUserDetails[0][1],
outputUserDetails[0][2], enteredUsername),
self.root)
else:
outputUserDetails = db.run(
"SELECT FNAME, SNAME, ADDRESS FROM POSTER WHERE USERNAME = %s",
(enteredUsername, ))
self.forget_widgets()
PosterHome(
Poster(outputUserDetails[0][0],
outputUserDetails[0][1],
outputUserDetails[0][2], enteredUsername),
self.root)
else:
print("HERE")
messagebox.showerror("ERROR",
"Incorrect username or password")
db.close()
except Exception as e:
print(e)
db.close()
messagebox.showerror("ERROR", "Incorrect username or password")
def __init__(self):
self._my_exchange_table = \
[[0 for col in range(self._NUMBER_OF_RSC + 1)] for row in range(self._NUMBER_OF_RSC + 1)]
self._other_exchange_table = \
[[0 for col in range(self._NUMBER_OF_RSC + 1)] for row in range(self._NUMBER_OF_RSC + 1)]
self._rsc_enum = {'food': 0, 'water': 1}
# Information of Civilization
self._total_population = 0
self._total_tools = 0
# Initialize it
self._init_rsc_table(self._my_exchange_table, -1)
self._init_rsc_table(self._other_exchange_table, -1)
self._degree_of_civilized = 0
# Resource Object List
self._food = Food(0)
self._water = Water(0)
# Person Object Lists
# 여기 수정중
self._food_maker = FoodMaker(has_tool=0,
_food=self._food,
_water=self._water,
_population=0)
self._water_maker = WaterMaker(has_tool=0,
_food=self._food,
_water=self._water,
_population=0)
# Communication Data(Dictionary)
self._civil1_info_dic = {
'Civil1_NumPeople': self._total_population,
'Civil1_Food': self._food.getquantity(),
'Civil1_Water': self._water.getquantity(),
'Civil1_DegOfCivilized': self._degree_of_civilized,
}
self._civil2_info_dic = {
'Civil2_NumPeople': 0,
'Civil2_Food': 0,
'Civil2_Water': 0,
'Civil2_DegOfCivilized': 0,
}
self._db_manager = DBManager.DBManager(
civil_dic1=self._civil1_info_dic, civil_dic2=self._civil2_info_dic)
def __init__(self, windowSize, wordQty, clusterWordList, clusterQty,
clusteringType):
self.windowSize = windowSize
self.wordQty = int(wordQty)
self.clusterWordList = clusterWordList
self.nbOfClusters = int(clusterQty)
self.clusteringType = clusteringType
self.dbManager = DBManager()
self.mainWordDict = self.dbManager.selectDictionaryDB()
self.isWindowValid = self.dbManager.isWindowValid(self.windowSize)
self.analyzer = Analyzer(self.windowSize, self.mainWordDict)
self.analyzer.fillMatrixSearch(
self.dbManager.coocToDictWindow(self.windowSize))
self.wordMatrix = self.analyzer.wordMatrix
self.centroidArrayArray = [[]]
def __init__(self,
dbmanager=DBManager.DBManager(),
server_host='localhost',
actuator_manager_port=11202):
threading.Thread.__init__(self)
self.dbm = dbmanager
if server_host == 'localhost':
self.HOST = socket.gethostbyname(socket.getfqdn(
)) # automatically assign ip address as server's own ip address
print(frontstr, "set HOST:" + self.HOST)
else:
self.HOST = server_host
print(self.HOST)
self.PORT = actuator_manager_port
def addJobInDatabase(self, root, title, desc):
db = DBManager()
try:
db.run(
"INSERT INTO JOBS(JOBNAME, DESCRIPTION, POSTERID) "
"VALUES(%s, %s, %s);", (title, desc, self.user.posterid))
messagebox.showinfo("ALERT", "Job Posted")
db.close()
self.fillJobList()
root.destroy()
except Exception as e:
print(e)
db.close()
messagebox.showerror("ERROR", e)
def fetchTicker(index):
global tickers
tickers = []
db = DBManager()
# session = con.cursor()
# session.execute('select symbol from ' + index)
#
# for row in session:
# tickers.append(row[1])
#
# count = session.execute('select count(symbol)as cn from ' + index)
# tickerCount = count[0].cn - 1
# # print(tickerCount)
data = getList(db, 'nasdaq')
data = json.loads(data)
for r in data:
for j in r["data"]:
tickers.append(j["symbol"])
obj = {"count": r["count"], "tickerList": tickers}
return obj
def __init__(self, parent):
wx.Frame.__init__(self, parent, title=self.mAppName, size=(820, 720))
self.mDBManager = DBManager.DBManager()
self.mPlotter = Plotter.Plotter(self.mDBManager)
# Splitter window
self.sp = wx.SplitterWindow(self)
self.topPanel = wx.Panel(self.sp, style=wx.RAISED_BORDER)
self.mainPanel = wx.Panel(self.sp)
self.sp.SplitHorizontally(self.topPanel, self.mainPanel, 50)
self.mainPanel.SetBackgroundColour(wx.WHITE)
# Set the status bar
self.statusbar = self.CreateStatusBar()
self.statusbar.SetStatusText("")
#create label
text = wx.StaticText(self.topPanel, label='Events: ', pos=(0, 2))
font = self.GetFont()
font.SetPointSize(12)
text.SetFont(font)
# Create combo
filesList = self.getFilesList(self.mDBManager.mRawDataPath)
self.combo = wx.ComboBox(self.topPanel,
style=wx.CB_READONLY,
choices=filesList,
pos=(60, 2))
self.combo.Bind(wx.EVT_COMBOBOX, self.OnCombo)
# Crete buttons
self.myButton = wx.Button(self.topPanel,
-1,
'Plot',
size=(45, 24),
pos=(150, 2))
self.myButton.Bind(wx.EVT_BUTTON, self.graphPlot)
if __name__ == "__main__":
app = QApplication([])
logger = getLogger()
conf = getConf()
cloudService = YouDaoCloudService(conf, logger)
if cloudService.checkAuth() == False:
logger.debug("服务未认证,用户登陆")
tokens = cloudService.requestToken()
print "tokens", tokens
verifier = AuthorizeWidget.getVerifier(
BASE_URL + "/oauth/authorize?oauth_token=" + tokens["token"])
cloudService.accessToken(tokens["token"], tokens["secret"], verifier)
db = DBManager(conf, logger)
cloudNote = CloudNote(cloudService, db, conf, logger)
cloudNote.show()
syncThread = SyncThread(cloudNote)
syncThread.start()
syncThread.join()
# resp, content = cloudService.getUser()
# if resp['status'] == '200':
# logger.debug("getUser")
# print content, type(content)
# db.insertUser(content)
app.exec_()
format='%(levelname)s: %(message)s',
level=logging.INFO)
# Starting variables to have data collection run every x seconds
starttime = time.time()
dataCollectionInterval = 10.0
# Setting up UDP listener
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.settimeout(1)
port = 1854
server_address = ('10.0.0.71', port)
s.bind(server_address)
# Setting up database
redThumbdb = DBManager()
# Local flags
pictureFlag = False
waterFlag = False
# Json validator
def isJson(myjson):
try:
jsonObject = json.loads(myjson)
except ValueError:
return False
return True
from sqlalchemy.orm.exc import NoResultFound
from DBManager import *
from entities import *
from utils import *
app=Flask(__name__)
#解决跨域问题
CORS(app,supports_credentials=True)
#解决中文显示问题
app.config['JSON_AS_ASCII']=False
#设置密钥
app.config['SECRET_KEY']='CYCLONE_TEMPEST_TORNADO'
#连接数据库
db_manager=DBManager("mysql+mysqlconnector","47.107.86.216:3306","root","0C45313cea34","timecontrol")
if db_manager is not None:
print("DB is OK!")
# 创建新用户
@app.route('/create_user', methods=['POST', 'GET'])
def create_user():
p_account = request.values.get("account")
p_password = request.values.get("password")
print(p_account,p_password)
db_session = db_manager.create_session()
try:
user_exist = db_session.query(User).filter(User.account == p_account).one()
except NoResultFound:
def __init__(self, dbmanager = DBManager.DBManager(), mqtt_broker_host=''):
threading.Thread.__init__(self)
self.dbm = dbmanager
self.mqtt_broker_host = mqtt_broker_host
self.system_id = ""
def __init__(self, db_name):
self.db = DBManager(db_name)
self.parsers = [ProtestChicagoParser(db_manager=self.db)]
