Exemplo n.º 1
0
 def post(self):
     if not current_user.is_authenticated:
         abort(HTTPStatus.FORBIDDEN, message='Not authorized')
     login = api.payload['login']
     user = get_user(login, 'login') or get_user(login, 'email')
     if not user:
         abort(HTTPStatus.BAD_REQUEST, message="User not found")
     return jsonify(name=user.name,
                    surname=user.surname,
                    login=user.login,
                    email=user.email,
                    role=user.get_role_description())
Exemplo n.º 2
0
 def post(self):
     if current_user.is_authenticated:
         return abort(HTTPStatus.METHOD_NOT_ALLOWED,
                      message='Already logged in')
     login = api.payload['login']
     password = api.payload['password']
     user = get_user(login, 'login') or get_user(login, 'email')
     if user and user.confirmed and user.check_password(password=password):
         login_user(user)
         return jsonify(result='Login successful')
     if user and not user.confirmed:
         return abort(HTTPStatus.FORBIDDEN, message='Unconfirmed account')
     abort(HTTPStatus.UNAUTHORIZED,
           message=ValidationResults.WRONG_CREDS.value)
Exemplo n.º 3
0
 def validate(data):
     error_messages = []
     if not (data.get('login') and data.get('email')
             and data.get('password') and data.get('name')
             and data.get('surname')):
         error_messages.append(ValidationResults.EMPTY_FIELDS)
     if get_user(data.get('login'), 'login'):
         error_messages.append(ValidationResults.LOGIN_EXISTS)
     if get_user(data.get('email'), 'email'):
         error_messages.append(ValidationResults.EMAIL_EXISTS)
     if len(data.get('password')) < 8:
         error_messages.append(ValidationResults.SHORT_PASSWORD)
     return error_messages if error_messages else [
         ValidationResults.SUCCESS
     ]
Exemplo n.º 4
0
    def password(self, request, *args, **kwargs):
        serializer = UserPasswordSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        userId = get_user(request)
        password = hashlib.sha256(
            request.data.get('password').encode()).hexdigest()
        newPassword = hashlib.sha256(
            request.data.get('newPassword').encode()).hexdigest()

        response = Response(status=401, data='아이디 또는 패스워드를 다시 확인해주세요.')
        try:
            account = Usr.objects.raw(
                f'SELECT * FROM (SELECT * FROM USR WHERE USR_ID=\'{userId}\') WHERE ROWNUM=1;'
            )[0]
        except IndexError:
            return response

        if account.usr_password != password:
            return response
        with connection.cursor() as cursor:
            cursor.execute(
                f"UPDATE USR SET USR_PASSWORD = '******' " \
                        f"WHERE USR_ID = '{userId}';"
            )
            return HttpResponse(status=200)
Exemplo n.º 5
0
    def destroy(self, request, pk, *args, **kwargs):
        userId = get_user(request)
        if not userId:
            return HttpResponse(status=401, content="로그인이 필요합니다.")

        pay_id = pk

        with connection.cursor() as cursor:
            cursor.execute(
                f"""SELECT P.PAY_STATE, P.PAY_TYPE, P.PAY_PRICE, T.USR_ID 
                    FROM PAY P, TICKET T 
                    WHERE P.PAY_ID={pay_id} AND P.PAY_ID=T.PAY_ID;""")
            payusr = cursor.fetchone()
            err = HttpResponse(status=404, content="결제번호가 올바르지 않습니다.")
            if not payusr:
                return err
            (pay_state, pay_type, money, usr_id) = payusr
            if usr_id != userId or pay_state > 3:
                return err

        sid = transaction.savepoint()
        with connection.cursor() as cursor:
            cursor.execute(f"""
                    UPDATE TICKET 
                    SET TICKET_STATE=2 
                    WHERE PAY_ID={pay_id};""")
        try:
            cancel(pay_id, pay_type, money, userId)
        except Exception as e:
            transaction.savepoint_rollback(sid)
            return HttpResponse(status=400, content=e)

        return HttpResponse(status=204)
