def delete_user(self, user_id):
s = Session()
del_user = s.query(User).filter(User.id == user_id).one()
s.delete(del_user)
s.commit()
self.signal_delete_user.emit(user_id)
s.close()
def delete(self):
db_session = Session()
json_data = request.get_json()
if not json_data:
return {'message': 'No input data provided'}, 400
try:
data, errors = note_schema.load(json_data)
if not data.get('id'):
raise ValidationError('Data not provided')
except ValidationError as err:
db_session.close()
return err.messages, 422
try:
note = db_session.query(Note).filter(
Note.id == data.get('id')).first()
if note is None:
raise ValidationError('Note is not found')
except ValidationError as err:
db_session.close()
return err.messages, 404
db_session.delete(note)
db_session.commit()
db_session.close()
return {"result": "Note successfully deleted"}
def del_user_controller(request):
user_id = int(request.get('id'))
session = Session()
for each_user in session.query(User).filter_by(id=user_id):
session.delete(each_user)
session.commit()
return make_response(request, 200, f'User id {user_id} deleted')
def delete_message_controller(request):
data = request.get('data')
message_id = data.get('message_id')
session = Session()
message = session.query(Message).filter_by(id=message_id).first()
session.delete(message)
session.commit()
session.close()
return make_response(request, 200)
async def clear_bankrupt(self, session: database.Session):
for index_company, company in enumerate(
session.query(Company).filter_by(bankrupt=True)):
self.bankrupt_info.append(f'{company.abbv.upper()}')
shares = session.query(
database.Shares).filter_by(company_id=company.id).all()
for share in shares:
user = session.query(database.User).get(share.user_id)
await self.api.upgraded_add_points(user, share.amount, session)
self.owners_of_bankrupt_companies.add(f'@{user.name}')
# print(f"Refunded {share.amount} points to @{user.name}")
session.delete(company)
session.commit()
def delete_listing(id: int,
user=Depends(manager),
db: database.Session = Depends(database.get_db)):
db_listing = db.query(database.Listing).filter_by(id=id).first()
if db_listing == None:
raise HTTPException(status.HTTP_404_NOT_FOUND,
detail='Requested listing not found')
elif db_listing.author == user.username:
db.delete(db_listing)
db.commit()
return {'Detail': f'Listing {id} deleted successfully'}
else:
raise HTTPException(status.HTTP_401_UNAUTHORIZED,
detail='Not authorized to delete this listing')
def delete_message_controller(request):
"""
Function that deletes requested message
:param request: request
:return: response with id of deleted message
"""
session = Session()
message = get_item(request, session)
session.delete(message)
session.commit()
messages = get_all_messages()
id_deleted = request['id_req']
messages.append({'deleted': f'message with id {id_deleted} was deleted!'})
return make_response(request, 200, messages)
def delete_account(password=Form(...),
user=Depends(manager),
db: database.Session = Depends(database.get_db)):
if not user:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
detail='Not authenticated')
else:
db_user = db.query(
database.User).filter_by(username=user.username).first()
if database.Hash.verify_password(password, db_user.password):
db.delete(db_user)
db.commit()
return {'detail': 'Account deleted successfully.'}
else:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
detail='Account password is incorrect')
class MediaDialog(QtWidgets.QDialog, Ui_Media):
def __init__(self, parent=None):
super(QtWidgets.QDialog, self).__init__(parent)
self.setupUi(self)
self.session = Session()
self.usage = UsageDialog(session=self.session)
self.roots = sorted(self.session.query(Root).order_by(Root.root).all(),
key=lambda r: locale.strxfrm(r.root))
self.media = self.session.query(Media).order_by(Media.name).all()
self.encDialog = EncounterDialog(self)
self.encDialog.setwords(self.roots)
self.encDialog.setmedia(self.media)
self.encDialog.accepted.connect(self.acceptenc)
self.newEncButton.clicked.connect(self.newenc)
self.editEncButton.clicked.connect(self.editenc)
self.deleteEncButton.clicked.connect(self.delenc)
self.editDialog = MediaEditDialog(self)
self.editDialog.accepted.connect(self.acceptmed)
self.searchButton.clicked.connect(self.search)
self.editButton.clicked.connect(self.editmedia)
self.newButton.clicked.connect(self.newmedia)
self.deleteButton.clicked.connect(self.delmedia)
self.mediaTable.currentCellChanged.connect(self.changed)
self.mediaTable.setColumnWidth(0, 200)
self.encDialog.saveandnew.connect(self.encapply)
self.encountersTable.cellDoubleClicked.connect(self.openword)
self.search()
def openword(self, row, col):
cell = self.encountersTable.item(row, 0)
encounter = cell.data(QtCore.Qt.UserRole)
self.usage.settext(encounter.root.root)
self.usage.show()
print("Openword", encounter.root.root)
def encapply(self):
self.session.add(self.encounter)
self.session.commit()
self.newenc()
def delenc(self):
row = self.encountersTable.currentRow()
cell = self.encountersTable.item(row, 0)
self.encounter = cell.data(QtCore.Qt.UserRole)
self.session.delete(self.encounter)
self.session.commit()
self.search()
def newenc(self):
row = self.mediaTable.currentRow()
cell = self.mediaTable.item(row, 0)
media = cell.data(QtCore.Qt.UserRole)
self.encounter = Encounter(media=media,
skill=60,
notes="Put Notes Here")
self.encDialog.setdata(self.encounter)
self.encDialog.show()
def editenc(self):
row = self.encountersTable.currentRow()
cell = self.encountersTable.item(row, 0)
self.encounter = cell.data(QtCore.Qt.UserRole)
self.encDialog.setdata(self.encounter)
self.encDialog.show()
def acceptenc(self):
self.session.add(self.encounter)
self.session.commit()
self.search()
def changed(self):
row = self.mediaTable.currentRow()
if row > -1:
cell = self.mediaTable.item(row, 0)
media = cell.data(QtCore.Qt.UserRole)
self.notesText.setText(media.notes)
for _ in range(self.encountersTable.rowCount()):
self.encountersTable.removeRow(0)
for ndx, encounter in enumerate(media.encounters):
self.encountersTable.insertRow(ndx)
cell = QtWidgets.QTableWidgetItem(encounter.root.root)
cell.setData(QtCore.Qt.UserRole, encounter)
self.encountersTable.setItem(ndx, 0, cell)
self.encountersTable.setItem(
ndx, 1,
QtWidgets.QTableWidgetItem(
encounter.encounter_time.strftime('%y-%m-%d')))
self.encountersTable.setItem(
ndx, 2, QtWidgets.QTableWidgetItem(str(encounter.skill)))
def delmedia(self):
row = self.mediaTable.currentRow()
cell = self.mediaTable.item(row, 0)
self.subject = cell.data(QtCore.Qt.UserRole)
self.session.delete(self.subject)
self.session.commit()
self.search()
def acceptmed(self):
self.session.add(self.subject)
self.session.commit()
self.search()
def newmedia(self):
self.subject = Media(created=datetime.now())
self.editDialog.setmedia(self.subject)
self.editDialog.show()
def editmedia(self):
row = self.mediaTable.currentRow()
if row > -1:
cell = self.mediaTable.item(row, 0)
self.subject = cell.data(QtCore.Qt.UserRole)
self.editDialog.setmedia(self.subject)
self.editDialog.show()
def search(self):
snip = self.wordLine.text()
self.medialist = self.session.query(Media).filter(
Media.name.like("%{}%".format(snip))).order_by(Media.name).all()
for _ in range(self.mediaTable.rowCount()):
self.mediaTable.removeRow(0)
for cnt, media in enumerate(self.medialist):
self.mediaTable.insertRow(cnt)
cell = QtWidgets.QTableWidgetItem(media.name)
cell.setData(QtCore.Qt.UserRole, media)
self.mediaTable.setItem(cnt, 0, cell)
# Calculate skill and date from encounters
encdate = media.created.strftime("%Y-%m-%d")
self.mediaTable.setItem(cnt, 4,
QtWidgets.QTableWidgetItem(encdate))
if self.mediaTable.rowCount() > 0:
self.mediaTable.setCurrentCell(0, 0)
def update():
logger = getLogger("cronjob.tourney")
logger.info("Updating Tournament database...")
repo_path = environ["TOURNEY_REPO"]
repository = Path(repo_path)
if not repository.is_dir():
logger.critical("Repository path %s is not a valid directory.",
repository)
raise NotADirectoryError(str(repository))
logger.info("Pulling repository changes...")
call(["git", "pull", "-q"],
cwd=str(repository),
stdout=DEVNULL,
stderr=DEVNULL)
tourney_base = repository / "tournaments"
if not tourney_base.is_dir():
logger.critical("Tournament base %s is not a valid directory.",
tourney_base)
raise NotADirectoryError(str(tourney_base))
logger.info("Reading tournament event files...")
event_json_files = (json for json in tourney_base.glob("**/*.json")
if json.is_file())
logger.info("Updating tournament database...")
session = Session()
paths = list()
for event_json_file in event_json_files:
relative = event_json_file.relative_to(tourney_base)
paths.append(str(relative))
logger.debug("Handling file %s.", relative)
with event_json_file.open() as event_json:
raw = event_json.read()
hash = md5(raw.encode("utf-8")).hexdigest()
tourney_data = loads(raw)
logger.debug("Read JSON data, file hash: %s.", hash)
tourney_date = datetime.strptime(tourney_data["date"], STRP_FORMAT)
try:
tourney = (session.query(Tournament).filter(
Tournament.path == str(relative)).one())
except NoResultFound:
tourney = Tournament(tourney_data["title"], tourney_date,
tourney_data["winner"], tourney_data["mode"],
tourney_data["url"], str(relative), hash)
session.add(tourney)
logger.debug("Created new tourney: {0}".format(tourney))
else:
# check if hash has changed
if tourney.md5_hash != hash:
tourney.md5_hash = hash
tourney.title = tourney_data["title"]
tourney.date = tourney_date
tourney.winner = tourney_data["winner"]
tourney.mode = tourney_data["mode"]
tourney.url = tourney_data["url"]
session.add(tourney)
session.commit()
# remove tournaments no longer in the repo
obsolete_tourneys = (session.query(Tournament).filter(
Tournament.path.notin_(paths)).all())
for obsolete_tourney in obsolete_tourneys:
logger.info("Purged tourney {0} which is no longer present in the "
"repository".format(obsolete_tourney))
session.delete(obsolete_tourney)
session.commit()
session.close()
class Word(QtWidgets.QDialog, Ui_Word):
def __init__(self, parent=None):
super(QtWidgets.QDialog, self).__init__(parent)
self.setupUi(self)
self.session = Session()
self.usage = UsageDialog()
self.roots = self.session.query(Root).order_by(Root.root).all()
self.media = self.session.query(Media).order_by(Media.name).all()
self.encDialog = EncounterDialog(self)
self.encDialog.setwords(self.roots)
self.encDialog.setmedia(self.media)
self.encDialog.accepted.connect(self.acceptenc)
self.newButton.clicked.connect(self.newenc)
self.editButton.clicked.connect(self.editenc)
self.deleteButton.clicked.connect(self.delenc)
#self.wordLine.editingFinished.connect(self.search)
self.searchButton.clicked.connect(self.search)
self.downloadButton.clicked.connect(self.download)
self.wordTable.cellDoubleClicked.connect(self.open_usage)
self.wordTable.currentCellChanged.connect(self.setenc)
def delenc(self):
row = self.encountersTable.currentRow()
cell = self.encountersTable.item(row, 0)
self.encounter = cell.data(QtCore.Qt.UserRole)
self.session.delete(self.encounter)
self.session.commit()
self.search()
def newenc(self):
row = self.wordTable.currentRow()
cell = self.wordTable.item(row, 0)
root = cell.data(QtCore.Qt.UserRole)
self.encounter = Encounter(root=root, skill=60, notes="Put Notes Here")
self.encDialog.setdata(self.encounter)
print(self.encounter)
self.encDialog.show()
def editenc(self):
row = self.encountersTable.currentRow()
cell = self.encountersTable.item(row, 0)
self.encounter = cell.data(QtCore.Qt.UserRole)
self.encDialog.setdata(self.encounter)
self.encDialog.show()
def acceptenc(self):
print(self.encounter, self.encounter.root.root,
self.encounter.media.name, self.encounter.skill)
self.session.add(self.encounter)
self.session.commit()
self.search()
def setenc(self, row, col):
print("setenc", row, col)
if row < 0:
return
cell = self.wordTable.item(row, 0)
root = cell.data(QtCore.Qt.UserRole)
for _ in range(self.encountersTable.rowCount()):
self.encountersTable.removeRow(0)
for row, encounter in enumerate(root.encounters):
self.encountersTable.insertRow(row)
cell = QtWidgets.QTableWidgetItem(encounter.media.name)
cell.setData(QtCore.Qt.UserRole, encounter)
self.encountersTable.setItem(row, 0, cell)
self.encountersTable.setItem(
row, 1,
QtWidgets.QTableWidgetItem(
encounter.encounter_time.strftime('%Y-%m-%d')))
self.encountersTable.setItem(
row, 2, QtWidgets.QTableWidgetItem(str(encounter.skill)))
def open_usage(self, row, col):
tgt = self.wordTable.item(row, 0).text()
self.usage.settext(tgt)
self.usage.show()
def search(self):
snip = self.wordLine.text()
self.words = self.session.query(Root).filter(
Root.root.like("%{}%".format(snip))).order_by(Root.root).all()
self.words = sorted(self.words, key=lambda r: locale.strxfrm(r.root))
for _ in range(self.wordTable.rowCount()):
self.wordTable.removeRow(0)
for cnt, root in enumerate(self.words):
self.wordTable.insertRow(cnt)
cell = QtWidgets.QTableWidgetItem(root.root)
cell.setData(QtCore.Qt.UserRole, root)
red = green = blue = 255
if root.usages and root.usages[0].grammar:
gram = root.usages[0].grammar
if 'masc' in gram:
red = red - 25
green = green - 25
if 'minin' in gram:
green = green - 25
blue = blue - 25
cell.setBackground(QtGui.QColor(red, green, blue))
self.wordTable.setItem(cnt, 0, cell)
self.wordTable.setItem(cnt, 1,
QtWidgets.QTableWidgetItem(root.importance))
# Calculate skill and date from encounters
encdate = root.created.strftime("%Y-%m-%d")
self.wordTable.setItem(cnt, 4, QtWidgets.QTableWidgetItem(encdate))
if len(self.words) > 0:
self.wordTable.setCurrentCell(0, 0)
def download(self):
snip = self.wordLine.text()
parse.download(snip)
if __name__ == '__main__':
print("Вывод достопримечательностей\n")
printSights()
#Добавление данных
Russia = Session.query(Country).filter(Country.name == "Россия").one()
Volgograd = State("Волгоградсткая Область", Russia)
Session.add(Volgograd)
Session.commit()
newSigt = Sight(
"Родина-Мать", 1967,
"Lorem ipsum dolor sit amet, consectetur adipisicing elit. Assumenda velit quis, ex iusto, nam molestias dolore quia asperiores alias obcaecati maiores consequatur qui porro natus totam commodi earum, odio itaque.",
Volgograd)
Session.add(newSigt)
Session.commit()
print()
print("Добавлены данные\nДостопримечательность: Родина-Мать")
printSights()
#Каскадное удаление данных
USA = Session.query(Country).filter(Country.name == "США").one()
Session.delete(USA)
Session.commit()
print()
print("Каскадное удаление данных\n")
printSights()
print("\nСША и все её достопримечательности удалены успешно")
