text:
Florida vs. Auburn set for 3:30 p.m. kickoff
gatorsports
Florida Gators enter the stadium Saturday during Gator Walk before the first home game of the season against UT-Martin at Ben Hill Griffin Stadium. [Brad McClenny/The Gainesville Sun]
The Oct. 5 game at Ben Hill Griffin Stadium between Auburn and Florida is set for a 3:30 p.m. kickoff and carried by CBS.
The Gators will host Auburn in The Swamp for the first time since 2007. The Tigers lead the all-time series (43-38-2), as Auburn defeated the Gators at home, 17-6, in their last meeting on Oct. 15, 2011. In addition, the Gators own a 67-26-2 record in Homecoming games all-time, including a 25-5 mark since 1989.
Florida plays in The Swamp again this Saturday, hosting Towson in Ben Hill Griffin Stadium for a 4 p.m. kickoff on the SEC Network.
SEC television schedule for Saturday, Oct. 5:
Utah State at LSU, 12 p.m. ET on SEC Network
Auburn at Florida, 3:30 p.m. on CBS
Troy at Missouri, 4 p.m. on SEC Network
Georgia at Tennessee, 7 p.m. on ESPN
Vanderbilt at Ole Miss, 7:30 p.m. on SEC Network
Previous articlePitts emerges alongside Trask in UF's passing game
Next articleUF's Heggie named SEC Offensive Lineman of Week
http://gatorsports.wpengine.com
Albert_D_Alligator September 23, 2019 At 3:17 pm
Please let the o-line learn how to block by game time, or it could get real ugly…
Gator-6 September 24, 2019 At 1:43 pm
We're all holding our breath, Albert. If they improve just a little more, and Trask continues to show us how it's done, there is no reason to lose this game. None.
Unless we don't have urgency and intensity, of course.
Joe Shiver September 23, 2019 At 4:57 pm
TAMU was able to contain Auburn's offense, with the exception of a long TD run, and the Gators should be, as well. Our DL needs to bow up and be strong against the run, as well as staying in their lanes to contain and pressure Nix. Need Zuniga and Henderson back. Also need to create some turnovers, which TAMU failed to do.
The Gators probably won't be able to line up and run the ball against Auburn, so I think CDM needs to get creative in order to scratch out enough of a ground threat to keep the Tigers' D honest. I'm sure he's got a plan for EJ, some jet sweeps, and maybe a surprise or two from Trask. If the OL can give Trask enough time to find Pitts and the other receivers over the middle, 10-15 yards downfield, the Gators can move the ball and score. Just protect the ball, and don't have turnovers that give Auburn a short field.
Nix has a couple of weeks to get better, but I think the Gator D can contain him. It's too early for this, but give me UF 31-24.
StLGator September 23, 2019 At 11:32 pm
Joe, the Auburn front 7 makes the Kentucky and Miami front 7s that shut down the Gator running game look like pikers by comparison. And their DL will put max pressure on Trask on passing downs. So, the key to winning this game lies with the Gator D exercising gap discipline and TACKLING!
Some way, somehow, Gator LBs and DBs have to learn to wrap up ball carriers and TACKLE them by the time they face Gus Malzahn's spread, multi-option offense. That will force Auburn's freshman QB into must pass situations that will play to the Gator D's strength.
Just like in past Auburn games, turnovers and which team successfully runs on the other will decide this probably low scoring game.
Joe Shiver September 24, 2019 At 9:25 am
I may be too optimistic in predicting 31 points, but they would've hit 40 against UK if not for the penalties that negated Feleipe's two rushing TD's. That was on the road, and since the Auburn game is not only at home, but Homecoming as well, I'm hoping the Gator O will be fired up and motivated to have it's best game yet.
I think CDM can figure out a way to run the ball just enough to make the offense work. I don't think the Gators necessarily have to run for more yards, but they will need to have some success. I agree with you about the turnovers.
My biggest concern is the Gators' DL. They're very good, but they're built for rushing the passer, not stuffing the run. I'm concerned about whether they can be strong enough to limit the Tigers' running game. They need to be able to hold their ground and not be pushed backwards, and the D as a whole needs to get off the field on 3rd downs.
Still, I'm sticking with a prediction of a Homecoming win. Go Gators!
StLGator September 24, 2019 At 5:53 pm
I hope you're right Joe. GO GATORS!!!
Me, too, but if I'm wrong it won't be the first time. But hey, we're still undefeated now, so I'm sayin' there's a chance!


text:
Got Sciatica? Stay Active and Start Early on Physical Therapy
MONDAY, Oct. 5, 2020 (HealthDay News) -- For people with back pain caused by sciatica, it might be a good idea to start physical therapy sooner rather than later, a new clinical trial suggests.
Sciatica refers to pain that radiates along the sciatic nerve, which runs from the lower back, through the hip and down the back of the leg. It's often the result of a bulging spinal disc that compresses the nerve.
In general, people with sciatica should try to remain active and not take to bed, said study author Julie Fritz, a physical therapist and associate dean for research at the University of Utah's College of Health, in Salt Lake City.
But it's one thing to tell patients to stay active, and another to give them targeted exercises to deal with the condition, Fritz said.
So her team looked at whether starting physical therapy fairly soon after a sciatica diagnosis could speed people's recovery.
On average, the 220 study patients had suffered sciatica pain for about a month. Half were randomly assigned to four weeks of physical therapy (PT), while the rest took a wait-and-see approach.
Six months later, patients who'd received early PT were reporting less disability in their daily activities, compared to the comparison group, the researchers report in the Oct. 6 issue of the Annals of Internal Medicine.
That does not mean everyone with sciatica should start PT right off the bat, according to Fritz.
"There really is no magic-bullet, slam-dunk therapy for everyone," she said.
Some people with sciatica feel better within weeks, without any special intervention, while others have lingering pain. Even in this trial, 45% of patients in early PT said they were feeling "a great deal better" one year later. That was better than the comparison group, at just under 28% -- but it also meant a majority did not feel that degree of improvement.
Unfortunately, Fritz said, there's no way to predict which sciatica patients stand to benefit from early PT.
Low back pain is complicated, said Dr. Salvador Portugal, a physical medicine and rehabilitation specialist at NYU Langone Orthopedic Center in New York City.
Even when the source can be pegged to sciatica, there can be different "pain generators" for different people, said Portugal, who was not involved in the study.
And pain is not only physical, he pointed out, but involves psychological factors. People who become depressed or anxious, or tend to "catastrophize" pain, or become fearful of physical activity can be at risk of lasting pain.
"Some patients are afraid that physical activity will worsen the pain," Portugal said. "But the opposite is true. You want to remain active."
There are cases, he noted, where patients are in such severe pain that it makes sense to hold off on PT and use pain medication until exercise becomes more doable.
And while Portugal agreed there is no one-size-fits-all therapy for sciatica, he said the new findings do show the value of remaining physically active -- in "a controlled way."
While some sciatica patients fear activity, he noted, others adopt a "no pain, no gain" attitude. "That's not what we want, either," Portugal said.
For the trial, Fritz's team recruited 220 patients ages 18 to 60 who had sciatica pain for less than three months.
Half were randomly assigned to four weeks of PT, which included exercise, manual therapy and individualized home exercises. The other half stuck with "usual care," which included an education pamphlet on staying active.
Six months later, both groups were showing an improvement on a standard questionnaire that asked about difficulties with daily activities such as walking, sitting and lifting objects. But the improvement was greater in the PT group.
In the real world, even if people want PT, there can be obstacles, Fritz said. Not everyone has time to fit the sessions in, and insurance coverage varies.
Knowing when to start PT is tricky, too. "A fair number of patients will get better on their own pretty quickly," Fritz said. "So we're trying to balance. We don't want to over-treat, and we don't want to miss this window of opportunity where intervening can help recovery."
On average, Fritz noted, patients in the PT group had only about five sessions. "That suggests a potential benefit of early PT is that it requires less effort to gain a benefit," she said.
The U.S. National Library of Medicine has more on sciatica.
SOURCES: Julie Fritz, P.T., Ph.D., associate dean, research, College of Health, University of Utah, Salt Lake City; Salvador Portugal, D.O., M.B.A., physical medicine and rehabilitation specialist, NYU Langone Orthopedic Center, and assistant professor, rehabilitation medicine, NYU Grossman School of Medicine, New York City; Annals of Internal Medicine, Oct. 6, 2020, online
Brain Center
Cardiovascular Disease Prevention
Epidural Corticosteroid Injections
1 in 3 Americans With Arthritis Say Pain, Symptoms Persist

redpajama_set_name: RedPajamaCommonCrawl


Despite all the outrageous rhetoric from AOC and her New Green Deal, Majority Leader Mitch McConnell brought the Green New Deal resolution up for a vote without any hearings after a brief floor debate. He wanted the world to see that shutting down all air transportation and ending anything with fossil fuels would not go well with the American people. So McConnell gave the Democrats in the Senate their chance to show the world just how extreme they have become.
Yes, McConnell wanted to allow the Democrats to show everyone their agenda as environmental radicals. The Democrats blinked and voted "present," so they refused to go on record for this New Green Deal that would have no doubt been used in 2020 against them. However, with this stunt, they are claiming that they can be for it or against it since they refused to vote. How will a voter even know what they stand for? Do you vote for a person who then wants to end all air travel? One would think that is a fairly radical proposal that warrants a clear response.


