func send(c context.Context, message *PostmarkMessage) error {
client := urlfetch.Client(c)
requestBody, err := json.Marshal(message)
if err != nil {
return err
}
req, err := http.NewRequest("POST", "https://api.postmarkapp.com/email/withTemplate", strings.NewReader(string(requestBody)))
if err != nil {
return err
}
req.Header.Add("Content-Type", "application/json")
req.Header.Add("X-Postmark-Server-Token", config.Get(c, "POSTMARK_KEY"))
res, err := client.Do(req)
log.Infof(c, "Postmark: %v %v %v", req, res, err)
if err != nil {
return err
}
defer res.Body.Close()
resBody, err := ioutil.ReadAll(res.Body)
log.Infof(c, "Postmark response: %s", string(resBody))
return nil
}
func ShipHandler(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
sc := client.New(config.Get(c, "STRIPE_KEY"), stripe.NewBackends(urlfetch.Client(c)))
r.ParseForm()
orderID := r.Form.Get("orderID")
trackingNumber := r.Form.Get("trackingNumber")
order, err := sc.Orders.Update(orderID, &stripe.OrderUpdateParams{
Status: stripe.StatusFulfilled,
Params: stripe.Params{
Meta: map[string]string{"tracking_number": trackingNumber},
},
})
if err != nil {
web.SendError(c, w, err, 500, "Error marking order as fulfilled")
return
}
customer, err := sc.Customers.Get(order.Customer.ID, nil)
if err != nil {
web.LogError(c, err, "Error fetching customer info for email")
} else {
err = email.SendShippingNotification(c, customer.Desc, customer.Email, order.Shipping, trackingNumber)
if err != nil {
web.LogError(c, err, "Error sending shipping notification")
}
}
web.SendJSON(c, w, ChargeResponse{Success: true})
}
func OrdersHandler(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
sc := client.New(config.Get(c, "STRIPE_KEY"), stripe.NewBackends(urlfetch.Client(c)))
lastKey := "or_17fQDrKpn8lOrcLslDTTOnWv"
r.ParseForm()
before := r.Form.Get("before")
if before != "" {
lastKey = before
}
params := &stripe.OrderListParams{
ListParams: stripe.ListParams{
Single: true,
End: lastKey,
},
}
status := r.Form.Get("status")
if status != "" && status != "all" {
params = &stripe.OrderListParams{
Status: stripe.OrderStatus(status),
ListParams: stripe.ListParams{
Single: true,
End: lastKey,
},
}
}
iter := sc.Orders.List(params)
var response OrdersResponse
response.Orders = []*ShortOrder{}
for iter.Next() {
if iter.Order().Status != stripe.StatusCanceled {
o := iter.Order()
response.Orders = append(response.Orders, &ShortOrder{
ID: o.ID,
Created: o.Created,
Status: o.Status,
Shipping: o.Shipping,
Customer: o.Customer,
Meta: o.Meta,
})
}
}
web.SendJSON(c, w, response)
}
func init() {
if config.Get("AWS_ACCESS_KEY_ID") == "" {
panic("AWS_ACCESS_KEY_ID environmental variable not specified.")
}
if config.Get("AWS_SECRET_ACCESS_KEY") == "" {
panic("AWS_SECRET_ACCESS_KEY environmental variable not specified.")
}
aws.DefaultConfig.Credentials = credentials.NewStaticCredentials(
config.Get("AWS_ACCESS_KEY_ID"),
config.Get("AWS_SECRET_ACCESS_KEY"), "")
if config.Get("AWS_REGION") == "" {
panic("AWS_REGION environmental variable not specified.")
}
aws.DefaultConfig.Region = config.Get("AWS_REGION")
}
// Replaces contents from the source for the transition from old to new
// Author: Ryan Benson
package replacer
import (
"config"
"net/url"
"path/filepath"
"strings"
)
var oldWebsite = config.Get("Oldwebsite")
var website = config.Get("Website")
var oldWebsitePath = config.Get("Oldwebsitepath")
var Websitepath = config.Get("Websitepath")
var imageCdn = config.Get("Cdn")
func init() {
// Initializer
}
// ReplaceUrl (public) - replace url from a string to once that is given
// but keeps the URL path. Example:
// http://www.test.com/articles/hello-world ->
// http://www.new-website.com/articles/hello-world
// @params: from {string} - origin URL
// @params: to {string} - new URL
// @return: {string} - final URL
func ReplaceUrl(from, to string) string {
return to + getUrlPath(from)
}
"net"
"net/http"
"time"
"appengine"
"appengine/socket"
"appengine/urlfetch"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/ec2"
"config"
)
var (
dreamServerAmi = config.Get("DREAMPICS_DREAMSERVER_AMI")
dreamServerInstanceType = config.Get("DREAMPICS_DREAMSERVER_INSTANCE_TYPE")
awsSecurityGroup = config.Get("AWS_SECURITY_GROUP")
)
func init() {
if dreamServerAmi == "" {
panic("DREAMPICS_DREAMSERVER_AMI environmental variable missing.")
}
if dreamServerInstanceType == "" {
panic("DREAMPICS_DREAMSERVER_INSTANCE_TYPE environmental variable missing.")
}
if awsSecurityGroup == "" {
panic("AWS_SECURITY_GROUP environmental variable missing.")
}
}
// Downloads invidual assets or bulk downloads assets, and also ensures
// that there's a proper directory locally to hold them
// Author: Ryan Benson
package downloader
import (
"config"
"io"
"net/http"
"os"
"replacer"
"scraper"
)
var filesDir string = config.Get("Dir")
var oldWebsite string = config.Get("Oldwebsite")
func init() {
// check to see if directory exists, if not make it
if isDir(filesDir) == false {
makeDir(filesDir)
}
}
// Download (public) - downloads a remote file to local directory
// @params: output {string} - filename to save file as
// @params: file {string} - URL to download the file from
// @return: {nil}
func Download(output, file string) {
out, err := os.Create(filesDir + "/" + output)
if err != nil {
package storage
import (
"config"
)
var (
gcsBucket = config.Get("GCS_BUCKET")
)
func init() {
if gcsBucket == "" {
panic("Missing GCS_BUCKET environmental variable.")
}
}
func main() {
var ex profile.TSProfile
ex.Execute.Start(0)
/**
* Get the configuration information and set the properties
* of each data set
*/
var configs = config.Get("conf.json")
for _, config := range configs.Property {
fmt.Println(config)
}
// Initialise each data set
var sets = make([]data.TSSet, len(configs.Property))
// Iterate through each data set as defined by its properties
for idxProps, v := range configs.Property {
/**
* Set each data set's properties from the configuration
* information pulled from the JSON configuration file
*/
sets[idxProps].Id = int64(idxProps)
sets[idxProps].Property = v
if sets[idxProps].Property.Now {
sets[idxProps].Property.Start = time.Now()
}
sets[idxProps].Property.Verbose = false
sets[idxProps].Output.Verbose = false
// Create a channel for each data set to indicate when it is done
sets[idxProps].Done = make(chan bool)
// Open Report with config settings
sets[idxProps].Report = new(report.TSReport)
sets[idxProps].Report.Name = "Report_" + strconv.Itoa(idxProps+1)
sets[idxProps].Report.AddString("Report_" + strconv.Itoa(idxProps+1) + " of " + strconv.Itoa(len(configs.Property)))
sets[idxProps].Report.AddString("***Config***")
sets[idxProps].Report.AddStruct(v)
/**
* Start the creation of each dataset as a separate go concurrent
* process(es)
*/
go sets[idxProps].Create()
}
// Wait for each of the data sets to complete before exit
for idxProps := 0; idxProps < len(configs.Property); idxProps++ {
<-sets[idxProps].Done
fmt.Println("Samples/s:", float64(float64(sets[idxProps].Property.Samples)/float64(float64(ex.Execute.Elapsed())/1e9)))
fmt.Println("Sites:", sets[idxProps].Property.Sites)
fmt.Println("Samples:", sets[idxProps].Property.Samples)
fmt.Println("Batch:", sets[idxProps].Property.Batch)
fmt.Println("Spools:", sets[idxProps].Property.Spools)
}
fmt.Println("Done")
fmt.Println("Total execution time:", float64(ex.Execute.Elapsed())/1e9, "s")
}
// Initializer - sets up the CLI flag, includes default from config (from JSON)
// @params: {nil}
// @return: {nil}
func init() {
defaultCsvFile := config.Get("DefaultCsvFile")
flag.StringVar(&file, "file", defaultCsvFile, "Path and filename to import (e.g. files/content.csv)")
flag.Parse()
}
func PaymentHandler(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
decoder := json.NewDecoder(r.Body)
body := new(PaymentRequestBody)
err := decoder.Decode(&body)
if err != nil {
web.SendError(c, w, err, 400, "Could not parse payment information")
return
}
token := body.Token
args := body.Args
sc := client.New(config.Get(c, "STRIPE_KEY"), stripe.NewBackends(urlfetch.Client(c)))
shipping := &stripe.ShippingParams{
Name: args.ShippingName,
Address: &stripe.AddressParams{
Line1: args.ShippingAddressLine1,
Line2: args.ShippingAddressLine2,
City: args.ShippingAddressCity,
State: args.ShippingAddressState,
PostalCode: args.ShippingAddressZIP,
Country: args.ShippingAddressCountry,
},
}
customer, err := sc.Customers.New(&stripe.CustomerParams{
Email: token.Email,
Desc: args.BillingName,
Source: &stripe.SourceParams{Token: token.ID},
})
if err != nil {
web.SendError(c, w, err, 500, "Error saving customer to Stripe")
return
}
order, err := sc.Orders.New(&stripe.OrderParams{
Currency: "usd",
Customer: customer.ID,
Shipping: shipping,
Items: []*stripe.OrderItemParams{
&stripe.OrderItemParams{
Type: "sku",
Parent: "book",
},
},
})
if err != nil {
web.SendError(c, w, err, 500, "Error saving order to Stripe")
return
}
err = incrementSoldCounter(c)
if err != nil {
web.LogError(c, err, "Error incrementing sold counter")
}
err = email.SendReceipt(c, args.BillingName, token.Email, order.Shipping)
if err != nil {
web.LogError(c, err, "Error sending receipt")
}
web.SendJSON(c, w, PaymentResponse{Ok: true})
}
func ChargeHandler(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
sc := client.New(config.Get(c, "STRIPE_KEY"), stripe.NewBackends(urlfetch.Client(c)))
r.ParseForm()
orderID := r.Form.Get("orderID")
customerID := r.Form.Get("customerID")
_, err := sc.Orders.Pay(orderID, &stripe.OrderPayParams{
Customer: customerID,
})
if err != nil {
stripeErr := err.(*stripe.Error)
web.LogError(c, err, "Error from Stripe")
switch stripeErr.Code {
case stripe.IncorrectNum:
fallthrough
case stripe.InvalidNum:
fallthrough
case stripe.InvalidExpM:
fallthrough
case stripe.InvalidExpY:
fallthrough
case stripe.InvalidCvc:
fallthrough
case stripe.ExpiredCard:
fallthrough
case stripe.IncorrectCvc:
fallthrough
case stripe.IncorrectZip:
fallthrough
case stripe.CardDeclined:
customer, err := sc.Customers.Get(customerID, nil)
if err != nil {
web.SendError(c, w, err, 500, "Error getting customer")
return
}
_, err = sc.Orders.Update(orderID, &stripe.OrderUpdateParams{
Status: stripe.StatusCanceled,
})
if err != nil {
web.SendError(c, w, err, 500, "Error marking order as cancelled")
return
}
err = email.SendPaymentDeclinedNotification(c, customer.Desc, customer.Email)
if err != nil {
web.SendError(c, w, err, 500, "Error sending payment declined email")
}
web.SendJSON(c, w, ChargeResponse{Success: false})
return
default:
web.SendError(c, w, err, 500, "Error charging card")
return
}
}
web.SendJSON(c, w, ChargeResponse{Success: true})
}
