Example #1
0
    def test_delete_group_view(self):
        """
        Testing delete group
        """

        # Create a group to delete
        group_data = {
            'name': 'Group to delete',
            'title': 'Group to delete',
            'header_logo_img': '',
            'srid': G3WSpatialRefSys.objects.get(auth_srid=4326)
        }
        group = Group(**group_data)
        group.save()

        # check 1 group on db
        dbgroups = Group.objects.all()
        self.assertEqual(len(dbgroups), 1)
        self.assertEqual(dbgroups[0].name, group_data['name'])

        url = reverse('group-delete', args=[group.slug])

        client = Client()
        self.assertTrue(
            client.login(username=self.test_user1.username,
                         password=self.test_user1.username))
        response = client.post(url)

        self.assertEqual(response.status_code, 200)

        # check no groups into db
        dbgroups = Group.objects.all()
        self.assertEqual(len(dbgroups), 0)

        client.logout()
Example #2
0
def group_create(request):
    """

    :param request:
    :return:
    """
    logger.debug('POST %s', str(request.POST))

    data = None if 'data' not in request.POST else request.POST[
        'data']  # что создавать
    try:
        # пытаемся получить словарик из json строки, притом один единственный,
        # т.к. в пакетном режиме не работаем.
        obj = json.loads(data)[0]
    except Exception as e:
        return HttpResponseServerError(
            "Deserialize json string (%s) error: %s" % (str(data), str(e)))
    new_group = Group()
    for key, value in obj.items():
        if hasattr(new_group, key):
            setattr(new_group, key, value)
    try:
        new_group.save()
    except Exception as e:
        return HttpResponseServerError("Save group error: %s" % str(e))
    return JsonResponse({'success': True, 'msg': 'Group create!'})
Example #3
0
 def insert(self, camp_idx):
     ''' 폼으로 입력받은 정보를 바탕으로 새로운 group 정보를 데이터베이스에 저장'''
     group = Group()
     group.camp_idx = camp_idx
     group.regdate = datetime.datetime.today()
     group.groupid = request.form.get('groupid')
     group.pwd = hashlib.sha224(self.pwd.data.encode('utf-8')).hexdigest()
     self.populate_obj(group)
     group.cancel_yn = 0
     group.cancel_reason = None
     group.cancedate = None
     group.mem_num = 0
     db.session.add(group)
     db.session.commit()
     return group.idx
Example #4
0
 def createGroup(self, request, **kwargs):
   self.method_check(request, allowed=['post'])
   data = self.deserialize(request, request.raw_post_data, format=request.META.get('CONTENT_TYPE', 'application/json'))
   owner = User.objects.get(id=data.get('owner'))
   title = data.get('title')
   members = data.get('members')
   group = Group(title=title, owner=owner)
   group.save()
   for member in members:
     member = User.objects.get(id=member)
     group.members.add(member)
   group.save()
   return self.create_response(request, {
         'success': True
         })
Example #5
0
    def setUp(self):

        self.client = Client()

        self.user = MyUser(
            username='******',
            email='*****@*****.**',
            is_active=True,
            is_staff=True,
            is_superuser=True,
        )
        self.user.set_password('test')
        self.user.save()

        self.client.login(username='******', password='******')

        teacher = MyUser.objects.create(username='******')
        students_lst = []
        groups_lst = []

        for counter in range(10):
            students_lst.append(Student(id=counter))
            groups_lst.append(Group(id=counter, teacher=teacher))
        Student.objects.bulk_create(students_lst)

        for group in groups_lst:
            group.students.set(students_lst)
        Group.objects.bulk_create(groups_lst)
Example #6
0
def create_admin(provider):
    print "What is the username of the provider admin?"
    username_select = raw_input("username of provider admin: ")
    print "What is the password of the provider admin?"
    password_select = raw_input("password of provider admin: ")
    print "What is the tenant_name of the provider admin?"
    tenant_name_select = raw_input("tenant_name of provider admin: ")


    (user, group) = Group.create_usergroup(username_select)

    new_identity = Identity.objects.get_or_create(provider=provider,
                                                  created_by=user)[0]
    new_identity.credential_set.get_or_create(key='key',
                                              value=username_select)
    new_identity.credential_set.get_or_create(key='secret',
                                              value=password_select)
    new_identity.credential_set.get_or_create(key='ex_tenant_name',
                                              value=tenant_name_select)
    new_identity.credential_set.get_or_create(key='ex_project_name',
                                              value=tenant_name_select)

    prov_membership = ProviderMembership.objects.get_or_create(
        provider=provider, member=group)[0]
    #TODO: Create quota if none exists
    quota = Quota.objects.all()[0]
    #Necessary for save hooks -- Default project, select an identity
    user.save()

    admin = AccountProvider.objects.get_or_create(
        provider=provider, identity=new_identity)[0]
    id_membership = IdentityMembership.objects.get_or_create(
        identity=new_identity, member=group, quota=quota)[0]
    return new_identity
Example #7
0
 def _update_threshold(self, request, app, **kwargs):
     user = request.user
     data = request.DATA
     app_owner = app.created_by
     app_members = app.get_members()
     if user != app_owner and not Group.check_membership(user, app_members):
         return failure_response(
             status.HTTP_403_FORBIDDEN,
             "You are not the Application owner. "
             "This incident will be reported")
         #Or it wont.. Up to operations..
     if kwargs.get('delete'):
         threshold = app.get_threshold()
         if threshold:
             threshold.delete()
         serializer = ApplicationThresholdSerializer(app.get_threshold())
         return Response(serializer.data)
     partial_update = True if request.method == 'PATCH' else False
     serializer = ApplicationThresholdSerializer(
         app.threshold,
         data=data,
         context={'request': request},
         partial=partial_update)
     if serializer.is_valid():
         serializer.save()
         logger.info(serializer.data)
         return Response(serializer.data)
     return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
Example #8
0
 def _update_application(self, request, app, **kwargs):
     data = request.DATA
     user = request.user
     data = request.DATA
     app_owner = app.created_by
     app_members = app.get_members()
     if user != app_owner and not Group.check_membership(user, app_members):
         return failure_response(
             status.HTTP_403_FORBIDDEN,
             "You are not the Application owner. "
             "This incident will be reported")
         #Or it wont.. Up to operations..
     partial_update = True if request.method == 'PATCH' else False
     serializer = ApplicationSerializer(app,
                                        data=data,
                                        context={'request': request},
                                        partial=partial_update)
     if serializer.is_valid():
         logger.info('metadata = %s' % data)
         #TODO: Update application metadata on each machine?
         #update_machine_metadata(esh_driver, esh_machine, data)
         serializer.save()
         if 'created_by_identity' in data:
             identity = serializer.object.created_by_identity
             update_application_owner(serializer.object, identity)
         if 'boot_scripts' in data:
             _save_scripts_to_application(serializer.object,
                                          data.get('boot_scripts', []))
         return Response(serializer.data)
     return failure_response(status.HTTP_400_BAD_REQUEST, serializer.errors)
Example #9
0
    def setUp(self):

        self.factory = RequestFactory()
        self.user_admin01 = User.objects.create_user(username="******", email="*****@*****.**", password="******",
                                                   is_staff=True, is_superuser=True)

        self.user_admin02 = User.objects.create_user(username="******", email="*****@*****.**", password="******",
                                                    is_superuser=True)

        self.user_editor1 = User.objects.create_user(username="******", email="*****@*****.**", password="******")
        self.group_editor1 = Group.objects.get(name=G3W_EDITOR1)
        self.group_editor1.user_set.add(self.user_editor1)

        self.user_editor2 = User.objects.create_user(username="******", email="*****@*****.**", password="******")
        self.group_editor2 = Group.objects.get(name=G3W_EDITOR2)
        self.group_editor2.user_set.add(self.user_editor2)

        self.user_viewer1 = User.objects.create_user(username="******", email="*****@*****.**", password="******")
        self.group_viewer1 = Group.objects.get(name=G3W_VIEWER1)
        self.group_viewer1.user_set.add(self.user_viewer1)

        self.user_viewer2 = User.objects.create_user(username="******", email="*****@*****.**", password="******")
        self.group_viewer2 = Group.objects.get(name=G3W_VIEWER2)
        self.group_viewer2.user_set.add(self.user_viewer2)

        # create a map group test
        self.group_test = Group(name='Test', title='Test')
Example #10
0
 def _update_threshold(self, request, app, **kwargs):
     user = request.user
     data = request.DATA
     app_owner = app.created_by
     app_members = app.get_members()
     if user != app_owner and not Group.check_membership(user, app_members):
         return failure_response(status.HTTP_403_FORBIDDEN,
                                 "You are not the Application owner. "
                                 "This incident will be reported")
         #Or it wont.. Up to operations..
     if kwargs.get('delete'):
         threshold = app.get_threshold()
         if threshold:
             threshold.delete()
         serializer = ApplicationThresholdSerializer(
             app.get_threshold())
         return Response(serializer.data)
     partial_update = True if request.method == 'PATCH' else False
     serializer = ApplicationThresholdSerializer(
         app.threshold, data=data, context={'request': request},
         partial=partial_update)
     if serializer.is_valid():
         serializer.save()
         logger.info(serializer.data)
         return Response(serializer.data)
     return failure_response(
         status.HTTP_400_BAD_REQUEST,
         serializer.errors)
Example #11
0
 def _update_application(self, request, app, **kwargs):
     data = request.DATA
     user = request.user
     data = request.DATA
     app_owner = app.created_by
     app_members = app.get_members()
     if user != app_owner and not Group.check_membership(user, app_members):
         return failure_response(status.HTTP_403_FORBIDDEN,
                                 "You are not the Application owner. "
                                 "This incident will be reported")
         #Or it wont.. Up to operations..
     partial_update = True if request.method == 'PATCH' else False
     serializer = ApplicationSerializer(app, data=data,
                                        context={'request': request},
                                        partial=partial_update)
     if serializer.is_valid():
         logger.info('metadata = %s' % data)
         #TODO: Update application metadata on each machine?
         #update_machine_metadata(esh_driver, esh_machine, data)
         serializer.save()
         if 'created_by_identity' in data:
             identity = serializer.object.created_by_identity
             update_application_owner(serializer.object, identity)
         if 'boot_scripts' in data:
             _save_scripts_to_application(serializer.object,
                                          data.get('boot_scripts',[]))
         return Response(serializer.data)
     return failure_response(
         status.HTTP_400_BAD_REQUEST,
         serializer.errors)
