Example #1
0
    def put(self, user_id=None):
        app.logger.info('Accessing User.put')
        id = ''
        username = ''
        new_password = ''
        confirm_password = ''
        email = ''
        first_name = ''
        last_name = ''
        role_id = ''

        if user_id is not None:
            id = user_id
        elif request.args.get('user_id') is not None:
            id = request.args.get('user_id')

        user = User.query.filter_by(id=user_id).first()

        if user is not None:
            if request_is_json():
                app.logger.info('Updating user based upon JSON Request')
                print json.dumps(request.get_json())
                data = request.get_json()
                for key, value in data.iteritems():
                    print key + '-' + str(value)
                    if key == 'new_password':
                        new_password = value
                    if key == 'confirm_password':
                        confirm_password = value
                    elif key == 'email':
                        email = value
                        username = value
                        user.username = value
                        user.email = value
                    elif key == 'first_name':
                        first_name = value
                        user.first_name = value
                    elif key == 'last_name':
                        last_name = value
                        user.last_name = value
            elif request_is_form_urlencode():
                # TODO: Handle nulls
                app.logger.info('Updating user ' + username)
                requestData = json.loads(request.form['data'])
                user.username = requestData['email']
                user.email = requestData['email']
                user.last_name = requestData['last_name']
                user.first_name = requestData['first_name']
                confirm_password = requestData['confirm_password']
                password = requestData['password']
            else:
                return {"meta": buildMeta(), "error": "Unable to process " + request.accept_mimetypes}

        else:
            return {"meta": buildMeta(), "error": "Could not find user id #" + id, "data": None}

        # TODO: PASSWORD and CONFIRM_PASSWORD comparison

        db_session.commit()
        return {"meta": buildMeta(), "data": "Updated Record with ID " + user_id, "data": None}
Example #2
0
    def delete(self, user_id):
        app.logger.info("Deleting User #: " + user_id)
        user = User.query.filter_by(id=user_id).first()
        db_session.delete(user)
        db_session.commit()

        return {"meta": buildMeta(), "data": None}
    def tearDown(self):
        #Bill.query.filter(models.User.first_name=self.get_default_test_name()).delete()
        for row in User.query.filter_by(first_name=self.get_default_test_name(), last_name=self.get_default_test_name()):
            db_session.delete(row)

        db_session.commit()
        db_session.remove()
        self.logout()
Example #4
0
    def post(self):
        username = None
        password = None
        app.logger.info(request.accept_mimetypes)
        if request_is_json():
            app.logger.info('Attempting to login using JSON')
            data = request.get_json()
            app.logger.info(request.data)
            for key, value in data.iteritems():
                print key + '-' + value
                if key == 'username':
                    username = value
                if key == 'password':
                    password = value
        elif request_is_form_urlencode():
            app.logger.info('Attempting to login using x-www-form-urlencoded')
            requestData = json.loads(request.form['data'])
            username = requestData['email']
            password = requestData['password']
        else:
            return {"meta": buildMeta(), "error": "Unable to process " + request.accept_mimetypes}


        # validate username and password
        if (username is not None and password is not None):
            user = User.query.filter_by(username=username).first()
            if (user is not None and user.verify_password(password)):
                app.logger.info('Login Successful')
                login_user(user)
                session['username'] = username;
                return {"meta": buildMeta(), "data": None}
            elif (config.DEBUG == True and username == config.ADMIN_USERNAME and password == config.ADMIN_PASSWORD):
                app.logger.info('Attempting to login as Root User')
                user = User.query.filter_by(username=username).first()
                if (user is None):
                    app.logger.info('No Admin User Found, Creating')
                    newUser = User(username=config.ADMIN_USERNAME, password=config.ADMIN_PASSWORD,
                                   email=config.ADMIN_EMAIL, first_name='Admin', last_name='Admin')
                    db_session.add(newUser)
                    db_session.commit()
                    login_user(newUser)
                    session['username'] = username;
                else:
                    login_user(user)
                    session['username'] = username;
            else:
                app.logger.info('Username or password incorrect')
                return {"meta": buildMeta(), "error": "Username or password incorrect", "data": None}
        else:
            app.logger.info('Please provide a username and password')
            return {"meta": buildMeta(), "error": "Please provide a username and password", "data": None}

        return {"meta": buildMeta()}