School gardens need many hands to thrive and the ʻĀINA In Schools program is continuing to make connections with local partners and friends to help our gardens grow. This summer, with enormous support from First Hawaiian Bank's Community Care service program, two ʻĀINA schools received major makeovers for the new school year.
On June 23rd, 2018, Waikiki Elementary received over 110 volunteers from First Hawaiian Bank, Hands in Helping Out (HIHO), the UH Master Gardener Program, and Iolani School. Volunteers helped to prune the school orchard, clear and aerate ʻĀINA garden beds, revitalize the compost system, and clear new ground. With the help of UH Master Gardeners, keiki had the opportunity to learn about invasive species with live samples and lessons on why invasive species control is so vital. First Hawaiian Bank helped to plant a tahitian lime tree in the orchard, which some of their own children will be able to care for as Waikiki Elementary students. At the end of the Garden Party, families enjoyed a picnic lunch in the garden to cap off a fun, productive, and active morning.
This month, July 7th, 2018, another branch of First Hawaiian Bank's Community Care program convened in Waianae to support Kamaile Academy's Garden Party. With over 100 adults and keiki in attendance, volunteers, along with Kamaile and 'ĀINA In Schools staff, helped to plant a native garden border, clear new areas for cultivation, and prepare space for wauke and kalo planting. With the Waiʻanae sun for company, volunteers brought new life to the garden, ending in a much-appreciated BBQ in the school cafeteria (they even brought a shave ice machine!).
Earlier this year, First Hawaiian Bank helped to support Waialae Public Charter School during their Fall Garden Party. The Community Care program is a volunteer service program, launched in 2014, to connect employees with volunteer opportunities with local non-profits. A longtime partner of Kōkua Hawaiʻi Foundation, HIHO is a sustainable volunteerism non-profit whose continued support of ʻĀINA In Schools is a major contributor to the success of our Garden Parties. Mahalo to all of our partners and friends for helping our keiki and gardens to grow!


text:
Pennsylvania's Stubborn and "Savage Inequalities"
by Sharif El-Mekki
"Unless we have the wealth to pay for private education, we are compelled by law to go to public school—and to the public school in our district. Thus the state, by requiring attendance but refusing to require equity, effectively requires inequality. Compulsory inequity, perpetuated by state law, too frequently condemns our children to unequal lives." ― Kozol
In PA we have an unfunded funding formula. Crazy, right?!
My state makes school funding choices that are not consistent with the Constitution. Pennsylvania now has a funding formula. Finally. However, as crazy as this sounds, it is an almost completely unfunded formula. We have an almost six billion dollar education budget. However, the total budget will not be distributed with the fairer formula that the bi-partisan school funding commission came up with. Instead, only new funding will go through this equity tool. What does that look like? 3% of the total budget (only new money) will be distributed using the fair and weighted formula. Yes, three percent. The equity and justice in our politicians' decision making continues to be severely lacking.
We are also still very short in providing schools with the "adequate" amount of money necessary to fund our schools. Pennsylvania's funding of schools is the most inequitable in the United States. That means it is the most oppressive-especially to Black, Brown, and poor people. Years ago, former Philadelphia School Superintendent, David Hornbeck, called Pennsylvania's general assembly school funding plan "racially discriminatory" because it systematically and deliberately underfunded schools. Not much has changed.
PA Continues to Have the COuntries Most Inequitable School Funding Gap
Earlier this spring, one of my teachers, Zachary Wright, led busloads of seniors to Harrisburg because our students wanted to express their frustrations with the budget process. Mr. Wright's speech is below.
Talk is cheap, as our state representatives must know, since they have been discussing, and not enacting a budget, for ten months. And since I do not possess the resources that would allow me to talk endlessly, let's stick to the facts.
Of the fifty states in the nation, only 2 have not passed budgets – Illinois, and Pennsylvania.
Of the fifty states in the nation, one state is behind all others in job growth – Pennsylvania.
Most states budget a 50% share for education funding, meaning that the state will cover half a city's cost of educating its children –Pennsylvania covers 35%, among the lowest in the nation.
Pennsylvania ranks in the top 7 states for locking up its own citizens behind bars with a prison population of almost 49,000 people, a population larger than the entire city of Harrisburg.
The situation is clear. Pennsylvania is a state with too few jobs, too many prisoners, impoverished schools, and an intransigent government that refuses to fulfill its obligations to its citizens by passing a budget.
And yet, even when the politicians in Harrisburg come to their collective senses and do the jobs they were elected to do, we will still not have true educational equality.
In PA, Zip Codes Continue to Determine Your Academic Worth
As it stands, there is one factor that supersedes all others in whether a child will succeed in school; not teachers, not school size, not parents; zip code. As it stands, in our state of Pennsylvania, a child's zip code determines whether a school will prepare their students for college, or a jail cell. A child's zip code determines whether a school has counselors and nurses. A child's zip code, 5 numbers, sets the trajectory for a child's entire life.
How is this possible? Through the link of property taxes to school funding.
A district with high property taxes, Lower Merion for instance, receives vastly more tax revenue for its schools than those in Philadelphia. One student on 53rd street and Lancaster Avenue in West Philadelphia is allotted $8,000 for her education. A 10 minute drive away, past City Line Avenue, that same student would have $21,000. And why? Zip Codes.
As Americans, we love to believe in our exceptionalism. We love to believe that here, in this land, anybody can make it, anybody can become successful. The American Dream is hardwired into our DNA.
But not here. Not in Pennsylvania. Not when politicians cannot, or rather will not, do their jobs and fund our schools. Not when a young person's future is determined by their zip code rather than their grit. Here, the rich get corridors to colleges, and the poor get pipelines to prisons.
We are here to send a clear message.
Fund our schools, not our prisons.
Dress our young people in graduation gowns, not orange jump suits.
Harrisburg, do your job, or we will elect those who will.
"Equity, after all, does not mean simply equal funding. Equal funding for unequal needs is not equality." –Kozol
fair funding funding Harrisburg Inequity Pennsylvania schools weighted formula
Why I Am Asking Black Men To Teach
You Can't Help Our Children If You Refuse to Be Accountable
Sharif El-Mekki is the principal of Mastery Charter School–Shoemaker Campus, a neighborhood public charter school in Philadelphia that serves 750 students in grades 7-12. From 2013-2015, he was one of three principal ambassador fellows working on issues of education policy and practice with U.S. Department of Education under Secretary Arne Duncan.
Pingback: Integration: The Panacea for Low Achievement in Black and Communities? – Philly's 7th Ward
Pingback: Integration: The Panacea for Low Achievement in Our Schools? – Philly's 7th Ward
Pingback: I'm tired of sacrificing for the dream of integrated public schools – Citizen Ed


This wooden whale would make a wonderful addition to your home décor or beach house! It would also make a great decoration to add to a nursery with a nautical theme.
The whale shown is hand painted in blue and green colors, then distressed. This can be painted in any color of your choice, with the option of a distressed look or solid paint color.
Signs are hand painted on a cedar board and sealed to preserve the look, along with a hanger added to the back so it is ready to display.
To customize, please include the color and option of solid paint or distressed look in the comment box at checkout.
This listing measures 18 inches in length and 8 inches in height, and are cut to 3/4 inch in thickness.


Olivia's Gift provides nurturance and support to help adults with severe disabilities live rich lives and achieve their potential. More than a building, it's a resource center, a therapeutic environment, and a point of connection for families and community. A home away from the family home.
Professional care is supported by advanced therapies and equipment to create a rich, stimulating environment for residents.


text:
require 'spec_helper'
require 'securerandom'