Exemplo n.º 6
0
def login():
    if current_user.is_authenticated:
        return redirect(url_for('web.index'))
    login = ''
    if request.method == 'POST':
        login = request.form.get('login')
        password = request.form.get('password')
        user = get_user(login, 'login') or get_user(login, 'email')
        if user and user.confirmed and user.check_password(password=password):
            login_user(user)
            next_page = session.get('next_page', '/')
            session['next_page'] = ''
            return redirect(next_page or url_for('web.words'))
        if user and not user.confirmed:
            session['email_to_confirm'] = user.email
            return redirect(url_for('web.finish_signup'))
        flash(ValidationResults.WRONG_CREDS.value)
    return render_template('login.html', form_data=login)
Exemplo n.º 7
0
def edit(request, block):
   model_name = request.GET.get('model', None) if request.wepo.block else request.wepo.url_parts[3]
   id = request.GET.get('id', None)
   if not request.wepo.block and len(request.wepo.url_parts) > 4:
      id = request.wepo.url_parts[4]

   if id and id == 'me':
      from core.user import get_user
      id = get_user(request).id

   model_obj = get_model(request, model_name)
   model = model_obj['model']
   instance = model.objects.get(id=id) if id else None

   fields = get_model_fields(request, model)
   groups = get_model_groups(request, model)

   template = get_template('admin/object/edit.html')
   context = {'groups': groups, 'fields': fields, 'instance': instance, 'model': model}
   if 'attributes' in block:
      context['attributes'] = block['attributes']

   form = AdminForm(request, model, instance)

   from core.form import FormItem
   context['form'] = form
   context['request_wr'] = FormItem('Hidden', request, name='wr', value="json")
   context['request_raw'] = FormItem('Hidden', request, name='raw', value="true")

   context['edit_object_instance'] = FormItem('Hidden', request, name='object_instance', value=id)
   context['edit_object_type'] = FormItem('Hidden', request, name='object_type', value=model_name)

   #
   #  assets
   #
   from core import wepo_assets
   from core.asset import add_asset
   add_asset(request, type='script', code=wepo_assets.script.jquery_form, position='footer')
   add_asset(request, type='script', code="""
      jQuery('#object-edit #save_object').click(function() {
         jQuery('#object-edit').ajaxForm({
            success: function(responseText, statusText, xhr, $form) {
               wepo.callback_message(responseText);
            }
         });
      });
      jQuery('#object-edit #close_form').click(function() {
         wepo.redirect('/admin/object/list/' + wepo.url_part(3));
      });
      """, include_type='code', position="footer")

   return template.render(Context(context))
Exemplo n.º 8
0
def confirm_email(token):
    try:
        email = s.loads(token,
                        salt=current_app.config.get('MAIL_SALT'),
                        max_age=3600)
        session['email_to_confirm'] = ''
        user = get_user(email, 'email')
        user.confirmed = True
        update_user(user)
        flash('Адрес электронной почты подтверждён успешно!')
        login_user(user)
        return redirect(url_for('web.login'))
    except SignatureExpired:
        abort(401, 'Невозможно заершить регистрацию, так как ссылка устарела.')
Exemplo n.º 9
0
def navbar(request, block):
   template = get_template('admin/navbar.html')
   context = {}
   if 'attributes' in block:
      context['attributes'] = block['attributes']

   context['logout_link'] = '/user/logout?destination=%s' % urllib.quote(request.wepo.url.encode('utf8'), '')

   from core.user import get_user
   context['user'] = get_user(request)
   context['destination'] = urllib.quote(request.wepo.url.encode('utf8'), '')
   context['active_language'] = get_user_language(request)
   context['languages'] = Language.objects.all()

   return template.render(Context(context))
Exemplo n.º 10
0
    def point(self, request, *args, **kwargs):
        userId = get_user(request)
        if not userId:
            return HttpResponse(status=401)

        try:
            account = Usr.objects.raw(
                f'SELECT * FROM (SELECT * FROM USR WHERE USR_ID=\'{userId}\') WHERE ROWNUM=1;'
            )[0]
        except IndexError:
            return HttpResponse(status=401)
        else:
            point = account.usr_point
            res = {'point': point}
            return JsonResponse(res, status=200)
Exemplo n.º 11
0
    def validation(self, request, *args, **kwargs):
        userId = get_user(request)
        response = HttpResponse(status=401)
        response.delete_cookie('jwt')
        if not userId:
            return response

        try:
            Usr.objects.raw(
                f'SELECT * FROM (SELECT * FROM USR WHERE USR_ID=\'{userId}\') WHERE ROWNUM=1;'
            )[0]
        except IndexError:
            return response
        else:
            return HttpResponse(status=200)
