Exemplo n.º 1
0
def message(request):

    if request.method == 'POST':
        request_data = ((request.body).decode('utf-8'))
        request_data = json.loads(request_data)
        userMessage = request_data['content']
        user_key = request_data['user_key']

    user = User.getOrCreate(user_key)

    start = datetime.datetime.now()
    botMessageDict = Response.getResponseDict(user, userMessage)
    timeDiff = datetime.datetime.now() - start

    numOfMails = Mail.getNumOfMails(user)
    if numOfMails:
        botMessageDict['message']['text'] = '[\'메시지\'라고 입력해주세요!(' + str(
            numOfMails) + '개)]\n\n' + botMessageDict['message']['text']

    Log.write(user, userMessage, botMessageDict['message']['text'],
              timeDiff.total_seconds())

    botMessageDumped = json.dumps(botMessageDict)

    return HttpResponse(botMessageDumped)
Exemplo n.º 2
0
def ds_addlog(source, type, user, character):
    user = User.objects.get(id=user)
    log = Log(source=source,
        type=type,
        user=user,
        character=character)
    log.save()
    return "OK!" + "from " + log.source + "log.user" + " logged in"
Exemplo n.º 3
0
 def log_in(self, episode):
     """
     log_in/out
     create logs, and lock.unlock the episode
     """
     where = socket.gethostname()
     if os.environ.get('STY') is not None:
         where += ":" + os.environ['STY']
     what_where = "%s@%s" % (self.__class__.__name__, where)
     episode.locked = datetime.datetime.now()
     episode.locked_by = what_where[:35]
     # save the lock to disk
     episode.save()
     try:
         state = State.objects.get(sequence=episode.state)
     except State.DoesNotExist:
         state = None
     self.start = datetime.datetime.now()
     self.log = Log(
         episode=episode,
         state=state,
         ready=datetime.datetime.now(),
         start=datetime.datetime.now(),
         result=what_where)
     self.log.save()
Exemplo n.º 4
0
def request_temp_log_more_details(request):
    try:
        constraint = helpers.constraint(request, "POST");
        data = constraint.safe({
            "log_id": True,
        });

        of_user = UserProfile.objects.get(user_id=request.user.id);

        of_log = Log.objects.get(
            id=data['log_id'],
            added_by__department_id=of_user.department_id
        );


        return render(request, "ajax_temp/log_details.html", {
            'data': of_log,
            'out': of_log.out(),
            "is_out": of_log.is_out_provided(),
            "LOG" : Log
        });


    except Log.DoesNotExist:
        raise Log.DoesNotExist("Index id of Log object does not exists");

    except UserProfile.DoesNotExist:
        raise UserProfile.DoesNotExist("Index id of UserProfile object does not exists");

    except helpers.InvalidRequest:
        raise helpers.InvalidRequest("Parameters does not supply required fields")
    pass;

    pass;
Exemplo n.º 5
0
 def log_in(self, episode):
     """
 log_in/out
 create logs, and lock.unlock the episode
 """
     where = socket.gethostname()
     if os.environ.get('STY') is not None:
         where += ":" + os.environ['STY']
     what_where = "%s@%s" % (self.__class__.__name__, where)
     episode.locked = datetime.datetime.now()
     episode.locked_by = what_where
     # save the lock to disk
     episode.save()
     try:
         state = State.objects.get(sequence=episode.state)
     except State.DoesNotExist:
         state = None
     self.start = datetime.datetime.now()
     self.log = Log(episode=episode,
                    state=state,
                    ready=datetime.datetime.now(),
                    start=datetime.datetime.now(),
                    result=what_where)
     self.log.save()
Exemplo n.º 6
0
def database_save_as_out(request):
    try:
        constraint = helpers.constraint(request, "POST");
        data = constraint.safe({
            "log_id": True,
            "receiver_name": False,
            "description": False
        });

        of_user = UserProfile.objects.get(user_id=request.user.id);

        of_log = Log.objects.get(
            id=data['log_id'],
            added_by__department_id=of_user.department_id,
        );

        of_out = Out(
            receiver_name=data['receiver_name'],
            log=of_log,
            description=data['description'],
            added_by=of_user
        );

        of_out.full_clean();
        of_out.clean();
        of_out.save();

        of_log.is_out = True;
        of_log.save();


        return render(request, "ajax_temp/log_details.html", {
            'data': of_log,
            'out': of_log.out(),
            "is_out": of_log.is_out_provided(),
            "LOG" : Log
        });


    except Log.DoesNotExist:
        raise Log.DoesNotExist("Index id of Log object does not exists");

    except UserProfile.DoesNotExist:
        raise UserProfile.DoesNotExist("Index id of UserProfile object does not exists");

    except helpers.InvalidRequest:
        raise helpers.InvalidRequest("Parameters does not supply required fields")
    pass;
Exemplo n.º 7
0
 def log_in(self,episode):
   """
   log_in/out
   create logs, and lock.unlock the episode
   """
   hostname=socket.gethostname()
   what_where = "%s@%s" % (self.__class__.__name__, hostname)
   episode.locked = datetime.datetime.now()
   episode.locked_by = what_where
   # save the lock to disk
   episode.save()
   try:
       state = State.objects.get(id=episode.state)
   except State.DoesNotExist:
       state = None
   self.start=datetime.datetime.now()
   self.log=Log(episode=episode,
       state=state,
       ready = datetime.datetime.now(),
       start = datetime.datetime.now(),
       result = what_where)
   self.log.save()
Exemplo n.º 8
0
def get_tracing_code_info(request):

    try:
        constraint = helpers.constraint(request, "POST");
        data = constraint.safe({
            "tracing_code": True
        });

        of_user_profile = UserProfile.objects.get(id=request.user.id);

        of_log_details = Log_details.objects.get(
            tracing_code=data['tracing_code']
        );

        is_department_log = of_log_details\
                                .added_by\
                                .department_id == of_user_profile.department_id;

        return render(request, "ajax_temp/action_tracking_code_info.html", {
            'log_details': of_log_details,
            'is_department_log' : is_department_log,
            "obj_log" : Log,
            "log_details_person" : of_log_details.person_visitor
        });

    except Log_details.DoesNotExist:
        raise Log.DoesNotExist("Log details id does not exists");

    except UserProfile.DoesNotExist:
        raise UserProfile.DoesNotExist("Index id of UserProfile object does not exists");

    except helpers.InvalidRequest:
        raise helpers.InvalidRequest("Parameters does not supply required fields")
    pass;

    pass;
