def __init__(self,
screen_title='OpenNI',
screen_size=(640, 480),
res=RES_VGA,
fps=30):
self.context = Context()
self.context.init()
self.res = res
self.fps = fps
self.depth_generator = DepthGenerator()
self.depth_generator.create(self.context)
self.depth_generator.set_resolution_preset(self.res)
self.depth_generator.fps = self.fps
self.image_generator = ImageGenerator()
self.image_generator.create(self.context)
self.image_generator.set_resolution_preset(self.res)
self.image_generator.fps = self.fps
self.user_manager = UserManager(self.context, self.depth_generator)
self.context.start_generating_all()
pygame.init()
self.screen = pygame.display.set_mode(screen_size)
pygame.display.set_caption(screen_title)
def __init__(self, slack_clients, msg_writer, markov_chain):
self.clients = slack_clients
self.msg_writer = msg_writer
self.game_manager = GameManager(self.msg_writer)
self.user_manager = UserManager(self.clients, self.msg_writer)
self.tictactoe_manager = TicTacToeManager(
self.msg_writer, self.user_manager, self.game_manager
)
self.response_master = Response_master(self.msg_writer)
self.user_manager = UserManager(self.clients, self.msg_writer)
self.rude_manager = RudeManager(self.msg_writer)
self.channel_manager = ChannelManager(slack_clients)
self.markov_chain = markov_chain
markov_files = ['hpOne.txt', 'lotrOne.txt', 'memoriesOfIce.txt']
self.lotrMarkov = Markov(2, msg_writer, markov_files)
def __init__(self, setting_filename):
dir_path = os.path.dirname(os.path.realpath(__file__))
self.cfg = Config(os.path.join(dir_path, setting_filename))
self.logger = Log.get_logger(os.path.join(dir_path, self.cfg.LOG_FILE))
self.cfg.verify_config()
self.botAPI = VkApi(self.cfg)
self.uManager = UserManager(os.path.join(dir_path, self.cfg.USERS_FILE))
self.logger.info("\nVKBot started")
def setUpClass(cls):
"""Called before everything. (setup)"""
print("setUpClass")
cls.user_manager = UserManager()
cls.user = {
'name': 'Libor',
'surname': 'Zachoval',
'email': '*****@*****.**',
'role': 'Admin',
'password': '******'
}
async def main():
man = UserManager(sys.argv[1])
await man.connect()
if not await man.is_username_taken(sys.argv[2]):
print("User does not exist!")
await man.shutdown()
return
await man.drop_user(sys.argv[2])
print(f"User '{sys.argv[2]}' has been removed from the database!")
await man.shutdown()
def login_command(transport, data):
if transport is None:
return
else:
log.debug('login command start')
login = data['login']
password = data['password']
_id = int(data['id'])
usermanager = UserManager()
user = usermanager.get_user(login)
if not user:
usermanager.add_user(login, password)
user = usermanager.get_user(login)
log.debug('get user %i' % user.uid)
transport.uid = user.uid
user.transport = transport
rspd = {'login': login, 'status': 'ok'}
rsp = Mlang().create_rsp(rspd, _id)
peername = transport.get_extra_info('peername')
log.debug('client logon : %i %s' % (user.uid, str(peername)))
transport.write(rsp.encode())
log.debug('login command end')
def check_init(self, sas_if, sas_api, config=None, logger=print) -> bool:
final_ret = True
with self.__lock:
if self.__init:
return True
self.__sas_if = sas_if
self.__sas_api = sas_api
self.__config = config if config is not None else self.__sas_api.config(
)
self.__logger = logger
self.__sas_terminal = SasTerminal(self.__sas_if, self.__sas_api)
self.__user_manager = UserManager()
self.__access_control = AccessControl()
ret = self.__init_offline_analysis_result()
final_ret = ret and final_ret
self.__init = final_ret
return final_ret
class User(AbstractBaseUser, PermissionsMixin):
REQUIRED_FIELDS = []
USERNAME_FIELD = 'user_name'
user_name = models.EmailField(blank=False, unique=True, max_length=200)
first_name = models.CharField(max_length=50)
last_name = models.CharField(max_length=50)
parent_name = models.CharField(max_length=200, null=True)
reg_no = models.IntegerField(null=True)
mobile_no = models.CharField(max_length=12, null=True)
password = models.CharField(max_length=50)
profile_image = models.CharField(max_length=500)
dob = models.DateField(null=True)
standard = models.CharField(max_length=10, null=True)
user_type = models.CharField(max_length=10)
is_admin = models.BooleanField(default=False)
created_by = models.ForeignKey('self',
null=True,
related_name="u_created_by")
updated_by = models.ForeignKey('self',
null=True,
related_name="u_updated_by")
teacher_id = models.ForeignKey('self',
null=True,
related_name="u_teacher_id")
updated_at = models.DateTimeField(auto_now_add=True)
created_at = models.DateTimeField(auto_now_add=True)
objects = UserManager()
def get_full_name(self):
full_name = '%s %s' % (self.first_name, self.last_name)
return full_name.strip()
def check_password(self, password):
if self.password == password:
return True
return False
key = k
connections.pop(key)
print("Total Connections: ", len(connections))
def send_message(self,type,data):
print("send_message")
msg=dict()
msg["type"]=type
msg["data"]=data
msg=json.dumps(msg)
self.write_message(msg)
user_manager = UserManager()
settings = {
'debug':True #includes autoreload
}
app= tornado.web.Application([
#map the handler to the URI named "wstest"
(r'/wstest', WSHandler),
], settings)
if __name__ == '__main__':
server_port = 8080
print("server starting")
app.listen(server_port)
ioloop = tornado.ioloop.IOLoop.instance()
autoreload.start(ioloop)
def __init__(self, configured_api):
self.twitterApi = configured_api
self.manager = UserManager(configured_api)
def __init__(self):
self.__socket = self.init_socket()
# 用户管理器
self.__user_manager = UserManager()
import os
import itchat
from itchat.content import TEXT, PICTURE, CARD
from constant import pkl_path, qr_path, pic_dir, cmd_user_name
from constant import use_mq, mq_queue
from log import gen_logger
from tools import msg_repeated, clear_db_task, msg2json, json2msg
from user_manager import UserManager
if use_mq:
from mq_manager import MQProducer, MQConsumer
import threading
logger = gen_logger("logger.py")
# UserManager对象
user_m = UserManager()
if use_mq:
mq_p = MQProducer(mq_queue)
def log_card(msg):
'''打印名片'''
nickname = msg.get('RecommendInfo', {}).get('NickName', "NULL")
logger.info(nickname)
@itchat.msg_register([TEXT, PICTURE, CARD],
isFriendChat=True,
isGroupChat=True)
def msg_reply(msg):
'''接收消息'''
"image": "success",
"music": "info",
"text": "warning"
}
iconMapping = {
"video": "video",
"image": "image",
"music": "audio",
"text": "alt"
}
offerManager = OfferManager(os.path.join(app.instance_path, 'offers.json'),
os.path.join(app.instance_path, 'buys.json'))
userManager = UserManager(os.path.join(app.instance_path, 'users.json'))
@app.route('/')
@app.route('/index')
def index():
if current_user.is_authenticated:
return redirect(url_for('shop'))
return render_template('index.html', form=LoginForm())
@app.route("/registerAction", methods=['POST'])
def signUp():
form = RegisterForm()
if form.validate_on_submit():
from flask import render_template, jsonify
from flask_login import login_required, current_user
from boxer_app import app
from users import User
import boxer_app
from user_manager import UserManager
import datetime
tstring = datetime.datetime.utcnow().strftime("%Y-%H-%M-%S")
admin_user = User.get_user_by_username("admin")
user_manager = UserManager("user")
from js_source_management import js_source_dict, _develop, css_source
@app.route('/admin_list_with_metadata/<res_type>', methods=['GET', 'POST'])
@login_required
def admin_list_with_metadata(res_type):
manager = user_manager
return jsonify({"data_list": manager.get_resource_data_list()})
@app.route('/admin_interface', methods=['GET', 'POST'])
@login_required
def admin_interface():
if current_user.get_id() == admin_user.get_id():
return render_template("library/library_home_react.html",
develop=str(_develop),
#encoding=utf-8 from utils.log import logger from user_manager import UserManager userManager = UserManager(logger)