Exemplo n.º 12
0
    def profile(self, request, *args, **kwargs):
        userId = get_user(request)
        if not userId:
            return HttpResponse(status=401)

        try:
            account = Usr.objects.raw(
                f'SELECT * FROM (SELECT * FROM USR WHERE USR_ID=\'{userId}\') WHERE ROWNUM=1;'
            )[0]
        except IndexError:
            return HttpResponse(status=401)
        else:
            userName = account.usr_name
            email = account.usr_email
            res = {'userId': userId, 'username': userName, 'email': email}
            return JsonResponse(res, status=200)
Exemplo n.º 13
0
 def link_contact_to_user(self, contact, bind_user_account):
     if strutil.is_empty(bind_user_account):
         contact.bind_user_id = model.EMPTY_UID
         return contact
     query = Contact.all()
     usermo = user.get_user(u_account=bind_user_account)
     if usermo is None:
         raise Error("cont_error_linkusernotfound", account=bind_user_account)
     
     query.filter("bind_user_id =", usermo.key())
     query.filter("creator_id =", contact.creator_id)
     if contact.key() != None:
         query.filter("uid !=", contact.key())
     if query.count() > 0:
         raise Error("cont_error_linkuserexisted", account=bind_user_account, contactName=query.get().contact_name)
     
     contact.bind_user_id = usermo.key()
     return contact
Exemplo n.º 14
0
def file_list(request, block):
   template_name = 'files/file_list_container.html'
   directory = request.GET.get('directory', 1)
   offset = int(request.GET.get('offset', 0))
   if offset > 0:
      template_name = 'files/file_list.html'

   template = get_template(template_name)

   raw_config = request.GET.get('config', {})
   config = files_config_dec(raw_config)
   is_private = config.get('private', False)

   from core.models import File

   filter = {'directory': directory}
   if is_private:
      filter['owner'] = get_user(request).id

   files = File.objects.filter(**filter).order_by('-id')[offset:offset + 20]

   #
   #  generate file tags
   #
   file_tags = []
   for file in files:
      tag = get_file_tag(file)
      if not tag in file_tags:
         file_tags.append(tag)

   context = {
      'files': files,
      'file_tags': file_tags
   }

   #
   #  assets
   #
   from core import wepo_assets
   from core.asset import add_asset

   add_asset(request, type='style', code=wepo_assets.wepo.files.file_select, position='head')

   return template.render(Context(context))
Exemplo n.º 15
0
def authenticated(request, attributes=None):

   redirect_url = attributes[0] if attributes else '/user/login'
   url_parameters = {}
   if attributes and len(attributes) > 1:
      url_parameters = attributes[1]

   url_parameters = urllib.urlencode(url_parameters)
   if url_parameters:
      redirect_url = '%s?%s' % (redirect_url, url_parameters)

   #
   #  redirect user to login if not logged in
   #
   user = get_user(request)
   if not user:
      return False, redirect(redirect_url)
   else:
      return True, None
