Rewrite to use modules, clean up code, merged fixes

Commands/__init__.py

@@ -0,0 +1,16 @@
+# import sys
+# import imp
+
+# from .create_connection import *
+# from .create_diff_scratch import *
+# from .enter_credentials import *
+# from .load_all_snow_record import *
+# from .load_snow_record import *
+# from .load_snow_table import *
+# from .open_service_now_record import *
+# from .refresh_snow_record import *
+# from .test_connection import *
+
+# imp.reload('servicenow_sync.commands.test_connection')
+
+# print("different")

Commands/create_connection.py

@@ -0,0 +1,37 @@
+from utils import *
+import sublime
+import sublime_plugin
+
+class CreateConnectionCommand(sublime_plugin.WindowCommand):
+    settings = dict()
+    user = ""
+    dir = ""
+
+    def run(self):
+        if not self.window.folders():
+            sublime.message_dialog("SNOW Sync Sublime plugin requires an open folder.")
+            return
+        else:
+            self.dir = self.window.folders()[0]
+            self.window.show_input_panel("Instance Name:", "", self.create_instance, None, None)
+
+        return
+
+    def create_instance(self, instance):
+        self.settings['instance'] = instance
+
+        self.window.show_input_panel("User Name:", "", self.create_user, None, None)
+
+    def create_user(self, user):
+        self.user = user
+        self.window.show_input_panel("Password:", "", self.create_pass, None, None)
+
+    def create_pass(self, password):
+        cred = self.user + ":" + password
+        encoded_cred = base64.encodestring(bytes(cred, "utf-8"))
+
+        self.settings['auth'] = "Basic " + encoded_cred.decode("utf-8").replace("\n", "")
+        save_settings(self.dir, self.settings)
+
+    def is_visible(self):
+        return is_sn(self.window.folders()) is False

Commands/create_diff_scratch.py

@@ -0,0 +1,6 @@
+import sublime
+import sublime_plugin
+
+class CreateDiffScratchCommand(sublime_plugin.TextCommand):
+    def run(self, edit, content):
+        self.view.insert(edit, 0, content)

Commands/enter_credentials.py

@@ -0,0 +1,24 @@
+from utils import *
+import sublime
+import sublime_plugin
+
+class EnterCredentialsCommand(sublime_plugin.WindowCommand):
+    settings = dict()
+    user = ""
+    dir = ""
+
+    def run(self):
+        self.dir = self.window.folders()[0]
+        self.window.show_input_panel("User Name:", "", self.create_user, None, None)
+
+    def create_user(self, user):
+        self.user = user
+        self.window.show_input_panel("Password:", "", self.create_pass, None, None)
+
+    def create_pass(self, password):
+        cred = self.user + ":" + password
+        encoded_cred = base64.encodestring(bytes(cred, "utf-8"))
+        save_setting(self.dir, "auth", "Basic " + encoded_cred.decode("utf-8").replace("\n", ""))
+
+    def is_visible(self):
+        return is_sn(self.window.folders()) is True

Commands/load_all_snow_record.py

@@ -0,0 +1,25 @@
+from utils import *
+import sublime
+import sublime_plugin
+
+class LoadAllSnowRecordCommand(sublime_plugin.WindowCommand):
+    this_dirs = []
+
+    def run(self, dirs):
+        self.this_dirs = dirs
+        self.window.show_input_panel("Enter an encoded query (or leave blank):", "", self.get_records, None, None)
+        return
+
+
+    def get_records(self, query):
+        working_dir = self.window.folders()[0]
+        settings = load_settings(working_dir)
+        file_dir = self.this_dirs[0]
+        table_settings = load_settings( file_dir )
+
+        load_multiple(settings, table_settings, file_dir, query)
+        return
+
+
+    def is_visible(self, dirs):
+        return is_sn(self.window.folders()) and len(dirs) > 0

Commands/load_modified_records.py

@@ -0,0 +1,21 @@
+from utils import *
+import sublime
+import sublime_plugin
+
+class LoadModifiedRecordCommand(sublime_plugin.WindowCommand):
+    this_dirs = []
+
+    def run(self, dirs):
+        working_dir = self.window.folders()[0]
+        settings = load_settings(working_dir)
+        file_dir = dirs[0]
+        table_settings = load_settings(file_dir)
+        query = "sys_customer_update=true"
+
+        settings = load_settings(working_dir)
+        table_settings = load_settings( file_dir )
+
+        load_multiple(settings, table_settings, file_dir, query)
+
+    def is_visible(self, dirs):
+        return is_sn(self.window.folders()) and len(dirs) > 0

