Exemplo n.º 1
0
    def test_user_is_present_by_phone(self, db):
        """
        This test try to test the simple operation to create a new operator

         Test flow:
         - Make the JSON object with the correct data
         - user the UserService to share the request
         - clean DB
        """
        json = {
            "firstname": "Vincenzo",
            "lastname": "Palazzo",
            "password": "******",
            "phone": "345432234",
            "dateofbirth": "1996-12-12",
            "email": "*****@*****.**",
        }
        user = UserService.create_user(db, json, 2)
        assert user is not None
        assert user.role_id is not 3
        assert user.role_id is 2

        user = UserService.user_is_present(db, phone=json["phone"])
        assert user is not None

        Utils.del_user_on_db_with_id(db, user.id)
Exemplo n.º 2
0
    def test_unmark_user_as_covid_positive(self, db):
        """
        This function test try to discover fault inside the
        mark postivive function inside the USerServices

        Flow tests is:
        - Create a new User
        - Mark this user as positive
        - check if the user if positive on the table
        - clean db (remove the user and the positive)
        """
        json = Utils.get_json_about_new_user()
        user = UserService.create_user(db, json)
        assert user is not None
        assert user.role_id is 3

        success_mark = UserService.mark_user_as_positive(
            db, json["email"], json["phone"])
        assert success_mark is True

        success_unmark = UserService.unmark_user_as_not_positive(db, user.id)
        assert success_unmark is True

        Utils.del_user_on_db_with_id(db, user.id)
        user = Utils.del_user_on_db_with_id(db, user.id)
        assert user is None
Exemplo n.º 3
0
    def post(self):
        user_schema_register = UserRegistrationSchema()
        user_json = request.get_json()
        try:
            user = user_schema_register.load(user_json)
        except ValidationError as e:
            return e.messages

        if UserService.get_by_username(user["username"]):
            return {"message": USER_ALREADY_EXISTS}, 400

        if UserService.get_by_email(user["email"]):
            return {"message": EMAIL_ALREADY_EXISTS}, 400

        try:
            user = UserService.create(
                user["username"],
                user["email"],
                user["password"],
                user["first_name"],
                user["last_name"],
            )
            user_schema = UserSchema()
            return user_schema.dump(user), 201
        except:  # failed to save user to db
            traceback.print_exc()
            if user:
                user.delete()
            return {"message": FAILED_TO_CREATE}, 500
Exemplo n.º 4
0
    def get(self, nickname):
        service = UserService()
        self.set_header("Content-type", "application/json")

        result, status = service.get_user(nickname)

        self.set_status(int(status))
        self.write(result)
Exemplo n.º 5
0
    def post(self, nickname):
        service = UserService()
        self.set_header("Content-type", "application/json")

        result, status = service.update_user(
            nickname, tornado.escape.json_decode(self.request.body))
        self.set_status(int(status))
        self.write(result)
Exemplo n.º 6
0
def attemptlogin(request):
    uid = extractkeyfromrequest(request, 'u')
    emailid = request.get('e')
    studentid = request.get('s')
    if emailid and studentid:
        userservice = UserService()
        uid = userservice.registersession(emailid, studentid)
    insession = isinsession(uid)
    return (uid, insession)
Exemplo n.º 7
0
def register():
    data = request.get_json()
    user_service = UserService(data)
    user_service.register_user()
    return (jsonify({
        "Token":
        base64.b64encode(
            ("%s:%s" %
             (data["email"], data["password"])).encode()).decode("utf-8")
    }), 201)
Exemplo n.º 8
0
	def get(self, id=None):
		try:
			if id is None:
				(status, data) = UserService().read_all()
				return {'status': status, 'data': data}
			else:
				(status, data) = UserService().read(id)
				return {'status': status,
					'data': data.to_json() if callable(getattr(data, "to_json", None)) else str(data)}

		except Exception as x:
			return {'status': False, 'message': str(x)}
Exemplo n.º 9
0
def create_game(message):
    sid = request.sid
    game = GameService.create(message['game_name'])
    task = TaskService.create(
                      message['task_name'],
                      game['id'],
                    )
    UserService.create(sid, message['user_name'])
    UserTaskService.create_or_update(task['id'],
                                     sid,
                                     0)
    emit('send:game_data', {'game': game['uuid'], 'task': task['id']})