Example #12
0
    def create(self, validated_data):
        username = validated_data['atmo_user']
        groupname = validated_data['atmo_group']
        atmo_user, atmo_group = Group.create_usergroup(
            username, groupname)

        provider = validated_data['provider']
        provider_type = provider.get_type_name().lower()
        if provider_type == 'openstack':
            new_identity = self.create_openstack_identity(atmo_user, provider, validated_data)
        else:
            raise Exception("Cannot create accounts for provider of type %s" % provider_type)

        # Always share identity with group (To enable Troposphere access)
        new_identity.share(atmo_group)

        admin_account = validated_data['admin_account']
        if admin_account:
            AccountProvider.objects.get_or_create(
                provider=new_identity.provider,
                identity=new_identity)

        # TODO: When the refactor of rtwo/get_esh_driver is complete, validate_identity should be call-able without the django model (to avoid create-then-delete)
        validate_identity(new_identity)
        return new_identity
    def create(self, validated_data):
        username = validated_data['atmo_user']
        groupname = validated_data['atmo_group']
        atmo_user, atmo_group = Group.create_usergroup(username, groupname)

        provider = validated_data['provider']
        provider_type = provider.get_type_name().lower()
        if provider_type == 'openstack':
            new_identity = self.create_openstack_identity(
                atmo_user, provider, validated_data
            )
        else:
            raise Exception(
                "Cannot create accounts for provider of type %s" % provider_type
            )

        # Always share identity with group (To enable Troposphere access)
        new_identity.share(atmo_group)

        admin_account = validated_data['admin_account']
        if admin_account:
            AccountProvider.objects.get_or_create(
                provider=new_identity.provider, identity=new_identity
            )

        # TODO: When the refactor of rtwo/get_esh_driver is complete,
        # validate_identity should be call-able without the django model (to
        # avoid create-then-delete)
        validate_identity(new_identity)
        return new_identity
Example #14
0
def create_admin(provider):
    print "What is the username of the provider admin?"
    username_select = raw_input("username of provider admin: ")
    print "What is the password of the provider admin?"
    password_select = raw_input("password of provider admin: ")
    print "What is the tenant_name of the provider admin?"
    tenant_name_select = raw_input("tenant_name of provider admin: ")

    (user, group) = Group.create_usergroup(username_select)

    new_identity = Identity.objects.get_or_create(provider=provider,
                                                  created_by=user)[0]
    new_identity.credential_set.get_or_create(key='key', value=username_select)
    new_identity.credential_set.get_or_create(key='secret',
                                              value=password_select)
    new_identity.credential_set.get_or_create(key='ex_tenant_name',
                                              value=tenant_name_select)
    new_identity.credential_set.get_or_create(key='ex_project_name',
                                              value=tenant_name_select)

    prov_membership = ProviderMembership.objects.get_or_create(
        provider=provider, member=group)[0]
    #TODO: Create quota if none exists
    quota = Quota.objects.all()[0]
    #Necessary for save hooks -- Default project, select an identity
    user.save()

    admin = AccountProvider.objects.get_or_create(provider=provider,
                                                  identity=new_identity)[0]
    id_membership = IdentityMembership.objects.get_or_create(
        identity=new_identity, member=group, quota=quota)[0]
    return new_identity
Example #15
0
def fake_groups():
    u1, u2, u3 = fake_users(3)

    groups = [
        {'name': 'Grupão doido', 'users': [u1, u3]},
        {'name': 'Só no back-end', 'users': [u1, u2]},
        {'name': 'Todo mundo null', 'users': [u2, u3]},
    ]

    saved_groups = []
    for group in groups:
        g = Group(name=group['name'])
        g.save()
        g.users.add(*group['users'])
        saved_groups.append(g)

    return saved_groups
    def build_account(
        cls,
        account_user,
        group_name,
        username,
        provider_location,
        quota=None,
        allocation=None,
        is_leader=False,
        max_quota=False,
        account_admin=False,
        **kwarg_creds
    ):
        """
        DEPRECATED: POST to v2/identities API to create an identity.
        """
        # Do not move up. ImportError.
        from core.models import Group, Quota, Provider, AccountProvider

        provider = Provider.objects.get(location__iexact=provider_location)
        credentials = cls._kwargs_to_credentials(kwarg_creds)

        if not quota:
            quota = Quota.default_quota()
        #DEV NOTE: 'New' identities are expected to have a router name directly assigned
        # upon creation. If the value is not passed in, we can ask the provider to select
        # the router with the least 'usage' to ensure an "eventually consistent" distribution
        # of users->routers.
        topologyClsName = provider.get_config(
            'network', 'topology', raise_exc=False
        )
        if topologyClsName == 'External Router Topology' and 'router_name' not in credentials:
            credentials['router_name'] = provider.select_router()

        (user,
         group) = Group.create_usergroup(account_user, group_name, is_leader)

        identity = cls._get_identity(user, group, provider, quota, credentials)
        # NOTE: This specific query will need to be modified if we want
        # 2+ Identities on a single provider

        id_membership = identity.share(group, allocation=allocation)
        # ID_Membership exists.

        # 3. Assign admin account, if requested
        if account_admin:
            AccountProvider.objects.get_or_create(
                provider=id_membership.identity.provider,
                identity=id_membership.identity
            )[0]

        # 4. Save the user to activate profile on first-time use
        # FIXME: only call .save() if 'no profile' test is True.
        # TODO: write a 'no profile' test f()
        user.save()

        # Return the identity
        return identity
Example #17
0
def group_home(request):
    """
    renders list of groups available
    """
    groups = Group(request.user).GROUP_DEFINITIONS
    return render_to_response('core/group.html', {
        'groups': groups,
    },
                              context_instance=RequestContext(request))
Example #18
0
def obtain_group_zone_games():
    groups_info = pd.read_csv('calculator/data/group_zone_matches.csv')
    for index, row in groups_info.iterrows():
        group = Group.get_or_create(group_name=row['group'])
        date = datetime.strptime(row['date'], '%d/%m/%Y %H:%M')
        Match.new_with(date=date,
                       home_team=row['home'],
                       visiting_team=row['visiting'],
                       group=group)
Example #19
0
    def build_account(cls,
                      account_user,
                      group_name,
                      username,
                      provider_location,
                      quota=None,
                      allocation=None,
                      is_leader=False,
                      max_quota=False,
                      account_admin=False,
                      **kwarg_creds):
        """
        DEPRECATED: POST to v2/identities API to create an identity.
        """
        # Do not move up. ImportError.
        from core.models import Group, Quota,\
            Provider, AccountProvider, Allocation,\
            IdentityMembership

        provider = Provider.objects.get(location__iexact=provider_location)
        credentials = cls._kwargs_to_credentials(kwarg_creds)

        if not quota:
            quota = Quota.default_quota()
        #DEV NOTE: 'New' identities are expected to have a router name directly assigned
        # upon creation. If the value is not passed in, we can ask the provider to select
        # the router with the least 'usage' to ensure an "eventually consistent" distribution
        # of users->routers.
        topologyClsName = provider.get_config('network',
                                              'topology',
                                              raise_exc=False)
        if topologyClsName == 'External Router Topology' and 'router_name' not in credentials:
            credentials['router_name'] = provider.select_router()

        (user, group) = Group.create_usergroup(account_user, group_name,
                                               is_leader)

        identity = cls._get_identity(user, group, provider, quota, credentials)
        # NOTE: This specific query will need to be modified if we want
        # 2+ Identities on a single provider

        id_membership = identity.share(group, allocation=allocation)
        # ID_Membership exists.

        # 3. Assign admin account, if requested
        if account_admin:
            AccountProvider.objects.get_or_create(
                provider=id_membership.identity.provider,
                identity=id_membership.identity)[0]

        # 4. Save the user to activate profile on first-time use
        # FIXME: only call .save() if 'no profile' test is True.
        # TODO: write a 'no profile' test f()
        user.save()

        # Return the identity
        return identity
Example #20
0
 def _create_group(fake, users):
     """Generate and save a group object."""
     name = fake.company()
     g = Group(name=name)
     g.save()
     g.members = users
     g.save()
     return g
Example #21
0
    def create_identity(cls, username, provider_location,
                        quota=None, allocation=None,
                        max_quota=False, account_admin=False, **kwarg_creds):
        """
        Create new User/Group & Identity for given provider_location
        NOTES:
        * kwargs prefixed with 'cred_' will be collected as credentials
        * Can assign optional flags:
          + max_quota - Assign the highest quota available, rather than
            default.
          + account_admin - Private Clouds only - This user should have ALL
            permissions including:
              * Image creation (Glance)
              * Account creation (Keystone)
              * Access to ALL instances launched over ALL users

          Atmosphere will run fine without an account_admin, but the above
          features will be disabled.
        """
        # Do not move up. ImportError.
        from core.models import Group, Quota,\
            Provider, AccountProvider, Allocation,\
            IdentityMembership

        provider = Provider.objects.get(location__iexact=provider_location)
        credentials = cls._kwargs_to_credentials(kwarg_creds)

        #DEV NOTE: 'New' identities are expected to have a router name directly assigned
        # upon creation. If the value is not passed in, we can ask the provider to select
        # the router with the least 'usage' to ensure an "eventually consistent" distribution
        # of users->routers.
        if 'router_name' not in credentials:
            credentials['router_name'] = provider.select_router()

        (user, group) = Group.create_usergroup(username)

        identity = cls._get_identity(user, group, provider, credentials)
        # NOTE: This specific query will need to be modified if we want
        # 2+ Identities on a single provider

        id_membership = identity.share(group, quota=quota, allocation=allocation)
        # ID_Membership exists.

        # 3. Assign admin account, if requested
        if account_admin:
            AccountProvider.objects.get_or_create(
                provider=id_membership.identity.provider,
                identity=id_membership.identity)[0]

        # 4. Save the user to activate profile on first-time use
        # FIXME: only call .save() if 'no profile' test is True.
        # TODO: write a 'no profile' test f()
        user.save()

        # Return the identity
        return identity
Example #22
0
 def insert(self, camp_idx):
     ''' 폼으로 입력받은 정보를 바탕으로 새로운 group 정보를 데이터베이스에 저장'''
     group = Group()
     group.camp_idx = camp_idx
     group.regdate = datetime.datetime.today()
     group.groupid = request.form.get('groupid')
     group.pwd = hashlib.sha224(self.pwd.data.encode('utf-8')).hexdigest()
     self.populate_obj(group)
     group.cancel_yn = 0
     group.cancel_reason = None
     group.cancedate = None
     group.mem_num = 0
     db.session.add(group)
     db.session.commit()
     return group.idx
Example #23
0
def group_view(request, id):
    """
    renders a specific group's view.
    """
    group = Group(request.user).get_group(id)
    customer_list = Group(request.user).get_group_customers_query(id)
    page = int(request.GET.get('page', '1'))

    try:
        paginator = Paginator(customer_list, settings.DEFAULT_PAGESIZE)
        customers = paginator.page(page)
    except (EmptyPage, InvalidPage):
        # if the supplied page number is beyond the scope
        # show last page
        customers = paginator.page(paginator.num_pages)
    print customers.object_list
    return render_to_response('core/group_view.html', {
        'group': group,
        'customers': customers
    },
                              context_instance=RequestContext(request))