shared_examples 'Customer Subscriptions' do
  let(:gen_card_tk) { stripe_helper.generate_card_token }

  let(:product) { stripe_helper.create_product }
  let(:plan_attrs) { {id: 'silver', product: product.id, amount: 4999, currency: 'usd'} }
  let(:plan) { stripe_helper.create_plan(plan_attrs) }

  let(:plan_with_trial_attrs) { {id: 'trial', product: product.id, amount: 999, trial_period_days: 14 } }
  let(:plan_with_trial) { stripe_helper.create_plan(plan_with_trial_attrs) }

  let(:free_plan) { stripe_helper.create_plan(id: 'free', product: product.id, amount: 0) }

  context "creating a new subscription" do
    it "adds a new subscription to customer with none using items", :live => true do
      plan
      customer = Stripe::Customer.create(source: gen_card_tk)

      expect(customer.subscriptions.data).to be_empty
      expect(customer.subscriptions.count).to eq(0)

      subscription = Stripe::Subscription.create({
        customer: customer.id,
        items: [{ plan: 'silver' }],
        metadata: { foo: "bar", example: "yes" }
      })

      expect(subscription.object).to eq('subscription')
      expect(subscription.plan.to_hash).to eq(plan.to_hash)
      expect(subscription.metadata.foo).to eq("bar")
      expect(subscription.metadata.example).to eq("yes")

      customer = Stripe::Customer.retrieve(customer.id)
      subscriptions = Stripe::Subscription.list(customer: customer.id)
      charges = Stripe::Charge.list(customer: customer.id)

      expect(subscriptions.data).to_not be_empty
      expect(subscriptions.count).to eq(1)
      expect(subscriptions.data.length).to eq(1)
      expect(charges.data.length).to eq(1)
      expect(customer.currency).to eq("usd")

      expect(subscriptions.data.first.id).to eq(subscription.id)
      expect(subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)
      expect(subscriptions.data.first.customer).to eq(customer.id)
      expect(subscriptions.data.first.metadata.foo).to eq( "bar" )
      expect(subscriptions.data.first.metadata.example).to eq( "yes" )
    end

    it "adds a new subscription to customer with none", :live => true do
      plan
      customer = Stripe::Customer.create(source: gen_card_tk)
      subscriptions = Stripe::Subscription.list(customer: customer.id)

      expect(subscriptions.data).to be_empty
      expect(subscriptions.count).to eq(0)

      sub = Stripe::Subscription.create({ plan: 'silver', customer: customer.id, metadata: { foo: "bar", example: "yes" } })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan.to_hash)
      expect(sub.metadata.foo).to eq( 'bar' )
      expect(sub.metadata.example).to eq( 'yes' )

      customer = Stripe::Customer.retrieve(customer.id)
      subscriptions = Stripe::Subscription.list(customer: customer.id)
      charges = Stripe::Charge.list(customer: customer.id)

      expect(subscriptions.data).to_not be_empty
      expect(subscriptions.count).to eq(1)
      expect(subscriptions.data.length).to eq(1)
      expect(charges.data.length).to eq(1)
      expect(customer.currency).to eq( "usd" )

      expect(subscriptions.data.first.id).to eq(sub.id)
      expect(subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)
      expect(subscriptions.data.first.customer).to eq(customer.id)
      expect(subscriptions.data.first.billing).to eq('charge_automatically')
      expect(subscriptions.data.first.metadata.foo).to eq( "bar" )
      expect(subscriptions.data.first.metadata.example).to eq( "yes" )
    end

    it 'when customer object provided' do
      plan
      customer = Stripe::Customer.create(source: gen_card_tk)
      subscriptions = Stripe::Subscription.list(customer: customer.id)

      expect(subscriptions.data).to be_empty
      expect(subscriptions.count).to eq(0)

      sub = Stripe::Subscription.create({ plan: 'silver', customer: customer, metadata: { foo: "bar", example: "yes" } })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan.to_hash)
      expect(sub.billing).to eq('charge_automatically')
      expect(sub.metadata.foo).to eq( "bar" )
      expect(sub.metadata.example).to eq( "yes" )

      customer = Stripe::Customer.retrieve(customer.id)
      subscriptions = Stripe::Subscription.list(customer: customer.id)
      charges = Stripe::Charge.list(customer: customer.id)

      expect(subscriptions.data).to_not be_empty
      expect(subscriptions.count).to eq(1)
      expect(subscriptions.data.length).to eq(1)
      expect(charges.data.length).to eq(1)
      expect(customer.currency).to eq( "usd" )

      expect(subscriptions.data.first.id).to eq(sub.id)
      expect(subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)

      expect(subscriptions.data.first.customer).to eq(customer.id)
      expect(subscriptions.data.first.billing).to eq('charge_automatically')
      expect(subscriptions.data.first.metadata.foo).to eq( "bar" )
      expect(subscriptions.data.first.metadata.example).to eq( "yes" )
    end

    it "adds a new subscription to customer (string/symbol agnostic)" do
      customer = Stripe::Customer.create(source: gen_card_tk)
      subscriptions = Stripe::Subscription.list(customer: customer.id)
      expect(subscriptions.count).to eq(0)

      plan
      sub = Stripe::Subscription.create({plan: plan.id, customer: customer.id })

      customer = Stripe::Customer.retrieve(customer.id)
      subscriptions = Stripe::Subscription.list(customer: customer.id)
      expect(sub.plan.to_hash).to eq(plan.to_hash)
      expect(subscriptions.count).to eq(1)
    end

    it 'creates a charge for the customer', live: true do
      customer = Stripe::Customer.create(source: gen_card_tk)
      Stripe::Subscription.create({ plan: plan.id, customer: customer.id, metadata: { foo: "bar", example: "yes" } })
      customer = Stripe::Customer.retrieve(customer.id)
      charges = Stripe::Charge.list(customer: customer.id)

      expect(charges.data.length).to eq(1)
      expect(charges.data.first.amount).to eq(4999)
    end

    it 'contains coupon object', live: true do
      coupon = stripe_helper.create_coupon(id: 'free_coupon', duration: 'repeating', duration_in_months: 3)
      customer = Stripe::Customer.create(source: gen_card_tk)
      Stripe::Subscription.create(plan: plan.id, customer: customer.id, coupon: coupon.id)
      customer = Stripe::Customer.retrieve(customer.id)

      subscriptions = Stripe::Subscription.list(customer: customer.id)

      expect(subscriptions.data).to be_a(Array)
      expect(subscriptions.data.count).to eq(1)
      expect(subscriptions.data.first.discount).not_to be_nil
      expect(subscriptions.data.first.discount).to be_a(Stripe::Discount)
      expect(subscriptions.data.first.discount.coupon.id).to eq(coupon.id)
    end

    it 'when coupon is not exist', live: true do
      customer = Stripe::Customer.create(source: gen_card_tk)

      expect {
        Stripe::Subscription.create(plan: plan.id, customer: customer.id, coupon: 'none')
      }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(400)
        expect(e.message).to eq('No such coupon: none')
      }
    end

    it "correctly sets quantity, application_fee_percent and tax_percent" do
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)

      subscription = Stripe::Subscription.create({
        plan: plan.id,
        customer: customer.id,
        quantity: 2,
        application_fee_percent: 10,
        tax_percent: 20
      })
      expect(subscription.quantity).to eq(2)
      expect(subscription.application_fee_percent).to eq(10)
      expect(subscription.tax_percent).to eq(20)
    end

    it "correctly sets pending invoice item interval" do
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)

      subscription = Stripe::Subscription.create({
        plan: plan.id,
        customer: customer.id,
        quantity: 2,
        pending_invoice_item_interval: { interval: 'month', interval_count: 1 }
      })

      expect(subscription.pending_invoice_item_interval.interval).to eq 'month'
      expect(subscription.pending_invoice_item_interval.interval_count).to eq 1
    end

    it "correctly sets created when it's not provided as a parameter", live: true do
      customer = Stripe::Customer.create(source: gen_card_tk)
      subscription = Stripe::Subscription.create({ plan: plan.id, customer: customer.id })

      expect(subscription.created).to eq(subscription.current_period_start)
    end

    it "correctly sets created when it's provided as a parameter" do
      customer = Stripe::Customer.create(source: gen_card_tk)
      subscription = Stripe::Subscription.create({ plan: plan.id, customer: customer.id, created: 1473576318 })

      expect(subscription.created).to eq(1473576318)
    end

    it "adds additional subscription to customer with existing subscription" do
      silver =  stripe_helper.create_plan(id: 'silver', product: product.id)
      gold =    stripe_helper.create_plan(id: 'gold', product: product.id)
      customer = Stripe::Customer.create(id: 'test_customer_sub', product: product.id, source: gen_card_tk, plan: 'gold')

      sub = Stripe::Subscription.create({ plan: 'silver', customer: customer.id })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(silver.to_hash)

      customer = Stripe::Customer.retrieve('test_customer_sub')
      expect(customer.subscriptions.data).to_not be_empty
      expect(customer.subscriptions.count).to eq(2)
      expect(customer.subscriptions.data.length).to eq(2)

      expect(customer.subscriptions.data.last.plan.to_hash).to eq(gold.to_hash)
      expect(customer.subscriptions.data.last.customer).to eq(customer.id)

      expect(customer.subscriptions.data.first.id).to eq(sub.id)
      expect(customer.subscriptions.data.first.plan.to_hash).to eq(silver.to_hash)
      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
    end

    it "subscribes a cardless customer when specifing a card token" do
      plan = stripe_helper.create_plan(id: 'enterprise', product: product.id, amount: 499)
      customer = Stripe::Customer.create(id: 'cardless')

      sub = Stripe::Subscription.create(plan: 'enterprise', customer: customer.id, source: gen_card_tk)
      customer = Stripe::Customer.retrieve('cardless')

      expect(customer.subscriptions.data.first.id).to eq(sub.id)
      expect(customer.subscriptions.data.first.customer).to eq(customer.id)

      expect(customer.sources.count).to eq(1)
      expect(customer.sources.data.length).to eq(1)
      expect(customer.default_source).to_not be_nil
      expect(customer.default_source).to eq customer.sources.data.first.id
    end

    it 'throws an error when plan does not exist' do
      customer = Stripe::Customer.create(id: 'cardless')

      expect { Stripe::Subscription.create({ plan: 'gazebo', customer: customer.id }) }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(404)
        expect(e.message).to_not be_nil
      }

      expect(customer.subscriptions.data).to be_empty
      expect(customer.subscriptions.count).to eq(0)
    end

    it "throws an error when subscribing a customer with no card" do
      plan = stripe_helper.create_plan(id: 'enterprise', product: product.id, amount: 499)
      customer = Stripe::Customer.create(id: 'cardless')

      expect { Stripe::Subscription.create({ plan: plan.id, customer: customer.id }) }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(400)
        expect(e.message).to_not be_nil
      }

      expect(customer.subscriptions.data).to be_empty
      expect(customer.subscriptions.count).to eq(0)
    end

    it "throws an error when subscribing the customer to a second plan in a different currency" do
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)

      expect(plan.currency).to eql("usd")
      usd_subscription = Stripe::Subscription.create({ plan: plan.id, customer: customer.id })

      eur_plan = stripe_helper.create_plan(plan_attrs.merge(id: "plan_EURO", currency: 'eur'))
      expect(eur_plan.currency).to eql("eur")
      expect { Stripe::Subscription.create({ plan: eur_plan.id, customer: customer.id }) }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(400)
        expect(e.message).to_not be_nil
      }
    end

    it 'when attempting to create a new subscription with the params trial', live: true do
      plan = stripe_helper.create_plan(id: 'trial', product: product.id, amount: 999)
      customer = Stripe::Customer.create(source: gen_card_tk)

      expect{ Stripe::Subscription.create(plan: plan.id, customer: customer.id, trial: 10) }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(400)
        expect(e.param).to eq('trial')
        expect(e.message).to match /Received unknown parameter/
      }
    end

    it "subscribes a customer with no card to a plan with a free trial" do
      customer = Stripe::Customer.create(id: 'cardless')
      sub = Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan_with_trial.to_hash)
      expect(sub.trial_end - sub.trial_start).to eq(14 * 86400)
      expect(sub.billing_cycle_anchor).to be_nil

      customer = Stripe::Customer.retrieve(customer.id)
      subscriptions = Stripe::Subscription.list(customer: customer.id)
      charges = Stripe::Charge.list(customer: customer.id)

      expect(subscriptions.data).to_not be_empty
      expect(subscriptions.count).to eq(1)
      expect(subscriptions.data.length).to eq(1)

      expect(subscriptions.data.first.id).to eq(sub.id)
      expect(subscriptions.data.first.plan.to_hash).to eq(plan_with_trial.to_hash)
      expect(subscriptions.data.first.customer).to eq(customer.id)
      expect(charges.count).to eq(0)
    end

    it "subscribes a customer with no card to a plan with a free trial with plan as item" do
      customer = Stripe::Customer.create(id: 'cardless')
      sub = Stripe::Subscription.create({ items: [ { plan: plan_with_trial.id } ], customer: customer.id })

      expect(sub.object).to eq('subscription')
      expect(sub.items.data[0].plan.to_hash).to eq(plan_with_trial.to_hash)
      # no idea how to fix this one
      # expect(sub.trial_end - sub.trial_start).to eq(14 * 86400)

      customer = Stripe::Customer.retrieve('cardless')
      expect(customer.subscriptions.data).to_not be_empty
      expect(customer.subscriptions.count).to eq(1)
      expect(customer.subscriptions.data.length).to eq(1)

      expect(customer.subscriptions.data.first.id).to eq(sub.id)
      expect(customer.subscriptions.data.first.items.data.first.plan.to_hash).to eq(plan_with_trial.to_hash)
      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
      # No idea on this one
      # expect(customer.charges.count).to eq(0)
    end

    it "subscribes a customer with no card to a free plan" do
      plan = stripe_helper.create_plan(id: 'free_tier', product: product.id, amount: 0)
      customer = Stripe::Customer.create(id: 'cardless')

      sub = Stripe::Subscription.create({ plan: plan.id, customer: customer.id })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan.to_hash)

      customer = Stripe::Customer.retrieve('cardless')
      expect(customer.subscriptions.data).to_not be_empty
      expect(customer.subscriptions.count).to eq(1)
      expect(customer.subscriptions.data.length).to eq(1)

      expect(customer.subscriptions.data.first.id).to eq(sub.id)
      expect(customer.subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)
      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
    end

    it "overrides trial length when trial end is set" do
      customer = Stripe::Customer.create(id: 'short_trial')
      trial_end = Time.now.utc.to_i + 3600

      sub = Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: trial_end })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan_with_trial.to_hash)
      expect(sub.current_period_end).to eq(trial_end)
      expect(sub.trial_end).to eq(trial_end)
    end

    it "does not override trial end when trial end is not set" do
      product = stripe_helper.create_product(name: 'Trial')
      plan = stripe_helper.create_plan(id: 'trial', amount: 999,
                                       trial_period_days: 14, product: product.id)
      customer = Stripe::Customer.create(id: 'short_trial')
      trial_end = Time.now.utc.to_i + 3600
      metadata = {description: 'original description'}

      sub = Stripe::Subscription.create({ plan: 'trial', customer: customer.id, trial_end: trial_end, metadata: metadata })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan.to_hash)
      expect(sub.current_period_end).to eq(trial_end)
      expect(sub.trial_end).to eq(trial_end)
      expect(sub.metadata.description).to eq(metadata[:description])

      metadata = {description: 'updated description'}
      sub = Stripe::Subscription.update(sub.id, { metadata: metadata })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan.to_hash)
      expect(sub.current_period_end).to eq(trial_end)
      expect(sub.trial_end).to eq(trial_end) # check that the trial_end has NOT changed
      expect(sub.metadata.description).to eq(metadata[:description]) # check that the description has changed
    end

    it "returns without a trial when trial_end is set to 'now'" do
      customer = Stripe::Customer.create(id: 'no_trial', source: gen_card_tk)

      sub = Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: "now" })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan_with_trial.to_hash)
      expect(sub.status).to eq('active')
      expect(sub.trial_start).to be_nil
      expect(sub.trial_end).to be_nil
    end

    it "raises error when trial_end is not an integer or 'now'" do
      customer = Stripe::Customer.create(id: 'cus_trial')

      expect { Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: "gazebo" }) }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(400)
        expect(e.message).to eq('Invalid timestamp: must be an integer')
      }
    end

    it "raises error when trial_end is set to a time in the past" do
      customer = Stripe::Customer.create(id: 'past_trial')
      trial_end = Time.now.utc.to_i - 3600

      expect { Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: trial_end }) }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(400)
        expect(e.message).to eq('Invalid timestamp: must be an integer Unix timestamp in the future')
      }
    end

    it "raises error when trial_end is set to a time more than five years in the future" do
      customer = Stripe::Customer.create(id: 'long_trial')
      trial_end = Time.now.utc.to_i + 31557600*5 + 3600 # 5 years + 1 hour

      expect { Stripe::Subscription.create({ plan: plan_with_trial.id, customer: customer.id, trial_end: trial_end }) }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(400)
        expect(e.message).to eq('Invalid timestamp: can be no more than five years in the future')
      }
    end

    it 'overrides current period end when billing cycle anchor is set' do
      customer = Stripe::Customer.create(source: gen_card_tk)
      billing_cycle_anchor = Time.now.utc.to_i + 3600

      sub = Stripe::Subscription.create({ plan: plan.id, customer: customer.id, billing_cycle_anchor: billing_cycle_anchor })

      expect(sub.status).to eq('active')
      expect(sub.current_period_end).to eq(billing_cycle_anchor)
      expect(sub.billing_cycle_anchor).to eq(billing_cycle_anchor)
    end

    it 'when plan defined inside items', live: true do
      plan = stripe_helper.create_plan(id: 'BASE_PRICE_PLAN1', product: product.id)

      plan2 = stripe_helper.create_plan(id: 'PER_USER_PLAN1', product: product.id)
      customer = Stripe::Customer.create(
        source: stripe_helper.generate_card_token
      )
      subscription = Stripe::Subscription.create(
        customer: customer.id,
        items: [
          { plan: plan.id, quantity: 1 },
          { plan: plan2.id, quantity: 2 }
        ]
      )

      expect(subscription.id).to match /(test_su_|sub_).+/
      expect(subscription.plan).to eq nil
      expect(subscription.items.data[0].plan.id).to eq plan.id
      expect(subscription.items.data[1].plan.id).to eq plan2.id
      expect(subscription.items.data[0].quantity).to eq 1
      expect(subscription.items.data[1].quantity).to eq 2
    end

    it 'when plan defined inside items for trials with no card', live: true do
      plan = stripe_helper.create_plan(id: 'BASE_PRICE_PLAN1', product: product.id)

      plan2 = stripe_helper.create_plan(id: 'PER_USER_PLAN1', product: product.id)
      customer = Stripe::Customer.create
      trial_end = Time.now.utc.to_i + 3600

      subscription = Stripe::Subscription.create(
        customer: customer.id,
        items: [
          { plan: plan.id, quantity: 1 },
          { plan: plan2.id, quantity: 2 }
        ],
        trial_end: trial_end
      )

      expect(subscription.id).to match /(test_su_|sub_).+/
      expect(subscription.plan).to eq nil
      expect(subscription.items.data[0].plan.id).to eq plan.id
      expect(subscription.items.data[1].plan.id).to eq plan2.id
    end

    it 'add a new subscription to bill via an invoice' do
      product = stripe_helper.create_product(id: 'invoice_billing')
      plan = stripe_helper.create_plan(id: 'silver', product: product.id,
                                       amount: 4999, currency: 'usd')
      customer = Stripe::Customer.create(id: 'cardless')

      expect(customer.subscriptions.data).to be_empty
      expect(customer.subscriptions.count).to eq(0)

      sub = Stripe::Subscription.create({
        plan: 'silver',
        customer: customer.id,
        metadata: { foo: 'bar', example: 'yes' },
        billing: 'send_invoice',
        days_until_due: 30,
      })

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan.to_hash)
      expect(sub.billing).to eq 'send_invoice'
      expect(sub.days_until_due).to eq 30
    end

    let(:subscription_header) {{
      :idempotency_key => SecureRandom.hex
    }}

    it "adds a new subscription to customer with identical idempotency key" do
      product = stripe_helper.create_product(name: 'Silver Product')
      plan = stripe_helper.create_plan(id: 'silver', product: product.id,
                                       amount: 4999, currency: 'usd')
      customer = Stripe::Customer.create(source: gen_card_tk)

      expect(customer.subscriptions.data).to be_empty
      expect(customer.subscriptions.count).to eq(0)

      subscription_header = {
        :idempotency_key => "uniq_idempotency_key_#{customer.id}"
      }

      sub1 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, subscription_header)
      sub2 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, subscription_header)
      expect(sub1).to eq(sub2)
    end

    it "adds a new subscription to customer with different idempotency key", :live => true do
      product = stripe_helper.create_product(name: 'Silver Product')
      plan = stripe_helper.create_plan(id: 'silver', product: product.id,
                                       amount: 4999, currency: 'usd')
      customer = Stripe::Customer.create(source: gen_card_tk)

      expect(customer.subscriptions.data).to be_empty
      expect(customer.subscriptions.count).to eq(0)

      sub_header_1 = {
        :idempotency_key => SecureRandom.hex
      }
      sub_header_2 = {
        :idempotency_key => SecureRandom.hex
      }

      sub1 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, sub_header_1)
      sub2 = Stripe::Subscription.create({ items: [{ plan: 'silver' }], customer: customer.id }, sub_header_2)
      expect(sub1).not_to eq(sub2)
    end

    it "accepts a hash of items" do
      product = stripe_helper.create_product(name: 'Silver Product')
      silver = stripe_helper.create_plan(id: 'silver', product: product.id)
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)

      sub = Stripe::Subscription.create({ items: { '0' => { plan: 'silver' } }, customer: customer.id })
      sub.delete(at_period_end: true)

      expect(sub.cancel_at_period_end).to be_truthy
      expect(sub.save).to be_truthy
      expect(sub.cancel_at_period_end).to be_truthy
    end

    it 'accepts default_tax_rates param' do
      tax_rate = Stripe::TaxRate.create(
        display_name: 'VAT',
        description: 'VAT Germany',
        jurisdiction: 'DE',
        percentage: 19.0,
        inclusive: false,
      )
      product = stripe_helper.create_product(name: 'Silver Product')
      silver = stripe_helper.create_plan(id: 'silver', product: product.id)
      customer = Stripe::Customer.create(source: gen_card_tk)
      subscription = Stripe::Subscription.create(
        customer: customer.id,
        items: [{ plan: silver.id }],
        default_tax_rates: [ tax_rate ]
      )

      aggregate_failures do
        expect(subscription.default_tax_rates.length).to eq(1)
        expect(subscription.default_tax_rates.first.id).to eq(tax_rate.id)
      end
    end
  end

  context "updating a subscription" do
    it 'raises invalid request exception when subscription is cancelled' do
      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)

      subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      subscription.delete

      expect { subscription.save }.to raise_error { |e|
        expect(e).to be_a(Stripe::InvalidRequestError)
        expect(e.http_status).to eq(404)
        expect(e.message).to eq("No such subscription: #{subscription.id}")
      }
    end

    it "updates a stripe customer's existing subscription with one plan inside items" do
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)

      sub = Stripe::Subscription.create({ items: [ { plan: plan.id } ], customer: customer.id })
      sub.delete(at_period_end: true)

      expect(sub.cancel_at_period_end).to be_truthy
      expect(sub.save).to be_truthy
      expect(sub.cancel_at_period_end).to be_truthy
    end

    it "updates a stripe customer's existing subscription when plan inside of items" do
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: plan.id)

      gold_plan = stripe_helper.create_plan(id: 'gold', product: product.id)
      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      sub.plan = gold_plan.id
      sub.quantity = 5
      sub.metadata.foo = 'bar'
      sub.metadata.example = 'yes'

      expect(sub.save).to be_truthy

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(gold_plan.to_hash)
      expect(sub.quantity).to eq(5)
      expect(sub.metadata.foo).to eq( 'bar' )
      expect(sub.metadata.example).to eq( 'yes' )

      customer = Stripe::Customer.retrieve('test_customer_sub')
      expect(customer.subscriptions.data).to_not be_empty
      expect(customer.subscriptions.count).to eq(1)
      expect(customer.subscriptions.data.length).to eq(1)

      expect(customer.subscriptions.data.first.id).to eq(sub.id)
      expect(customer.subscriptions.data.first.plan.to_hash).to eq(gold_plan.to_hash)
      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
    end

    it "updates a stripe customer's existing subscription with single plan when multiple plans inside of items" do
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: plan.id)

      gold_plan = stripe_helper.create_plan(id: 'gold', product: product.id)
      addon_plan = stripe_helper.create_plan(id: 'addon_plan', product: product.id)
      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      sub.items = [{ plan: gold_plan.id, quantity: 2 }, { plan: addon_plan.id, quantity: 2 }]
      expect(sub.save).to be_truthy

      expect(sub.object).to eq('subscription')
      expect(sub.plan).to be_nil

      customer = Stripe::Customer.retrieve('test_customer_sub')
      expect(customer.subscriptions.data).to_not be_empty
      expect(customer.subscriptions.count).to eq(1)
      expect(customer.subscriptions.data.length).to eq(1)

      expect(customer.subscriptions.data.first.id).to eq(sub.id)
      expect(customer.subscriptions.data.first.plan).to be_nil
      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
      expect(customer.subscriptions.data.first.items.data[0].plan.to_hash).to eq(gold_plan.to_hash)
      expect(customer.subscriptions.data.first.items.data[1].plan.to_hash).to eq(addon_plan.to_hash)
    end

    it "updates a stripe customer's existing subscription with multple plans when multiple plans inside of items" do
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
      addon1_plan = stripe_helper.create_plan(id: 'addon1', product: product.id)
      sub = Stripe::Subscription.create(customer: customer.id, items: [{ plan: plan.id }, { plan: addon1_plan.id }])

      gold_plan = stripe_helper.create_plan(id: 'gold', product: product.id)
      addon2_plan = stripe_helper.create_plan(id: 'addon2', product: product.id)

      sub.items = [{ plan: gold_plan.id, quantity: 2 }, { plan: addon2_plan.id, quantity: 2 }]
      expect(sub.save).to be_truthy

      expect(sub.object).to eq('subscription')
      expect(sub.plan).to be_nil

      customer = Stripe::Customer.retrieve('test_customer_sub')
      expect(customer.subscriptions.data).to_not be_empty
      expect(customer.subscriptions.count).to eq(1)
      expect(customer.subscriptions.data.length).to eq(1)

      expect(customer.subscriptions.data.first.id).to eq(sub.id)
      expect(customer.subscriptions.data.first.plan).to be_nil
      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
      expect(customer.subscriptions.data.first.items.data[0].plan.to_hash).to eq(gold_plan.to_hash)
      expect(customer.subscriptions.data.first.items.data[1].plan.to_hash).to eq(addon2_plan.to_hash)
    end

    it "updates a subscription's cancel_at_period_end" do
      silver = stripe_helper.create_plan(id: 'silver', product: product.id)
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)

      sub = Stripe::Subscription.create({ items: [ { plan: 'silver' } ], customer: customer.id })

      expect(sub.cancel_at_period_end).to be_falsey

      sub.cancel_at_period_end = true
      sub.save

      expect(sub.save).to be_truthy
      expect(sub.cancel_at_period_end).to be_truthy
      expect(sub.canceled_at).to be_truthy

      sub.cancel_at_period_end = false
      sub.save

      expect(sub.save).to be_truthy
      expect(sub.cancel_at_period_end).to be_falsey
      expect(sub.canceled_at).to be_falsey
    end

    it "updates a subscription's pending invoice item interval" do
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)

      subscription = Stripe::Subscription.create({
        plan: plan.id,
        customer: customer.id,
        quantity: 2,
        pending_invoice_item_interval: { interval: 'month', interval_count: 1 }
      })

      expect(subscription.pending_invoice_item_interval.interval).to eq 'month'
      expect(subscription.pending_invoice_item_interval.interval_count).to eq 1

      subscription.pending_invoice_item_interval = { interval: 'week', interval_count: 3 }
      subscription.save

      expect(subscription.pending_invoice_item_interval.interval).to eq 'week'
      expect(subscription.pending_invoice_item_interval.interval_count).to eq 3
    end

    it 'when adds coupon', live: true do
      coupon = stripe_helper.create_coupon
      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
      subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)

      subscription.coupon = coupon.id
      subscription.save

      expect(subscription.discount).not_to be_nil
      expect(subscription.discount).to be_a(Stripe::Discount)
      expect(subscription.discount.coupon.id).to eq(coupon.id)
    end

    it 'when add not exist coupon' do
      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
      subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)

      subscription.coupon = 'none'

      expect { subscription.save }.to raise_error { |e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(400)
        expect(e.message).to eq('No such coupon: none')
      }

    end

    it 'when coupon is removed' do
      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
      coupon = stripe_helper.create_coupon
      subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)

      subscription.coupon = coupon.id
      subscription.save
      subscription.coupon = nil
      subscription.save

      expect(subscription.discount).to be_nil
    end

    it "throws an error when plan does not exist" do
      customer = Stripe::Customer.create(id: 'cardless', plan: free_plan.id)

      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      sub.plan = 'gazebo'

      expect { sub.save }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(404)
        expect(e.message).to_not be_nil
      }

      customer = Stripe::Customer.retrieve('cardless')
      expect(customer.subscriptions.count).to eq(1)
      expect(customer.subscriptions.data.length).to eq(1)
      expect(customer.subscriptions.data.first.plan.to_hash).to eq(free_plan.to_hash)
    end

    it "throws an error when subscription does not exist" do
      expect(stripe_helper.list_subscriptions(50).keys).to_not include("sub_NONEXIST")
      expect { Stripe::Subscription.retrieve("sub_NONEXIST") }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(404)
        expect(e.message).to_not be_nil
      }
    end

    [nil, 0].each do |trial_period_days|
      it "raises an error when updating a customer with no card, and plan trial_period_days = #{trial_period_days}", live: true do
        begin
          free_plan
          paid_plan = stripe_helper.create_plan(id: 'enterprise', product: product.id, amount: 499, trial_period_days: trial_period_days)
          customer = Stripe::Customer.create(description: 'cardless', plan: free_plan.id)

          sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
          sub.plan = paid_plan.id

          expect {
            sub.save
          }.to raise_error(Stripe::InvalidRequestError, "This customer has no attached payment source")
        ensure
          customer.delete if customer
          paid_plan.delete if paid_plan
          free_plan.delete if free_plan
        end
      end
    end

    it 'updates a subscription if the customer has a free trial', live: true do
      trial_end = Time.now.utc.to_i + 3600
      customer = Stripe::Customer.create(plan: plan.id, trial_end: trial_end)
      subscription = customer.subscriptions.first
      subscription.quantity = 2
      subscription.save
      expect(subscription.quantity).to eq(2)
    end

    it "updates a customer with no card to a plan with a free trial" do
      free_plan
      trial_plan = stripe_helper.create_plan(id: 'trial', product: product.id, amount: 999, trial_period_days: 14)
      customer = Stripe::Customer.create(id: 'cardless', plan: free_plan.id)

      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      sub.plan = trial_plan.id
      sub.save

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(trial_plan.to_hash)

      customer = Stripe::Customer.retrieve('cardless')
      expect(customer.subscriptions.data).to_not be_empty
      expect(customer.subscriptions.count).to eq(1)
      expect(customer.subscriptions.data.length).to eq(1)

      expect(customer.subscriptions.data.first.id).to eq(sub.id)
      expect(customer.subscriptions.data.first.plan.to_hash).to eq(trial_plan.to_hash)
      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
    end

    it "updates a customer with no card to a free plan" do
      free_plan
      customer = Stripe::Customer.create(id: 'cardless', product: product.id, plan: free_plan.id)

      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      gratis_plan = stripe_helper.create_plan(id: 'gratis', product: product.id, amount: 0)
      sub.plan = gratis_plan.id

      sub.save
      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(gratis_plan.to_hash)

      customer = Stripe::Customer.retrieve('cardless')
      expect(customer.subscriptions.data).to_not be_empty
      expect(customer.subscriptions.count).to eq(1)
      expect(customer.subscriptions.data.length).to eq(1)

      expect(customer.subscriptions.data.first.id).to eq(sub.id)
      expect(customer.subscriptions.data.first.plan.to_hash).to eq(gratis_plan.to_hash)
      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
    end

    it "sets a card when updating a customer's subscription" do
      customer = Stripe::Customer.create(id: 'test_customer_sub', plan: free_plan.id)

      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      sub.plan = plan.id
      sub.source = gen_card_tk
      sub.save

      customer = Stripe::Customer.retrieve('test_customer_sub')

      expect(customer.sources.count).to eq(1)
      expect(customer.sources.data.length).to eq(1)
      expect(customer.default_source).to_not be_nil
      expect(customer.default_source).to eq customer.sources.data.first.id
    end

    it "overrides trial length when trial end is set" do
      customer = Stripe::Customer.create(id: 'test_trial_end', plan: plan_with_trial.id)
      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      trial_end = Time.now.utc.to_i + 3600
      sub.trial_end = trial_end
      sub.save

      expect(sub.object).to eq('subscription')
      expect(sub.trial_end).to eq(trial_end)
      expect(sub.current_period_end).to eq(trial_end)
    end

    it "returns without a trial when trial_end is set to 'now'" do
      customer = Stripe::Customer.create(id: 'test_trial_end', plan: plan_with_trial.id, default_source: 'tok_visa')

      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)

      sub.trial_end = "now"
      sub.save

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan_with_trial.to_hash)
      expect(sub.status).to eq('active')
      expect(sub.trial_start).to be_nil
      expect(sub.trial_end).to be_nil
    end

    it "changes an active subscription to a trial when trial_end is set" do
      customer = Stripe::Customer.create(id: 'test_trial_end', plan: plan.id, source: gen_card_tk)
      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      trial_end = Time.now.utc.to_i + 3600
      sub.trial_end = trial_end
      sub.save

      expect(sub.object).to eq('subscription')
      expect(sub.plan.to_hash).to eq(plan.to_hash)
      expect(sub.status).to eq('trialing')
      expect(sub.trial_end).to eq(trial_end)
      expect(sub.current_period_end).to eq(trial_end)
    end

    it "raises error when trial_end is not an integer or 'now'" do
      expect(plan.trial_period_days).to be_nil
      customer = Stripe::Customer.create(id: 'test_trial_end', plan: plan.id, source: gen_card_tk)

      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      sub.trial_end = "gazebo"

      expect { sub.save }.to raise_error {|e|
        expect(e).to be_a Stripe::InvalidRequestError
        expect(e.http_status).to eq(400)
        expect(e.message).to eq('Invalid timestamp: must be an integer')
      }
    end
  end

  context "cancelling a subscription" do
    let(:customer) { Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: plan.id) }

    it "cancels a stripe customer's subscription", :live => true do
      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)

      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
      result = sub.delete

      expect(result.status).to eq('canceled')
      expect(result.cancel_at_period_end).to eq false
      expect(result.canceled_at).to_not be_nil
      expect(result.id).to eq(sub.id)

      customer = Stripe::Customer.retrieve(customer.id)
      expect(customer.subscriptions.data).to be_empty
      expect(customer.subscriptions.count).to eq(0)
      expect(customer.subscriptions.data.length).to eq(0)
    end
  end

  it "supports 'cancelling' by updating cancel_at_period_end" do
    product = stripe_helper.create_product(name: 'Truth Product')
    truth = stripe_helper.create_plan(id: 'the_truth', product: product.id)
    customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "the_truth")

    sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
    result = Stripe::Subscription.update(sub.id, cancel_at_period_end: true)

    expect(result.status).to eq('active')
    expect(result.cancel_at_period_end).to eq(true)
    expect(result.id).to eq(sub.id)

    customer = Stripe::Customer.retrieve('test_customer_sub')
    expect(customer.subscriptions.data).to_not be_empty
    expect(customer.subscriptions.count).to eq(1)
    expect(customer.subscriptions.data.length).to eq(1)

    expect(customer.subscriptions.data.first.status).to eq('active')
    expect(customer.subscriptions.data.first.cancel_at_period_end).to eq(true)
    expect(customer.subscriptions.data.first.ended_at).to be_nil
    expect(customer.subscriptions.data.first.canceled_at).to_not be_nil
  end

  it "resumes a subscription cancelled by updating cancel_at_period_end" do
    product = stripe_helper.create_product(name: 'Truth Product')
    truth = stripe_helper.create_plan(id: 'the_truth', product: product.id)
    customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "the_truth")

    sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
    Stripe::Subscription.update(sub.id, cancel_at_period_end: true)

    result = Stripe::Subscription.update(sub.id, cancel_at_period_end: false)

    expect(result.status).to eq('active')
    expect(result.cancel_at_period_end).to eq(false)
    expect(result.id).to eq(sub.id)

    customer = Stripe::Customer.retrieve('test_customer_sub')
    expect(customer.subscriptions.data).to_not be_empty
    expect(customer.subscriptions.count).to eq(1)
    expect(customer.subscriptions.data.length).to eq(1)

    expect(customer.subscriptions.data.first.status).to eq('active')
    expect(customer.subscriptions.data.first.cancel_at_period_end).to eq(false)
    expect(customer.subscriptions.data.first.ended_at).to be_nil
    expect(customer.subscriptions.data.first.canceled_at).to be_nil
  end

  it "doesn't change status of subscription when cancelling at period end" do
    trial = stripe_helper.create_plan(id: 'trial', product: product.id, trial_period_days: 14)
    customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: "trial")

    sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
    result = sub.delete(at_period_end: true)

    expect(result.status).to eq('trialing')

    customer = Stripe::Customer.retrieve('test_customer_sub')

    expect(customer.subscriptions.data.first.status).to eq('trialing')
  end

  it "doesn't require a card when trial_end is present", live: true do
    plan = stripe_helper.create_plan(
      :amount => 2000,
      :product => product.id,
      :interval => 'month',
      :currency => 'usd',
      :id => 'gold'
    )

    stripe_customer = Stripe::Customer.create
    options = {plan: plan.id, customer: stripe_customer.id, trial_end: (Date.today + 30).to_time.to_i}
    Stripe::Subscription.create options
  end

  context 'retrieving a single subscription' do
    let(:customer) { Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: 'free') }
    let(:subscription) { Stripe::Subscription.retrieve(customer.subscriptions.data.first.id) }

    before do
      free_plan
      Stripe::Subscription.create({ plan: 'free', customer: customer.id })
    end

    it 'retrieves a single subscription' do
      expect(subscription).to be_truthy
    end

    it "includes 'items' object on retrieved subscription" do
      expect(subscription.items).to be_truthy
      expect(subscription.items.object).to eq('list')
      expect(subscription.items.data.class).to eq(Array)
      expect(subscription.items.data.count).to eq(1)
      expect(subscription.items.data.first.id).to eq('test_txn_default')
      expect(subscription.items.data.first.created).to eq(1504716183)
      expect(subscription.items.data.first.object).to eq('subscription_item')
      expect(subscription.items.data.first.plan.amount).to eq(0)
      expect(subscription.items.data.first.plan.created).to eq(1466698898)
      expect(subscription.items.data.first.plan.currency).to eq('usd')
      expect(subscription.items.data.first.quantity).to eq(2)
    end
  end

  context "retrieve multiple subscriptions" do

    it "retrieves a list of multiple subscriptions" do
      free_plan
      paid = stripe_helper.create_plan(id: 'paid', product: product.id, amount: 499)
      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: free_plan.id)
      Stripe::Subscription.create({ plan: 'paid', customer: customer.id })

      subs = Stripe::Subscription.list({ customer: customer.id })

      expect(subs.object).to eq("list")
      expect(subs.count).to eq(2)
      expect(subs.data.length).to eq(2)
    end

    it 'retrieves an empty list if there are no subscriptions' do
      Stripe::Customer.create(id: 'no_subs')
      customer = Stripe::Customer.retrieve('no_subs')

      list = Stripe::Subscription.list({ customer: customer.id })

      expect(list.object).to eq("list")
      expect(list.count).to eq(0)
      expect(list.data.length).to eq(0)
    end
  end

  describe "metadata" do

    it "creates a stripe customer and subscribes them to a plan with meta data", :live => true do

      stripe_helper.
        create_plan(
        :amount => 500,
        :interval => 'month',
        :product => product.id,
        :currency => 'usd',
        :id => 'Sample5'
      )

      customer = Stripe::Customer.create(
        email: 'johnny@appleseed.com',
        source: gen_card_tk
      })

      subscription = Stripe::Subscription.create({ plan: "Sample5", customer: customer.id })
      subscription.metadata['foo'] = 'bar'

      expect(subscription.save).to be_a Stripe::Subscription

      customer = Stripe::Customer.retrieve(customer.id)
      expect(customer.email).to eq('johnny@appleseed.com')
      expect(customer.subscriptions.first.plan.id).to eq('Sample5')
      expect(customer.subscriptions.first.metadata['foo']).to eq('bar')
    end
  end