Exemplo n.º 9
0
class process():
    """
  Abstract class for processing.
  Provides basic options and itarators.
  Only operates on episodes in ready_state,
  or all if ready_state is None.
  if read_sate is not None and .processing() returns True, 
      bump the episode's state:
      state=ready_state+1
  """

    extra_options = {}

    # set stop to True to stop processing at the end of episode
    # will not abort a process, like an encode, upload or anything like that.
    # it just exits these loops:
    #    for e in es: (process episodes) and do while not Done: (poll)
    stop = False

    ready_state = None

    # defaults to ntsc stuff
    # fps=29.98
    fps = 30000 / 1001.0
    bpf = 120000

    def run_cmd(self, cmd):
        """
    given command list
    if verbose prints stuff,
    runs it, returns pass/fail.
    """
        if self.options.verbose:
            print(cmd)
            print(' '.join(cmd))

        if self.options.test:
            print("TEST: not running command.")
            return True

        p = subprocess.Popen(cmd)
        p.wait()
        retcode = p.returncode
        if retcode:
            if self.options.verbose:
                print("command failed")
                print(retcode)
            ret = False
        else:
            ret = True
        return ret

    def run_cmds(self, episode, cmds):
        """
      given a list of commands
      append them to the episode's shell script
      then run each
      abort and return False if any fail.
      """

        script_pathname = os.path.join(self.work_dir, episode.slug + ".sh")
        sh = open(script_pathname, 'a')

        for cmd in cmds:
            if type(cmd) == list:
                print(cmd)
                log_text = ' '.join(cmd)
            else:
                log_text = cmd
                cmd = cmd.split()

            try:
                # Not sure what python v3 wants. str I guess.
                # .write(b'a') and .writeline(b'a') - Errpr must be str, not b
                sh.writelines(log_text)
                # sh.writelines([t.encode('utf-8','ignore') for t in log_text])
            except Exception as e:
                import code
                code.interact(local=locals())
                import sys
                sys.exit()

            # if isinstance(s, unicode): return s.encode('utf-8') else: return s
            sh.write('\n')
            # self.log_info(log_text)
            if self.options.debug_log:
                episode.description += "\n{0:>s}\n".format(log_text, )
                episode.save()

            if not self.run_cmd(cmd):
                return False

        sh.write('\n')
        sh.close()

        return True

    def file2cdn(self, show, src, dst=None):
        """
        src is relitive to the show dir.
        src and dst get filled to full paths.
        Check to see if src exists,
        if it does, try to upload it to cdn
        (rax_uploader will skip if same file exists).
        """
        print("checking:", src)

        if dst is None: dst = src

        src = os.path.join(self.show_dir, src)
        dst = os.path.join("veyepar", show.client.slug, show.slug, dst)

        if os.path.exists(src):

            u = rax_uploader.Uploader()

            u.user = show.client.rax_id

            if not show.client.bucket_id.strip():
                raise AttributeError("client.bucket_id is blank")
            u.bucket_id = show.client.bucket_id
            u.bucket = show.client.bucket_id

            u.pathname = src
            u.key_id = dst

            ret = u.upload()
            print(u.new_url)
            ret = u.new_url

        else:
            print(("file2cdn can't find {}".format(src)))
            ret = False

        return ret

    def set_dirs(self, show):
        client = show.client
        self.show_dir = os.path.join(self.options.media_dir, client.slug,
                                     show.slug)
        if self.options.tmp_dir:
            self.tmp_dir = self.options.tmp_dir
        else:
            self.tmp_dir = os.path.join(self.show_dir, "tmp")
        # change me to "cmd" or something before the next show
        self.work_dir = os.path.join(self.show_dir, "tmp")

        return

    def log_in(self, episode):
        """
    log_in/out
    create logs, and lock.unlock the episode
    """
        where = socket.gethostname()
        if os.environ.get('STY') is not None:
            where += ":" + os.environ['STY']
        what_where = "%s@%s" % (self.__class__.__name__, where)
        episode.locked = datetime.datetime.now()
        episode.locked_by = what_where
        # save the lock to disk
        episode.save()
        try:
            state = State.objects.get(sequence=episode.state)
        except State.DoesNotExist:
            state = None
        self.start = datetime.datetime.now()
        self.log = Log(episode=episode,
                       state=state,
                       ready=datetime.datetime.now(),
                       start=datetime.datetime.now(),
                       result=what_where)
        self.log.save()

    def log_info(self, text):
        self.log.result += text + '\n'

    def log_out(self, episode):

        # done processing
        # log the end time
        # unlock the episode

        self.log.end = datetime.datetime.now()
        self.log.save()

        episode.locked = None
        episode.locked_by = ''
        episode.save()

    def process_ep(self, episode):
        print(("stubby process_ep: #{} state:{} {}".format(
            episode.id, episode.state, episode.name)))
        return

    def process_eps(self, episodes):
        def foo(e):
            # shard over ...umm.. a bunch of tmux sessions I think.
            s = os.environ.get('STY')
            if s:
                s = s.split('-')
                if len(s) == 3:
                    s = s[-1]
                    if s.isdigit():
                        return e.id % 11 == int(s)
            return True

        ret = None
        sleepytime = False
        for e in episodes:
            if foo(e):

                # next line requires the db to make sure the lock field is fresh
                ep = Episode.objects.get(pk=e.id)
                if self.options.unlock: ep.locked = None
                if ep.locked and not self.options.force:
                    if self.options.verbose:
                        print('#%s: "%s" locked on %s by %s' %
                              (ep.id, ep.name, ep.locked, ep.locked_by))
                        ret = None
                else:
                    # ready_state:
                    # None means "don't care",
                    # ready == X means ready to do X,
                    # force is dangerous and will likely mess tings up.
                    if self.ready_state is None \
                       or ep.state==self.ready_state \
                       or self.options.force:

                        self.set_dirs(ep.show)
                        self.episode_dir = os.path.join(
                            self.show_dir, 'dv', ep.location.slug)

                        if self.options.verbose: print(ep.name)

                        if self.options.lag:
                            if sleepytime:
                                # don't lag on the first one that needs processing,
                                # we only want to lag between the fence posts.
                                print("lagging....", self.options.lag)
                                time.sleep(self.options.lag)
                            else:
                                sleepytime = True

                        self.log_in(ep)

                        if not self.options.quiet:
                            print(self.__class__.__name__, ep.id, ep.name)
                        if self.options.skip:
                            ret = True
                        else:
                            ret = self.process_ep(ep)
                        if self.options.verbose: print("process_ep:", ret)

                        # .process is long running (maybe, like encode or post)
                        # so refresh episode in case its .stop was set
                        # (would be set in some other process, like the UI)
                        ep = Episode.objects.get(pk=e.id)

                        if ret:
                            # if the process doesn't fail,
                            # and it was part of the normal process,
                            # don't bump if the process was forced,
                            # even if it would have been had it not been forced.
                            # if you force, you know better than the process,
                            # so the process is going to let you bump.
                            # huh?!
                            # so..  ummm...
                            # 1. you can't bump None
                            # 2. don't bump when in test mode
                            # 3. if it wasn't forced:, bump.
                            if self.ready_state is not None \
                                    and not self.options.test \
                                    and not self.options.force:
                                # bump state
                                ep.state += 1
                        self.end = datetime.datetime.now()
                        ep.save()
                        self.log_out(ep)
                        if ep.stop:
                            if self.options.verbose:
                                print(".STOP set on the episode.")
                            # send message to .process_eps which bubbles up to .poll
                            self.stop = True
                            # re-set the stop flag.
                            ep.stop = False
                            ep.save()
                            break

                    else:
                        if self.options.verbose:
                            print('#%s: "%s" is in state %s, ready is %s' %
                                  (ep.id, ep.name, ep.state, self.ready_state))

        return ret

    def one_show(self, show):
        """
 
    """
        self.set_dirs(show)

        locs = Location.objects.filter(show=show)
        if self.options.room:
            locs = locs.filter(slug=self.options.room)

        for loc in locs:
            if self.options.verbose: print(loc.name)
            # episodes = Episode.objects.filter( location=loc).order_by(
            #    'sequence','start',)
            # if self.options.day:
            #    episodes=episodes.filter(start__day=self.options.day)
            self.one_loc(show, loc)

    def work(self):
        """
        find and process episodes
        """
        episodes = Episode.objects
        if self.options.client:
            clients = Client.objects.filter(slug=self.options.client)
            episodes = episodes.filter(show__client__in=clients)
        if self.options.show:
            shows = Show.objects.filter(slug=self.options.show)
            episodes = episodes.filter(show__in=shows)
        if self.options.day:
            episodes = episodes.filter(start__day=self.options.day)
        if self.options.room:
            episodes = episodes.filter(location__slug=self.options.room)
        if self.args:
            episodes = episodes.filter(id__in=self.args)
        if self.ready_state is not None \
                and not self.options.force:
            episodes = episodes.filter(state=self.ready_state)

        # episodes = Episode.objects.order_by( 'sequence','start',)

        self.start = datetime.datetime.now()
        ret = self.process_eps(episodes)
        self.end = datetime.datetime.now()
        work_time = self.end - self.start
        if work_time.seconds or True:
            print("run time: %s minutes" % (work_time.seconds / 60))

        return ret

    def poll(self):
        done = False
        while not done:
            ret = self.work()
            if self.stop:
                done = True
            else:
                if self.options.verbose: print("sleeping....")
                time.sleep(int(self.options.poll))
        return ret

    def list(self):
        """
    list clients and shows.
    """
        clients=Client.objects.annotate(
                max_date=Max('show__episode__start')) \
                .filter(active=True) \
                .order_by('max_date')

        if self.options.client:
            clients = clients.filter(slug=self.options.client)

        for client in clients:
            print("\nName: %s  Slug: %s" % (client.name, client.slug))
            shows=Show.objects.filter(client=client)\
                    .annotate( max_date=Max('episode__start'))\
                    .order_by('max_date')

            # if self.options.show:
            #    shows = shows.filter(slug=self.options.show)

            for show in shows:
                print(show)
                print("\tName: %s  Slug: %s" % (show.name, show.slug))
                print("\t--client %s --show %s" % (client.slug, show.slug))
                print("client=%s\nshow=%s" % (client.slug, show.slug))
                locations = show.locations.filter(
                    active=True).order_by('sequence')
                for loc in locations:
                    print(("room={}".format(loc.slug)))

                if self.options.verbose:
                    for ep in Episode.objects.filter(show=show):
                        print("\t\t id: %s state: %s %s" %
                              (ep.id, ep.state, ep))
        return

    def add_more_options(self, parser):
        pass

    def add_more_option_defaults(self, parser):
        pass

    def set_options(self, *bar, **extra_options):
        # hook for test runner
        self.extra_options = extra_options

    def get_options(self):
        for k, v in self.extra_options.items():
            self.options.ensure_value(k, v)
            setattr(self.options, k, v)

    def parse_args(self):
        """
    parse command line arguments.
    """
        parser = optparse.OptionParser()

        # hardcoded defaults
        # parser.set_defaults(dv_format="square_ntsc_wide")
        parser.set_defaults(dv_format="hdv_720_30p")
        parser.set_defaults(upload_formats="mp4")
        parser.set_defaults(media_dir=os.path.expanduser('~/Videos/veyepar'))
        parser.set_defaults(lag=0)
        self.add_more_option_defaults(parser)

        # read from config file, overrides hardcoded
        """
    >>> open('blip_uploader.cfg').read()
    '[global]\ncategory=7\nlicense=13\ntopics=test\n'
    >>> config.read('blip_uploader.cfg')
    >>> config.items('global')
    [('category', '7'), ('topics', 'test'), ('license', '13')]
    """

        config = configparser.RawConfigParser()
        files = config.read(
            ['veyepar.cfg', os.path.expanduser('~/veyepar.cfg')])

        if files:
            d = dict(config.items('global'))
            d['whack'] = False  # don't want this somehow getting set in .config - too dangerous.
            parser.set_defaults(**d)
            if 'verbose' in d:
                print("using config file(s):", files)
                print(d)

        parser.add_option(
            '-m',
            '--media-dir',
            help="media files dir",
        )
        parser.add_option(
            '--tmp-dir',
            help="temp files dir (should be local)",
        )
        parser.add_option('-c', '--client')
        parser.add_option('-s', '--show')
        parser.add_option('-d', '--day')
        parser.add_option('-r', '--room', help="Location")
        parser.add_option('--dv-format', help='pal, pal_wide, ntsc, ntsc_wide')
        parser.add_option('--upload-formats', help='ogg, ogv, mp4, flv, dv')
        parser.add_option('-l', '--list', action="store_true")
        parser.add_option('-v', '--verbose', action="store_true")
        parser.add_option('-q', '--quiet', action="store_true")
        parser.add_option(
            '--debug-log',
            action="store_true",
            help="append logs to .description so it gets posted to blip")
        parser.add_option(
            '--test',
            action="store_true",
            help="test mode - do not make changes to the db.  maybe. "
            "(not fully implemented, for development use.")
        parser.add_option('--ready-state',
                          type="int",
                          help="set self.ready_state")
        parser.add_option('--force',
                          action="store_true",
                          help="override ready state and lock, use with care.")
        parser.add_option('--unlock',
                          action="store_true",
                          help="clear locked status, use with care.")
        parser.add_option('--whack',
                          action="store_true",
                          help="whack current episodes, use with care.")
        parser.add_option('--skip',
                          action="store_true",
                          help="skip processing and bump state.")
        parser.add_option('--lag',
                          type="int",
                          help="delay in seconds between processing episodes.")
        parser.add_option('--poll', help="poll every x seconds.")

        self.add_more_options(parser)

        self.options, self.args = parser.parse_args()
        # this needs to be done better:
        self.options.upload_formats = self.options.upload_formats.split()
        self.get_options()

        if self.options.verbose:
            print(self.options, self.args)

        if "pal" in self.options.dv_format:
            self.fps = 25.0
            self.bpf = 144000

        if self.options.ready_state:
            self.ready_state = self.options.ready_state

        return

    def main(self):
        self.parse_args()

        if self.options.list:
            ret = self.list()
        elif self.options.poll:
            ret = self.poll()
        else:
            ret = self.work()

        return ret