Example #24
0
def create_group(request, ):
    """
    Create group for the professor user.
    """
    if request.method == "GET":
        form = GroupForm()
        # Set the choices field for the member fields.
        form.fields['members'].choices = get_related_candidates(request.user)
        return render(request, 'core/create_group.html', {
            'form': form,
        })
    # The request is a POST method.
    elif request.method == "POST":
        """
        We need to set the choices field for the form, so that it can validates itself.
        """
        form = GroupForm(request.POST)
        form.fields['members'].choices = get_related_candidates(request.user)
        if form.is_valid():
            members = form.cleaned_data['members']
            title = form.cleaned_data['title']
            group = Group()
            group.creator = request.user.professor
            group.title = title
            group.save()
            for student in members:
                candidate = User.objects.get(username=student).candidate
                group.members.add(candidate)
            return redirect("core:connection")
        else:
            print(form.errors)
Example #25
0
    def setUpClass(cls):
        super(ClientApiTest, cls).setUpClass()

        # Fill the cache with getprojectsettings response so we don't need a QGIS instance running
        # TODO: eventually move to QgsServer
        cls.prj_test = Project.objects.get(title='Un progetto')

        # new properties has to save before caching, signal on svaing project invalidate cache['django']

        cls.prj_test.thumbnail = '/fake/project.png'
        cls.prj_test.save()

        # create a group print for follow project
        cls.print_group = Group(name='Print Group',
                                title='Print Group',
                                header_logo_img='',
                                srid=cls.prj_test.group.srid)
        cls.print_group.save()

        qgis_project_file_print = File(
            open('{}/{}'.format(DATASOURCE_PATH, QGS310_FILE), 'r'))
        cls.project_print310 = QgisProject(qgis_project_file_print)
        cls.project_print310.group = cls.print_group
        cls.project_print310.save()

        cache_key = settings.QDJANGO_PRJ_CACHE_KEY.format(cls.prj_test.pk)
        cache = caches['qdjango']
        cache.set(
            cache_key,
            open(
                os.path.join(
                    DATASOURCE_PATH,
                    'getProjectSettings_gruppo-1_un-progetto_qgis310.xml'),
                'rb').read())

        cache_key = settings.QDJANGO_PRJ_CACHE_KEY.format(
            cls.project_print310.instance.pk)
        cache.set(
            cache_key,
            open(
                os.path.join(
                    DATASOURCE_PATH,
                    'getProjectSettings_g3wsuite_project_test_qgis310.xml'),
                'rb').read())

        qgis_project_file_1 = File(
            open('{}/{}'.format(DATASOURCE_PATH, QGS310_FILE_1), 'r'))
        cls.project_print310_1 = QgisProject(qgis_project_file_1)
        cls.project_print310_1.group = cls.print_group
        cls.project_print310_1.save()
Example #26
0
def create_admin(provider):
    print "What is the username of the provider admin?"
    username_select = raw_input("username of provider admin: ")
    print "What is the password of the provider admin?"
    password_select = raw_input("password of provider admin: ")
    print "What is the tenant_name of the provider admin?"
    tenant_name_select = raw_input("tenant_name of provider admin: ")

    print "What is the admin_url of the provider admin?"
    admin_url_select = raw_input("admin_url of provider admin: ")
    print "What is the auth_url of the provider admin?"
    auth_url_select = raw_input("auth_url of provider admin: ")
    print "What is the router_name of the provider admin?"
    router_name_select = raw_input("router_name of provider admin: ")
    print "What is the region_name of the provider admin?"
    region_name_select = raw_input("region_name of provider admin: ")

    (user, group) = Group.create_usergroup(username_select)

    new_identity = Identity.objects.get_or_create(provider=provider,
                                                  created_by=user)[0]
    new_identity.credential_set.get_or_create(key='key',
                                              value=username_select)
    new_identity.credential_set.get_or_create(key='secret',
                                              value=password_select)
    new_identity.credential_set.get_or_create(key='ex_tenant_name',
                                              value=tenant_name_select)
    new_identity.credential_set.get_or_create(key='ex_project_name',
                                              value=tenant_name_select)
    provider.providercredential_set.get_or_create(key='admin_url',
                                                  value=admin_url_select)
    provider.providercredential_set.get_or_create(key='auth_url',
                                                  value=auth_url_select)
    provider.providercredential_set.get_or_create(key='router_name',
                                                  value=router_name_select)
    provider.providercredential_set.get_or_create(key='region_name',
                                                  value=region_name_select)

    prov_membership = ProviderMembership.objects.get_or_create(
        provider=provider, member=group)[0]
    quota = Quota.objects.all()[0]
    user.save()
    admin = AccountProvider.objects.get_or_create(
        provider=provider, identity=new_identity)[0]
    id_membership = IdentityMembership.objects.get_or_create(
        identity=new_identity, member=group, quota=quota)[0]
    return new_identity
Example #27
0
def create_admin(provider, admin_info):

    REQUIRED_FIELDS = ["username", "password", "tenant"]

    if not has_fields(admin_info, REQUIRED_FIELDS):
        print "Please add missing admin information."
        sys.exit(1)

    username = admin_info["username"]
    password = admin_info["password"]
    tenant = admin_info["tenant"]

    (user, group) = Group.create_usergroup(username)

    try:
        new_identity = Identity.objects.get(
            provider=provider, created_by=user
        )    # FIXME: This will need to be more explicit, look for AccountProvider?
    except Identity.DoesNotExist:
        new_identity = Identity.objects.create(
            provider=provider, created_by=user, quota=Quota.default_quota()
        )
    new_identity.credential_set.get_or_create(key='key', value=username)
    new_identity.credential_set.get_or_create(key='secret', value=password)
    new_identity.credential_set.get_or_create(
        key='ex_tenant_name', value=tenant
    )
    new_identity.credential_set.get_or_create(
        key='ex_project_name', value=tenant
    )

    quota = Quota.objects.filter(**Quota.default_dict()).first()
    if not quota:
        quota = Quota.default_quota()
    # TODO: Test why we do this here and not AFTER creating AccountProvider/IdentityMembership -- Then label the rationale.
    # Necessary for save hooks -- Default project, select an identity
    user.save()

    AccountProvider.objects.get_or_create(
        provider=provider, identity=new_identity
    )
    IdentityMembership.objects.get_or_create(
        identity=new_identity, member=group
    )

    return new_identity
Example #28
0
    def login():
        '''신청 조회 / 로그인하기.'''
        if request.method == 'POST':
            logintype = request.form.get('logintype', None)
            userid = request.form.get('userid', None)
            pwd = request.form.get('pwd', None)

            if logintype == '' or logintype is None:
                flash('신청 구분을 선택해주세요')
            elif userid == '' or userid is None:
                flash('아이디를 입력해주세요')
            elif pwd == '' or pwd is None:
                flash('비밀번호를 입력해 주세요')
            else:
                campidx = Camp.get_idx(campcode)
                if logintype == '개인':
                    if Member.login_check(campidx, userid, pwd):
                        idx = db.session.query(Member).filter(Member.camp_idx == campidx,
                                                              Member.userid == userid,
                                                              Member.cancel_yn == 0).one().idx
                        session['type'] = '개인'
                        session['idx'] = idx
                        return redirect(url_for('.member_info'))
                    else:
                        flash('아이디 또는 비밀번호가 잘못되었습니다.')
                elif logintype == '단체':
                    if Group.login_check(campidx, userid, pwd):
                        idx = db.session.query(Group).filter(Group.camp_idx == campidx,
                                                             Group.groupid == userid,
                                                             Group.cancel_yn == 0).one().idx
                        session['type'] = '단체'
                        session['idx'] = idx
                        return redirect(url_for('.group_info'))
                    else:
                        flash('아이디 또는 비밀번호가 잘못되었습니다.')
            return redirect(url_for('.login'))
        return render_template('{0}/check.html'.format(campcode))
Example #29
0
def create_admin(provider, admin_info):
    REQUIRED_FIELDS = ["username", "password", "tenant"]

    if not has_fields(admin_info, REQUIRED_FIELDS):
        print "Please add missing admin information."
        sys.exit(1)

    username = admin_info["username"]
    password = admin_info["password"]
    tenant = admin_info["tenant"]

    (user, group) = Group.create_usergroup(username)

    new_identity = Identity.objects.get_or_create(provider=provider,
                                                  created_by=user)[0]
    new_identity.credential_set.get_or_create(key='key',
                                              value=username)
    new_identity.credential_set.get_or_create(key='secret',
                                              value=password)
    new_identity.credential_set.get_or_create(key='ex_tenant_name',
                                              value=tenant)
    new_identity.credential_set.get_or_create(key='ex_project_name',
                                              value=tenant)

    quota = Quota.objects.filter(**Quota.default_dict()).first()
    if not quota:
        quota = Quota.default_quota()
    # TODO: Test why we do this here and not AFTER creating AccountProvider/IdentityMembership -- Then label the rationale.
    # Necessary for save hooks -- Default project, select an identity
    user.save()

    AccountProvider.objects.get_or_create(
        provider=provider, identity=new_identity)
    IdentityMembership.objects.get_or_create(
        identity=new_identity, member=group, quota=quota)

    return new_identity
Example #30
0
    def login():
        '''신청 조회 / 로그인하기.'''
        if request.method == 'POST':
            logintype = request.form.get('logintype', None)
            userid = request.form.get('userid', None)
            pwd = request.form.get('pwd', None)

            if logintype == '' or logintype is None:
                flash('신청 구분을 선택해주세요')
            elif userid == '' or userid is None:
                flash('아이디를 입력해주세요')
            elif pwd == '' or pwd is None:
                flash('비밀번호를 입력해 주세요')
            else:
                campidx = Camp.get_idx(campcode)
                if logintype == '개인':
                    if Member.login_check(campidx, userid, pwd):
                        idx = db.session.query(Member).filter(Member.camp_idx == campidx,
                                                              Member.userid == userid,
                                                              Member.cancel_yn == 0).one().idx
                        session['type'] = '개인'
                        session['idx'] = idx
                        return redirect(url_for('.member_info'))
                    else:
                        flash('아이디 또는 비밀번호가 잘못되었습니다.')
                elif logintype == '단체':
                    if Group.login_check(campidx, userid, pwd):
                        idx = db.session.query(Group).filter(Group.camp_idx == campidx,
                                                             Group.groupid == userid,
                                                             Group.cancel_yn == 0).one().idx
                        session['type'] = '단체'
                        session['idx'] = idx
                        return redirect(url_for('.group_info'))
                    else:
                        flash('아이디 또는 비밀번호가 잘못되었습니다.')
            return redirect(url_for('.login'))
        return render_template('{0}/check.html'.format(campcode))
