public function createRewriteFeature(Gadget $gadget)
 {
     $requires = $gadget->getRequires();
     if (!isset($requires[ContentRewriteFeature::$REWRITE_TAG])) {
         return;
     }
     $rewriteFeature = $requires[ContentRewriteFeature::$REWRITE_TAG];
     $rewriteParams = $rewriteFeature->getParams();
     if (isset($rewriteParams[ContentRewriteFeature::$INCLUDE_URLS])) {
         $this->includeParam = $this->normalizeParam($rewriteParams[ContentRewriteFeature::$INCLUDE_URLS], '//');
     } else {
         $this->includeParam = '//';
     }
     if (isset($rewriteParams[ContentRewriteFeature::$EXCLUDE_URLS])) {
         $this->excludeParam = $this->normalizeParam($rewriteParams[ContentRewriteFeature::$EXCLUDE_URLS], '//');
     } else {
         $this->excludeParam = '//';
     }
     if (isset($rewriteParams[ContentRewriteFeature::$INCLUDE_TAGS])) {
         $this->tagsParam = $rewriteParams[ContentRewriteFeature::$INCLUDE_TAGS];
         $this->tagsParam = explode(',', $this->tagsParam);
     } else {
         $this->tagsParam = array();
     }
     if ($this->excludeParam == '.*' || $this->includeParam == null) {
         $this->includeNone = true;
     }
     if ($this->includeParam == '.*' || $this->excludeParam == null) {
         $this->includeAll = true;
     }
 }

 public function rewriteGadgetView(Gadget $gadget, ViewSpec $gadgetView)
 {
     // Dont rewrite content if the spec is unavailable
     $requires = $gadget->getRequires();
     if (isset($requires[ContentRewriteFeature::$REWRITE_TAG])) {
         // Store the feature in the spec so we dont keep parsing it
         $rewriteFeature = new ContentRewriteFeature();
         $rewriteFeature->createRewriteFeature($gadget);
     } else {
         return false;
     }
     if (!$rewriteFeature->isRewriteEnabled()) {
         return false;
     }
     if (ContentRewriteFeature::$PROXY_URL != null) {
         $defaultTags = ContentRewriteFeature::defaultHTMLTags();
         $htmlTags = null;
         if (count($rewriteFeature->getTagsParam()) > 0) {
             foreach ($rewriteFeature->getTagsParam() as $tag) {
                 if (isset($defaultTags[$tag])) {
                     $htmlTags[$tag] = $defaultTags[$tag];
                 }
             }
         } else {
             $htmlTags = $defaultTags;
         }
     }
     $gadgetView->setRewrittenContent($this->rewrite($gadgetView->getContent(), $htmlTags, $rewriteFeature->getExcludeParam(), $rewriteFeature->getIncludeParam(), Config::get('web_prefix') . ContentRewriteFeature::$PROXY_URL, $gadget->getId()->getURI(), $rewriteFeature->getTagsParam()));
     return true;
 }

 public function up()
 {
     $gadget = new Gadget();
     $gadget->setType('loginTop');
     $gadget->setName('loginForm');
     $gadget->setSortOrder(10);
     $gadget->save();
 }

 /**
  * Prepares the environment before running a test.
  */
 protected function setUp()
 {
     parent::setUp();
     $this->gadgetContext = new GadgetContext('GADGET');
     $gadgetSpecFactory = new MockRewriterGadgetFactory($this->gadgetContext, null);
     $gadgetSpecFactory->fetchGadget = null;
     $this->gadget = $gadgetSpecFactory->createGadget();
     $this->gadgetRewriter = new GadgetRewriter($this->gadgetContext);
     $this->view = $this->gadget->getView($this->gadgetContext->getView());
 }

 private function getIframeURL(Gadget $gadget, GadgetContext $context)
 {
     $v = $gadget->getChecksum();
     $view = $gadget->getView($context->getView());
     $up = '';
     foreach ($gadget->gadgetSpec->userPrefs as $pref) {
         $up .= '&up_' . urlencode($pref['name']) . '=' . urlencode($pref['value']);
     }
     $locale = $context->getLocale();
     //Note: putting the URL last, else some browsers seem to get confused (reported by hi5)
     return Config::get('default_iframe_prefix') . 'container=' . $context->getContainer() . ($context->getIgnoreCache() ? '&nocache=1' : '&v=' . $v) . ($context->getModuleId() != 0 ? '&mid=' . $context->getModuleId() : '') . '&lang=' . $locale['lang'] . '&country=' . $locale['country'] . '&view=' . $view['view'] . $up . '&url=' . urlencode($context->getUrl());
 }

 public function up()
 {
     $criteria = new Criteria();
     $criteria->add(GadgetPeer::TYPE, 'mobileLoginContents');
     $criteria->add(GadgetPeer::NAME, 'loginForm');
     if (!GadgetPeer::doSelectOne($criteria)) {
         $gadget = new Gadget();
         $gadget->setType('mobileLoginContents');
         $gadget->setName('loginForm');
         $gadget->setSortOrder(10);
         $gadget->save();
     }
 }

 public function save()
 {
     foreach ($this->values as $type => $gadgets) {
         if (!$gadgets) {
             continue;
         }
         foreach ($gadgets as $value) {
             $gadget = new Gadget();
             $gadget->setType($type);
             $gadget->setName($value);
             $gadget->save();
         }
     }
 }

 /**
  *
  * @param Gadget $gadget
  * @throws GadgetException
  */
 protected function renderGadget(Gadget $gadget)
 {
     $view = $gadget->getView($this->context->getView());
     $renderClasses = Config::get('gadget_renderer');
     foreach ($renderClasses as $renderClass => $constraints) {
         // if current view meets the configurated renderer constraints
         // render the gadget and stop checking
         if ($this->checkConstraints($view, $constraints)) {
             $gadgetRenderer = new $renderClass($this->context);
             $gadgetRenderer->renderGadget($gadget, $view);
             return;
         }
     }
     throw new GadgetException("Invalid view type");
 }

 private function getList()
 {
     $data = array();
     $result = $this->getResult();
     $gadgets = Gadget::loadStructuredList();
     foreach ($gadgets as $category => $list) {
         if (!$this->neededNames || isset($this->neededNames[$category])) {
             $row = array();
             if (isset($this->props['name'])) {
                 $row['name'] = $category;
             }
             if ($category !== "") {
                 if (isset($this->props['title'])) {
                     $row['desc'] = wfMessage("gadget-section-{$category}")->parse();
                 }
             }
             if (isset($this->props['members'])) {
                 $row['members'] = count($list);
             }
             $data[] = $row;
         }
     }
     $result->setIndexedTagName($data, 'category');
     $result->addValue('query', $this->getModuleName(), $data);
 }

 /**
  * logs a user in
  *
  * Status Codes:<br />
  * 0: success<br />
  * 1: incorrect password<br />
  * 1: incorrect email<br />
  *
  * @param   String  $u          Username
  * @param   String  $p          Password
  * @param   Boolean $redirect   redirect on successful login
  * @return  Int     status code
  */
 public static function log_user_in($u, $p, $redirect = true) {
     if ($_SESSION['logged_in']) {
         self::logout();
     }
     $u   = dbi()->escape($u);
     $ip  = $_SESSION['IpAddr'];
     if ($row = dbi()->q_1("SELECT CustomerID, Password FROM Customers WHERE Email = '$u'")) {
         if (crypt($p, $row->Password) == $row->Password) { // match found
             self::force_login($row->CustomerID);
             if ($redirect) {
                 if ($_SESSION['last_page']) {
                     $page = $_SESSION['last_page'];
                     unset($_SESSION['last_page']);
                 } else {
                     $page = '/';
                 }
                 Gadget::redirect($page);
             }
             return 0;
         } else { // incorrect password
             return 1;
         }
     } else { // email not found
         return 2;
     }
 }

    function testPreferences()
    {
        global $wgUser, $wgOut, $wgTitle;
        // This test makes call to the parser which requires valids Outputpage
        // and Title objects. Set them up there, they will be released at the
        // end of the test.
        $old_wgOut = $wgOut;
        $old_wgTitle = $wgTitle;
        $wgTitle = Title::newFromText('Parser test for Gadgets extension');
        // Proceed with test setup:
        $prefs = array();
        $context = new RequestContext();
        $wgOut = $context->getOutput();
        $wgOut->setTitle(Title::newFromText('test'));
        Gadget::loadStructuredList('* foo | foo.js
==keep-section1==
* bar| bar.js
==remove-section==
* baz [rights=embezzle] |baz.js
==keep-section2==
* quux [rights=read] | quux.js');
        $this->assertTrue(GadgetHooks::getPreferences($wgUser, $prefs), 'GetPrefences hook should return true');
        $options = $prefs['gadgets']['options'];
        $this->assertFalse(isset($options['<gadget-section-remove-section>']), 'Must not show empty sections');
        $this->assertTrue(isset($options['<gadget-section-keep-section1>']));
        $this->assertTrue(isset($options['<gadget-section-keep-section2>']));
        // Restore globals
        $wgOut = $old_wgOut;
        $wgTitle = $old_wgTitle;
    }

 protected function renderGadget(Gadget $gadget)
 {
     $view = $gadget->getView($this->context->getView());
     if ($view['type'] == 'URL') {
         require_once "src/gadgets/render/GadgetUrlRenderer.php";
         $gadgetRenderer = new GadgetUrlRenderer($this->context);
     } elseif ($view['type'] == 'HTML' && empty($view['href'])) {
         require_once "src/gadgets/render/GadgetHtmlRenderer.php";
         $gadgetRenderer = new GadgetHtmlRenderer($this->context);
     } elseif (empty($view['type']) || !empty($view['href'])) {
         require_once "src/gadgets/render/GadgetHrefRenderer.php";
         $gadgetRenderer = new GadgetHrefRenderer($this->context);
     } else {
         throw new GadgetException("Invalid view type");
     }
     $gadgetRenderer->renderGadget($gadget, $view);
 }

 public function __construct(Gadget $gadget, $options = array(), $CSRFSecret = null)
 {
     $this->gadget = $gadget;
     parent::__construct(array(), $options, $CSRFSecret);
     $config = Doctrine::getTable('Gadget')->getGadgetConfigListByType($options['type']);
     if (empty($config[$gadget->getName()]['config'])) {
         throw new RuntimeException('The gadget has not registered or it doesn\'t have any configuration items.');
     }
     $gadgetConfig = $config[$gadget->getName()]['config'];
     foreach ($gadgetConfig as $key => $value) {
         $this->setWidget($key, opFormItemGenerator::generateWidget($value));
         $this->setValidator($key, opFormItemGenerator::generateValidator($value));
         $config = Doctrine::getTable('GadgetConfig')->retrieveByGadgetIdAndName($gadget->getId(), $key);
         if ($config) {
             $this->setDefault($key, $config->getValue());
         }
     }
     $this->widgetSchema->setNameFormat('gadget_config[%s]');
 }

 public function up()
 {
     $eventNavigation = new Navigation();
     $eventNavigation->setType('community');
     $eventNavigation->setUri('communityEvent/listCommunity');
     $eventNavigation->setSortOrder(6);
     $eventNavigation->setCaption('Events', 'en');
     $eventNavigation->setCaption('イベントリスト', 'ja_JP');
     $gadget = new Gadget();
     $gadget->setType('contents');
     $gadget->setName('recentCommunityEventComment');
     $gadget->setSortOrder(132);
     $gadget->save();
     $gadget = new Gadget();
     $gadget->setType('mobileContents');
     $gadget->setName('recentCommunityEventComment');
     $gadget->setSortOrder(111);
     $gadget->save();
 }

 public function up()
 {
     $gadget = new Gadget();
     $gadget->setType('top');
     $gadget->setName('birthdayBox');
     $gadget->setSortOrder(0);
     $gadget->save();
     $gadget = new Gadget();
     $gadget->setType('mobileTop');
     $gadget->setName('birthdayBox');
     $gadget->setSortOrder(0);
     $gadget->save();
     $gadget = new Gadget();
     $gadget->setType('profileTop');
     $gadget->setName('birthdayBox');
     $gadget->setSortOrder(0);
     $gadget->save();
     $gadget = new Gadget();
     $gadget->setType('mobileProfileTop');
     $gadget->setName('birthdayBox');
     $gadget->setSortOrder(0);
     $gadget->save();
 }

    function testPreferences()
    {
        $prefs = array();
        Gadget::loadStructuredList('* foo | foo.js
==keep-section1==
* bar| bar.js
==remove-section==
* baz [rights=embezzle] |baz.js
==keep-section2==
* quux [rights=read] | quux.js');
        $this->assertTrue(GadgetHooks::getPreferences(new User(), $prefs), 'GetPrefences hook should return true');
        $options = $prefs['gadgets']['options'];
        $this->assertFalse(isset($options['<gadget-section-remove-section>']), 'Must not show empty sections');
        $this->assertTrue(isset($options['<gadget-section-keep-section1>']));
        $this->assertTrue(isset($options['<gadget-section-keep-section2>']));
    }

 /**
  * Fetches all remote resources simultaniously using a multiFetchRequest to optimize rendering time.
  *
  * The preloads will be json_encoded to their gadget document injection format, and the locales will
  * be reduced to only the GadgetContext->getLocale matching entries.
  *
  * @param Gadget $gadget
  * @param GadgetContext $context
  */
 protected function fetchResources(Gadget &$gadget)
 {
     $contextLocale = $this->context->getLocale();
     $unsignedRequests = $signedRequests = array();
     foreach ($gadget->gadgetSpec->locales as $key => $locale) {
         // Only fetch the locales that match the current context's language and country
         if ($locale['country'] == 'all' && $locale['lang'] == 'all' || $locale['lang'] == $contextLocale['lang'] && $locale['country'] == 'all' || $locale['lang'] == $contextLocale['lang'] && $locale['country'] == $contextLocale['country']) {
             if (!empty($locale['messages'])) {
                 $transformedUrl = RemoteContentRequest::transformRelativeUrl($locale['messages'], $this->context->getUrl());
                 if (!$transformedUrl) {
                     // remove any locales that are not applicable to this context
                     unset($gadget->gadgetSpec->locales[$key]);
                     continue;
                 } else {
                     $gadget->gadgetSpec->locales[$key]['messages'] = $transformedUrl;
                 }
                 // locale matches the current context, add it to the requests queue
                 $request = new RemoteContentRequest($gadget->gadgetSpec->locales[$key]['messages']);
                 $request->createRemoteContentRequestWithUri($gadget->gadgetSpec->locales[$key]['messages']);
                 $request->getOptions()->ignoreCache = $this->context->getIgnoreCache();
                 $unsignedRequests[] = $request;
             }
         } else {
             // remove any locales that are not applicable to this context
             unset($gadget->gadgetSpec->locales[$key]);
         }
     }
     if (!$gadget->gadgetContext instanceof MetadataGadgetContext) {
         // Add preloads to the request queue
         foreach ($gadget->getPreloads() as $preload) {
             if (!empty($preload['href'])) {
                 $request = new RemoteContentRequest($preload['href']);
                 if (!empty($preload['authz']) && $preload['authz'] == 'SIGNED') {
                     if ($this->token == '') {
                         throw new GadgetException("Signed preloading requested, but no valid security token set");
                     }
                     $request = new RemoteContentRequest($preload['href']);
                     $request->setAuthType(RemoteContentRequest::$AUTH_SIGNED);
                     $request->setNotSignedUri($preload['href']);
                     $request->setToken($this->token);
                     $request->getOptions()->ignoreCache = $this->context->getIgnoreCache();
                     if (strcasecmp($preload['signViewer'], 'false') == 0) {
                         $request->getOptions()->viewerSigned = false;
                     }
                     if (strcasecmp($preload['signOwner'], 'false') == 0) {
                         $request->getOptions()->ownerSigned = false;
                     }
                     $signedRequests[] = $request;
                 } else {
                     $request->createRemoteContentRequestWithUri($preload['href']);
                     $request->getOptions()->ignoreCache = $this->context->getIgnoreCache();
                     $unsignedRequests[] = $request;
                 }
             }
         }
         // Add template libraries to the request queue
         if ($gadget->gadgetSpec->templatesRequireLibraries) {
             foreach ($gadget->gadgetSpec->templatesRequireLibraries as $key => $libraryUrl) {
                 $request = new RemoteContentRequest($libraryUrl);
                 $transformedUrl = RemoteContentRequest::transformRelativeUrl($libraryUrl, $this->context->getUrl());
                 if (!$transformedUrl) {
                     continue;
                 } else {
                     $gadget->gadgetSpec->templatesRequireLibraries[$key] = $transformedUrl;
                 }
                 $request->createRemoteContentRequestWithUri($gadget->gadgetSpec->templatesRequireLibraries[$key]);
                 $request->getOptions()->ignoreCache = $this->context->getIgnoreCache();
                 $unsignedRequests[] = $request;
             }
         }
     }
     // Perform the non-signed requests
     $responses = array();
     if (count($unsignedRequests)) {
         $brc = new BasicRemoteContent();
         $resps = $brc->multiFetch($unsignedRequests);
         foreach ($resps as $response) {
             $responses[$response->getUrl()] = array('body' => $response->getResponseContent(), 'rc' => $response->getHttpCode());
         }
     }
     // Perform the signed requests
     if (count($signedRequests)) {
         $signingFetcherFactory = new SigningFetcherFactory(Config::get("private_key_file"));
         $remoteFetcherClass = Config::get('remote_content_fetcher');
         $remoteFetcher = new $remoteFetcherClass();
         $remoteContent = new BasicRemoteContent($remoteFetcher, $signingFetcherFactory);
         $resps = $remoteContent->multiFetch($signedRequests);
         foreach ($resps as $response) {
             $responses[$response->getNotSignedUrl()] = array('body' => $response->getResponseContent(), 'rc' => $response->getHttpCode());
         }
     }
//.........这里部分代码省略.........

<?php
require '../includes/global.inc.php';
debug(1, 1, 0);

if (!$_SESSION['madison_status_UserName']) {
    Gadget::redirect('/admin');
}

$date = date(DATE_FORMAT_MYSQL, strtotime('next Tuesday', strtotime('-1 day')));

$date_do = new DateTime($date);

switch ($date) {
    case '2013-12-24':
        $date_do->setDate('2013', '12', '23');
        break;
    case '2013-12-31':
        $date_do->setDate('2013', '12', '30');
        break;
}
$date_delivery   = $date_do->format('n/j/Y');
?>
<!doctype html>
<html>
    <head>
        <style type="text/css" media="screen">
            .order{
                margin-bottom:20px;
                font-family: "Gill Sans", "Gill Sans MT", "Myriad Pro", "DejaVu Sans Condensed", Helvetica, Arial, sans-serif, sans-serif; font-size: 10pt; line-height: 1.1;
            }
            .header_image img{

                        $newPromoCodeAmount = $promoCodeAmount - $giftCertAmount;
                        if ($newPromoCodeAmount < 0) {
                            $newPromoCodeAmount = 0;
                        }
                        $dbi->update('PromoCodes', array('Amount' => $newPromoCodeAmount), array('PromoCodeID' => $PromoCodeID));
                    }
                }

                //Gadget::add_message('success');
                Gadget::redirect('success2');
            } else {
                Gadget::add_message($transaction->get_error_message());
            }
        } catch (Exception $e) {
            s('Error: ' . $e->getMessage() . $transaction->get_error_message());
            Gadget::add_message($e->getMessage() . $transaction->get_error_message());
        }
    }
}

$page = Page::get_from_alias('giftcertificates');
$page->add_js('/js/giftcertificates.js');

require 'header.php';
?>
<div class="content-padding">
    <div><?php echo $page->content['main']; ?></div>
    <form class="user-form" name="giftcertificates-form" id="checkout-form" action="giftcertificates" method="post" onsubmit="return validateForm();">
        <table>
            <tbody>
                <tr style="vertical-align:top;">

 /**
  * @param $g Gadget
  * @return array
  */
 private function fakeMetadata(Gadget $g)
 {
     return array('settings' => array('rights' => $g->getRequiredRights(), 'skins' => $g->getRequiredSkins(), 'default' => $g->isOnByDefault(), 'hidden' => false, 'shared' => false, 'category' => $g->getCategory()), 'module' => array('scripts' => $g->getScripts(), 'styles' => $g->getStyles(), 'dependencies' => $g->getDependencies(), 'messages' => array()));
 }