Part of Slepp's ProjectsPastebinTURLImagebinFilebin
Feedback -- English French German Japanese
Create Upload Newest Tools Donate
Sign In | Create Account

Something
Monday, September 3rd, 2012 at 7:25:07pm UTC 

  1. <?php
  2.  
  3. // Copyright (c) 2012 PHP Experts, Inc.
  4. // All rights reserved.
  5.  
  6. // Iteration 3: Create Tax Drivers.
  7. set_include_path(get_include_path() . PATH_SEPARATOR .
  8.  realpath('../'));
  9.  
  10. // This uses my Thrive framework, which extends
  11. // the Flourish framework.
  12. // NOTE: Using require, or require_once has performance penalties that aren't
  13. //       necessary.  If the file isn't loaded successfully, the app will crash
  14. //       anyway.
  15. include_once 'thrive/Autoloader.php';
  16. new Thrive_Autoloader;
  17.  
  18. // Iteration 2: Create the Data Models.
  19.  
  20. // TIP: By always building out class datatypes instead of relying on hashmaps (array keys0, you
  21. //      make it much easier to create what's called an API that people can easily use later.
  22. class TaxBracket
  23. {
  24.         public $min;
  25.         public $max;
  26.         public $rate;
  27. }
  28.  
  29. // Let's create an interface for our new taxing system.
  30. interface API_Tax
  31. {
  32.         public function getTaxLiability(fMoney $revenue, fMoney $deductions);
  33. }
  34.  
  35. // It makes more sense to use a Factory for this.
  36. // Uses the Factory Design Pattern.
  37. class USFederalTaxesFactory
  38. {
  39.         public static function create(fMoney $revenue, fMoney $deductions, $numOfEmployees)
  40.         {
  41.                 // TODO: Rearchitect out the magic Constants.
  42.                 // TODO: Add a proper Service Locator Pattern here...
  43.                 $taxes = array(
  44.                         'ssi' => 'SocialSecurityTax',
  45.                         'medicare' => 'MedicareTax',
  46.                         //'unemployment' => 'UnemploymentTax',
  47.                 );
  48.                 foreach ($taxes as $taxName => $taxClass)
  49.                 {
  50.                         $tax = new $taxClass();
  51.                         /** @var $tax API_Tax */
  52.                         $liabilities[$taxName] = $tax->getTaxLiability($revenue, $deductions);
  53.                 }
  54.  
  55.                 $tax = new UnemploymentTax($numOfEmployees);
  56.                 $liabilities['unemployment'] = $tax->getTaxLiability($revenue, $deductions);
  57.  
  58.                 $incomeTax = new USFederalIncomeTax($revenue, $deductions, $liabilities);
  59.  
  60.                 return $incomeTax;
  61.         }
  62. }
  63.  
  64. // FIXME: Figure out a way to save the API_Tax interface ;-/
  65. class USFederalIncomeTax /* implements API_Tax*/
  66. {
  67.         // AVOID MAGIC CONSTANTS.
  68.         // FIXME: These need to be moved to their own classes. It's a serious weakness right now!!!!
  69.         const INCOME_TAX_KEY = 'income';
  70.         const SSI_TAX_KEY = 'ssi';
  71.         const MEDCARE_TAX_KEY = 'medicare';
  72.         const UNEMPLOYMENT_TAX_KEY = 'unemployment';
  73.  
  74.         /** @var TaxBracketManager */
  75.         protected $bracketManager;
  76.  
  77.         /** @var TaxBracket[] */
  78.         protected $brackets;
  79.  
  80.         /** @var fMoney */
  81.         protected $revenue;
  82.  
  83.         /** @var fMoney */
  84.         protected $deductions;
  85.  
  86.         /** @var fMoney[] */
  87.         protected $taxLiabilities;
  88.  
  89.         public function __construct(fMoney $revenue, fMoney $deductions, array $otherTaxLiabilities, $bracketManager = null)
  90.         {
  91.                 $this->amountOwed = new fMoney('0', 'USD');
  92.  
  93.                 $this->revenue = $revenue;
  94.                 $this->deductions = $deductions;
  95.                 $this->taxLiabilities = $otherTaxLiabilities;
  96.  
  97.                 if ($bracketManager === null)
  98.                 {
  99.                         $bracketManager = new TaxBracketManager();
  100.                 }
  101.                 $this->bracketManager = $bracketManager;
  102.         }
  103.  
  104.         /**
  105.          * @param $tax
  106.          * @return fMoney
  107.          * @throws LogicException*/
  108.         public function getLiabilityByTax($tax)
  109.         {
  110.                 if (!isset($this->taxLiabilities[$tax]))
  111.                 {
  112.                         throw new LogicException("No tax liabilities named '$tax'");
  113.                 }
  114.  
  115.                 return $this->taxLiabilities[$tax];
  116.         }
  117.  
  118.         public function getTaxLiability()
  119.         {
  120.                 $brackets = $this->fetchTaxBracketRates();
  121.  
  122.                 // Federal income tax algorithm works like this:
  123.                 // Total Revenue - Qualified Deductions - Other Fed Taxes -> Tax Brackets -> Rate.
  124.                 // Minimum possible taxes owed: $0.
  125.  
  126.                 $otherTaxes = new fMoney(0, 'USD');
  127.                 // TODO: It'd be a nice-to-have to be able to dynamically figure out which
  128.                 // taxes are non-income and just do a foreach() here...
  129.                 $otherTaxes = $otherTaxes->add($this->getLiabilityByTax(self::SSI_TAX_KEY));
  130.                 $otherTaxes = $otherTaxes->add($this->getLiabilityByTax(self::MEDCARE_TAX_KEY));
  131.                 $otherTaxes = $otherTaxes->add($this->getLiabilityByTax(self::UNEMPLOYMENT_TAX_KEY));
  132.  
  133.                 $amountOwed = $this->calculateTaxLiability($this->revenue, $this->deductions, $otherTaxes);
  134.                 $this->taxLiabilities[self::INCOME_TAX_KEY] = $amountOwed;
  135.                 return $amountOwed;
  136.         }
  137.  
  138.         protected function calculateTaxLiability(fMoney $taxableRevenue, fMoney $deductions, fMoney $otherTaxes)
  139.         {
  140.                 if (isset($_GET['debug']))
  141.                 {
  142.                         echo "<pre>";
  143.                         echo "[income] Total revenue: $taxableRevenue\n";
  144.                         echo "[income] Qualified deductions: " . $deductions . "\n";
  145.                         echo "[income] Other Federal tax liabilities: " . $otherTaxes . "\n";
  146.                 }
  147.  
  148.                 $taxableRevenue = $taxableRevenue->sub($deductions);
  149.                 $taxableRevenue = $taxableRevenue->sub($otherTaxes);
  150.  
  151.                 if (isset($_GET['debug']))
  152.                 {
  153.                         echo "[income] Taxable revenue: $taxableRevenue\n";
  154.                         echo "----------\n";
  155.                 }
  156.  
  157.                 $totalTaxLiability = new fMoney(0, 'USD');
  158.                 foreach ($this->brackets as /** @var TaxBracket */ $bracket)
  159.                 {
  160.                         // Assume 500 0000
  161.                         // Algorithm: Get subvalue -> get liability -> add liability -> subtract subvalue -> continue
  162.                         if ($bracket->max !== null)
  163.                         {
  164.                                 $amountTaxedInBracket = $bracket->max - $bracket->min;
  165.                         }
  166.                         else
  167.                         {
  168.                                 $amountTaxedInBracket = $taxableRevenue;
  169.                         }
  170.  
  171.                         if ($taxableRevenue->lte($amountTaxedInBracket))
  172.                         {
  173.                                 $amountTaxedInBracket = $taxableRevenue;
  174.                         }
  175.  
  176.                         $taxLiability = new fMoney($amountTaxedInBracket, 'USD');
  177.                         $taxLiability = $taxLiability->mul($bracket->rate);
  178.  
  179.                         $totalTaxLiability = $totalTaxLiability->add($taxLiability);
  180.  
  181.                         $taxableRevenue = $taxableRevenue->sub($amountTaxedInBracket);
  182.  
  183.                         if (isset($_GET['debug']))
  184.                         {
  185.                                 echo "[income] Bracket tax rate: {$bracket->rate}\n";
  186.                                 echo "[income] Income taxed in bracket: {$bracket->min} ... {$bracket->max}\n";
  187.                                 echo "[income] Amount in bracket: $amountTaxedInBracket\n";
  188.                                 echo "[income] Tax Lability in bracket: $taxLiability\n";
  189.                                 echo "[income] Taxable revenue: $taxableRevenue\n";
  190.                                 echo "[income] Total Taxable liability: $totalTaxLiability\n";
  191.                                 echo "------------\n";
  192.                         }
  193.  
  194.                         if ($taxableRevenue->lte(0))
  195.                         {
  196.                                 break;
  197.                         }
  198.                 }
  199.  
  200.                 if (isset($_GET['debug']))
  201.                 {
  202.                         echo "</pre>";
  203.                 }
  204.  
  205.                 return $totalTaxLiability;
  206.         }
  207.  
  208.         protected function fetchTaxBracketRates()
  209.         {
  210.                 if ($this->brackets !== null)
  211.                 {
  212.                         return $this->brackets;
  213.                 }
  214.  
  215.                 // TODO: Load this from a database table.
  216.                 // FIXME: Add more brackets.
  217.                 // TIP: By doing a little extra work now, all i have to do later is do $pdo->fetchArray() later ;-)
  218.                 // I **LOVE** our complicated corporate income tax system!! WOOO!!!!!
  219.  
  220.                 $brackets = $this->bracketManager->fetchAll();
  221.                 $this->brackets = $brackets;
  222.  
  223.                 return $brackets;
  224.         }
  225. }
  226.  
  227. class TaxBracketManager
  228. {
  229.         public function fetchTaxBrackets()
  230.         {
  231.                 $bracketsInfo = array(
  232.                         array('min' => 0,        'max' => 50000,    'rate' => 0.15),
  233.                         array('min' => 50001,    'max' => 75000,    'rate' => 0.25),
  234.                         array('min' => 75001,    'max' => 100000,   'rate' => 0.34),
  235.                         array('min' => 100001,   'max' => 335000,   'rate' => 0.39),
  236.                         array('min' => 335001,   'max' => 10000000, 'rate' => 0.34),
  237.                         array('min' => 10000001, 'max' => 15000000, 'rate' => 0.35),
  238.                         array('min' => 15000001, 'max' => 18333333, 'rate' => 0.38),
  239.                         array('min' => 18333334, 'max' => null,     'rate' => 0.35),
  240.                 );
  241.  
  242.                 $brackets = array();
  243.                 foreach ($bracketsInfo as $i)
  244.                 {
  245.                         $bracket = new TaxBracket;
  246.                         $bracket->min = $i['min'];
  247.                         $bracket->max = $i['max'];
  248.                         $bracket->rate = $i['rate'];
  249.  
  250.                         $brackets[] = $bracket;
  251.                 }
  252.  
  253.                 return $brackets;
  254.         }
  255. }
  256.  
  257. // Social security tax does not allow for deductions. It is off of the entire gross wage.
  258. class SocialSecurityTax implements API_Tax
  259. {
  260.         public function getTaxLiability(fMoney $revenue, fMoney $deductions)
  261.         {
  262.                 $taxLiability = $this->calculateTaxLiability($revenue);
  263.  
  264.                 return $taxLiability;
  265.         }
  266.  
  267.         protected function calculateTaxLiability(fMoney $taxableRevenue)
  268.         {
  269.                 $maxTaxable = $this->fetchMaxTaxableAmount();
  270.  
  271.                 $taxableRevenue = min($maxTaxable, $taxableRevenue);
  272.                 $taxRate = $this->fetchTaxRate();
  273.                 $taxLiability = $taxableRevenue->mul($taxRate);
  274.  
  275.                 if (isset($_GET['debug']))
  276.                 {
  277.                         echo "<pre>";
  278.                         echo "[ssi] Taxable Revenue: $taxableRevenue\n";
  279.                         echo "[ssi] Tax Rate: $taxRate\n";
  280.                         echo "[ssi] Total Tax Liability: $taxLiability\n";
  281.                         echo "</pre>";
  282.                 }
  283.  
  284.                 return $taxLiability;
  285.         }
  286.  
  287.         protected function fetchMaxTaxableAmount()
  288.         {
  289.                 return new fMoney(110100, 'USD');
  290.         }
  291.  
  292.         protected function fetchTaxRate()
  293.         {
  294.                 return 0.062;
  295.         }
  296. }
  297.  
  298. // Medicare tax does not allow for deductions. It is off of the entire gross wage.
  299. class MedicareTax implements API_Tax
  300. {
  301.         public function getTaxLiability(fMoney $revenue, fMoney $deductions)
  302.         {
  303.                 $taxLiability = $this->calculateTaxLiability($revenue);
  304.  
  305.                 return $taxLiability;
  306.         }
  307.  
  308.         protected function calculateTaxLiability(fMoney $taxableRevenue)
  309.         {
  310.                 $taxRate = $this->fetchTaxRate();
  311.                 $taxLiability = $taxableRevenue->mul($taxRate);
  312.  
  313.                 if (isset($_GET['debug']))
  314.                 {
  315.                         echo "<pre>";
  316.                         echo "[medicare] Taxable Revenue: $taxableRevenue\n";
  317.                         echo "[medicare] Tax Rate: $taxRate\n";
  318.                         echo "[medicare] Total Tax Liability: $taxLiability\n";
  319.                         echo "</pre>";
  320.                 }
  321.  
  322.                 return $taxLiability;
  323.         }
  324.  
  325.         protected function fetchTaxRate()
  326.         {
  327.                 return 0.0145;
  328.         }
  329. }
  330.  
  331. // Unemployment Insurance tax does not allow for deductions. It is off of the entire gross wage.
  332. // Source: http://workforcesecurity.doleta.gov/unemploy/uitaxtopic.asp
  333. class UnemploymentTax implements API_Tax
  334. {
  335.         protected $numOfEmployees;
  336.  
  337.         public function __construct($numOfEmployees = null)
  338.         {
  339.                 if ($numOfEmployees !== null)
  340.                 {
  341.                         echo "Num of Employees 2.5: $numOfEmployees";
  342.                         $this->setNumberOfEmployees($numOfEmployees);
  343.                 }
  344.         }
  345.  
  346.         public function setNumberOfEmployees($numOfEmployees)
  347.         {
  348.                 echo "Num of Employees 3: " . $numOfEmployees;
  349.                 $this->numOfEmployees = $numOfEmployees;
  350.         }
  351.  
  352.         public function getTaxLiability(fMoney $revenue, fMoney $deductions)
  353.         {
  354.                 if (empty($this->numOfEmployees))
  355.                 {
  356.                         throw new LogicException("Cannot calculate Unemployment tax without specifying the number of employees.");
  357.                 }
  358.  
  359.                 $taxLiability = new fMoney(0, 'USD');
  360.                 for ($a = 0; $a < $this->numOfEmployees; ++$a)
  361.                 {
  362.                         $taxLiability = $taxLiability->add($this->calculateTaxLiability($revenue));
  363.                 }
  364.  
  365.                 return $taxLiability;
  366.         }
  367.  
  368.         protected function calculateTaxLiability(fMoney $taxableRevenue)
  369.         {
  370.                 if ($taxableRevenue->lte($this->fetchMinimumAmountToTax()))
  371.                 {
  372.                         return new fMoney(0, 'USD');
  373.                 }
  374.  
  375.                 $maxTaxLiability = $this->fetchMaxTaxLiability();
  376.                 $taxRate = $this->fetchTaxRate();
  377.  
  378.                 $taxLiability = $taxableRevenue->mul($taxRate);
  379.  
  380.                 if ($taxLiability->gte($maxTaxLiability))
  381.                 {
  382.                         $taxLiability = $maxTaxLiability;
  383.                 }
  384.  
  385.                 if (isset($_GET['debug']))
  386.                 {
  387.                         echo "<pre>";
  388.                         echo "[unemployment] Taxable Revenue: $taxableRevenue\n";
  389.                         echo "[unemployment] Tax Rate: $taxRate\n";
  390.                         echo "[unemployment] Total Tax Liability: $taxLiability\n";
  391.                         echo "</pre>";
  392.                 }
  393.  
  394.                 return $taxLiability;
  395.         }
  396.  
  397.         protected function fetchMinimumAmountToTax()
  398.         {
  399.                 return new fMoney(1500, 'USD');
  400.         }
  401.  
  402.         protected function fetchMaxTaxLiability()
  403.         {
  404.                 return new fMoney(56.00, 'USD');
  405.         }
  406.  
  407.         protected function fetchTaxRate()
  408.         {
  409.                 return 0.062;
  410.         }
  411. }
  412.  
  413.  
  414. class FedTaxes
  415. {
  416.         /** @var fMoney */
  417.         public $income;
  418.         /** @var fMoney */
  419.         public $ssi;
  420.         /** @var fMoney */
  421.         public $medicare;
  422.         /** @var fMoney */
  423.         public $unemployment;
  424.         /** @var fMoney */
  425.         public $total;
  426.  
  427.         public function __construct()
  428.         {
  429.                 $this->income = new fMoney(0, 'USD');
  430.                 $this->ssi = new fMoney(0, 'USD');
  431.                 $this->medicare = new fMoney(0, 'USD');
  432.                 $this->unemployment = new fMoney(0, 'USD');
  433.                 $this->total = new fMoney(0, 'USD');
  434.         }
  435. }
  436.  
  437. // Main execution path.
  438. function getTaxLiability()
  439. {
  440.         if (!empty($_POST['gross_income']))
  441.         {
  442.                 // I prefer filter_var($_POST) over filter_input(INPUT_POST) because it
  443.                 // is **impossible** to simulate form data in unit tests with filter_input().
  444.                 if (($grossIncome = filter_var($_POST['gross_income'], FILTER_SANITIZE_NUMBER_FLOAT)) === false)
  445.                 {
  446.                         throw new InvalidArgumentException("Invalid input for gross income, only numbers are accepted.");
  447.                 }
  448.                 if (($expenses = filter_var($_POST['expenses'], FILTER_SANITIZE_NUMBER_FLOAT)) === false)
  449.                 {
  450.                         throw new InvalidArgumentException("Invalid input for expenses, only numbers are accepted.");
  451.                 }
  452.                 if (($numOfEmployees = filter_var($_POST['num_of_employees'], FILTER_SANITIZE_NUMBER_INT)) === false)
  453.                 {
  454.                         throw new InvalidArgumentException("Invalid input for number of employees, only integers are accepted.");
  455.                 }
  456.                 echo "Num of Employees: $numOfEmployees";
  457.  
  458.                 fMoney::setDefaultCurrency('USD');
  459.                 $taxManager = USFederalTaxesFactory::create(new fMoney($grossIncome), new fMoney($expenses), $numOfEmployees);
  460.                 $amountOwed = $taxManager->getTaxLiability();
  461.  
  462.                 $fedTaxes = new FedTaxes;
  463.                 $fedTaxes->income = $amountOwed;
  464.                 $fedTaxes->ssi = $taxManager->getLiabilityByTax('ssi');
  465.                 $fedTaxes->medicare = $taxManager->getLiabilityByTax('medicare');
  466.                 $fedTaxes->unemployment = $taxManager->getLiabilityByTax('unemployment');
  467.  
  468.                 // TODO: fMoney **really** should be able to add multiple values at once. I mean, come on!
  469.                 foreach (array('income', 'ssi', 'medicare', 'unemployment') as $tax)
  470.                 {
  471.                         $fedTaxes->total = $fedTaxes->total->add($fedTaxes->$tax);
  472.                 }
  473.  
  474.                 return $fedTaxes;
  475.         }
  476.  
  477.         return null;
  478. }
  479.  
  480. $fedTaxes = null;
  481. try
  482. {
  483.         $fedTaxes = getTaxLiability();
  484. }
  485. catch(InvalidArgumentException $e)
  486. {
  487.         $errorMessage = "Oops! An error has occurred:<br/>\n";
  488.         $errorMessage .= $e->getMessage();
  489. }
  490. catch(Exception $e)
  491. {
  492.         $errorMessage = "Oops: An error has occured.";
  493.         $errorMessage .= $e->getMessage();
  494.  
  495.         error_log($e->getMessage());
  496. }
  497.  
  498. ?>
  499. <?php
  500. // Start of the view.
  501. $e_grossIncome = isset($_POST['gross_income']) ? htmlspecialchars($_POST['gross_income']) : '';
  502. $e_expenses = isset($_POST['expenses']) ? htmlspecialchars($_POST['expenses']) : '';
  503. $e_numOfEmployees = isset($_POST['num_of_employees']) ? htmlspecialchars($_POST['num_of_employees']) : '';
  504.  
  505. if (isset($errorMessage))
  506. {
  507.         $e_errorMessage = htmlspecialchars($errorMessage);
  508. }
  509. // Iteration 1: Create the HTML.
  510. ?>
  511. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  512. "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  513. <html xmlns="http://www.w3.org/1999/xhtml">
  514.         <head>
  515.                 <title>Federal Corporate Income Tax Calculator</title>
  516. <style type="text/css">
  517. table#tax_data_table th { text-align: left; }
  518. table#tax_data_table td { text-align: right; }
  519. </style>
  520.         </head>
  521.         <body>
  522.                 <h1>Federal Corporate Income Tax Calculator</h1>
  523.                 <p>This app is designed to calculate the estimated income tax of a corporation.</p>
  524.                 <h4>Disclaimer</h4>
  525.                 <p>This app is for educational purposes only. It is by no means a substitute for proper tax accounting services!</p>
  526.                 <p><em>Note: Because of <a href="http://workforcesecurity.doleta.gov/unemploy/uitaxtopic.asp">Congressional bungling</a>, the Unemployment Taxrate
  527.                         for 2011 is overstated (usually by just 0.2%).</em></p>
  528. <?php
  529. if (isset($e_errorMessage)):
  530. ?>
  531.                 <div id="error_messag">
  532.                         <?php echo $e_errorMessage; ?>
  533.                 </div>
  534. <?php endif; ?>
  535.                 <div id="income_form">
  536.                         <form method="post">
  537.                                 <table id="income_data_table">
  538.                                         <tr>
  539.                                                 <th><label for="gross_income">Gross income:</label></th>
  540.                                                 <td><input type="text" name="gross_income" value="<?php echo $e_grossIncome; ?>"/></td>
  541.                                         </tr>
  542.                                         <tr>
  543.                                         <th><label for="expenses">Expenses:</label></th>
  544.                                                 <td><input type="text" name="expenses" value="<?php echo $e_expenses; ?>"/></td>
  545.                                         </tr>
  546.                                         <tr>
  547.                                                 <th><label for="expenses">No. of Employees:</label></th>
  548.                                                 <td><input type="text" name="num_of_employees" value="<?php echo $e_numOfEmployees; ?>"/></td>
  549.                                         </tr>
  550.                                         <tr>
  551.                                                 <td span="2"><input type="submit" value="Calculate"></td>
  552.                                         </tr>
  553.                                 </table>
  554.                         </form>
  555.                 </div>
  556. <?php
  557. if ($fedTaxes instanceof FedTaxes):
  558. ?>
  559.                 <div id="taxes_data">
  560.                         <h3>Tax Information</h3>
  561.                         <table id="tax_data_table">
  562.                                 <tr>
  563.                                         <th>Income Tax: </th>
  564.                                         <td><?php echo $fedTaxes->income; ?></td>
  565.                                 </tr>
  566.                                 <tr>
  567.                                         <th>Social Security Tax:</th>
  568.                                         <td><?php echo $fedTaxes->ssi; ?></td>
  569.                                 </tr>
  570.                                 <tr>
  571.                                         <th>Medicare Tax:</th>
  572.                                         <td><?php echo $fedTaxes->medicare; ?></td>
  573.                                 </tr>
  574.                                 <tr>
  575.                                         <th><a href="http://workforcesecurity.doleta.gov/unemploy/uitaxtopic.asp">Unemployment Tax:</a></th>
  576.                                         <td><?php echo $fedTaxes->unemployment; ?></td>
  577.                                 </tr>
  578.                                 <tr>
  579.                                         <th>Total Liability:</th>
  580.                                         <td><?php echo $fedTaxes->total; ?></td>
  581.                                 </tr>
  582.                         </table>
  583.                 </div>
  584. <?php endif; ?>
  585.         </body>
  586. </html>

Update the Post

Either update this post and resubmit it with changes, or make a new post.

You may also comment on this post.

update paste below
details of the post (optional)

Note: Only the paste content is required, though the following information can be useful to others.

Save name / title?

(space separated, optional)



Please note that information posted here will expire by default in one month. If you do not want it to expire, please set the expiry time above. If it is set to expire, web search engines will not be allowed to index it prior to it expiring. Items that are not marked to expire will be indexable by search engines. Be careful with your passwords. All illegal activities will be reported and any information will be handed over to the authorities, so be good.

comments powered by Disqus
worth-right