Golang lib.Printer類代碼示例

// Register calls google.com/cloudprint/register to register a GCP printer.
//
// Sets the GCPID field in the printer arg.
func (gcp *GoogleCloudPrint) Register(printer *lib.Printer) error {
	capabilities, err := marshalCapabilities(printer.Description)
	if err != nil {
		return err
	}

	semanticState, err := json.Marshal(cdd.CloudDeviceState{Printer: printer.State})
	if err != nil {
		return err
	}

	form := url.Values{}
	form.Set("name", printer.Name)
	form.Set("default_display_name", printer.DefaultDisplayName)
	form.Set("proxy", gcp.proxyName)
	form.Set("uuid", printer.UUID)
	form.Set("manufacturer", printer.Manufacturer)
	form.Set("model", printer.Model)
	form.Set("gcp_version", printer.GCPVersion)
	form.Set("setup_url", lib.ConnectorHomeURL)
	form.Set("support_url", lib.ConnectorHomeURL)
	form.Set("update_url", lib.ConnectorHomeURL)
	form.Set("firmware", printer.ConnectorVersion)
	form.Set("semantic_state", string(semanticState))
	form.Set("use_cdd", "true")
	form.Set("capabilities", capabilities)
	form.Set("capsHash", printer.CapsHash)

	sortedKeys := make([]string, 0, len(printer.Tags))
	for key := range printer.Tags {
		sortedKeys = append(sortedKeys, key)
	}
	sort.Strings(sortedKeys)
	for _, key := range sortedKeys {
		form.Add("tag", fmt.Sprintf("%s%s=%s", gcpTagPrefix, key, printer.Tags[key]))
	}

	responseBody, _, _, err := postWithRetry(gcp.robotClient, gcp.baseURL+"register", form)
	if err != nil {
		return err
	}

	var registerData struct {
		Printers []struct {
			ID string
		}
	}
	if err = json.Unmarshal(responseBody, &registerData); err != nil {
		return err
	}

	printer.GCPID = registerData.Printers[0].ID

	return nil
}

