# -*- coding: utf-8 -*-
from flask import Module,render_template,request,g,jsonify
from nuteam.controllers.filters import login_filter
from nuteam.services import teamservice, issueservice
issue = Module(__name__)
issue.before_request(login_filter)
@issue.route('/Project/Issue/<int:project_id>')
def list(project_id):
member_list = teamservice.member_in_project(project_id)
category = issueservice.available_category()
return render_template('Issue/List.html',ProjectId=project_id,MemberList=member_list,Category=category)
@issue.route('/Issue/Create/<int:project_id>')
def create(project_id):
member_list = teamservice.member_in_project(project_id)
category = issueservice.available_category()
return render_template('Issue/Create.html',ProjectId=project_id,MemberList=member_list,Category=category)
@issue.route('/Issue/CreateNew',methods=['POST'])
def create_new():
issueservice.create(request.json['ProjectId'],request.json['Subject'],request.json['Priority'],request.json['AssignTo'],request.json['Description'],request.json['CategoryId'],g.user_id)
return jsonify(created=True,ProjectId=request.json['ProjectId'])
@issue.route('/Issue/Query',methods=['POST'])
def query():
subject = request.json['Subject']
assign_to = int(request.json['AssignTo'])
if assign_to == -1:
assign_to = g.user_id
from flask import (Module)
from flaskcma.stories.documents import Story
mod = Module(__name__, name="stories")
mod.flaskcma = {
'content_list': [Story]
}
# -*- coding: utf-8 -*-
from flask import Module,render_template,redirect,request,session,jsonify,g
from nuteam.services import userservice
from nuteam.controllers.filters import login_filter
user = Module(__name__)
user.before_request(login_filter)
@user.route('/SignOut')
def sign_out():
response = redirect('/')
session['username'] = None
session['userid'] = None
return response
@user.route('/Profile')
def profile():
u = userservice.get(session['username'])
return render_template('Profile/Detail.html',User=u)
@user.route('/ChangePassword',methods=['POST'])
def change_password():
raw_password = request.json['RawPassword']
password = request.json['Password']
updated = userservice.change_password(raw_password,password,g.user_id)
return jsonify(Updated=updated)
@user.route('/UpdateProfile',methods=['POST'])
def update_profile():
email = request.json['Email']
nick = request.json['Nick']
from flask import (
g,
Module,
redirect,
render_template,
request,
session,
url_for,
)
from flatland.out.markup import Generator
from cockerel.models.schema import db, User
from cockerel.forms import LoginForm, SignupForm
admin = Module(__name__)
@admin.route('/login', methods=['GET', 'POST'])
def login():
# TODO: make this do better auth, it needs to set a cookie for a period of
# time
if request.method == 'POST':
form = LoginForm.from_flat(request.form)
if form.validate():
user = User.query.filter_by(
username=request.form['username']).first()
if user == None:
form['username'].add_error(
'Username %s not found' % form['username'].value)
gen = Generator()
# -*- coding: utf-8 -*-
from flask import Module,render_template,request,jsonify,g
from nuteam.controllers.filters import login_filter
from nuteam.services import taskservice, teamservice
task = Module(__name__)
task.before_request(login_filter)
@task.route('/Project/Task/<int:project_id>')
def list(project_id):
member_list = teamservice.member_in_project(project_id)
return render_template('Task/List.html',ProjectId=project_id,MemberList=member_list)
@task.route('/Task/Query',methods=['POST'])
def query():
task_name = request.json['TaskName']
assign_to = int(request.json['AssignTo'])
if assign_to == -1:
assign_to = g.user_id
status_new = request.json['New']
status_in_progress = request.json['InProgress']
status_completed = request.json['Completed']
status_canceled = request.json['Canceled']
page_no = request.json['PageNo']
(row_count,page_count,page_no,page_size,data) = taskservice.query(task_name,assign_to,status_new,status_in_progress,status_completed,status_canceled,'Priority',page_no)
tasks = []
for t in data.all():
tasks.append({'TaskId':t.TaskId,'TaskName':t.TaskName,'Priority':t.Priority,'Progress':t.Progress,'Status':t.Status,'Effort':t.Effort,'AssignTo':t.AssignToProfile.Nick,'Creator':t.CreatorProfile.Nick,'LastUpdateDate':t.LastUpdateDate.isoformat()})
return jsonify(row_count=row_count,page_count=page_count,page_no=page_no,page_size=page_size,data=tasks)
@task.route('/Task/Create/<int:project_id>')
flask-odesk version 0.4.1
(C) 2011 oDesk
"""
from __future__ import absolute_import
from functools import wraps
from flask import Module, request, redirect, session, flash,\
url_for, current_app
from odesk import Client
ODESK_REQUEST_TOKEN = '_ort'
ODESK_ACCESS_TOKEN = '_oat'
odesk = Module(__name__)
def is_authorized():
"""
Check authorization for current user
"""
return session.get(ODESK_ACCESS_TOKEN, False) and True
odesk.is_authorized = is_authorized
@odesk.app_context_processor
def inject_is_authorized():
"""
Context processor for is_authorized method
"""
import os
from uuid import uuid4
from flask import Module, jsonify, request, Response
from flask.views import MethodView
from core.api import API
from core.api.decorators import jsonp
from core.backends.UNIX import UNIXBackend
from core.utils.RequestValidator import CreateUnikernelValidator
from ..RedisQueue import Q
api = Module(
__name__,
# url_prefix='/api'
)
def jsonify_status_code(*args, **kw):
response = jsonify(*args, **kw)
response.status_code = kw['code']
return response
@api.route('/')
def index():
"""
The root of the API returns an error
"""
return jsonify_status_code(
code=400,
# -*- coding: UTF-8 -*-
import json
from flask import Module, render_template, jsonify, redirect, request, session, g
from src.fitnessconfig import *
from src.services import userservice, employeeservice, memberservice
from src.models.userprofile import UserStatus
fitnessmanages = Module(__name__)
@fitnessmanages.route('/fitnessmanages')
def fitnessmanage():
return render_template('FitnessManages/index.html')
from flask import Module, request, render_template
mod = Module(__name__)
import logging
import json
log = logging.getLogger('svg-web')
import svgweb.util.phantomjs as pjs
import svgweb.util.pdf_util as pdf
@mod.route('/')
def index():
return render_template('index.html')
@mod.route('/ajax/convert/')
def convert():
a = request.args
if not 'url' in a:
return ajax_error('no url given')
if not 'ext' in a:
return ajax_error('no extension given')
ext = a['ext']
if ext != '.png' and ext != '.pdf':
return ajax_error('invalid format png/pdf only')
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask import Module, redirect, url_for, session, flash, \
abort, request, current_app
from flask.ext.babel import gettext as _
from flask.ext.principal import Identity, identity_changed
from newsmeme.models import User
from newsmeme.helpers import slugify, render_template
from newsmeme.forms import OpenIdSignupForm, OpenIdLoginForm
from newsmeme.extensions import oid, db
openid = Module(__name__)
@oid.after_login
def create_or_login(response):
openid = response.identity_url
user, authenticated = \
User.query.authenticate_openid(response.email, openid)
next_url = session.pop('next', None)
if user is None:
session['openid'] = openid
username = response.fullname or response.nickname
from __future__ import unicode_literals, division, absolute_import
from flexget.ui.webui import manager, register_plugin, app
from flexget.task import Task
from flask import render_template, request, flash, redirect, Module
import yaml
import logging
from flask.helpers import url_for
configure = Module(__name__, url_prefix='/configure')
log = logging.getLogger('ui.configure')
@configure.route('/')
def index():
return render_template('configure/configure.html')
@configure.route('/new/<root>', methods=['POST', 'GET'])
def new_text(root):
if root not in ['tasks', 'presets']:
flash('Invalid root.', 'error')
return redirect(url_for('index'))
config_type = root.rstrip('s')
context = {'root': root, 'config_type': config_type}
if request.method == 'POST':
context['config'] = request.form.get('config')
name = request.form.get('name')
if not name:
flash('You must enter a name for this %s' % config_type, 'error')
elif name in manager.config.get(root, []):
# -*- coding: utf-8 -*-
from flask import Module,render_template,request,jsonify
from nuteam.controllers.filters import admin_filter
from nuteam.services import userservice, issueservice
admin = Module(__name__)
admin.before_request(admin_filter)
@admin.route('/Admin')
def index():
return render_template('Admin/index.html')
@admin.route('/Admin/CategorySetting')
def category():
return render_template('Admin/CategorySetting.html')
@admin.route('/QueryUser',methods=['POST'])
def query():
mail_or_nick = request.json['Word']
status = request.json['Status']
page_no = request.json['PageNo']
(row_count,page_count,page_no,page_size,data) = userservice.query_user(mail_or_nick,int(status),"RegDate desc",page_no)
user_list = []
for i in data.all():
user_list.append({'UserId':i.UserId,'Email':i.Email,'Nick':i.Nick,'Status':i.Status,'IsAdmin':i.IsAdmin,'RegDate':i.RegDate.isoformat()})
return jsonify(row_count=row_count,page_count=page_count,page_no=page_no,page_size=page_size,data=user_list)
@admin.route('/EnableUser',methods=['POST'])
def enable_user():
userid = request.json['UserId']
"""
"""
import os
import urllib, urlparse
from flask import Module, url_for, render_template, request, session, redirect, g, current_app
from .decorators import login_required, guest_or_login_required, with_lock
from flask.ext.babel import Babel, gettext, ngettext, lazy_gettext
_ = gettext
worksheet_listing = Module('sagenb.flask_version.worksheet_listing')
def render_worksheet_list(args, pub, username):
"""
Returns a rendered worksheet listing.
INPUT:
- ``args`` - ctx.args where ctx is the dict passed
into a resource's render method
- ``pub`` - boolean, True if this is a listing of
public worksheets
- ``username`` - the user whose worksheets we are
listing
OUTPUT:
a string
"""
import os
from flask import Module, url_for, render_template, request
from .models import get_posts, num_posts
import config
blog = Module(__name__, 'blog')
@blog.route('/')
def index():
page_size = config.BLOG_POSTS_PR_PAGE
total_posts = num_posts()
page = int(request.args.get('page', 1))
if page < 1:
page = 1
posts = get_posts((page - 1) * page_size, page * page_size)
return render_template('blog/index.html', **locals())
#! /usr/bin/env python
# coding:utf-8
from flask import Module, jsonify, request
from flask.views import MethodView
from core.api import API
from core.api.decorators import jsonp
from core.api.utils.RequestValidator import PaymentDataValidator
api = Module(
__name__,
url_prefix='/api'
)
def jsonify_status_code(*args, **kw):
response = jsonify(*args, **kw)
response.status_code = kw['code']
return response
@api.route('/')
def index():
"""
The root of the API returns an error
"""
return jsonify_status_code(
code=400,
message='Room no 404: File not found. HTTP GET requests to API root are not allowed.'
)
expires = domain = None
if session.permanent:
expires = datetime.utcnow() + self.permanent_session_lifetime
if self.config['SERVER_NAME'] is not None:
domain = '.' + self.config['SERVER_NAME']
session.save_cookie(response, self.session_cookie_name,
expires=expires, httponly=False, domain=domain)
def message(self, msg, cont='/', username=None, **kwds):
"""Returns an error message to the user."""
template_dict = {'msg': msg, 'cont': cont, 'username': username}
template_dict.update(kwds)
return render_template(os.path.join('html', 'error_message.html'),
**template_dict)
base = Module('flask_version.base')
#############
# Main Page #
#############
@base.route('/')
def index():
if 'username' in session:
# If there is a next request use that. See issue #76
if 'next' in request.args:
response = redirect(request.values.get('next', ''))
return response
response = redirect(url_for('worksheet_listing.home', username=session['username']))
if 'remember' in request.args:
response.set_cookie('nb_session_%s'%g.notebook.port,
expires=(time.time() + 60 * 60 * 24 * 14))
# coding:utf-8
# Copyright 2011 Litl, LLC. All Rights Reserved.
import logging
from flask import Module, render_template, request, redirect, url_for, session, flash
from portal.models import PortalUser
from portal.forms import UserForm, NewUserForm, PasswordForm
from login import check_login
portal = Module(__name__, url_prefix='/user')
portal.before_request(check_login)
@portal.route('/all/')
def list_users():
users = PortalUser.all()
return render_template('user_list.html', users=users)
@portal.route('/save/', methods=['POST'])
def save_user():
needs_password = '******' in request.form
if needs_password:
form = NewUserForm(request.form)
else:
form = UserForm(request.form)
if form.validate():
email = form.email.data
if form.id.data:
user = PortalUser.find_by_key(form.id.data)
else:
user = PortalUser.find_by_email(email)
from flask import (Flask, request, Markup, Response, render_template,
make_response, Module, current_app)
NSDEF = 'xmlns:gml="http://www.opengis.net/gml" \
xmlns:xlink="http://www.w3.org/1999/xlink" \
xmlns:xsd="http://www.w3.org/2001/XMLSchema" \
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" \
xmlns:wtr="http://www.cuahsi.org/waterML/" \
xmlns="http://www.cuahsi.org/waterML/1.0/"'
try:
from flask import Blueprint
rest = Blueprint(__name__, __name__)
except ImportError:
rest = Module(__name__)
@rest.route('/')
def index():
return render_template('index.html',
p=current_app.wof_inst.network,
s=current_app.wof_inst.default_site,
v=current_app.wof_inst.default_variable,
sd=current_app.wof_inst.default_start_date,
ed=current_app.wof_inst.default_end_date)
@rest.route('/GetSites', methods=['GET'])
def get_sites():
"""
Flask Module Docs: http://flask.pocoo.org/docs/api/#flask.Module
This file is used for both the routing and logic of your
application.
"""
from flask import Module, url_for, render_template, request, redirect,\
session, g, flash
from flaskext.oauth import OAuth
import models
from forms import TodoForm
views = Module(__name__, 'views')
oauth = OAuth()
twitter = oauth.remote_app(
'twitter',
base_url='http://api.twitter.com/1/',
# where flask should look for new request tokens
request_token_url='http://api.twitter.com/oauth/request_token',
# where flask should exchange the token with the remote application
access_token_url='http://api.twitter.com/oauth/access_token',
# twitter knows two authorizatiom URLs. /authorize and /authenticate.
# they mostly work the same, but for sign on /authenticate is
# expected because this will give the user a slightly different
# user interface on the twitter side.
#authorize_url='http://api.twitter.com/oauth/authenticate',
authorize_url='https://api.twitter.com/oauth/authorize',
consumer_key='qbAWqQcTBtOxPqbTh5Uag',
consumer_secret='TdKlsHpqaSzVfZircnOEoANdsylCskNsgQcvJNMqfk')
__author__ = 'jmpews'
from flask import Module, request
from flask import render_template
from app.models import Proxy
from . import index_blue as index_blue
index_module = Module(__name__)
@index_blue.route('/')
def index():
r_type = request.args.get('proxytype', 'http')
# proxylist=Proxy.query.all()
proxylist = Proxy.query.filter_by(type=r_type).order_by(
Proxy.id.desc()).limit(100)
return render_template('index.html', proxylist=proxylist)
from flask import Module, jsonify
from . import auth
consumer = Module(__name__)
consumer.test_consumer_key = None
consumer.test_consumer_user = None
@consumer.route('/token')
def generate_token():
if not consumer.test_consumer_key:
raise Exception, "No test_consumer_key specified."
if not consumer.test_consumer_user:
raise Exception, "No test_consumer_user specified."
tokenData = auth.generate_token(
consumer.test_consumer_key,
consumer.test_consumer_user
)
return jsonify(**tokenData)
# -*- coding: UTF-8 -*-
from flask import Module, render_template, jsonify, redirect, request, session, g
from src.agentconfig import *
import os
import logging
import json
from src.services.component import server
import httplib
import re
import operator
logging.basicConfig(level=logging.DEBUG)
registryV2Server = Module(__name__)
@registryV2Server.route('/')
def hello_registryV2Server():
print dir(request)
return 'Hello registryV2Server!'
@registryV2Server.route('/nexus/1.0/package/delete', methods=['DELETE'])
def imagesList():
return 'Hello nexusServer_info!'
from flask import Module, request, abort, render_template, current_app
from flaskcma.content.documents import Content
from flaskcma import utils
mod = Module(__name__, name="content", url_prefix="")
@mod.route("/<path>/edit/<content_type>/")
def edit_content(path, content_type="Content"):
path = "/%s/"
# Get the content type otherwise 404
try:
Document = utils.content_type(current_app, content_type)
except KeyError:
abort(404)
content = Document.objects(path=path).first()
if content is None:
content = Document()
Form = content.admin_form()
if Form is None:
abort(404) # We can't edit this content item
form = Form(request.forms, instance=content)
if request.method == "post" and form.validate():
# -*- coding: UTF-8 -*-
from flask import Module, render_template, jsonify, redirect, request, session, g
from testTeam.testteamconfig import *
from testTeam.services import userservice
from testTeam.models.userprofile import UserStatus
home = Module(__name__)
@home.route('/')
def index():
if 'username' in session and not session['username'] == None:
return redirect('/Project')
return render_template('Login.html', title=u'登陆')
@home.route('/Login', methods=['POST'])
def login():
email = request.json['Email']
password = request.json['Password']
user = userservice.get(email)
if user == None:
response = jsonify(isDisabled=False, isMatch=False)
return response
if user.Status == UserStatus.Disabled:
response = jsonify(isDisabled=True, isMatch=None)
return response
if not user.Password == password:
from flask import Module, abort, jsonify, request
from flask.ext.login import current_user, login_user, logout_user
from flask.views import MethodView
from flask_mail import Message
from werkzeug import secure_filename
from backend.backend.decorators import jsonp
from backend.backend.models.my_model import MyModel
from backend.backend.models.user import User
api = Module(__name__, url_prefix='/api')
def jsonify_status_code(status_code, *args, **kw):
response = jsonify(*args, **kw)
response.status_code = status_code
return response
@api.route('/')
def index():
'''
The root of the api returns an error
'''
abort(404)
class MyModelAPI(MethodView):
@jsonp
def get(self, id=None):
if id:
my_model = MyModel.objects.get(id=id)
from flask import Module, g, render_template
__all__ = ('commits', )
SEARCH_TERM = 'github.com/'
WINDOW_MAP = {
'day': 'd',
'3day': 'd3',
'week': 'w',
'month': 'm',
'year': 'y',
}
topsy = Module(__name__)
@topsy.before_request
def configure_redi():
redi.config.redis = g.r
def get_by_window(term, n, pages=3):
for page in range(pages):
r = otter.Resource('search')
r(q=term, window=n, offset=page * 10)
for link in r.response.list:
# -*- coding: utf-8 -*-
from flask import Module,render_template, request, jsonify,g
from nuteam.controllers.filters import login_filter
from nuteam.services import teamservice, projectservice
team = Module(__name__)
team.before_request(login_filter)
@team.route('/Project/Team/<int:project_id>')
def list(project_id):
p = projectservice.get(project_id)
return render_template('Team/List.html',ProjectId=project_id,Creator =p.Creator,CurrentUser=g.user_id)
@team.route('/Team/GetMemberCandidate',methods=['POST'])
def member_candidate():
project_id = request.json['ProjectId']
member_list = teamservice.member_candidate(project_id)
result = []
for m in member_list:
result.append({'Email':m.Email,'Nick':m.Nick})
return jsonify(data=result)
@team.route('/Team/GetMemberInProject',methods=['POST'])
def member_in_project():
project_id = request.json['ProjectId']
member_list = teamservice.member_in_project(project_id)
result = []
for m in member_list:
result.append({'Email':m.Email,'Nick':m.Nick,'UserId':m.UserId})
return jsonify(data=result)
# -*- coding: UTF-8 -*-
from flask import Module,render_template,redirect,request,session,jsonify,g
from src.services import roleservice
from src.controllers.filters import login_filter
role = Module(__name__)
role.before_request(login_filter)
roleName={
u"用户管理" : 0x01,
u"课程管理" : 0x02,
u"商品添加" : 0x04,
u"商品查询" : 0x08
}
@role.route('/role/permissionQury',methods=['POST'])
def queryPermission():
key=request.json.get('id',"")
data= []
roleName.keys()
for item in roleName.keys():
role={"right":roleName[item],"wrong":0,"name":item}
if key != "":
if roleservice.varifyPermission(roleName[item], key):
role['checked']=1
else:
role['checked']=-1
data.append(role)
return jsonify(got=True,data=data)
@role.route('/role/add',methods=['POST'])
from google.appengine.api.users import User
from livecount.counter import PeriodType, LivecountCounter
from jsmin import jsmin
from fogbugz import FogBugz
import settings
from extensions import context_processor
from models import SchemaVersion, Style, StyleRevision, Site, Invitation, Page, PageChannel, UserSettings
from tasks import queue_import
from tasks import IMPORT_DONE, CAN_IMPORT
from proxy import get_html, check_for_tags
from count import count_view, get_period_and_count
from forms import StyleForm, InviteForm, PageForm, SiteForm
from decorators import requires_auth, requires_admin
from docs import doc_list
views = Module(__name__, 'views')
views.app_context_processor(context_processor)
def _localeselector():
locale = UserSettings.get_locale() or session.get('locale', None)
if locale:
return locale
locale = request.accept_languages.best_match([locale[0] for locale in settings.available_locales])
if locale:
return locale
return 'en' # Default if we still have no match.
def _timezoneselector():
return None
# -*- coding: utf-8 -*-
from flask import Module,request,jsonify
from nuteam.controllers.filters import login_filter
import os
from nuteam.nuteamconfig import *
import uuid
upload = Module(__name__)
upload.before_request(login_filter)
@upload.route('/uploadimg',methods=['POST'])
def uploadimg():
file = request.files['upfile']
ext = file.filename.split('.')[-1]
filename = str(uuid.uuid4()) + '.' + ext
if not os.path.exists(UPLOADPATH):
os.makedirs(UPLOADPATH)
file.save(os.path.join(UPLOADPATH, filename))
return jsonify(url=os.path.join(UPLOADDIR, filename))
# -*- coding: UTF-8 -*-
from flask import Module,render_template,jsonify, redirect, request,session,g
from testTeam.testteamconfig import *
from testTeam.controllers.filters import login_filter
from testTeam.services import classesservice
classes = Module(__name__)
classes.before_request(login_filter)
@classes.route('/Classes/Create',methods=['POST'])
def create():
classname = request.json['Name']
projects = request.json['Project']
projects = projects if (len(projects) != 0) else []
isexist = classesservice.isexist(classname)
if not isexist:
classesservice.create(classname,projects,g.user_id)
# if len(projects) != 0:
# classesservice.create(classname,projects,g.user_id)
# else:
# classesservice.create(classname,None,g.user_id)
# existname = classesservice.get_name()
#
# if not classname in existname:
# isexist = False
# for project in projects:
# classesservice.create(classname,project,g.user_id)
# else:
# isexist = True
return jsonify(isexist=isexist)
from flask import Module,render_template,jsonify, request,g
from src.dcosconfig import *
from src.controllers.filters import login_filter
dashboard = Module(__name__)
dashboard.before_request(login_filter)
@dashboard.route('/Dashboard')
def index():
menuList = {
'index': {
'main': 'active'
},
'template': {
'main': '',
'sub1': '',
'sub2': '',
}
}
return render_template('Dashboard/index.html', menu = menuList)
@dashboard.route('/template/container')
def container():
menuList = {
'index': {
'main': ''
},
'template': {
'main': 'active',
# -*- coding: UTF-8 -*-
from flask import Module,render_template,jsonify, request,g
from testTeam.testteamconfig import *
from testTeam.services import projectservice,teamservice
from testTeam.controllers.filters import login_filter
project = Module(__name__)
project.before_request(login_filter)
@project.route('/Project')
def index():
return render_template('Project/List.html')
@project.route('/Project/Create',methods=['POST'])
def create():
projectservice.create(request.json['ProjectName'],request.json['Introduction'],g.user_id)
return jsonify(created=True)
@project.route('/Project/Query',methods=['POST'])
def query():
page_no = request.json['PageNo']
class_name = request.json['ClassName']
checked_list = request.json['CheckedList']
(data,subdata,row_count,page_count,page_no) = projectservice.query(page_no,PAGESIZE_project,'LastUpdateDate',g.user_id,class_name)
projects = []
for p in data.all():
if subdata == []:
isChecked = True if p.ProjectId in checked_list else False
projects.append({'ProjectId':p.ProjectId,'ProjectName':p.ProjectName,'Introduction':p.Introduction,'CreateDate':p.CreateDate.isoformat(),'LastUpdateDate':p.LastUpdateDate.isoformat(),'Creator':p.UserProfile.Nick,'IsChecked':isChecked})
else :
import hashlib
import smtplib
from flask import g, Module, redirect, render_template, request, session, url_for
from flaskext.principal import Identity, identity_changed, ActionNeed
from flatland.out.markup import Generator
from cockerel.models.schema import db, User, Action
from cockerel.forms import LoginForm, SignupForm, ActivateLoginForm
from cockerel.auth.security import get_activationcode, load_identity, save_identity
from cockerel.auth.permissions import read_action
import cockerel.webapp
admin = Module(__name__)
@admin.route("/login", methods=["GET", "POST"])
def login():
gen = Generator()
if request.method == "POST":
form = LoginForm.from_flat(request.form)
if form.validate():
user = User.query.filter_by(username=request.form["username"]).first()
if user != None:
if not user.activestatus:
form.add_error(
"""Username %s need to be activated before 1st login.
It can only be activated with the link sent to email
of this username."""
% form["username"].value
# -*- coding: UTF-8 -*-
from flask import Module,render_template,jsonify, redirect, request,session,g
from testTeam.testteamconfig import *
from testTeam.services import modelservice,projectservice,teamservice
from testTeam.models.userprofile import UserStatus
from testTeam.controllers.filters import login_filter
model = Module(__name__)
model.before_request(login_filter)
@model.route('/Model/<int:project_id>')
def index(project_id):
project = projectservice.get(project_id)
return render_template('Model/List.html',Project = project,title = project.ProjectName, CurrentUser = g.user_id)
@model.route('/Model/Create',methods=['POST'])
def create():
modelname = request.json["ModelName"]
description = request.json["Description"]
project = request.json["Project"]
isExist = modelservice.create(modelname, description, project, g.user_id)
return jsonify(isExist=isExist)
@model.route('/Model/Query',methods=['POST'])
def query():
project = request.json["Project"]
models = modelservice.query(project)
models_dict_list = []
for m in models:
m_dict = {}
m_dict.update(m.__dict__)
from uuid import uuid4
from flask import Module, jsonify, request
from flask.views import MethodView
from core.api.decorators import jsonp
from core.backends.UNIX import UNIXBackend
from core.utils.RequestValidator import CreateUnikernelValidator
from ..RedisQueue import Q
from core.api import API
api = Module(
__name__,
url_prefix='/api'
)
def jsonify_status_code(*args, **kw):
response = jsonify(*args, **kw)
response.status_code = kw['code']
return response
@api.route('/')
def index():
"""
The root of the API returns an error
"""
return jsonify_status_code(
code=400,
fmt = '%s/%s'
for ident, theme in ctx.app.theme_manager.themes.iteritems():
res.extend((fmt % (ident, t)).encode("utf8")
for t in theme.jinja_loader.list_templates())
return res
def template_exists(templatename):
ctx = _request_ctx_stack.top
return templatename in containable(ctx.app.jinja_env.list_templates())
### theme functionality
themes_mod = Module(__name__, name='_themes', url_prefix='/_themes')
themes_mod.jinja_loader # prevent any of the property's methods from
# taking effect
themes_mod.jinja_loader = ThemeTemplateLoader(False)
if USING_BLUEPRINTS:
themes_blueprint = Blueprint('_themes', __name__, url_prefix='/_themes')
themes_blueprint.jinja_loader
themes_blueprint.jinja_loader = ThemeTemplateLoader(True)
@themes_mod.route('/<themeid>/<path:filename>')
def static(themeid, filename):
try:
ctx = _request_ctx_stack.top
from flask import Module, render_template
frontend = Module(__name__)
@frontend.route('/')
def index():
return render_template('frontend/login.html')