Example #5
0
    def post(self, user_id=None):
        app.logger.info('Accessing User.post')

        username = ''
        password = ''
        confirm_password = ''
        email = ''
        first_name = ''
        last_name = ''
        role_id = ''

        if request_is_json():
            app.logger.info('Creating new user based upon JSON Request')
            print json.dumps(request.get_json())
            data = request.get_json()
            for key, value in data.iteritems():
                print key + '-' + str(value)
                if key == 'password':
                    password = value
                if key == 'confirm_password':
                    confirm_password = value
                elif key == 'email':
                    username = value
                    email = value
                elif key == 'first_name':
                    first_name = value
                elif key == 'last_name':
                    last_name = value
        elif request_is_form_urlencode():
            app.logger.info('Creating new user based upon other Request')
            requestData = json.loads(request.form['data'])
            username = requestData['email']
            email = requestData['email']
            last_name = requestData['last_name']
            first_name = requestData['first_name']
            confirm_password = requestData['confirm_password']
        else:
            return {"meta": buildMeta(), "error": "Unable to process " + request.accept_mimetypes}

        # TODO: PASSWORD and CONFIRM_PASSWORD comparison
        if email is None or password is None:
            return {"meta": buildMeta(), "error": "Email and Password is required", "data": None}

        if User.query.filter_by(username=username).first() is not None:
            return {"meta": buildMeta(), "error": "Username already exists", "data": None}

        newUser = User(username=username, password=password, email=email, first_name=first_name, last_name=last_name)

        db_session.add(newUser)
        db_session.commit()

        return {"meta": buildMeta()}
Example #6
0
    def post(self, feedback_id=None):
        app.logger.info('Accessing Feedback.post')

        user = None
        user_id = None
        rating = None
        feedback = None

        if 'username' in session:
            user = User.query.filter_by(username=session['username']).first()

        if user is None:
            return {"meta": buildMeta(), "error": "No Session Found"}
        else:
            user_id = user.id;

        if request_is_json():
            app.logger.info('Creating new feedback based upon JSON Request')
            print json.dumps(request.get_json())
            data = request.get_json()
            if data is not None:
                for key, value in data.iteritems():
                    print key + '-' + str(value)
                    if key == 'rating':
                        rating = value
                    if key == 'feedback':
                        feedback = value
        elif request_is_form_urlencode():
            app.logger.info('Creating new user based upon other Request')
            requestData = json.loads(request.form['data'])
            rating = requestData['rating']
            feedback = requestData['feedback']
        else:
            return {"meta": buildMeta(), "error": "Unable to process " + request.accept_mimetypes}

        if rating is not None and feedback is not None:
            newFeedback = Feedback(user_id=user_id, rating=int(rating), feedback=feedback)

            db_session.add(newFeedback)
            db_session.commit()

            html_message = "<p>Rating: " + str(rating) + "</p><p>Feedback: " + feedback + "</p>"
            text_message = "Rating: " + str(rating) + "\r\nFeedback: " + feedback

            send_email('New Feedback',
                       ['"Robert Donovan" <*****@*****.**>', '"David Larrimore" <*****@*****.**'],
                       text_message, html_message)

            return {"meta": buildMeta(), 'data': newFeedback.serialize}, 201
        else:
            return {"meta": buildMeta(), 'error': 'No feedback was provided'}, 201
Example #7
0
    def delete(self, bill_id):

        if 'username' in session:
            user = User.query.filter_by(username=session['username']).first()
        if user is None:
            return {"meta": buildMeta(), "error": "No Session Found"}

        app.logger.info("Deleting Bill #: " + bill_id)
        bill = Bill.query.filter_by(id=bill_id, user_id=user.id).first()
        if bill is not None:
            db_session.delete(bill)
            db_session.commit()
            return {"meta": buildMeta(), "data": None}
        else:
            return {"meta": buildMeta(), "error": "Bill #" + bill_id + " Could not be found", "data": None}
    def createNewUser(self, **kwargs):
        password = kwargs.get('new_password')
        email = kwargs.get('email')
        next_pay_date = kwargs.get('next_pay_date')
        pay_recurrance_flag = kwargs.get('pay_recurrance_flag')
        confirmed_at = kwargs.get('confirmed_at')
        active = kwargs.get('active')

        if email is None:
            email = testUtils.random_email_generator()

        if password is None:
            password = testUtils.random_password_generator()

        if isinstance(next_pay_date, datetime):
            next_pay_date = next_pay_date
        elif next_pay_date is True:
            next_pay_date = self.get_default_test_date()
        elif next_pay_date is False:
            next_pay_date = None
        else:
            next_pay_date = self.get_default_test_date()

        if pay_recurrance_flag is None:
            pay_recurrance_flag = "B"

        if isinstance(confirmed_at, datetime):
            confirmed_at = confirmed_at
        elif confirmed_at is True:
            confirmed_at = self.get_default_test_date()
        elif confirmed_at is False:
            confirmed_at = None
        else:
            confirmed_at = None

        newUser = User(username=email, password=password, email=email, first_name=self.get_default_test_name(), last_name=self.get_default_test_name(), next_pay_date=next_pay_date, pay_recurrance_flag = pay_recurrance_flag,  confirmed_at=confirmed_at, active=active)
        db_session.add(newUser)
        db_session.commit()
        return newUser