Exemplo n.º 10
0
def add_user():
    pb_user = PBUser()
    pb_user.basic_info.uname = 'kk'
    pb_user.basic_info.nick = 'kk'
    print pb_user

    user = User()
    basic_info = UserBasic()
    basic_info.uname = pb_user.basic_info.uname
    basic_info.nick = pb_user.basic_info.nick

    user.basic_info = basic_info
    userService = UserService()
    userService.save(user)
Exemplo n.º 11
0
async def register(request):
    data = await request.json()

    username, password = data['username'], data['password']

    if UserService.get_user(username=username):
        return utils.json_response({
            "errors": [
                {"username": "******"}
            ]
        })

    user = UserService.add_user(username, password)

    return web.Response(text=utils.create_jwt_token(user.id))
Exemplo n.º 12
0
 def get(self):
     uid, insession = attemptlogin(self.request)
     coursesservice = CoursesService()
     userservice = UserService()
     emailid = userservice.getemailidforsession(uid)
     usercourses = coursesservice.listusercourses(emailid)
     template_values = {}
     header_template_values = buildheadertemplatevalues(insession, uid)
     template_values.update(header_template_values)
     course_template_values = buildmycoursestemplatevalues(
         insession, uid, usercourses)
     template_values.update(course_template_values)
     template = JINJA_ENVIRONMENT.get_template('mycourses.html?s=' +
                                               str(sessionid))
     self.response.write(template.render(template_values))
Exemplo n.º 13
0
    def test_get_user_by_email(self, db):
        """
        This function contains the code to test the
        user service tha allows to retetrive the user having the email
        :param db: database session
        """
        json = Utils.get_json_about_new_user()
        user = UserService.create_user(db, json)
        assert user is not None
        assert user.role_id is 3

        assert UserService.get_user_by_email(db, user.email).id == user.id

        is_delete = UserService.delete_user(db, user.id)
        assert is_delete is True
Exemplo n.º 14
0
	def delete(self, id=None, visit_id=None):
		try:
			if id is None:
				return { 'status': False, 'message': 'User Id is required.' }

			if visit_id is None:
				return { 'status': False, 'message': 'Visit Id is required.' }

			(status, user) = UserService().read(id)
			if status is False:
				return { 'status': False, 'message': 'User Id {} is not valid.'.format(id) }

			(status, visits) = VisitService().read(visit_id)
			if status is True and len(visits) > 0:
				visit = visits[0]

				if visit.get('user_id') == id:
					(status, visit) = VisitService().delete(visit_id)
					return { 'status': status,
							'message': 'Visit has been deleted.' if status else 'An error exists',
							'data': visit.to_json() }
			else:
				return { 'status': False,
						'message': 'Visit Id {} does not correspond with User Id {}'.format(visit_id, id) }

		except Exception as x:
			return {'status': False, 'error': str(x)}
Exemplo n.º 15
0
    def test_user_delete_ok(self, db):
        """
        This function contains the code to test the
        User services about the login, and I will aspect a good result.
        :param db: database session
        """
        json = Utils.get_json_about_new_user()
        user = UserService.create_user(db, json)
        assert user is not None
        assert user.role_id is 3
        user = UserService.user_login(db, user.email, json["password"])
        is_delete = UserService.delete_user(db, user.id)
        assert is_delete is True

        user = Utils.get_user_on_db_with_email(db, user.email)
        assert user is None
Exemplo n.º 16
0
	def prepare(self):
		self.channel_string = ''
		self.server_string = []
		ip = self.get_ip()
		if ip!='192.168.2.70':
			print(ip)
		user_id = self.current_user
		self.start_now = datetime.datetime.now().strftime('%Y-%m-%d 00:00:00')
		if not user_id:
			self.redirect('/login/')	
		self.url = (self.request.uri.split('?')[0])
		self.urls = (caching.get(str(user_id)))
		self.privilege = True
		if self.urls is not None:
			if self.admin_flag is False:
				if self.url not in (list(self.urls.values()) if self.urls else []):
					self.privilege = False
		if self.admin_flag is False:
			user_secontrol_data = yield UserService.GetByUser(int(user_id))
			secontrol = json.loads(user_secontrol_data.get('secontrol','{}'))
			for k,v in secontrol.items():
				if self.channel_string:
					self.channel_string+=',' + k
				else:
					self.channel_string = k
				self.server_string+=v
		self.server_string = ','.join(self.server_string)
