Use a REST API: Difference between revisions
Content added Content deleted
(Added Wren) |
|||
Line 891: | Line 891: | ||
main()</lang> |
main()</lang> |
||
=={{header|Wren}}== |
|||
{{trans|Go}} |
|||
{{libheader|WrenGo}} |
|||
{{libheader|Meetup-client(for Go)}} |
|||
{{libheader|Wren-date}} |
|||
An embedded program with a Go host and a translation of the second Go example so we can use its third party library to create events. |
|||
I did wonder whether it was worth the effort to do this task given that we're using a deprecated API and can't test creating events without a paid subscription which I don't have. However, from Wren's viewpoint, there are some points of interest relating to the use of WrenGo - notably passing Wren maps to Go - which may be a useful reference for the future. |
|||
<lang ecmascript>/* meetup.wren */ |
|||
import "./date" for Date |
|||
class Meetup { |
|||
static groupId { "group_id" } |
|||
static groupUrlName { "group_urlname" } |
|||
static eventName { "name" } |
|||
static description { "description" } |
|||
static eventTime { "time" } |
|||
static eventUpcoming { "upcoming" } |
|||
foreign static getKey(fileName) |
|||
} |
|||
foreign class Client { |
|||
construct new(clientOpts) {} |
|||
groupByUrlName(urlName) { Group.new(this, urlName) } |
|||
eventsByGroup(urlName, status, desc) { Events.new(this, urlName, status, desc) } |
|||
createEvent(o) { Event.new(this, o) } |
|||
foreign deleteEvent(eventId) |
|||
} |
|||
foreign class Group { |
|||
construct new(client, urlName) {} |
|||
foreign urlName |
|||
foreign groupId |
|||
foreign memberCount |
|||
foreign organizerName |
|||
} |
|||
foreign class Event { |
|||
construct new(client, o) {} |
|||
foreign eventName |
|||
foreign eventId |
|||
} |
|||
foreign class Events { |
|||
construct new(client, urlName, status, desc) {} |
|||
foreign eventsCount |
|||
foreign eventsId(index) |
|||
foreign eventsName(index) |
|||
foreign eventsLink(index) |
|||
foreign venueName(index) |
|||
} |
|||
var keyFile = "api_key.txt" |
|||
var key = Meetup.getKey(keyFile) |
|||
var c = Client.new(key) |
|||
// get basic information for a particular group |
|||
var urlName = "Meetup-API-Testing" |
|||
var g = c.groupByUrlName(urlName) |
|||
System.print("Basic information for the %(g.urlName) group:") |
|||
System.print(" ID : %(g.groupId)") |
|||
System.print(" Member count : %(g.memberCount)") |
|||
System.print(" Organizer : %(g.organizerName)") |
|||
// get a list of upcoming events for this group |
|||
var events = c.eventsByGroup(urlName, Meetup.eventUpcoming, false) |
|||
System.print("Upcoming events for the %(g.urlName) group") |
|||
for (i in 0...events.eventsCount) { |
|||
System.print(" ID : %(events.eventsId(i))") |
|||
System.print(" Name : %(events.eventsName(i))") |
|||
System.print(" Link : %(events.eventsLink(i))") |
|||
System.print(" Venue : %(events.venueName(i))") |
|||
System.print() |
|||
} |
|||
// create an event for this group |
|||
var eventDate = (Date.new(2022, 4, 1, 18, 0, 0, 0, "UTC").unixTime * 1000).toString |
|||
var o = { |
|||
Meetup.groupId: g.groupId.toString, |
|||
Meetup.groupUrlName: urlName, |
|||
Meetup.eventName: "Test Meetup integration", |
|||
Meetup.description: "This is an event test.", |
|||
Meetup.eventTime: eventDate |
|||
} |
|||
var event = c.createEvent(o) |
|||
System.print("The ID for the %(event.eventName) event is %(event.eventId)\n") |
|||
// delete the event just posted |
|||
c.deleteEvent(event.eventId) |
|||
System.print("The %(event.eventName) event has been cancelled.\n")</lang> |
|||
<br> |
|||
We now embed this in the following Go program and build it. To run it, you will need the necessary authorization, a paid subscription and, of course, non-fictitious data. |
|||
<lang go>/* go build meetup.go */ |
|||
package main |
|||
import ( |
|||
"github.com/Guitarbum722/meetup-client" |
|||
"github.com/Guitarbum722/meetup-client/models" |
|||
wren "github.com/crazyinfin8/WrenGo" |
|||
"io/ioutil" |
|||
"log" |
|||
"net/url" |
|||
"strings" |
|||
) |
|||
type any = interface{} |
|||
func eventOptions(et map[string][]string, vals url.Values) { |
|||
for k, v := range et { |
|||
if len(v) < 1 { |
|||
break |
|||
} |
|||
switch k { |
|||
case meetup.GroupID: |
|||
vals.Add(meetup.GroupID, strings.Join(v, ",")) |
|||
case meetup.GroupURLName: |
|||
vals.Add(meetup.GroupURLName, strings.Join(v, ",")) |
|||
case meetup.EventName: |
|||
vals.Add(meetup.EventName, strings.Join(v, ",")) |
|||
case meetup.Description: |
|||
vals.Add(meetup.Description, strings.Join(v, ",")) |
|||
case meetup.EventTime: |
|||
vals.Add(meetup.EventTime, strings.Join(v, ",")) |
|||
default: |
|||
// empty |
|||
} |
|||
} |
|||
} |
|||
func check(err error) { |
|||
if err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
} |
|||
func getKey(vm *wren.VM, parameters []any) (any, error) { |
|||
keyFile := parameters[1].(string) |
|||
keydata, err := ioutil.ReadFile(keyFile) |
|||
check(err) |
|||
key := strings.TrimSpace(string(keydata)) |
|||
return key, nil |
|||
} |
|||
func newClient(vm *wren.VM, parameters []any) (any, error) { |
|||
key := parameters[1].(string) |
|||
c := meetup.NewClient(&meetup.ClientOpts{APIKey: key}) |
|||
return &c, nil |
|||
} |
|||
func deleteEvent(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
c := ifc.(*meetup.Clienter) |
|||
eventId := parameters[1].(string) |
|||
err := (*c).DeleteEvent(eventId) |
|||
check(err) |
|||
return nil, nil |
|||
} |
|||
func newGroup(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[1].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
c := ifc.(*meetup.Clienter) |
|||
urlName := parameters[2].(string) |
|||
groups, err := (*c).GroupByURLName([]string{urlName}) |
|||
check(err) |
|||
if len(groups.Groups) == 0 { |
|||
log.Fatalf("There are no groups for the url name '%s'.\n", urlName) |
|||
} |
|||
return &(groups.Groups[0]), nil |
|||
} |
|||
func urlName(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
g := ifc.(**models.Group) |
|||
return (**g).URLName, nil |
|||
} |
|||
func groupId(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
g := ifc.(**models.Group) |
|||
return (**g).ID, nil |
|||
} |
|||
func memberCount(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
g := ifc.(**models.Group) |
|||
return (**g).MemberCount, nil |
|||
} |
|||
func organizerName(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
g := ifc.(**models.Group) |
|||
return (**g).Organizer.Name, nil |
|||
} |
|||
func newEvent(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[1].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
c := ifc.(*meetup.Clienter) |
|||
mhandle := parameters[2].(*wren.MapHandle) |
|||
o := make(map[string][]string) |
|||
keys := []string{ |
|||
meetup.GroupID, meetup.GroupURLName, meetup.EventName, |
|||
meetup.Description, meetup.EventTime, |
|||
} |
|||
for _, key := range keys { |
|||
s, err := mhandle.Get(key) |
|||
check(err) |
|||
o[key] = []string{s.(string)} |
|||
} |
|||
event, err2 := (*c).CreateEvent(eventOptions, o) |
|||
check(err2) |
|||
return &event, nil |
|||
} |
|||
func eventId(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
event := ifc.(**models.Event) |
|||
return (**event).ID, nil |
|||
} |
|||
func eventName(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
event := ifc.(**models.Event) |
|||
return (**event).Name, nil |
|||
} |
|||
func newEvents(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[1].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
c := ifc.(*meetup.Clienter) |
|||
urlName := parameters[2].(string) |
|||
status := parameters[3].(string) |
|||
desc := parameters[4].(bool) |
|||
events, err := (*c).EventsByGroup(urlName, []string{status}, desc) |
|||
check(err) |
|||
return &events, nil |
|||
} |
|||
func eventsCount(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
events := ifc.(**models.Events) |
|||
return len((**events).Events), nil |
|||
} |
|||
func eventsId(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
events := ifc.(**models.Events) |
|||
index := int(parameters[1].(float64)) |
|||
return (**events).Events[index].ID, nil |
|||
} |
|||
func eventsName(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
events := ifc.(**models.Events) |
|||
index := int(parameters[1].(float64)) |
|||
return (**events).Events[index].Name, nil |
|||
} |
|||
func eventsLink(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
events := ifc.(**models.Events) |
|||
index := int(parameters[1].(float64)) |
|||
return (**events).Events[index].Link, nil |
|||
} |
|||
func venueName(vm *wren.VM, parameters []any) (any, error) { |
|||
handle := parameters[0].(*wren.ForeignHandle) |
|||
ifc, _ := handle.Get() |
|||
events := ifc.(**models.Events) |
|||
index := int(parameters[1].(float64)) |
|||
return (**events).Events[index].Venue.Name, nil |
|||
} |
|||
func moduleFn(vm *wren.VM, name string) (string, bool) { |
|||
if name != "meta" && name != "random" && !strings.HasSuffix(name, ".wren") { |
|||
name += ".wren" |
|||
} |
|||
return wren.DefaultModuleLoader(vm, name) |
|||
} |
|||
func main() { |
|||
cfg := wren.NewConfig() |
|||
cfg.LoadModuleFn = moduleFn |
|||
vm := cfg.NewVM() |
|||
meetupMethodMap := wren.MethodMap{ |
|||
"static getKey(_)": getKey, |
|||
} |
|||
clientMethodMap := wren.MethodMap{ |
|||
"deleteEvent(_)": deleteEvent, |
|||
} |
|||
groupMethodMap := wren.MethodMap{ |
|||
"urlName": urlName, |
|||
"groupId": groupId, |
|||
"memberCount": memberCount, |
|||
"organizerName": organizerName, |
|||
} |
|||
eventMethodMap := wren.MethodMap{ |
|||
"eventId": eventId, |
|||
"eventName": eventName, |
|||
} |
|||
eventsMethodMap := wren.MethodMap{ |
|||
"eventsCount": eventsCount, |
|||
"eventsId(_)": eventsId, |
|||
"eventsName(_)": eventsName, |
|||
"eventsLink(_)": eventsLink, |
|||
"venueName(_)": venueName, |
|||
} |
|||
classMap := wren.ClassMap{ |
|||
"Meetup": wren.NewClass(nil, nil, meetupMethodMap), |
|||
"Client": wren.NewClass(newClient, nil, clientMethodMap), |
|||
"Group": wren.NewClass(newGroup, nil, groupMethodMap), |
|||
"Event": wren.NewClass(newEvent, nil, eventMethodMap), |
|||
"Events": wren.NewClass(newEvents, nil, eventsMethodMap), |
|||
} |
|||
module := wren.NewModule(classMap) |
|||
fileName := "meetup.wren" |
|||
vm.SetModule(fileName, module) |
|||
vm.InterpretFile(fileName) |
|||
vm.Free() |
|||
}</lang> |