Exemplo n.º 16
0
def file_select(request, block):
   template = get_template('files/index.html')

   raw_config = request.GET.get('config', '')
   config = files_config_dec(raw_config if raw_config else {})

   # crop, height, width, prefix, name
   image_scales = config.get('scales', {})
   is_private = config.get('private', False)
   preview = config.get('preview', 'prws')

   #
   #  get directories
   #
   directories = get_directory_tree()

   from core.models import File

   filter = {'directory': 1}
   if is_private:
      filter['owner'] = get_user(request).id

   files = File.objects.filter(**filter).order_by('-id')[:20]

   from core.form import FormItem

   new_directory_input = FormItem('Text', request, name='new_directory', id='new_directory', **{'class': 'col-lg-12'})

   form_file_id = FormItem('Hidden', request, name='file_id', id='file_id', **{'class': 'col-lg-12'})
   form_file_title = FormItem('Text', request, name='file_title', id='file_title', **{'class': 'col-lg-12'})
   form_file_description = FormItem('Textarea', request, name='file_description', id='file_description', rows=10, **{'class': 'col-lg-12'})
   form_file_author = FormItem('Text', request, name='file_author', id='file_author', **{'class': 'col-lg-12'})

   #
   #  generate initial file tags
   #
   file_tags = []
   for file in files:
      tag = get_file_tag(file)
      if not tag in file_tags:
         file_tags.append(tag)

   context = {
      'directories': directories,
      'new_directory_input': new_directory_input,
      'files': files,
      'form_file_id': form_file_id,
      'form_file_title': form_file_title,
      'form_file_description': form_file_description,
      'form_file_author': form_file_author,
      'file_tags': file_tags,
      'scales': image_scales,
      'preview': preview

   }

   #
   #  assets
   #
   from core import wepo_assets
   from core.asset import add_asset

   add_asset(request, type='script', code=wepo_assets.script.nested_sort, position='footer')
   add_asset(request, type='script', code=wepo_assets.script.smooth_zoom, position='footer')
   add_asset(request, type='style', code=wepo_assets.wepo.files.directory_tree, position='head')
   add_asset(request, type='style', code=wepo_assets.wepo.files.file_select, position='head')
   add_asset(request, type='script', code="""
      wepo.files.image_scales=%s;
      wepo.files.widget_config='%s';
   """ % (json.dumps(image_scales), raw_config), include_type='code', position="footer")

   return template.render(Context(context))
Exemplo n.º 17
0
    def create(self, request, *args, **kwargs):
        serializer = TicketingSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        userId = get_user(request)
        email = request.data.get('email')
        password = hashlib.sha256(
            request.data.get('password', '000000').encode()).hexdigest()
        member = userId is not None

        show_id = int(self.kwargs.get('show_id'))
        pay_type = request.data.get('payType')
        ticket_amount = request.data.get('ticketAmount')
        seat_ids = request.data.get('seatIds')

        try:
            show = Show.objects.raw(
                f"SELECT * FROM SHOW WHERE SHOW_ID={show_id};")[0]
        except IndexError:
            return HttpResponse(status=404)

        with connection.cursor() as cursor:
            cursor.execute("SELECT CUSTOMER_TYPE_ID, MOVIE_FEE FROM FEE " \
                    f"WHERE THEATER_TYPE_ID={show.theater.theater_type.theater_type_id} " \
                    "ORDER BY CUSTOMER_TYPE_ID;")
            fee = {f[0]: f[1] for f in cursor.fetchall()}

        money = 0
        for cus in ticket_amount:
            if cus['customerTypeId'] not in fee:
                return HttpResponse(
                    status=400,
                    content=
                    f"customerType: {cus['customerTypeId']} 은(는) 올바르지 않은 값입니다."
                )
            else:
                money += fee[cus['customerTypeId']] * cus['amount']

        sid = transaction.savepoint()
        if not userId:
            if not email:
                return HttpResponse(status=400,
                                    content="비회원 예매는 이메일을 입력해야 합니다.")
            with connection.cursor() as cursor:
                cursor.execute(
                    f"""INSERT INTO USR (USR_ID, USR_NAME, USR_EMAIL, USR_PASSWORD, USR_TYPE) 
                        VALUES ('$'||USR_SEQ.NEXTVAL, 'GUEST', '{email}', '{password}', 2);"""
                )
                cursor.execute("SELECT '$'||USR_SEQ.CURRVAL FROM DUAL;")
                userId = cursor.fetchone()[0]
        try:
            pay_id = pay(pay_type, money, userId, member)
        except Exception as e:
            transaction.savepoint_rollback(sid)
            return HttpResponse(status=400, content=e)

        with connection.cursor() as cursor:
            cursor.execute(f"""SELECT S.SEAT_ID, S.SEAT_TYPE, T.TICKET_STATE 
                               FROM (SELECT * FROM TICKET
                                              WHERE SHOW_ID={show_id} AND 
                                                    (TICKET_STATE=1 OR TICKET_STATE IS NULL) ) T, SEAT S 
                               WHERE T.SEAT_ID(+)=S.SEAT_ID AND 
                                     S.THEATER_ID={show.theater.theater_id};"""
                           )
            e_seats = {
                seat[0]: (seat[1], seat[2])
                for seat in cursor.fetchall()
            }

        typeslist = [[c["customerTypeId"]] * c["amount"]
                     for c in ticket_amount]
        types = list(itertools.chain(*typeslist))
        with connection.cursor() as cursor:
            money = 0
            for i in range(len(seat_ids)):
                seat_id = seat_ids[i]
                customer_type_id = types[i]
                try:
                    # e_seats = { SEAT_ID: (SEAT_TYPE, TICKET_STATE) }
                    seat = e_seats[seat_id]
                except KeyError:
                    transaction.savepoint_rollback(sid)
                    return HttpResponse(
                        status=404, content=f"'seatNo: {seat_id}'는 존재하지 않습니다.")
                if not seat[0] or (seat[1] and seat[1] == 1):
                    transaction.savepoint_rollback(sid)
                    return HttpResponse(
                        status=400,
                        content=f"'seatNo: {seat_id}'는 예매할 수 없는 자리입니다.")
                cursor.execute(
                    f"INSERT INTO TICKET VALUES (TICKET_SEQ.NEXTVAL, 1, {pay_id}, " \
                            f"{seat_id}, '{userId}', {show_id}, {customer_type_id});")

        return HttpResponse(status=201)
