Merge pull request #50 from seatable/add-table-api-columns

Add table api columns

Author: freeplant

demo/airtable_importer.py

@@ -3,18 +3,19 @@
 import sys
 from seatable_api import Base, AirtableConvertor
 from airtable_importer_settings import server_url, api_token, airtable_api_key, airtable_base_id, \
-    table_names, links
+    table_names, first_columns, links
 
 
 def get_convertor():
     base = Base(api_token, server_url)
     base.auth()
     convertor = AirtableConvertor(
-        airtable_api_key,
-        airtable_base_id,
-        base,
-        table_names,
-        links,
+        airtable_api_key=airtable_api_key,
+        airtable_base_id=airtable_base_id,
+        base=base,
+        table_names=table_names,
+        first_columns=first_columns,
+        links=links,
     )
     return convertor
 

demo/airtable_importer_settings.py

@@ -14,10 +14,20 @@
 airtable_base_id = 'airtable base id'
 
 
-# table names in Airtable [('name_of_table_1', 'name_of_table_2', '...'])
+# table names in Airtable ['name_of_table_1', 'name_of_table_2', '...']
 table_names = ['Design projects', 'Tasks', 'Clients']
 
 
+# first columns in Airtable [('table_name', 'first_column_name')]
+# The first column ensures the correct display of the links
+# if there are no links in all tables, you still have to provide "first_columns = []"
+first_columns = [
+    ('Design projects', 'Name'),
+    ('Tasks', 'Name'),
+    ('Clients', 'Name'),
+]
+
+
 # links in Airtable: [('table_name', 'column_name', 'other_table_name')]
 # if there are no links in all tables, you still have to provide "links = []"
 links = [

seatable_api/convert_airtable.py

@@ -16,6 +16,8 @@
 TEXT_COLOR = '#FFFFFF'
 DATE_FORMAT = '%Y-%m-%d'
 DATETIME_FORMAT = '%Y-%m-%dT%H:%M:%S.%fZ'
+FIRST_COLUMN_TYPES = [
+    ColumnTypes.TEXT, ColumnTypes.NUMBER, ColumnTypes.DATE, ColumnTypes.SINGLE_SELECT, ColumnTypes.AUTO_NUMBER]
 AIRTABLE_API_URL = 'https://api.airtable.com/v0/'
 ColumnTypes.BARCODE = 'barcode'
 
@@ -221,21 +223,21 @@ def get_value_map(self, airtable_rows):
                     value_map[column_name].append(value)
         return value_map
 
-    def get_select_data(self, select_list):
-        return {'options': [{
+    def get_select_options(self, select_list):
+        return [{
             'name': str(value),
             'id': self.random_num_id(),
             'color': self.random_color(),
             'textColor': TEXT_COLOR,
-        } for value in select_list]}
+        } for value in select_list]
 
     def get_column_data(self, link_map, table_name, column_name, column_type, values):
         column_data = None
         try:
             if column_type == ColumnTypes.BARCODE:
                 column_type = ColumnTypes.TEXT
-            # elif column_type == ColumnTypes.DATE and len(values[0]) == 24:
-            #     column_data = {'format': 'YYYY-MM-DD HH:mm'}
+            elif column_type == ColumnTypes.DATE:
+                column_data = {'format': 'YYYY-MM-DD'}
             elif column_type == ColumnTypes.LINK:
                 other_table_name = link_map[table_name][column_name]
                 column_data = {'other_table': other_table_name}
@@ -246,7 +248,7 @@ def get_column_data(self, link_map, table_name, column_name, column_type, values
                         item = str(item)
                         if item not in select_list:
                             select_list.append(item)
-                column_data = self.get_select_data(select_list)
+                column_data = {'options': self.get_select_options(select_list)}
             elif column_type == ColumnTypes.COLLABORATOR:
                 if isinstance(values[0], dict):
                     column_type = ColumnTypes.SINGLE_SELECT
@@ -255,7 +257,7 @@ def get_column_data(self, link_map, table_name, column_name, column_type, values
                         name = value['name']
                         if name not in select_list:
                             select_list.append(name)
-                    column_data = self.get_select_data(select_list)
+                    column_data = {'options': self.get_select_options(select_list)}
                 elif isinstance(values[0], list):
                     column_type = ColumnTypes.MULTIPLE_SELECT
                     select_list = []
@@ -264,9 +266,9 @@ def get_column_data(self, link_map, table_name, column_name, column_type, values
                             name = item['name']
                             if name not in select_list:
                                 select_list.append(name)
-                    column_data = self.get_select_data(select_list)
+                    column_data = {'options': self.get_select_options(select_list)}
         except Exception as e:
-            print('[Warning] get column data error:', e)
+            print('[Warning] get', column_type.value, 'column data error:', e)
         return column_type, column_data
 
     def get_column_type(self, values):
@@ -378,18 +380,10 @@ def get_select_value_map(self, columns, airtable_rows):
                         select_value_map[column_name].append(item)
         return select_value_map
 
-    def get_select_options(self, select_list):
-        return [{
-            'name': str(value),
-            'id': self.random_num_id(),
-            'color': self.random_color(),
-            'textColor': TEXT_COLOR,
-        } for value in select_list]
-
     def gen_select_columns(self, select_value_map):
         select_columns = []
-        for column_name, values in select_value_map.items():
-            options = self.get_select_options(values)
+        for column_name, select_list in select_value_map.items():
+            options = self.get_select_options(select_list)
             column = {
                 'name': column_name,
                 'options': options,
@@ -441,7 +435,7 @@ def list_all_rows(self, table_name):
 
 class AirtableConvertor(object):
 
-    def __init__(self, airtable_api_key, airtable_base_id, base, table_names, links=[]):
+    def __init__(self, airtable_api_key, airtable_base_id, base, table_names, first_columns=[], links=[]):
         """
         airtable_api_key: str
         airtable_base_id: str
@@ -452,15 +446,18 @@ def __init__(self, airtable_api_key, airtable_base_id, base, table_names, links=
         self.airtable_api = AirtableAPI(airtable_api_key, airtable_base_id)
         self.base = base
         self.table_names = table_names
+        self.first_columns = first_columns
         self.links = links
         self.columns_parser = ColumnsParser()
         self.rows_convertor = RowsConvertor()
         self.links_convertor = LinksConvertor()
+        self.get_first_column_map()
         self.get_link_map()
 
     def convert_metadata(self):
-        self.convert_tables()
         self.get_airtable_row_map(is_demo=True)
+        self.get_airtable_column_map()
+        self.convert_tables()
         self.convert_columns()
         self.convert_rows(is_demo=True)
         self.convert_links(is_demo=True)
@@ -478,20 +475,38 @@ def convert_tables(self):
         for table_name in self.table_names:
             table = self.table_map.get(table_name)
             if not table:
-                self.add_table(table_name)
-                print('[Info] Added table [ %s ]' % table_name)
+                airtable_columns = self.airtable_column_map[table_name]
+                first_column_name = self.first_column_map.get(table_name) or \
+                    airtable_columns[0]['name']
+                columns = []
+                for column in airtable_columns:
+                    if column['type'] == ColumnTypes.LINK:
+                        continue
+                    item = {
+                        'column_name': column['name'],
+                        'column_type': column['type'].value,
+                        'column_data': column['data'],
+                    }
+                    if column['name'] == first_column_name:
+                        if column['type'] not in FIRST_COLUMN_TYPES:
+                            item['column_type'] = ColumnTypes.TEXT.value
+                            item['column_data'] = None
+                        columns.insert(0, item)
+                    else:
+                        columns.append(item)
+                self.add_table(table_name, columns)
+                print(
+                    '[Info] Added table [ %s ] with %s columns' % (table_name, len(columns)))
         print('[Info] Success\n')
         time.sleep(1)
 
     def convert_columns(self):
         print('[Info] Convert columns')
         self.get_table_map()
         for table_name in self.table_names:
-            airtable_rows = self.airtable_row_map[table_name]
-            columns = self.columns_parser.parse(
-                self.link_map, table_name, airtable_rows)
+            airtable_columns = self.airtable_column_map[table_name]
             table = self.table_map.get(table_name)
-            for column in columns:
+            for column in airtable_columns:
                 column_name = column['name']
                 exists_column = table.get(column_name)
                 if not exists_column:
@@ -560,6 +575,14 @@ def convert_select_columns(self):
         print('[Info] Success\n')
         time.sleep(1)
 
+    def get_first_column_map(self):
+        self.first_column_map = {}
+        for column in self.first_columns:
+            table_name = column[0]
+            column_name = column[1]
+            self.first_column_map[table_name] = column_name
+        return self.first_column_map
+
     def get_link_map(self):
         self.link_map = {}
         for link in self.links:
@@ -583,6 +606,15 @@ def get_airtable_row_map(self, is_demo=False):
         print('[Info] Success\n')
         return self.airtable_row_map
 
+    def get_airtable_column_map(self):
+        self.airtable_column_map = {}
+        for table_name in self.table_names:
+            airtable_rows = self.airtable_row_map[table_name]
+            columns = self.columns_parser.parse(
+                self.link_map, table_name, airtable_rows)
+            self.airtable_column_map[table_name] = columns
+        return self.airtable_column_map
+
     def get_table_map(self):
         self.table_map = {}
         self.column_map = {}
@@ -598,8 +630,8 @@ def get_table_map(self):
         time.sleep(0.1)
         return self.table_map
 
-    def add_table(self, table_name):
-        table = self.base.add_table(table_name)
+    def add_table(self, table_name, columns):
+        table = self.base.add_table(table_name, columns=columns)
         time.sleep(0.1)
         return table
 

seatable_api/main.py

@@ -185,16 +185,19 @@ def get_metadata(self):
         data = parse_response(response)
         return data.get('metadata')
 
-    def add_table(self, table_name, lang='en'):
+    def add_table(self, table_name, lang='en', columns=[]):
         """
         :param table_name: str
         :param lang: str, currently 'en' for English, and 'zh-cn' for Chinese
+        :param columns: list
         """
         url = self._table_server_url()
         json_data = {
             'table_name': table_name,
             'lang': lang,
         }
+        if columns:
+            json_data['columns'] = columns
         response = requests.post(url, json=json_data, headers=self.headers, timeout=self.timeout)
         return parse_response(response)