// create a set of item templates based on existing
// items in a vault
func exportItemTemplates(vault *onepass.Vault, pattern string) {
items, err := vault.ListItems()
if err != nil {
fatalErr(err, "Unable to list vault items")
}
typeTemplates := map[string]onepass.ItemContent{}
for _, item := range items {
typeTemplate := onepass.ItemContent{
Sections: []onepass.ItemSection{},
FormFields: []onepass.WebFormField{},
}
if !strings.HasPrefix(strings.ToLower(item.Title), pattern) {
continue
}
content, err := item.Content()
if err != nil {
fmt.Fprintf(os.Stderr, "Failed to decrypt item: %v\n", err)
}
// section templates
for _, section := range content.Sections {
sectionTemplate := onepass.ItemSection{
Name: section.Name,
Title: section.Title,
Fields: []onepass.ItemField{},
}
for _, field := range section.Fields {
fieldTemplate := onepass.ItemField{
Name: field.Name,
Title: field.Title,
Kind: field.Kind,
}
sectionTemplate.Fields = append(sectionTemplate.Fields, fieldTemplate)
}
typeTemplate.Sections = append(typeTemplate.Sections, sectionTemplate)
}
// web form field templates
for _, formField := range content.FormFields {
formTemplate := onepass.WebFormField{
Name: formField.Name,
Id: formField.Id,
Type: formField.Type,
Designation: formField.Designation,
}
typeTemplate.FormFields = append(typeTemplate.FormFields, formTemplate)
}
// URL templates
for _, url := range content.Urls {
urlTemplate := onepass.ItemUrl{Label: url.Label}
typeTemplate.Urls = append(typeTemplate.Urls, urlTemplate)
}
typeTemplates[item.TypeName] = typeTemplate
}
data, err := json.Marshal(typeTemplates)
if err != nil {
fatalErr(err, "Unable to export item templates")
}
_, _ = os.Stdout.Write(prettyJson(data))
}
func addItem(vault *onepass.Vault, title string, shortTypeName string) {
itemContent := onepass.ItemContent{}
var typeName string
for typeKey, itemType := range onepass.ItemTypes {
if itemType.ShortAlias == shortTypeName {
itemContent = onepass.ItemContent{}
typeName = typeKey
}
}
if len(typeName) == 0 {
fatalErr(fmt.Errorf("Unknown item type '%s'", shortTypeName), "")
}
template, ok := onepass.StandardTemplate(typeName)
if !ok {
fatalErr(fmt.Errorf("No template for item type '%s'", shortTypeName), "")
}
// read sections
for _, sectionTemplate := range template.Sections {
section := onepass.ItemSection{
Name: sectionTemplate.Name,
Title: sectionTemplate.Title,
Fields: []onepass.ItemField{},
}
for _, fieldTemplate := range sectionTemplate.Fields {
field := onepass.ItemField{
Name: fieldTemplate.Name,
Title: fieldTemplate.Title,
Kind: fieldTemplate.Kind,
}
field.Value = readFieldValue(field)
section.Fields = append(section.Fields, field)
}
itemContent.Sections = append(itemContent.Sections, section)
}
// read form fields
for _, formFieldTemplate := range template.FormFields {
field := onepass.WebFormField{
Name: formFieldTemplate.Name,
Id: formFieldTemplate.Id,
Type: formFieldTemplate.Type,
Designation: formFieldTemplate.Designation,
}
field.Value = readFormFieldValue(field)
itemContent.FormFields = append(itemContent.FormFields, field)
}
// read URLs
for _, urlTemplate := range template.Urls {
url := onepass.ItemUrl{
Label: urlTemplate.Label,
}
url.Url = readLinePrompt("%s (URL)", url.Label)
itemContent.Urls = append(itemContent.Urls, url)
}
// save item to vault
item, err := vault.AddItem(title, typeName, itemContent)
if err != nil {
fatalErr(err, "Unable to add item")
}
logItemAction("Added new item", item)
}