def get_subtitle(subtitile: Subtitle,
location: str = "",
keep_zip_file: bool = False):
"""gets the subtitle itself and saves it to a specific location,
and returns True in case of succession"""
# write to the current location if there was no specified location
# if there was a one write to it
if location:
try:
os.chdir(location)
except:
Errors.location_error()
page = requests.get(subtitile.link)
soup = BeautifulSoup(page.content, "html.parser")
check_soup(soup, "To many requests", "Too many requests error")
download_link = URL_SITE + soup.find("a", {"id": "downloadButton"})["href"]
# getting the file and writing it to the disk
subtitle_zip_file = requests.get(download_link, allow_redirects=True)
with open(subtitile.title + ".zip", "wb") as file:
file.write(subtitle_zip_file.content)
# unzipping the subtitle zip file and putting the subtitles in a file with the same name
# as the subtitle title and the zip file name
with zipfile.ZipFile(subtitile.title + ".zip", "r") as zip_file:
zip_file.extractall(subtitile.title)
# removing the old zip file
if not keep_zip_file:
os.remove(subtitile.title + ".zip")
return True
def checkOrderErrors(self, main_type, bun_type, patty_type, ingredients,
Main_size, main_q, Other_type, sides_size, side_q):
errors = Errors(main_type, bun_type, patty_type, ingredients,
Main_size, main_q, Other_type, sides_size, side_q,
self._inventory)
err = errors.check()
if (self.checkErrors(err)):
return 'Failed to place order.'
def main():
data = get_args(argv)
if data["type"] == "movie":
movie_subtitle(data["title"], data["language"], data["format"])
elif data["type"] == "series":
series_subtitle(data["title"], data["season"], data["episode"],
data["language"], data["format"])
else:
Errors.args_error()
def get_args(argv: list):
"""gets the args and dictionarize them"""
if len(argv) not in [5, 7]:
Errors.args_error()
data = {}
# getting the type of the title
if "-" in argv[1]:
data["type"] = "series" if argv[
1] == "-s" else "movie" if argv[1] == "-m" else None
else:
Errors.args_error()
# getting the title itself
data["title"] = argv[2]
data["format"] = argv[3]
data["language"] = argv[4]
if data["type"] == "series":
if len(argv) != 7:
Errors.args_error()
try:
data["season"] = int(argv[5])
data["episode"] = int(argv[6])
except:
Errors.args_error()
return data
def scanFail(self):
self.window.lbl_scan.hide()
self.errWindow = Errors(u'Error')
self.connect(self.errWindow, QtCore.SIGNAL('ErrorWindowClosing'),
self._setLabels)
self.errWindow.window.show()
self.window.hide()
def getItemButtonDict(self):
if len(self.itemsForSale)==0:
self.message=Errors(_(u'There are no items to sell'))
self.message.window.setWindowTitle(_(u'Message'))
self.message.window.show()
return
ibdict={}
itemButton=ItemButton(1, self.itemsForSale, self.window.Button_1, self.window.label_1)
self.connect(itemButton, QtCore.SIGNAL("SellItem"), self.payItem)
ibdict[1]= itemButton
itemButton=ItemButton(2, self.itemsForSale, self.window.Button_2, self.window.label_2)
self.connect(itemButton, QtCore.SIGNAL("SellItem"), self.payItem)
ibdict[2]= itemButton
itemButton=ItemButton(3, self.itemsForSale, self.window.Button_3, self.window.label_3)
self.connect(itemButton, QtCore.SIGNAL("SellItem"), self.payItem)
ibdict[3]= itemButton
itemButton=ItemButton(4, self.itemsForSale, self.window.Button_4, self.window.label_4)
self.connect(itemButton, QtCore.SIGNAL("SellItem"), self.payItem)
ibdict[4]= itemButton
itemButton=ItemButton(5, self.itemsForSale, self.window.Button_5, self.window.label_5)
self.connect(itemButton, QtCore.SIGNAL("SellItem"), self.payItem)
ibdict[5]= itemButton
itemButton=ItemButton(6, self.itemsForSale, self.window.Button_6, self.window.label_6)
self.connect(itemButton, QtCore.SIGNAL("SellItem"), self.payItem)
ibdict[6]= itemButton
return ibdict
def _showMessage(self, header, message):
self.message=Errors(message)
self.message.window.setWindowTitle(header)
self.message.window.show()
def __init__(self, path):
if path == 'TestDB':
self.dbContext = TestDb.TestDb()
elif path == 'SQLDB':
self.dbContext = MySQLDB.MySQLDB()
else:
self.message = Errors(_(u'There are no items to sell'))
self.message.window.setWindowTitle(_(u'Message'))
self.message.window.show()
def _getDbProvider(self, dbType):
try:
dbConnector = BDCon.BDCon(dbType) #('TestDB')
dbProvider = dbConnector.dbContext #Экземпляр подключенной базы данных
return dbProvider
except:
self.message = Errors(_(u'Database connection error'))
self.message.window.setWindowTitle(_(u'Error'))
self.message.window.show()
return
def main():
try:
if len(sys.argv) < 2:
raise Exception(
'ERRO: Caminho para arquivo codigo fonte nao digitado.')
errors = Errors()
lexAnalyzer = LexicalAnalyzer(sys.argv[1], errors)
SyntacticAnalyzer(lexAnalyzer, errors)
with open('saida.txt', 'w') as fp:
if errors.has_errors:
sorted_dict = sorted(errors.errors.keys())
for key in sorted_dict:
for item in errors.errors[key]:
fp.write(item + '\n')
else:
fp.write('Sucesso!')
except Exception as ex:
print(ex)
def writeFail(self):
self.window.lbl_write.hide()
self.errWindow=Errors(u'Error', 5000)
self.connect(self.errWindow, QtCore.SIGNAL('ErrorWindowClosing'), self._setLabels)
self.errWindow.window.show()
self.window.hide()
happyPalaces = [] # the happy palaces nees to be generated, it is an array
isBookIncluded = 1 # whether to generate words in the book or not
isCardIncluded = 1 # whether to generate words in the card or not
isErrorWordsIncluded = 1 # whether to generate the words in the error list or not
isSentencesIncluded = 1 # whether to generate the sentences in the book or not
books = Books()
bookChinese = books.bookChinese4 # select words in the fourth book in the elementary school
title = books.lessonTitle4
bookHappyChinese = books.bookHappyChinese4 # select words in the happy palace in the fourth book
sentencesChinese = books.bookSentence4 # select the sentences in the fourth book in the elementary school
cards = Cards()
cardChinese = cards.cardChinese4 # select the fourth card in the elementary school
cardHappyChinese = cards.cardHappyChinese4 # select the happy palaces in the fourth card in the elementary school
errors = Errors()
errorChinese = errors.errorChinese4 # select the fourth error words in the elementary school
errorHappyChinese = errors.errorHappyChinese4 # select the happy palace
line = ''
f_word = canvas.Canvas('Dictation.pdf')
f_word.setFont('STSong-Light', 16)
gPageCurrXPo = gPageLeftPo
gPageCurrYPo = gPageTopPo
for less in range(0, len(lessons)):
f_word.drawString(200, gPageCurrYPo, Title(lessons[less], f_word))
gPageCurrYPo -= gLessonTitleHe
if (isBookIncluded == 1):
DrawSubTitle(SubTitleBook(lessons[less], f_word), f_word)
def Warning(self, msg):
if self.errDist >= Parser.minErrDist:
Errors.Warn(msg)
self.errDist = 0
def SemErr(self, msg):
if self.errDist >= Parser.minErrDist:
Errors.SemErr(msg)
self.errDist = 0
def SynErr(self, errNum):
if self.errDist >= Parser.minErrDist:
Errors.SynErr(errNum)
self.errDist = 0
def staffSideErrors(self, side, side_size, side_q):
errors = Errors(None, None, None, None, None, None, side, side_size,
side_q, None)
err = errors.staffCheckSides()
if self.checkErrors(err):
return 'Failed to update sides.'
def staffMainErrors(self, main_type, main_size, main_q):
errors = Errors(main_type, None, None, None, main_size, main_q, None,
None, None, None)
err = errors.staffCheckMain()
if self.checkErrors(err):
return 'Failed to update main.'
def main(argv=None):
print 'Coco/R v%s for Python (May 16, 2007) - Translated by %s (%s)\n' % (
MetaData['version'], MetaData['author'], MetaData['author_email'])
if argv is None:
if len(sys.argv) == 1:
argv = [sys.argv[0], '-h']
else:
argv = sys.argv
options, args = Tab.parseArgs(argv)
ATGName = args[1]
dirName, fileName = os.path.split(ATGName)
# Setup the default frame directory
try:
if options.frameFileDir:
framesDir = options.frameFileDir
else:
framesDir = os.path.join(ROOT_DIR, 'frames')
CodeGenerator.frameDir = framesDir
Tab.frameDir = framesDir
except:
pass
# Initialize the Scanner
try:
s = open(fileName, 'r')
try:
strVal = s.read()
except IOError:
sys.stdout.write(
'-- Compiler Error: Failed to read from source file "%s"\n'
% fileName)
try:
s.close()
except IOError:
raise RuntimeError(
'-- Compiler Error: cannot close source file "%s"' %
fileName)
except IOError:
raise RuntimeError('-- Compiler Error: Cannot open file "%s"' %
fileName)
scanner = Scanner(strVal)
parser = Parser()
Errors.Init(fileName, dirName, Tab.ddt[5], parser.getParsingPos,
parser.errorMessages)
Trace.Init(dirName)
Tab.Init()
DFA.Init(fileName, dirName)
CodeGenerator.sourceDir = dirName
CodeGenerator.frameDir = Tab.frameDir
ParserGen.Init(fileName, dirName)
DriverGen.Init(fileName, dirName)
parser.Parse(scanner)
Errors.Summarize(scanner.buffer)
Trace.Close()
if Errors.count != 0:
sys.exit(1)
for image in dataInfo:
height = image["height"]
width = image["width"]
if 300 < int(height) and 300 < int(width):
myopener.retrieve(image['unescapedUrl'], "photos/"+searchTerm+'.jpg')
break
else:
error.log("No Valid Sizes for Query: "+searchTerm+". Height: "+str(height)+" Width: "+str(width))
else:
error.log("No Results for Query: "+searchTerm)
# Sleep for one second to prevent IP blocking from Google
time.sleep(1)
def getQueries(path):
textFile = open(path,"r")
queries = textFile.readlines()
for i in range(len(queries)):
queries[i] = queries[i].strip()
textFile.close()
return queries
error = Errors()
for query in getQueries("imagesToGet.csv"):
getImagesForTerm(query)
# getImagesForTerm("10293020idlfsdjfl34", 1)
error.close()
class MagazinesController(QObject):
OPERATION_OUTCOME = '-'
OPERATION_INCOME = '+'
def __init__(self, form):
QObject.__init__(self)
self.DbConnector = DbConnector()
self.form = form
self.ItemsList = self._getItemsList(
) #Список имеющихся предметов для выпадающего списка
self.MagazinsTable = self.form.window.tblw_Magazines
#Прописываем события кнопок для магазинов
self.form.window.btn_AddMag.clicked.connect(self._addMagazin)
self.form.window.btn_DelMag.clicked.connect(self._delMagazin)
self.form.window.btn_MagSave.clicked.connect(self._saveMagazins)
self.form.window.tblw_Magazines.cellClicked.connect(
self._magTableCellClicked)
self.form.window.btn_plus.clicked.connect(self._plusQty)
self.form.window.btn_minus.clicked.connect(self._minusQty)
def setUpMagazinsTable(self):
rowsFont = QFont('Lucida', 12, QtGui.QFont.Bold)
self.MagazinsTable.setFont(rowsFont)
headerFont = QFont('Lucida', 12, QtGui.QFont.Bold)
self.MagazinsTable.horizontalHeader().setFont(headerFont)
self.MagazinsTable.horizontalHeader().setResizeMode(
0, QHeaderView.ResizeToContents)
self.MagazinsTable.horizontalHeader().setResizeMode(
1, QHeaderView.Stretch)
self.MagazinsTable.horizontalHeader().setResizeMode(
2, QHeaderView.Stretch)
self.MagazinsTable.horizontalHeader().setResizeMode(
3, QHeaderView.Stretch)
self.MagazinsTable.verticalHeader().hide()
self._fillMagazinsTable()
@QtCore.pyqtSlot(name="fillMagazinsTable")
def _fillMagazinsTable(self):
self.ItemsList = self._getItemsList(
) #Список имеющихся предметов для выпадающего списка
rows = self.DbConnector.getMagazinsItemsMap()
if rows is None or len(rows) == 0:
return
self.MagazinsTable.setItemDelegateForColumn(3, NonEditColumnDelegate())
self.MagazinsTable.setRowCount(0)
counter = 0
for row in rows:
ItemIdMag = QtGui.QTableWidgetItem(str(str(row[0])))
ItemIdMag.setTextAlignment(QtCore.Qt.AlignCenter)
cmbx = QComboBox()
cmbx.addItems(self.ItemsList)
name = str(row[1])
index = cmbx.findText(name)
cmbx.setCurrentIndex(index)
ItemItemQty = QtGui.QTableWidgetItem(str(row[2]))
ItemItemQty.setTextAlignment(QtCore.Qt.AlignCenter)
ItemIdItem = QtGui.QTableWidgetItem(str(row[3]))
ItemIdItem.setTextAlignment(QtCore.Qt.AlignCenter)
self.MagazinsTable.insertRow(counter)
self.MagazinsTable.setItem(counter, 0, ItemIdMag)
self.MagazinsTable.setCellWidget(counter, 1, cmbx)
self.MagazinsTable.setItem(counter, 2, ItemItemQty)
self.MagazinsTable.setItem(counter, 3, ItemIdItem)
counter += 1
def _addMagazin(self):
rowCount = self.MagazinsTable.rowCount()
self.MagazinsTable.insertRow(rowCount)
ItemItemQty = QtGui.QTableWidgetItem()
ItemItemQty.setTextAlignment(QtCore.Qt.AlignCenter)
self.MagazinsTable.setItem(rowCount, 0, ItemItemQty)
cmbx = QComboBox()
cmbx.addItems(self.ItemsList)
cmbx.setCurrentIndex(-1)
self.MagazinsTable.setCellWidget(rowCount, 1, cmbx)
ItemItemQty = QtGui.QTableWidgetItem('0')
ItemItemQty.setTextAlignment(QtCore.Qt.AlignCenter)
self.MagazinsTable.setItem(rowCount, 2, ItemItemQty)
def _delMagazin(self):
currentRow = self.MagazinsTable.currentRow()
self.MagazinsTable.removeRow(currentRow)
def _saveMagazins(self):
MagazinsMappingList = []
for i in range(0, self.MagazinsTable.rowCount()):
row = []
for j in range(0, self.MagazinsTable.columnCount()):
wgt = self.MagazinsTable.cellWidget(i, j)
itemType = type(wgt)
if str(itemType) == '<class \'PyQt4.QtGui.QComboBox\'>':
value = wgt.currentText()
elif str(itemType) == '<type \'NoneType\'>':
try:
value = self.MagazinsTable.item(i, j).text()
except:
value = 0
row.append(value)
MagazinsMappingList.append(row)
if self._checkCorrectMagazineTable(MagazinsMappingList):
return
self._saveMagazinsMapping(MagazinsMappingList)
def _checkCorrectMagazineTable(self, MagazinsMappingList):
for i in range(0, len(MagazinsMappingList)):
magazine = MagazinsMappingList[i]
#Проверка заполнения номера магазина
if magazine[0] == 0:
self._showMessage(u'Ошибка', u'Не указан номер магазина')
return True
#Проверка числового значения в номере магазина
if self._isNotNumber(magazine[0]):
self._showMessage(
u'Ошибка', u'В поле номера магазина не числовое значение')
return True
#Проверка заполнения поля Количество
if magazine[2] == '0':
self._showMessage(u'Ошибка', u'Не заполнено поле "Количество"')
return True
#Проверка числового значения в поле Количество
if self._isNotNumber(magazine[2]):
self._showMessage(u'Ошибка',
u'В поле "Количество" не числовое значение')
return True
#Проверка уникальности номера магазина
for j in range(i + 1, len(MagazinsMappingList)):
if magazine[0] == MagazinsMappingList[j][0]:
self._showMessage(u'Ошибка',
u'Дублируются номера магазинов')
return True
return False
def _isNotNumber(self, value):
try:
num = (int)(value)
except:
return True
else:
return False
def _magTableCellClicked(self, row, column):
item = self.MagazinsTable.item(row, 0)
if item is None: return
magNum = item.text()
self.form.window.lbl_magNumber.setText(magNum)
def _plusQty(self):
qty = self._getQtyToChange()
row = self.MagazinsTable.currentRow()
if row == -1: return
oldValue = int(self.MagazinsTable.item(row, 2).text())
newValue = oldValue + qty
self.MagazinsTable.item(row, 2).setText(str(newValue))
def _minusQty(self):
qty = self._getQtyToChange()
row = self.MagazinsTable.currentRow()
if row == -1: return
oldValue = int(self.MagazinsTable.item(row, 2).text())
newValue = oldValue - qty
if newValue <= 0:
self._showMessage(
u'Ошибка', u'Удаляемое количество предметов больше имеющегося')
return
self.MagazinsTable.item(row, 2).setText(str(newValue))
def _getQtyToChange(self):
value = self.form.window.le_qty.text()
try:
qty = (int)(value)
except:
self._showMessage(u'Ошибка',
u'В поле "Количество" не числовое значение')
return 0
else:
return qty
def _getItemsList(self):
result = self.DbConnector.getItems(False)
listItems = QStringList()
if result is None or len(result) == 0:
return listItems
for element in result:
listItems.append(element[1])
return listItems
def _saveMagazinsMapping(self, magazinesMap):
#Дописываем в таблицу предметов их id
self._addIdToMagazinesMap(magazinesMap)
#Записываем в БД приход/расход предметов
result = self._inOutCommingItems(magazinesMap)
#Очищаем таблицу предметов
if not self._dropMagazinesTable(): return
#Записываем в таблицу предметов новые значения
isError = False
for magazin in magazinesMap:
param = {}
param["magazineNumber"] = (int)(magazin[0])
param["itemName"] = magazin[1]
param["itemQty"] = int(magazin[2])
param["itemId"] = magazin[3]
if not self._insertMagazine(param):
isError = True
if isError:
self._showMessage(u'Результат операции',
u"Ошибка записи в базу данных")
else:
self._showMessage(u'Результат операции', u"Данные записаны")
def _addIdToMagazinesMap(self, magazinesMap):
for row in magazinesMap:
itemName = row[1]
item = self.DbConnector.getIdItemByName(itemName, False)
if item is not None and len(item) > 0:
itemId = item[0][0]
row.append(itemId)
def _inOutCommingItems(self, magazinesMap):
ItemsInOldTable = self.DbConnector.getQtyOfItemsByType()
ItemsInNewTable = self._groupMagazinesMapTable(magazinesMap)
ItemMovementTable = self._getItemMovementTable(ItemsInOldTable,
ItemsInNewTable)
result = self.DbConnector.getMaxMovementId()[0]
if result is None:
result = 0
idRecharge = result + 1
for itemMovement in ItemMovementTable:
idItem = itemMovement[0]
date = datetime.datetime.now()
OperationType = itemMovement[1]
itemQty = itemMovement[2]
result = self.DbConnector.addMovement(idRecharge, idItem, date,
OperationType, itemQty)
#Печатаем отчеты
if len(ItemMovementTable) == 0:
#печатаем отчет о загрузке магазинов
magazinesLoadReport = self._makeMagazinesLoadReport()
self._printReport(magazinesLoadReport, 'NotFisk')
else:
#печатаем отчет о перезарядке
printRechargeReport = self._makeRechargeReport(
ItemsInOldTable, ItemsInNewTable)
self._printReport(printRechargeReport, 'NotFisk')
return result
def _groupMagazinesMapTable(self, magazinesMap):
#Функция группирует предметы, указанные в списке магазинов, суммируя их по видам
ItemsId = []
qty = []
ItemsName = []
for i in range(0, len(magazinesMap)):
idItem = int(magazinesMap[i][3])
itemQty = int(magazinesMap[i][2])
itemName = str(magazinesMap[i][1])
if idItem in ItemsId:
continue
if len(magazinesMap) == 1:
ItemsId.append(idItem)
qty.append(itemQty)
ItemsName.append(itemName)
break
for j in range(i + 1, len(magazinesMap)):
if idItem == int(magazinesMap[j][3]):
itemQty += int(magazinesMap[j][2])
ItemsId.append(idItem)
qty.append(itemQty)
ItemsName.append(itemName)
result = zip(ItemsId, qty, ItemsName)
return result
def _getItemMovementTable(self, ItemsInOldTable, ItemsInNewTable):
#Функция формирует список движений предметов: приход/расход
itemsMovementTable = []
#Перебираем предметы в новой таблице (заполненной в интерфейсе)
for newItem in ItemsInNewTable:
newItemId = newItem[0]
oldItemQty = 0
#Сравниваем предмет из новой таблице со списком предметов в таблице, полученной из БД
for oldItem in ItemsInOldTable:
oldItemId = oldItem[0]
#Если предметы совпали, то получаем количество предметов из базы (старое, до обновления)
if newItemId == oldItemId:
oldItemQty = oldItem[1]
#Получаем разницу количества предметов по сравнению со старым (из БД) значением
qty = newItem[1] - oldItemQty
if qty == 0:
continue
#Создаем движение
itemMovement = []
#Если новых предметов стало больше, то это - приход
if qty > 0:
itemMovement.append(int(newItemId))
itemMovement.append(self.OPERATION_INCOME)
itemMovement.append(qty)
#Если новых предметов стало меньше, то это - расход
elif qty < 0:
itemMovement.append(int(newItemId))
itemMovement.append(self.OPERATION_OUTCOME)
itemMovement.append(qty)
itemsMovementTable.append(itemMovement)
#Перебираем предметы которые были в старой (из БД) таблице и выбираем только те, которых нет в
#новой таблице, заполненной в интерфейсе, т.е. их полностью выгрузили из магазинов. Это - расход
for oldItem in ItemsInOldTable:
oldItemId = oldItem[0]
oldItemQty = oldItem[1]
itemExists = False
for newItem in ItemsInNewTable:
newItemId = newItem[0]
if oldItemId == newItemId:
itemExists = True
break
if not itemExists:
itemMovement = []
itemMovement.append(int(oldItemId))
itemMovement.append(self.OPERATION_OUTCOME)
itemMovement.append(oldItemQty)
itemsMovementTable.append(itemMovement)
return itemsMovementTable
def _insertMagazine(self, param):
#Получаем Id предмета по его имени
result = self.DbConnector.getIdItemByName(param["itemName"], False)
#Прописываем предмет в магазине
if result is not None:
itemId = result[0][0]
success = self.DbConnector.addMagazin(param["magazineNumber"],
itemId, param["itemQty"])
return success
return False
def _dropMagazinesTable(self):
result = self.DbConnector.dropMagazinesTable()
return result
def _makeRechargeReport(self, ItemsInOldTable, ItemsInNewTable):
context = []
itemMovementTable = self.DbConnector.getMovements()
if len(itemMovementTable) == 0 or itemMovementTable is None:
return
context.append(dict(Text=''))
context.append(dict(Text='Report: %s' %
(str(itemMovementTable[0][0]))))
context.append(dict(Text='Date: %s' % (str(itemMovementTable[0][2]))))
context.append(dict(Text='--------------------------------------'))
context.append(dict(Text=''))
context.append(dict(Text='{:^35}'.format('Begin:')))
for item in ItemsInOldTable:
row = '{:<35}{:>3}'.format(str(item[2]), str(item[1]))
context.append(dict(Text=row))
context.append(dict(Text=''))
context.append(dict(Text='--------------------------------------'))
if len(itemMovementTable) == 0:
return
context.append(dict(Text='{:^35}'.format('Movements:')))
for item in itemMovementTable:
if item[3] == self.OPERATION_INCOME:
sign = '+'
else:
sign = '-'
row = '{:<34}{}{:>3}'.format(str(item[1]), sign, str(abs(item[4])))
context.append(dict(Text=row))
context.append(dict(Text=''))
context.append(dict(Text='--------------------------------------'))
context.append(dict(Text='{:^35}'.format('Rest:')))
for item in ItemsInNewTable:
row = '{:<35}{:>3}'.format(str(item[2]), str(item[1]))
context.append(dict(Text=row))
context.append(dict(Text=''))
context.append(dict(Text=''))
context.append(dict(Text='--------------------------------------'))
for s in context:
st = s['Text']
print st
return context
def _makeMagazinesLoadReport(self):
result = self.DbConnector.getMagazinLoadTable()
context = []
context.append(dict(Text=''))
context.append(dict(Text='{:^35}'.format('Magazines load')))
context.append(
dict(Text='{:^35}'.format('Date: %s' %
(str(datetime.datetime.now())))))
context.append(dict(Text='------------'))
context.append(dict(Text=''))
for row in result:
rowStr = '{:<35}{:>3}'.format(
str(row[0]) + '.' + str(row[1]), str(row[2]))
context.append(dict(Text=rowStr))
context.append(dict(Text=''))
context.append(dict(Text='------------'))
for s in context:
st = s['Text']
print st
return context
def _printReport(self, context, checkType):
try:
printer = Printer.Printer()
logMessages = printer.checkStatus()
self.DbConnector.writeLog(logMessages)
printer.run(context, checkType)
except Printer.PrinterHardwareException as e:
self.emit(QtCore.SIGNAL('Printer is not ready'), e.value)
def _showMessage(self, header, message):
self.message = Errors(message)
self.message.window.setWindowTitle(header)
self.message.setParent(self)
self.message.window.show()
def _prnIsNotFound(self, message):
self.message = Errors(message)
self.message.window.setWindowTitle(u'Ошибка')
self.message.window.show()
def fail(self):
self.errWindow = Errors(u"Delivery error. Call techsupport, please.")
self.connect(self.errWindow, QtCore.SIGNAL('ErrorWindowClosing'),
self._backToTitlePage)
self.errWindow.window.show()
self.givingOutWindow.hide()
class ItemsController(QObject):
ItemDeleted = QtCore.pyqtSignal()
def __init__(self, form):
QObject.__init__(self)
self.DbConnector = DbConnector()
self.form = form
self.editWindow = None
self.ItemTable = self.form.window.ItemTable
#Прописываем события кнопок для предметов
self.form.window.btn_AddItem.clicked.connect(self._addItem)
self.form.window.btn_EditItem.clicked.connect(self._editItem)
self.form.window.btn_DeleteItem.clicked.connect(self._deleteItem)
self.form.window.ItemTable.cellClicked.connect(self._refreshIcon)
def setUpItemsTable(self):
rowsFont = QFont('Lucida', 12, QtGui.QFont.Bold)
self.ItemTable.setFont(rowsFont)
headerFont = QFont('Lucida', 12, QtGui.QFont.Bold)
self.ItemTable.setFont(rowsFont)
self.ItemTable.horizontalHeader().setFont(headerFont)
self.ItemTable.horizontalHeader().setResizeMode(
0, QHeaderView.ResizeToContents)
self.ItemTable.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.ItemTable.horizontalHeader().setResizeMode(2, QHeaderView.Stretch)
self.ItemTable.verticalHeader().hide()
self._fillItemsTable()
def _fillItemsTable(self):
rows = self._getItems(False)
self.ItemTable.setRowCount(0)
counter = 0
for row in rows:
ItemIdItem = QtGui.QTableWidgetItem(str(row[0]))
ItemIdItem.setTextAlignment(QtCore.Qt.AlignCenter)
ItemName = QtGui.QTableWidgetItem(row[1])
ItemName.setTextAlignment(QtCore.Qt.AlignCenter)
ItemPrice = QtGui.QTableWidgetItem(str(row[2] / 100.0))
ItemPrice.setTextAlignment(QtCore.Qt.AlignCenter)
self.ItemTable.insertRow(counter)
self.ItemTable.setItem(counter, 0, ItemIdItem)
self.ItemTable.setItem(counter, 1, ItemName)
self.ItemTable.setItem(counter, 2, ItemPrice)
counter += 1
def _getItems(self, hidden):
return self.DbConnector.getItems(hidden)
def _addItem(self):
param = {}
param["itemId"] = 0
param["itemName"] = ""
param["itemPrice"] = "0"
param["itemIcon"] = QtGui.QPixmap()
self.editWindow = EditItem.EditItemHandler(param, 'Add')
self.connect(self.editWindow, QtCore.SIGNAL('RefreshItemTable'),
self.form.setUpTables)
self.editWindow.window.show()
def _editItem(self):
selectedRow = self.form.window.ItemTable.selectedItems()
if len(selectedRow) == 0:
message = u"Объект не выбран"
self._showMessage(u'Ошибка', message)
return
param = {}
param["itemId"] = int(selectedRow[0].text())
param["itemName"] = selectedRow[1].text()
param["itemPrice"] = selectedRow[2].text()
param["itemIcon"] = self.form.window.ibl_ItemIcon.pixmap()
self.editWindow = EditItem.EditItemHandler(param, 'Edit')
self.connect(self.editWindow, QtCore.SIGNAL('RefreshItemTable'),
self.form.setUpTables)
self.editWindow.window.show()
def _deleteItem(self):
selectedRow = self.form.window.ItemTable.selectedItems()
if len(selectedRow) == 0:
message = u"Объект не выбран"
self._showMessage(u'Ошибка', message)
return
idItem = int(selectedRow[0].text())
MagazinesWithItems = self.DbConnector.getMagazinesContainItem(idItem)
if len(MagazinesWithItems) != 0:
message = u'Удаление невозможно. Предмет загружен в магазин(ы): ' + MagazinesWithItems
self._showMessage(u'Ошибка', message)
return
#Проверяем был ли предмет хотя бы раз продан
sellsOfItem = self.DbConnector.sellsOfItem(idItem)
#Проверяем есть ли предмет в таблице движений
itemMovements = self.DbConnector.movementsOfItem(idItem)
if len(sellsOfItem) > 0 or itemMovements > 0:
#Предмет был продан или есть движения с ним - делаем его невидимым
result = self.DbConnector.setItemHide(idItem, True)
if not result:
message = u'Ошибка базы данных. Предмет не удален.'
self._showMessage(u'Ошибка', message)
return
else:
#Удаляем предмет
result = self.DbConnector.deleteItem(idItem)
if result:
message = u'Предмет удален.'
self._showMessage(u'Операция успешна', message)
self._fillItemsTable()
self.ItemDeleted.emit()
def _refreshIcon(self):
Items = self.form.window.ItemTable.selectedItems()
idItem = int(Items[0].text())
qpixmap = self._getIconById(idItem)
self._setIcon(qpixmap)
def _getIconById(self, idItem):
result = self.DbConnector.getIconById(idItem)[0]
qpixmap = QtGui.QPixmap()
if result is not None:
picBytes = base64.b64decode(result)
qpixmap.loadFromData(picBytes)
return qpixmap
def _setIcon(self, qpixmap):
self.form.window.ibl_ItemIcon.setPixmap(qpixmap)
def _showMessage(self, header, message):
self.message = Errors(message)
self.message.window.setWindowTitle(header)
self.message.setParent(self)
self.message.window.show()
