Beispiel #1
0
def list(uid=None):
    result = []

    if uid:
        u = User.query.get(uid)
        if u is not None:
            user_data = {
                'id': u.id,
                'email': u.email,
                'active': u.active,
                'role': get_detailed_roles(u.roles)
            }
            result.append(user_data)
    else:
        users = User.query.all()
        for u in users:
            result.append({
                'id': u.id,
                'email': u.email,
                'active': u.active,
                'role': get_detailed_roles(u.roles)
            })
    result = Result(200,
                    "SUCCESS",
                    "SUCCESS",
                    extra_fields={"results": result})
    return result.http_response()
Beispiel #2
0
def api_login():
    data = request.json
    if 'email' not in data or 'password' not in data:
        result = InvalidParameterResult(
            errors=["Both email and password are required"])
        return result.http_response()
    r = requests.post(request.url_root + "/auth",
                      data=json.dumps({
                          'email': data['email'],
                          'password': data['password']
                      }),
                      headers={'content-type': 'application/json'})

    response = r.json()
    if response['meta']['code'] == 200:
        extra_fiends = {
            'authentication_token':
            response['response']['user']['authentication_token']
        }
        result = Result(200, "SUCCESS", "SUCCESS", extra_fields=extra_fiends)
    else:
        result = Result(response['meta']['code'],
                        "FAILED",
                        "FAILED",
                        extra_fields=response['response'])
    return result.http_response()
Beispiel #3
0
def role(rid):
    """

    Args:
      rid: Role id

    Returns: List of pgAdmin4 users roles or single role if rid is provided.

    """
    result = []
    if rid:
        r = Role.query.get(rid)
        if r is not None:
            result.append({'id': r.id, 'name': r.name})
    else:
        roles = Role.query.all()

        for r in roles:
            result.append({'id': r.id, 'name': r.name})

    result = Result(200,
                    "SUCCESS",
                    "SUCCESS",
                    extra_fields={"results": result})
    return result.http_response()
Beispiel #4
0
def update(uid):
    """

    Args:
      uid:

    Returns:

    """

    usr = User.query.get(uid)

    if not usr:
        return NotFoundResult(message="User with id {0} is not found".format(
            uid)).http_response()

    data = request.form if request.form else json.loads(request.data,
                                                        encoding='utf-8')

    try:
        new_data = validate_user(data)

        if 'roles' in new_data:
            roles_obj = []
            for r in new_data['roles']:
                roles_obj.append(Role.query.get(r))
            new_data['roles'] = roles_obj

    except Exception as e:
        return InvalidParameterResult(errors=[str(e)]).http_response()

    try:
        for k, v in new_data.items():
            setattr(usr, k, v)

        db.session.commit()

        res = {
            'id': usr.id,
            'email': usr.email,
            'active': usr.active,
            'role': get_detailed_roles(usr.roles)
        }

        result = Result(200,
                        "SUCCESS",
                        "SUCCESS",
                        extra_fields={"results": [res]})
        return result.http_response()

    except Exception as e:
        return ServerErrorResult(message=str(e)).http_response()
Beispiel #5
0
def create():
    """

    Returns:

    """
    data = request.form if request.form else json.loads(request.data,
                                                        encoding='utf-8')
    for f in ('email', 'role', 'active', 'newPassword', 'confirmPassword'):
        if f in data and data[f] != '':
            continue
        else:
            return InvalidParameterResult(
                errors=["Missing field: '{0}'".format(f)]).http_response()

    try:
        new_data = validate_user(data)
        if 'roles' in new_data:
            roles_obj = []
            for r in new_data['roles']:
                roles_obj.append(Role.query.get(r))
            new_data['roles'] = roles_obj

    except Exception as e:
        return InvalidParameterResult(errors=[str(e)]).http_response()

    try:
        usr = User(email=new_data['email'],
                   roles=new_data['roles'],
                   active=new_data['active'],
                   password=new_data['password'])
        db.session.add(usr)
        db.session.commit()
        # Add default server group for new user.
        server_group = ServerGroup(user_id=usr.id, name="Servers")
        db.session.add(server_group)
        db.session.commit()
    except Exception as e:
        return ServerErrorResult(message=str(e)).http_response()

    res = {
        'id': usr.id,
        'email': usr.email,
        'active': usr.active,
        'role': get_detailed_roles(usr.roles)
    }

    result = Result(200, "SUCCESS", "SUCCESS", extra_fields={"results": [res]})
    return result.http_response()
Beispiel #6
0
 def get(self, cmd):
     pg_response = pgc.get_data('instances '+cmd)
     if len(pg_response) == 0:
         return ServerErrorResult().http_response()
     if pg_response[0]['state'] != 'completed':
         return ServerErrorResult(state=pg_response[0]['state'],message=pg_response[0].get('msg')).http_response()
     extra_fields = pg_response[0]['data']
     return Result(200,pg_response[0]['state'],'SUCCESS',extra_fields={"data":extra_fields}).http_response(pretty=1)
Beispiel #7
0
 def get(self):
     pg_response = pgc.get_cmd_data('credentials --list')
     return Result(200,
                   'SUCCESS',
                   'SUCCESS',
                   extra_fields={
                       "data": pg_response
                   }).http_response()