Example #31
0
def test(request):
    """ Заполняем тестовыми данными нашу любимую БД """
    groups = Group.objects.filter(name='ВТ-111')
    if len(groups) > 0:
        return HttpResponse('Already done')

    vt111 = Group(name='ВТ-111')
    vt112 = Group(name='ВТ-112')

    vt111.save()
    vt112.save()

    for i in range(1, 100):
        Student(name="student_number_%d" % i, login="******" % i, password="******" % i, group=vt111).save()
        Student(name="student_number_%d%d" % (i, i), login="******" % (i, i), password="******" % (i, i),
                group=vt112).save()
    for i in range(1, 10):
        Teacher(name="teacher%d" % i, login="******" % i, password='******' % i).save()

    """ чтобы хоть как-то понять что всё прошло хорошо отправим сообщение """
    return HttpResponse('Everything is ok')
    async def get_user_groups(self, task_message: GetUserGroupsMessage):
        user = User.objects.get(pk=task_message.user_pk)
        social_uid, access_token = self._get_vk_credentials(user)
        method = GroupsGetMethod(access_token=access_token,
                                 user_id=social_uid,
                                 extended=1,
                                 fields='members_count,can_post',
                                 filter='admin,editor,moder',
                                 priority=task_message.priority)
        response_dict = await method.execute()

        if VK_MESSAGE_KEY.ERROR in response_dict:
            sentry_logger.error(msg='Authorization Failed: User - {}'.format(
                user.get_full_name()))
            return False

        if not response_dict:
            sentry_logger.error(
                'No response on get_user_groups: User - {}'.format(
                    user.get_full_name()))
            return False

        response = response_dict.get(VK_MESSAGE_KEY.RESPONSE)

        if not response or len(response) < 2:
            sentry_logger.error(
                'No vk response key in get_user_groups response, {} User - {}'.
                format(response, user.get_full_name()))
            return False

        group_items = response.get(VK_MESSAGE_KEY.ITEMS)

        for group_item in group_items:
            try:
                group = Group.objects.get(group_id=group_item["id"])
            except Group.DoesNotExist:
                group = Group(group_id=group_item["id"],
                              name=group_item["name"],
                              members=group_item.get("members_count", 0))
                group.save()

            group.name = group_item[
                "name"] if group.name != group_item["name"] else group.name

            if VK_MESSAGE_KEY.DEACTIVATED in group_item:
                sentry_logger.warning(msg={
                    'group': group,
                    'reason': 'Группа забанена ВК'
                })
                continue

            try:
                group.members = group_item["members_count"] \
                    if group.members != group_item["members_count"] else group.members
            except Exception as e:
                sentry_logger.error(msg=e)
            group.is_closed = bool(group_item['is_closed']) \
                if group.is_closed != bool(group_item['is_closed']) else group.is_closed

            group.groups_img = group_item.get("photo_50") \
                if group.groups_img != group_item.get("photo_50") else group.groups_img
            group.save()

            user_group, created = UserGroup.objects.get_or_create(user=user,
                                                                  group=group)

            user_group.is_admin = bool(group_item.get('is_admin')) \
                if user_group.is_admin != bool(group_item.get('is_admin')) else user_group.is_admin

            user_group.admin_level = group_item.get('admin_level', UserGroup.ADMIN) \
                if user_group.admin_level != group_item.get('admin_level', UserGroup.ADMIN) else user_group.admin_level

            user_group.save()

        return True
Example #33
0
    def setUpClass(cls):
        super(ClientApiTest, cls).setUpClass()

        # Fill the cache with getprojectsettings response so we don't need a QGIS instance running
        # TODO: eventually move to QgsServer
        cls.prj_test = Project.objects.get(title='Un progetto')

        # new properties has to save before caching, signal on svaing project invalidate cache['django']

        cls.prj_test.thumbnail = '/fake/project.png'
        cls.prj_test.save()

        # create a group print for follow project
        cls.print_group = Group(name='Print Group',
                                title='Print Group',
                                header_logo_img='',
                                srid=cls.prj_test.group.srid)
        cls.print_group.save()

        qgis_project_file_print = File(
            open('{}/{}'.format(PROJECTS_PATH, QGS310_FILE), 'r'))
        cls.project_print310 = QgisProject(qgis_project_file_print)
        cls.project_print310.group = cls.print_group
        cls.project_print310.save()

        cache_key = settings.QDJANGO_PRJ_CACHE_KEY.format(cls.prj_test.pk)
        cache = caches['qdjango']
        cache.set(
            cache_key,
            open(
                os.path.join(
                    PROJECTS_PATH,
                    'getProjectSettings_gruppo-1_un-progetto_qgis310.xml'),
                'rb').read())

        cache_key = settings.QDJANGO_PRJ_CACHE_KEY.format(
            cls.project_print310.instance.pk)
        cache.set(
            cache_key,
            open(
                os.path.join(
                    PROJECTS_PATH,
                    'getProjectSettings_g3wsuite_project_test_qgis310.xml'),
                'rb').read())

        qgis_project_file_1 = File(
            open('{}/{}'.format(PROJECTS_PATH, QGS310_FILE_1), 'r'))
        cls.project_print310_1 = QgisProject(qgis_project_file_1)
        cls.project_print310_1.group = cls.print_group
        cls.project_print310_1.save()
        qgis_project_file_1.close()

        cls.extent_group = Group(name='Extent Group',
                                 title='Extent Group',
                                 header_logo_img='',
                                 srid=G3WSpatialRefSys.objects.get(srid=32633))
        cls.extent_group.save()
        qgis_project_file_2 = File(
            open('{}/{}'.format(PROJECTS_PATH, QGS310_FILE_2), 'r'))
        cls.project_extent310_2 = QgisProject(qgis_project_file_2)
        cls.project_extent310_2.group = cls.extent_group
        cls.project_extent310_2.save()
        qgis_project_file_2.close()

        cls.custom_order_layer_group = Group(
            name='Custom Order Layer Group',
            title='Custom Order Layer Group',
            header_logo_img='',
            srid=G3WSpatialRefSys.objects.get(srid=4326))
        cls.custom_order_layer_group.save()
        qgis_project_file_3 = File(
            open('{}/{}'.format(PROJECTS_PATH, QGS310_FILE_3), 'r'))
        cls.project_extent316_1 = QgisProject(qgis_project_file_3)
        cls.project_extent316_1.group = cls.custom_order_layer_group
        cls.project_extent316_1.save()
        qgis_project_file_3.close()

        cls.empty_vector_layer_layer_group = Group(
            name='Empty vector layer Layer Group',
            title='Empty vector layer Layer Group',
            header_logo_img='',
            srid=G3WSpatialRefSys.objects.get(srid=4326))
        cls.empty_vector_layer_layer_group.save()
        qgis_project_file_4 = File(
            open('{}/{}'.format(PROJECTS_PATH, QGS310_FILE_4), 'r'))
        cls.project_extent316_2 = QgisProject(qgis_project_file_4)
        cls.project_extent316_2.group = cls.empty_vector_layer_layer_group
        cls.project_extent316_2.save()
        qgis_project_file_4.close()
Example #34
0
    def test_group_name(self):
        group = Group()
        group.description = 'Ferramentas'
        group.save()

        self.assertEqual(group.description, str(group))
Example #35
0
def calculate_charts(user):
    # sales per campaign


    total_profit_monthly_names = []
    total_profit_monthly_values = []

    top_3_popular_products = Product.objects.filter(user=user)\
                             .annotate(bought=Count('sale'))\
                             .order_by('-bought')[:3]

    monthly_sales_of_product = [[], [], []]
    name_product = [[], [], []]

    x = 0
    for product in top_3_popular_products:
        name_product[x] = product.name
        x += 1
    x = 0

    month = datetime.datetime.now().month
    year = datetime.datetime.now().year
    i = 0
    while i < 12:
        salez = Sale.objects.filter(user=user, transaction_date__year=str(year), transaction_date__month=str(month))
        total_profit_monthly_names.append(month_translate[month])
        profits = []
        profits = [int(sale.price) for sale in salez]
        total_profit_monthly_values.append(sum(profits))

        x = 0
        for product in top_3_popular_products:
            monthly_sales_of_product[x].append(int(product.turnover_generated_in_month(month)))
            x += 1

        i += 1
        if month != 1:
            month = month - 1
        else:
            year = year - 1
            month = 12
    campaignz = Campaign.objects.filter(user=user)

    campaign_values = []
    campaign_names = []

    for sale in salez:
        campaign_values.append(sale.marketing_source.total_sales())
        campaign_names.append("%% " + str(sale.marketing_source.campaign_name))


    for campaign in campaignz:
        campaign_values.append(campaign.total_sales())
        campaign_names.append("%% " + str(campaign.campaign_name))

    group_values = []
    group_names = []

    g = Group(user)
    for id in xrange(1, 3):
        group_values.append(int(g.get_group(id)['total_turnover']))
        group_names.append("%% " + str(g.get_group(id)['name']))

    charts = {}
    if sum(campaign_values) == 0:
        charts['campaign_values'] = 0
    else:
        charts['campaign_values'] = campaign_values
    charts['campaign_names'] = SafeString(campaign_names)
    total_profit_monthly_names.reverse()
    total_profit_monthly_values.reverse()

    if sum(total_profit_monthly_values) == 0:
        charts['total_monthly_profit_values'] = 0
    else:
        charts['total_monthly_profit_values'] = SafeString(total_profit_monthly_values)
    charts['total_monthly_profit_names'] = SafeString(total_profit_monthly_names)

    if sum(group_values) == 0:
        charts['group_values'] = 0
    else:
        charts['group_values'] = group_values
    charts['group_names'] = SafeString(group_names)

    monthly_sales_of_product[0].reverse()
    monthly_sales_of_product[1].reverse()
    monthly_sales_of_product[2].reverse()

    if (sum(monthly_sales_of_product[0]) + sum(monthly_sales_of_product[1]) + sum(monthly_sales_of_product[2])) == 0:
        charts['monthly_sales_all_products'] = 0

    if name_product[0]:
        charts['name_product_one'] = SafeString(name_product[0])
    else:
        charts['name_product_one'] = ""
    if name_product[1]:
        charts['name_product_two'] = SafeString(name_product[1])
    else:
        charts['name_product_two'] = ""
    if name_product[2]:
        charts['name_product_three'] = SafeString(name_product[2])
    else:
        charts['name_product_three'] = ""

    charts['monthly_sales_product_one'] = SafeString(monthly_sales_of_product[0])
    charts['monthly_sales_product_two'] = SafeString(monthly_sales_of_product[1])
    charts['monthly_sales_product_three'] = SafeString(monthly_sales_of_product[2])
    total_growth_monthly_names = []
    total_growth_monthly_values = []
    total_map = dict()
    monthh = datetime.datetime.now().month
    yearr = datetime.datetime.now().year
    # try using timedelta and excludes on dates below.  ## TODO try to figure out the django ORM way to do below sales query
    i = 0
    total_customer_count = Customer.objects.filter(user=user).count()
    while i < 12:

        sales = Customer.objects.filter(user=user, sale__transaction_date__year=str(yearr), sale__transaction_date__month=str(monthh)).annotate(bought=Count('sale')).filter(bought__gte=1)
        #sales = Customer.objects.raw('Select * from ')
        logger.info("\n #### monthly %s %d\n" %(month_translate[monthh],yearr))
        logger.info(sales)
        total_growth_monthly_names.append(month_translate[monthh])
        growth = 0
        if sales.count()>0:
            growth = float(sales.count()/total_customer_count)
        if growth<1.0:
            total_growth_monthly_values.append(sales.count())
            total_map[month_translate[monthh]] = (sales.count(),False)

        if growth>1.0:
            total_growth_monthly_values.append(growth)
            total_map[month_translate[monthh]] = (growth,True)

        i += 1
        if monthh != 1:
            monthh -= 1
        else:
            yearr -= 1
            monthh = 12
    charts['total_growth_monthly_values'] = SafeString(total_growth_monthly_values)
    charts['total_growth_monthly_names'] = SafeString(total_growth_monthly_names)
    charts['total_growth_map'] = total_map
    logger.info(charts)
    return charts