Exemplo n.º 10
0
class process(object):
  """
  Abstract class for processing.
  Provides basic options and itarators.
  Only operates on episodes in ready_state,
  or all if ready_state is None.
  if read_sate is not None and .processing() returns True, 
      bump the episode's state:
      state=ready_state+1
  """

  extra_options={} 

  # set stop to True to stop processing at the end of episode
  # will not abort a process, like an encode, upload or anything like that.
  # it just exits these loops: 
  #    for e in es: (process episodes) and do while not Done: (poll)
  stop = False 

  ready_state=None

# defaults to ntsc stuff
  # fps=29.98
  fps=30000/1001.0
  bpf=120000

  def run_cmd(self,cmd):
    """
    given command list
    if verbose prints stuff,
    runs it, returns pass/fail.
    """
    if self.options.verbose:
        print cmd
        print ' '.join(cmd)

    if self.options.test:
        print "TEST: not running command."
        return True

    p=subprocess.Popen(cmd)
    p.wait()
    retcode=p.returncode
    if retcode:
        if self.options.verbose:
            print "command failed"
            print retcode
        ret = False
    else:
        ret = True
    return ret

  def run_cmds(self, episode, cmds):
      """
      given a list of commands
      append them to the episode's shell script
      then run each
      abort and return False if any fail.
      """

      script_pathname = os.path.join(self.work_dir, episode.slug+".sh")
      sh = open(script_pathname,'a')

      for cmd in cmds: 
          if type(cmd)==list:
              print cmd
              log_text = ' '.join(cmd)
          else:
              log_text = cmd
              cmd=cmd.split()
          sh.writelines([t.encode('utf-8','ignore') for t in log_text])
          # sh.writelines(log_text)
          # if isinstance(s, unicode): return s.encode('utf-8') else: return s
          sh.write('\n')
          # self.log_info(log_text)
          if self.options.debug_log:
              episode.description += "\n{0:>s}\n".format(log_text, )
              episode.save()

          if not self.run_cmd(cmd):
              return False

      sh.write('\n')
      sh.close()

      return True

  def set_dirs(self,show):
      client = show.client
      self.show_dir = os.path.join(
          self.options.media_dir,client.slug,show.slug)
      if self.options.tmp_dir:
          self.tmp_dir = self.options.tmp_dir
      else:
          self.tmp_dir = os.path.join(self.show_dir,"tmp")
      # change me to "cmd" or something before the next show
      self.work_dir = os.path.join(self.show_dir,"tmp")

      return


  def log_in(self,episode):
    """
    log_in/out
    create logs, and lock.unlock the episode
    """
    where=socket.gethostname()
    if os.environ.get('STY') is not None:
        where += ":" + os.environ['STY']
    what_where = "%s@%s" % (self.__class__.__name__, where)
    episode.locked = datetime.datetime.now()
    episode.locked_by = what_where
    # save the lock to disk
    episode.save()
    try:
        state = State.objects.get(id=episode.state)
    except State.DoesNotExist:
        state = None
    self.start=datetime.datetime.now()
    self.log=Log(episode=episode,
        state=state,
        ready = datetime.datetime.now(),
        start = datetime.datetime.now(),
        result = what_where)
    self.log.save()

  def log_info(self,text):
    self.log.result += text + '\n'

  def log_out(self, episode):

    # done processing
    # log the end time
    # unlock the episode

    self.log.end = datetime.datetime.now()
    self.log.save()

    episode.locked = None
    episode.locked_by = ''
    episode.save()

  def process_ep(self, episode):
    print "stubby process_ep", episode.id, episode.name
    return 

  def process_eps(self, episodes):
    ret = None 
    sleepytime=False
    for e in episodes:
      # next line requires the db to make sure the lock field is fresh
      ep=Episode.objects.get(pk=e.id)
      if self.options.unlock: ep.locked=None
      if ep.locked and not self.options.force:
        if self.options.verbose:
          print '#%s: "%s" locked on %s by %s' % (ep.id, ep.name, ep.locked, ep.locked_by)
          ret = None
      else:
        # None means "don't care", 
        # ready means ready, 
        # force is dangerous and will likely mess tings up.
        if self.ready_state is None \
           or ep.state==self.ready_state \
           or self.options.force:

            self.set_dirs(ep.show)
            self.episode_dir=os.path.join( 
                self.show_dir, 'dv', ep.location.slug )

            if self.options.verbose: print ep.name
     
            if self.options.lag:
                if sleepytime: 
                    # don't lag on the first one that needs processing,
                    # we only want to lag between the fence posts.
                    print "lagging....", self.options.lag
                    time.sleep(self.options.lag)
                else:
                     sleepytime = True

            self.log_in(ep)

            if not self.options.quiet: print self.__class__.__name__, ep.id, ep.name
            if self.options.skip:
                ret = True
            else:
                ret = self.process_ep(ep)
            if self.options.verbose: print "process_ep:", ret

            # .process is long running (maybe, like encode or post) 
            # so refresh episode in case its .stop was set 
            # (would be set in some other process, like the UI)
            ep=Episode.objects.get(pk=e.id)

            if ret:
                # if the process doesn't fail,
                # and it was part of the normal process, 
                # don't bump if the process was forced, 
                # even if it would have been had it not been forced.
                # if you force, you know better than the process,
                # so the process is going to let you bump.
                # huh?!  
                # so..  ummm... 
                # 1. you can't bump None
                # 2. don't bump when in test mode
                # 3. if it wasn't forced:, bump.
                if self.ready_state is not None \
                        and not self.options.test \
                        and not self.options.force:
                    # bump state
                    ep.state += 1
            self.end = datetime.datetime.now()
            ep.save()
            self.log_out(ep)
            if ep.stop: 
                if self.options.verbose: print ".STOP set on the episode."
                # send message to .process_eps which bubbles up to .poll 
                self.stop = True
                # re-set the stop flag.
                ep.stop = False
                ep.save()
                break

        else:
            if self.options.verbose:
                print '#%s: "%s" is in state %s, ready is %s' % (
                    ep.id, ep.name, ep.state, self.ready_state)

    return ret


  def one_show(self, show):

    """
 
    """
    self.set_dirs(show)

    locs = Location.objects.filter(show=show)
    if self.options.room:
        loc=Location.objects.get(name=self.options.room)
        locs=locs.filter(location=loc)

    for loc in locs:
        if self.options.verbose: print loc.name
        episodes = Episode.objects.filter( location=loc).order_by(
            'sequence','start',)
        if self.options.day:
            episodes=episodes.filter(start__day=self.options.day)
        for day in [17,18,19,20,21]:
            # self.process_eps(episodes.filter(start__day=day))
            es=episodes.filter(start__day=day)
            self.process_eps(es)

  def work(self):
        """
        find and process episodes
        """
        episodes = Episode.objects
        if self.options.client: 
            clients = Client.objects.filter(slug=self.options.client)
            episodes = episodes.filter(show__client__in=clients)
        if self.options.show: 
            shows = Show.objects.filter(slug=self.options.show)
            episodes = episodes.filter(show__in=shows)
        if self.options.day:
            episodes = episodes.filter(start__day=self.options.day)
        if self.options.room:
            episodes = episodes.filter(location__slug=self.options.room)
        if self.args:
            episodes = episodes.filter(id__in=self.args)

        self.start=datetime.datetime.now()
        ret = self.process_eps(episodes)
        self.end=datetime.datetime.now()
        work_time = self.end-self.start
        if work_time.seconds or True:
            print "run time: %s minutes" % (work_time.seconds/60)

        return ret

  def poll(self):
        done=False
        while not done:
            ret = self.work()
            if self.stop:
                done=True
            else: 
                if self.options.verbose: print "sleeping...."
                time.sleep(int(self.options.poll))
        return ret


  def list(self):
    """
    list clients and shows.
    """
    for client in Client.objects.all():
        print "\nName: %s  Slug: %s" %( client.name, client.slug )
        for show in Show.objects.filter(client=client):
            print "\tName: %s  Slug: %s" %( show.name, show.slug )
            print "\t--client %s --show %s" %( client.slug, show.slug )
            print "client=%s\nshow=%s" %( client.slug, show.slug )
            if self.options.verbose:
                for ep in Episode.objects.filter(show=show):
                    print "\t\t id: %s state: %s %s" % ( 
                        ep.id, ep.state, ep )
    return

  def add_more_options(self, parser):
    pass

  def add_more_option_defaults(self, parser):
    pass

  def set_options(self,*bar,**extra_options):
    # hook for test runner
    self.extra_options=extra_options

  def get_options(self):
    for k,v in self.extra_options.iteritems():
      self.options.ensure_value(k,v)
      setattr(self.options, k, v)

  def parse_args(self):
    """
    parse command line arguments.
    """
    parser = optparse.OptionParser()

    # hardcoded defaults
    parser.set_defaults(dv_format="ntsc")
    parser.set_defaults(upload_formats="mp4")
    parser.set_defaults(media_dir=os.path.expanduser('~/Videos/veyepar'))
    parser.set_defaults(lag=0)
    self.add_more_option_defaults(parser)

    # read from config file, overrides hardcoded
    """
    >>> open('blip_uploader.cfg').read()
    '[global]\ncategory=7\nlicense=13\ntopics=test\n'
    >>> config.read('blip_uploader.cfg')
    >>> config.items('global')
    [('category', '7'), ('topics', 'test'), ('license', '13')]
    """

    config = ConfigParser.RawConfigParser()
    files=config.read(['veyepar.cfg',
                os.path.expanduser('~/veyepar.cfg')])

    if files:
        d=dict(config.items('global'))
        d['whack']=False # don't want this somehow getting set in .config - too dangerous.
        parser.set_defaults(**d)
        if 'verbose' in d: 
            print "using config file(s):", files
            print d


    parser.add_option('-m', '--media-dir', 
        help="media files dir", )
    parser.add_option('--tmp-dir', 
        help="temp files dir (should be local)", )
    parser.add_option('-c', '--client' )
    parser.add_option('-s', '--show' )
    parser.add_option('-d', '--day' )
    parser.add_option('-r', '--room',
              help="Location")
    parser.add_option('--dv-format', 
              help='pal, pal_wide, ntsc, ntsc_wide' )
    parser.add_option('--upload-formats', 
              help='ogg, ogv, mp4, flv, dv' )
    parser.add_option('-l', '--list', action="store_true" )
    parser.add_option('-v', '--verbose', action="store_true" )
    parser.add_option('-q', '--quiet', action="store_true" )
    parser.add_option('--debug-log', action="store_true",
              help="append logs to .description so it gets posted to blip" )
    parser.add_option('--test', action="store_true",
              help="test mode - do not make changes to the db.  maybe. "
                "(not fully implemented, for development use.")
    parser.add_option('--ready-state', type="int",
              help="set self.ready_state" )
    parser.add_option('--force', action="store_true",
              help="override ready state and lock, use with care." )
    parser.add_option('--unlock', action="store_true",
              help="clear locked status, use with care." )
    parser.add_option('--whack', action="store_true",
              help="whack current episodes, use with care." )
    parser.add_option('--skip', action="store_true",
              help="skip processing and bump state." )
    parser.add_option('--lag', type="int",
        help="delay in seconds between processing episodes.")
    parser.add_option('--poll',
              help="poll every x seconds." )

    self.add_more_options(parser)

    self.options, self.args = parser.parse_args()
    # this needs to be done better:
    self.options.upload_formats = self.options.upload_formats.split()
    self.get_options()

    if self.options.verbose:
        print self.options, self.args

    if "pal" in self.options.dv_format:
        self.fps=25.0
        self.bpf=144000 

    if self.options.ready_state:
        self.ready_state = self.options.ready_state

    return 



  def main(self):
    self.parse_args()

    if self.options.list:
        ret = self.list()
    elif self.options.poll:
        ret = self.poll()
    else:
        ret = self.work()

    return ret
