def GetBranchOfficeAssociateList(self, request, context):

        user_identity = Users.get_identity_resource({
            "email": request.uuid,
            "visible": True
        })

        if not user_identity:
            yield make_pb({}, GetBranchOfficeAssociateListResponse)

        if user_identity.branch_office_uuid:

            branch_office_identity = BranchOffice.get_identity_resource(
                {"uuid": user_identity.branch_office_uuid})

        if not branch_office_identity:
            yield make_pb({}, GetBranchOfficeAssociateListResponse)

        branch_office_identity = BranchOfficeSchema(
            only=["users.email"]).dump(branch_office_identity)

        for branch_office_associate_identity in branch_office_identity[
                "users"]:

            yield make_pb(branch_office_associate_identity or {},
                          GetBranchOfficeAssociateListResponse)
    def DeleteUser(self, request, context):

        try:

            filter_dict = dict()
            filter_dict["uuid"] = request.uuid

            user_identity = Users.get_identity_resource(filter_dict)

            if not user_identity:
                return DeleteUserIdentityResponse(uuid=user_identity)

            old_role = user_identity.role

            loop = asyncio.new_event_loop()
            loop.run_until_complete(
                delete_user_role(filter_dict["uuid"], old_role))

            user_identity.disable()

        except Exception as e:
            warning(e)
            raise e

        return DeleteUserIdentityResponse(uuid=user_identity.uuid)
    def CreateUser(self, request, context):

        try:
            user_dict = dict()
            user_dict["uuid"] = request.uuid
            user_dict["first_name"] = request.first_name
            user_dict["last_name"] = request.last_name
            user_dict["email"] = request.email
            user_dict["role"] = request.role or "associate"

            if request.branch_office_uuid:
                user_dict["branch_office"] = dict()
                user_dict["branch_office"]["uuid"] = request.branch_office_uuid

                branch_office_identity = BranchOffice.get_identity_resource({
                    "uuid":
                    request.branch_office_uuid,
                    "visible":
                    True
                })

                if not branch_office_identity:
                    return make_pb({}, CreateUserIdentityResponse)

            user_identity = Users.get_identity_resource({
                "uuid": request.uuid,
                "visible": False
            })
            if user_identity:

                user_identity.first_name = request.first_name
                user_identity.last_name = request.last_name
                user_identity.email = request.email
                user_identity.role = request.role or "associate"
                user_identity.branch_office_uuid = request.branch_office_uuid

                user_identity.updated_at = datetime.datetime.now()
                user_identity.visible = True

                user_identity.save()
            else:

                user_identity = UserSchema().load(user_dict)
                user_identity.save()

        except Exception as e:
            warning(e)
            raise e

        try:
            loop = asyncio.new_event_loop()
            loop.run_until_complete(
                add_user_role(user_identity.uuid, user_identity.role))
        except Exception as e:
            warning(e)
            raise e
        return CreateUserIdentityResponse(uuid=user_identity.uuid)
    def GetUserByUUID(self, request, context):

        user_identity = Users.get_identity_resource({
            "uuid": request.uuid,
            "visible": True
        })

        user_identity = UserSchema().dump(user_identity)
        return make_pb(user_identity or {}, GetUserIdentityByUUIDResponse)
    def UpdateUser(self, request, context):

        try:

            user_identity = Users.get_identity_resource({
                "uuid": request.uuid,
                "visible": True
            })

            if not user_identity:
                return make_pb({}, UpdateUserIdentityResponse)

            if request.branch_office_uuid:

                branch_office_identity = BranchOffice.get_identity_resource({
                    "uuid":
                    request.branch_office_uuid,
                    "visible":
                    True
                })

                if not branch_office_identity:
                    return make_pb({}, UpdateUserIdentityResponse)

            old_role = user_identity.role

            if old_role != request.role:

                loop = asyncio.new_event_loop()
                loop.run_until_complete(
                    delete_user_role(request.uuid, old_role))

            user_identity.first_name = request.first_name
            user_identity.last_name = request.last_name
            user_identity.role = request.role or "associate"
            user_identity.branch_office_uuid = request.branch_office_uuid
            user_identity.updated_at = datetime.datetime.now()

            user_identity.save()

            if old_role != request.role:
                loop.run_until_complete(
                    add_user_role(request.uuid, request.role))

        except Exception as e:
            warning(e)
            raise e

        return UpdateUserIdentityResponse(uuid=user_identity.uuid)