import os
import os.path as op
from sqlalchemy.event import listens_for
from jinja2 import Markup
from flask import Flask, Blueprint, render_template, url_for, redirect, request, session, flash, abort


from models import User, Role, Image, File
from views import MyModelView, ImageView, FileView
from forms import LoginForm, RegistrationForm

from flask_sqlalchemy import SQLAlchemy
import flask_admin as admin
import flask_login as login
from flask_admin.contrib import sqla
from flask_security import Security, SQLAlchemyUserDatastore, current_user, UserMixin, RoleMixin
from werkzeug.security import generate_password_hash, check_password_hash
from flask_admin import helpers, expose, form
from wtforms import form, validators, fields
from flask_admin import helpers as admin_helpers

# Create application
app = Flask(__name__)

app.config['DATABASE_FILE'] = 'sample_db.sqlite'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + app.config['DATABASE_FILE']
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
app.config['SECRET_KEY'] = 'thisissecret'

db = SQLAlchemy(app)

# Create directory for file fields to use
file_path = op.join(op.dirname(__file__), 'static/images/menu-product')
try:
    os.mkdir(file_path)
except OSError:
    pass

    '''
        def __init__(self, login, email, password, active):
            self.login = login
            self.email = email
            self.password = password
            self.active = active
    '''

# Setup Flask-Security
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security = Security(app, user_datastore)


# Initialize flask-login
def init_login():
    login_manager = login.LoginManager()
    login_manager.init_app(app)

    # Create user loader function
    @login_manager.user_loader
    def load_user(user_id):
        return db.session.query(User).get(user_id)


# Delete hooks for models, delete files if models are getting deleted
@listens_for(File, 'after_delete')
def del_file(mapper, connection, target):
    if target.path:
        try:
            os.remove(op.join(file_path, target.path))
        except OSError:
            # Don't care if was not deleted because it does not exist
            pass


@listens_for(Image, 'after_delete')
def del_image(mapper, connection, target):
    if target.path:
        # Delete image
        try:
            os.remove(op.join(file_path, target.path))
        except OSError:
            pass

        # Delete thumbnail
        try:
            os.remove(op.join(file_path,
                              admin.form.thumbgen_filename(target.path)))
        except OSError:
            pass


# Create customized index view class that handles login & registration
class MyAdminIndexView(admin.AdminIndexView):
    @expose('/')
    def index(self):
        if not login.current_user.is_authenticated:
            return redirect(url_for('.login_view'))
        return super(MyAdminIndexView, self).index()

    @expose('/login/', methods=['GET', 'POST'])
    def login_view(self):
        # handle user login
        form = LoginForm(request.form)

        if helpers.validate_form_on_submit(form):
            user = form.get_user()
            login.login_user(user)

        if login.current_user.is_authenticated:
            return redirect(url_for('.index'))
        link = '<p>Don't have an account? <a href="' + url_for('.register_view') + '">Click here to register.</a></p>'
        self._template_args['form'] = form
        self._template_args['link'] = link
        return super(MyAdminIndexView, self).index()

    @expose('/register/', methods=['GET', 'POST'])
    def register_view(self):
        form = RegistrationForm(request.form)

        if helpers.validate_form_on_submit(form):
            user = User()

            form.populate_obj(user)
            # we hash the users password to avoid saving it as plaintext in the db,
            # remove to use plain text:
            user.password = generate_password_hash(form.password.data)

            db.session.add(user)
            db.session.commit()

            login.login_user(user)
            return redirect(url_for('.index'))
        link = '<p>Already have an account? <a href="' + url_for('.login_view') + '">Click here to log in.</a></p>'
        self._template_args['form'] = form
        self._template_args['link'] = link
        return super(MyAdminIndexView, self).index()

    @expose('/logout/')
    def logout_view(self):
        login.logout_user()
        return redirect(url_for('.index'))


def common_args():
    name = 'Вхід'
    if login.current_user.is_authenticated:
        name = 'Кабінет' + ' ' + current_user.login
    return {'name': name}


# Flask views
@app.route('/')
def index():
    return render_template('index.html', **common_args())


@app.route('/menu')
def menu():
    return render_template('project_templates/menu.html', **common_args())


@app.route('/contacts')
def contacts():
    return render_template('project_templates/contacts.html', **common_args())


# Initialize flask-login
init_login()

# Create admin
admin = admin.Admin(app, index_view=MyAdminIndexView(), base_template='my_master.html')

# Add view
admin.add_view(MyModelView(User, db.session, name='Shoppers'))
admin.add_view(MyModelView(Role, db.session))
admin.add_view(FileView(File, db.session))
admin.add_view(ImageView(Image, db.session, name='Order'))


# define a context processor for merging flask-admin's template context into the
# flask-security views.
@security.context_processor
def security_context_processor():
    return dict(
        admin_base_template=admin.base_template,
        admin_view=admin.index_view,
        h=admin_helpers,
        get_url=url_for
    )


def build_sample_db():
    """
    Populate a small db with some example entries.
    """

    db.create_all()

    with app.app_context():
        user_role = Role(name='user')
        super_user_role = Role(name='superuser')
        db.session.add(user_role)
        db.session.add(super_user_role)
        db.session.commit()

        test_user = user_datastore.create_user(
            login='Admin',
            email='admin',
            password=generate_password_hash('admin'),
            roles=[super_user_role]
        )
        db.session.add(test_user)
        db.session.commit()

    return


if __name__ == '__main__':
    # Build a sample db on the fly, if one does not exist yet.
    app_dir = os.path.realpath(os.path.dirname(__file__))
    database_path = os.path.join(app_dir, app.config['DATABASE_FILE'])
    if not os.path.exists(database_path):
        build_sample_db()

    # Start app
    app.run(debug=True)

from app import db
from flask_security import UserMixin, RoleMixin


# Create models
class File(db.Model):
    __tablename__ = 'files'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.Unicode(64))
    path = db.Column(db.Unicode(128))
    price = db.Column(db.String(64))

    def __unicode__(self):
        return self.name


class Image(db.Model):
    __tablename__ = 'images'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.Unicode(64))
    path = db.Column(db.Unicode(128))
    price = db.Column(db.String(64))

    def __unicode__(self):
        return self.name


# Define models
roles_users = db.Table(
    'roles_users',
    db.Column('user_id', db.Integer(), db.ForeignKey('user.id')),
    db.Column('role_id', db.Integer(), db.ForeignKey('role.id'))
)


class Role(RoleMixin, db.Model):
    __tablename__ = 'roles'

    id = db.Column(db.Integer(), primary_key=True)
    name = db.Column(db.String(80), unique=True)
    description = db.Column(db.String(255))

    def __str__(self):
        return self.name


class User(UserMixin, db.Model):
    __tablename__ = 'users'

    id = db.Column(db.Integer, primary_key=True)
    login = db.Column(db.String(255))
    email = db.Column(db.String(50), unique=True)
    password = db.Column(db.String(100))
    active = db.Column(db.Boolean())
    registered_on = db.Column('registered_on', db.DateTime)
    roles = db.relationship('Role', secondary=roles_users,
                            backref=db.backref('users', lazy='dynamic'))

    # Flask-Login integration
    def is_authenticated(self):
        return True

    def is_active(self):
        return True

    def is_anonymous(self):
        return False

    def get_id(self):
        return self.id

    # Required for administrative interface
    def __unicode__(self):
        return self.login

    def __repr__(self):
        return '<User %r>' % self.login

    def __str__(self):
        return self.email

File "D:projectprobeprojectflaskapp.py", line 7, in <module>
    from models import User
ImportError: cannot import name 'User'