Exemplo n.º 11
0
class process():
    """
    Abstract class for processing.
    Provides basic options and itarators.
    Only operates on episodes in ready_state,
    or all if ready_state is None.
    if read_sate is not None and .processing() returns True,
        bump the episode's state:
        state=ready_state+1
    """

    extra_options = {}

    # set stop to True to stop processing at the end of episode
    # will not abort a process, like an encode, upload or anything like that.
    # it just exits these loops:
    #    for e in es: (process episodes) and do while not Done: (poll)
    stop = False

    ready_state = None

    # defaults to ntsc stuff
    # fps=29.98
    fps = 30000 / 1001.0
    bpf = 120000

    def save_me(self, o):
        # tring to fix the db timeout problem
        try:
            o.save()
        except DatabaseError as e:
            connection.connection.close()
            connection.connection = None
            o.save()

    def run_cmd(self, cmd):
        """
        given command list
        if verbose prints stuff,
        runs it, returns pass/fail.
        """
        if self.options.verbose:
            print(cmd)
            print(' '.join(cmd))

        if self.options.test:
            print("TEST: not running command.")
            return True

        p = subprocess.Popen(cmd)
        p.wait()
        retcode = p.returncode
        if retcode:
            if self.options.verbose:
                print("command failed")
                print(retcode)
            ret = False
        else:
            ret = True
        return ret

    def run_cmds(self, episode, cmds):
        """
        given a list of commands
        append them to the episode's shell script
        then run each
        abort and return False if any fail.
        """

        script_pathname = os.path.join(self.work_dir, episode.slug+".sh")
        sh = open(script_pathname, 'a')

        for cmd in cmds:
            if type(cmd) == list:
                print(cmd)
                log_text = ' '.join(cmd)
            else:
                log_text = cmd
                cmd = cmd.split()

            try:
                # Not sure what python v3 wants. str I guess.
                # .write(b'a') and .writeline(b'a') - Errpr must be str, not b
                sh.writelines(log_text)
                # sh.writelines([t.encode('utf-8','ignore') for t in log_text])
            except Exception as e:
                import code; code.interact(local=locals())
                import sys; sys.exit()

            # if isinstance(s, unicode): return s.encode('utf-8') else: return s
            sh.write('\n')
            # self.log_info(log_text)
            if self.options.debug_log:
                episode.description += "\n{0:>s}\n".format(log_text, )
                episode.save()

            if not self.run_cmd(cmd):
                return False

        sh.write('\n')
        sh.close()

        return True

    def file2cdn(self, show, src, dst=None):
        """
        src is relitive to the show dir.
        src and dst get filled to full paths.
        Check to see if src exists,
        if it does, try to upload it to cdn
        (rax_uploader will skip if same file exists).
        """
        print("checking:", src, end='')

        if dst is None:
            dst = src

        src = os.path.join(self.show_dir, src)
        dst = os.path.join("veyepar", show.client.slug, show.slug, dst)

        if os.path.exists(src):

            u = rax_uploader.Uploader()

            u.user = show.client.rax_id

            if not show.client.bucket_id.strip():
                raise AttributeError("client.bucket_id is blank")
            u.bucket_id = show.client.bucket_id
            u.bucket = show.client.bucket_id

            u.pathname = src
            u.key_id = dst

            print(" uploading....")
            ret = u.upload()
            print(u.new_url)
            ret = u.new_url

        else:
            print(("file2cdn can't find {}".format(src)))
            ret = False

        return ret

    def set_dirs(self, show):
        client = show.client
        self.show_dir = os.path.join(
            self.options.media_dir, client.slug, show.slug)
        if self.options.tmp_dir:
            self.tmp_dir = self.options.tmp_dir
        else:
            self.tmp_dir = os.path.join(self.show_dir, "tmp")
        # change me to "cmd" or something before the next show
        self.work_dir = os.path.join(self.show_dir, "tmp")

        return

    def log_in(self, episode):
        """
        log_in/out
        create logs, and lock.unlock the episode
        """
        where = socket.gethostname()
        if os.environ.get('STY') is not None:
            where += ":" + os.environ['STY']
        what_where = "%s@%s" % (self.__class__.__name__, where)
        episode.locked = datetime.datetime.now()
        episode.locked_by = what_where[:35]
        # save the lock to disk
        episode.save()
        try:
            state = State.objects.get(sequence=episode.state)
        except State.DoesNotExist:
            state = None
        self.start = datetime.datetime.now()
        self.log = Log(
            episode=episode,
            state=state,
            ready=datetime.datetime.now(),
            start=datetime.datetime.now(),
            result=what_where)
        self.log.save()

    def log_info(self, text):
        self.log.result += text + '\n'

    def log_out(self, episode):
        # done processing
        # log the end time
        # unlock the episode

        self.log.end = datetime.datetime.now()
        self.log.save()

        episode.locked = None
        episode.locked_by = ''
        episode.save()

    def process_ep(self, episode):
        print("stubby process_ep: #{} state:{} {}".format(
              episode.id, episode.state, episode.name))
        return

    def ep_in_shard(self, episode):
        """shard over ...umm.. a bunch of tmux sessions I think"""
        s = os.environ.get('STY')
        if s:
            s = s.split('-')
            if len(s) == 3:
                s = s[-1]
                if s.isdigit():
                    return episode.id % 11 == int(s)
        return True

    def ep_is_available(self, episode):
        """Is episode something we want to act on? Return boolean.

        Will take a lock on the episode.
        """
        e_id = episode.id

        if not self.ep_in_shard(episode):
            return False

        with transaction.atomic():
            # require the db to make sure the lock field is fresh
            try:
                ep = Episode.objects.select_for_update(skip_locked=True) \
                    .get(pk=e_id)
            except Episode.DoesNotExist:
                print('#%s: "%s" is locked at a DB level'
                      % (e_id, episode.name))
                return False

            # ready_state:
            # None means "don't care",
            # ready == X means ready to do X,
            # force is dangerous and will likely mess tings up.
            if self.ready_state is not None \
               and ep.state != self.ready_state \
               and not self.options.force:
                if self.options.verbose:
                    print('#%s: "%s" is in state %s, ready is %s'
                          % (e_id, ep.name, ep.state, self.ready_state))
                return False

            if self.options.unlock:
                ep.locked = None
            if ep.locked and not self.options.force:
                if self.options.verbose:
                    print('#%s: "%s" locked on %s by %s'
                          % (e_id, ep.name, ep.locked, ep.locked_by))
                return False

            if not self.options.test and not self.options.skip:
                # Don't log or lock when testing
                self.log_in(ep)

        return True

    def process_eps(self, episodes):
        # if self.options.verbose: print("process_ep: enter")

        ret = None
        for e in episodes:
            if not self.ep_is_available(e):
                continue

            # It may have been a while since whe retrieved it
            # And we've just taken a lock in a separate transaction
            e.refresh_from_db()

            self.set_dirs(e.show)
            self.episode_dir = os.path.join(
                self.show_dir, 'dv', e.location.slug)

            if self.options.verbose:
                print(e.name)

            if not self.options.quiet:
                print(self.__class__.__name__, e.id, e.name)

            if not self.options.skip:
                ret = self.process_ep(e)
                if self.options.verbose:
                    print("process_ep:", ret)

            # .process is long running (maybe, like encode or post)
            # so refresh episode in case its .stop was set
            # (would be set in some other process, like the UI)

            try:
                e_id = e.id
                e = Episode.objects.get(pk=e_id)
            except DatabaseError as err:
                connection.connection.close()
                connection.connection = None
                e = Episode.objects.get(pk=e_id)

            if ret:
                # if the process doesn't fail,
                # and it was part of the normal process,
                # don't bump if the process was forced,
                # even if it would have been had it not been forced.
                # if you force, you know better than the process,
                # so the process is going to let you bump.
                # huh?!
                # so..  ummm...
                # 1. you can't bump None
                # 2. don't bump when in test mode
                # 3. if it wasn't forced:, bump.
                if self.ready_state is not None \
                        and not self.options.test \
                        and not self.options.force:
                    # bump state
                    e.state += 1
            self.end = datetime.datetime.now()
            e.save()

            if not self.options.test:
                self.log_out(e)

            if e.stop:
                if self.options.verbose:
                    print(".STOP set on the episode.")
                # send message to .process_eps which bubbles up to .poll
                self.stop = True
                # re-set the stop flag.
                e.stop = False
                e.save()
                break

            if self.options.lag:
                print("lagging....", self.options.lag)
                time.sleep(self.options.lag)

        return ret

    def one_show(self, show):
        """

        """
        self.set_dirs(show)

        locs = Location.objects.filter(show=show)
        if self.options.room:
            locs = locs.filter(slug=self.options.room)

        for loc in locs:
            if self.options.verbose:
                print(loc.name)
            # episodes = Episode.objects.filter( location=loc).order_by(
            #    'sequence','start',)
            # if self.options.day:
            #    episodes=episodes.filter(start__day=self.options.day)
            self.one_loc(show, loc)

    def work(self):
        """
        find and process episodes
        """
        # if self.options.verbose: print("work: enter")
        episodes = Episode.objects
        if self.options.client:
            clients = Client.objects.filter(slug=self.options.client)
            episodes = episodes.filter(show__client__in=clients)
        if self.options.show:
            shows = Show.objects.filter(slug=self.options.show)
            episodes = episodes.filter(show__in=shows)
        if self.options.day:
            episodes = episodes.filter(start__day=self.options.day)
        if self.options.room:
            episodes = episodes.filter(location__slug=self.options.room)
        if self.args:
            episodes = episodes.filter(id__in=self.args)

        if self.options.resume:
            episodes.exclude(log__id__gte=self.options.resume)

            """
            log = Log.objects.get(id=self.options.resume)
            start = log.start
            print(start)
            episodes = episodes.annotate( max_start=Max('log__start'))
            episodes.exclude(max_start__gte=start)
            """

        if self.ready_state is not None \
                and not self.options.force:
            episodes = episodes.filter(state=self.ready_state)

        # episodes = Episode.objects.order_by( 'sequence','start',)

        if episodes:
            self.start = datetime.datetime.now()
            ret = self.process_eps(episodes)
            self.end = datetime.datetime.now()
            work_time = self.end-self.start
            if work_time.seconds or True:
                print("run time: %s minutes" % (work_time.seconds/60))
        else:
            if self.options.poll == 0:
                print("queue empty, poll 0, exiting.")
                ret = False
            else:
                ret = True

        return ret

    def poll(self):
        done = False
        while not done:
            ret = self.work()
            if self.stop:
                done = True
            else:
                if self.options.verbose:
                    print("sleeping....")
                time.sleep(int(self.options.poll))
        return ret

    def list(self):
        """
        list clients and shows.
        """
        clients = Client.objects \
            .annotate(max_date=Max('show__episode__start')) \
            .filter(active=True) \
            .order_by('max_date') \

        if self.options.client:
            clients = clients.filter(slug=self.options.client)

        for client in clients:
            print("\nName: %s  Slug: %s" % (client.name, client.slug))
            shows = Show.objects.filter(client=client) \
                .annotate(max_date=Max('episode__start')) \
                .order_by('max_date')

            # if self.options.show:
            #    shows = shows.filter(slug=self.options.show)

            for show in shows:
                print(show)
                print("\tName: %s  Slug: %s" % (show.name, show.slug))
                print("\t--client %s --show %s" % (client.slug, show.slug))
                print("client=%s\nshow=%s" % (client.slug, show.slug))
                locations = show.locations.filter(
                        active=True).order_by('sequence')
                for loc in locations:
                    print(("room={}".format(loc.slug)))

                if self.options.verbose:
                    for ep in Episode.objects.filter(show=show):
                        print("\t\t id: %s state: %s %s"
                              % (ep.id, ep.state, ep))
        return

    def add_more_options(self, parser):
        pass

    def add_more_option_defaults(self, parser):
        pass

    def set_options(self, *bar, **extra_options):
        # hook for test runner
        self.extra_options = extra_options

    def get_options(self):
        for k, v in self.extra_options.items():
            self.options.ensure_value(k, v)
            setattr(self.options, k, v)

    def parse_args(self):
        """
        parse command line arguments.
        """
        parser = optparse.OptionParser()

        # hardcoded defaults
        # parser.set_defaults(dv_format="square_ntsc_wide")
        parser.set_defaults(dv_format="hdv_720_30p")
        parser.set_defaults(upload_formats="mp4")
        parser.set_defaults(media_dir=os.path.expanduser('~/Videos/veyepar'))
        parser.set_defaults(lag=0)
        self.add_more_option_defaults(parser)

        # read from config file, overrides hardcoded
        """
        >>> open('blip_uploader.cfg').read()
        '[global]\ncategory=7\nlicense=13\ntopics=test\n'
        >>> config.read('blip_uploader.cfg')
        >>> config.items('global')
        [('category', '7'), ('topics', 'test'), ('license', '13')]
        """

        config = configparser.RawConfigParser()
        files = config.read([
            '/etc/veyepar/veyepar.cfg',
            os.path.expanduser('~/veyepar.cfg'),
            'veyepar.cfg',
            ])

        if files:
            d = dict(config.items('global'))
            # don't want this somehow getting set in .config - too dangerous.
            d['whack'] = False
            parser.set_defaults(**d)
            if 'verbose' in d:
                print("using config file(s):", files)
                print(d)

        parser.add_option('-m', '--media-dir',
                          help="media files dir", )
        parser.add_option('--tmp-dir',
                          help="temp files dir (should be local)", )
        parser.add_option('-c', '--client')
        parser.add_option('-s', '--show')
        parser.add_option('-d', '--day')
        parser.add_option('-r', '--room',
                          help="Location")
        parser.add_option('--dv-format',
                          help='pal, pal_wide, ntsc, ntsc_wide')
        parser.add_option('--upload-formats',
                          help='ogg, ogv, mp4, flv, dv')
        parser.add_option('-l', '--list', action="store_true")
        parser.add_option('-v', '--verbose', action="store_true")
        parser.add_option('-q', '--quiet', action="store_true")
        parser.add_option(
            '--debug-log', action="store_true",
            help="append logs to .description so it gets posted to blip")
        parser.add_option(
            '--test', action="store_true",
            help="test mode - do not make changes to the db.  maybe. "
                 "(not fully implemented, for development use.")
        parser.add_option('--ready-state', type="int",
                          help="set self.ready_state")
        parser.add_option('--force', action="store_true",
                          help="override ready state and lock, use with care.")
        parser.add_option('--unlock', action="store_true",
                          help="clear locked status, use with care.")
        parser.add_option('--whack', action="store_true",
                          help="whack current episodes, use with care.")
        parser.add_option('--skip', action="store_true",
                          help="skip processing and bump state.")
        parser.add_option('--resume', type="int",
                          help="resume a failed run.")
        parser.add_option('--lag', type="int",
                          help="delay in seconds between processing episodes.")
        parser.add_option('--poll',
                          help="poll every x seconds.")

        self.add_more_options(parser)

        self.options, self.args = parser.parse_args()
        # strip # from #123
        self.args = [a.strip('#') for a in self.args]

        # this needs to be done better:
        self.options.upload_formats = self.options.upload_formats.split()

        self.get_options()

        if self.options.verbose:
            # import code; code.interact(local=locals())
            pprint(self.options.__dict__)
            pprint(self.args)

        if "pal" in self.options.dv_format:
            self.fps = 25.0
            self.bpf = 144000

        if self.options.ready_state:
            self.ready_state = self.options.ready_state

        return

    def main(self):
        self.parse_args()

        if self.options.list:
            ret = self.list()
        elif self.options.poll:
            ret = self.poll()
        else:
            ret = self.work()

        return ret
