kodo
/
page
/
screen_views.py


      
              # -*- coding: utf-8 -*-

import shortuuid
from django.conf import settings
from django_logit import logit
from django_query import get_query_value
from django_response import response
from json_render import json_render

from guideline.models import ScreenAdminInfo
from utils.error.errno_utils import PermissionStatusCode, ScreenStatusCode
from utils.redis.connect import r
from utils.redis.rkeys import SCREEN_ADMIN_LOGIN


@logit
def screen_admin_oauthqr(request):
    brand_id = request.GET.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)

    return json_render(request, 'page/screen_admin_oauth_qrcode.html', unjsondumpsdict={
        'qr': settings.KODO_SCREEN_AUTH_URL.format(brand_id)
    })


@logit
def screen_admin_oauth(request):
    brand_id = request.GET.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    unionid = request.GET.get('unionid', '')
    openid = request.GET.get('openid', '')

    ScreenAdminInfo.objects.update_or_create(brand_id=brand_id, unionid=unionid, openid=openid, defaults={
        'nickname': request.GET.get('nickname', ''),
        'avatar': request.GET.get('avatar', '') or request.GET.get('headimgurl', ''),
        'user_status': ScreenAdminInfo.ACTIVATED,
    })

    return json_render(request, 'page/screen_admin_oauth_success.html', unjsondumpsdict={
    })


@logit
def screen_admin_loginqr(request):
    brand_id = get_query_value(request, 'brand_id', settings.KODO_DEFAULT_BRAND_ID)

    token = shortuuid.uuid()

    return response(200, data={
        'qr': settings.KODO_SCREEN_LOGIN_URL.format(brand_id, token),
        'token': token,
    })


@logit
def screen_admin_login(request):
    brand_id = request.GET.get('brand_id', settings.KODO_DEFAULT_BRAND_ID)
    unionid = request.GET.get('unionid', '')
    openid = request.GET.get('openid', '')
    token = request.GET.get('token', '')

    try:
        admin = ScreenAdminInfo.objects.get(brand_id=brand_id, unionid=unionid, user_status=ScreenAdminInfo.ACTIVATED)
    except ScreenAdminInfo.DoesNotExist:
        return json_render(request, 'page/screen_admin_login_fail.html', unjsondumpsdict={
        })

    r.setex(SCREEN_ADMIN_LOGIN % (brand_id, token), r.REDIS_EXPIRED_HALF_HOUR, unionid)

    return json_render(request, 'page/screen_admin_login_success.html', unjsondumpsdict={
    })


@logit
def screen_admin_loginrst(request):
    brand_id = get_query_value(request, 'brand_id', settings.KODO_DEFAULT_BRAND_ID)
    token = get_query_value(request, 'token', '')

    admin_login_key = SCREEN_ADMIN_LOGIN % (brand_id, token)

    if not r.exists(admin_login_key):
        return response(ScreenStatusCode.QRCODE_NOT_SCAN)

    unionid, _ = r.getdelete(admin_login_key)

    try:
        admin = ScreenAdminInfo.objects.get(brand_id=brand_id, unionid=unionid, user_status=ScreenAdminInfo.ACTIVATED)
    except ScreenAdminInfo.DoesNotExist:
        return response(PermissionStatusCode.PERMISSION_DENIED)

    return response(200, data={
        'info': admin.data,
    })

      
              #!/usr/bin/env node
var fs = require('fs');
var path = require('path');

var command, directory, file;

var yargs = require('yargs')
    .usage('Usage: $0 <command> [options] <dir> [file]')
    // .demand(1)

    .command('ancestors', 'Output the ancestors')
    .command('descendents', 'Output the descendents')

    .example('$0 ancestors -I src src/ src/_footer.scss', 'outputs the ancestors of src/_footer.scss')

    .option('I', {
      alias: 'load-path',
      default: [process.cwd()],
      describe: 'Add directories to the sass load path',
      type: 'array',
    })

    .option('e', {
      alias: 'extensions',
      default: ['scss', 'css', 'sass'],
      describe: 'File extensions to include in the graph',
      type: 'array',
    })

    .option('f', {
      alias: 'follow',
      default: false,
      describe: 'Follow symbolic links',
      type: 'bool',
    })

    .option('j', {
      alias: 'json',
      default: false,
      describe: 'Output the index in json',
      type: 'bool',
    })

    .version(function() {
      return require('../package').version;
    })
    .alias('v', 'version')

    .help('h')
    .alias('h', 'help');

var argv = yargs.argv;

if (argv._.length === 0) {
  yargs.showHelp();
  process.exit(1);
}

if (['ancestors', 'descendents'].indexOf(argv._[0]) !== -1) {
  command = argv._.shift();
}

if (argv._ && path.extname(argv._[0]) === '') {
  directory = argv._.shift();
}

if (argv._ && path.extname(argv._[0])) {
  file = argv._.shift();
}


try {
  if (!directory) {
    throw new Error('Missing directory');
  }

  if (!command && !argv.json) {
    throw new Error('Missing command');
  }

  if (!file && (command === 'ancestors' || command === 'descendents')) {
    throw new Error(command + ' command requires a file');
  }

  var loadPaths = argv.loadPath;
  if(process.env.SASS_PATH) {
    loadPaths = loadPaths.concat(process.env.SASS_PATH.split(/:/).map(function(f) {
      return path.resolve(f);
    }));
  }

  var graph = require('../').parseDir(directory, {
    extensions: argv.extensions,
    loadPaths: loadPaths,
    follow: argv.follow,
  });

  if(argv.json) {
    console.log(JSON.stringify(graph.index, null, 4));
    process.exit(0);
  }

  if (command === 'ancestors') {
    graph.visitAncestors(path.resolve(file), function(f) {
      console.log(f);
    });
  }

  if (command === 'descendents') {
    graph.visitDescendents(path.resolve(file), function(f) {
      console.log(f);
    });
  }
} catch(e) {
  if (e.code === 'ENOENT') {
    console.error('Error: no such file or directory "' + e.path + '"');
  }
  else {
    console.log('Error: ' + e.message);
  }

  // console.log(e.stack);
  process.exit(1);
}