Exemplo n.º 17
0
    def test_login_user_ok(self, client, db):
        """
        This function test the perform the  request to login the user
        :param client: flask test client
        :param db: database session
        """
        json_create = {
            "firstname": "Vincenzo",
            "lastname": "Palazzo",
            "password": "******",
            "phone": "100023",
            "dateofbirth": "1996-12-12",
            "email": "*****@*****.**",
        }
        user = UserService.create_user(db, json_create)
        assert user is not None

        json_login = {
            "email": json_create["email"],
            "password": json_create["password"],
        }
        response = Utils.login_user(client, json_login)
        user = Utils.get_user_on_db_with_email(db, json_create["email"])
        assert response.status_code == 200
        assert user.email in response.data.decode("utf-8")

        Utils.del_user_on_db_with_id(db, user.id)
        user = Utils.get_user_on_db_with_email(db, json_create["email"])
        assert user is None
Exemplo n.º 18
0
    def test_modify_user_ok(self, client, db):
        """
        This test method perform the request to modify the user
        :param client: flask test client
        :param db: database session
        """
        json = {
            "firstname": "Bart",
            "lastname": "Simpson",
            "password": "******",
            "phone": "100023",
            "dateofbirth": "1996-12-12",
            "email": "*****@*****.**",
        }
        user = UserService.create_user(db, json)
        assert user is not None

        json["firstname"] = "Homer"
        json["role"] = user.role_id
        json["id"] = user.id

        response = Utils.modify_user(client, json)
        logging.debug(response.data)
        user = Utils.get_user_on_db_with_email(db, json["email"])
        assert response.status_code == 200
        assert "Homer" in response.data.decode("utf-8")
        assert "Bart" not in response.data.decode("utf-8")

        Utils.del_user_on_db_with_id(db, user.id)
        user = Utils.get_user_on_db_with_email(db, json["email"])
        assert user is None
Exemplo n.º 19
0
    def test_delete_user_ok(self, client, db):
        """
        This test method perform the request to modify the user
        :param client: flask test client
        :param db: database session
        """
        json = {
            "firstname": "Bart",
            "lastname": "Simpson",
            "password": "******",
            "phone": "100023",
            "dateofbirth": "1996-12-12",
            "email": "*****@*****.**",
        }
        user = UserService.create_user(db, json)
        assert user is not None

        json_login = {
            "email": json["email"],
            "password": json["password"],
        }
        response = Utils.login_user(client, json_login)

        response = Utils.delete_user(client, user.id)
        assert response.status_code == 200
        assert "OK" in response.data.decode("utf-8")

        user = Utils.get_user_on_db_with_email(db, json["email"])
        assert user is None
Exemplo n.º 20
0
def add_user():

    uid = request.args.get('uid')
    uname = request.args.get('uname')
    nick = request.args.get('nick')

    user = User()
    basic_info = UserBasic()
    basic_info.uid = uid
    basic_info.uname = uname
    basic_info.nick = nick
    user.basic_info = basic_info

    userService = UserService()
    userService.save(user)
    return ''
Exemplo n.º 21
0
	def post(self, id=None):
		try:
			state = request.form.get('state')
			city  = request.form.get('city')

			if id is None or state is None or city is None:
				return { 'status': False, 'message': 'User id, State and City are required.' }

			if id is not None:
				(status, user) = UserService().read(id)

				if status is False or user is None:
					return { 'status': False, 'message': 'User id [{}] is not valid'.format(id) }

			if state is not None:
				(status, state) = StateService().read(None, state)

				if status is False or state is None:
					return { 'status': False, 'message': 'State provided [{}] is not valid'.format(state) }

			if city is not None:
				(status, city) = CityService().read(None, city)

				if status is False or city is None:
					return { 'status': False, 'message': 'City provided [{}] is not valid'.format(city) }

			(status, visit) = VisitService().create(user.id, state.id, city.id)
			return { 'status': status,
					'message': 'Visit has been added.' if status else 'An error exists',
					'data': visit.to_json()}

		except Exception as x:
			return {'status': False, 'message': str(x)}