Exemplo n.º 12
0
def database_add_new_log(request):
    constraint = helpers.constraint(request, "POST");
    data = constraint.safe({
        "contact_number2": False,
        "purpose": False,
        "type": True,
        "visitor_id": True,
        "document_from": False,
        "document_type" : False
    });

    try:
        of_user = UserProfile.objects.get(user=request.user.id);
        of_person = Person.objects.get(id=data['visitor_id']);

        log_details_params = {
            "person_visitor": of_person,
            "contact_number":data['contact_number2'],
            "added_by" : of_user
        };

        if data['document_type']:
            log_details_params['document_type'] = Document_type.objects.get(id=data['document_type']);

        if data['document_from']:
            log_details_params['document_from'] = Department.objects.get(id=data['document_from']);

        of_log_details = Log_details(**log_details_params);

        of_log_details.full_clean();
        of_log_details.clean();
        of_log_details.save();

        of_log = Log(
            type=data['type'],
            purpose=data['purpose'],
            details=of_log_details,
            added_by=of_user
        );

        try:
            of_log.full_clean();
            of_log.clean();
            of_log.save();
        except e :
            of_log_details.delete();
            raise Exception(e);
            pass;

        return render(request, "ajax_temp/after_added_new_log.html", {
            'log': of_log,
            "obj_log" : Log,
            "log_details_person" : of_log.details.person_visitor
        });

    except Person.DoesNotExist:
        raise UserProfile.DoesNotExist("Index id of Person object does not exists");

    except UserProfile.DoesNotExist:
        raise UserProfile.DoesNotExist("Index id of UserProfile object does not exists");

    except helpers.InvalidRequest:
        return HttpResponse('Invalid Request');

    pass;