Commands/load_snow_record.py

@@ -0,0 +1,116 @@
+from utils import *
+import sublime
+import sublime_plugin
+
+class LoadSnowRecordCommand(sublime_plugin.WindowCommand):
+    items = []
+    table_settings = {}
+    working_dir = ''
+    file_dir = ""
+
+    def run(self, dirs):
+        self.working_dir = self.window.folders()[0]
+        settings = load_settings(self.working_dir)
+        self.file_dir = dirs[0]
+        self.table_settings = load_settings(self.file_dir)
+
+        query = ""
+
+        if 'query' in self.table_settings:
+            query = self.table_settings['query']
+
+        if settings is not False and self.table_settings is not False:
+            fields = ['sys_id','sys_updated_on']
+
+            if "display" in self.table_settings:
+                fields.append(self.table_settings["display"])
+
+            fields = ",".join(fields);
+            self.items = get_list(settings, self.table_settings['table'], query, fields)
+            item_list = []
+
+            for item in self.items:
+                item_list.append([item[self.table_settings['display']], item['sys_id']])
+
+            self.window.show_quick_panel(item_list, self.on_done)
+
+    def on_done(self, index):
+        if index != -1:
+            item = self.items[index]
+            settings = load_settings(self.working_dir)
+
+            if settings is not False and self.table_settings is not False:
+                record = get_record(settings,self.table_settings['table'],item['sys_id'])
+
+            if 'grouped' in self.table_settings:
+                name_field = self.table_settings['display']
+                name = record[name_field]
+                name = re.sub('[^-a-zA-Z0-9_.() ]+', '', name)
+                grouped_dir = os.path.join(self.file_dir, name)
+
+                if os.path.exists(grouped_dir):
+                        grouped_dir = grouped_dir + "_" + record['sys_id']
+
+                os.makedirs(grouped_dir)
+                settings = json.loads('{}')
+                settings['grouped_child'] = True
+                settings['id'] = record['sys_id']
+                save_settings(grouped_dir, settings)
+
+                for child in self.table_settings['fields']:
+                    body_field = child['field'];
+                    extension = child['extension']
+                    name = convert_file_name(child['name'] + "." + extension)
+                    file_name = os.path.join(grouped_dir , name)
+
+                    if os.path.exists(file_name):
+                            if sublime.ok_cancel_dialog("File already exists.\nOverwrite?")==False:
+                                return False
+
+                    doc = record[body_field]
+                    write_doc_file(file_name, doc)
+
+            if 'multi' in self.table_settings:
+                for child in os.listdir(self.file_dir):
+                    test_path = os.path.join(self.file_dir, child)
+                    if os.path.isdir(test_path):
+                        sub_settings = load_settings(test_path)
+                        body_field = child
+                        name_field = sub_settings['display']
+                        extension = sub_settings['extension']
+                        name = convert_file_name(record[name_field] + "." + extension)
+
+                        doc = record[body_field]
+                        file_name = os.path.join(self.file_dir, child, name)
+
+                        if os.path.exists(file_name):
+                            if sublime.ok_cancel_dialog("File already exists.\nOverwrite?") is False:
+                                return False
+
+                        write_doc_file(file_name, doc)
+
+                        add_file(test_path, record['sys_id'], name)
+
+            else:
+                body_field = self.table_settings['body_field']
+                name_field = self.table_settings['display']
+                extension = self.table_settings['extension']
+                name = convert_file_name(record[name_field] + "." + extension)
+
+                doc = record[body_field]
+                file_name = os.path.join(self.file_dir, name)
+
+                if os.path.exists(file_name):
+                    if sublime.ok_cancel_dialog("File already exists.\nOverwrite?") is False:
+                        return False
+
+                write_doc_file(file_name, doc)
+
+                add_file(self.file_dir, record['sys_id'], name)
+
+                self.window.open_file(os.path.join(self.file_dir, name))
+
+            return
+
+    def is_visible(self, dirs):
+        return is_sn(self.window.folders()) and len(dirs) > 0

