poiyzy (Roy)

新博文：介绍 Fengche.co 中对 Observer 的使用

poiyzy — Thu, 20 Mar 2014 16:51:04 +0800

新博客，介绍 Fengche.co 中为什么使用 Observer，希望和大家一起交流 :)

http://yangzhuoyu.com/why-we-use-rails-observer/

新的起点，加入远程创业团队 Pragmatic.ly

poiyzy — Wed, 16 Oct 2013 13:43:47 +0800

加入 Pragmatic.ly 一个月了，写了一篇新博文，和大家分享一下在一个国内优秀远程创业团队中所学到的东西。

对于远程工作甚至是创业，在我加入这个团队之前，一直都很好奇。体验了一个月，我来分享一下在这个团队中大家是如何有效利用自由时间享受工作和生活。

http://yangzhuoyu.com/first-month-in-pragmatic-ly/

使用 Mailgun 建立一个数据驱动方法来保持用户 Email 更新

poiyzy — Sat, 23 Mar 2013 01:34:01 +0800

在 @knwang 老师的指导下，最近给 Mailgun 写了一篇博客，原文在这里 - http://blog.mailgun.net/post/45366504974/building-a-data-driven-approach-to-keeping-users

无耻小请求：小菜鸟第一次写这样的技术博文，居然上了 Hacker News, 各位大大们帮忙在 HN 上投个票吧。

Building a data-driven approach to keeping user contacts up-to-date

This blog was written by Roy Young. Roy is a student from Tealeaf Academy.

Do you remember every email address you use with every one of your online accounts? You know, the accounts you use with your spam email address, versus your "real" email, versus your work email? Probably not. And neither do your users. That is why it makes sense to periodically confirm that you have the best contact information on file for your customers. You could do this every month, or once a year, or take a data driven approach that lets you focus only on the customers that will most likely find your notices to update their contact information helpful, rather than annoying.

Application logic for prompting user to update their email address

When you send email to an email address that no longer exists, the receiving party (e.g. Gmail or Yahoo) will bounce the email back to you. If you listen to these bounces, your app can react appropriately, creating a great user experience while keeping your customer database up-to-date. This blog outlines a sample application built on Heroku that uses Mailgun to listen to these bounced emails so that users with bad email addresses can continue to receive monthly invoice emails. The same logic could be applied to any of your emails, however, making sure that your users stay engaged and up-to-date with your company via email.

This post is built around the following workflow:

Some user signs up for the app with some email address.
App sends out automatic monthly billing emails to all users using Heroku Scheduler.
User changes job, leaving their email address in system no longer valid.
Emails sent to the old address bounce, and Mailgun sends a POST via the bounce webhook to the app.
The app marks the user with a special status and stops sending the user monthly billing emails.
When the user signs in to your app the next time, a flash message displays about email no longer being valid and takes them to the account page and prompts them to update their email.
User updates their email address and they continue to receive the monthly billing emails.

I've created a demo site for this article and made the source code available on Github. This demo walks a novice through the entire process of setting up this functionality. Click here if you want to skip directly to integrating bounce web hooks into your a app.

Sending monthly invoice emails via Mailgun using Heroku Scheduler

To send monthly invoices to your users, you'll need to write code to:

Deploy customized invoice emails to your hundreds, or thousands or millions of customers.
Actually Schedule the deployment of these emails.

Let's look at each of these in turn.

Deploying customized invoce emails using Mailgun

Sending emails via Mailgun simply requires an account. For the purposes of this tutorial, I'll you've already done that. From there, you'll want to send your customer list to Mailgun, along with any variables that you want dynamically inserted into the emails as a JSON file and the HTML or text body of the email. Here is the code.