Example #36
0
def calculate_charts(user):
    # sales per campaign

    total_profit_monthly_names = []
    total_profit_monthly_values = []

    top_3_popular_products = Product.objects.filter(user=user)\
                             .annotate(bought=Count('sale'))\
                             .order_by('-bought')[:3]

    monthly_sales_of_product = [[], [], []]
    name_product = [[], [], []]

    x = 0
    for product in top_3_popular_products:
        name_product[x] = product.name
        x += 1
    x = 0

    month = datetime.datetime.now().month
    year = datetime.datetime.now().year
    i = 0
    while i < 12:
        salez = Sale.objects.filter(user=user,
                                    transaction_date__year=str(year),
                                    transaction_date__month=str(month))
        total_profit_monthly_names.append(month_translate[month])
        profits = []
        profits = [int(sale.price) for sale in salez]
        total_profit_monthly_values.append(sum(profits))

        x = 0
        for product in top_3_popular_products:
            monthly_sales_of_product[x].append(
                int(product.turnover_generated_in_month(month)))
            x += 1

        i += 1
        if month != 1:
            month = month - 1
        else:
            year = year - 1
            month = 12
    campaignz = Campaign.objects.filter(user=user)

    campaign_values = []
    campaign_names = []

    for sale in salez:
        campaign_values.append(sale.marketing_source.total_sales())
        campaign_names.append("%% " + str(sale.marketing_source.campaign_name))

    for campaign in campaignz:
        campaign_values.append(campaign.total_sales())
        campaign_names.append("%% " + str(campaign.campaign_name))

    group_values = []
    group_names = []

    g = Group(user)
    for id in xrange(1, 3):
        group_values.append(int(g.get_group(id)['total_turnover']))
        group_names.append("%% " + str(g.get_group(id)['name']))

    charts = {}
    if sum(campaign_values) == 0:
        charts['campaign_values'] = 0
    else:
        charts['campaign_values'] = campaign_values
    charts['campaign_names'] = SafeString(campaign_names)
    total_profit_monthly_names.reverse()
    total_profit_monthly_values.reverse()

    if sum(total_profit_monthly_values) == 0:
        charts['total_monthly_profit_values'] = 0
    else:
        charts['total_monthly_profit_values'] = SafeString(
            total_profit_monthly_values)
    charts['total_monthly_profit_names'] = SafeString(
        total_profit_monthly_names)

    if sum(group_values) == 0:
        charts['group_values'] = 0
    else:
        charts['group_values'] = group_values
    charts['group_names'] = SafeString(group_names)

    monthly_sales_of_product[0].reverse()
    monthly_sales_of_product[1].reverse()
    monthly_sales_of_product[2].reverse()

    if (sum(monthly_sales_of_product[0]) + sum(monthly_sales_of_product[1]) +
            sum(monthly_sales_of_product[2])) == 0:
        charts['monthly_sales_all_products'] = 0

    if name_product[0]:
        charts['name_product_one'] = SafeString(name_product[0])
    else:
        charts['name_product_one'] = ""
    if name_product[1]:
        charts['name_product_two'] = SafeString(name_product[1])
    else:
        charts['name_product_two'] = ""
    if name_product[2]:
        charts['name_product_three'] = SafeString(name_product[2])
    else:
        charts['name_product_three'] = ""

    charts['monthly_sales_product_one'] = SafeString(
        monthly_sales_of_product[0])
    charts['monthly_sales_product_two'] = SafeString(
        monthly_sales_of_product[1])
    charts['monthly_sales_product_three'] = SafeString(
        monthly_sales_of_product[2])
    total_growth_monthly_names = []
    total_growth_monthly_values = []
    total_map = dict()
    monthh = datetime.datetime.now().month
    yearr = datetime.datetime.now().year
    # try using timedelta and excludes on dates below.  ## TODO try to figure out the django ORM way to do below sales query
    i = 0
    total_customer_count = Customer.objects.filter(user=user).count()
    while i < 12:

        sales = Customer.objects.filter(
            user=user,
            sale__transaction_date__year=str(yearr),
            sale__transaction_date__month=str(monthh)).annotate(
                bought=Count('sale')).filter(bought__gte=1)
        #sales = Customer.objects.raw('Select * from ')
        logger.info("\n #### monthly %s %d\n" %
                    (month_translate[monthh], yearr))
        logger.info(sales)
        total_growth_monthly_names.append(month_translate[monthh])
        growth = 0
        if sales.count() > 0:
            growth = float(sales.count() / total_customer_count)
        if growth < 1.0:
            total_growth_monthly_values.append(sales.count())
            total_map[month_translate[monthh]] = (sales.count(), False)

        if growth > 1.0:
            total_growth_monthly_values.append(growth)
            total_map[month_translate[monthh]] = (growth, True)

        i += 1
        if monthh != 1:
            monthh -= 1
        else:
            yearr -= 1
            monthh = 12
    charts['total_growth_monthly_values'] = SafeString(
        total_growth_monthly_values)
    charts['total_growth_monthly_names'] = SafeString(
        total_growth_monthly_names)
    charts['total_growth_map'] = total_map
    logger.info(charts)
    return charts
Example #37
0
    def create_identity(cls, username, provider_location,
                        quota=None,
                        max_quota=False, account_admin=False, **kwarg_creds):
        """
        Create new User/Group & Identity for given provider_location
        NOTES:
        * kwargs prefixed with 'cred_' will be collected as credentials
        * Can assign optional flags:
          + max_quota - Assign the highest quota available, rather than
            default.
          + account_admin - Private Clouds only - This user should have ALL
            permissions including:
              * Image creation (Glance)
              * Account creation (Keystone)
              * Access to ALL instances launched over ALL users

          Atmosphere will run fine without an account_admin, but the above
          features will be disabled.
        """
        # Do not move up. ImportError.
        from core.models import Group, Credential, Quota,\
            Provider, AccountProvider, Allocation,\
            IdentityMembership

        provider = Provider.objects.get(location__iexact=provider_location)

        credentials = {}
        for (c_key, c_value) in kwarg_creds.items():
            if 'cred_' not in c_key.lower():
                continue
            c_key = c_key.replace('cred_', '')
            credentials[c_key] = c_value

        (user, group) = Group.create_usergroup(username)

        # NOTE: This specific query will need to be modified if we want
        # 2+ Identities on a single provider

        id_membership = IdentityMembership.objects.filter(
            member__name=user.username,
            identity__provider=provider,
            identity__created_by__username=user.username)
        if not id_membership:
            default_allocation = Allocation.default_allocation()
            # 1. Create an Identity Membership
            # DEV NOTE: I have a feeling that THIS line will mean
            #          creating a secondary identity for a user on a given
            #          provider will be difficult. We need to find a better
            #          workflow here..
            try:
                identity = Identity.objects.get(created_by=user,
                                                provider=provider)
            except Identity.DoesNotExist:
                new_uuid = uuid4()
                identity = Identity.objects.create(
                    created_by=user,
                    provider=provider,
                    uuid=str(new_uuid))
            id_membership = IdentityMembership.objects.get_or_create(
                identity=identity,
                member=group,
                allocation=default_allocation,
                quota=Quota.default_quota())
        # Either first in list OR object from two-tuple.. Its what we need.
        id_membership = id_membership[0]

        # ID_Membership exists.

        # 2. Make sure that all kwargs exist as credentials
        # NOTE: Because we assume only one identity per provider
        #       We can add new credentials to
        #       existing identities if missing..
        # In the future it will be hard to determine when we want to
        # update values on an identity Vs. create a second, new
        # identity.
        for (c_key, c_value) in credentials.items():
            test_key_exists = Credential.objects.filter(
                identity=id_membership.identity,
                key=c_key)
            if test_key_exists:
                logger.info("Conflicting Key Error: Key:%s Value:%s "
                            "Replacement:%s" %
                            (c_key, c_value, test_key_exists[0].value))
                # No Dupes... But should we really throw an Exception here?
                continue
            Credential.objects.get_or_create(
                identity=id_membership.identity,
                key=c_key,
                value=c_value)[0]
        # 3. Assign a different quota, if requested
        if quota:
            id_membership.quota = quota
            id_membership.allocation = None
            id_membership.save()
        elif max_quota:
            quota = Quota.max_quota()
            id_membership.quota = quota
            id_membership.allocation = None
            id_membership.save()
        if account_admin:
            admin = AccountProvider.objects.get_or_create(
                provider=id_membership.identity.provider,
                identity=id_membership.identity)[0]

        # 5. Save the user to activate profile on first-time use
        user.save()
        # Return the identity
        return id_membership.identity