func TestTranslateTicket(t *testing.T) {
	printer := lib.Printer{}
	expected := map[string]string{}
	o, err := translateTicket(&printer, nil)
	if err != nil {
		t.Logf("did not expect error %s", err)
		t.Fail()
	}
	if !reflect.DeepEqual(o, expected) {
		t.Logf("expected %+v, got %+v", expected, o)
		t.Fail()
	}

	ticket := cdd.CloudJobTicket{}
	o, err = translateTicket(&printer, &ticket)
	if err != nil {
		t.Logf("did not expect error %s", err)
		t.Fail()
	}
	if !reflect.DeepEqual(o, expected) {
		t.Logf("expected %+v, got %+v", expected, o)
		t.Fail()
	}

	printer = lib.Printer{
		Description: &cdd.PrinterDescriptionSection{
			Color: &cdd.Color{
				Option: []cdd.ColorOption{
					cdd.ColorOption{
						VendorID: "zebra-stripes",
						Type:     cdd.ColorTypeCustomMonochrome,
					},
				},
				VendorKey: "ColorModel",
			},
			Duplex: &cdd.Duplex{
				Option: []cdd.DuplexOption{
					cdd.DuplexOption{
						Type:     cdd.DuplexNoDuplex,
						VendorID: "None",
					},
				},
				VendorKey: "Duplex",
			},
			PageOrientation: &cdd.PageOrientation{},
			Copies:          &cdd.Copies{},
			Margins:         &cdd.Margins{},
			DPI: &cdd.DPI{
				Option: []cdd.DPIOption{
					cdd.DPIOption{
						HorizontalDPI: 100,
						VerticalDPI:   100,
						VendorID:      "q",
					},
				},
			},
			FitToPage:    &cdd.FitToPage{},
			MediaSize:    &cdd.MediaSize{},
			Collate:      &cdd.Collate{},
			ReverseOrder: &cdd.ReverseOrder{},
		},
	}
	ticket.Print = cdd.PrintTicketSection{
		VendorTicketItem: []cdd.VendorTicketItem{
			cdd.VendorTicketItem{"number-up", "a"},
			cdd.VendorTicketItem{"a:b/c:d/e", "f"},
		},
		Color:           &cdd.ColorTicketItem{VendorID: "zebra-stripes", Type: cdd.ColorTypeCustomMonochrome},
		Duplex:          &cdd.DuplexTicketItem{Type: cdd.DuplexNoDuplex},
		PageOrientation: &cdd.PageOrientationTicketItem{Type: cdd.PageOrientationAuto},
		Copies:          &cdd.CopiesTicketItem{Copies: 2},
		Margins:         &cdd.MarginsTicketItem{100000, 100000, 100000, 100000},
		DPI:             &cdd.DPITicketItem{100, 100, "q"},
		FitToPage:       &cdd.FitToPageTicketItem{cdd.FitToPageNoFitting},
		MediaSize:       &cdd.MediaSizeTicketItem{100000, 100000, false, "r"},
		Collate:         &cdd.CollateTicketItem{false},
		ReverseOrder:    &cdd.ReverseOrderTicketItem{false},
	}
	expected = map[string]string{
		"number-up":           "a",
		"a":                   "b",
		"c":                   "d",
		"e":                   "f",
		"ColorModel":          "zebra-stripes",
		"Duplex":              "None",
		"copies":              "2",
		"media-left-margin":   micronsToPoints(100000),
		"media-right-margin":  micronsToPoints(100000),
		"media-top-margin":    micronsToPoints(100000),
		"media-bottom-margin": micronsToPoints(100000),
		"Resolution":          "q",
		"fit-to-page":         "false",
		"PageSize":            "r",
		"collate":             "false",
		"outputorder":         "normal",
	}
	o, err = translateTicket(&printer, &ticket)
	if err != nil {
		t.Logf("did not expect error %s", err)
		t.Fail()
//.........這裏部分代碼省略.........

// tagsToPrinter converts a map of tags to a Printer.
func tagsToPrinter(printerTags map[string][]string, systemTags map[string]string, infoToDisplayName bool) lib.Printer {
	tags := make(map[string]string)

	for k, v := range printerTags {
		tags[k] = strings.Join(v, ",")
	}
	for k, v := range systemTags {
		tags[k] = v
	}

	var name string
	if n, ok := printerTags[attrPrinterName]; ok {
		name = n[0]
	}
	var uuid string
	if u, ok := printerTags[attrPrinterUUID]; ok {
		uuid = u[0]
	}

	state := cdd.PrinterStateSection{}

	if s, ok := printerTags[attrPrinterState]; ok {
		switch s[0] {
		case "3":
			state.State = cdd.CloudDeviceStateIdle
		case "4":
			state.State = cdd.CloudDeviceStateProcessing
		case "5":
			state.State = cdd.CloudDeviceStateStopped
		default:
			state.State = cdd.CloudDeviceStateIdle
		}
	}

	if reasons, ok := printerTags[attrPrinterStateReasons]; ok && len(reasons) > 0 {
		sort.Strings(reasons)
		state.VendorState = &cdd.VendorState{Item: make([]cdd.VendorStateItem, len(reasons))}
		for i, reason := range reasons {
			vendorState := cdd.VendorStateItem{DescriptionLocalized: cdd.NewLocalizedString(reason)}
			if strings.HasSuffix(reason, "-error") {
				vendorState.State = cdd.VendorStateError
			} else if strings.HasSuffix(reason, "-warning") {
				vendorState.State = cdd.VendorStateWarning
			} else if strings.HasSuffix(reason, "-report") {
				vendorState.State = cdd.VendorStateInfo
			} else {
				vendorState.State = cdd.VendorStateInfo
			}
			state.VendorState.Item[i] = vendorState
		}
	}

	markers, markerState := convertMarkers(printerTags[attrMarkerNames], printerTags[attrMarkerTypes], printerTags[attrMarkerLevels])
	state.MarkerState = markerState
	description := cdd.PrinterDescriptionSection{Marker: markers}

	p := lib.Printer{
		Name:        name,
		UUID:        uuid,
		State:       &state,
		Description: &description,
		Tags:        tags,
	}
	p.SetTagshash()

	if pi, ok := printerTags[attrPrinterInfo]; ok && infoToDisplayName {
		p.DefaultDisplayName = pi[0]
	}

	return p
}