govno

# -*- coding: utf-8 -*-
from PyQt5.QtWidgets import QApplication, QDialog, QLineEdit, QMessageBox
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QPixmap
from ui.login import Ui_LoginDialog
from ui.captcha import Ui_CaptchaDialog
from vkapi import VkClient, VkError
import os

IPHONE_CLIENT_ID=3140623
IPHONE_CLIENT_SECRET="VeWdmVclDCtn6ihuP1nt"
DEFAULT_PERMISSIONS="notify,friends,photos,audio,video,docs,notes,pages,status,offers,questions,wall,groups,messages,email,notifications,stats,ads,offline"
API_VERSION = 5.27
API_DELAY = 0.34
TOKEN_FILE = 'data/access_token.txt'

class BaseApp(VkClient):
    def __init__(self,
                 client_id=IPHONE_CLIENT_ID,
                 client_secret=IPHONE_CLIENT_SECRET,
                 permissions=DEFAULT_PERMISSIONS,
                 api_version=API_VERSION,
                 api_delay=API_DELAY,
                 token_file=TOKEN_FILE):
        VkClient.__init__(self)
        self.tokenFile = token_file
        self.clientId = client_id
        self.clientSecret = client_secret
        self.permissions = permissions
        self.apiVersion = api_version
        self.apiDelay = api_delay

        self.userId = None
        self.isAuthed = True
        self.qApp = QApplication([])
        self.mainWindow = None

        try:
            self.accessToken = open(self.tokenFile).read()
        except:
            pass

        try:
            users = self.users.get()
            self.userId = users[0]['id']
        except VkError:
            self.isAuthed = False
            self.showLoginDialog()

        if not self.isAuthed:
            raise SystemExit

    def run(self):
        raise RuntimeError("Not implemented yet.")

    def showLoginDialog(self):
        self.mainWindow = LoginDialog(self)
        self.mainWindow.show()
        self.qApp.exec_()

    def login(self, username, password):
        username = username.strip()
        password = password.strip()
        error = ""

        if not username:
            error = "Введите имя пользователя."
        elif not password:
            error = "Введите пароль."
        else:
            r = self._auth(username, password)

            if 'access_token' in r:
                self.accessToken = r['access_token']
                self.userId = r['user_id']
                self.isAuthed = True

                with open(self.tokenFile, 'w') as f:
                    f.write(self.accessToken)

                self.mainWindow.close()
                self.mainWindow = None
                return

            error = r['error']

            if 'error_description' in r:
                error += ': ' + r['error_description']

        self.mainWindow.showError(error)

    def _auth(self, username, password, captcha_key=None, captcha_sid=None):
        params = dict(username=username,
                      password=password,
                      client_id=self.clientId,
                      client_secret=self.clientSecret,
                      scope=self.permissions,
                      grant_type='password')

        if captcha_key:
            params['captcha_key'] = captcha_key
            params['captcha_sid'] = captcha_sid

        r = self.session.post('https://oauth.vk.com/token', params).json()

        if 'error' in r:
            if r['error'] == 'need_captcha':
                captcha_key = self.solveCaptcha(r['captcha_img'])

                # Если введена капча отправляем запрос еще раз.
                if captcha_key is not False:
                    return self._auth(username, password, captcha_key,
                                      r['captcha_sid'])

        return r

    def solveCaptcha(self, url):
        data = self.session.get(url).content
        dialog = CaptchaDialog(self.mainWindow)
        dialog.setCaptchaImage(data)

        if dialog.exec_():
            return str(dialog.lineEdit_captcha.text())

        return False

    def logout(self):
        self.accessToken = None
        self.userId = None
        self.isAuthed = False

        try:
            os.unlink(self.tokenFile)
        except:
            pass

        try:
            self.mainWindow.close()
        except:
            pass

    def captchaHandler(self, error):
        params = dict(error.params)
        captcha_key = self.solveCaptcha(error.captchaImg)

        if captcha_key is not False:
            params['captcha_key'] = captcha_key
            params['captcha_sid'] = error.captchaSid
            return self.api(error.method, params)

        raise error

    def log(self, s):
        print(s)

class LoginDialog(QDialog, Ui_LoginDialog):
    def __init__(self, controller):
        QDialog.__init__(self)
        self.setupUi(self)
        self.controller = controller
        sz = self.size()
        self.setFixedSize(sz.width(), sz.height())
        # Убираем кнопку "?"
        # self.setWindowFlags(self.windowFlags() &
        #                     ~Qt.WindowContextHelpButtonHint)
        self.lineEdit_password.setEchoMode(QLineEdit.Password)
        self.checkBox_showPassword.stateChanged.connect(self.showHidePassword)
        self.pushButton_login.clicked.connect(self.onLogin)

    def showHidePassword(self, state):
        mode = QLineEdit.Normal if state == 2 else QLineEdit.Password
        self.lineEdit_password.setEchoMode(mode)

    def onLogin(self):
        username = str(self.lineEdit_username.text())
        password = str(self.lineEdit_password.text())
        self.pushButton_login.setDisabled(True)
        self.controller.login(username, password)
        self.pushButton_login.setEnabled(True)

    def showError(self, message):
        QMessageBox.critical(self, "Ошибка", message)

class CaptchaDialog(QDialog, Ui_CaptchaDialog):
    def __init__(self, parent=None):
        QDialog.__init__(self, parent)
        self.setupUi(self)
        self.parent = parent
        sz = self.size()
        self.setFixedSize(sz.width(), sz.height())

    def setCaptchaImage(self, imdata):
        pixmap = QPixmap()
        pixmap.loadFromData(imdata)
        self.label_captcha.setPixmap(pixmap)

if __name__ == '__main__':
    app = BaseApp()
    app.run()