def register_interface(back_dic, conn):
user_name = back_dic.get('name')
user_pwd = common.get_pwd_md5(back_dic.get('pwd'))
user_type = back_dic.get('user_type')
user_obj_list = models.User.select(user_name=user_name)
if user_obj_list:
for user_obj in user_obj_list:
if user_obj.user_type == user_type:
send_dic = {'flag': False, 'msg': '该用户已经存在了！'}
break
else:
user_obj = models.User(user_name=user_name,
pwd=user_pwd,
is_vip=0,
is_locked=0,
user_type=user_type,
register_time=datetime.datetime.now())
user_obj.save()
send_dic = {'flag': True, 'msg': '用户注册成功'}
else:
user_obj = models.User(user_name=user_name,
pwd=user_pwd,
is_vip=0,
is_locked=0,
user_type=user_type,
register_time=datetime.datetime.now())
user_obj.save()
send_dic = {'flag': True, 'msg': '用户注册成功'}
print(send_dic)
common.send_msg(send_dic, conn)
def register_interface(client_back_dic, conn):
# 写业务逻辑
# 1.判断用户名是否存在
username = client_back_dic.get('username')
# 通过用户名当作条件查询
user_obj_list = models.User.select(name=username)
# 若存在，给客户端返回数据, 告诉用户，用户已存在!
if user_obj_list:
send_dic = {'flag': False, 'msg': '用户已存在!'}
# 若不存在，保存数据到MySQL数据库中， 返回注册成功给客户端
else:
password = client_back_dic.get('password')
user_obj = models.User(
name=username,
# pwd, is_vip, is_locked, user_type, register_time
pwd=common.get_md5_pwd(password),
is_vip=0, # 0表示不是VIP， 1表示VIP
is_locked=0, # 0表示不锁定， 1表示锁定
user_type=client_back_dic.get('user_type'),
register_time=common.get_time())
user_obj.save()
send_dic = {'flag': True, 'msg': '注册成功'}
common.send_data(send_dic, conn)
def initialize_database():
"""Create database for self use."""
print(DATABASE_URI)
with transaction() as s:
# Create Madors:
# Creat Permissions:
admin_permission = models.Permission(type="admin")
operator_permission = models.Permission(type="reporter")
commander_permission = models.Permission(type="commander")
s.add_all([admin_permission, operator_permission,
commander_permission])
s.commit()
# Create Reasons:
with open(f"{BASE_PATH}/fixtures/reasons.json", 'r') as f:
reasons = json.loads(f.read())
s.add_all([models.date_datas.Reason(name=reason) for reason in
reasons.values()])
# Create Users:
one_report = models.User(english_name="One Report",
username="******",
password=get_password_hash("one_report"),
permissions=[
commander_permission,
admin_permission])
s.add(one_report)
s.commit()
def create_user_from_key(self, user: schemas.UserCreate, key: str,
db: Session) -> Any:
""" Add New User"""
try:
hashed_password = passutil.get_password_hash(str(user.password))
db_user = models.User(id=str(uuid.uuid4().hex),
email=user.email,
hashed_password=hashed_password,
first_name=user.first_name,
is_active=user.is_active,
is_admin=user.is_admin,
created_by_userid=user.created_by_userid)
db_key = db.query(models.AccessKey).filter(
models.AccessKey.key_id == key).first()
db_key.user_id = db_user.id
db.add(db_user)
db.commit()
db.refresh(db_user)
db.refresh(db_key)
return db_user
except SQLAlchemyError as e:
print(e)
def get_fake_user():
full_name, username, password = _get_fake_username_password()
return models.User(
english_name=full_name,
username=username,
password=database.get_password_hash(password)
)
def map_user_to_model(user: User) -> models.User:
model = models.User(username=user.username,
full_name=user.full_name,
email=user.email,
disabled=user.disabled)
if user.oid > 0:
model.id = user.oid
return model
def create_user(db: Session, user: schemas.UserCreate):
fake_hashed_password = user.password + "notreallyhashed"
db_user = models.User(email=user.email,
hashed_password=fake_hashed_password)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
def register_interface(user,pwd):
user_obj = models.User.select(user)
if user_obj:
return '用户已存在'
models.User(user,common_interface.encrypt(pwd))
return f'{user}注册成功'
def user_create_customer(values, session=None):
if not session:
session = get_session()
with session.begin(subtransactions=True):
user_ref = models.User()
session.add(user_ref)
user_ref.update(values)
return user_ref
def register(user_dic,conn):
user=models.User.select_one(name=user_dic['name'])
if user:
back_dic={'flag':False,'msg':'username has existed'}
else:
user=models.User(name=user_dic['name'],password=user_dic['password'],user_type=user_dic['user_type'])
user.save()
back_dic={'flag':True,'msg':'user:%s register successfully'%user_dic['name']}
common.send_back(back_dic,conn)
def register(user_dic):
user = models.User.select_one(name=user_dic['name'])
if user: # 用户存在
back_dic = {'flag': False, 'msg': 'user is exisit'}
else:
user = models.User(name=user_dic['name'], password=user_dic['password'], user_type=user_dic['user_type'])
user.save()
back_dic = {'flag': True, 'msg': 'register success'}
return back_dic
def post(self, user, roles):
parser = reqparse.RequestParser()
parser.add_argument('username', type=str, required=True)
parser.add_argument('uid', type=int, required=True)
parser.add_argument('farm_user', type=bool)
args = parser.parse_args(strict=True)
user = m.User(username=args.get('username'))
data_access.UserDataAccess.save_user(db, user)
return user, 201
def user_create(values, session=None):
if not values['created_at']:
values['created_at'] = utc_now()
if not session:
session = get_session()
with session.begin(subtransactions=True):
user_ref = models.User()
session.add(user_ref)
user_ref.update(values)
return user_ref
def insertUser(email, username, password):
id = 1
tupe = hashpassword(password)
hash = tupe[0]
salt = tupe[1]
user = models.User(id=id, name=username, email=email, hash=hash, salt=salt, createddate=datetime.datetime.now(), lastlogindate=None, active=True)
print (user)
db.session.add()
db.session.commit()
def register(conn, message):
status, name, password = message.split('|')
# password = server_interface.get_file_md5(password)
if status == '1': # 管理员注册
now_role = models.Admin(name, password)
else:
now_role = models.User(name, password)
print(now_role.name)
is_success = db_handler.create_user(now_role, int(status))
msg = str(is_success) + '|0'
msg = msg.encode('utf-8')
conn.send(msg)
def create_user(user: schemas.UserCreate, session: Session = SessionLocal()):
db_user = models.User(**user.dict())
session.add(db_user)
msg = {"status": "success", "msg": f"user {user.username} created"}
try:
session.commit()
session.refresh(db_user)
except Exception:
session.rollback()
msg = {"status": "error", "msg": f"username {user.username} already taken"}
finally:
session.close()
return msg
def create_user(db: Session, user: schemas.UserCreate) -> Any:
try:
hashed_password = passutil.get_password_hash(str(user.password))
db_user = models.User(email=user.email,
password=hashed_password,
name=user.name)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("create_user")
return None
def register_interface(name, password, status):
if status == 1:
now_user = models.Admin(name, password)
else:
now_user = models.User(name, password)
flag, msg = db_handler.create_user(now_user, status)
if flag:
if status == 1:
role = 'admin'
else:
role = 'user'
logging.info('{} {}完成注册'.format(role, name))
return flag, msg
def register(back_dic, conn):
user_list = models.User.select(name=back_dic.get('name'))
if not user_list:
user_obj = models.User(name=back_dic.get('name'),
password=back_dic.get('password'),
is_vip=0,
is_locked=0,
user_type=back_dic.get('user_type'),
register_time=common.get_now_time())
user_obj.insert()
send_dic = {'flag': True, 'msg': '注册成功！'}
else:
send_dic = {'flag': False, 'msg': '当前用户已存在！'}
common.send_msg(send_dic, conn)
def get_fake_current_user(app_test: TestClient, db: Session, name):
full_name, username, password = _get_fake_username_password(name)
current_user = models.User(
english_name=full_name,
username=username,
password=database.get_password_hash(password)
)
db.add(current_user)
db.commit()
token = _get_faked_user_token(
app_test=app_test,
username=username,
password=password
)
return current_user, token
def register_interface(back_dic, conn):
username = back_dic.get('username')
password = back_dic.get('password')
user_type = back_dic.get('user_type')
user_obj_list = models.User.orm_select(username=username)
if user_obj_list:
send_dic = {'flag': False, 'msg': '用户名已存在'}
else:
user_obj = models.User(username=username,
password=password,
user_type=user_type,
is_vip=0,
register_time=datetime.datetime.now())
user_obj.orm_insert()
send_dic = {'flag': True, 'msg': '注册成功'}
common.send_data(send_dic, conn)
def register(recv_dic, conn):
user_list = models.User.select(name=recv_dic['name'])
if not user_list:
# 注册
user_obj = models.User(name=recv_dic['name'],
password=recv_dic['password'],
is_vip=0,
is_locked=0,
user_type=recv_dic['user_type'],
register_time=common.get_time())
user_obj.save()
send_dic = {'flag': True, 'msg': '注册成功'}
else:
send_dic = {'flag': False, 'msg': '用户名已存在'}
common.send_msg(send_dic, conn)
def register(user_dic, conn):
'''
注册功能
:param user_dic:
:param conn:
:return:
'''
user = models.User.select_one(name=user_dic['name'])
if user: # 用户存在
back_dic = {'flag': False, 'msg': 'user is exisit'}
else:
user = models.User(name=user_dic['name'],
password=user_dic['password'],
user_type=user_dic['user_type'])
user.save()
back_dic = {'flag': True, 'msg': 'register success'}
common.send_back(back_dic, conn)
def create_user(self, user: schemas.UserCreate, created_by_userid: str,
db: Session) -> Any:
""" Add New User"""
try:
hashed_password = passutil.get_password_hash(str(user.password))
db_user = models.User(id=str(uuid.uuid4().hex),
email=user.email,
hashed_password=hashed_password,
first_name=user.first_name,
is_active=user.is_active,
is_admin=user.is_admin,
created_by_userid=created_by_userid)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
print(e)
def register_interface(recv_dict, conn):
username = recv_dict.get('username')
# 1.判断用户是否存在 ---接收到--->[{},{}] 列表套字典
user_obj_list = models.User.orm_select(username=username)
# 2.有值--->用户存在
if user_obj_list:
send_dict = {'flag': False, 'msg': '用户已存在'}
# 3.没有值就注册
else:
user_obj = models.User(username=username,
password=common.md5(recv_dict.get('password')),
user_type=recv_dict.get('user_type'),
is_vip=0,
register_time=datetime.datetime.now())
user_obj.orm_insert()
send_dict = {'flag': True, 'msg': '注册成功！'}
print(f'【{username}】用户注册成功！')
# 调用公共方法发送数据到客户端
common.send_dict(send_dict, conn)
def create_user(self, user: schemas.UserCreate, db: Session) -> Any:
""" Add New User"""
try:
hashed_password = passutil.get_password_hash(str(user.password))
db_user = models.User(email=user.email,
password=hashed_password,
first_name=user.first_name,
last_name=user.last_name,
full_name=user.full_name,
gender=user.gender,
is_active=user.is_active,
is_superuser=user.is_superuser,
is_admin=user.is_admin,
created_by_userid=user.created_by_userid,
modified_by_userid=user.created_by_userid)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
except SQLAlchemyError as e:
fastapi_logger.exception("create_user")
return None
def register_interface(user_dic, conn):
user_list = models.User.select_sql(user_name=user_dic.get("user_name"))
pwd = user_dic.get("pwd")
if not user_list:
user_obj = models.User(
user_name=user_dic.get("user_name"),
pwd=common.get_pwd_md5(pwd),
register_time=datetime.datetime.now(),
is_vip=0,
is_locked=0,
user_type=user_dic.get("user_type"),
)
user_obj.instert_sql()
send_dic = {
"flag": True,
"msg": "注册成功",
}
common.send_msg(send_dic, conn)
else:
send_dic = {
"flag": False,
"msg": "注册失败",
}
common.send_msg(send_dic, conn)
def register_user(db: Session, username: str, pwd: str) -> schemas.User:
db_user = models.User(username=username, password=pwd)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
def create_user(db: Session, name: str, _id: int):
user = models.User()
user.name = name
user.id = _id
db.add(user)
db.commit()
def save_file(path, file_, source_id, source_type='stream'):
session = Session()
tweet_batch = []
user_batch = []
logger.info(f"Loading json file {path}")
for line in file_:
tweet_obj = orjson.loads(line)
if tweet_obj['user']['id'] in IGNORE_USERS:
continue
if tweet_obj['is_quote_status']:
q = tweet_obj.get('quoted_status')
if q:
u = q['user']
q['user_id'] = u['id']
if q['user_id'] in IGNORE_USERS:
continue
q['source_type'] = source_type
#q['source_id'] = source_id
tweet_batch.append(q)
user_batch.append(u)
if 'retweeted_status' in tweet_obj:
rt = tweet_obj.get('retweeted_status')
if rt:
u = rt['user']
rt['user_id'] = u['id']
if rt['user_id'] in IGNORE_USERS:
continue
rt['source_type'] = source_type
#rt['source_id'] = source_id
tweet_batch.append(rt)
user_batch.append(u)
tweet_obj['retweeted_status_id'] = rt.get('id')
tweet_obj['is_retweet_status'] = True
tweet_obj['source_type'] = source_type
#tweet_obj['source_id'] = source_id
tweet_obj['user_id'] = tweet_obj['user']['id']
tweet_batch.append(tweet_obj)
user_batch.append(tweet_obj['user'])
tweets = tweet_sc.load(tweet_batch, many=True)
users = user_sc.load(user_batch, many=True)
user_objs = [models.User(**user) for user in users]
tweet_objs = [models.Tweet(**tweet) for tweet in tweets]
source_objs = [
models.SourceTweet(tweet_id=tweet['id'], source_id=source_id)
for tweet in tweets
]
try:
logger.info(f"Adding {len(user_objs)} users to session")
for i, u in enumerate(user_objs):
if i % 5000 == 0:
logger.info(f"User {i} of {len(user_objs)}")
session.merge(u)
logger.info(f"Adding {len(tweet_objs)} tweets to session")
for i, t in enumerate(tweet_objs):
if i % 5000 == 0:
logger.info(f"Tweet {i} of {len(tweet_objs)}")
session.merge(t)
logger.info(f"Adding {len(source_objs)} tweet-source to session")
for i, so in enumerate(source_objs):
if i % 5000 == 0:
logger.info(f"SourceTweet {i} of {len(source_objs)}")
session.merge(so)
logger.info("Committing...")
session.commit()
logger.info("Done.")
except Exception as e:
logger.error(f"Error: {e}")
session.rollback()
raise
finally:
session.close()
