def setUp(self) -> None:
# get connection, 2 users, 2 polls (named/unnamed), 4 votes, third user for testing the logIn
self.connection = MongoDB()
self.user: User = User("mavroudo", "*****@*****.**", "1234")
self.user2: User = User("charis", "*****@*****.**", "12345")
self.user3: User = User("Stef", "*****@*****.**", "asdf")
# user: UserWrapper = self.connection.userDB.deleteUser(self.user.mail)
# user2: UserWrapper = self.connection.userDB.deleteUser(self.user2.mail)
userWrapper: UserWrapper = self.connection.userDB.createNewUser(self.user.name, self.user.mail,
self.user.password)
self.assertIsNotNone(userWrapper.object)
self.assertIsNotNone(userWrapper.object.session_id)
self.session_id = userWrapper.object.session_id
userWrapper2: UserWrapper = self.connection.userDB.createNewUser(self.user2.name, self.user2.mail,
self.user2.password)
self.assertIsNotNone(userWrapper2.object)
self.assertIsNotNone(userWrapper2.object.session_id)
self.session_id2 = userWrapper.object.session_id
# get user id from session_id
(user, self.user_id) = self.connection.userDB.getUserWithSessionId(self.session_id)
self.assertIsNotNone(user)
self.assertNotEqual(self.user_id, "")
(user2, self.user_id2) = self.connection.userDB.getUserWithSessionId(self.session_id2)
self.assertIsNotNone(user2)
self.assertNotEqual(self.user_id2, "")
# add polls
self.poll: Poll = Poll("how cool are we?", ["A lot", "A lot but second", "same as 2"], named=True, unique=True,
creator_user_id=self.user_id)
pollWrapper: PollWrapper = self.connection.pollsDB.createPoll(self.poll.question, self.poll.options,
self.poll.named, self.poll.unique, self.user_id)
self.assertTrue(pollWrapper.operationDone)
self.assertIsNotNone(pollWrapper.object)
self.poll_id = pollWrapper.pollId
self.poll2_noNamed: Poll = Poll("how cool are we?", ["A lot", "A lot but second", "same as 2"], named=False,
unique=True,
creator_user_id=self.user_id)
pollWrapper2: PollWrapper = self.connection.pollsDB.createPoll(self.poll2_noNamed.question,
self.poll2_noNamed.options,
self.poll2_noNamed.named,
self.poll2_noNamed.unique, self.user_id)
self.assertTrue(pollWrapper2.operationDone)
self.assertIsNotNone(pollWrapper2.object)
self.poll_id2 = pollWrapper2.pollId
# add 2 votes for each
voteWrapper: VotesWrapper = self.connection.votesDB.createVote(self.user_id, self.poll_id, self.poll.named, 0)
self.assertTrue(voteWrapper.operationDone)
voteWrapper: VotesWrapper = self.connection.votesDB.createVote(self.user_id2, self.poll_id, self.poll.named, 1)
self.assertTrue(voteWrapper.operationDone)
voteWrapper: VotesWrapper = self.connection.votesDB.createVote(self.user_id, self.poll_id2,
self.poll2_noNamed.named, 0)
self.assertTrue(voteWrapper.operationDone)
voteWrapper: VotesWrapper = self.connection.votesDB.createVote(self.user_id2, self.poll_id2,
self.poll2_noNamed.named, 1)
self.assertTrue(voteWrapper.operationDone)
def setUp(self) -> None:
self.connection = MongoDB() # this will connect to mongo
self.user1 = User("mavroudo", "*****@*****.**", "1234")
self.user2_same_mail = User("mavroudo2", "*****@*****.**", "4567")
self.user3 = User("kalliopi", "*****@*****.**", "789")
userWrapper: UserWrapper = self.connection.userDB.createNewUser(
self.user1.name, self.user1.mail, self.user1.password)
self.assertTrue(userWrapper.operationDone)
self.session_id = userWrapper.object.session_id
def populate(self, all_users):
user_id = -1
items = []
for entry in all_users:
if user_id != entry[0]:
if user_id != -1:
current_user.borrowed_items = set(items[:])
self.list_of_users.append(current_user)
user_id = entry[0]
current_user = User(entry[0], entry[1], entry[2], entry[3],
entry[4], entry[5], entry[6], entry[7])
items = []
if entry[8] is not None:
# (id, fk, status, return_date, user_fk)
items.append(
PhysicalBook(entry[8], entry[9], entry[10], entry[11],
entry[12]))
if entry[13] is not None:
items.append(
PhysicalMusic(entry[13], entry[14], entry[15], entry[16],
entry[17]))
if entry[18] is not None:
items.append(
PhysicalMovie(entry[18], entry[19], entry[20], entry[21],
entry[22]))
# to account for the last user
current_user.borrowed_items = set(items[:])
self.list_of_users.append(current_user)
def post(self):
data = json.loads(self.request.body.decode("utf-8"))
user = User(data['first_name'], data['last_name'], data['password'],
data['email'], data['phone'], [])
self.__users_repo.create(user)
self.set_status(201)
def new_user():
if request.json:
if "password" not in request.json or "username" not in request.json:
return make_response(400, 6, "username and password json fields required")
else:
username = request.json.get('username')
password = request.json.get('password')
else:
return make_response(400, 6, "Invalid request data")
if User.query.filter_by(username=username).first() is not None:
return make_response(409, 1, "Username already exists")
else:
user = User(username=username)
user.hash_password(password)
try:
db.session.add(user)
db.session.commit()
return jsonify({'hypermedia': {
'info': {
'resource': str('/api/user/' + str(user.id)),
'method': 'GET'
},
'self': {
'resource': str('/api/user' + str(user.id)),
'method': 'GET'
}
},
'message': 'Created.'
}), 201
except Exception:
return make_response(500, 2, "Database exception")
def add(self, user: User):
if not self.user_exists(user):
self.db.insert(user.__dict__)
addedUser = self.get_by_id(user.email)
return User(addedUser['email'], addedUser['username'])
else:
raise Exception("User with email: " + user.email + " already exists")
def insertUser(name, fullname, password):
user = User(name=name, fullname=fullname, password=password)
try:
um.insertUser(user)
except:
return 400, {'msg': '新增用户时发生错误'}
return 201, user.to_dict()
async def user_register(*, name, email, passwd):
if not name or not name.strip():
raise APIValueError(name)
if not email or not _RE_EMAIL.match(email):
raise APIValueError(email)
if not passwd or not _RE_SHA1.match(passwd):
raise APIValueError(passwd)
users = await User.findAll('email=?', [email])
if len(users) > 0:
raise APIError(error='register:failed',
data='email',
message='该邮箱已被注册.')
uid = next_id()
sha1_passwd = '%s:%s' % (uid, passwd)
user = User(id=uid,
name=name.strip(),
email=email,
passwd=hashlib.sha1(sha1_passwd.encode('utf-8')).hexdigest(),
image='http://www.gravatar.com/avatar/%s?d=mm&s=120' %
hashlib.md5(email.encode('utf-8')).hexdigest())
res = await user.save()
if res == 1:
return res
else:
logging.error(msg="用户注册失败")
raise APIError(error='register:failed', data='', message='系统错误，请稍后重试。')
def addUser(self, name, fullName, password, email=None, url=None):
"""Create a User
@param name: user's name
@param fullName: user's full name
@param password: user's password
@param email: user's email (default value is set by Confluence)
@param url: user's URL on Confluence (default value is set by Confluence)
@return: User"""
user = User(name, fullName)
user.email = email
user.url = url
try:
result = self.server.addUser(self.token, user.toDict(), password)
return user.toDict()
except Exception, ex:
self.logger.log(str(ex))
raise Exception(
'Unable to add user with the given name %(name)s, full name %(fullName)s, Reason %(errorMessage)s'
% {
'name': name,
'fullName': fullName,
'errorMessage': Utils.extractDetails(ex)
})
class Post:
topic = Topic("", None, None)
user = User("", "", "")
postDate = ""
content = ""
def __init__(self, postDate, content, topic, user):
self.topic = topic
self.user = user
self.postDate = postDate
self.content = content
@staticmethod
def creationPost(content, idTopic, idUser):
return bdd.creationPost(content, idTopic, idUser)
@staticmethod
def listePost(idTopic):
return bdd.listePost(idTopic)
@staticmethod
def suppressionPost(idPost):
return bdd.suppressionPost(idPost)
@staticmethod
def miseAjourPost(idPost, content):
return bdd.miseAjourPost(idPost, content)
def fetch_reservation_data(self, token):
"""Get Details of Reservation History"""
response = self.authservice.get_email_from_token(token)
if not response['status']:
return False
user = User(response['email'], readonly=True)
return [r.get_data_dict() for r in user.reservations]
def register():
data = request.json
log(data)
u = User(**data)
u.save()
session = Session.new(u)
return session.response()
def connect(self, nickname, addr, port="50001"):
self.user = User(nickname, addr, port)
self.receiver = MessagingReceiver(port, self, nickname)
self.sender = MessagingSender()
self.receiver.discover(addr)
self.voiceReceiver = VoiceReceiver()
self.voiceSender = VoiceSender()
def update_user_data(self, token: str, updata: dict, join: bool) -> dict:
"""Update User information"""
user = self.authservice.get_email_from_token(token)
if "status" not in user or not user["status"]:
return {"status": False, "message": "Invalid Token."}
if any(k in updata
for k in ["password", "balance", "dataflags", "user_id"]):
return {"status": False, "message": "Invalid Arguments."}
wuser = User(user["email"])
for field in [
'first_name', 'last_name', 'street', 'number', 'plz', 'city',
'country', 'client_settings'
]:
if field in updata:
if join and field == 'client_settings':
j = json.loads(wuser.client_settings) # type: json
j2 = json.loads(updata[field])
merge(j, j2)
wuser.client_settings = json.dumps(j)
else:
setattr(wuser, field, updata[field])
wuser.save()
wuser.flush()
return {"status": True}
def register():
if not request.json:
resultDict = returnNoneMsg("failed!")
return jsonify(resultDict)
jsonData = request.get_data()
dataDict = json.loads(jsonData)
name = dataDict.get('name', None)
password = dataDict.get('password', None)
email = dataDict.get('email', None)
phone = dataDict.get('phone', None)
user_info = User.query.filter_by(user_name=name).first()
if user_info:
resultDict = returnNoneMsg(cec.code_1)
return jsonify(resultDict)
user = User(user_name=name,
email=email,
phone=phone,
user_password=generate_password_hash(password),
user_reg_ip=request.remote_addr)
db.session.add(user)
db.session.commit()
resultDict = returnMsg("register success")
return jsonify(resultDict)
def noPath(update, context):
currUser = User(update.effective_user.first_name,
update.effective_user.full_name,
update.effective_user.id,
update.effective_user.is_bot,
update.effective_user.last_name,
update.effective_user.name)
query = update.callback_query
query.answer()
send_edit_text(query,
text=DidYouReleaseTheFishYouCaught)
context.bot.send_message(update.effective_chat.id,
text=ReminderNoPathMsg,
parse_mode=telegram.ParseMode.MARKDOWN)
keyboard = [[InlineKeyboardButton(CaughtAFishMsg, callback_data=str('caught'))],
[InlineKeyboardButton('Quit', callback_data=str('quit'))]]
reply_markup = InlineKeyboardMarkup(keyboard)
context.bot.send_message(update.effective_chat.id,
text=YouMayBeginYourCatchMsg,
parse_mode=telegram.ParseMode.MARKDOWN,
reply_markup=reply_markup)
fish = Fish(currUser.id, currUser.name,
context.user_data['photoId'], context.user_data['category'], context.user_data['details'],
"Not Released")
saveFishToExcel(currUser, fish)
return IHAVEAFISH
def cancel_reservation(self, token, reservationid):
"""Cancel Reservation"""
response = self.authservice.get_email_from_token(token)
if not response['status']:
return False
user = User(response['email'])
if user.balance is None:
user.balance = Decimal(0)
reservation = self.get_user_reservation_for_id(user, reservationid)
if reservation is None or reservation.reservation_start is None:
return False
if reservation.parking_start is not None:
return False
spot = ParkingSpot(reservation.spot_id)
lot = ParkingLot(spot.lot_id)
reservation.parking_start = reservation.parking_end = datetime.now()
user.balance -= reservation.reservation_fee
user.save()
user.flush()
lot.removeReservation(reservation.spot_id)
reservation.remove_mapping()
return True
def reportAFish(update, context):
query = update.callback_query
query.answer()
context.bot.delete_message(update.effective_chat.id, query.message.message_id)
# Check if the user is still logged in
currUser = User(update.effective_user.first_name,
update.effective_user.full_name,
update.effective_user.id,
update.effective_user.is_bot,
update.effective_user.last_name,
update.effective_user.name)
if (isLastShareLocationMoreThan15(currUser)):
keyboard = []
keyboard.append([InlineKeyboardButton("Next", callback_data=str('next'))])
reply_markup = InlineKeyboardMarkup(keyboard)
# Send message with text and appended InlineKeyboard
context.bot.send_message(update.effective_chat.id,
text=YourLiveLocationExpiredMsg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=reply_markup
)
# Tell ConversationHandler that we're in state `FIRST` now
return JOIN
keyboard = [[InlineKeyboardButton('Quit', callback_data=str('quit'))]]
reply_markup = InlineKeyboardMarkup(keyboard)
context.bot.send_message(update.effective_chat.id,
text=CongratulationsOnCaughtMsg,
parse_mode=telegram.ParseMode.MARKDOWN,
reply_markup=reply_markup)
return UPLOADPHOTO
class Topic:
title = ""
categorie = ""
user = User("","","")
def __init__(self, title, categorie, user):
self.title = title
self.categorie = categorie
self.user = user
@staticmethod
def listeTitreTopic():
return bdd.listeTitreTopic()
@staticmethod
def creationTopic(title, idCategory, idUser):
return bdd.creationTopic(title, idCategory, idUser)
@staticmethod
def supressionTopic(idTopic):
return bdd.supressionTopic(idTopic)
@staticmethod
def miseAjourTopic(idTopic, title):
return bdd.miseAjourTopic(idTopic,title)
def joined(update, context):
currUser = User(update.effective_user.first_name,
update.effective_user.full_name,
update.effective_user.id,
update.effective_user.is_bot,
update.effective_user.last_name,
update.effective_user.name)
query = update.callback_query
query.answer()
context.bot.delete_message(update.effective_chat.id, query.message.message_id)
if not isUserSharingLocation(currUser):
keyboard = [[InlineKeyboardButton('Next', callback_data=str('next'))]]
reply_markup = InlineKeyboardMarkup(keyboard)
context.bot.send_message(update.effective_chat.id,
text=NotSharedLocationPleaseShareMsg,
parse_mode=telegram.ParseMode.MARKDOWN,
reply_markup=reply_markup)
return JOIN
keyboard = [[InlineKeyboardButton(CaughtAFishMsg, callback_data=str('caught'))],
[InlineKeyboardButton('Quit', callback_data=str('quit'))]]
reply_markup = InlineKeyboardMarkup(keyboard)
context.bot.send_message(update.effective_chat.id,
text=YouMayBeginYourCatchMsg,
parse_mode=telegram.ParseMode.MARKDOWN,
reply_markup=reply_markup)
return IHAVEAFISH
def login(self, email, password):
try:
user = self.__userRepository.get_by_id(email)
user = User(user['email'], user['username'], user['password'])
if user and bcrypt.checkpw(password.encode(), user.password.encode()):
auth_token = user.encode_auth_token()
response_object = {
'status': 'success',
'message': 'Successfully logged in.',
'auth_token': auth_token.decode()
}
return json.dumps(response_object)
else:
response_object = {
'status': 'fail',
'message': 'User does not exist.'
}
return json.dumps(response_object)
except Exception as e:
print(e)
response_object = {
'status': 'fail',
'message': 'Try again'
}
return json.dumps(response_object)
def register(self, email, password, username):
"""
Register the user
:param email:
:param password:
:param username:
:return string:
"""
user = self.__userRepository.get_by_id(email)
if not user:
try:
new_user = User(email, username, bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode("utf-8"))
added_user = self.__userRepository.add(new_user)
auth_token = added_user.encode_auth_token()
response_object = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return json.dumps(response_object)
except Exception as e:
response_object = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return json.dumps(response_object)
else:
response_object = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return json.dumps(response_object)
def begin_parking(self, token, reservationid):
"""State the presence at the parking spot and request barrier opening"""
response = self.authservice.get_email_from_token(token)
if not response['status']:
return False
user = User(response['email'])
reservation = self.get_user_reservation_for_id(user, reservationid)
if reservation is None:
return False
spot = ParkingSpot(reservation.spot_id)
lot = ParkingLot(spot.lot_id)
if lot.api_path is not None:
response = requests.post(lot.api_path + "/unlock?" +
spot.coap_ip.decode(),
cert='assets/alice2.pem',
data=str(reservation.res_id),
verify=False)
if response.status_code < 200 or response.status_code >= 300:
from sys import stderr
print(lot.api_path + "/unlock?" + str(spot.coap_ip),
response.status_code,
response.content,
response.headers,
file=stderr)
return False
reservation.parking_start = datetime.now()
user.balance -= Decimal(reservation.reservation_fee)
user.save()
user.flush()
return True
def getLocationAfterStart(update, context):
currUser = User(update.effective_user.first_name,
update.effective_user.full_name,
update.effective_user.id,
update.effective_user.is_bot,
update.effective_user.last_name,
update.effective_user.name)
message = None
if update.edited_message:
message = update.edited_message
else:
message = update.message
print("getting position after start")
current_pos = (message.location.latitude, message.location.longitude)
currUser.setLocation(message.location.latitude, message.location.longitude)
setSharingLocationUser(currUser)
saveLocationToExcel(currUser)
keyboard = []
keyboard.append([InlineKeyboardButton("Next", callback_data=str('next'))])
reply_markup = InlineKeyboardMarkup(keyboard)
# Send message with text and appended InlineKeyboard
context.bot.send_message(update.effective_chat.id,
text=GotLocationMsg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=reply_markup
)
return JOIN
def end_parking(self, event):
"""IoT Gateway announces the leaving of a Car"""
reservationid = event["ID"]
duration = event["stopTime"] - event["startTime"]
try:
user = User(Reservation.get_email_from_resid(reservationid))
except NotFoundException:
return False
reservation = self.get_user_reservation_for_id(user, reservationid)
if reservation is None or reservation.parking_end is not None:
return False
spot = ParkingSpot(reservation.spot_id)
lot = ParkingLot(spot.lot_id)
begin = any_to_datetime(reservation.parking_start)
end = begin + timedelta(seconds=duration)
reservation.parking_end = end
user.balance -= Decimal(reservation.parking_fee)
user.save()
user.flush()
lot.removeReservation(reservation.spot_id)
reservation.remove_mapping()
return True
def setUp(self) -> None:
# get connection, create a user, get its session_id, create a Poll object
self.connection = MongoDB()
self.user: User = User("mavroudo", "*****@*****.**", "1234")
userWrapper: UserWrapper = self.connection.userDB.createNewUser(
self.user.name, self.user.mail, self.user.password)
self.assertIsNotNone(userWrapper.object)
self.assertIsNotNone(userWrapper.object.session_id)
self.session_id = userWrapper.object.session_id
# get user id from session_id
(user, user_id) = self.connection.userDB.getUserWithSessionId(
self.session_id)
self.assertIsNotNone(user)
self.assertNotEqual(user_id, "")
self.poll: Poll = Poll("how cool are we?",
["A lot", "A lot but second", "same as 2"],
named=True,
unique=True,
creator_user_id=user_id)
pollWrapper: PollWrapper = self.connection.pollsDB.createPoll(
self.poll.question, self.poll.options, self.poll.named,
self.poll.unique, user_id)
self.assertTrue(pollWrapper.operationDone)
self.assertIsNotNone(pollWrapper.object)
self.poll_id = pollWrapper.pollId
def fetch_user_data(self, token):
"""Return User information"""
user = self.authservice.get_email_from_token(token)
if "status" not in user or not user["status"]:
return {"status": False, "message": "Invalid Token."}
ruser = User(user["email"], readonly=True)
return {"status": True, "user": ruser.get_data_dict()}
def receiveReleaseVideo(update, context):
currUser = User(update.effective_user.first_name,
update.effective_user.full_name,
update.effective_user.id,
update.effective_user.is_bot,
update.effective_user.last_name,
update.effective_user.name)
# deleteMessage(update, context, 2)
file = context.bot.getFile(update.message.video.file_id)
# mime_type =
print("video_id: " + str(file.file_id))
file_type = file.file_path.split('.')[-1]
videoId = '{}-{}-video-{}.{}'.format(update.effective_user.name, update.effective_user.id,
datetime.timestamp(datetime.now()), file_type)
file.download(videoId)
context.user_data['videoId'] = videoId
keyboard = [[InlineKeyboardButton(CaughtAFishMsg, callback_data=str('caught'))],
[InlineKeyboardButton('Quit', callback_data=str('quit'))]]
reply_markup = InlineKeyboardMarkup(keyboard)
context.bot.send_message(update.effective_chat.id,
text=ThanksForSubmittingTheVideo,
parse_mode=telegram.ParseMode.MARKDOWN,
reply_markup=reply_markup)
#
# fish = Fish(context.user_data['photoId'], context.user_data['category'], context.user_data['details'],
# context.user_data['videoId'])
# saveFishToExcel(currUser, fish)
return IHAVEAFISH
def index(self):
user_model = User()
users = user_model.get_total_users()
return self.render('home_admin.html', report={
'users': users[0],
})
def _get_user(self, user_id, cursor):
command = 'SELECT * FROM `frc_library`.`user` WHERE `user_id` = %s;'
cursor.execute(command, user_id)
result = cursor.fetchone()
if result:
return User(user_id, result[0], result[2])
else:
return None