Exemplo n.º 13
0
def database_add_new_visitor(request):

    constraint = helpers.constraint(request, "POST");
    data = constraint.safe({
        "contact_number": False,
        "department": False,
        "first_name": True,
        "last_name": True,
        "middle_name": False,
        "gender": True,
        "purpose": False,
        "type": True,
        "contact_number2": False,
        "document_type": False,
        "document_from": False
    });

    of_user = UserProfile.objects.get(user=request.user.id);

    person_params = {
        "first_name": data['first_name'],
        "last_name": data['last_name'],
        "middle_name": data['middle_name'],
        "gender": data['gender'],
        "added_by": of_user
    };

    if data['contact_number']:
        person_params['contact_number'] = data['contact_number'];
        pass;

    if data['department']:
        person_params['department'] = Department.objects.get(id=data['department']);

    of_person = Person(**person_params);

    of_person.full_clean();
    of_person.clean();
    of_person.save();

    log_details_params = {
        "person_visitor": of_person,
        "contact_number":data['contact_number2'],
        "added_by" : of_user
    };

    if data['document_type']:
        log_details_params['document_type'] = Document_type.objects.get(id=data['document_type']);

    if data['document_from']:
        log_details_params['document_from'] = Department.objects.get(id=data['document_from']);

    of_log_details = Log_details(**log_details_params);

    of_log_details.full_clean();
    of_log_details.clean();
    of_log_details.save();

    of_log = Log(
        type=data['type'],
        purpose=data['purpose'],
        details=of_log_details,
        added_by=of_user
    );

    try:
        of_log.full_clean();
        of_log.clean();
        of_log.save();
    except e :
        of_log_details.delete();
        raise Exception(e);
        pass;

    return render(request, "ajax_temp/after_added_new_log.html", {
        'log': of_log,
        "obj_log" : Log,
        "log_details_person" : of_log.details.person_visitor
    });