Exemplo n.º 18
0
def load_user(user_id):
    if user_id:
        return get_user(ObjectId(user_id))
    return None
Exemplo n.º 19
0
    def list(self, request, *args, **kwargs):
        count = request.GET.get('count')
        email = request.GET.get('email')

        userId = get_user(request)
        if not userId and not email:
            return HttpResponse(status=400, content="비회원은 이메일을 입력해야 합니다.")

        if count is not None:
            with connection.cursor() as cursor:
                if userId:
                    cursor.execute(f"""
                        SELECT COUNT(*) FROM 
                            (SELECT P.PAY_ID
                             FROM TICKET T, PAY P
                             WHERE P.PAY_ID=T.PAY_ID AND T.USR_ID='{userId}' 
                                   AND P.PAY_STATE<=3 GROUP BY P.PAY_ID);""")
                else:
                    cursor.execute(f"""
                        SELECT COUNT(*) FROM 
                            (SELECT P.PAY_ID
                             FROM TICKET T, PAY P
                             WHERE P.PAY_ID=T.PAY_ID AND T.USR_ID IN 
                                    (SELECT USR_ID FROM USR WHERE USR_EMAIL='{email}')
                                   AND P.PAY_STATE<=3 GROUP BY P.PAY_ID);""")
                count = cursor.fetchone()[0]
            return JsonResponse({"count": count}, status=200)

        res = {}
        with connection.cursor() as cursor:
            if userId:
                cursor.execute(f"""
                        SELECT P.PAY_ID, P.PAY_STATE, TH.THEATER_NAME, M.MOVIE_NAME, 
                               S.SHOW_START_TIME, S.SHOW_COUNT, ST.SEAT_ROW, ST.SEAT_COL, 
                               T.CUSTOMER_TYPE_ID, P.PAY_DATE, P.PAY_PRICE 
                        FROM TICKET T, PAY P, SEAT ST, SHOW S, THEATER TH, MOVIE M 
                        WHERE T.USR_ID='{userId}' AND T.PAY_ID=P.PAY_ID AND T.SEAT_ID=ST.SEAT_ID AND 
                              T.SHOW_ID=S.SHOW_ID AND S.THEATER_ID=TH.THEATER_ID AND S.MOVIE_ID=M.MOVIE_ID 
                        ORDER BY PAY_ID;""")
            else:
                cursor.execute(f"""
                        SELECT P.PAY_ID, P.PAY_STATE, TH.THEATER_NAME, M.MOVIE_NAME, 
                               S.SHOW_START_TIME, S.SHOW_COUNT, ST.SEAT_ROW, ST.SEAT_COL, 
                               T.CUSTOMER_TYPE_ID, P.PAY_DATE, P.PAY_PRICE 
                        FROM TICKET T, PAY P, SEAT ST, SHOW S, THEATER TH, MOVIE M 
                        WHERE T.USR_ID IN (SELECT USR_ID FROM USR WHERE USR_EMAIL='{email}') AND 
                              T.PAY_ID=P.PAY_ID AND T.SEAT_ID=ST.SEAT_ID AND 
                              T.SHOW_ID=S.SHOW_ID AND S.THEATER_ID=TH.THEATER_ID AND S.MOVIE_ID=M.MOVIE_ID 
                        ORDER BY PAY_ID;""")
            fetched = cursor.fetchall()
            tickets = filter(lambda x: x[1] <= 3, fetched)
            canceled = filter(lambda x: x[1] >= 4, fetched)

            def rows_to_pay(rows):
                arr = list(rows)
                pay = arr[0]
                return {
                    "payId":
                    pay[0],
                    "payState":
                    pay[1],
                    "theaterName":
                    pay[2],
                    "movieName":
                    pay[3],
                    "showStartTime":
                    pay[4].strftime("%Y-%m-%d %H:%M:%S"),
                    "showCount":
                    pay[5],
                    "seatsList": [{
                        "seatRow": row[6],
                        "seatCol": row[7],
                        "customerType": row[8],
                    } for row in arr],
                    "payDate":
                    pay[9].strftime("%Y-%m-%d %H:%M:%S"),
                    "payPrice":
                    pay[10]
                }

            res['tickets'] = [
                rows_to_pay(rows)
                for _, rows in itertools.groupby(tickets, lambda x: x[0])
            ]
            res['canceled'] = [
                rows_to_pay(rows)
                for _, rows in itertools.groupby(canceled, lambda x: x[0])
            ]

        return JsonResponse(res, status=200)