end

redpajama_set_name: RedPajamaGithub


text:
Дубенский — посёлок в Беляевском районе Оренбургской области России. Центр сельского поселения Дубенский поссовет.

География
Посёлок расположен в 12 км от железнодорожной станции Кандуровка Южно-Уральской железной дороги.

История
В 1944 году Дубенский получил статус посёлка городского типа. С 2001 года — сельский населённый пункт.

Население

Примечания

Населённые пункты Беляевского района (Оренбургская область)

redpajama_set_name: RedPajamaWikipedia


Wife Linda often works at Yorktown in Lombard on Friday evenings so we regularly meet there for a casual date night wine and dine encounter at DOC. They regularly feature a selection of wine flights - three different wines of the same style for sharing/comparing. Their menu offers mostly small plates and sides suitable for wine pairing vs an extensive selection of entrees. So it was tonight that we chose the premium Reserve Flight to accompany my selection of sushi grade Ahi Tuna and Linda's pulled pork 'sliders', with a side of our favored polenta fries. All the foods were excellent and the service was attentive, friendly and effective.
The DOC folks actually have nine different locations around Chicagoland, four of those being operated under the DOC brand.
Note for those so interested, their name is actually D.O.C. and stands for "Denominazione di Origine Controllata" (DOC) ("Controlled Denomination of Origin") which is Italy's equivalent of France's AOC - Appellation D'Origine Controlee or America's AVA's for American Viticultural Area. The Italian DOC, like the other Appellation designations, are a defined geographic area and its designated production for wines produced from grapes grown in that area and includes specifications for the varieties that can be used, the minimum alcohol content, the maximum yield, and the specifications for aging.
The Reserve wine flight featured three bold expressive concentrated wines at the top of the range of styles from light to big and bold. Two of three of the wines were our favorite and most oft selected wines, Syrah and Cabernet, while the third was a Tempranillo, in which we rarely imbibe.
We've dined there often and tonight's experience rated as the most enjoyable ever. My Ahi tuna was wonderful and the wine flight scored highest over our previous encounters, even with one gaining lower marks. Lastly, during the summer months we will dine outside and always before we dined in the main dining room which tends to be dark. Tonight we dined in their 'Tasting Room' adjacent to the main dining room, behind the bar. This casual setting with the large fireplace and couches, and our table adjacent the large windows was most comfortable and pleasant.
The American centric wine selection is extensive with the actual wine list spanning ten pages - more than twenty each of American Pinot Noirs, California Chardonnays and Cabernets including popular and favored selections Robert Craig, Caymus, Silver Oak, David Arthur Elevation, Keenan, Cakebread, Darioush and Lakoya. They also offer half bottles and an extensive selection of wines BTG - by the glass. The wine prices tend to be a bit expensive, slightly more than 2x retail for bottle selections, and by the glass, and the Wine Flights are too, based on the amount of wine served for the price point. These are price points of elegant fine dining restaurants and one would hope to find more value in a casual bistro wine bar. Never-the-less, it does allow a broad selection of choices, BTG, and a series of wine flights, three different wines for about the cost of one and a half glasses, so its a good choice if one's objective is a tasting experience over a single glass of wine.
For precision and the record, note that since we were pressed for time, I didn't inspect the labels of these featured selections and I know the producer's offer several labels of each of these wines. I did search for the bottles in their display case but didn't see any of these that we selected.
Blend: 85.5% Cabernet Sauvignon, 13% Merlot, 1% Cabernet Franc, 0.5% Petit Verdot.
Dark garnet colored, medium bodied, smooth and polished so approachable and ready to drink now for enjoyable casual sipping, almost sophisticated and complex enough for serious dining, black cherry and dark plum fruits with tones of smoke, tobacco, licorice and hint of cedar.
Once again I didn't ask to see the label (which I normally do) so I am attributing my notes to their estate label. While their winelist and flight card specify Walla Walla, Oregon, I believe this is in error and they mean Walla Walla Valley in Washington.
Garnet colored, medium bodied, blackberry fruits with tones of leather and cured meat, hints of pepper, smoke, earth and floral.
Once again, since we were pressed for time, I didn't inspect the label of this feature and I know they offer several labels of this varietal.
Garnet colored, medium bodied, more modest less expressive blackberry fruits with a layer of tobacco, smoke, tar and hints of clove spice.


