Пример #1
0
// Add Response API
func plurk_AddResponse(call otto.FunctionCall) otto.Value {

	plurkID, _ := call.Argument(0).ToInteger()
	message, _ := call.Argument(1).ToString()
	qualifier, _ := call.Argument(2).ToString()

	if plurkID == 0 {
		logger.Error("Plurk ID not specify, add response failed!")
		return otto.FalseValue()
	}

	if len(message) <= 0 || message == "undefined" {
		logger.Error("No plurk content specify, add response failed!")
		return otto.FalseValue()
	}

	if qualifier == "undefined" {
		qualifier = ":"
	}

	responses := client.GetResponses()
	res, err := responses.ResponseAdd(int(plurkID), message, qualifier)

	if err != nil {
		logger.Error("Add response failed, because %s", err.Error())
	}

	logger.Info("Add response success, content is %s", res.RawContent)

	return otto.TrueValue()
}
Пример #2
0
// Send GET Request to PlurkClient API
func (plurk *PlurkClient) Get(endpoint string, params url.Values) ([]byte, error) {

	requestUri := fmt.Sprintf("%s/%s", plurk.ApiBase, endpoint)
	uri, err := url.Parse(requestUri)
	// TODO(elct9620): Imrpove error handle
	if err != nil {
		return nil, err
	}
	params = signParams(&plurk.credential, "GET", uri, params)
	requestUri = fmt.Sprint(requestUri, "?", params.Encode())
	res, err := http.Get(requestUri)
	logger.Info("GET %s", uri.String())
	logger.Debug("Params %s", params.Encode())
	if err != nil {
		return nil, err
	}

	defer res.Body.Close()
	data, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}

	if res.StatusCode != 200 {
		var responseError Error
		json.Unmarshal(data, &responseError)
		logger.Error(responseError.ErrorText)
		return nil, errors.New(responseError.ErrorText)
	}

	return data, nil
}
Пример #3
0
// Add Plurk API
func plurk_AddPlurk(call otto.FunctionCall) otto.Value {
	message, _ := call.Argument(0).ToString()
	qualifier, _ := call.Argument(1).ToString()
	lang, _ := call.Argument(2).ToString()

	// No message specify, return error
	if len(message) <= 0 {
		return otto.FalseValue()
	}

	// Default qualifier
	if qualifier == "undefined" {
		qualifier = ":"
	}

	if lang == "undefined" {
		lang = "en"
	}

	timeline := client.GetTimeline()
	res, err := timeline.PlurkAdd(message, qualifier, make([]int, 0), false, lang, true)

	if err != nil {
		logger.Error("Add Plurk failed, because %s", err.Error())
		return otto.FalseValue()
	}

	logger.Info("New plurk added, content is %s", res.RawContent)

	return otto.TrueValue()
}
Пример #4
0
func (r *Robot) Stop() {
	r.cron.Stop()

	if r.db != nil {
		r.db.Session.Close()
	}

	logger.Info("Robot stopped!")
}
Пример #5
0
func (r *Robot) Start() {
	r.cron.Start()

	// Setup
	r.LoadCronJobs()
	r.LoadTasks()
	r.SetupSignal()

	logger.Info("Robot started!")

	for {
		sign := <-r.Signal
		if r.HandleSignal(sign) {
			logger.Info("Graceful down robot...")
			break
		}
	}

}
Пример #6
0
func Test_SetupLogger(t *testing.T) {
	buffer := bytes.NewBuffer(make([]byte, 0))
	LogFile = buffer
	RobotName = "Test Robot"

	setupLogger()
	logger.Info("Test Message")

	// Validate logger wirte into buffer and conatains spacify robot name
	assert.Contains(t, buffer.String(), RobotName)
}
Пример #7
0
// Load cron jobs from database
func (r *Robot) LoadCronJobs() {
	jobsIt := r.db.C("jobs").Find(nil).Iter()

	job := db.Job{}
	// Read all jobs and throw into motto vm to run script
	for jobsIt.Next(&job) {
		jobName := GenerateJobScript(job.Name, job.Script)
		logger.Info("Add new job: %s", job.Name)
		r.cron.AddFunc(job.Schedule, func() {
			motto.Run(jobName)
		})
	}
}
Пример #8
0
// Get Plurks using "Polling" way
func (p *Polling) GetPlurks(offset *Time, limit int) (result *GetPlurkResponse, err error) {
	params := make(url.Values)
	params.Add("offset", offset.PollingOffset())
	params.Add("limit", fmt.Sprintf("%d", limit))

	logger.Info("Polling from %s", offset.PollingOffset())

	data, err := p.Get("Polling/getPlurks", params)
	if err != nil {
		return nil, err
	}

	result = &GetPlurkResponse{}
	err = json.Unmarshal(data, result)

	if err != nil {
		return nil, err
	}

	return result, nil
}
Пример #9
0
func (t *Timeline) GetPlurks(offset int, limit int, filter string) (result *GetPlurkResponse, err error) {
	params := make(url.Values)
	params.Add("offset", fmt.Sprintf("%d", offset))
	params.Add("limit", fmt.Sprintf("%d", limit))
	if len(filter) > 0 {
		params.Add("filter", fmt.Sprintf("%d", filter))
	}

	data, err := t.Get("Timeline/getPlurks", params)
	if err != nil {
		return nil, err
	}

	logger.Info("Plruks JSON: %s", string(data))

	result = &GetPlurkResponse{}
	err = json.Unmarshal(data, result)
	if err != nil {
		return nil, err
	}

	return result, err
}