Exemplo n.º 20
0
def list(request, block):
   model_name = None
   if hasattr(block, 'model_name'):
      model_name = block.model_name
   else:
      model_name = request.GET.get('model', None) if request.wepo.block else request.wepo.url_parts[3]

   model_name = model_name.replace('-', '_')

   model_obj = get_model(request, model_name)
   model = model_obj['model']

   restricted_content = hasattr(model, 'restricted_content')

   template = get_template('admin/object/list.html')

   fields = get_model_fields(request, model)

   per_page = int(request.GET.get('_per_page', block.limit if hasattr(block, 'limit') else 10))
   page = int(request.GET.get('_page', 0))
   offset = page * per_page

   # sort by ...
   default_sort = [block.order] if hasattr(block, 'order') else model.default_sort if hasattr(model, 'default_sort') else ['id']

   objects = []
   if restricted_content and model.restricted_content:
      permissions_to_check = model.grant_permission if hasattr(model, 'grant_permission') else ['admin.superuser_access']

      from core.permission import check_permissions
      from core.user import get_user
      status, action = check_permissions(request, permissions_to_check)
      if status:
         # ok has permission to list all
         objects = model.objects.all().order_by(*default_sort)

      else:
         # list only owners items and to those who are granted to see
         from django.db.models import Q
         user = get_user(request)
         query = None

         # grant only to those who can access this content
         grant_access = model.grant_access if hasattr(model, 'grant_access') else None
         if grant_access:
            for access in grant_access:
               if not query:
                  query = Q(**{'%s' % access.replace('.', '__'): user})
               else:
                  query |= Q(**{'%s' % access.replace('.', '__'): user})

         # grant to this content if some parameters are not yet set
         grant_access_empty = model.grant_access_empty if hasattr(model, 'grant_access_empty') else None
         if grant_access_empty:
            for access in grant_access_empty:
               if not query:
                  query = Q(**{'%s__isnull' % access.replace('.', '__'): True})
               else:
                  query |= Q(**{'%s__isnull' % access.replace('.', '__'): True})

         if not grant_access:
            return ''

         objects = model.objects.filter(query).order_by(*default_sort).distinct()
   else:
      objects = model.objects.all().order_by(*default_sort)

   # count objects
   count = objects.count()
   objects = objects[offset:offset + per_page]

   # generate pagination
   list_last = int(count / per_page)
   first = max(page - 5, 0)
   last = min(page + 5, list_last)
   pagination = [a for a in range(first, last)]

   show_pagination = True
   if hasattr(block, 'pagination'):
      show_pagination = block.pagination

   context = {
      'objects': objects,
      'fields': fields,
      'list_first': 0,
      'list_page': page,
      'list_last': list_last,
      'pagination': pagination,
      'show_pagination': show_pagination,
      'url': request.wepo.url,
      'query': request.wepo.query,
      'model_name': model_name,
      'page': page,
      'widget_size': block.widget_size if hasattr(block, 'widget_size') else 12,
      'start_row': block.start_row if hasattr(block, 'start_row') else True,
      'end_row': block.end_row if hasattr(block, 'end_row') else True,
      'add_new_button': _(request, 'Add new %s' % model_name.title())
   }

   return template.render(Context(context))