Example #38
0
    def create_identity(cls,
                        username,
                        provider_location,
                        quota=None,
                        max_quota=False,
                        account_admin=False,
                        **kwarg_creds):
        """
        Create new User/Group & Identity for given provider_location
        NOTES:
        * kwargs prefixed with 'cred_' will be collected as credentials
        * Can assign optional flags:
          + max_quota - Assign the highest quota available, rather than
            default.
          + account_admin - Private Clouds only - This user should have ALL
            permissions including:
              * Image creation (Glance)
              * Account creation (Keystone)
              * Access to ALL instances launched over ALL users

          Atmosphere will run fine without an account_admin, but the above
          features will be disabled.
        """
        #Do not move up. ImportError.
        from core.models import Group, Credential, Quota,\
            Provider, AccountProvider, Allocation,\
            IdentityMembership

        provider = Provider.objects.get(location__iexact=provider_location)

        credentials = {}
        for (c_key, c_value) in kwarg_creds.items():
            if 'cred_' not in c_key.lower():
                continue
            c_key = c_key.replace('cred_', '')
            credentials[c_key] = c_value

        (user, group) = Group.create_usergroup(username)

        #NOTE: This specific query will need to be modified if we want
        # 2+ Identities on a single provider

        id_membership = IdentityMembership.objects.filter(
            member__name=user.username,
            identity__provider=provider,
            identity__created_by__username=user.username)
        if not id_membership:
            default_allocation = Allocation.default_allocation()
            #1. Create an Identity Membership
            #DEV NOTE: I have a feeling that THIS line will mean
            #          creating a secondary identity for a user on a given
            #          provider will be difficult. We need to find a better
            #          workflow here..
            try:
                identity = Identity.objects.get(created_by=user,
                                                provider=provider)
            except Identity.DoesNotExist:
                new_uuid = uuid4()
                identity = Identity.objects.create(created_by=user,
                                                   provider=provider,
                                                   uuid=str(new_uuid))
            #Two-tuple, (Object, created)
            id_membership = IdentityMembership.objects.get_or_create(
                identity=identity,
                member=group,
                allocation=default_allocation,
                quota=Quota.default_quota())
        #Either first in list OR object from two-tuple.. Its what we need.
        id_membership = id_membership[0]

        #ID_Membership exists.

        #2. Make sure that all kwargs exist as credentials
        # NOTE: Because we assume only one identity per provider
        #       We can add new credentials to
        #       existing identities if missing..
        # In the future it will be hard to determine when we want to
        # update values on an identity Vs. create a second, new
        # identity.
        for (c_key, c_value) in credentials.items():
            test_key_exists = Credential.objects.filter(
                identity=id_membership.identity, key=c_key)
            if test_key_exists:
                logger.info("Conflicting Key Error: Key:%s Value:%s "
                            "Replacement:%s" %
                            (c_key, c_value, test_key_exists[0].value))
                #No Dupes... But should we really throw an Exception here?
                continue
            Credential.objects.get_or_create(identity=id_membership.identity,
                                             key=c_key,
                                             value=c_value)[0]
        #3. Assign a different quota, if requested
        if quota:
            id_membership.quota = quota
            id_membership.allocation = None
            id_membership.save()
        elif max_quota:
            quota = Quota.max_quota()
            id_membership.quota = quota
            id_membership.allocation = None
            id_membership.save()
        if account_admin:
            admin = AccountProvider.objects.get_or_create(
                provider=id_membership.identity.provider,
                identity=id_membership.identity)[0]

        #5. Save the user to activate profile on first-time use
        user.save()
        #Return the identity
        return id_membership.identity
Example #39
0
File: group.py Project: vodaka/cmdb
def create(name, t):
    g = Group()
    g.name = name
    g.type = t
    g.save()
    return g.id
