def OnHttpRecv(self, httpObj):
if httpObj.header["method"] == "GET":
action = httpObj.urlParamDict.get("action")
if action == "user_new":
userId = httpObj.urlParamDict.get("userid")
s = SessionManager().CreateSession(userId, httpObj)
if s:
s.Start()
elif action == "user_close":
userId = httpObj.urlParamDict.get("userid")
SessionManager().StopSession(userId)
#itchat.auto_login()
if httpObj.header["method"] == "POST":
pass
def finish_initializing(self, builder): # pylint: disable=E1002
self.sm = SessionManager('gecos-firstart')
self.sm.start()
iconfile = config.get_data_file('media', '%s' % ('wizard1.png',))
self.set_icon_from_file(iconfile)
screen = Gdk.Screen.get_default()
sw = math.floor(screen.width() - screen.width() / 8)
sh = math.floor(screen.height() - screen.height() / 9)
self.resize(sw, sh)
self.ui.btnTest.set_visible(False)
self.ui.btnTest.set_sensitive(False)
self.show_browser()
self.block()
self.dbusclient = DBusClient()
self.dbusclient.connect('state-changed', self.on_dbusclient_state_changed)
try:
self.dbusclient.start()
self.dbusclient.user_login()
state = self.dbusclient.get_state(reply_handler=self.reply_handler, error_handler=self.error_handler)
except Exception as e:
self.unblock()
def load_session(key):
#session = Session()
session = SessionManager().current()
if session.has_key(key):
mem_key = session[key]
return memcache.get(mem_key)
else:
return None
def save_session(key, value):
#session = Session()
session = SessionManager().current()
if session.has_key(key):
mem_key = session[key]
if memcache.get(mem_key):
memcache.set(mem_key, value, time=EXPIRATION_DELTA_SECONDS)
else:
memcache.add(mem_key, value, time=EXPIRATION_DELTA_SECONDS)
def initBackend(self, backend, page):
#init session if session is None
if not page.session:
#TO-DO: open session dialog to get connnection info
page.session = SessionManager(self.parent)
if len(page.session.sessionManagerDialog.auth_info.hostname) == 0:
return
term = backend(page.writeText,
page.session.sessionManagerDialog.auth_info)
page.sendToBackend = term.sendChar
page.term = term
class Inventory(BaseDaemon.Inventory):
import pyre.facilities
import pyre.properties
from UserManager import UserManager
from SessionManager import SessionManager
inventory = [
pyre.properties.str("db", default="users.db"),
pyre.properties.int("port", default=50000),
pyre.facilities.facility("userManager", default=UserManager()),
pyre.facilities.facility("sessionManager",
default=SessionManager())
]
def __init__(self, parent=None): # attach to top-level?
self.first = 1
self.USERID = None
self.PASSWORD = None
self.myScreen = None
Frame.__init__(self, parent) # do superclass init
self.canvas = Canvas(parent, width=600, height=500, bg='black')
self.manager = SessionManager()
self.pack()
self.createWidgets() # attach frames/widgets
self.master.title("TN5250 for Python - Testing")
self.master.iconname("TN5250") # label when iconified
self.strprg()
def load_from_session_or_new(url):
site = urlparse.urlparse(url).netloc.encode('utf-8')
#site = url
session = SessionManager().current()
cookie = None
if session.has_key(COOKIE_SESSION_NAME % get_url_key_name(site)):
cookie = load_session(COOKIE_SESSION_NAME % get_url_key_name(site))
if not cookie:
session[COOKIE_SESSION_NAME % get_url_key_name(site)] = str(
uuid.uuid4())
cookie = MySimpleCookie()
cookie.site = site
return cookie
def start(dbconnectionstring, username, password):
Database.StartEngine(dbconnectionstring)
session = SessionManager()
if username != '' and password != '':
if session.Login(username, password):
print "Login success"
else:
print "Login Error Invalid Username/Password"
peripherals = Peripherals
from ReciptPrinter import ReciptPrinter
peripherals.ReciptPrinter = ReciptPrinter
#from EpsonEscPos import EpsonEscPos
#peripherals.ReciptPrinter = EpsonEscPos
app = Vikuraa(session, peripherals)
app.MainLoop()
import random
import string
from Administrator import Administrator
from Category import Category
from Customer import Customer
from Department import Department
from Product import Product
from Orders import Orders
import datetime
from SessionManager import SessionManager
from ShoppingCart import ShoppingCart
sesManag = SessionManager()
user = sesManag.add_user("qwerty", "pass", "name", "customer", "as", "asa",
1231, "asdas", "asdas")
admin = sesManag.add_user("qwertyAdmin", "pass", "name", "admin", "Asda")
user.register()
admin.register()
prod1 = Product("prod1", "prod1", 14, "as", 12431)
prod2 = Product("prod2", "prod1", 14, "as", 12412)
prod3 = Product("prod3", "prod1", 14, "as", 12413)
prod1.add_product()
prod2.add_product()
prod3.add_product()
shopping = ShoppingCart()
shopping.add_cart_item(prod1, 1)
def sessionManager(name=None):
from SessionManager import SessionManager
return SessionManager(name)
# set/export FLASK_APP=src/photosynthesis_webapp.py
# flask run
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
# create uploads folder
uploadFolder = os.path.join(os.path.dirname(__file__),
app.config['UPLOAD_FOLDER'])
if os.path.exists(uploadFolder):
shutil.rmtree(uploadFolder, ignore_errors=True)
os.mkdir(uploadFolder)
# initiate sessionManager
appSessions = SessionManager(MAX_SESSIONS)
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET'])
def form():
return render_template("form.html")
@app.route('/api/generate_blink_free', methods=['POST'])
def upload_file():
# check for numFiles entry
from flask import Flask, jsonify, Response, request
# from ML import ML
from ML import ML
from DB import DB
from Social import Social
from SessionManager import SessionManager
from flask_cors import CORS
app = Flask(__name__)
cors = CORS(app, resources={r"/*": {"origins": "*"}})
ml = ML()
db = DB()
social = Social([db, ml])
sessMan = SessionManager(db, social)
@app.route('/sessMan/getTweets', methods=['get'])
def runGetTweets():
PID = request.args.get('key')[1:]
count = db.getCountPerDay(PID)[0][0]
print(count)
return sessMan.getTweets(PID, count), 200
@app.route('/sessMan/isRunning', methods=['get'])
def profileIsRunning():
PID = request.args.get('key')[1:]
return str(sessMan.isProfileRunning(PID))
@app.route('/sessMan/stopProfile', methods=['get'])
#!/usr/bin/env python
import sys
from threading import Thread
from Config import Config
from ControlPane import ControlPane
from SessionManager import SessionManager
tmuxSessionName = sys.argv[1]
configFilePath = sys.argv[2]
config = Config(configFilePath)
sessionManager = SessionManager(tmuxSessionName)
# class Colors:
# default = '\033[49m'
# cyan = '\033[87m'
def initialize():
sessionManager.resize_pane(1, 10)
sessionManager.send_keys(
"PS1='$(echo -e \"\e[1m\e[32m\$(date +%H:%M:%S)\e[0m | \e[94mTASK BASHER\e[0m | Executing... \")' Enter"
)
sessionManager.clear_pane()
if config.startupTask:
sessionManager.execute(config.startupTask.script)
Thread(target=initialize).start()
from flask_ask import Ask, statement, question, session
from RESTClient import RESTClient
from FiniteStateMachine import FiniteStateMachine
from SessionManager import SessionManager
from LearningGraph import LearningGraph, Node
from QTIValidator import QTIValidator
from time import strftime, localtime
import Helper
app = Flask(__name__)
ask = Ask(app, "/")
logging.getLogger("flask_ask").setLevel(logging.DEBUG)
REST = RESTClient()
FSM = FiniteStateMachine()
SM = SessionManager()
VAL = QTIValidator()
@ask.launch
def onLaunch():
# init FSM on launch
session.attributes['state'] = FSM.initFSM()
# set state launch
session.attributes['state'] = FSM.setState("launch")
# check if logged in
isLoggedIn, name = SM.checkLoggedIn()
# if logged in
if isLoggedIn:
session.attributes['state'] = FSM.setState("loggedin")
# load session
# -*- coding: utf-8 -*-
"""此模块通过调用GraphUtil和Serializer提供查询入口的底层函数"""
from SessionManager import SessionManager
from GraphUtil import GraphUtil
from django.conf import settings
from smart_backend.serializer import NodeSerializer, RelationshipSerializer, PathSerializer
from neo4j.v1 import types
MANAGER = SessionManager(settings.DB_URI, settings.DB_USERNAME,
settings.DB_PASSWORD)
GRAPHUITL = GraphUtil()
def test_cypher(conditions, targets, enable_graph, enable_like):
# cypher = GRAPHUITL.build_cypher(conditions, targets, enable_graph, enable_like)
cypher = "Match p = (b:Brand)-[r:BELONGS_TO]->()-[:SOLD_BY]->(d:Dealer{siteid:'1'}) return b, d limit 5"
targets = ["b", "d"]
with MANAGER.session as session:
records = session.run(cypher)
for record in records:
for key in targets:
if isinstance(record[key], types.Node):
yield NodeSerializer(record[key]).data
elif isinstance(record[key], types.Relationship):
yield RelationshipSerializer(record[key]).data
elif isinstance(record[key], types.Path):
yield PathSerializer(record[key]).data
def auto_query(conditions, targets, enable_graph, enable_like):
"""