text:
Q: nodejs re-import file when it changes My main code is under chokidar watched folder, when a file changes it emit an event
The main script is this
const fileName = "test.ts";
import(fileName).then((t: any) => {
  t.default();
});

and this is the file test.ts
export default () => {
  console.log("aaa");
};

I need to reimport file when I change test.ts, for example, I need this

START script
OUTPUT "aaa"
CHANGE test.ts from "console.log("aaa")" to "console.log("bbb")"
OUTPUT "bbb"

A: The solution is to use decache, full code is this (with chokidar folder watcher)
const folder = chokidar.watch("./myFolder", {
    ignored: /(^|[\/\\])\../,
    persistent: true,
});
folder
.on("add", (fileName: string) => {
    const mod = require(fileName)
    mod.default();
.on("change", (fileName: string) => {
    decache(fileName);
    const mod = require(fileName)
    mod.default();
})

redpajama_set_name: RedPajamaStackExchange


We all want our computers in tip top shape. We want them to be fast and work well without annoying popups and other issues caused by viruses. The best way to maintain a well-running computer is to protect it from getting a virus. The good news is you can protect your computer from viruses for free!
Set your computer up with a good free antivirus like Avast as soon as you get it. This will help prevent your computer from falling prey to the most common viruses. If you haven't done this yet it's never too late, but don't be surprised when the first scan pulls up a few things you had on your computer already. Avast is a great free antivirus that will find and contain viruses, alert you to them, and give you options on how you wish to deal with them.
Install browser protection. Most anti-virus programs offer browser extensions that will let you know if a link is untrusted or is a site is safe for you to browse without issues. these add-ons go a long way to protect your device from malicious viruses.
Keep your computer up to date. Keep your system updated as well as your browser, add-ons, and antivirus protections. Many of these updates are to block new viruses and doors into your computer that hackers have created. Leaving these updates sitting leaves your computer open to known issues. Yes, some of these updates bring big changes you may not like. I get that trust me but, sometimes those changes just have to happen so you can have the protection you need.
Don't click the click bait. You will notice a lot of things on the web have titles made to entice you to click things like "You won't believe what so and so is doing now…" Don't click it. These are the types of things packed with viruses that can infect your computer. Likewise, skip the spam-like links you receive on Facebook. Odds are your friend was hacked and if you click that link you could be next.
Beware of downloads. The biggest way to have your device infected is through downloading files that contain viruses. The best prevention for this is to be careful when downloading files. Use anti-virus software that will check files before downloading from emails, websites, and services. That means skip the pirated movies, and games. Are they really worth crashing your computer, losing vital files, and having information stolen?


text:
In Defence of Irish Revisionist Historiography
I'm reading Guy Beiner's masterful study of the folk memory of the 1798 Rebellion in Ireland for my Irish Public History class. In it, Beiner, like nearly every single Irish historian of the past two decades, goes off on Irish revisionist historiography. For those who are unfamiliar with the wars of Irish Historiography, revisionism in the Irish context dates back to the 1920s. In that decade, young scholars, educated at English universities, became frustrated with the fundamental lack of critical studies of the Irish past. Thus, centred around T.W. Moody and R. Dudley Edwards, they began to re-assess Irish history. They eschewed myth and folk tale for fact. They abhorred Irish nationalism for its warping of Irish historiography. They sought a dispassionate, "value-free" national historiography.
Revisionism became the dominant vision of Irish historiography for a period from the 1930s through to the 1990s. In the late 1980s, however, revisionism came under attack for its inability to deal with the more traumatic events in the Irish past. One of the problems with revisionism, critics charged, was that in its desire to view Ireland as un nation comme les autres, it whitewashed calamity: 1641, 1798, 1847, 1916, 1922, etc. At its fundamental core, revisionism is incapable of processing the fact (I know, ironic) that Ireland was an English, and then British, colony from roughly the 13th century until the 20th (there is also the complicating factor of Northern Ireland, still a constituent part of the United Kingdom of Great Britain & Northern Ireland).
I certainly have no great love for the revisionist project, in part because it denied the colonial fact of Ireland. This means that those moments of atrocity, most notably the Famine, get played down. Revisionism tends to shy away from criticising the English/British for their actions in Ireland. But sometimes, as during the Famine, it is simply the fact of the matter that Britain did little to alleviate the starving and misery in Ireland whilst at the same time continuing to export food from the nation.
However. In reading Beiner's devastating critique of revisionism, I am reminded that it DID serve a purpose. Once. A long time ago. When Moody and Edwards were organising their critique of Irish nationalist historiography, their corrective WAS a necessary tonic. Moody argued that nationalist histories were harmful to an understanding of the Irish past, arguing that it was a matter of "facing the facts of the Irish past" as a means to countering the falsehoods of mythology. In the 1930s, for a newborn nation, this was an essential process. The problem is that revisionism went too far and was never able to accord to its internal contradictions. But that doesn't mean it wasn't once necessary.
Tagged: 1798 rebellion, culture, guy beiner, history, ireland, irish history, irish revisionist history, language, memory, r. dudley edwards, tw moody
§ 3 Responses to In Defence of Irish Revisionist Historiography
paulkaramkass says:
Reblogged this on Paul Karam Kassab.
Margo Shea says:
Good piece, thanks.
John Matthew Barlow says:
I cannot believe I'm defending revisionism!
« The International Museum of Folklore
Reflections on Feminism and Class »
You are currently reading In Defence of Irish Revisionist Historiography at Matthew Barlow.
Author: Matthew Barlow
Categories: books, history, ideas


I was really excited about attending the SCBWI Adventures in Nonfiction conference, and I am happy to say that I was not disappointed. I had a lot of fun and learned so much!
I came home with 14 pages of notes in a notebook, multiple worksheets (with even more of my handwritten notes), numerous ideas for nonfiction children's books, and a personalized signed copy of Women Who Dared that I won as a door prize.
Women Who Dared is a beautiful book written by Linda Skeers about 52 not as well-known women in history who dared to dream big. I personally know Linda, and I was super excited to win this book as a door prize. My daughters read through this book and were inspired to research more about a couple of the women.
I am still trying to process all of the information, but I am excited to create some works of nonfiction using some of the information I learned. Nonfiction does not have to mean boring!
What is something you are trying to learn more about?


Tennessee Tea Recipe. How to prepare a delicious Tennessee Tea Cocktail!
BarBug! shows you how to make a TENNESSEE TEA Mixed Drink.
BarBug! is now serving up a Tennessee Tea! He shows you his Tennessee Tea mixed drink recipe and makes suggestions for spirits, mixers and the proper serving glass.
Return to previous page Over 10528679 recipes served!


text:
Admin Exit Admin
Difference Makers 2021
2021-22 Basketball Preview
Zags
Cougs
Tag search results
Tags let us describe our content with keywords, making it easier to find what you're most interested in. Use the search box to look for tags, or explore our coverage with the lists below.
Ramona Siebenhofer wins back-to-back downhills, Lindsey Vonn 9th in Cortina
Austrian skier Ramona Siebenhofer won her second World Cup downhill in two days, while Lindsey Vonn finished tied for ninth Saturday in the second race of her return from injury. Siebenhofer, who had her first career win in Friday's race, finished a slim 0.04 seconds ahead of Austrian teammate Nicole Schmidhofer.
With braces on both knees, Lindsey Vonn struggles with aerodynamics
Lindsey Vonn made an uncharacteristic mistake midway down the slope and finished tied for 15th in a downhill on her return from injury. Austrian skier Ramona Siebenhofer claimed her first World Cup victory with a near-perfect run.
Bill Jennings: For Lookout's marketing director, the Silver Valley is now home
Most ski areas are rather remote. Around here, Lookout Pass is the farthest from modern civilization. What's more, there's something about Idaho's Silver Valley that makes you feel 10,000 miles from home, even though it's only 90 minutes away.
Mikaela Shiffrin finally conquers elusive Kronplatz giant slalom
Mikaela Shiffrin takes advantage of a massive first-run lead to win a World Cup giant slalom in Kronplatz and earn her 10th victory of the season. Having established a 1.39-second lead in the opening leg, Shiffrin finished a comfortable 1.21 seconds ahead of Tessa Worley of France on the steep Erta slope.
Skijoring bring pets to Mount Spokane for Winterfest
Sun., Jan. 13, 2019
Beginners and experienced skiers headed to Mount Spokane on Sunday to try cross-country skiing and skijoring, where up to two dogs can pull their owner down a trail.
The snow is finally here, so check out these Spokane-area deals on skiing, snowboarding
January is learn to ski and snowboard month, and with the area's snow pack finally filling in there are a multitude of deals and events at area resorts.
Petra Vlhova wins slalom to deny Mikaela Shiffrin 8th straight victory
Tue., Jan. 8, 2019
Petra Vlhova of Slovakia has won a women's World Cup night slalom, denying Mikaela Shiffrin a record eighth consecutive win in the discipline. Racing in dense snowfall, Vlhova was third after the opening run but impressed by posting the fastest second-run time to beat Shiffrin by 0.15 seconds. Anna Swenn Larsson of Sweden was 1.05 behind in third.
Free presentation to focus on history of area skiing Jan. 17
The author of a book uncovering Spokane's rich skiing history will give a free presentation Jan. 17 starting at 7 p.m.
Ski for free in Ferry County this weekend
Mon., Jan. 7, 2019
Cross-country ski for free on the Ferry County Rail Trail on Saturday from 10 a.m. to 2 p.m.
High-speed lasers measure glacial movement at Big Sky Resort
Sat., Jan. 5, 2019
Many skiers and snowboarders probably don't know it, but the 9,800-foot-high base of Big Sky Resort's Lone Peak Tram sits atop a slow-moving rock glacier.
Mount Spokane ski patroller wins national Outstanding Alpine Patroller award
Thu., Jan. 3, 2019
Mt. Spokane ski patroller wins national Outstanding Alpine Patroller award.
Jennings: When it's hard to see, seek trees
The forecast for Saturday predicted overnight snow, followed by warming temperatures, rain and wind later in the day. My wingman Dan and me planned to rise early and get first tracks before fresh powder changed to concrete.
Dominik Paris wins super-G for back-to-back victories in Bormio
Sat., Dec. 29, 2018
Italy's Dominik Paris makes it two World Cup victories in two days on home snow by winning a super-G by the slimmest of margins on Saturday. Paris beat Olympic champion Matthias Mayer of Austria by 0.01 seconds for a record fourth win on the Stelvio course, breaking a tie with Austrian greats Hermann Maier and Michael Walchhofer.
American Mikaela Shiffrin wins record 36th World Cup slalom
Mikaela Shiffrin has become the most successful female slalom skier in the 52-year history of the World Cup by winning the last race of 2018. The American built on a big first-run lead to beat Petra Vlhova of Slovakia by 0.29 seconds for her 36th slalom victory. Shiffrin previously shared the record with Marlies Raich. Shiffrin also became the first skier, male or female, to win 15 World Cup races in a single calendar year.
Petra Vlhova wins 1st World Cup GS, 1st-run leader Mikaela Shiffrin 5th
Petra Vlhova became the first Slovakian winner of a women's World Cup giant slalom on Friday, benefiting from first-run leader Mikaela Shiffrin's uncharacteristic second run which saw the Olympic champion drop to fifth.
Slovenia's Klemen Kosi airlifted off downhill course after crash
Slovenian skier Klemen Kosi has been airlifted by helicopter to a local hospital with suspected facial trauma after crashing in a World Cup downhill.
Best Hand Fun Ski event upcoming
Thu., Dec. 27, 2018
The 28th annual Best Hand Fun Ski and Snowshoe Event is scheduled for Jan. 5 at the 4th of July Pass Recreation area in Idaho. Check-in time is 10:30-11:30 a.m. The event starts at 11:30 and prizes will be awarded at 1:30 p.m.
Bill Jennings: Bored by rain, so time to tune the boards
The wait for winter to make up its mind leaves plenty of time for a thorough ski tune.
US coach: Vonn plans to return to racing next month
Sun., Dec. 16, 2018
Lindsey Vonn is hoping to return from injury next month and resume her pursuit of the all-time World Cup wins record, according to the U.S. Ski Team's head coach.
Mt. Spokane ski park adds seven new runs, launches chairlift
Skiers were able to venture to a new part of Mt. Spokane for the first time this weekend after the launch of a new, state-of-the-art chairlift connecting the park to almost 280 ski-able acres.


The World War I Centennial Network is a collaborative association of organizations, museums and historic sites in the United States related to the First World War. The goal of the Network is to further public awareness of the history and memory of The Great War (1914-1918) as we approach and experience its centenary years. To this end, the World War I Centennial Network fosters collaboration and cross-promotion of the special events, commemorations and exhibits created by its members.
The World War I Centennial Network is proudly sponsored by The Western Front Association (WFA) – the World's premier organization dedicated to remembering the First World War. The WFA was founded in the United Kingdom in 1980 and since that time has grown to include branches in Western Europe, Canada, Australia, New Zealand and the United States. It is the aim of the WFA to further interest in the period 1914-1918 to perpetuate the memory, courage and comradeship of those of both sides who served their countries in The Great War.
The founding organization of The World War I Centennial Network is the WFA East Coast Branch (USA) – the American branch of the Western Front Association. Since the early 1990s, WFA East Coast has actively promoted the memory and study of the First World War through the sponsorship of WWI history symposiums, the promotion of a wide variety of WWI-related events in the mid-east region of the United States, and the support of WWI-related museums and sites.
The World War I Centennial Network aims to bring together, for the public good, organizations which share the goals of preserving, perpetuating and interpreting the memory of the First World War – the watershed event of modern history.


text:
Resident Education - current page
Abraham Alvarado-Gonzalez, MD - current page
Expand About Our Program Submenu
Expand Applicant Resources Submenu
M-4 Externships
Residency Videos
UF Neurosurgery in the News
Expand Neurosurgery at UF Submenu
Expand Faculty Clinical Specialties Submenu
Expand Visiting Professor Series Schedule Submenu
Expand Our Current Residents Submenu
Expand Current Resident Quick Links Submenu
Expand Stroke: Self-Study Course Submenu
Archive - 2017 Stroke Conference
Abraham Alvarado-Gonzalez, MD was born in Tamaulipas, Mexico and raised in Laredo, Texas. He completed his undergraduate studies at The University of Texas—Pan American. He graduated summa cum laude with degrees in Chemistry and Psychology. Abe then attended Vanderbilt University School of Medicine and conducted outcomes-based research with the Surgical Outcomes Center for Kids at Monroe Carrel Jr. Children's Hospital. He received his medical degree in May 2016.
Dr. Alvarado-Gonzalez began his neurosurgical training at the University of Florida in July 2016 and is scheduled to complete his residency in June 2023. He enjoys hiking, kayaking and participating in obstacle races.