Example #9
0
    def post(self, bill_id=None):
        app.logger.info('Accessing Bill.post')

        user = None

        user_id = None
        payee_id = None
        name = None
        description = None
        due_date = None
        billing_period = None
        total_due = None
        paid_flag = None
        paid_date = None
        check_number = None
        payment_type = None

        if 'username' in session:
            user = User.query.filter_by(username=session['username']).first()

        if user is None:
            return {"meta": buildMeta(), "error": "No Session Found"}

        if request_is_json():
            app.logger.info('Creating new user based upon JSON Request')
            print json.dumps(request.get_json())
            data = request.get_json()
            for key, value in data.iteritems():
                print key + '-' + str(value)
                if key == 'name':
                    name = value
                if key == 'description':
                    description = value
                elif key == 'due_date':
                    due_date = value
                elif key == 'billing_period':
                    billing_period = value
                elif key == 'total_due':
                    total_due = value
                elif key == 'paid_flag':
                    paid_flag = value
                elif key == 'paid_date':
                    paid_date = value
                elif key == 'check_number':
                    check_number = value
                elif key == 'payment_type':
                    payment_type = value
        elif request_is_form_urlencode():
            app.logger.info('Creating new user based upon other Request')
            requestData = json.loads(request.form['data'])
            name = requestData['name']
            description = requestData['description']
            due_date = requestData['due_date']
            billing_period = requestData['billing_period']
            total_due = requestData['total_due']
            paid_flag = requestData['paid_flag']
            paid_date = requestData['paid_date']
            check_number = requestData['check_number']
            payment_type = requestData['payment_type']
        else:
            return {"meta": buildMeta(), "error": "Unable to process " + request.accept_mimetypes}

        if Bill.query.filter_by(name=name, user_id=user_id).first() is not None:
            return {"meta": buildMeta(), "error": "Bill already exists"}

        newBill = Bill(user_id=user.id, name=name, description=description, due_date=due_date,
                       billing_period=billing_period, total_due=total_due, paid_flag=paid_flag, paid_date=paid_date,
                       payment_type=payment_type, check_number=check_number)

        db_session.add(newBill)
        db_session.commit()

        return {"meta": buildMeta(), 'data': newBill.serialize}, 201
Example #10
0
    def put(self, bill_id=None):
        app.logger.info('Accessing Bill.put')

        # TODO: Handle update
        user_id = None
        payee_id = None
        name = None
        description = None
        due_date = None
        billing_period = None
        total_due = None
        paid_flag = None
        paid_date = None
        check_number = None
        payment_type = None

        user = None

        if 'username' in session:
            user = User.query.filter_by(username=session['username']).first()
        if user is None:
            return {"meta": buildMeta(), "error": "No Session Found"}

        if bill_id is not None:
            id = bill_id
        elif request.args.get('user_id') is not None:
            id = request.args.get('user_id')

        bill = Bill.query.filter_by(id=bill_id).first()
        bill.user_id = user.id

        if bill is not None:
            if request_is_json():
                app.logger.info('Updating bill based upon JSON Request')
                print json.dumps(request.get_json())
                data = request.get_json()
                if data:
                    for key, value in data.iteritems():
                        # print key+'-'+str(value)
                        if key == 'name':
                            name = value
                        if key == 'description':
                            description = value
                        elif key == 'due_date':
                            due_date = value
                        elif key == 'billing_period':
                            billing_period = value
                        elif key == 'total_due':
                            total_due = value
                        elif key == 'paid_flag':
                            paid_flag = value
                        elif key == 'paid_date':
                            paid_date = value
                        elif key == 'check_number':
                            check_number = value
                        elif key == 'payment_type':
                            payment_type = value
            elif request_is_form_urlencode():
                app.logger.info('Updating bill #' + bill_id)
                requestData = json.loads(request.form['data'])

                name = requestData['name']
                description = requestData['description']
                due_date = requestData['due_date']
                billing_period = requestData['billing_period']
                total_due = requestData['total_due']
                paid_flag = requestData['paid_flag']
                paid_date = requestData['paid_date']
                check_number = requestData['check_number']
                payment_type = requestData['payment_type']
            else:
                return {"meta": buildMeta(), "error": "Unable to process " + request.accept_mimetypes}
        else:
            return {"meta": buildMeta(), "error": "Could not find bill id #" + id}

        if name:
            bill.name = name
        if description:
            bill.description = description
        if due_date:
            bill.due_date = due_date
        if billing_period:
            bill.billing_period = billing_period
        if total_due:
            bill.total_due = total_due
        if paid_flag:
            bill.paid_flag = paid_flag
        if paid_date:
            bill.paid_date = paid_date
        if check_number:
            bill.check_number = check_number
        if payment_type:
            bill.payment_type = payment_type

        if bill.name is None or bill.name == '' or not bill.name:
            return {"meta": buildMeta(), "error": "Name is required", "data": None}
        else:
            db_session.commit()
            return {"meta": buildMeta(), "data": bill.serialize}, 201