class MailgunGateway
  include Rails.application.routes.url_helpers

  def send_batch_message(users)
    RestClient.post(messaging_api_end_point,
    from: "Mailgun Demo <billing@#{ENV["mailgun_domain_name"]}>",
    to: users.map(&:email).join(", "),
    subject: "Monthly Billing Info",
    html: billing_info_text,
    :"h:Reply-To" =>  "billing@#{ENV["mailgun_domain_name"]}",
    :"recipient-variables" => recipient_variables(billing_recipients)
    )
  end

  private

  def api_key
    @api_key ||= ENV["mailgun_api_key"]
  end

  def messaging_api_end_point
    @messaging_api_end_piont ||= "https://api:#{api_key}@api.mailgun.net/v2/#{ENV["mailgun_domain_name"]}/messages"
  end

  def billing_recipients
    @users ||= User.where(locked: false)
  end

  def recipient_variables(recipients)
    vars = recipients.map do |recipient|
      "\"#{recipient.email}\": {\"name\":\"#{recipient.fullname}\"}"
    end
    "{#{vars.join(', ')}}"
  end

  def billing_info_text
<<-EMAIL
<html><body>

Hi %recipient.name%,

<p>
Your bill for the current month is now available, please click on
<br/>
#{billing_url}
<br/>
to see details.
</p>
<p>Reply to this email directly</p>

</body></html>
EMAIL
  end
end

In the send_batch_message method, we also use Recipient Variables so that we can define variables to customize each email. You'll notice that we are inserting the user's first name in the email. You could compose an invoice email that includes details like account number, invoice account, or anything else you like, but I'm keeping things simple.

Sending out automatic monthly billing emails with Heroku Scheduler

Once we have our method for creating and deploying emails via Mailgun, we need to write some code that automatically triggers this method. I've chosen to deploy this app on Heroku and am using Heroku Scheduler because it does the job, is a free add-on, and is easy to integrate.

Heroku Scheduler will run a specified Rake task at a specified time. So here we need to build a Rake task to send billing emails using Mailgun in lib/tasks/scheduer.rake.

desc "This task is called by the Heroku scheduler add-on"

task :send_billing_info => :environment do
  if DateTime.now.mday == 1
    User.where(locked: false).find_in_batches(batch_size: 1000) do |group|
      MailgunGateway.new.send_batch_message(group)
    end
  end
end

Beacuse Heroku Scheduler "FREQUENCY" setting has only three selectors-- "daily, hourly, every 10 mins"-- we need to check whether the current day is the first day of the month using if DateTime.now.mday == 1. If it is, the email is deployed. If not, no email.

When we send billing invoices to users, we need to find the email addresses of the customer we need to invoice.

In this sample app's very simple database shcema, we have a :locked attribute that is set to True when an email has bounced previously (more on that below). So our query simply pulls all our users where this field is False.

To actually send the email, I'm using Maigun Batch Sending. Beacuse the maximum number of recipients allowed per API call is 1,000, we use find_in_batches to send billing emails to Mailgun in batches of 1000 recipients.

This is what the Scheduler setting look like in Heroku:

Receiving notification of bounced emails from Mailgun

When an email is bounced, Mailgun will send a POST via the bounce webhook to our app. You need to set the callback url under "Bounces" in the Mailgun Control Panel. In this demo, my callback url is "http://mailgun-demo.herokuapp.com/api/bounced_mails"

When the app receives the notification from Mailgun, the app will find the email address in the customer database, and set the user status to locked, so the app will not send billing email to the user until the user update his email address.

class Api::BouncedMailsController < ApplicationController
  skip_before_filter :verify_authenticity_token

  def create
    if verify(ENV["mailgun_api_key"], params[:token], params[:timestamp], params[:signature])
      user = User.find_by_email(params[:recipient])
      if user && params[:event] == "bounced"
        user.lock!
      end
      head(200)
    end
  end

  private
  def verify(api_key, token, timestamp, signature)
    signature == OpenSSL::HMAC.hexdigest(
      OpenSSL::Digest::Digest.new('sha256'),
      api_key,
      '%s%s' % [timestamp, token])
  end
end

The user.lock! is to set user status to locked, so our Rake Task will never send emails to this user. This method is set in User model.

class User < ActiveRecord::Base

  …

  def lock!
    self.locked = true
    save(validate: false)
  end
end

The verity method is to verify the webhook is originating from Mailgun, otherwise any others could send a fake POST to lock the users in your app.

For more details on configuring web hooks you can read the Mailgun documentation - Events/Webhooks.

In the end, we return a 200 header to tell Mailgun that this interaction is successful, otherwise Mailgun will think our server is down and will keep trying to call our webhook.