Beispiel #8
0
 def put(self):
     json_dict = {}
     args = request.json.get('params')
     pgcCmd = self.constructCmd(args, method_type="UPDATE")
     data = pgc.get_cmd_data(pgcCmd)
     if len(data) == 0:
         return ServerErrorResult().http_response()
     if data[0]['state'] != 'info' or data[0]['state'] == 'completed':
         return ServerErrorResult(
             state=data[0]['state'],
             message=data[0].get('msg')).http_response()
     return Result(200, data[0]['state'], data[0]['msg']).http_response()
Beispiel #9
0
 def post(self):
     result = {}
     args = request.json
     if not validate_backup_fields(args):
         return InvalidParameterResult().http_response()
     try:
         from BackupRestore import BackupRestore
         backuprestore = BackupRestore()
         ctime = get_current_time(format='%y%m%d%H%M%S%f')
         import util
         if args['host'] in ['localhost', '127.0.0.1']:
             args['host'] = util.get_host_ip()
         result = backuprestore.backup_restore(ctime,
                                               'restore',
                                               args['host'],
                                               args['port'],
                                               args['username'],
                                               args['dbName'],
                                               args['sshServer'],
                                               args['backupDirectory'],
                                               args['fileName'],
                                               args['format'],
                                               args.get('advOptions', ""),
                                               password=args.get(
                                                   'password', None))
         process_log_dir = result['log_dir']
         process_status = get_process_status(process_log_dir)
         result['pid'] = process_status.get('pid')
         result['exit_code'] = process_status.get('exit_code')
         result['process_log_id'] = result["process_log_id"]
         if process_status.get('exit_code') is None:
             result['in_progress'] = True
             try:
                 j = Process(pid=int(result["process_log_id"]),
                             command=result['cmd'],
                             logdir=result["log_dir"],
                             desc=dumps(str(args['action'])),
                             user_id=current_user.id,
                             acknowledge='pgDevOps')
                 db_session.add(j)
                 db_session.commit()
             except Exception as e:
                 print str(e)
                 pass
         if result['error']:
             response = Result(500,
                               "error",
                               result['error'],
                               extra_fields={'data': result})
         else:
             response = Result(200,
                               "Success",
                               "Success",
                               extra_fields={'data': result})
     except Exception as e:
         import traceback
         response = ServerErrorResult(message=str(e))
     time.sleep(1)
     return response.http_response()
Beispiel #10
0
 def delete(self, uuids):
     json_dict = {}
     result = {}
     for cred_uuid in uuids.split(','):
         pgcCmd = "credentials DELETE "
         if cred_uuid:
             pgcCmd = pgcCmd + " --cred_uuid \"" + cred_uuid + "\""
             data = pgc.get_cmd_data(pgcCmd)
     if len(data) == 0:
         return ServerErrorResult().http_response()
     if data[0]['state'] != 'info' or data[0]['state'] == 'completed':
         return ServerErrorResult(
             state=data[0]['state'],
             message=data[0].get('msg')).http_response()
     return Result(200, data[0]['state'], data[0]['msg']).http_response()
Beispiel #11
0
 def post(self):
     try:
         json_body = request.json
         pgcCmd = "create " + json_body.get(
             "type") + " --cloud " + json_body.get("cloud")
         pgcCmd = pgcCmd + " --params '" + str(
             json.dumps(json_body.get("params"))) + "'"
         data = pgc.get_cmd_data(pgcCmd)
         if len(data) == 0:
             return ServerErrorResult().http_response()
         if data[0]['state'] != 'complete':
             return ServerErrorResult(
                 state=data[0]['state'],
                 message=data[0].get('msg')).http_response()
         return Result(200, 'SUCCESS',
                       message=data[0].get('msg')).http_response()
     except Exception as ex:
         return ServerErrorResult(message=str(ex)).http_response()
Beispiel #12
0
    def post(self):
        payload = request.get_json()['params']
        if not set(("cloud_type", "credentials")).issubset(payload):
            return InvalidParameterResult(
                errors=["Both cloud_type and credentials are required"
                        ]).http_response()
        if payload["cloud_type"] not in ('aws', 'azure', 'vmware'):
            return InvalidParameterResult(
                errors=["Possible values for cloud_type are aws/azure/vmware"
                        ]).http_response()

        pgcCmd = "test-cred --cloud=" + payload["cloud_type"]
        pgcCmd = pgcCmd + " --credentials \'" + json.dumps(
            payload["credentials"]) + "\'"
        data = pgc.get_cmd_data(pgcCmd)
        if len(data) == 0:
            return ServerErrorResult().http_response()
        if data[0]['state'] != 'info' or data[0]['state'] == 'completed':
            return ServerErrorResult(
                state=data[0]['state'],
                message=data[0].get('msg')).http_response()
        return Result(200, data[0]['state'], data[0]['msg']).http_response()
Beispiel #13
0
def delete(uid):
    """

    Args:
      uid:

    Returns:

    """
    usr = User.query.get(uid)

    if not usr:
        return NotFoundResult(
            message="User with id {0} is not found".format(uid))

    try:

        Setting.query.filter_by(user_id=uid).delete()

        UserPreference.query.filter_by(uid=uid).delete()

        Server.query.filter_by(user_id=uid).delete()

        ServerGroup.query.filter_by(user_id=uid).delete()

        Process.query.filter_by(user_id=uid).delete()

        # Finally delete user
        db.session.delete(usr)

        db.session.commit()

        return Result(200, "SUCCESS",
                      "User Deleted Successfully").http_response()
    except Exception as e:
        return ServerErrorResult(message=str(e)).http_response()