func MakeBarcode(rw http.ResponseWriter, req *http.Request) {
var id = req.FormValue("id")
var bigint *big.Int = big.NewInt(0)
var code barcode.Barcode
var uuid cassandra.UUID
var err error
if id == "" {
http.NotFound(rw, req)
return
}
uuid, err = cassandra.ParseUUID(id)
if err != nil {
log.Print("Error parsing UUID: ", err)
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Error parsing UUID: " + err.Error()))
return
}
bigint.SetBytes([]byte(uuid))
id = bigint.String()
code, err = code128.Encode(id)
if err != nil {
log.Print("Error generating barcode: ", err)
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Error generating barcode: " + err.Error()))
return
}
code, err = barcode.Scale(code, code.Bounds().Max.X, 24*code.Bounds().Max.Y)
if err != nil {
log.Print("Error scaling barcode: ", err)
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Error scaling barcode: " + err.Error()))
return
}
rw.Header().Set("Content-Type", "image/png")
rw.Header().Set("Content-Disposition", "inline; filename="+uuid.String()+".png")
err = png.Encode(rw, code)
if err != nil {
log.Print("Error writing out image: ", err)
rw.Header().Set("Content-Type", "text/plain; charset=utf8")
rw.Header().Set("Content-Disposition", "inline")
rw.Write([]byte("Error writing out image: " + err.Error()))
}
}
// Get a list of all members which are currently in the trash.
func (m *MembershipDB) EnumerateTrashedMembers(prev string, num int32) ([]*MemberWithKey, error) {
var cp *cassandra.ColumnParent = cassandra.NewColumnParent()
var pred *cassandra.SlicePredicate = cassandra.NewSlicePredicate()
var r *cassandra.KeyRange = cassandra.NewKeyRange()
var kss []*cassandra.KeySlice
var ks *cassandra.KeySlice
var rv []*MemberWithKey
var err error
// Fetch the protobuf column of the application column family.
cp.ColumnFamily = "membership_archive"
pred.ColumnNames = [][]byte{
[]byte("pb_data"),
}
if len(prev) > 0 {
var uuid cassandra.UUID
if uuid, err = cassandra.ParseUUID(prev); err != nil {
return rv, err
}
r.StartKey = append([]byte(archivePrefix), []byte(uuid)...)
} else {
r.StartKey = []byte(archivePrefix)
}
r.EndKey = []byte(archiveEnd)
r.Count = num
kss, err = m.conn.GetRangeSlices(cp, pred, r, cassandra.ConsistencyLevel_ONE)
if err != nil {
return rv, err
}
for _, ks = range kss {
var member *MemberWithKey
var scol *cassandra.ColumnOrSuperColumn
var uuid cassandra.UUID = cassandra.UUIDFromBytes(
ks.Key[len(archivePrefix):])
if len(ks.Columns) == 0 {
continue
}
for _, scol = range ks.Columns {
var col *cassandra.Column = scol.Column
if string(col.Name) == "pb_data" {
var agreement = new(MembershipAgreement)
member = new(MemberWithKey)
err = proto.Unmarshal(col.Value, agreement)
proto.Merge(&member.Member, agreement.GetMemberData())
member.Key = uuid.String()
}
}
if member != nil {
rv = append(rv, member)
}
}
return rv, nil
}
// Get a list of all membership applications currently in the database.
// Returns a set of "num" entries beginning after "prev". If "criterion" is
// given, it will be compared against the name of the member.
func (m *MembershipDB) EnumerateMembershipRequests(criterion, prev string, num int32) (
[]*MemberWithKey, error) {
var cp *cassandra.ColumnParent = cassandra.NewColumnParent()
var pred *cassandra.SlicePredicate = cassandra.NewSlicePredicate()
var r *cassandra.KeyRange = cassandra.NewKeyRange()
var kss []*cassandra.KeySlice
var ks *cassandra.KeySlice
var rv []*MemberWithKey
var err error
// Fetch the name, street, city and fee columns of the application column family.
cp.ColumnFamily = "application"
pred.ColumnNames = [][]byte{
[]byte("name"), []byte("street"), []byte("city"), []byte("fee"),
[]byte("fee_yearly"),
}
if len(prev) > 0 {
var uuid cassandra.UUID
if uuid, err = cassandra.ParseUUID(prev); err != nil {
return rv, err
}
r.StartKey = append([]byte(applicationPrefix), []byte(uuid)...)
} else {
r.StartKey = []byte(applicationPrefix)
}
r.EndKey = []byte(applicationEnd)
r.Count = num
kss, err = m.conn.GetRangeSlices(
cp, pred, r, cassandra.ConsistencyLevel_ONE)
if err != nil {
return rv, err
}
for _, ks = range kss {
var member *MemberWithKey = new(MemberWithKey)
var scol *cassandra.ColumnOrSuperColumn
var uuid cassandra.UUID = cassandra.UUIDFromBytes(
ks.Key[len(applicationPrefix):])
member.Key = uuid.String()
if len(ks.Columns) == 0 {
continue
}
for _, scol = range ks.Columns {
var col *cassandra.Column = scol.Column
if string(col.Name) == "name" {
member.Name = proto.String(string(col.Value))
} else if string(col.Name) == "street" {
member.Street = proto.String(string(col.Value))
} else if string(col.Name) == "city" {
member.City = proto.String(string(col.Value))
} else if string(col.Name) == "fee" {
member.Fee = proto.Uint64(binary.BigEndian.Uint64(col.Value))
} else if string(col.Name) == "fee_yearly" {
member.FeeYearly = proto.Bool(col.Value[0] == 1)
}
}
rv = append(rv, member)
}
return rv, nil
}
// Output a JSON list of all applicants currently waiting to become members.
func (a *ApplicantListHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
var applist applicantListType
var enc *json.Encoder
var err error
if !a.auth.IsAuthenticatedScope(req, a.admingroup) {
rw.WriteHeader(http.StatusUnauthorized)
return
}
if req.FormValue("single") == "true" && len(req.FormValue("start")) > 0 {
var memberreq *membersys.MembershipAgreement
var mwk *membersys.MemberWithKey
var bigint *big.Int = big.NewInt(0)
var uuid cassandra.UUID
var ok bool
bigint, ok = bigint.SetString(req.FormValue("start"), 10)
if !ok {
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Unable to parse " + req.FormValue("start") +
" as a number"))
return
}
if bigint.BitLen() == 128 {
uuid = cassandra.UUIDFromBytes(bigint.Bytes())
memberreq, _, err = a.database.GetMembershipRequest(
uuid.String(), "application", "applicant:")
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Unable to retrieve the membership request " +
uuid.String() + ": " + err.Error()))
return
}
mwk = new(membersys.MemberWithKey)
mwk.Key = uuid.String()
proto.Merge(&mwk.Member, memberreq.GetMemberData())
applist.Applicants = []*membersys.MemberWithKey{mwk}
}
} else {
applist.Applicants, err = a.database.EnumerateMembershipRequests(
req.FormValue("criterion"), req.FormValue("start"), a.pagesize)
if err != nil {
log.Print("Error enumerating applications: ", err)
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Error enumerating applications: " + err.Error()))
return
}
}
applist.AgreementUploadCsrfToken, err = a.auth.GenCSRFToken(
req, applicantAgreementUploadURL, 10*time.Minute)
if err != nil {
log.Print("Error generating CSRF token: ", err)
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Error generating CSRF token: " + err.Error()))
return
}
applist.ApprovalCsrfToken, err = a.auth.GenCSRFToken(
req, applicantApprovalURL, 10*time.Minute)
if err != nil {
log.Print("Error generating CSRF token: ", err)
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Error generating CSRF token: " + err.Error()))
return
}
applist.RejectionCsrfToken, err = a.auth.GenCSRFToken(
req, applicantRejectionURL, 10*time.Minute)
if err != nil {
log.Print("Error generating CSRF token: ", err)
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Error generating CSRF token: " + err.Error()))
return
}
rw.Header().Set("Content-Type", "application/json; encoding=utf8")
enc = json.NewEncoder(rw)
if err = enc.Encode(applist); err != nil {
log.Print("Error JSON encoding member list: ", err)
rw.WriteHeader(http.StatusInternalServerError)
rw.Write([]byte("Error encoding result: " + err.Error()))
return
}
}