Exemplo n.º 21
0
               setattr(through_instance, object_type, instance)
               through_instance.save()
            else:
               tdata = {object_type:instance, through_to_model._meta.db_table:new_object}
               through_instance = through_model.objects.get(**tdata)
               through_instance.enabled = True
               through_instance.save()

   parent_model_name = post.get('parent_model_name', None)
   parent_id = int(post.get('parent_id', -1))
   parent_field = post.get('parent_field', None)

   if hasattr(model, 'user'):
      if not instance.user:
         from core.user import get_user
         instance.user = get_user(request)

   instance.save()

   #
   #  link new object with it's parent
   #
   if parent_model_name and parent_field and parent_id != -1:
      parent_model = get_model(request, parent_model_name)
      parent_model = parent_model['model']
      parent_instance = parent_model.objects.get(id=parent_id)

      through = getattr(parent_model, parent_field).through
      through_instance = through()
      setattr(through_instance, parent_model_name, parent_instance)
      setattr(through_instance, object_type, instance)
Exemplo n.º 22
0
 def to_dict(self):
     self.bind_user_account = user.get_user(user_id=self.bind_user_id).u_account if self.bind_user_id != None and self.bind_user_id != model.EMPTY_UID else ""
     self.creatorDisplayName = user.get_user_display_name(self.creator_id)
     from contact.contactservice import ContactService
     self.groupKeys = list(set(map(lambda x: x.group_id, ContactService.get_instance().fetch_contactgroups(contact_id=self.key()))))
     return Model.to_dict(self)
Exemplo n.º 23
0
def upload(request, block):
   #
   #  file info
   #
   file_id = request.META.get('HTTP_X_FILE_ID', None)

   chunk = int(request.META.get('HTTP_X_FILE_CHUNK', 0))
   file_size = int(request.META.get('HTTP_X_FILE_SIZE', 0))
   selected_directory = int(request.META.get('HTTP_X_FILE_DIRECTORY', 1))

   file_name = request.META.get('HTTP_X_FILE_NAME', '')
   mime_type = request.META.get('HTTP_X_FILE_TYPE', '')

   if file_id is None:
      return dict(status=False, message='No file defined')

   if file_size == 0:
      return dict(status=False, message='File size is 0')

   if file_name == '':
      return dict(status=False, message='No file name defined')

   #
   #  Get current file chunk data
   #
   bin = request.body

   #
   #  save file to temporary file
   #
   f = open('/tmp/%s' % file_id, 'a')
   f.write(bin)
   f.close()

   #
   #  move uploaded file when completely uploaded
   #
   if chunk == file_size:
      path = datetime.datetime.now().strftime("%Y/%m/%d")
      file_path = '%s/%s' % (MEDIA_ROOT, path)

      # do not override existing images
      full_file_path = '%s/%s' % (file_path, file_name)
      if os.path.exists(full_file_path):
         n = datetime.datetime.now()
         unix_time = time.mktime(n.timetuple())

         file_name = '%d%d_%s' % (unix_time, random.randint(10, 100), file_name)
         full_file_path = '%s/%s' % (file_path, file_name)

      if not os.path.exists(file_path):
         os.makedirs(file_path)

      shutil.move('/tmp/%s' % file_id, full_file_path)

      from core.models import File, Directory

      directory = Directory.objects.get(id=selected_directory)
      created = datetime.datetime.now()

      file, created = File.objects.get_or_create(file_name=file_name, directory=directory, path=path, size=file_size, created=created)
      file.title = ' '.join(part.upper() for part in file_name.split('.')[:-1])
      file.data = {}
      file.mime_type = mime_type

      user = get_user(request)
      if user:
         file.owner = user

      file.save()

      for scale in DEFAULT_IMAGE_SCALES:
         scale_image(file, scale)

      return dict(status=True, message='File uploaded (real size: %d)' % len(bin), file_name=file.file_name, file_path=file.path, file_id=file.id, file_mime_type=file.mime_type, file_rough_mime_type=get_file_rough_mime_type(file))

   return dict(status=True, message='Chunk %d uploaded (real size: %d)' % (chunk, len(bin)))