Exemplo n.º 22
0
    async def __run_gain(self):

        if len(self.args) not in [2]:
            await self.reply([
                "Incorrect number of arguments!!!",
                self.__class__.gain_help()
            ])
            return

        if not represents_int(self.args[1]) or int(self.args[1]) > 50 or int(
                self.args[1]) <= 0:
            await self.reply([
                f"**{self.args[1]}** must be whole positive number and be less or equal 50!"
            ])
            return

        sorted_users = UserService.order_by_current_gain(int(self.args[1]))

        msg = ["```asciidoc"]
        msg.append(" = Place = | = Gain = | = Investor =")
        for i, (position, value, user) in enumerate(sorted_users):
            msg.append("{:3d}.       |{:9.2f} | {:s}".format(
                position, value, user.short_name()))
        msg.append("```")

        await self.reply(msg)
        return
Exemplo n.º 23
0
    def test_get_user_by_id(self, client, db):
        """
        Test flow:
        - Create User
        - Get user by id
        - check user
        - clean db
        :param client: flask test client
        :param db: db session
        """
        json_create = {
            "firstname": "Vincenzo",
            "lastname": "Palazzo",
            "password": "******",
            "phone": "100023",
            "dateofbirth": "1996-12-12",
            "email": "*****@*****.**",
        }
        user = UserService.create_user(db, json_create)
        assert user is not None

        response = Utils.get_user_by_id(client, user.id)
        assert response.status_code == 200
        json = response.data.decode("utf-8")
        assert user.firstname in json
        assert user.phone in json
        assert user.email in json
        assert str(user.role_id) in json

        Utils.del_user_on_db_with_id(db, user.id)
        user = Utils.get_user_on_db_with_email(db, json_create["email"])
        assert user is None
Exemplo n.º 24
0
    def on_join_jap(self, data: dict):
        """Call on message JOIN_JAP.

        Emit USER_JOINED_JAP in the room 'jap_event/jap_id'. and USER_JOINED_TABLE if the user has one

        Args :
            data = {user_id, jap_event_id, ?table_id}
        Emit :
            USER_JOINED_JAP = {
                "jap_event_id": int,
                "new_member": asdict(new_member),
                "members": list(User)
            }
        """
        app.logger.info("JOIN_JAP")
        app.logger.info(request.sid)

        session_id = request.sid
        user_id = data["user_id"]
        jap_event_id = data["jap_event_id"]

        self.session_id_user_id[session_id] = {
            "user_id": user_id,
            "jap_event_id": jap_event_id,
        }

        jap_event = JapEventService.get_jap_event(jap_event_id)

        table = TableService.get_user_table(user_id, jap_event_id)

        new_member = UserService.get_user(user_id)
        new_member_dict = asdict(new_member)
        room = self.__get_jap_event_room(data["jap_event_id"])

        if (room not in self.connected_by_jap_event
                or new_member_dict not in self.connected_by_jap_event[room]):
            join_room(room)
            self.__add_to_event(new_member, room)
            emit(
                socket_messages["USER_JOINED_JAP"],
                {
                    "jap_event_id": data["jap_event_id"],
                    "new_member": new_member_dict,
                    "members": self.connected_by_jap_event[room],
                },
                room=room,
            )
            if table:
                self.on_join_table({
                    "user_id": user_id,
                    "jap_event_id": jap_event_id,
                    "table_id": table.id,
                })
            else:
                # checkt that the user is not a jap creator, otherwise it must have a table.
                if jap_event.creator_id == user_id:
                    raise (Exception(
                        "Error at jap creation for jap creator, not added to a table"
                    ))
Exemplo n.º 25
0
    def register(username):
        """Register a new user, with his username.

        Args :
            username: string
        """
        user = UserService.create_user(username, username, username, None)
        return user
Exemplo n.º 26
0
    def test_report_positive_after_one(self, db):
        json = Utils.get_json_about_new_user()
        user = UserService.create_user(db, json)
        assert user is not None
        assert user.role_id is 3
        success_mark = UserService.mark_user_as_positive(
            db, json["email"], json["phone"])
        assert success_mark is True

        users = UserService.report_positive(db)
        assert len(users) == 1

        success_unmark = UserService.unmark_user_as_not_positive(db, user.id)
        assert success_unmark is True
        Utils.del_user_on_db_with_id(db, user.id)
        user = Utils.del_user_on_db_with_id(db, user.id)
        assert user is None