Displaying the flash screen for a user to update their email

Once the app knows which users have a bad email address, we need to display a flash screen to the user upon their next login with a prompt to verify their contact information on file.

class SessionsController < ApplicationController
  def new
    redirect_to home_path if current_user
  end

  def create
    user = User.find_by_email(params[:email])
    if user && user.authenticate(params[:password])
      session[:user_id] = user.id
      if user.locked
        flash[:error] = "Your Email Address is invalid, please update it."
        redirect_to edit_user_path(current_user)
      else
        redirect_to home_path
      end
    else
      flash[:error] = "Incorrect email or password. Please try again."
      redirect_to sign_in_path
    end
  end

  def destroy
    session[:user_id] = nil
    redirect_to root_path
  end
end

Once they've updated their email address, we set the locked attribute back to false so that they will continue to receive emails.

That's it. Now, when your users email's bounce, you can prompt them to update their information, providing a great user experience with the added benefit of keeping your customer data fresh.

我的成长 (新手)

poiyzy — Wed, 27 Feb 2013 17:42:39 +0800

我接触 Rails 大概有 1 年半的时间，目前还是新手一名。通过最近半年的专心学习，感触很多，所以分享出来，以便帮助和我情况相同的新手。

我在接触 Ruby 之前做了两年的 PHP，后来很偶然的一个机会开始学习 Ruby。自学 Ruby 的时候无非就是看书，泡论坛，自己做玩具，在 Github 上看别人的代码，订阅 Screencast。大概半年的时间，感觉是入门了，可是还是无法深入。总是停留在做玩具的阶段，后来帮朋友用 Ruby 重构一个 PHP 的网站算是积累了一些解决实际问题的经验，不过这些经验还是少的可怜。

我自学的时候最大的问题是对自己不自信（因为首先是新手，其次我本科不是计算机专业的），所以就是混论坛也不敢说话、不敢分享，不是怕被别人笑话，而是怕误导了其他新手，但是正像 @lgn21st 在 Teahour 当中提到的正是不自信才驱动自己不断的去学习去提高。可是如何去提高自己呢？

就这样一年过去了，那个时候我感觉和这里的很多朋友一样，非常渴望找一个师傅带带自己（因为自己周围没有做 Ruby 的人可以请教），最近在参加 @knwang 的 Gotealeaf Intermediate 课程，课程进行过半来分享一下有了老师以后的感觉。

课程本身的内容就不说了，很赞。自学的时候总是对自己定位不清楚，不知道自己欠缺什么，终于知道自己欠缺什么的时候，但是不知道该看什么，走了很多弯路。很多时候，看一本书，看到一半的时候发现这本书大部分东西都很初级，提升并不是很多，但是看一半了又不想放下，这样看完一本书提高并不多。再者就是太难了，耐着性子看好几天最后放弃了，这样一来二去的花费不少时间。

在这次课程上，我最激动的是终于完成了找到一个师傅的心愿！在课程中，Kevin 哥给每个学员做了 1 对 1 的谈话，关于你的目标是什么？Where you are？并且给予了每个人单独的建议。一下子我就明朗了，知道具体该做，订阅什么 Screencasts，读什么书…… He gets me on the fast track!

说了这么多废话，给大家分享一些很棒的付费内容（大家多次推荐的就不再推荐了）:

Course:

当然是 Gotealeaf 啦！

Books:

@Xdite 的 Rails 101 和 Essential Rails Design Patterns（这本现在还没有完结）
Everyday Rails Testing with RSpec （测试入门）

Screencasts:

都是收费内容。为自己投资，值得！

A student from Gotealeaf, Thanks Kevin to bring me to Ruby world!

在 Gemfile 中通过 bundle install 安装源自 github 的 gem 后如何删除 gem 呢？

poiyzy — Tue, 09 Oct 2012 19:20:54 +0800

难道直接 bundle show [Gem_Name] 找到 path 后删除文件夹么？

现在的收藏功能一直不能用啊

poiyzy — Mon, 02 Jul 2012 16:31:10 +0800

收藏了好多东西，现在有时间想去看看学习学习，可是一直打不开啊。