Example #40
0
    def handle(self, *args, **options):
        os.environ["DJANGO_COLORS"] = "nocolor"
        Site(id=4000, domain=settings.SITH_URL, name=settings.SITH_NAME).save()
        root_path = os.path.dirname(
            os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
        Group(name="Root").save()
        Group(name="Public").save()
        Group(name="Subscribers").save()
        Group(name="Old subscribers").save()
        Group(name="Accounting admin").save()
        Group(name="Communication admin").save()
        Group(name="Counter admin").save()
        Group(name="Banned from buying alcohol").save()
        Group(name="Banned from counters").save()
        Group(name="Banned to subscribe").save()
        Group(name="SAS admin").save()
        Group(name="Forum admin").save()
        Group(name="Pedagogy admin").save()
        self.reset_index("core", "auth")
        root = User(
            id=0,
            username="******",
            last_name="",
            first_name="Bibou",
            email="*****@*****.**",
            date_of_birth="1942-06-12",
            is_superuser=True,
            is_staff=True,
        )
        root.set_password("plop")
        root.save()
        profiles_root = SithFile(parent=None,
                                 name="profiles",
                                 is_folder=True,
                                 owner=root)
        profiles_root.save()
        home_root = SithFile(parent=None,
                             name="users",
                             is_folder=True,
                             owner=root)
        home_root.save()

        # Page needed for club creation
        p = Page(name=settings.SITH_CLUB_ROOT_PAGE)
        p.set_lock(root)
        p.save()

        club_root = SithFile(parent=None,
                             name="clubs",
                             is_folder=True,
                             owner=root)
        club_root.save()
        SithFile(parent=None, name="SAS", is_folder=True, owner=root).save()
        main_club = Club(
            id=1,
            name=settings.SITH_MAIN_CLUB["name"],
            unix_name=settings.SITH_MAIN_CLUB["unix_name"],
            address=settings.SITH_MAIN_CLUB["address"],
        )
        main_club.save()
        bar_club = Club(
            id=2,
            name=settings.SITH_BAR_MANAGER["name"],
            unix_name=settings.SITH_BAR_MANAGER["unix_name"],
            address=settings.SITH_BAR_MANAGER["address"],
        )
        bar_club.save()
        launderette_club = Club(
            id=84,
            name=settings.SITH_LAUNDERETTE_MANAGER["name"],
            unix_name=settings.SITH_LAUNDERETTE_MANAGER["unix_name"],
            address=settings.SITH_LAUNDERETTE_MANAGER["address"],
        )

        launderette_club.save()
        self.reset_index("club")
        for b in settings.SITH_COUNTER_BARS:
            g = Group(name=b[1] + " admin")
            g.save()
            c = Counter(id=b[0], name=b[1], club=bar_club, type="BAR")
            c.save()
            g.editable_counters.add(c)
            g.save()
        self.reset_index("counter")
        Counter(name="Eboutic", club=main_club, type="EBOUTIC").save()
        Counter(name="AE", club=main_club, type="OFFICE").save()

        home_root.view_groups.set([
            Group.objects.filter(
                name=settings.SITH_MAIN_MEMBERS_GROUP).first()
        ])
        club_root.view_groups.set([
            Group.objects.filter(
                name=settings.SITH_MAIN_MEMBERS_GROUP).first()
        ])
        home_root.save()
        club_root.save()

        Sith(weekmail_destinations="[email protected] [email protected]").save()
        Weekmail().save()

        p = Page(name="Index")
        p.set_lock(root)
        p.save()
        p.view_groups.set([settings.SITH_GROUP_PUBLIC_ID])
        p.set_lock(root)
        p.save()
        PageRev(
            page=p,
            title="Wiki index",
            author=root,
            content="""
Welcome to the wiki page!
""",
        ).save()

        p = Page(name="services")
        p.set_lock(root)
        p.save()
        p.view_groups.set([settings.SITH_GROUP_PUBLIC_ID])
        p.set_lock(root)
        PageRev(
            page=p,
            title="Services",
            author=root,
            content="""
|   |   |   |
| :---: | :---: | :---: | :---: |
| [Eboutic](/eboutic) | [Laverie](/launderette) | Matmat | [Fichiers](/file) |
| SAS | Weekmail | Forum | |

""",
        ).save()

        p = Page(name="launderette")
        p.set_lock(root)
        p.save()
        p.set_lock(root)
        PageRev(page=p,
                title="Laverie",
                author=root,
                content="Fonctionnement de la laverie").save()

        # Here we add a lot of test datas, that are not necessary for the Sith, but that provide a basic development environment
        if not options["prod"]:
            # Adding user Skia
            skia = User(
                username="******",
                last_name="Kia",
                first_name="S'",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
            )
            skia.set_password("plop")
            skia.save()
            skia.view_groups = [
                Group.objects.filter(
                    name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
            ]
            skia.save()
            skia_profile_path = os.path.join(root_path,
                                             "core/fixtures/images/3.jpg")
            with open(skia_profile_path, "rb") as f:
                name = str(skia.id) + "_profile.jpg"
                skia_profile = SithFile(
                    parent=profiles_root,
                    name=name,
                    file=resize_image(Image.open(BytesIO(f.read())), 400,
                                      "JPEG"),
                    owner=skia,
                    is_folder=False,
                    mime_type="image/jpeg",
                    size=os.path.getsize(skia_profile_path),
                )
                skia_profile.file.name = name
                skia_profile.save()
                skia.profile_pict = skia_profile
                skia.save()

            # Adding user public
            public = User(
                username="******",
                last_name="Not subscribed",
                first_name="Public",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
                is_superuser=False,
                is_staff=False,
            )
            public.set_password("plop")
            public.save()
            public.view_groups = [
                Group.objects.filter(
                    name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
            ]
            public.save()
            # Adding user Subscriber
            subscriber = User(
                username="******",
                last_name="User",
                first_name="Subscribed",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
                is_superuser=False,
                is_staff=False,
            )
            subscriber.set_password("plop")
            subscriber.save()
            subscriber.view_groups = [
                Group.objects.filter(
                    name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
            ]
            subscriber.save()
            # Adding user old Subscriber
            old_subscriber = User(
                username="******",
                last_name="Subscriber",
                first_name="Old",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
                is_superuser=False,
                is_staff=False,
            )
            old_subscriber.set_password("plop")
            old_subscriber.save()
            old_subscriber.view_groups = [
                Group.objects.filter(
                    name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
            ]
            old_subscriber.save()
            # Adding user Counter admin
            counter = User(
                username="******",
                last_name="Ter",
                first_name="Coun",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
                is_superuser=False,
                is_staff=False,
            )
            counter.set_password("plop")
            counter.save()
            counter.view_groups = [
                Group.objects.filter(
                    name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
            ]
            counter.groups.set([
                Group.objects.filter(
                    id=settings.SITH_GROUP_COUNTER_ADMIN_ID).first().id
            ])
            counter.save()
            # Adding user Comptable
            comptable = User(
                username="******",
                last_name="Able",
                first_name="Compte",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
                is_superuser=False,
                is_staff=False,
            )
            comptable.set_password("plop")
            comptable.save()
            comptable.view_groups = [
                Group.objects.filter(
                    name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
            ]
            comptable.groups.set([
                Group.objects.filter(
                    id=settings.SITH_GROUP_ACCOUNTING_ADMIN_ID).first().id
            ])
            comptable.save()
            # Adding user Guy
            u = User(
                username="******",
                last_name="Carlier",
                first_name="Guy",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
                is_superuser=False,
                is_staff=False,
            )
            u.set_password("plop")
            u.save()
            u.view_groups = [
                Group.objects.filter(
                    name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
            ]
            u.save()
            # Adding user Richard Batsbak
            r = User(
                username="******",
                last_name="Batsbak",
                first_name="Richard",
                email="*****@*****.**",
                date_of_birth="1982-06-12",
            )
            r.set_password("plop")
            r.save()
            r.view_groups = [
                Group.objects.filter(
                    name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
            ]
            r.save()
            # Adding syntax help page
            p = Page(name="Aide_sur_la_syntaxe")
            p.save(force_lock=True)
            with open(os.path.join(root_path) + "/doc/SYNTAX.md", "r") as rm:
                PageRev(page=p,
                        title="Aide sur la syntaxe",
                        author=skia,
                        content=rm.read()).save()
            p.view_groups.set([settings.SITH_GROUP_PUBLIC_ID])
            p.save(force_lock=True)
            p = Page(name="Services")
            p.save(force_lock=True)
            p.view_groups.set([settings.SITH_GROUP_PUBLIC_ID])
            p.save(force_lock=True)
            PageRev(
                page=p,
                title="Services",
                author=skia,
                content="""
|   |   |   |
| :---: | :---: | :---: |
| [Eboutic](/eboutic) | [Laverie](/launderette) | Matmat |
| SAS | Weekmail | Forum|

""",
            ).save()

            # Subscription
            default_subscription = "un-semestre"
            # Root
            s = Subscription(
                member=User.objects.filter(pk=root.pk).first(),
                subscription_type=default_subscription,
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()
            # Skia
            s = Subscription(
                member=User.objects.filter(pk=skia.pk).first(),
                subscription_type=default_subscription,
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()
            # Counter admin
            s = Subscription(
                member=User.objects.filter(pk=counter.pk).first(),
                subscription_type=default_subscription,
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()
            # Comptable
            s = Subscription(
                member=User.objects.filter(pk=comptable.pk).first(),
                subscription_type=default_subscription,
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()
            # Richard
            s = Subscription(
                member=User.objects.filter(pk=r.pk).first(),
                subscription_type=default_subscription,
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()
            # User
            s = Subscription(
                member=User.objects.filter(pk=subscriber.pk).first(),
                subscription_type=default_subscription,
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()
            # Old subscriber
            s = Subscription(
                member=User.objects.filter(pk=old_subscriber.pk).first(),
                subscription_type=default_subscription,
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start(
                datetime(year=2012, month=9, day=4))
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()

            # Clubs
            Club(
                name="Bibo'UT",
                unix_name="bibout",
                address="46 de la Boustifaille",
                parent=main_club,
            ).save()
            guyut = Club(
                name="Guy'UT",
                unix_name="guyut",
                address="42 de la Boustifaille",
                parent=main_club,
            )
            guyut.save()
            Club(name="Woenzel'UT",
                 unix_name="woenzel",
                 address="Woenzel",
                 parent=guyut).save()
            Membership(user=skia, club=main_club, role=3,
                       description="").save()
            troll = Club(
                name="Troll Penché",
                unix_name="troll",
                address="Terre Du Milieu",
                parent=main_club,
            )
            troll.save()
            refound = Club(
                name="Carte AE",
                unix_name="carte_ae",
                address="Jamais imprimée",
                parent=main_club,
            )
            refound.save()

            # Counters
            Customer(user=skia, account_id="6568j", amount=0).save()
            Customer(user=r, account_id="4000k", amount=0).save()
            p = ProductType(name="Bières bouteilles")
            p.save()
            c = ProductType(name="Cotisations")
            c.save()
            r = ProductType(name="Rechargements")
            r.save()
            verre = ProductType(name="Verre")
            verre.save()
            cotis = Product(
                name="Cotis 1 semestre",
                code="1SCOTIZ",
                product_type=c,
                purchase_price="15",
                selling_price="15",
                special_selling_price="15",
                club=main_club,
            )
            cotis.save()
            cotis2 = Product(
                name="Cotis 2 semestres",
                code="2SCOTIZ",
                product_type=c,
                purchase_price="28",
                selling_price="28",
                special_selling_price="28",
                club=main_club,
            )
            cotis2.save()
            refill = Product(
                name="Rechargement 15 €",
                code="15REFILL",
                product_type=r,
                purchase_price="15",
                selling_price="15",
                special_selling_price="15",
                club=main_club,
            )
            refill.save()
            barb = Product(
                name="Barbar",
                code="BARB",
                product_type=p,
                purchase_price="1.50",
                selling_price="1.7",
                special_selling_price="1.6",
                club=main_club,
            )
            barb.save()
            cble = Product(
                name="Chimay Bleue",
                code="CBLE",
                product_type=p,
                purchase_price="1.50",
                selling_price="1.7",
                special_selling_price="1.6",
                club=main_club,
            )
            cble.save()
            cons = Product(
                name="Consigne Eco-cup",
                code="CONS",
                product_type=verre,
                purchase_price="1",
                selling_price="1",
                special_selling_price="1",
                club=main_club,
            )
            cons.id = 1152
            cons.save()
            dcons = Product(
                name="Déconsigne Eco-cup",
                code="DECO",
                product_type=verre,
                purchase_price="-1",
                selling_price="-1",
                special_selling_price="-1",
                club=main_club,
            )
            dcons.id = 1151
            dcons.save()
            Product(
                name="Corsendonk",
                code="CORS",
                product_type=p,
                purchase_price="1.50",
                selling_price="1.7",
                special_selling_price="1.6",
                club=main_club,
            ).save()
            Product(
                name="Carolus",
                code="CARO",
                product_type=p,
                purchase_price="1.50",
                selling_price="1.7",
                special_selling_price="1.6",
                club=main_club,
            ).save()
            mde = Counter.objects.filter(name="MDE").first()
            mde.products.add(barb)
            mde.products.add(cble)
            mde.products.add(cons)
            mde.products.add(dcons)
            mde.sellers.add(skia)
            mde.save()

            eboutic = Counter.objects.filter(name="Eboutic").first()
            eboutic.products.add(barb)
            eboutic.products.add(cotis)
            eboutic.products.add(cotis2)
            eboutic.products.add(refill)
            eboutic.save()

            refound_counter = Counter(name="Carte AE",
                                      club=refound,
                                      type="OFFICE")
            refound_counter.save()
            refound_product = Product(
                name="remboursement",
                code="REMBOURS",
                purchase_price="0",
                selling_price="0",
                special_selling_price="0",
                club=refound,
            )
            refound_product.save()

            # Accounting test values:
            BankAccount(name="AE TG", club=main_club).save()
            BankAccount(name="Carte AE", club=main_club).save()
            ba = BankAccount(name="AE TI", club=main_club)
            ba.save()
            ca = ClubAccount(name="Troll Penché", bank_account=ba, club=troll)
            ca.save()
            gj = GeneralJournal(name="A16",
                                start_date=date.today(),
                                club_account=ca)
            gj.save()
            credit = AccountingType(code="74",
                                    label="Subventions d'exploitation",
                                    movement_type="CREDIT")
            credit.save()
            debit = AccountingType(
                code="606",
                label="Achats non stockés de matières et fournitures(*1)",
                movement_type="DEBIT",
            )
            debit.save()
            debit2 = AccountingType(
                code="604",
                label="Achats d'études et prestations de services(*2)",
                movement_type="DEBIT",
            )
            debit2.save()
            buying = AccountingType(code="60",
                                    label="Achats (sauf 603)",
                                    movement_type="DEBIT")
            buying.save()
            comptes = AccountingType(code="6",
                                     label="Comptes de charge",
                                     movement_type="DEBIT")
            comptes.save()
            simple = SimplifiedAccountingType(label="Je fais du simple 6",
                                              accounting_type=comptes)
            simple.save()
            woenzco = Company(name="Woenzel & co")
            woenzco.save()

            operation_list = [
                (
                    27,
                    "J'avais trop de bière",
                    "CASH",
                    None,
                    buying,
                    "USER",
                    skia.id,
                    "",
                    None,
                ),
                (
                    4000,
                    "Ceci n'est pas une opération... en fait si mais non",
                    "CHECK",
                    None,
                    debit,
                    "COMPANY",
                    woenzco.id,
                    "",
                    23,
                ),
                (
                    22,
                    "C'est de l'argent ?",
                    "CARD",
                    None,
                    credit,
                    "CLUB",
                    troll.id,
                    "",
                    None,
                ),
                (
                    37,
                    "Je paye CASH",
                    "CASH",
                    None,
                    debit2,
                    "OTHER",
                    None,
                    "tous les étudiants <3",
                    None,
                ),
                (300, "Paiement Guy", "CASH", None, buying, "USER", skia.id,
                 "", None),
                (32.3, "Essence", "CASH", None, buying, "OTHER", None,
                 "station", None),
                (
                    46.42,
                    "Allumette",
                    "CHECK",
                    None,
                    credit,
                    "CLUB",
                    main_club.id,
                    "",
                    57,
                ),
                (
                    666.42,
                    "Subvention de far far away",
                    "CASH",
                    None,
                    comptes,
                    "CLUB",
                    main_club.id,
                    "",
                    None,
                ),
                (
                    496,
                    "Ça, c'est un 6",
                    "CARD",
                    simple,
                    None,
                    "USER",
                    skia.id,
                    "",
                    None,
                ),
                (
                    17,
                    "La Gargotte du Korrigan",
                    "CASH",
                    None,
                    debit2,
                    "CLUB",
                    bar_club.id,
                    "",
                    None,
                ),
            ]
            for op in operation_list:
                operation = Operation(
                    journal=gj,
                    date=date.today(),
                    amount=op[0],
                    remark=op[1],
                    mode=op[2],
                    done=True,
                    simpleaccounting_type=op[3],
                    accounting_type=op[4],
                    target_type=op[5],
                    target_id=op[6],
                    target_label=op[7],
                    cheque_number=op[8],
                )
                operation.clean()
                operation.save()

            # Adding user sli
            sli = User(
                username="******",
                last_name="Li",
                first_name="S",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
            )
            sli.set_password("plop")
            sli.save()
            sli.view_groups = [
                Group.objects.filter(
                    name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
            ]
            sli.save()
            sli_profile_path = os.path.join(root_path,
                                            "core/fixtures/images/5.jpg")
            with open(sli_profile_path, "rb") as f:
                name = str(sli.id) + "_profile.jpg"
                sli_profile = SithFile(
                    parent=profiles_root,
                    name=name,
                    file=resize_image(Image.open(BytesIO(f.read())), 400,
                                      "JPEG"),
                    owner=sli,
                    is_folder=False,
                    mime_type="image/jpeg",
                    size=os.path.getsize(sli_profile_path),
                )
                sli_profile.file.name = name
                sli_profile.save()
                sli.profile_pict = sli_profile
                sli.save()
            # Adding user Krophil
            krophil = User(
                username="******",
                last_name="Phil'",
                first_name="Kro",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
            )
            krophil.set_password("plop")
            krophil.save()
            krophil_profile_path = os.path.join(root_path,
                                                "core/fixtures/images/6.jpg")
            with open(krophil_profile_path, "rb") as f:
                name = str(krophil.id) + "_profile.jpg"
                krophil_profile = SithFile(
                    parent=profiles_root,
                    name=name,
                    file=resize_image(Image.open(BytesIO(f.read())), 400,
                                      "JPEG"),
                    owner=krophil,
                    is_folder=False,
                    mime_type="image/jpeg",
                    size=os.path.getsize(krophil_profile_path),
                )
                krophil_profile.file.name = name
                krophil_profile.save()
                krophil.profile_pict = krophil_profile
                krophil.save()
            # Adding user Com Unity
            comunity = User(
                username="******",
                last_name="Unity",
                first_name="Com",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
            )
            comunity.set_password("plop")
            comunity.save()
            comunity.groups.set(
                [Group.objects.filter(name="Communication admin").first().id])
            comunity.save()
            Membership(
                user=comunity,
                club=bar_club,
                start_date=timezone.now(),
                role=settings.SITH_CLUB_ROLES_ID["Board member"],
            ).save()
            # Adding user tutu
            tutu = User(
                username="******",
                last_name="Tu",
                first_name="Tu",
                email="*****@*****.**",
                date_of_birth="1942-06-12",
            )
            tutu.set_password("plop")
            tutu.save()
            tutu.groups.set([settings.SITH_GROUP_PEDAGOGY_ADMIN_ID])
            tutu.save()

            # Adding subscription for sli
            s = Subscription(
                member=User.objects.filter(pk=sli.pk).first(),
                subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[0],
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()
            StudentCard(uid="9A89B82018B0A0", customer=sli.customer).save()
            # Adding subscription for Krophil
            s = Subscription(
                member=User.objects.filter(pk=krophil.pk).first(),
                subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[0],
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()
            # Com Unity
            s = Subscription(
                member=comunity,
                subscription_type=default_subscription,
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()
            # Tutu
            s = Subscription(
                member=tutu,
                subscription_type=default_subscription,
                payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
            )
            s.subscription_start = s.compute_start()
            s.subscription_end = s.compute_end(
                duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
                ["duration"],
                start=s.subscription_start,
            )
            s.save()

            Selling(
                label=dcons.name,
                product=dcons,
                counter=mde,
                unit_price=dcons.selling_price,
                club=main_club,
                quantity=settings.SITH_ECOCUP_LIMIT + 3,
                seller=skia,
                customer=krophil.customer,
            ).save()

            # Add barman to counter
            c = Counter.objects.get(id=2)
            c.sellers.add(User.objects.get(pk=krophil.pk))
            c.save()

            # Create an election
            public_group = Group.objects.get(id=settings.SITH_GROUP_PUBLIC_ID)
            subscriber_group = Group.objects.get(
                name=settings.SITH_MAIN_MEMBERS_GROUP)
            ae_board_group = Group.objects.get(
                name=settings.SITH_MAIN_BOARD_GROUP)
            el = Election(
                title="Élection 2017",
                description="La roue tourne",
                start_candidature="1942-06-12 10:28:45+01",
                end_candidature="2042-06-12 10:28:45+01",
                start_date="1942-06-12 10:28:45+01",
                end_date="7942-06-12 10:28:45+01",
            )
            el.save()
            el.view_groups.add(public_group)
            el.edit_groups.add(ae_board_group)
            el.candidature_groups.add(subscriber_group)
            el.vote_groups.add(subscriber_group)
            el.save()
            liste = ElectionList(title="Candidature Libre", election=el)
            liste.save()
            listeT = ElectionList(title="Troll", election=el)
            listeT.save()
            pres = Role(election=el,
                        title="Président AE",
                        description="Roi de l'AE")
            pres.save()
            resp = Role(election=el,
                        title="Co Respo Info",
                        max_choice=2,
                        description="Ghetto++")
            resp.save()
            cand = Candidature(role=resp,
                               user=skia,
                               election_list=liste,
                               program="Refesons le site AE")
            cand.save()
            cand = Candidature(
                role=resp,
                user=sli,
                election_list=liste,
                program="Vasy je deviens mon propre adjoint",
            )
            cand.save()
            cand = Candidature(role=resp,
                               user=krophil,
                               election_list=listeT,
                               program="Le Pôle Troll !")
            cand.save()
            cand = Candidature(
                role=pres,
                user=sli,
                election_list=listeT,
                program="En fait j'aime pas l'info, je voulais faire GMC",
            )
            cand.save()

            # Forum
            room = Forum(
                name="Salon de discussions",
                description="Pour causer de tout",
                is_category=True,
            )
            room.save()
            Forum(name="AE", description="Réservé au bureau AE",
                  parent=room).save()
            Forum(name="BdF", description="Réservé au bureau BdF",
                  parent=room).save()
            hall = Forum(
                name="Hall de discussions",
                description="Pour toutes les discussions",
                parent=room,
            )
            hall.save()
            various = Forum(name="Divers",
                            description="Pour causer de rien",
                            is_category=True)
            various.save()
            Forum(name="Promos",
                  description="Réservé aux Promos",
                  parent=various).save()
            ForumTopic(forum=hall)

            # News
            friday = timezone.now()
            while friday.weekday() != 4:
                friday += timedelta(hours=6)
            friday.replace(hour=20, minute=0, second=0)
            # Event
            n = News(
                title="Apero barman",
                summary="Viens boire un coup avec les barmans",
                content="Glou glou glou glou glou glou glou",
                type="EVENT",
                club=bar_club,
                author=subscriber,
                is_moderated=True,
                moderator=skia,
            )
            n.save()
            NewsDate(
                news=n,
                start_date=timezone.now() + timedelta(hours=70),
                end_date=timezone.now() + timedelta(hours=72),
            ).save()
            n = News(
                title="Repas barman",
                summary="Enjoy la fin du semestre!",
                content="Viens donc t'enjailler avec les autres barmans aux "
                "frais du BdF! \o/",
                type="EVENT",
                club=bar_club,
                author=subscriber,
                is_moderated=True,
                moderator=skia,
            )
            n.save()
            NewsDate(
                news=n,
                start_date=timezone.now() + timedelta(hours=72),
                end_date=timezone.now() + timedelta(hours=84),
            ).save()
            n = News(
                title="Repas fromager",
                summary="Wien manger du l'bon fromeug'",
                content="Fô viendre mangey d'la bonne fondue!",
                type="EVENT",
                club=bar_club,
                author=subscriber,
                is_moderated=True,
                moderator=skia,
            )
            n.save()
            NewsDate(
                news=n,
                start_date=timezone.now() + timedelta(hours=96),
                end_date=timezone.now() + timedelta(hours=100),
            ).save()
            n = News(
                title="SdF",
                summary="Enjoy la fin des finaux!",
                content="Viens faire la fête avec tout plein de gens!",
                type="EVENT",
                club=bar_club,
                author=subscriber,
                is_moderated=True,
                moderator=skia,
            )
            n.save()
            NewsDate(
                news=n,
                start_date=friday + timedelta(hours=24 * 7 + 1),
                end_date=timezone.now() + timedelta(hours=24 * 7 + 9),
            ).save()
            # Weekly
            n = News(
                title="Jeux sans faim",
                summary="Viens jouer!",
                content="Rejoins la fine équipe du Troll Penché et viens "
                "d'amuser le Vendredi soir!",
                type="WEEKLY",
                club=troll,
                author=subscriber,
                is_moderated=True,
                moderator=skia,
            )
            n.save()
            for i in range(10):
                NewsDate(
                    news=n,
                    start_date=friday + timedelta(hours=24 * 7 * i),
                    end_date=friday + timedelta(hours=24 * 7 * i + 8),
                ).save()

            # Create som data for pedagogy

            UV(
                code="PA00",
                author=User.objects.get(id=0),
                credit_type=settings.SITH_PEDAGOGY_UV_TYPE[3][0],
                manager="Laurent HEYBERGER",
                semester=settings.SITH_PEDAGOGY_UV_SEMESTER[3][0],
                language=settings.SITH_PEDAGOGY_UV_LANGUAGE[0][0],
                department=settings.SITH_PROFILE_DEPARTMENTS[-2][0],
                credits=5,
                title="Participation dans une association étudiante",
                objectives=
                "* Permettre aux étudiants de réaliser, pendant un semestre, un projet culturel ou associatif et de le valoriser.",
                program=
                """* Semestre précédent proposition d'un projet et d'un cahier des charges
* Evaluation par un jury de six membres
* Si accord réalisation dans le cadre de l'UV
* Compte-rendu de l'expérience
* Présentation""",
                skills=
                """* Gérer un projet associatif ou une action éducative en autonomie:
* en produisant un cahier des charges qui -définit clairement le contexte du projet personnel -pose les jalons de ce projet -estime de manière réaliste les moyens et objectifs du projet -définit exactement les livrables attendus
    * en étant capable de respecter ce cahier des charges ou, le cas échéant, de réviser le cahier des charges de manière argumentée.
* Relater son expérience dans un rapport:
* qui permettra à d'autres étudiants de poursuivre les actions engagées
* qui montre la capacité à s'auto-évaluer et à adopter une distance critique sur son action.""",
                key_concepts="""* Autonomie
* Responsabilité
* Cahier des charges
* Gestion de projet""",
                hours_THE=121,
                hours_TE=4,
            ).save()
Example #41
0
def group_list_and_create(request):
    '''
    group_list_and_create
    '''
    if request.method == 'GET':
        # check if user is logged_in
        if not request.user.is_authenticated:
            return HttpResponse(status=401)

        response_list = []
        group_list = [
            group for group in Group.objects.all()
            if group.user == request.user
        ]

        for group in group_list:
            # Make stock list
            response_stock_list = []

            stock_list = group.stocks.all()

            for stock in stock_list:
                fs_stock = FinancialStat.objects.filter(stock_id=stock.id)
                fs_score = get_fs_info(stock, fs_stock)
                stock_info_dict = {
                    'id': stock.id,
                    'title': stock.title,
                    'code': stock.code,
                    'sector': stock.sector,
                    'price': stock.price,
                    'highestPrice': stock.highestPrice,
                    'lowestPrice': stock.lowestPrice,
                    'tradeVolume': stock.tradeVolume,
                    'tradeValue': stock.tradeValue,
                    'startPrice': stock.startPrice,
                    'yesterdayPrice': stock.yesterdayPrice,
                    'amount': stock.amount,
                    'isKOSPI': stock.isKOSPI,
                    'score': stock.score,
                    'fs_score': fs_score,
                }
                response_stock_list.append(stock_info_dict)

            response_dict = {
                'id': group.id,
                'user': group.user.email,
                'name': group.name,
                'stocks': response_stock_list,
            }
            response_list.append(response_dict)

        return JsonResponse(response_list, safe=False)

    if request.method == 'POST':
        # check if user is logged_in
        if not request.user.is_authenticated:
            return HttpResponse(status=401)

        try:
            body = request.body.decode()
            name = json.loads(body)['name']
            user = request.user
        except (KeyError, JSONDecodeError):
            return HttpResponseBadRequest()

        group = Group(user=user, name=name)
        group.save()

        response_dict = {
            'id': group.id,
            'user': group.user.email,
            'name': group.name
        }
        return HttpResponse(content=json.dumps(response_dict), status=201)

    return HttpResponseNotAllowed(['GET', 'POST'])
Example #42
0
 def check_groupid():
     '''단체아이디 중복체크'''
     campidx = Camp.get_idx(campcode)
     userid = request.form.get('groupid')
     return "%d" % Group.check_groupid(campidx, userid)
Example #43
0
 def check_groupid():
     '''단체아이디 중복체크'''
     campidx = Camp.get_idx(campcode)
     userid = request.form.get('groupid')
     return "%d" % Group.check_groupid(campidx, userid)
Example #44
0
def create(name,t):
    g=Group()
    g.name=name
    g.type=t
    g.save()
    return g.id