521 lines
11 KiB
JavaScript
521 lines
11 KiB
JavaScript
/*
|
|
|
|
These are curl operations
|
|
This takes care of storing curl data
|
|
|
|
*/
|
|
|
|
class Curls {
|
|
static max_curls = 100
|
|
static max_length = 20
|
|
static old_delay = Utils.YEAR * 1
|
|
static colors = {}
|
|
|
|
static setup() {
|
|
this.fill_colors()
|
|
}
|
|
|
|
static fill_colors() {
|
|
for (let color in Colors.colors) {
|
|
this.colors[color] = this.load_curls(color)
|
|
|
|
if (this.fill(this.colors[color])) {
|
|
this.save(this.colors[color], color, true)
|
|
}
|
|
}
|
|
}
|
|
|
|
static add() {
|
|
Windows.prompt({title: `Add Curls`, callback: (value) => {
|
|
this.add_submit(value)
|
|
}, message: `Enter one or more curls`})
|
|
}
|
|
|
|
static add_submit(curls) {
|
|
if (!curls) {
|
|
return
|
|
}
|
|
|
|
let added = Utils.smart_list(curls)
|
|
|
|
if (!added.length) {
|
|
return
|
|
}
|
|
|
|
this.prepend(added)
|
|
}
|
|
|
|
static prepend(added) {
|
|
added = added.filter(x => this.check(x))
|
|
|
|
if (!added.length) {
|
|
return
|
|
}
|
|
|
|
let curls = this.get_curls()
|
|
let new_curls = Array.from(new Set([...added, ...curls]))
|
|
|
|
if (this.save_curls(new_curls)) {
|
|
added.reverse()
|
|
Update.update({ curls: added })
|
|
}
|
|
}
|
|
|
|
static new_item(curl) {
|
|
return {
|
|
curl: curl,
|
|
added: this.default_added(),
|
|
}
|
|
}
|
|
|
|
static add_owned(curl) {
|
|
let curls = this.get_curls()
|
|
|
|
if (curls.includes(curl)) {
|
|
return
|
|
}
|
|
|
|
this.prepend([curl])
|
|
}
|
|
|
|
static to_top(curls) {
|
|
let cleaned = [...curls]
|
|
|
|
for (let curl of this.get_curls()) {
|
|
if (cleaned.includes(curl)) {
|
|
continue
|
|
}
|
|
|
|
cleaned.push(curl)
|
|
}
|
|
|
|
this.after_move(cleaned, curls)
|
|
}
|
|
|
|
static to_bottom(curls) {
|
|
let cleaned = []
|
|
|
|
for (let curl of this.get_curls()) {
|
|
if (cleaned.includes(curl)) {
|
|
continue
|
|
}
|
|
|
|
if (curls.includes(curl)) {
|
|
continue
|
|
}
|
|
|
|
cleaned.push(curl)
|
|
}
|
|
|
|
cleaned.push(...curls)
|
|
this.after_move(cleaned, curls)
|
|
}
|
|
|
|
static after_move(new_curls, curls) {
|
|
this.save_curls(new_curls)
|
|
Sort.set_value(`order`)
|
|
Sort.sort_if_order()
|
|
Select.deselect_all()
|
|
|
|
for (let curl of curls) {
|
|
Select.curl(curl)
|
|
}
|
|
}
|
|
|
|
static save(items, color = Colors.mode, force = false) {
|
|
items = this.clean(items)
|
|
let same = true
|
|
let current = this.get(color)
|
|
|
|
if (current.length !== items.length) {
|
|
same = false
|
|
}
|
|
|
|
if (same) {
|
|
for (let i = 0; i < current.length; i++) {
|
|
if (current[i].curl !== items[i].curl) {
|
|
same = false
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if (same && !force) {
|
|
return false
|
|
}
|
|
|
|
let name = this.get_name(color)
|
|
this.colors[color] = [...items]
|
|
Utils.save(name, JSON.stringify(items))
|
|
return true
|
|
}
|
|
|
|
static default_added() {
|
|
return Utils.now()
|
|
}
|
|
|
|
static fill(items) {
|
|
let filled = false
|
|
|
|
for (let item of items) {
|
|
if (item.added === undefined) {
|
|
item.added = this.default_added()
|
|
filled = true
|
|
}
|
|
}
|
|
|
|
return filled
|
|
}
|
|
|
|
static get(color = Colors.mode) {
|
|
return this.colors[color]
|
|
}
|
|
|
|
static get_curls(color = Colors.mode) {
|
|
return this.get(color).map(x => x.curl)
|
|
}
|
|
|
|
static load_curls(color = Colors.mode) {
|
|
let name = this.get_name(color)
|
|
let saved = Utils.load_array(name)
|
|
return this.clean(saved)
|
|
}
|
|
|
|
static replace() {
|
|
Windows.prompt({title: `Replace Curls`, callback: (value) => {
|
|
this.replace_submit(value)
|
|
}, message: `Replace the entire list with this`})
|
|
}
|
|
|
|
static replace_submit(curls) {
|
|
if (!curls) {
|
|
return
|
|
}
|
|
|
|
let units = curls.split(` `).filter(x => x)
|
|
|
|
if (!units.length) {
|
|
return
|
|
}
|
|
|
|
this.clear()
|
|
let added = []
|
|
|
|
for (let curl of units) {
|
|
if (this.check(curl)) {
|
|
added.push(curl)
|
|
}
|
|
}
|
|
|
|
if (added) {
|
|
if (this.save_curls(added)) {
|
|
Update.update()
|
|
}
|
|
}
|
|
}
|
|
|
|
static clear(color = Colors.mode) {
|
|
this.save([], color)
|
|
}
|
|
|
|
static edit(curl) {
|
|
Windows.prompt({title: `Edit Curl`, callback: (value) => {
|
|
this.edit_submit(curl, value)
|
|
}, value: curl, message: `Change the name of this curl`})
|
|
}
|
|
|
|
static edit_submit(curl, new_curl) {
|
|
if (!new_curl) {
|
|
return
|
|
}
|
|
|
|
this.do_edit(curl, new_curl)
|
|
}
|
|
|
|
static do_edit(curl, new_curl) {
|
|
if (!this.check(new_curl)) {
|
|
return
|
|
}
|
|
|
|
if (curl === new_curl) {
|
|
return
|
|
}
|
|
|
|
let curls = this.get_curls().slice()
|
|
let index = curls.indexOf(curl)
|
|
|
|
if (index === -1) {
|
|
return
|
|
}
|
|
|
|
curls[index] = new_curl
|
|
|
|
if (this.save_curls(curls)) {
|
|
Items.remove_curl(curl)
|
|
Update.update({ curls: [new_curl] })
|
|
}
|
|
}
|
|
|
|
static check(curl) {
|
|
if (!curl) {
|
|
return false
|
|
}
|
|
|
|
if (curl.length > this.max_length) {
|
|
return false
|
|
}
|
|
|
|
if (!/^[a-zA-Z0-9]+$/.test(curl)) {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
static clean(items) {
|
|
let cleaned = []
|
|
|
|
for (let item of items) {
|
|
if (cleaned.some(x => x.curl === item.curl)) {
|
|
continue
|
|
}
|
|
|
|
if (!this.check(item.curl)) {
|
|
continue
|
|
}
|
|
|
|
cleaned.push(item)
|
|
|
|
if (cleaned.length >= this.max_curls) {
|
|
break
|
|
}
|
|
}
|
|
|
|
return cleaned
|
|
}
|
|
|
|
static get_name(color) {
|
|
return `curls_${color}`
|
|
}
|
|
|
|
static remove(curls) {
|
|
let cleaned = []
|
|
let removed = []
|
|
|
|
for (let curl of this.get_curls()) {
|
|
if (!curls.includes(curl)) {
|
|
cleaned.push(curl)
|
|
}
|
|
else {
|
|
removed.push(curl)
|
|
}
|
|
}
|
|
|
|
if (!removed.length) {
|
|
return
|
|
}
|
|
|
|
this.save_cleaned(cleaned, removed)
|
|
}
|
|
|
|
static remove_selected(curl = ``) {
|
|
let curls = Select.get_curls()
|
|
|
|
if (curl) {
|
|
if (!curls.includes(curl)) {
|
|
curls = [curl]
|
|
}
|
|
}
|
|
|
|
this.remove(curls)
|
|
}
|
|
|
|
static remove_all() {
|
|
Windows.confirm({title: `Remove All Curls`, ok: () => {
|
|
this.clear()
|
|
Container.show_empty()
|
|
}, message: `Remove all curls in the current color`})
|
|
}
|
|
|
|
static show_remove_menu(e) {
|
|
let items = [
|
|
{
|
|
text: `Remove One`,
|
|
action: () => {
|
|
this.remove_one()
|
|
}
|
|
},
|
|
{
|
|
text: `Remove Not Found`,
|
|
action: () => {
|
|
this.remove_not_found()
|
|
}
|
|
},
|
|
{
|
|
text: `Remove Empty`,
|
|
action: () => {
|
|
this.remove_empty()
|
|
}
|
|
},
|
|
{
|
|
text: `Remove Old`,
|
|
action: () => {
|
|
this.remove_old()
|
|
}
|
|
},
|
|
{
|
|
text: `Remove All`,
|
|
action: () => {
|
|
this.remove_all()
|
|
}
|
|
},
|
|
]
|
|
|
|
Utils.context({items: items, e: e})
|
|
}
|
|
|
|
static remove_one() {
|
|
Windows.prompt({title: `Remove Curl`, callback: (value) => {
|
|
this.remove_one_submit(value)
|
|
}, message: `Enter the curl to remove`})
|
|
}
|
|
|
|
static remove_one_submit(curl) {
|
|
if (!curl) {
|
|
return
|
|
}
|
|
|
|
this.do_remove(curl)
|
|
}
|
|
|
|
static do_remove(curl, remove_item = true) {
|
|
let cleaned = []
|
|
|
|
for (let curl_ of this.get_curls()) {
|
|
if (curl_ !== curl) {
|
|
cleaned.push(curl_)
|
|
}
|
|
}
|
|
|
|
this.save_curls(cleaned)
|
|
|
|
if (remove_item) {
|
|
Items.remove([curl])
|
|
}
|
|
}
|
|
|
|
static remove_not_found() {
|
|
let missing = Items.get_missing().map(x => x.curl)
|
|
let cleaned = []
|
|
let removed = []
|
|
|
|
for (let curl of this.get_curls()) {
|
|
if (!missing.includes(curl)) {
|
|
cleaned.push(curl)
|
|
}
|
|
else {
|
|
removed.push(curl)
|
|
}
|
|
}
|
|
|
|
if (!removed.length) {
|
|
return
|
|
}
|
|
|
|
this.save_cleaned(cleaned, removed)
|
|
}
|
|
|
|
static remove_empty() {
|
|
let cleaned = []
|
|
let removed = []
|
|
|
|
for (let curl of this.get_curls()) {
|
|
let item = Items.get(curl)
|
|
|
|
if (!item) {
|
|
continue
|
|
}
|
|
|
|
if (!item.status) {
|
|
removed.push(curl)
|
|
continue
|
|
}
|
|
|
|
cleaned.push(curl)
|
|
}
|
|
|
|
if (!removed.length) {
|
|
return
|
|
}
|
|
|
|
this.save_cleaned(cleaned, removed)
|
|
}
|
|
|
|
static remove_old() {
|
|
let now = Utils.now()
|
|
let cleaned = []
|
|
let removed = []
|
|
|
|
for (let curl of this.get_curls()) {
|
|
let item = Items.get(curl)
|
|
|
|
if (!item) {
|
|
continue
|
|
}
|
|
|
|
let date = item.updated
|
|
|
|
if (date) {
|
|
let datetime = new Date(date + `Z`).getTime()
|
|
|
|
if ((now - datetime) > (this.old_delay)) {
|
|
removed.push(curl)
|
|
continue
|
|
}
|
|
}
|
|
|
|
cleaned.push(curl)
|
|
}
|
|
|
|
if (!removed.length) {
|
|
return
|
|
}
|
|
|
|
this.save_cleaned(cleaned, removed)
|
|
}
|
|
|
|
static save_cleaned(cleaned, removed) {
|
|
let s = Utils.plural(removed.length, `Curl`, `Curls`)
|
|
let curls = removed.join(`, `)
|
|
|
|
Windows.confirm({title: `Remove ${removed.length} ${s}`, ok: () => {
|
|
this.save_curls(cleaned)
|
|
Items.remove(removed)
|
|
}, message: curls})
|
|
}
|
|
|
|
static copy() {
|
|
let curls = this.get_curls()
|
|
let text = curls.join(` `)
|
|
Utils.copy_to_clipboard(text)
|
|
}
|
|
|
|
static save_curls(curls, color = Colors.mode) {
|
|
let current = this.get(color)
|
|
let items = []
|
|
|
|
for (let curl of curls) {
|
|
let item = current.find(x => x.curl === curl)
|
|
|
|
if (item) {
|
|
items.push(item)
|
|
}
|
|
else {
|
|
item = this.new_item(curl)
|
|
items.push(item)
|
|
}
|
|
}
|
|
|
|
return this.save(items, color)
|
|
}
|
|
} |