Example #11
0
    def put(self, user_id=None):
        app.logger.info('Accessing User.put')
        id = ''
        username = None
        new_password = None
        current_password = None
        new_password = None
        confirm_new_password = None
        email = None
        first_name = None
        last_name = None

        next_pay_date = None
        pay_recurrance_flag = None

        if user_id is not None:
            id = user_id
        elif request.args.get('user_id') is not None:
            id = request.args.get('user_id')

        user = User.query.filter_by(id=user_id).first()

        if user is not None:
            if request_is_json():
                app.logger.info('Updating user based upon JSON Request')
                print json.dumps(request.get_json())
                data = request.get_json()
                if data:
                    for key, value in data.iteritems():
                        # print key+'-'+str(value)
                        if key == 'new_password':
                            new_password = value
                        elif key == 'current_password':
                            current_password = value
                        elif key == 'confirm_new_password':
                            confirm_new_password = value
                        elif key == 'email':
                            email = value
                            username = value
                        elif key == 'first_name':
                            first_name = value
                        elif key == 'last_name':
                            last_name = value
                        elif key == 'next_pay_date':
                            next_pay_date = value
                        elif key == 'pay_recurrance_flag':
                            pay_recurrance_flag = value
                else:
                    return {"meta": buildMeta(), "error": "No Data Sent", "data": None}
            elif request_is_form_urlencode():
                # TODO: Handle nulls
                app.logger.info('Updating user ' + username)
                requestData = json.loads(request.form['data'])
                username = requestData['email']
                email = requestData['email']
                last_name = requestData['last_name']
                first_name = requestData['first_name']
                confirm_new_password = requestData['confirm_new_password']
                new_password = requestData['new_password']
                current_password = requestData['current_password']
                password = requestData['password']
                next_pay_date = requestData['next_pay_date']
                pay_recurrance_flag = requestData['pay_recurrance_flag']
            else:
                return {"meta": buildMeta(), "error": "Unable to process " + request.accept_mimetypes}

        else:
            return {"meta": buildMeta(), "error": "Could not find user id #" + id, "data": None}

        # TODO: PASSWORD and CONFIRM_PASSWORD comparison
        # TODO: Prevent Username or Email Change without confirmation token!?!



        if first_name:
            user.first_name = first_name;
        if last_name:
            user.last_name = last_name;
        if pay_recurrance_flag:
            user.pay_recurrance_flag = pay_recurrance_flag;
        if next_pay_date:
            user.next_pay_date = next_pay_date;




        # Password Change Logic
        if current_password and new_password and confirm_new_password:
            app.logger.info(
                'Current Password:'******', Proposed Password:' + generate_password_hash(new_password))
            if new_password == confirm_new_password and user.verify_password(
                    current_password) and current_password != new_password:
                app.logger.info("Everything checks out, creating new password")
                user.password = generate_password_hash(new_password)
            elif current_password == new_password:
                app.logger.info("Your new password must be different than your own password")
                return {"meta": buildMeta(), "error": "Your new password must be different than your own password"}
            elif user.verify_password(current_password) == False:
                app.logger.info("Current password does not match our records. Please try again")
                return {"meta": buildMeta(), "error": "Current password does not match our records. Please try again"}
            elif new_password != confirm_new_password:
                return {"meta": buildMeta(), "error": "New passwords do not match"}
            else:
                return {"meta": buildMeta(), "error": "Failed to update Password"}
                # TODO: ADD LOGIC TO MEET PASSWORD COMPLEXITY REQUIREMENTS
        elif new_password and not confirm_new_password:
            return {"meta": buildMeta(),
                    "error": "When changing passwords, both password and confirmation are required"}
        elif confirm_new_password and not new_password:
            return {"meta": buildMeta(),
                    "error": "When changing passwords, both password and confirmation are required"}
        elif current_password and not confirm_new_password or new_password:
            return {"meta": buildMeta(), "error": "New Password not provided, ignoring"}
        elif current_password and not confirm_new_password or new_password:
            return {"meta": buildMeta(), "error": "All required information was not provided to change password"}

        db_session.commit()
        return {"meta": buildMeta(), "data": [user.serialize]}