Checks to see if a tansfer has been completed.
18363
def is_transfer_complete(self, relation_name):
    """"""
    phold = self.data_access.sql_writer.to_placeholder()
    return self.data_access.find_model(
      Relation,
      ("name = {0} and completed_at is not null".format(phold), [relation_name])) is not None
379778
private void checkNotFinished() throws CmsUgcException {

        if (m_finished) {
            String message = Messages.get().container(Messages.ERR_FORM_SESSION_ALREADY_FINISHED_0).key(
                getCmsObject().getRequestContext().getLocale());
            throw new CmsUgcException(CmsUgcConstants.ErrorCode.errInvalidAction, message);
        }
    }
915887
public function isFinished()
    {
        $batch = $this->getBatch();
        if ($this->_finished) {
            $batch->resetCounter('movestarted');
            $moved    = $batch->getCounter('moved');
            $notFound = $batch->getCounter('notfound');
            
            $this->getBatch()->addMessage(
                    sprintf($this->_('%d \'%s\' survey answers have been copied to \'%s\'.'),
                            $moved,
                            $this->sourceSurveyName,
                            $this->targetSurveyName));
            if ($notFound > 0) {
                $this->getBatch()->addMessage(sprintf($this->_('For %d tokens no answers were found.'), $notFound));
            }
        } else {
            if ($this->getBatch()->getCounter('movesteps') === 0) {
                // Add 1 to the counter to keep going
                $this->getBatch()->addStepCount(1);
            }
        }
        return $this->_finished;
    }
909582
public function is_finished() {

        if ($this->finished === null) {
            $endtime = $this->get_end();
            if ($endtime === 0 || $this->now < $endtime) {
                // It is not yet finished or no idea when it finishes.
                $this->finished = false;
            } else {
                $this->finished = true;
            }
        }

        return $this->finished;
    }
912833
function softwareUpdate_waitForCheckFinished(timeout) {
    timeout = timeout ? timeout : gTimeoutUpdateCheck;

    this._controller.waitFor(function() {
      return this.currentPage != WIZARD_PAGES.checking;
    }, "Check for updates has been completed.", timeout, null, this);
  }
280336
def unfinished_items(self):
    """"""
    return [(key, stat) for key, stat in self._statuses.items() if stat not in self.DONE_STATES]
549076
def finished(self):
        
        self.progress_bar.set_state(ProgressBar.STATE_DONE)
        self.progress_bar.show()
41959
def complete(self):
        
        return self.valid and (self.access_token or self.refresh_token or self.type == 2)
44414
def is_done(self):
        
        if not self.is_ready():
            return False
        done = (self._state.content['isDone'] == '1')
        return done
509675
def _check_fulfilled(self):
        
        is_fulfilled = False
        result = None
        start_time = time.time()

        # Check whether the promise has been fulfilled until we run out of time or attempts
        while self._has_time_left(start_time) and self._has_more_tries():

            # Keep track of how many attempts we've made so far
            self._num_tries += 1

            is_fulfilled, result = self._check_func()

            # If the promise is satisfied, then continue execution
            if is_fulfilled:
                break

            # Delay between checks
            time.sleep(self._try_interval)

        return is_fulfilled, result
903782
def on_finished(self):
        """"""
        self.controller.is_running = False

        error = self.controller.current_error
        if error is not None:
            self.info(self.tr("Stopped due to error(s), see Terminal."))
        else:
            self.info(self.tr("Finished successfully!"))
351664
def not_completed(f):
    

    @wraps(f)
    def check_if_complete(cls, *args, **kwargs):
        if cls.is_complete:
            raise FMBaseError('Transfer already completed.')

        return f(cls, *args, **kwargs)

    return check_if_complete
592530
public boolean isCompleted() {
    WorkingState state = getWorkingState();
    return state == WorkingState.SUCCESSFUL || state == WorkingState.COMMITTED || state == WorkingState.FAILED;
  }
601748
public void run(final StatusUpdate onStatus,
                    final Command onCompletion) {
        //Ensure active analysis is cancelled
        cancelExistingAnalysis();

        //If there are no checks to run simply return
        if (rechecks.isEmpty()) {
            if (onCompletion != null) {
                onCompletion.execute();
                return;
            }
        }

        checkRunner.run(rechecks,
                        onStatus,
                        onCompletion);
        rechecks.clear();
    }
940301
def _completion_checker(async_id, context_id):
    """"""

    if not context_id:
        logging.debug("Context for async %s does not exist", async_id)
        return

    context = FuriousContext.from_id(context_id)
    marker = FuriousCompletionMarker.get_by_id(context_id)

    if marker and marker.complete:
        logging.info("Context %s already complete" % context_id)
        return True

    task_ids = context.task_ids
    if async_id in task_ids:
        task_ids.remove(async_id)

    logging.debug("Loaded context.")
    logging.debug(task_ids)

    done, has_errors = _check_markers(task_ids)

    if not done:
        return False

    _mark_context_complete(marker, context, has_errors)

    return True
700056
private boolean isReady() {
    if (this.status != Status.READY) {
      // e.g. if the node is disabled, it is not ready to run.
      return false;
    }
    for (final Node parent : this.parents) {
      if (!parent.status.isSuccessEffectively()) {
        return false;
      }
    }
    return true;
  }
483899
function () {
      var i;
      for (i = 0; i < arguments.length; i++) {
         if ( ! (this.has_activity_completed(arguments[i]) || this.has_lambda_completed(arguments[i]) || this.childworkflow_completed(arguments[i])  || this.timer_fired(arguments[i]) ) ) {
            return false;
         }
      }
      return true;
   }