send a review notification to the shop owner.
340825
public function SendReviewReportNotification()
    {
        $this->SaveActionIdToComment();
        $oMail = TDataMailProfile::GetProfile('report-review');
        $aData = array();
        $oShop = TdbShop::GetInstance();
        $oArticle = &$this->GetFieldShopArticle();
        $aData['sArticleName'] = $oArticle->GetName();
        $aData['sReviewId'] = $this->id;
        $aData['sReviewTitle'] = $this->fieldTitle;
        $aData['sReviewText'] = $this->fieldComment;
        $aData['sReviewAuthor'] = $this->fieldAuthorName;
        $aData['sUnlockReviewLink'] = "<a href='".$this->GetUnlockURL(true)."'>".TGlobal::OutHtml(TGlobal::Translate('chameleon_system_shop_article_review.action.publish_comment')).'</a> ';
        $aData['sDeleteReviewLink'] = "<a href='".$this->GetDeleteWithActionIdURL(true)."'>".TGlobal::OutHtml(TGlobal::Translate('chameleon_system_shop_article_review.action.delete_comment')).'</a> ';
        $aData['shopname'] = $oShop->GetName();
        $oMail->AddDataArray($aData);
        $oMail->SendUsingObjectView('emails', 'Customer');
    }
1046509
def notification_message(cls, item):
        ''''''
        assert isinstance(item, Notification)
        return cls.encode_payload(cls.request_payload(item, None))
704366
def notify(self, force_notify=None, use_email=None, use_sms=None, **kwargs):
        
        notified = False
        instance = kwargs.get("instance")
        if instance._meta.label_lower == self.model:
            notified = super().notify(
                force_notify=force_notify,
                use_email=use_email,
                use_sms=use_sms,
                **kwargs,
            )
        return notified
259081
def send_notification(self, method, *args):
        
        message = self._version.create_request(method, args, notification=True)
        self.send_message(message)
772405
def do_notify(self, line):
        

        def f(p, method, params):
            p.send_notification(method, params)

        self._request(line, f)
755067
def update_orders(self, market_id, instructions, customer_ref=None):
        
        return self.make_api_request(
            'Sports',
            'updateOrders',
            utils.get_kwargs(locals()),
            model=models.UpdateExecutionReport,
        )
752585
def notify_change(self, change):
        """"""
        # Send the state to the frontend before the user-registered callbacks
        # are called.
        name = change['name']
        if self.comm is not None and self.comm.kernel is not None:
            # Make sure this isn't information that the front-end just sent us.
            if name in self.keys and self._should_send_property(name, getattr(self, name)):
                # Send new state to front-end
                self.send_state(key=name)
        super(Widget, self).notify_change(change)
875317
public function notifyCreate()
    {
        if (\Yii::$app->reviews2->notifyEmails) {
            foreach (\Yii::$app->reviews2->notifyEmails as $email) {
                \Yii::$app->mailer->compose('@skeeks/cms/reviews2/mail/new-message', [
                    'model' => $this
                ])
                    ->setFrom([\Yii::$app->cms->adminEmail => \Yii::$app->cms->appName])
                    ->setTo($email)
                    ->setSubject(\Yii::t('skeeks/reviews2', "Added a new review") . " #" . $this->id)
                    ->send();
            }
        }
    }
1060700
def _notify(self, title, message, expected_action=None):
        
        if self.editor is None:
            return
        inital_value = self.editor.save_on_focus_out
        self.editor.save_on_focus_out = False
        self._flg_notify = True
        dlg_type = (QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
        expected_action = (
            lambda *x: None) if not expected_action else expected_action
        if (self._auto_reload or QtWidgets.QMessageBox.question(
                self.editor, title, message, dlg_type,
                QtWidgets.QMessageBox.Yes) == QtWidgets.QMessageBox.Yes):
            expected_action(self.editor.file.path)
        self._update_mtime()
        self.editor.save_on_focus_out = inital_value
1182178
function notify(oldVal, newVal) {
	var count = 0;
        for (var key in watchers) {
	  var watcher = watchers[key];
          watcher.call(this, key, oldVal, newVal);
          count++;
        }

        return count;
      }
1106158
def add_review(self, review):
        
        for r in self.reviews:
            if r.id == review.id:
                return
        self.reviews.append(review)
267360
def broadcast(self, command, *args, **kwargs):
        
        criterion = kwargs.pop('criterion', self.BROADCAST_FILTER_ALL)
        for index, user in items(self.users()):
            if criterion(user, command, *args, **kwargs):
                self.notify(user, command, *args, **kwargs)
284418
def addcomment(self, order_increment_id,
            status, comment=None, notify=False):
        
        if comment is None:
            comment = ""
        return bool(self.call(
                'sales_order.addComment',
                [order_increment_id, status, comment, notify]
            )
        )
31958
def send_ready_for_review(build_id, release_name, release_number):
    """"""
    build = models.Build.query.get(build_id)

    if not build.send_email:
        logging.debug(
            'Not sending ready for review email because build does not have '
            'email enabled. build_id=%r', build.id)
        return

    ops = operations.BuildOps(build_id)
    release, run_list, stats_dict, _ = ops.get_release(
        release_name, release_number)

    if not run_list:
        logging.debug(
            'Not sending ready for review email because there are '
            ' no runs. build_id=%r, release_name=%r, release_number=%d',
            build.id, release.name, release.number)
        return

    title = '%s: %s - Ready for review' % (build.name, release.name)

    email_body = render_template(
        'email_ready_for_review.html',
        build=build,
        release=release,
        run_list=run_list,
        stats_dict=stats_dict)

    recipients = []
    if build.email_alias:
        recipients.append(build.email_alias)
    else:
        for user in build.owners:
            recipients.append(user.email_address)

    if not recipients:
        logging.debug(
            'Not sending ready for review email because there are no '
            'recipients. build_id=%r, release_name=%r, release_number=%d',
            build.id, release.name, release.number)
        return

    message = Message(title, recipients=recipients)
    message.html = email_body

    logging.info('Sending ready for review email for build_id=%r, '
                 'release_name=%r, release_number=%d to %r',
                 build.id, release.name, release.number, recipients)

    return render_or_send(send_ready_for_review, message)
242559
function giveAnswer(answeringPlayer, answer) {
    if(answeringPlayer === seller) return;
    if(answer <= currentBid) return;

    buyer = answeringPlayer;
    currentBid = answer;

    resetTimer();
    notify(false);
  }
1273333
def notify(contact_request)
      @contact_request = contact_request

      mail to: notification_recipients,
           from: notification_sender(contact_request),
           subject: notification_subject
    end
149386
private void requestNotification() {
        AndPermission.with(this)
            .notification()
            .permission()
            .rationale(new NotifyRationale())
            .onGranted(new Action<Void>() {
                @Override
                public void onAction(Void data) {
                    toast(R.string.successfully);
                }
            })
            .onDenied(new Action<Void>() {
                @Override
                public void onAction(Void data) {
                    toast(R.string.failure);
                }
            })
            .start();
    }