Exemplo n.º 27
0
def sendSignUpInfo(packet):
    minersInfo = usr.checkOnlineMiners()
    skt = socket.socket()
    for i in minersInfo:
        host = i[1]
        port = i[2]
        skt.connect((host, port))
        skt.send(packet)
    skt.close()
Exemplo n.º 28
0
 def create_user_on_db(db_session, ran: int = randrange(100000)):
     json = {
         "firstname": "User_{}".format(ran),
         "lastname": "user_{}".format(ran),
         "password": "******".format(ran),
         "phone": "1234562344{}".format(ran),
         "dateofbirth": "12/12/2000",
         "email": "alibaba{}@alibaba.com".format(str(ran)),
     }
     return UserService.create_user(db_session, json)
Exemplo n.º 29
0
def startClient(packet):
    freeMiners = usr.checkOnlineMiners()
    miners = []
    for i in freeMiners:
        miners.append([i[1],i[2]])
    skt = socket.socket()
    for j in miners:
        skt.connect((j[0],j[1]))
        skt.send(packet)
    skt.close()
Exemplo n.º 30
0
    def login(username):
        """Log a user in, using his username.

        Args :
            username: string
        """
        user = UserService.get_user_by_name(username)
        if not user:
            return AuthService.register(username)
        return user
Exemplo n.º 31
0
    def test_user_login_ko(self, db):
        """
        This function contains the code to test the
        User services about the login, and I will aspect a good result.
        :param db: database session
        """
        json = Utils.get_json_about_new_user()

        user = UserService.user_login(db, json["email"], json["password"])
        assert user is None
Exemplo n.º 32
0
def getServices(body, userId):
    userService = UserService(userServiceApi+"?format=json&agencyId="+agencyId+"&userId="+str(userId))
    
    print(" [x] Loading user service "+userServiceApi+"?format=json&agencyId="+agencyId+"&userId="+str(userId))
    box = BlackBox(serviceApi, userService)
    services = box.getWidgets(body)
    for service in services:
        service["AgencyID"] = agencyId
    result = json.dumps(services)
    return result
Exemplo n.º 33
0
def count_user():
    userService = UserService()
    users = userService.find()
    count = users.count()
    return str(count)
Exemplo n.º 34
0
def list_user():
    userService = UserService()
    users = userService.find()
    return ""
Exemplo n.º 35
0
def count_user():
    userService = UserService()
    count = userService.count()
    resp = Response(str(count), status=200, mimetype='application/json')
    return resp
Exemplo n.º 36
0
def list_user():
    userService = UserService()
    users = userService.find()
    resp = Response(users, status=200, mimetype='application/json')
    return resp
Exemplo n.º 37
0
 def setUp(self):
     self.db = connect_db(':memory:')
     init_db(self.db)
     self.s = UserService(self.db,
                          SecureHashService('salt', 'sha256'))
Exemplo n.º 38
0
class UserServiceTests(unittest.TestCase):
    
    def setUp(self):
        self.db = connect_db(':memory:')
        init_db(self.db)
        self.s = UserService(self.db,
                             SecureHashService('salt', 'sha256'))
        
    def tearDown(self):
        self.db.close()
    
    
    def test_signup_success(self):
        #given
        user = '******'
        self.assertEqual(self.s.user_exists(user), False)
        
        #when
        self.s.signup(user, 'any')
        
        #then
        self.assertEqual(self.s.user_exists(user), True)
        
    def test_signup_failed(self):
        #given
        user = '******'
        self.s.signup(user, 'any')
        
        #expect
        with self.assertRaises(Exception):
            self.s.signup(user, 'any')
        
    def test_check_credential_matched(self):
        #given
        user, password = ('teohm', 'password')
        self.s.signup(user, password)
        
        #expect
        self.assertEqual(self.s.check_credential(user, password), True)
        
    def test_check_credential_not_matched(self):
        #given
        user, password = ('teohm', 'password')
        wrong_password = '******'
        self.s.signup(user, password)
        
        #expect
        self.assertEqual(self.s.check_credential(user, wrong_password), False)