Exemplo n.º 14
0
def answer(request):

    json_str = ((request.body).decode('utf-8'))
    received_json_data = json.loads(json_str)
    datacontent = received_json_data['userRequest']['utterance']
    user_key = received_json_data['userRequest']['user']['properties']['plusfriendUserKey']

    user = User.get_or_create(user_key)

    bot_user = User.get_or_create('sunwoobot')
    if not bot_user.user_name:
        bot_user.set_name("선우봇")

    start = datetime.datetime.now()

    cmd = datacontent.split()[0]
    data = re.sub(cmd + " ", "", datacontent)

    if user.state == 'lazylet' and cmd == '/내카드':
        try:
            set_ = Lazylet_Set.objects.get(user=user)
        except Lazylet_Set.DoesNotExist:
            set_ = Lazylet_Set(user=user, title=str(user.user_name) + "의 세트")
            set_.save()

        if not Lazylet_Term.objects.filter(lazylet_set=set_).exists():
            setempty = "[귀찮렛 베타]\n세트가 비어 있습니다."

            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'simpleText': {
                                'text': setempty
                            }
                        }
                    ],
                    'quickReplies': [
                        {
                            'label': '/내카드',
                            'action': 'message',
                            'messageText': '/내카드'
                        },
                        {
                            'label': '/카드추가',
                            'action': 'message',
                            'messageText': '/카드추가'
                        }
                    ]
                }

            }
        else:
            term_list = Lazylet_Term.objects.filter(lazylet_set=set_)
            paginator = Paginator(term_list, 5)  # Show 5 terms per page

            page = data
            terms = paginator.get_page(page)
            items = []
            for t in terms:
                item = {
                    'title': t.term,
                    'description': t.definition,
                    'link': {
                        'web': 'http://dic.daum.net/search.do?dic=eng&q=' + t.term
                    }
                }
                if t.image_url:
                    item['imageUrl'] = t.image_url
                items.append(item)
            quickReplies = [
                {
                    'label': '내보내기',
                    'action': 'message',
                    'messageText': '/내보내기'
                },
                {
                    'label': '/내카드',
                    'action': 'message',
                    'messageText': '/내카드'
                },
                {
                    'label': '/카드추가',
                    'action': 'message',
                    'messageText': '/카드추가'
                },
                {
                    'label': '/지우기',
                    'action': 'message',
                    'messageText': '/지우기'
                }
            ]
            if terms.has_next():
                quickReplies.insert(0, {
                    'label': '다음',
                    'action': 'message',
                    'messageText': '/내카드 ' + str(terms.next_page_number())
                })
            if terms.has_previous():
                quickReplies.insert(0, {
                    'label': '이전',
                    'action': 'message',
                    'messageText': '/내카드 ' + str(terms.previous_page_number())
                })
            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'listCard': {
                                'header': {
                                    'title': '내 카드'
                                },
                                'items': items
                            }
                        }
                    ],
                    'quickReplies': quickReplies
                }

            }

    elif user.state == 'lazylet' and cmd == '/내보내기':
        try:
            set_ = Lazylet_Set.objects.get(user=user)
        except Lazylet_Set.DoesNotExist:
            set_ = Lazylet_Set(user=user, title=str(user.user_name) + "의 세트")
            set_.save()

        if not Lazylet_Term.objects.filter(lazylet_set=set_).exists():
            setempty = "[귀찮렛 베타]\n세트가 비어 있습니다."

            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'simpleText': {
                                'text': setempty
                            }
                        }
                    ],
                    'quickReplies': [
                        {
                            'label': '/내카드',
                            'action': 'message',
                            'messageText': '/내카드'
                        },
                        {
                            'label': '/카드추가',
                            'action': 'message',
                            'messageText': '/카드추가'
                        }
                    ]
                }

            }
        else:
            term_set = Lazylet_Term.objects.filter(lazylet_set=set_)
            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'simpleText': {
                                'text': "\n".join(['%s\t%s' % (term.term, term.definition) for term in term_set])
                            }
                        },
                        {
                            'basicCard': {
                                'description': 'Quizlet을 사용하고 있나요? 단어 목록을 복사하여 Quizlet에 붙여넣기만 하면 됩니다. 간단하죠?',
                                'buttons': [
                                    {
                                        'action': 'webLink',
                                        'label': 'Quizlet으로 가져오기',
                                        'webLinkUrl': 'https://quizlet.com/ko/help/2444107/import-content-to-quizlet'
                                    }
                                ]
                            }
                        }
                    ],
                    'quickReplies': [
                        {
                            'label': '/내카드',
                            'action': 'message',
                            'messageText': '/내카드'
                        },
                        {
                            'label': '/카드추가',
                            'action': 'message',
                            'messageText': '/카드추가'
                        },
                        {
                            'label': '/지우기',
                            'action': 'message',
                            'messageText': '/지우기'
                        }
                    ]
                }

            }

    elif user.state == 'lazylet' and cmd == '/카드추가':
        try:
            set_ = Lazylet_Set.objects.get(user=user)
        except Lazylet_Set.DoesNotExist:
            set_ = Lazylet_Set(user=user, title=str(user.user_name) + "의 세트")
            set_.save()

        if not Lazylet_Term.objects.filter(lazylet_set=set_).exists():
            setempty = "[귀찮렛 베타]\n여러분이 배우고 있는 단어나 문장을 입력하세요. Daum 사전 덕분에 뜻이 그 옆에 마법처럼 나타납니다."

            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'simpleText': {
                                'text': setempty
                            }
                        }
                    ],
                    'quickReplies': [
                        {
                            'label': '/내카드',
                            'action': 'message',
                            'messageText': '/내카드'
                        }
                    ]
                }

            }
        else:
            term_set = Lazylet_Term.objects.filter(lazylet_set=set_)
            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'simpleText': {
                                'text': "\n".join(['%s\t%s' % (term.term, term.definition) for term in term_set])
                            }
                        }
                    ],
                    'quickReplies': [
                        {
                            'label': '/내카드',
                            'action': 'message',
                            'messageText': '/내카드'
                        },
                        {
                            'label': '/지우기',
                            'action': 'message',
                            'messageText': '/지우기'
                        }
                    ]
                }

            }

    elif user.state == 'lazylet' and cmd == '/지우기':
        try:
            set_ = Lazylet_Set.objects.get(user=user)
        except Lazylet_Set.DoesNotExist:
            set_ = Lazylet_Set(user=user, title=str(user.user_name) + "의 세트")
            set_.save()
        Lazylet_Term.objects.filter(lazylet_set=set_).delete()
        setempty = "[귀찮렛 베타]\n세트가 비어 있습니다."
        response_body = {
            'version': "2.0",
            'template': {
                'outputs': [
                    {
                        'simpleText': {
                            'text': setempty
                        }
                    }
                ],
                'quickReplies': [
                    {
                        'label': '/내카드',
                        'action': 'message',
                        'messageText': '/내카드'
                    },
                    {
                        'label': '/카드추가',
                        'action': 'message',
                        'messageText': '/카드추가'
                    }
                ]
            }
        }

    elif user.state == 'lazylet' and not cmd.startswith('/'):
        words = re.findall("[\w']+", datacontent)
        try:
            set_ = Lazylet_Set.objects.get(user=user)
        except Lazylet_Set.DoesNotExist:
            set_ = Lazylet_Set(user=user, title=str(user.user_name) + "의 세트")
            set_.save()
        for w in words:
            term = Lazylet_Term(lazylet_set=set_, term=w,
                                definition="로드 중...", image_url="")
            term.save()
        t = Lazylet_GetMeaningWordsThread(set_)
        t.start()
        t.join(3)

        if len(words) == 1:
            basicCard = {
                'description': '[귀찮렛 베타]\n성공적으로 추가되었습니다.\n모든 카드를 보려면 /내카드 를 입력하십시오.\n\n %s\t%s' % (words[0], Lazylet_Term.objects.get(lazylet_set=set_, term=words[0]).definition),
                'buttons': [
                    {
                        'action': 'webLink',
                        'label': 'Daum 사전에서 보기',
                        'webLinkUrl': 'http://dic.daum.net/search.do?dic=eng&q=' + words[0]
                    }
                ]
            }
            if Lazylet_Term.objects.get(lazylet_set=set_, term=words[0]).image_url:
                basicCard['thumbnail'] = {
                    'imageUrl': Lazylet_Term.objects.get(lazylet_set=set_, term=words[0]).image_url
                }
            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'basicCard': basicCard
                        }
                    ],
                    'quickReplies': [
                        {
                            'label': '/내카드',
                            'action': 'message',
                            'messageText': '/내카드'
                        },
                        {
                            'label': '/지우기',
                            'action': 'message',
                            'messageText': '/지우기'
                        }
                    ]
                }

            }
        else:
            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'simpleText': {
                                'text': '[귀찮렛 베타]\n성공적으로 추가되었습니다.\n모든 카드를 보려면 /내카드 를 입력하십시오.\n\n ' + "\n".join(['%s\t%s' % (w, Lazylet_Term.objects.get(lazylet_set=set_, term=w).definition) for w in words])
                            }
                        }
                    ],
                    'quickReplies': [
                        {
                            'label': '/내카드',
                            'action': 'message',
                            'messageText': '/내카드'
                        },
                        {
                            'label': '/지우기',
                            'action': 'message',
                            'messageText': '/지우기'
                        }
                    ]
                }

            }

    elif user.state == 'wordchain' and cmd == '/랭킹':
        try:
            player = WordChain_Player.objects.get(user=user)
        except WordChain_Player.DoesNotExist:
            player = WordChain_Player(user=user)
            player.save()

        player_list = WordChain_Player.objects.all().order_by('-score')
        paginator = Paginator(player_list, 5)  # Show 5 players per page

        page = data
        players = paginator.get_page(page)
        items = []
        for idx, p in enumerate(players):
            item = {
                'title': str(players.start_index() + idx) + ". " + p.user.user_name,
                'description': str(p.score) + "점"
            }
            items.append(item)
        quickReplies = [
            {
                'label': '뒤로',
                'action': 'message',
                'messageText': '/끝말톡'
            },
            {
                'label': '/랭킹',
                'action': 'message',
                'messageText': '/랭킹'
            }
        ]
        if players.has_next():
            quickReplies.insert(0, {
                'label': '다음',
                'action': 'message',
                'messageText': '/랭킹 ' + str(players.next_page_number())
            })
        if players.has_previous():
            quickReplies.insert(0, {
                'label': '이전',
                'action': 'message',
                'messageText': '/랭킹 ' + str(players.previous_page_number())
            })
        response_body = {
            'version': "2.0",
            'template': {
                'outputs': [
                    {
                        'listCard': {
                            'header': {
                                'title': '🏆 랭킹'
                            },
                            'items': items
                        }
                    }
                ],
                'quickReplies': quickReplies
            }

        }

    elif user.state == 'setusername' and not cmd.startswith('/'):
        if not User.objects.filter(user_name=datacontent).exists():
            user.set_name(datacontent)

            user.state = 'home'
            user.save(update_fields=['state'])

            setusername = "******" + user.user_name + "님! 선우봇에 오신 것을 환영합니다!"

            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'simpleText': {
                                'text': setusername
                            }
                        }
                    ],
                    'quickReplies': [
                        {
                            'label': '/끝말톡',
                            'action': 'message',
                            'messageText': '/끝말톡'
                        },
                        {
                            'label': '/귀찮렛',
                            'action': 'message',
                            'messageText': '/귀찮렛'
                        },
                        {
                            'label': '/도움말',
                            'action': 'message',
                            'messageText': '/도움말'
                        }
                    ]
                }

            }
        else:
            setusername = "******"

            response_body = {
                'version': "2.0",
                'template': {
                    'outputs': [
                        {
                            'simpleText': {
                                'text': setusername
                            }
                        }
                    ]
                }

            }

    elif cmd == '/귀찮렛':
        user.state = 'lazylet'
        user.save(update_fields=['state'])

        lazylet = "[귀찮렛 베타]\n어학 사전을 찾는 것이 귀찮으신가요? 선우봇 귀찮렛 베타가 대신 찾아드립니다."

        response_body = {
            'version': "2.0",
            'template': {
                'outputs': [
                    {
                        'basicCard': {
                            'description': lazylet,
                            'thumbnail': {
                                'imageUrl': 'https://ryuhyuncom.files.wordpress.com/2019/01/lazylet-1.png'
                            }
                        }
                    }
                ],
                'quickReplies': [
                    {
                        'label': '/내카드',
                        'action': 'message',
                        'messageText': '/내카드'
                    },
                    {
                        'label': '/카드추가',
                        'action': 'message',
                        'messageText': '/카드추가'
                    },
                    {
                        'label': '/지우기',
                        'action': 'message',
                        'messageText': '/지우기'
                    }
                ]
            }

        }

    elif cmd == '/끝말톡':
        user.state = 'wordchain'
        user.save(update_fields=['state'])

        wordchain = "[끝말톡 이전 안내]\n\n끝말톡 온라인의 정식 버전이 출시되었어요!\n새로운 플러스친구 @끝말톡 (http://pf.kakao.com/_YzzWj)에서 지금 만나실 수 있습니다.\n오픈 베타 서비스가 종료됨에 따라, 모든 기존 사용자 데이터는 초기화되는 점에 유의하시기 바랍니다.\n\n그동안 끝말톡 오픈 베타를 이용해주셔서 감사드리며 더 좋은 서비스로 찾아뵙도록 하겠습니다."

        response_body = {
            'version': "2.0",
            'template': {
                'outputs': [
                    {
                        'basicCard': {
                            'description': wordchain,
                            'thumbnail': {
                                'imageUrl': 'http://ryuhyun.com/wp-content/uploads/2019/02/wordchain-1.png',
                                'fixedRatio': True
                            }
                        }
                    }
                ],
                'quickReplies': [
                    {
                        'label': '/랭킹',
                        'action': 'message',
                        'messageText': '/랭킹'
                    }
                ]
            }

        }

    else:
        user.state = 'home'
        user.save(update_fields=['state'])

        help = "봇 이름 : 선우봇\n버전 : " + version + \
            "\n제작자 : 류현(박선우)\n\n 앱을 실행하려면 /<앱 이름>을 사용하십시오."

        response_body = {
            'version': "2.0",
            'template': {
                'outputs': [
                    {
                        'simpleText': {
                            'text': help
                        }
                    }
                ],
                'quickReplies': [
                    {
                        'label': '/끝말톡',
                        'action': 'message',
                        'messageText': '/끝말톡'
                    },
                    {
                        'label': '/귀찮렛',
                        'action': 'message',
                        'messageText': '/귀찮렛'
                    },
                    {
                        'label': '/도움말',
                        'action': 'message',
                        'messageText': '/도움말'
                    }
                ]
            }

        }

    time_diff = datetime.datetime.now() - start

    if not user.user_name:
        user.state = 'setusername'
        user.save(update_fields=['state'])

        setusername = "******"

        response_body = {
            'version': "2.0",
            'template': {
                'outputs': [
                    {
                        'simpleText': {
                            'text': setusername
                        }
                    }
                ]
            }

        }

    Log.write(user, datacontent, str(response_body), time_diff.total_seconds())

    return JsonResponse(response_body)