Commands/load_snow_table.py

@@ -0,0 +1,131 @@
+from utils import *
+import sublime
+import sublime_plugin
+
+class LoadSnowTableCommand(sublime_plugin.WindowCommand):
+    items = []
+    folder = ''
+    display = ''
+    description = ''
+    body_field = ''
+    extension = ''
+    settings = {}
+    file_dir = ""
+    item = {}
+    table_fields = {}
+
+    def run(self):
+        working_dir = self.window.folders()
+        app_settings = load_settings(working_dir[0])
+        print(app_settings)
+        self.file_dir = working_dir[0]
+
+        if app_settings is not False:
+            self.items = get_tables(app_settings)
+            item_list = []
+
+            for item in self.items:
+                item_list.append([item['label'], item['name']])
+
+            self.window.show_quick_panel(item_list, self.sync_table)
+
+    def sync_table(self, index):
+        if index != -1:
+            self.item = self.items[index]
+            name = self.item['name']
+
+            self.table_fields = json.loads(table_field_list)
+
+            if name in self.table_fields:
+                if len(self.table_fields[name]) == 1:
+                    self.create_single()
+                else:
+                    self.create_multi()
+            else:
+                self.custom_get_folder_name()
+
+        return
+
+    def create_single(self):
+        name = self.item['name']
+        parent_settings = {}
+
+        friendly_name = str.replace(str.lower(self.item['label']), " ", "_") + "s"
+        os.makedirs(os.path.join(self.file_dir, friendly_name))
+
+        parent_settings['table'] = self.item['name']
+        parent_settings['display'] = 'name'
+        parent_settings['body_field'] = self.table_fields[name][0]['field']
+        parent_settings['extension'] = self.table_fields[name][0]['extension']
+        parent_settings['files'] = {}
+
+        save_settings(os.path.join(self.file_dir, friendly_name), parent_settings)
+
+    def create_multi(self):
+        name = self.item['name']
+        parent_settings = {}
+
+        friendly_name = str.replace(str.lower(self.item['label']), " ", "_") + "s"
+        base_folder = os.path.join(self.file_dir, friendly_name)
+        os.makedirs(base_folder)
+
+        parent_settings['table'] = self.item['name']
+        parent_settings['display'] = 'name'
+        parent_settings['multi'] = True
+
+        save_settings(base_folder, parent_settings)
+
+        for field in self.table_fields[name]:
+            sub_settings = {}
+            folder_name = field['field']
+            sub_folder = os.path.join(base_folder, folder_name)
+            os.makedirs(sub_folder)
+
+            sub_settings['table'] = self.item['name']
+            sub_settings['display'] = 'name'
+            sub_settings['body_field'] = field['field']
+            sub_settings['extension'] = field['extension']
+            sub_settings['files'] = {}
+            sub_settings['sub'] = 'true'
+
+            save_settings(sub_folder, sub_settings)
+
+    def custom_get_folder_name(self):
+        friendly_name = str.replace(str.lower(self.item['label']), " ", "_")
+        self.window.show_input_panel("Table Folder Name:", friendly_name + "s", self.custom_create_folder, None, None)
+
+        return
+
+    def custom_create_folder(self, name):
+        self.file_dir = os.path.join(self.file_dir, name)
+
+        os.makedirs(self.file_dir)
+
+        self.settings['table'] = self.item['name']
+        self.window.show_input_panel("Display Field:", "name", self.custom_get_display_field, None, None)
+
+    def custom_get_display_field(self, display):
+        self.settings['display'] = display
+
+        self.window.show_input_panel("Body Field:", "script", self.custom_get_extension, None, None)
+        return
+
+    def custom_get_extension(self, body_field):
+        self.settings['body_field'] = body_field
+
+        self.window.show_input_panel("File Extension:", "js", self.custom_create_settings, None, None)
+        return
+
+    def custom_create_settings(self, extension):
+        self.settings['extension'] = extension
+        self.settings['files'] = {}
+
+        file_name = os.path.join(self.file_dir, "service-now.json")
+        f = open(file_name, 'wb')
+        f.write(bytes(json.dumps(self.settings, indent=4), 'utf-8'))
+        f.close()
+
+        return
+
+    def is_visible(self):
+        return is_sn(self.window.folders())