text:
import unittest

from django.contrib.auth.models import Group, AnonymousUser
from django.core.exceptions import PermissionDenied
from django.test import TestCase, RequestFactory
from rest_framework.exceptions import NotFound

from hs_core.hydroshare import resource
from hs_core.hydroshare import users
from hs_core.testing import MockIRODSTestCaseMixin
from hs_core.views.utils import authorize, ACTION_TO_AUTHORIZE
from hs_access_control.models import PrivilegeCodes

class TestAuthorize(MockIRODSTestCaseMixin, TestCase):

    def setUp(self):
        super(TestAuthorize, self).setUp()
        self.group, _ = Group.objects.get_or_create(name='Hydroshare Author')
        # create a user - resource owner
        self.user = users.create_account(
            'test_user@email.com',
            username='testuser',
            first_name='some_first_name',
            last_name='some_last_name',
            superuser=False,
            groups=[])
        self.res = resource.create_resource(
            'GenericResource',
            self.user,
            'My Test Resource'
            )

        self.request = RequestFactory().request()

    def test_authorize_owner(self):
        common_parameters = [
                      # resource owner has authorization for resource metadata view
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None},
                      # resource owner has authorization for resource view (metadata and content files)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': True, 'exception': None},
                      # resource owner has authorization for creating a new resource version
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.CREATE_RESOURCE_VERSION,
                       'success': True, 'exception': None}
                      ]

        parameters = [
                      # resource owner has authorization for resource edit (metadata and content files)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': True, 'exception': None},
                      # resource owner has authorization for setting resource flags
                      # (public, published/immutable, shareable etc)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': True, 'exception': None},
                      # resource owner has authorization for resource delete
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.DELETE_RESOURCE,
                       'success': True, 'exception': None}
                      ] + common_parameters

        self.request.user = self.user

        # test for private resource
        self.assertFalse(self.res.raccess.public)
        self.assertFalse(self.res.raccess.discoverable)

        self._run_tests(self.request, parameters)

        # test for discoverable resource
        self.assertFalse(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

        # test for public resource
        self.assertTrue(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = False
        self.res.raccess.public = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

        # test for immutable/published resource
        self.assertFalse(self.res.raccess.immutable)
        self.assertFalse(self.res.raccess.published)
        self.assertTrue(self.res.raccess.public)

        self.res.raccess.published = True
        self.res.raccess.immutable = True
        self.res.raccess.save()

        parameters = [
                      # resource owner has authorization for resource edit 4/9/2021 (metadata and content files)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': True, 'exception': None},
                      # resource owner has no authorization for setting resource
                      # flags (public, immutable/published, shareable etc)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': False, 'exception': PermissionDenied},
                      # resource owner has no authorization for deleting a published resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.DELETE_RESOURCE,
                       'success': False, 'exception': PermissionDenied}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

    def test_authorize_editor(self):
        # create edit_user
        edit_user = users.create_account(
                'edit_user@email.com',
                username='edituser',
                first_name='edit_first_name',
                last_name='edit_last_name',
                superuser=False,
                groups=[])

        self.request.user = edit_user

        common_parameters = [
                      # resource editor has authorization for resource view (metadata and content files)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': True, 'exception': None},
                      # resource editor has authorization for resource metadata view
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None},
                      # resource editor has no authorization for changing resource flags
                      # (e.g., public, published/immutable, shareable etc)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': False, 'exception': PermissionDenied},
                      # resource editor has no authorization for deleting a resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.DELETE_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # resource editor has no authorization for creating version of a resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.CREATE_RESOURCE_VERSION,
                       'success': False, 'exception': PermissionDenied}
                      ]

        parameters = [
                      # resource editor has authorization for resource edit (metadata and content files)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': True, 'exception': None}
                      ] + common_parameters

        # grant edit_user edit permission
        self.user.uaccess.share_resource_with_user(self.res, edit_user, PrivilegeCodes.CHANGE)

        # test for private resource
        self.assertFalse(self.res.raccess.public)
        self.assertFalse(self.res.raccess.discoverable)

        self._run_tests(self.request, parameters)

        # test for discoverable resource
        self.assertFalse(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

        # test for public resource
        self.assertTrue(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = False
        self.res.raccess.public = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

        # test for immutable/published resource
        self.assertFalse(self.res.raccess.immutable)
        self.assertFalse(self.res.raccess.published)
        self.assertTrue(self.res.raccess.public)

        self.res.raccess.immutable = True
        self.res.raccess.published = True
        self.res.raccess.save()

        parameters = [
                      # resource editor has no authorization for editing a published resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': False, 'exception': PermissionDenied}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

    def test_authorize_viewer(self):
        # create view_user
        view_user = users.create_account(
            'view_user@email.com',
            username='viewuser',
            first_name='view_first_name',
            last_name='view_last_name',
            superuser=False,
            groups=[])

        self.request.user = view_user

        parameters = [
                      # resource viewer has authorization for resource metadata view
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None},
                      # resource viewer has authorization for resource view (metadata and content files)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': True, 'exception': None},
                      # resource viewer has no authorization for editing a resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # resource viewer has no authorization for changing resource flags
                      # (e.g., public, published/immutable, shareable etc)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': False, 'exception': PermissionDenied},
                      # resource viewer has no authorization for deleting a resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.DELETE_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # resource viewer has no authorization for creating a resource version
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.CREATE_RESOURCE_VERSION,
                       'success': False, 'exception': PermissionDenied}
                      ]

        # grant view_user view permission
        self.user.uaccess.share_resource_with_user(self.res, view_user, PrivilegeCodes.VIEW)

        # test for private resource
        self.assertFalse(self.res.raccess.public)
        self.assertFalse(self.res.raccess.discoverable)

        self._run_tests(self.request, parameters)

        # test for discoverable resource
        self.assertFalse(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

        # test for public resource
        self.assertTrue(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = False
        self.res.raccess.public = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

        # test for immutable/published resource
        self.assertFalse(self.res.raccess.immutable)
        self.assertFalse(self.res.raccess.published)
        self.assertTrue(self.res.raccess.public)

        self.res.raccess.immutable = True
        self.res.raccess.published = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

    def test_authorize_superuser(self):
        # create super user
        super_user = users.create_account(
            'super_user@email.com',
            username='superuser',
            first_name='super_first_name',
            last_name='super_last_name',
            superuser=True,
            groups=[])

        self.request.user = super_user

        common_parameters = [
                      # super user has authorization for resource metadata view for a resource
                      # that is private or discoverable or public or published
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None},
                      # super user has authorization for resource view (both metadata and content files)for a resource
                      # that is private or discoverable or public or published
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': True, 'exception': None},
                      # super user has authorization for editing a resource that is private or discoverable or public
                      # or published
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': True, 'exception': None},
                      # super user has authorization for deleting a resource that is private or discoverable or public
                      # or published
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.DELETE_RESOURCE,
                       'success': True, 'exception': None},
                      # super user has no authorization for creating a resource version
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.CREATE_RESOURCE_VERSION,
                       'success': False, 'exception': PermissionDenied}
                      ]

        parameters = [
                      # super user has authorization for setting resource flags (e.g., public,
                      # published/immutable, shareable etc) for a private, public or discoverable resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': True, 'exception': None},
                      ] + common_parameters

        # test for private resource
        self.assertFalse(self.res.raccess.public)
        self.assertFalse(self.res.raccess.discoverable)

        self._run_tests(self.request, parameters)

        # test for discoverable resource
        self.assertFalse(self.res.raccess.discoverable)
        self.res.raccess.discoverable = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

        # test for public resource
        self.assertTrue(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = False
        self.res.raccess.public = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

        # test for immutable/published resource
        self.assertFalse(self.res.raccess.immutable)
        self.assertFalse(self.res.raccess.published)
        self.assertTrue(self.res.raccess.public)

        self.res.raccess.immutable = True
        self.res.raccess.published = True
        self.res.raccess.save()

        parameters = [
                      # super user has authorization for setting resource flags (e.g., public,
                      # published/immutable, shareable etc) for a published resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': True, 'exception': None},
                      ] + common_parameters

        self._run_tests(self.request, parameters)

    def test_authorize_anonymous_user(self):
        self.request.user = AnonymousUser()
        common_parameters = [
                      # anonymous user has no authorization for resource edit (metadata and content files) for a
                      # private resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # anonymous user has no authorization for deleting a private resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.DELETE_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # anonymous user has no authorization for setting resource flags for a private resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': False, 'exception': PermissionDenied},
                      # anonymous user has no authorization for creating resource version
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.CREATE_RESOURCE_VERSION,
                       'success': False, 'exception': PermissionDenied}
                      ]

        # test for private resource
        self.assertFalse(self.res.raccess.public)
        self.assertFalse(self.res.raccess.discoverable)

        self._run_tests(self.request, common_parameters)

        # test for discoverable resource
        self.res.raccess.discoverable = True
        self.res.raccess.public = False
        self.res.raccess.save()

        parameters = [
                      # anonymous user has authorization for metadata view for a resource that is discoverable
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None},
                      # anonymous user has no authorization for resource view (metadata and content files) for a
                      # resource that is discoverable
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': False, 'exception': PermissionDenied}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

        # test for public resource
        self.assertTrue(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = False
        self.res.raccess.public = True
        self.res.raccess.save()

        parameters = [
                      # anonymous user has authorization for resource view (metadata and content files) for a
                      # resource that is public
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': True, 'exception': None},
                      # anonymous user has authorization for metadata view for a resource that is public
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

        # test for immutable/published resource
        self.assertFalse(self.res.raccess.immutable)
        self.assertFalse(self.res.raccess.published)
        self.assertTrue(self.res.raccess.public)

        self.res.raccess.immutable = True
        self.res.raccess.published = True
        self.res.raccess.save()

        parameters = [
                      # anonymous user has authorization for resource metadata view for a
                      # published resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None},
                      # anonymous user has authorization for resource view (metadata and content files) for a
                      # published resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': True, 'exception': None}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

    def test_authorize_user(self):
        # create user - has no assigned resource access privilege
        authenticated_user = users.create_account(
            'user@email.com',
            username='user',
            first_name='user_first_name',
            last_name='user_last_name',
            superuser=False,
            groups=[])

        self.request.user = authenticated_user

        common_parameters = [
                      # authenticated user (with no assigned access permission) has no authorization for editing a
                      # resource (metadata and content files)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # authenticated user (with no assigned access permission) has no authorization for
                      # setting resource flags
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': False, 'exception': PermissionDenied},
                      # authenticated user (with no assigned access permission) has no authorization for creating a
                      # resource version
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.CREATE_RESOURCE_VERSION,
                       'success': False, 'exception': PermissionDenied},
                      # authenticated user (with no assigned access permission) has no authorization for deleting a
                      # resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.DELETE_RESOURCE,
                       'success': False, 'exception': PermissionDenied}
                      ]

        # test for private resource
        self.assertFalse(self.res.raccess.public)
        self.assertFalse(self.res.raccess.discoverable)

        parameters = [
                      # authenticated user (with no assigned access permission) has no authorization for viewing
                      # metadata of a private resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': False, 'exception': PermissionDenied},
                      # authenticated user (with no assigned access permission) has no authorization for viewing a
                      # private resource (both metadata and content files
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': False, 'exception': PermissionDenied}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

        # test for discoverable resource
        self.res.raccess.discoverable = True
        self.res.raccess.public = False
        self.res.raccess.save()

        parameters = [
                      # authenticated user (with no assigned access permission) has no authorization for resource view
                      # (metadata and content files) for a discoverable resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # authenticated (with no assigned access permission) user has authorization for resource metadata
                      # only view for a discoverable resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

        # test for public resource
        self.assertTrue(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = False
        self.res.raccess.public = True
        self.res.raccess.save()

        parameters = [
                      # authenticated user (with no assigned access permission) has authorization for resource view
                      # (metadata and content files) for a public or published resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': True, 'exception': None},
                      # authenticated user (with no assigned access permission)has authorization for resource metadata
                      # only view for a public or published resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

        # test for immutable/published resource
        self.assertFalse(self.res.raccess.immutable)
        self.assertFalse(self.res.raccess.published)
        self.assertTrue(self.res.raccess.public)
        self.res.raccess.immutable = True
        self.res.raccess.published = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

    def test_authorize_inactive_user(self):
        self.user.is_active = False
        self.user.save()
        self.request.user = self.user

        common_parameters = [
                      # resource inactive owner has no authorization for editing a resource (metadata and content files)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # resource inactive owner has no authorization for setting resource flags
                      # (public, published/immutable, shareable etc)
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': False, 'exception': PermissionDenied},
                      # resource inactive owner has no authorization for creating a resource version
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.CREATE_RESOURCE_VERSION,
                       'success': False, 'exception': PermissionDenied},
                      # resource inactive owner has no authorization for deleting a resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.DELETE_RESOURCE,
                       'success': False, 'exception': PermissionDenied}
                      ]

        # test for private resource
        self.assertFalse(self.res.raccess.public)
        self.assertFalse(self.res.raccess.discoverable)

        parameters = [
                      # resource inactive owner has no authorization for resource view (metadata and content files)
                      # for a resource that is not discoverable
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # resource inactive owner has no authorization for resource metadata view for a resource
                      # that is not discoverable
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': False, 'exception': PermissionDenied}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

        # test for discoverable resource
        self.assertFalse(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = True
        self.res.raccess.save()

        parameters = [
                      # resource inactive owner has no authorization for resource view (metadata and content files)
                      # for a resource that is discoverable
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': False, 'exception': PermissionDenied},
                      # resource inactive owner has authorization for resource metadata view for a resource that is
                      # discoverable
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None}
                      ] + common_parameters

        self._run_tests(self.request, parameters)

        # test for public resource
        self.assertTrue(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = False
        self.res.raccess.public = True
        self.res.raccess.save()

        parameters = [
                      # resource inactive owner has authorization for resource view (metadata and content files) for a
                      # public resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': True, 'exception': None},
                      # resource inactive owner has authorization for resource metadata view for a public resource
                      {'res_id': self.res.short_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': True, 'exception': None}

                      ] + common_parameters

        self._run_tests(self.request, parameters)

        # test for immutable/published resource
        self.assertFalse(self.res.raccess.immutable)
        self.assertFalse(self.res.raccess.published)
        self.assertTrue(self.res.raccess.public)

        self.res.raccess.published = True
        self.res.raccess.immutable = True
        self.res.raccess.save()

        self._run_tests(self.request, parameters)

    def test_exception_notfound(self):
        invalid_res_id = '123x'
        parameters = [
                      {'res_id': invalid_res_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_METADATA,
                       'success': False, 'exception': NotFound},
                      {'res_id': invalid_res_id, 'needed_permission': ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                       'success': False, 'exception': NotFound},
                      {'res_id': invalid_res_id, 'needed_permission': ACTION_TO_AUTHORIZE.EDIT_RESOURCE,
                       'success': False, 'exception': NotFound},
                      {'res_id': invalid_res_id, 'needed_permission': ACTION_TO_AUTHORIZE.SET_RESOURCE_FLAG,
                       'success': False, 'exception': NotFound},
                      {'res_id': invalid_res_id, 'needed_permission': ACTION_TO_AUTHORIZE.CREATE_RESOURCE_VERSION,
                       'success': False, 'exception': NotFound},
                      {'res_id': invalid_res_id, 'needed_permission': ACTION_TO_AUTHORIZE.DELETE_RESOURCE,
                       'success': False, 'exception': NotFound}
                      ]

        self.request.user = self.user
        self._run_tests(self.request, parameters)

    def test_default_parameters(self):
        # default permission is view

        # >> test private resource
        self.assertFalse(self.res.raccess.public)
        # test private link sharing is not enabled
        self.assertFalse(self.res.raccess.allow_private_sharing)

        # test owner
        self.request.user = self.user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test super user
        super_user = users.create_account(
            'super_user@email.com',
            username='superuser',
            first_name='super_first_name',
            last_name='super_last_name',
            superuser=True,
            groups=[])

        self.request.user = super_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test edit user
        edit_user = users.create_account(
                'edit_user@email.com',
                username='edituser',
                first_name='edit_first_name',
                last_name='edit_last_name',
                superuser=False,
                groups=[])

        self.request.user = edit_user
        # grant edit_user edit permission
        self.user.uaccess.share_resource_with_user(self.res, edit_user, PrivilegeCodes.CHANGE)
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test view user
        view_user = users.create_account(
            'view_user@email.com',
            username='viewuser',
            first_name='view_first_name',
            last_name='view_last_name',
            superuser=False,
            groups=[])

        self.request.user = view_user
        # grant view_user view permission
        self.user.uaccess.share_resource_with_user(self.res, view_user, PrivilegeCodes.VIEW)
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test authenticated user with no granted permission
        authenticated_user = users.create_account(
            'user@email.com',
            username='user',
            first_name='user_first_name',
            last_name='user_last_name',
            superuser=False,
            groups=[])

        self.request.user = authenticated_user

        with self.assertRaises(PermissionDenied):
            authorize(self.request, res_id=self.res.short_id)

        # test anonymous user
        self.request.user = AnonymousUser()

        with self.assertRaises(PermissionDenied):
            authorize(self.request, res_id=self.res.short_id)

        # >> test for discoverable resource
        self.assertFalse(self.res.raccess.discoverable)
        self.assertFalse(self.res.raccess.allow_private_sharing)
        self.res.raccess.discoverable = True
        self.res.raccess.public = False
        self.res.raccess.save()

        # test owner
        self.request.user = self.user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test super user
        self.request.user = super_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test edit user
        self.request.user = edit_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test view user
        self.request.user = view_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test authenticated user
        self.request.user = authenticated_user
        with self.assertRaises(PermissionDenied):
            authorize(self.request, res_id=self.res.short_id)

        # test anonymous user
        self.request.user = AnonymousUser()
        with self.assertRaises(PermissionDenied):
            authorize(self.request, res_id=self.res.short_id)

        # >> test for public resource
        self.assertFalse(self.res.raccess.public)
        self.res.raccess.discoverable = False
        self.res.raccess.public = True
        self.res.raccess.save()

        # test owner
        self.request.user = self.user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test super user
        self.request.user = super_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test edit user
        self.request.user = edit_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test view user
        self.request.user = view_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test authenticated user
        self.request.user = authenticated_user
        authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test anonymous user
        self.request.user = AnonymousUser()
        authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # >> test for published resource
        self.assertFalse(self.res.raccess.published)
        self.res.raccess.published = False
        self.res.raccess.immutable = True
        self.res.raccess.save()

        # test owner
        self.request.user = self.user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test super user
        self.request.user = super_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test edit user
        self.request.user = edit_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test view user
        self.request.user = view_user
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test authenticated user
        self.request.user = authenticated_user
        authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

        # test anonymous user
        self.request.user = AnonymousUser()
        authorize(self.request, res_id=self.res.short_id)
        self.assertTrue(authorized)

    def test_raise_no_exception(self):
        # create user - has no assigned resource access privilege
        authenticated_user = users.create_account(
            'user@email.com',
            username='user',
            first_name='user_first_name',
            last_name='user_last_name',
            superuser=False,
            groups=[])

        self.request.user = authenticated_user

        res, authorized, user = authorize(self.request, res_id=self.res.short_id,
                                          needed_permission=ACTION_TO_AUTHORIZE.VIEW_RESOURCE, raises_exception=False)
        self.assertEqual(authorized, False)
        self.assertEqual(res, self.res)
        self.assertEqual(user, authenticated_user)

    def test_authorization_for_private_link_sharing(self):
        """Test that anonymous user is authorized to view resource when private share link enabled"""

        self.request.user = AnonymousUser()
        # check private link sharing is not enabled
        self.assertFalse(self.res.raccess.allow_private_sharing)
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id,
                                     needed_permission=ACTION_TO_AUTHORIZE.VIEW_RESOURCE, raises_exception=False)
        # test anonymous user is not authorized to vew resource
        self.assertFalse(authorized)
        # enable private link sharing
        self.res.raccess.allow_private_sharing = True
        self.res.raccess.save()
        _, authorized, _ = authorize(self.request, res_id=self.res.short_id,
                                     needed_permission=ACTION_TO_AUTHORIZE.VIEW_RESOURCE, raises_exception=False)
        # test anonymous user is authorized to vew resource
        self.assertTrue(authorized)

    def test_return_data(self):
        # test authorization True
        self.request.user = self.user
        res, authorized, user = authorize(self.request, res_id=self.res.short_id,
                                          needed_permission=ACTION_TO_AUTHORIZE.VIEW_RESOURCE)
        self.assertEqual(authorized, True)
        self.assertEqual(res, self.res)
        self.assertEqual(user, self.user)

        # test authorization False
        anonymous_user = AnonymousUser()
        self.request.user = anonymous_user
        res, authorized, user = authorize(self.request, res_id=self.res.short_id,
                                          needed_permission=ACTION_TO_AUTHORIZE.VIEW_RESOURCE,
                                          raises_exception=False)
        self.assertEqual(authorized, False)
        self.assertEqual(res, self.res)
        self.assertEqual(user, anonymous_user)

    def _run_tests(self, request, parameters):
        for params in parameters:
            if params['exception'] is None:
                res, authorized, user = authorize(request, res_id=params['res_id'],
                                                  needed_permission=params['needed_permission'])
                self.assertEqual(params['success'], authorized)
            else:
                with self.assertRaises(params['exception']):
                    authorize(request, res_id=params['res_id'], needed_permission=params['needed_permission'])


New to the Louis Kemp lineup, this premium surimi seafood is made from only 10 all natural ingredients including Wild Alaska Pollock, potato starch, sugar and sea salt. This product is Non-GMO, Gluten and Phosphate free so you know you are getting the highest quality ingredients from the number one name in surimi seafood.
INGREDIENTS: Alaska Pollock, water, potato starch, sugar, sea salt, natural flavor (Alaska Pollock), canola oil, paprika oleoresin, lycopene (color), citric acid.


@ dot our products are used by millions of people throughout the world every second of every day.
Many of our products our simply seen as everyday items.
We believe the best of design is that which needs no explanation, no instruction it just harmoniously is accepted into our lives.
we've been doing this for 30 years, all around the world. creating Iconic items that benefit us all.
Based in the London, we are Product Design and Development Consultants, working with international brands worldwide.


text:
Q: TypeError in Codality Python MaxProductOfThree I was practising the following exercise of Codality lessons in Python:
Your goal is to find the maximal product of any triplet.
Write a function:

def solution(A)

that, given a non-empty array A, returns the value of the maximal product of any triplet.

For example, given array A such that:

  A[0] = -3
  A[1] = 1
  A[2] = 2
  A[3] = -2
  A[4] = 5
  A[5] = 6
the function should return 60, as the product of triplet (2, 4, 5) is maximal.

def solution(A):
    A.sort()
    N=len(A)
    P1=A[N-1]*A[0]*A[1]
    P2=A[N-1]*A[N-2]*A[N-3]
    return max(P1, P2)

print(solution[4,2,2,5,1,5,8])

I have face this error while running the code : TypeError: 'function' object is not subscriptable
Can you please help me out in fixing the code?

A: print(solution([4,2,2,5,1,5,8]))

This is what you're missing
These added () is what tells the Python interpreter:
"Get what the solution() function returns when given [4,2,2,5,1,5,8] as the parameter.
Writing something like solution[something] means to subscript, or 'take some part out of' the solution, which is applicable to strings or lists for example, but not to functions, hence the error.

A: You should write it as solution([A]) and not solution[A].

redpajama_set_name: RedPajamaStackExchange


Dunbarton manufactures three building product lines: Rediframe Door Frames, Slimfold Closet Systems, and Achiever Entry Systems. Production is located in Dothan, Alabama, and is supported by a nationwide network of distributors and a satellite facility in Camden, Tennessee.
Request for Information / Request a Catalog from Dunbarton Corp.
To request more information from Dunbarton Corp., please complete the form below.
For other relevant searches, you might want to try: Dunbarton, dunbarton corp, steel door frames, biofold doors, steel bifold doors, mirror doors, closet doors, rediframe, steel closet doors, slimfold.
Copyright © 1996–2018 AECinfo.com – Company presentation: information, news and documentation about Dunbarton Corp..


how to disable Message outgoing tone on iphone 7/ios 10.
every time by sending sms its sound like a "swoosh " (similar). How to switch off whit out chenges in another settings ?
Unfortunately there is no way to do that. You would have to turn the volume on you phone off to do that, but that would silence everything.
Last edited by firedept10; 11-14-2016 at 02:35 PM.
iPhone 7 Plus sometimes wants passcode to unlock phone.
Touch ID not working for you? Here's how to fix it!


CARE Resolutions is committed to excellence of service and quality of care.
CARE Resolutions, Inc. is a family owned and operated company that was founded in 1997 by Vicky Hunt resulting from the compassionate, moving experience she had when providing care to her own mother. Her search for supplemental care to assist her with her mother, revealed at that time, there was a shortage of consistent, competent, affordable care agencies available.
Having been a Social Worker for many years, Vicky was driven to address the problem by forming her own successful agency. She studied health care and relied on her faith to ensure that her agency would provide compassionate, competent care through a network of excellent, meticulously trained caregivers. Shortly after starting the business it was impressed on Vicky that she should learn as much as possible about dementia, and Alzheimer's disease in particular, since the disease was beginning to receive the national recognition that it deserves.
Erica Tomasello, Vicky's daughter, has a background in Education and Clinical Psychology. She has worked with her mother for years, developing Care Resolutions into a premiere agency. Erica, and in turn, the agency's staff, continue to expand their knowledge with the ever growing development of understanding the aging process and geriatric disease. We are a member with Home Care Association of America and NFIB. We are also affiliated with NASW, National Association of Professional and Executive Women, Alzheimer's Partnership, Alzheimer's Association of Mass, MA Council for Home Care Aides.


I emerged tor and privoxy, edited my privoxy config file like mentioned the the news and started both services.
Now, when I try to open the test-tor page via firefox (of course, I set localhost and port 9050 as socks proxy in the preferences), the page loads endlessly and after some minutes, tells me that it couldn't connect.
I also tried the gentoo wiki tor-guide but that didn't work, too.
Installing vidalia and polipo also didn't help..
I'm sure there's an easy solution, but I can't figure it out, can someone help me please?
I don't know if it will help in your case, but the method that works for me is given in: How to install and use Tor for anonymous browsing or to access country-restricted content from another country.
The config file is probably not online anymore.
ok, got the config file.
Apr 13 12:04:19.084 [Notice] Tor v0.2.3.25 (git-17c24b3118224d65) running on Linux.
Apr 13 12:04:19.084 [Notice] Read configuration file "/home/yuki/.vidalia/torrc".
Apr 13 12:04:19.084 [Notice] Initialized libevent version 2.0.21-stable using method epoll (with changelist). Good.
Apr 13 12:04:19.084 [Notice] Parsing GEOIP file /usr/share/tor/geoip.
Apr 13 12:04:19.186 [Notice] This version of OpenSSL has a known-good EVP counter-mode implementation. Using it.
Apr 13 12:04:19.285 [Notice] Reloaded microdescriptor cache. Found 0 descriptors.
Apr 13 12:04:19.286 [Warning] Our clock is 20 hours, 55 minutes behind the time published in the consensus network status document (2013-04-14 09:00:00 GMT). Tor needs an accurate clock to work correctly. Please check your time and date settings!
Apr 13 12:04:19.286 [Notice] I learned some more directory information, but not enough to build a circuit: We have no recent usable consensus.
Apr 13 12:04:20.285 [Notice] Bootstrapped 5%: Connecting to directory server.
Apr 13 12:04:20.305 [Notice] Heartbeat: Tor's uptime is 0:00 hours, with 1 circuits open. I've sent 0 kB and received 0 kB.
Apr 13 12:04:20.353 [Notice] Bootstrapped 10%: Finishing handshake with directory server.
Apr 13 12:04:20.382 [Notice] We weren't able to find support for all of the TLS ciphersuites that we wanted to advertise. This won't hurt security, but it might make your Tor (if run as a client) more easy for censors to block.
Apr 13 12:04:20.382 [Notice] To correct this, use a version of OpenSSL built with none of its ciphers disabled.
Apr 13 12:04:20.438 [Notice] Bootstrapped 15%: Establishing an encrypted directory connection.
Apr 13 12:04:20.542 [Notice] Bootstrapped 20%: Asking for networkstatus consensus.
Apr 13 12:04:20.577 [Notice] Bootstrapped 25%: Loading networkstatus consensus.
Edit: now that I think of it, this could not be possibly caused by my iptables configuration?
1. the Tor site seems to recommend using the Tor bundle package instead of a real install of Tor and privoxy, noting in addition, as noted here in the forums previously, that privoxy is not needed anymore. So what is the lasted on this from a gentoo perspective? Should we just use the Tor bundle or emerge Tor and privoxy from the world tree?
2. how about iptables and Tor? is there a special setting to use for Tor compatibility or these are completely unrelated issues?


The 2014 CRWAD Meeting will be held December 7 – 9, at the Chicago Marriott, Downtown Magnificent Mile, Chicago, Illinois. The meeting will begin with the Researchers Reception, Sunday evening. The first poster session will coincide with the Researchers Reception. Presentations will conclude by 1 pm Tuesday afternoon, December 9. Attendance is limited to members, participants on the program and guests invited by the Council. If you desire to present at the Annual CRWAD Meeting or want an invitation to attend please contact Dr. Robert P. Ellis. The Students and Postdocs Reception (5:00 PM to 5:45 PM) will be held prior to the Researchers Reception and Poster Session I, Sunday (6:00 PM to 8:00 PM). CRWAD Keynote Speakers, CRWAD Council Members, CRWAD Dedicatee, students and postdocs are invited. Student and postdoc attendees should plan to attend both receptions. For those who need a US Visa in order to attend the CRWAD meeting please start your application process early. The formal dedication of the 95th Annual Meeting to the 2014 Dedicatee will be during the Tuesday noon Business Meeting and Awards Ceremony, in Salons A,B,C,D. The New Members will also be introduced at the Tuesday noon Business Meeting and Awards Ceremony. The student competition awards will be announced.


My heart is heavy. Recently, the board of Detroit Public Schools announced plans to close 52 schools by next year. Their rationale for this decision was in part to have school capacity reflect the rapid decline of school enrollment due to the growing exodus of families either moving to different cities or sending their kids to charter schools (or using a family member's address to enroll in another district). I have had enough! Our school system as a whole is not where it needs to be and I am tired of hearing about how we need to reform our schools without policies in place to inform those discussions.
We often hear about how we are living in a global economy and how our kids need to work hard but the way that we run our schools don't reflect this new paradigm. But before we get into the proposals put forth, we should first understand one of Garlin's themes for 2007; context.
But here in America, we are led to believe that influxes of Mexican immigrants are taking away domestic jobs. And while corporations pull the wool over our eyes, they are outsourcing work to places like China and India. In other words, someone doesn't have to live in the U.S. to compete for your job.
Next time, we will delve into the recommendations of the report.
Thanks for your work on Ed Reform in Detroit. Are you aware of any collaborative initatives working on Ed Reform in Detroit?


text:
BOARD OF REGENTS ACTS ON EMERGENCY REGULATION REVISIONS TO 2021 DIPLOMA REQUIREMENTS
August 2021 Regents Exams Cancelled
If USDE Waiver is Denied, Only Four June 2021 Regents Exams will be Administered
If USDE Waiver is Denied, Only Session One of the Grades 3-8 ELA & Math Assessments and Only the Written Test Component of the Grades 4 & 8 Science Tests will be Held
The Board of Regents today acted on a series of emergency regulations to allow for exemptions to diploma requirements associated with the June 2021 and August 2021 Regents Examination administrations. With the COVID-19 crisis still affecting the State of New York and students having varied levels of in-person instruction, the Board and the Department are taking necessary steps to provide essential flexibility for the State's students, families and educators.
These include actions to cancel the August 2021 Regents Exams and, should the U.S. Department of Education deny the Department's waiver request, only four of the June 2021 Regents Exams will be administered; only Session 1 of the Grades 3-8 English Language Arts (ELA) and Math Tests will be required; and only the one-session Written Test component of the Grades 4 and 8 Science Tests will be administered.
"As we continue to see a global pandemic impact our schools and students in every corner of the state, the Board and I are determined to complete this school year in a manner that protects the health and safety of all of New York's children," said Chancellor Lester W. Young, Jr. "While we were disappointed by the USDE decision not to grant blanket waivers for state assessments, we are confident that the regulatory amendments acted on today and other assessment-related actions by the Department provide for the flexibility necessary to meet federal requirements while ensuring the well-being of those in our school buildings."
"The Department continues to engage with USDE in regard to finding the best path forward in offering state assessments for the children of New York," said Commissioner Betty A. Rosa. "In order to inform these discussions, we are engaging with stakeholders across the state to gain insight on the local approaches to student assessment. The regulatory amendments advanced today provide fairness for our students; however we remain hopeful that USDE will provide the necessary waivers to allow our educators to remain engaged in the important work of fostering a safe and healthy learning environment for each child in New York state."
Summary of the AmendmentsA summary of the amendments follows. Full descriptions of the changes can be found in the Regents item.
CDOS Commencement Credential and CDOS Pathway: Commissioner's regulations are amended to exempt students from any unfinished requirements for the career development and occupational studies commencement credential (CDOS) provided that the student is otherwise eligible to exit from high school and has otherwise demonstrated knowledge and skills relating to the CDOS learning standards.
Regents Exam Exemption Eligibility Requirements: Regulations are amended to allow students who have met the standards for the course of study, as locally determined, to be eligible for an exemption to the examination requirements. To qualify for such an exemption to the diploma requirements, students must meet one of the following criteria:
The student is currently enrolled in a course of study culminating in a Regents Examination and by the end of the 2021 school year, or the 2021 summer session, will have earned credit in such course of study;
The student was previously enrolled in the course culminating in the applicable Regents Examination, has achieved course credit, and has not yet passed the associated required Regents Examination but was intending to take the test in June 2021 or August 2021 to achieve a passing score; or
The student is in grade 7 or 8, is enrolled in a course of study culminating in taking a Regents Examination and has met the standards assessed in the provided coursework.
The Department will also extend exemption eligibility for pathway assessments, alternative assessments, technical assessments, and locally developed tests through the 2020-21 school year.
Mastery and Honors Flexibility: Regulatory amendments will allow for flexibility in the calculations for the mastery and honors endorsement wherein student course grades may be substituted for exam scores in cases where Regents Examination exemptions would preclude a student from qualifying for an endorsement to their diploma.
Science Laboratory Experience: Commissioner's regulations relating to science laboratory experience are amended to:
Clarify that a student may still be eligible to take a science Regents examination, and therefore be eligible for an exemption if applicable, even if they are unable to meet the 1,200-minute science laboratory experience requirement due to the COVID-19 crisis; and
Expand the amendment allowing students to continue to meet the laboratory requirements through a combination of hands on and virtual experiences due to the COVID-19 crisis.
Graduation Assessment Exemption Declination: With the cancellation of the January 2021 Regents Examinations, the Department amended regulations to provide parents and persons in parental relation of students scheduled to graduate in January, June, or August of 2021 who have been exempted from a graduation assessment requirement the opportunity to decline such exemption.
Additionally, the amendment extended the time period required by schools to give parents or persons in parental relation notification of the option to decline such exemption from 10 calendar days to 30 calendar days.
USDE Waiver Exemption Requests: NYSED is in the process of surveying districts and charter schools about their local approaches to student assessment. This information will be used to inform NYSED's conversations with the USDE regarding the administration of the federally required spring 2021 grades 3-8 ELA and math assessments, grades 4 and 8 science tests, and Regents Examinations. It is the intent of the Department to showcase the wide range of quality assessment practices that are taking place at the school and district level throughout New York State.
While no final decisions have been made on the Department's assessment waiver request, the Department is planning ahead. Accordingly:
If USDE grants the Department's waiver request, the State's elementary- and intermediate-level assessments and all of its June and August 2021 Regents Examinations will be cancelled.
Should USDE not grant the waiver request or not respond prior to the scheduled test administration dates:
the Department will administer only the Regents Examinations required under ESSA during the June 2021 administration, which are the ELA, Algebra 1, Earth Science and Living Environment Exams;
the August 2021 Regents Exams will be cancelled;
only Session 1 of the grades 3-8 assessments in Math and ELA will be required, a shift from the standard practice where these assessments are administered in two sessions; and
only the written test component of the Grades 4 and 8 Science Tests will be held; the performance tests will not be administered.
Timetable for ImplementationThe emergency regulations will become effective on March 16, 2021. It is anticipated that the proposed amendment will be presented for permanent adoption at the June 2021 Regents meeting, after publication of the proposed amendment in the State Register and expiration of the 60-day public comment period required under the State Administrative Procedure Act.
The Sweeping implications of the supreme court's new union busting case
Cedar Point Nursery v. Hassid, which the Supreme Court will hear next Monday, March 22, targets a nearly half-century-old regulation in California that permits union organizers to briefly enter agricultural worksites and speak to farmworkers. But the stakes in this case go far beyond union busting.
The plaintiffs in Cedar Point ask the justices to so radically reshape the Court's approach to property rights that some of the most basic state and federal health and safety laws could fall. Among other things, if the Court accepts the plaintiffs' argument that farm owners have a constitutional right to kick union organizers off their property, it could also mean that restaurants have a constitutional right to keep health inspectors from entering their kitchens, or that factory owners can prohibit the government from inspecting their machines to make sure those machines are safe to operate.
Cedar Point is one of the most radical property rights cases to reach the justices in a long time. And its plaintiffs ask for a significant reshaping of the American social contract.
The case arises out of the Fifth Amendment's "Takings Clause," which provides that private property shall not "be taken for public use, without just compensation." The plaintiffs claim that this clause gives them a broad "right to exclude unwanted persons from private property," and that this right permits a property owner to forbid a union from entering their land, even if state law permits that union to do so.
If the Cedar Point plaintiffs prevail, California will have to pay farm owners if it wants to enforce its pro-union regulation.
The Supreme Court has repeatedly held that laws granting unions a limited right to enter an employer's property and speak to workers are constitutional. As the Court held in Central Hardware v. NLRB (1972), the government may require an employer to allow a union onto its property so long as "the access is limited to (i) union organizers; (ii) prescribed nonworking areas of the employer's premises; and (iii) the duration of organization activity."
But the Cedar Point plaintiffs don't just ask for a decision that could sweep away decisions like Central Hardware. They ask for such a broad power to exclude others from private property that even things like health inspections could be endangered.
Sign up for The Weeds newsletterVox's German Lopez is here to guide you through the Biden administration's unprecedented burst of policymaking. Sign up to receive our newsletter each Friday.
How the Takings Clause currently operatesThe specific regulation at issue in Cedar Point has been on the books since 1975. It allows organizers to enter a worksite and speak to farmworkers for up to three (nonconsecutive) hours a day — the hour before the start of work, the hour after the end of work, and the workers' lunch break.
Before a union may do so, it must notify the government and the employer. The union may enter the worksite for up to 30 days, and it may invoke this right to enter a particular worksite up to four times a year.
Thus, union organizers are allowed on a farm's property for a maximum of 120 days a year, and only for a total of three hours per day.
The Cedar Point plaintiffs argue that this limited intrusion of their property amounts to what is known as a "per se" taking. Current law distinguishes between per se takings, which involve unusually severe intrusions on private property and are treated with particular skepticism by courts, and milder intrusions on property rights that fall under the broader umbrella of "regulatory" takings. Notably, the Cedar Point plaintiffs do not argue that California's union access rule is a regulatory taking — so they appear to have made a strategic decision to avoid more measured legal arguments in favor of their more radical claim.
Property owners subject to a per se taking will generally prevail in court, while plaintiffs who allege a regulatory taking often lose — even if they challenge a land use regulation that imposes fairly substantial limits on how they can use their property. In one famous regulatory takings case, the Court upheld a New York City law that prevented the owners of Grand Central train station from constructing a high-rise office building on top of the terminal.
Very few cases qualify as per se takings. Under existing precedents, a law doesn't count as a per se taking unless it deprives a property owner of "all economically beneficial or productive use" of their property, or subjects the property owner to a "permanent physical occupation" of their land.
So, under this framework, California's union access rule is not a per se taking. Though a union that successfully organizes a workplace is likely to secure a contract that requires the employer to pay more money to its workers, unionization does not deprive an employer of all economic benefits from their land. And California's rule does not allow anyone to permanently occupy a property owner's land. It only allows union organizers to enter that land for a few hours a day, and only for about a third of the year.
How the Cedar Point plaintiffs want to remake the lawBefore we get into some details about the Cedar Point plaintiffs' argument, it's helpful to understand two legal concepts.
The first is the concept of a "license." Suppose that I hire a dog walker to walk my dog on weekday afternoons while I'm at the office. As part of this arrangement, I give the dog walker a key to my home and permission to enter in order to bring the dog outside for his walk. Under this arrangement, I have granted the dog walker a "license" to enter my home.
Licenses are often temporarily arrangements. And they typically (though not always) can be revoked by the property owner. If I decide that my dog walker is doing a bad job, I can fire them and take away their legal right to enter my home. And if I sell my home, the dog walker doesn't retain any right to enter my former home once the new owner takes possession.
Watson is a very good dog who will bark at you if you trespass upon my home without a license to enter.An "easement" is something else entirely. Suppose that Marge owns a house in a rural area with minimal electrical infrastructure. Now suppose that Big Electric wants to build a power line under Marge's land that can bring electricity to her neighbors, and that Big Electric also seeks a permanent right to enter Marge's land and repair this power line if it is damaged. So Big Electric offers Marge money in return for a permanent right to build and maintain this power line.
Big Electric is seeking an easement. Easements typically transfer a portion of a property owner's rights permanently to someone else. Under ordinary circumstances, a landowner may exclude anyone they want from their property. But under the terms of this easement, Marge would permanently give up her right to exclude Big Electric's repair crews. Big Electric would own the right to enter onto Marge's land just as surely as Marge owns her home.
And if Marge someday sells her home to someone else, Big Electric would still own that easement. It would belong to Big Electric, not Marge, and therefore is not something that Marge could transfer to someone else.
This distinction between licenses and easements matters because in Nollan v. California Coastal Commission (1987), the Supreme Court held that, if the government seeks a "public easement across a landowner's premises," then the Takings Clause requires the government to compensate that landowner. The Cedar Point plaintiffs rely heavily on Nollan in their brief, arguing that the California union-access regulation "appropriates an easement across the property of all agricultural businesses in California" by stripping those businesses of the right to exclude certain people from their land.
Essentially, they argue that this alleged easement amounts to a per se taking because it permanently gives unions a right to visit certain worksites — even if the unions can only enter those worksites some of the time.
The state concedes that its regulation "is similar to an easement insofar as it affords union organizers a 'nonpossessory right to enter' the property of agricultural employers." But the state ultimately argues that its regulation only grants "some form of license" to union organizers.
It's a strong argument because, while the California regulation does diminish some property owners' rights to exclude unwanted visitors, it does not resemble an easement in one very important way. The California regulation does not permanently transfer any of a farm owner's property rights to unions. The unions do not own anything because of this regulation.
If California were to repeal its regulation tomorrow, the unions would be left with nothing. Had the California regulation actually imposed an easement on farm owners, then unions would retain their ownership of this easement even after the regulation that established it ceased to exist. Under Nollan, if the unions had obtained an easement allowing them to enter private land, then the Takings Clause would forbid California from taking this easement from them without compensating them.
If the Supreme Court agrees that California's regulation appropriates an easement from farm owners, then the implications are profoundAt least in marginal cases, the line between an easement and a license can be blurry. As one California appeals court judge complained in a 1994 opinion, commercial land use arrangements often involve such complicated terms that "it is increasingly difficult and correspondingly irrelevant to attempt to pigeonhole these relationships as 'leases,' 'easements,' 'licenses,' 'profits,' or some other obscure interest in land devised by the common law in far simpler times."
But, to the extent that the Supreme Court is uncertain whether to classify the rights granted to unions by California's regulation as a "license" (and therefore as more permissible under the Constitution) or an "easement" (and therefore subject to the Takings Clause's restrictions), there are profound practical reasons to prefer the former option.
The state's brief in Cedar Point spends several pages explaining just how many laws could become invalid if the government cannot require landowners to allow unwanted persons onto their property.
"The categorical rules proposed by petitioners and their amici would also imperil a wide variety of health- and safety-inspection regimes," the state's legal team writes. "These include, among many others, food and drug inspections, occupational safety and health inspections, and home visits by social workers," as well as a federal law providing that "underground mines must be inspected 'at least four times a year.'"
States also frequently enact laws allowing non-governmental workers to enter onto private land. "Many States authorize utility companies and similar entities to enter private property, even absent the owner's consent, for surveys, repairs, connections, and similar purposes," the state's brief explains.
And, in what is likely a bid to secure the votes of conservative justices who support strict enforcement of immigration laws, California argues that the rule proposed by the Cedar Point plaintiffs could prevent law enforcement from arresting many undocumented immigrants.
Although longstanding legal principles permit "entries onto private property to make arrests or enforce criminal laws," these principles "do not appear to apply to entries by Border Patrol agents to enforce noncriminal immigration laws, or by other government officials to enforce other civil laws."
US laws permitting unwanted persons to enter a property owner's land, moreover, stretch back to the early days of the American Republic. Indeed, a Massachusetts law from the 1640s, when the state was still a British colony, provided that "'any man ... may pass and repass on foot through any man's propriety' in order to access 'great ponds' for the purpose of fishing or fowling, so long as the entry did not damage the property."
The strict limits on governmental regulation of property rights proposed by the Cedar Point plaintiffs, in other words, are quite novel. And those limits could invalidate countless state and federal laws, preventing health inspectors from investigating potentially unsafe businesses, and preventing workplace inspectors from investigating dangerous factories and other worksites.
The Roberts Court, which now has a 6-3 Republican majority, is often very hostile toward the rights of unions — even when those rights are clearly established by existing law. In Janus v. AFSCME (2018), for example, the Supreme Court overruled a 41-year-old decision permitting unions to collect certain fees from non-members who benefit from the union's services.
But, to rule against the unions in Cedar Point, the Supreme Court wouldn't simply need to undermine many years of decisions benefiting unions. Such a decision could profoundly rework the balance of power between landowners and the government, undercutting huge swaths of state and federal law in the process.
A justice who may be inclined to spite the United Farm Workers in Cedar Point, in other words, needs to ask themselves if they also feel safe eating out at a restaurant that is closed to health inspectors.

redpajama_set_name: RedPajamaCommonCrawl


All grade levels listed are based on the child's rising grade level – what grade s/he will enter in Fall 2019.
All classes are $195 per class except Week 3, which is $117 per class.
Basketball Fundamentals (3rd-6th) - NEW!
Percussion Jam (4th-6th) - NEW!
Jam through the week with buckets, drums and all things percussion! Styles like Southern Rock, R&B, as well as old time Rock and Roll, will be explored as well as the history of how various percussion styles evolved. The week will end with an energy-driven percussion performance.
Head to the barn and experience life on the farm!
Fit and Fast Football (3rd-6th) - NEW!
Java Coding in Minecraft (3rd-6th) - NEW!
Get excited about cooking in new and delightfully delicious ways as we use some of our favorite children's books to stir up our appetites. Read stories with food in the starring role – stone soup or the gingerbread man, anyone? Participate in hands-on activities related to the books and get ready for a culinary adventure as we cook up the incredible edibles from the stories.
A Disney Musical Extravaganza (K-3rd) - NEW!
Mobile App Maker (3rd-6th) - NEW!
Soak up some sun and have some beach and ocean fun!
Fun in the Sun (K-2nd) - NEW!
Campers will get to put their math, science, visual acuity, spatial relations skills and imagination to the test by seeing what they can create with various types of blocks, Lincoln Logs, Legos, K-nex, Tinker Toys, Wedgits, Zoobs, Model Magic, common household items and maybe even food. In addition to free building, there will be special challenges too. Perhaps we will experiment with how can we change our design to build a bridge that holds more weight…or how fast can we follow the directions and work together as a team to put together a brand new Lego set…or how high can we build a house of cards? A few lessons on basic architecture and engineering will round out this week of construction fun.
Experience some of nature and the great outdoors as we "camp out" together!
Fun in the Sun (3rd-6th) - NEW!
Coding Foundations (K-2nd) - NEW!
The volcanic explosion at Pompeii…the San Francisco earthquake of 1906…Hurricane Katrina. How did they happen? What about the fiery end to the Hindenburg and the icy end to the Titanic? What caused these disasters, and what was learned from them? Can we prevent similar disasters ? Travel back in time to take an in-depth look at these and other natural and human-made explosions, wacky weather and ground-shaking events. Learn about geology, seismology, aeronautics, meteorology, combustible gases and more through research as well as hands-on activities and simulations. Get wet, dusty and messy (but stay totally safe) with this explosive class!
Cardboard Engineering (3rd-6th) - NEW!
Read fun stories like If You Give a Mouse a Cookie, then cook up some yummy treats and participate in other food related activities!
Rockin' with Pete the Cat (K-2nd) - NEW!
Cardboard Engineering (K-2nd) - NEW!
Python Coding in Minecraft (3rd-6th) - NEW!
Data Science for Coders (3rd-6th) - NEW!
Pack your bag and grab your binoculars as we set off on a great animal adventure!
Stop Motion Video Production (K-2nd) - NEW!
In the Net (3rd-6th) - NEW!
Dough Discovery (K-2nd) - NEW!
Fun Boot Camp (K-2nd) - NEW!
Blast off for an "out of this world" experience in space!
Jumba, Dance & Tumbling (K-2nd) - NEW!
Video Game Maker (K-2nd) - NEW!
"Ad" venture (3rd-6th) - NEW!
Roblox Coding (3rd-6th) - NEW!
Move from one activity to another as we explore the wonderful world of transportation!
Fit and Fast Football (K-2nd) - NEW!
Coding Python Cryptography (3rd-6th) - NEW!
What's your favorite kind of work? We will have fun trying out many different jobs!
Circus Fun (K-2nd) - NEW!
Olympic Medals (3rd-6th) - NEW!
Java Code in Minecraft (3rd-6th) - NEW!
Cuddle up and enjoy fun times with your teddy bear and learn about real bears, too!


Sri Lanka is a wonderful destination for families. This little island seemingly has it all with something to offer every family whether you're looking for culture, wildlife, adventure or just a week or two soaking up the sunshine on some of Asia's best beaches.
Little kids will love the palm-fringed beaches and calm, swimmable waters, and will delight at the numerous turtle sanctuaries found near Bentota. For big kids and teens Sri Lanka is activity heaven, from water skiing and surfing on the coast to canoeing, and mountain biking in the hill country. And for parents there's everything you could possibly hope for in a family holiday destination – action, adventure, culture, history, relaxation, great food and the chance to create some incredible memories with your kids. And, if you're looking for some great places to stay, have a look at our favourite family hotels.
Five species of sea turtle call Sri Lanka home, the Olive Ridley Turtle, Loggerhead Turtle, Green Turtle, Hawksbill Turtle and Leatherhead Turtle. Their major nesting habitats are located along the southern coast in the Galle District and a number of turtle hatcheries can be found along the southern coastal road, from Bentota onwards.
Established to help protect these wonderful creatures, it's definitely worth stopping by a turtle hatchery at least once. Learn about the dangers turtles face, the conservation efforts in place and meet the turtles! Kids may even be able to help release baby turtles back into the ocean – an unforgettable experience. Near Bentota, Club Villa is a great hotel for families.
If you want to fish in Sri Lanka you're going to have to practice your balancing skills as local fisherman traditionally perch on stilts to snare their catch of the day. The stilt poles, known as riti panna, can be seen along the southern coast stuck a few metres offshore in the water. A small bench is attached to the poles and this is where the fishermen balance above the water. This method is used only for catching small reef fish called 'Bollu' and 'Koramburuwo', tiny fish not dissimilar in size to a sardine.
The origins surrounding stilt fishing are unclear although traditionally the skill was handed down generation to generation. Sadly there are fewer and fewer fishermen practicing the skill today but you'll usually see some fishing at sunset, noon and sunrise – you can even have a go yourself!
Galle's 17th-century Dutch Fort is one of Sri Lanka's highlights. Originally built by the Portuguese in 1588 and then extensively fortified by the Dutch from 1649 onwards, the fort has been beautifully preserved and is a UNESCO World Heritage Site. Walk the ramparts and then wander the charming, narrow streets lined with old houses and historic churches. There's also a good selection of boutiques, art galleries and restaurants. What's really interesting about the fort, however, is that it's still a living, breathing community with administrative offices and children heading off to school. Travel writer Juliet Coombe's book Around the Fort in 80 Lives is a great introduction to some of the characters that live here. Don't miss the locals jumping off the ramparts into the waters below!
For hotels near Galle, we really love The Why House and Apa Villa.
Cricket was first introduced to Sri Lanka (then called Ceylon) when the island became a British colony in 1802. It didn't take long for the game to take off and today it's the most popular sport in the country.
Despite its tiny size, the island has eight grounds that have been used to host international cricket matches including stadiums in Colombo, Kandy and Galle. The Galle International Stadium was originally opened in 1829 as a horseracing course but was soon taken over by stumps and wickets. Today it's one of the most picturesque Test grounds in the world with views of the Dutch Fort from the stadium. If you're lucky, your trip might coincide with a Test match and even if you can't get tickets, you can watch with the locals from the fort ramparts. Check the schedule here.
Sri Lanka is well known as a great surf destination. Because of the island's two seasons you can always find waves somewhere; the south west coast between November and March and the east cost from May to September.
But what if you can't tell your barrels from your breaks? Fortunately Sri Lanka offers consistent, small beginner-friendly waves, especially along the south west coast. Weligama in particular is a popular spot for beginners as it's a sheltered bay, protected from the wind. There are a number of local surf schools here where you can have lessons or simply hire a board. It won't be long before you're charging and carving like the best of them. For hotels near Weligama, we love Cape Weligama and W15.
10% of the world's elephant population is concentrated on this small island!
The Asian elephant has played a central part of Sri Lanka's culture and ecology for thousands of years – amazingly 10% of the world's elephant population is concentrated on this small island! There are many ways where you can get up close and personal with these incredible creatures – you can even learn how to make paper from elephant poo at the Eliphus Maximus project!
The Pinnawala Elephant Orphanage is a family highlight and one of the most popular places to visit. This orphanage, nursery and captive breeding ground for wild Asian elephants was originally founded in 1975 to care for and protect orphaned elephants found in the wild. Visitors can watch the elephants bathing in the river and being fed.
Other elephant encounters can be had on an elephant safari at Minneriya National Park, where herds of up to 150 elephants gather and the Elephant Transit Camp in Uda Walawe National Park. In Uda Walawe you can stay at Elephant Trails.
Located in the Central Province, the mythical ancient rock fortress of Sigiriya (Lion's Rock) is one of Sri Lanka's most mind-blowing sites and a UNESCO World Heritage Site. Originally built as the fortified capital for King Kassapa (477-95) after he had assassinated his father, there is little left of the original palace today but the views from the top of the rock, nearly 200 metres high, are breath taking.
Sri Lanka's tourist board likes to boast that it is the only country in the world where you can see the biggest land animal, the elephant, and the largest marine mammal, the blue whale, in one day. Indeed the southern coast of Sri Lanka is one of the best places in the world to see blue whales. The southern tip is surprisingly close to the deep waters of the continental shelf, where these giants swim. Nowhere else in the world do these incredible creatures come so close to land, or are so reliably seen. Here, you may be lucky enough to see dozens of whales feeding and even mothers and their calfs.
Numerous companies have set up shop offering trips to see the whales but we recommend choosing one such as Jetwing, an eco-tour specialist that ensures that their boat tours keep a comfortable distance from the whales so that they are not stressed. Parents should note that these boat trips are not short (contact your chosen operator for tour lengths) and so usually best suited to older children who are happy to spend hours at sea.
Kandy, the easy-going capital of the hill country, and the cultural capital of Sri Lanka, sits 115km inland at a cool height of 500m. It served as the last capital of the Sri Lanka kings before being toppled by the British in 1815 (having previously held out against the Portuguese and the Dutch). Today it's a lovely hill town surrounding by jungle (leopards have been known to step into town at night) with a picture-worthy lake in the middle and a gorgeous array of architecture.
Kandy is also home to Sri Lanka's most important Buddhist relic, a tooth of the Buddha. Housed within the golden-roofed Temple of the Sacred Tooth in the royal palace complex of the former Kingdom, tradition dictates that whoever holds this relic holds the governance of the country. Poojas (offerings or prayers) are held and dawn, noon and dusk daily during which time the room housing the tooth is open to devotees and tourists. That said, you won't see much as the tooth itself is kept in a golden casket shaped like a stupa. An annual festival, the Esala Perahera, is held in July and August to pay homage to the tooth.
There are some really lovely family-friendly hotels in Kandy including the excellent Madulkelle Tea and Eco Lodge, Elephant Stables and Theva Residency.
The rolling green hill country is simply beautiful. With mountains green hills, dramatic peaks and carefully manicured tea plantations it's a world away from the steamy coastal lowlands. There are various ways to enjoy the area, and big kids and teens will love the adventure activities on offer, however one of our favourite activities is to travel by train.
The train ride from Kandy to Nuwara Eliya, a charming colonial town by the British in the early 1800s as a summer retreat, is spectacular. The track climbs through pine and eucalyptus forest, past tea covered hills and roaring waterfalls with breath taking views of the emerald green hills. Pack a picnic and grab a seat in the observation car, normally at the rear of the train, for the best views. Make sure to book in advance. For more information on train travel in Sri Lanka, take a look at the fantastic website The Man in Seat 61… If you decide to stay in Nuwara Eliya then Heritance Tea Factory, a family-friendly hotel set within an old tea factory, is a great option.


Seller MediaTech - Is Bid Or Buy doing anything now???
Is Bid or Buy doing anything to assist with sorting out???
Hi there.. Not sure if you saw this : http://forum.bidorbuy.co.za/forum-community-watch/11886-just-setting-record-straight.html, or received an email from him. I know it's little comfort, but hoping you get your refund quickly.
I just hope all works out good for every one.
What did I mis?? Media Tech??!!
Hi ClickandShip... See http://forum.bidorbuy.co.za/forum-community-watch/11871-how-succesfull-scammer-bob-idiots-guide.html. I honestly don't think it was intentional though..
I can speak first hand obviously and know what this poor man is going through, his buyers don't beleive him, a testament to how people have lost faith in the existance of good honest people, he just musn't give up!! Even if he can do only 1 refund a day, do it!! Soon it will all be behind you!
And never fall prey to greed again!! Thats were all really bad belly-up situations come from...''WOW, think of the money I can make here!! I am gonna be rich!!'' = DISASTER!
Chin up Media Tech, I can tell you 1 thing, sow back honestly and without reserve, when it's over, you will reap the rewards of honesty and restoring your dignity and self worth, there's no price on that.
I think C&S has it in a nutshell here.
As advised previously, we are assisting users who have been affected by this, we have also released the sellers details to you and advised you to proceed with legal action against the seller, we will also assist the authorities in any way we can.
As you have paid the money to the seller, we unfortunately cannot act on your behalf or open cases against the seller, as we are not the buyer.
Please continue to liaise with Bertus or Bennet on this issue.
And C&S has set a fine example to follow too! Well done C&S - good to see you back as a "regular".
No, he did not have permission and this is exactly why we do not allow it, unless approval is given from our side. As soon as we were alerted to this his selling status was restricted and his listings removed, however, it seems he managed to get some sales before we were able to prevent this. Unfortunately this is very difficult to detect or prevent as we are never physically present at the sellers premises and never see the stock.
I sell the few watches I have for half the retail price because I won them in reputable magazines and therefore could even sell the brand new R4000 armani watche I have for R10 and still make a profit, and I have had them confirmed as genuine.
Seller Media Tech is a conman. Full stop.
I reported this seller on CW and still he got away with it....Why? Because he is a clever conman.People on this forum who still believe in him and believe he was conned,you are pathetically stupid (Oh Dear there I get personal again) The biggest idiot being SProducts who accused me of being out to get Seller Media Tech.
Yes, I will go all out to avoid scammers destroying BoB and so should all other Sellers - you should maybe ask people who lost money how they feel about this seller.
I can explain how he went about it, but it is a long story and he tried many tricks. He at first sold fake watches and was caught out. Any seller who is not trying to trick sellers would make sure they don't sell fakes BEFORE listing it on BoB. He also lied when people asked him questions on his products for sale and it was clear he was up to no good,and for that reason I reported him.Seller media tech was quick to show proof how he was "conned" by the Chinese,this by a person who gave his profession as a pshyclogist on his profile,but maybe he can show some more goodwill to the buyers who bought from him and explain where the money went that was paid into the Nedbank account of Angel Jacobs.This is the account name where money was paid into for all his sales.
Finally all people who lost money make sure you go for him in criminal court and not civil,this way he might decide to pay money back, as jail might not be that comfortable for him.
I guess some of us are far too trusting and gullible, and I (for one) apologise for not realising you were giving us all a good warning, pin nacle! Fortunately I hadn't bought anything from media tech and I feel heartsore for those who have lost many thousands to the scammer! Thank you for keeping an eye out for those of us who have been so gullible.
Good Morning. Seller Media Tech is a conman. (Oh Dear there I get personal again) The biggest idiot being SProducts who accused me of being out to get Seller Media Tech.
:sick:I am sorry to barge in like this pin_nacle, but the rules of this forum clearly states argue the post and not the poster, i think it is uncalled for to attack SProducts and to say he is a idiot, that is just plain rude and clearly shows your mind phrame, please refrain from attacking the forum members it is not going down to well with some of the forum members who is trying to give their oppinion in a civilized manner, this could affect your business quite a bit as buyers do see these threads and i assure you nobody likes a know it all or a i told you so, as we all get the point loud and clear!
Maybe Cuan can enlighten me and i certainly appologise to him and BOB for sending this as it is not in my nature to speak like this to other people so publically, so i hope i have not overstepped my line!
Well I for one feel that, while you were right as far as we know, you are a horrible rude, sarcastic person. Most of us here have at one point have been scammed, not because we are STUPID but trusted that we would get our goods.
Your toes are curling of happiness in a case where lots of people lost their hard earned money. That makes you just as bad as a scammer.
Trust and kindness goes along way and I feel sorry for you because you dont have either.
Well said DA, you were a lot kinder the me.
:sowsuser:Thanks BB, ever heard this saying, when you point your finger at someone else four of them actually points straight back at you, makes one wonder doesn't it??????
I get pi**ed of by seller like SProducts defending conmen like Media tech and will not hold back any punches.People will do business with me as I don't mess people around and my business on BoB will suffer more as a result of conmen sellers like Media Tech than by my forum posts .... I will call a spade a spade...if you don't like it. tough!
Well I can tell you that very few people are hear what you are saying.
You are personally attacking some of us and it is uncalled for.
Thanks lilythepink,Yes just wish this could have been avoided as sellers like that does scare buyers away and make online sales much harder.
Please let's play the ball and NOT the player here.
Pin_nacle, you have made your point well (if rather rudely at times) about Nico's alleged tactics. It is understandable that you are angry but reserve your anger for the scamsters and not the victims of a potential - alleged - con artist. Should MediaTech indeed turn out to be a con artist as alleged, then the folks on this forum have been conned in the same manner as the unsuspecting buyers who have potentially lost money.
Angel Jacobs is (as far as I know) the real (or imaginary?) partner/wife of MediaTech - known to the forum as View Profile: Timeless Classics - bidorbuy.co.za Forum - Items for sale from Timeless Classics on bidorbuy.co.za.
Incidentally, should it be the case that MediaTech IS indeed a con artist, then psychologist is indeed one of the most appropriate ways to describe his lifestyle.
Ok, thread closed - becoming confrontational and not following forum rules.


The road north, from the central Syrian city of Homs, as seen from a vehicle in the United Nations monitoring mission's convoy, June 11, 2012.
(CBS News) DAMASCUS - The fierce battle in the city of Homs is on the southern edge of a whole area of central Syria - where the army and the armed opposition have been fighting from positions that are sometimes just hundreds of yards apart.
A police barrier marks the start of the war zone, just north of Homs - fighting has closed Syria's main highway but the United Nations monitoring mission is allowed through, and CBS News went in with them.
Driving down the highway, there is mile after mile of devastation on either side. Dug in all along the way are Syrian tanks and artillery - some still doing the shelling which has battered parts of Homs and other cities, others wrecked and burned in attacks by the rebel forces.
Every few hundred yards along the road there are Syrian military installations, but as soon as CBS News stopped with the U.N. staff, Free Syrian Army members - the rebels - came out to talk to us.
They appeared from an abandoned building - anxious to talk to the U.N. monitors.
Most civilians have now fled from the towns along the highway. But less than a mile further up the road, a woman appears outside her ruined home and waves to the convoy, keen for someone to hear her story.
"Look what's happening to us," she says. "Are we not people?"
She says a missile from a Syrian army helicopter destroyed the row in shops she's standing in front of. A young opposition fighter agrees, and a helicopter suddenly appears overhead.
The U.N. has confirmed that Syrian forces attacked the opposition from the air in recent days, so the U.N. convoy decides it's time for us to go.
We pass through Syrian army checkpoints. We'd like to hear their story, too, but they won't talk to journalists.
They are dug in, with their heavy armor, in force. But it is not enough force to keep a rebel flag from hanging from an overpass just up the road.
While Syrians and international diplomats are reluctant to call this a civil war - that is what it looks like in central and northern areas of the country.