def test_update_layout(self): ks = pykintone.load(envs.FILE_PATH) form_api = ks.app(self.TEST_APP.app_id).administration().form() f1 = ff.BaseFormField.create("SINGLE_LINE_TEXT", "title", "title") f2 = ff.BaseFormField.create("SINGLE_LINE_TEXT", "description", "description") fields = [f1, f2] # add fields add_result = form_api.add(fields) self.assertTrue(add_result.ok) # create layout layout = Layout.create(fields) form_api.update_layout(layout) v_def = form_api.get_layout(preview=True) self.assertTrue(1, len(v_def.layouts)) # update layout size = 200 layout.fields[0].width = size form_api.update_layout(layout) updated = form_api.get_layout(preview=True).layouts[0] lf = [f for f in updated.fields if f.code == layout.fields[0].code][0] self.assertTrue(size, lf.size.width)
def getRecords(self): app = pykintone.load(envs.FILE_ACCOUNT).app() resp = app.select(ds['app']['query']) if not resp.ok: print(resp.error) return resp.records
def test_models(self): app = pykintone.load(envs.FILE_PATH).app() keyword = "models_test" select_models = lambda : app.select("stringField = \"{0}\"".format(keyword)).models(TestAppModel) # initialize model ms = [] for i in range(2): m = TestAppModel() m.my_key = "model_test_{0}".format(i) m.stringField = keyword m.numberField = i ms.append(m) # create model result = app.batch_create(ms) self.assertTrue(result.ok) # get model createds = select_models() # update model for i, m in enumerate(createds): m.numberField = i + 1 app.batch_update(createds) updateds = select_models() for i, m in enumerate(createds): self.assertEqual(i + 1, m.numberField) # delete model app.delete(updateds) deleted = select_models() self.assertEqual(0, len(deleted))
def test_model(self): app = pykintone.load(envs.FILE_PATH).app() # initialize model model = TestAppModel() model.my_key = "model_test" model.stringField = "model_test" model.numberField = 1 model.radio = "radio1" model.checkbox = ["check2"] model.changeLogs.append(History("initialized")) # create model result = app.create(model) self.assertTrue(result.ok) # get model created = app.get(result.record_id).model(TestAppModel) # update model created.stringField = "model_updated" created.changeLogs[0].historyDesc = "updated" created.changeLogs.append(History("added")) app.update(created) updated = app.get(result.record_id).model(TestAppModel) self.assertEqual(created.stringField, updated.stringField) self.assertEqual(2, len(updated.changeLogs)) for i, c in enumerate(created.changeLogs): self.assertEqual(c.historyDesc, updated.changeLogs[i].historyDesc) # delete model app.delete(updated) deleted = app.get(result.record_id).model(TestAppModel) self.assertFalse(deleted)
def test_uesrs(self): export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting users = export_api.get_users().users self.assertTrue(len(users) > 0) for u in users: self.assertTrue(u.name)
def setUpClass(cls): account = pykintone.load(envs.FILE_PATH).account admin = Administrator(account) cls.TEST_APP = admin.create_application("test view edit") fields = cls._default_form() add_result = admin.form().add(fields, app_id=cls.TEST_APP.app_id)
def test_models(self): app = pykintone.load(envs.FILE_PATH).app() keyword = "models_test" select_models = lambda: app.select("stringField = \"{0}\"".format( keyword)).models(TestAppModel) # initialize model ms = [] for i in range(2): m = TestAppModel() m.my_key = "model_test_{0}".format(i) m.stringField = keyword m.numberField = i ms.append(m) # create model result = app.batch_create(ms) self.assertTrue(result.ok) # get model createds = select_models() # update model for i, m in enumerate(createds): m.numberField = i + 1 app.batch_update(createds) updateds = select_models() for i, m in enumerate(createds): self.assertEqual(i + 1, m.numberField) # delete model app.delete(updateds) deleted = select_models() self.assertEqual(0, len(deleted))
def test_comment(self): app = pykintone.load(envs.FILE_PATH).app() model = TestAppModelSimple() model.my_key = "comment_test" model.stringField = "comment_test_now" result = app.create(model) self.assertTrue(result.ok) # confirm create the record to test comment _record_id = result.record_id # create comment r_created = app.comment(_record_id).create("コメントのテスト") self.assertTrue(r_created.ok) # it requires Administrator user is registered in kintone r_created_m = app.comment(_record_id).create( "メンションのテスト", [("Administrator", "USER")]) self.assertTrue(r_created_m.ok) # select comment r_selected = app.comment(_record_id).select(True, 0, 10) self.assertTrue(r_selected.ok) self.assertTrue(2, len(r_selected.raw_comments)) comments = r_selected.comments() self.assertTrue(1, len(comments[-1].mentions)) # delete comment for c in comments: r_deleted = app.comment(_record_id).delete(c.comment_id) self.assertTrue(r_deleted.ok) r_selected = app.comment(_record_id).select() self.assertEqual(0, len(r_selected.raw_comments)) # done test app.delete(_record_id)
def test_copy_application(self): kintone = pykintone.load(envs.FILE_PATH) app = kintone.app() with kintone.administration().transaction().as_test_mode() as admin: created = admin.copy_application("copied application", app.app_id) self.assertTrue(created.ok)
def test_single(self): app = pykintone.load(envs.FILE_PATH).app() record = {"my_key": {"value": "test0"}, "radio": {"value": "radio1"}} # create result = app.create(record) self.assertTrue(result.ok) record_id = result.record_id first_revision = result.revision created = app.get(record_id) self.assertTrue(created.ok) # update update = { "$id": { "value": record_id }, "$revision": { "value": result.revision }, "radio": { "value": "radio2" } } result = app.update(update) self.assertTrue(result.ok) self.assertTrue(first_revision < result.revision) updated = app.get(record_id).record self.assertTrue("redio2", updated["radio"]["value"]) # delete result = app.delete(record_id) self.assertTrue(result.ok)
def test_create_rollback_application(self): kintone = pykintone.load(envs.FILE_PATH) with kintone.administration().transaction().as_test_mode() as admin: created = admin.create_application("test_create_application") admin.revision = created.revision self.assertTrue(created.ok)
def test_comment(self): app = pykintone.load(envs.FILE_PATH).app() model = TestAppModelSimple() model.my_key = "comment_test" model.stringField = "comment_test_now" result = app.create(model) self.assertTrue(result.ok) # confirm create the record to test comment _record_id = result.record_id # create comment r_created = app.comment(_record_id).create("コメントのテスト") self.assertTrue(r_created.ok) # it requires Administrator user is registered in kintone r_created_m = app.comment(_record_id).create("メンションのテスト", [("Administrator", "USER")]) self.assertTrue(r_created_m.ok) # select comment r_selected = app.comment(_record_id).select(True, 0, 10) self.assertTrue(r_selected.ok) self.assertTrue(2, len(r_selected.raw_comments)) comments = r_selected.comments() self.assertTrue(1, len(comments[-1].mentions)) # delete comment for c in comments: r_deleted = app.comment(_record_id).delete(c.comment_id) self.assertTrue(r_deleted.ok) r_selected = app.comment(_record_id).select() self.assertEqual(0, len(r_selected.raw_comments)) # done test app.delete(_record_id)
def test_user_organization_titles(self): export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting users = export_api.get_users().users tested = False for u in users[:5]: code = u.code ots_result = export_api.get_user_organization_titles(code) self.assertTrue(ots_result.ok) ots = ots_result.organization_titles if len(ots) > 0: tested = True for ot in ots: self.assertTrue(ot.organization.code) if ot.title is None: print( "ot.title is None. Please set a job title to the user {} for stricter test." .format(code)) else: self.assertTrue(ot.title.code) if not tested: print( "Caution, organization and title deserialization is not checked. Please make user who belongs to some organization." )
def tearDownClass(cls): account = pykintone.load(envs.FILE_PATH).account admin = Administrator(account) rollbacked = admin.rollback_settings(cls.TEST_APP.app_id) cls.TEST_APP = None print( "You have to delete the application from the application administration view." )
def test_get_application_informations(self): app = pykintone.load(envs.FILE_PATH).app() ai = app.administration().select_app_info(name="pykintone").infos self.assertTrue(ai) app_id = ai[0].app_id ai = app.administration().select_app_info(app_ids=[app_id]).infos self.assertTrue(ai)
def test_error(self): app = pykintone.load(envs.FILE_PATH).app() record = {"radio": {"value": "xxxxx"}} # create (will be error) result = app.create(record) self.assertFalse(result.ok)
def test_options(self): app = pykintone.load(envs.FILE_PATH).app() app.requests_opstions = { "verify": True } result = app.select() self.assertTrue(result.ok) self.assertTrue(len(result.records) > 0)
def create_card(comment, entities, file_path, submitter, conf_path): app = pykintone.load(conf_path).app() name, company, location = entities['PERSON'], entities[ 'ORGANIZATION'], entities['LOCATION'] card = BusinessCard(app, name, company, location, comment, submitter, file_path) result = app.create(card) return result
def test_select(self): app = pykintone.load(envs.FILE_PATH).app() result = app.select() self.assertTrue(result.ok) self.assertTrue(len(result.records) > 0) record_id = result.records[0]["$id"]["value"] result = app.get(record_id) self.assertTrue(result.ok) print(result.record)
def test_error(self): app = pykintone.load(envs.FILE_PATH).app() record = { "radio": { "value": "xxxxx" } } # create (will be error) result = app.create(record) self.assertFalse(result.ok)
def test_api_interface(self): # load from file kintone = pykintone.load(envs.FILE_PATH) app = kintone.app() self.assertTrue(app) # login app = pykintone.login("domain", "user_id", "password").app(1, api_token="token") self.assertTrue(app) # app app = pykintone.app("domain", 1, "token") self.assertTrue(app)
def test_user_select(self): app = pykintone.load(envs.FILE_PATH).app() model = TestAppModel() model.my_key = "user_select_field_check" result = app.create(model) self.assertTrue(result.ok) created = app.get(result.record_id).model(TestAppModel) created.user_select = sf.UserSelect(created.creator.code) result = app.update(created) self.assertTrue(result.ok) app.delete([created])
def test_process(self): app = pykintone.load(envs.FILE_PATH).app() record = {"my_key": {"value": "test_process"}} for c in ("single", "multiple"): created_id = app.create(record).record_id created = app.get(created_id).record if c == "single": proceeded = app.proceed(created, "処理開始") else: proceeded = app.batch_proceed([created], "処理開始") app.delete(created_id) # delete record self.assertTrue(proceeded.ok)
def test_update_general_settings(self): account = pykintone.load(envs.FILE_PATH).account with Administrator(account).as_test_mode() as admin: created = admin.create_application("test_create_application") self.assertTrue(created.ok) g = admin.general_settings() s = g.get(preview=True).settings s.description = "test edit description" result = g.update(s) self.assertTrue(result.revision) after_updated = g.get(preview=True).settings self.assertEquals(s.description, after_updated.description)
def appDataget(self): # 受け取った引数でAPP接続先を変える fileName = self.appName + '_account.yml' try: account = pykintone.load(fileName) app = account.app() result = app.select("flag = 0").records return result except Exception: texta = "{}:アプリデータ取得に失敗\n" dt = datetime.datetime.now() with open("log.txt", "a") as fileobj: text = texta.format(dt) fileobj.write(text)
def test_create_application(self): kintone = pykintone.load(envs.FILE_PATH) with kintone.administration().transaction() as admin: # create application created = admin.create_application("my_application") # create form f1 = ff.BaseFormField.create("SINGLE_LINE_TEXT", "title", "Title") f2 = ff.BaseFormField.create("MULTI_LINE_TEXT", "description", "Desc") admin.form().add([f1, f2]) # create view view = View.create("mylist", ["title", "description"]) admin.view().update(view)
def test_get_layout(self): app = pykintone.load(envs.FILE_PATH).app() fl = app.administration().form().get_layout() self.assertTrue(fl.ok) # deserialize check layouts = fl.layouts self.assertTrue(len(layouts) > 0) self.assertTrue(len(layouts[0].fields) > 0) for lf in layouts[0].fields: self.assertTrue(isinstance(lf, LayoutField)) self.assertTrue(isinstance(lf.size, LayoutFieldSize)) # serialize check serialized = layouts[0].serialize() self.assertTrue(fl.raw[0], serialized)
def test_uesr_groups(self): from datetime import datetime export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting users = export_api.get_users().users tested = False for u in users[:5]: code = u.code groups_result = export_api.get_user_groups(code) self.assertTrue(groups_result.ok) if len(groups_result.groups) > 0: tested = True for g in groups_result.groups: self.assertTrue(g.name) if not tested: print("Caution, gruop deserialization is not checked. Please make user who belongs to some group.")
def test_file(self): import os app = pykintone.load(envs.FILE_PATH).app() file_path = os.path.join(os.path.dirname(__file__), "./kintone.PNG") model = TestAppModel() model.my_key = "file_field_check" model.attachfile = sf.File.upload(file_path, app) self.assertTrue(model.attachfile) result = app.create(model) self.assertTrue(result.ok) created = app.get(result.record_id).model(TestAppModel) file = created.attachfile.download(app) self.assertTrue(file) app.delete([created])
def insertOrderManagementAPP(self): print(appDataList[0]) account = pykintone.load("test.yml") app = account.app() record = Kintone() record.channel = "test6" record.customer = "test7" try: app.create(record) except Exception: texta = "{}:受注管理表の更新に失敗\n" dt = datetime.datetime.now() with open("log.txt", "a") as fileobj: text = texta.format(dt) fileobj.write(text)
def test_process(self): app = pykintone.load(envs.FILE_PATH).app() record = { "my_key": { "value": "test_process" } } for c in ("single", "multiple"): created_id = app.create(record).record_id created = app.get(created_id).record if c == "single": proceeded = app.proceed(created, "処理開始") else: proceeded = app.batch_proceed([created], "処理開始") app.delete(created_id) # delete record self.assertTrue(proceeded.ok)
def test_uesr_groups(self): from datetime import datetime export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting users = export_api.get_users().users tested = False for u in users[:5]: code = u.code groups_result = export_api.get_user_groups(code) self.assertTrue(groups_result.ok) if len(groups_result.groups) > 0: tested = True for g in groups_result.groups: self.assertTrue(g.name) if not tested: print( "Caution, gruop deserialization is not checked. Please make user who belongs to some group." )
def test_user_organization_titles(self): export_api = pykintone.load(envs.FILE_PATH).user_api().for_exporting users = export_api.get_users().users tested = False for u in users[:5]: code = u.code ots_result = export_api.get_user_organization_titles(code) self.assertTrue(ots_result.ok) ots = ots_result.organization_titles if len(ots) > 0: tested = True for ot in ots: self.assertTrue(ot.organization.code) self.assertTrue(ot.title.code) if not tested: print("Caution, organization and title deserialization is not checked. Please make user who belongs to some organization.")
def test_single(self): app = pykintone.load(envs.FILE_PATH).app() record = { "my_key": { "value": "test0" }, "radio": { "value": "radio1" } } # create result = app.create(record) self.assertTrue(result.ok) record_id = result.record_id first_revision = result.revision created = app.get(record_id) self.assertTrue(created.ok) # update update = { "$id": { "value": record_id }, "$revision": { "value": result.revision }, "radio": { "value": "radio2" } } result = app.update(update) self.assertTrue(result.ok) self.assertTrue(first_revision < result.revision) updated = app.get(record_id).record self.assertTrue("redio2", updated["radio"]["value"]) # delete result = app.delete(record_id) self.assertTrue(result.ok)
def test_update_views(self): ks = pykintone.load(envs.FILE_PATH) view_api = ks.app(self.TEST_APP.app_id).administration().view() view_name = "test_view" codes = FormAPI.gather_codes(self._default_form()) views = View.create(view_name, codes[1:]) # add views add_result = view_api.update(views) self.assertTrue(add_result.ok) v_def = view_api.get(preview=True).views self.assertEqual(1, len(v_def)) # update fields views = [View.create(view_name, codes), View.create("another_view", codes, index=2)] update_result = view_api.update(views, revision=add_result.revision) self.assertTrue(update_result.ok) v_def = view_api.get(preview=True).views self.assertEqual(2, len(v_def)) original = [v for v in v_def if v.name == view_name][0] self.assertEqual(len(codes), len(original.fields))
def test_update_fields(self): ks = pykintone.load(envs.FILE_PATH) form_api = ks.app(self.TEST_APP.app_id).administration().form() fields = self._make_fields() codes = form_api.gather_codes(fields) def filter_by_codes(fs, target_codes): return [f for f in fs if f.code in target_codes] # add fields add_result = form_api.add(fields) self.assertTrue(add_result.ok) f_def = form_api.get(preview=True).fields created = filter_by_codes(f_def, codes) self.assertEqual(len(fields), len(created)) # delete fields delete_result = form_api.delete(fields, revision=add_result.revision) self.assertTrue(delete_result.ok) f_def = form_api.get(preview=True).fields deleted = filter_by_codes(f_def, codes) self.assertEqual(0, len(deleted))
dotenv_path = join(dirname(__file__), '.env') load_dotenv(dotenv_path) # LINE Pay API LINE_PAY_CHANNEL_ID = os.environ.get("LINE_PAY_CHANNEL_ID") LINE_PAY_CHANNEL_SECRET = os.environ.get("LINE_PAY_CHANNEL_SECRET") LINE_PAY_IS_SANDBOX = False # True | False api = LinePayApi(LINE_PAY_CHANNEL_ID, LINE_PAY_CHANNEL_SECRET, is_sandbox=LINE_PAY_IS_SANDBOX) # Cache CACHE = {} # kintone account = pykintone.load("account.yml") kintone = account.app() class PayTransaction(model.kintoneModel): def __init__(self): super(PayTransaction, self).__init__() self.transaction_id = "" self.transaction_type = "" self.method = "" self.total_amount = 0 self.currency = "" self.payment_status = "" self.reg_key = ""
def test_get_view(self): app = pykintone.load(envs.FILE_PATH).app() vr = app.administration().view().get() self.assertTrue(vr.ok) views = vr.views self.assertTrue(len(views) > 0)
def test_get_form(self): app = pykintone.load(envs.FILE_PATH).app() fr = app.administration().form().get() self.assertTrue(fr.ok) fields = fr.fields self.assertTrue(len(fields) > 0)
def tearDownClass(cls): account = pykintone.load(envs.FILE_PATH).account admin = Administrator(account) rollbacked = admin.rollback_settings(cls.TEST_APP.app_id) cls.TEST_APP = None print("You have to delete the application from the application administration view.")
def test_get_general_settings(self): app = pykintone.load(envs.FILE_PATH).app() s = app.administration().general_settings().get().settings self.assertTrue(s.name)
def test_get_application_information(self): app = pykintone.load(envs.FILE_PATH).app() ai = app.administration().get_app_info().info self.assertTrue(ai)
def test_batch(self): app = pykintone.load(envs.FILE_PATH).app() records = [{ "my_key": { "value": "test_m0" }, "radio": { "value": "radio1" } }, { "my_key": { "value": "test_m1" }, "radio": { "value": "radio2" } }] # create result = app.batch_create(records) self.assertTrue(result.ok) record_keys = result.keys ids = [str(k.record_id) for k in record_keys] query = "レコード番号 in ({0})".format(",".join(ids)) created = app.select(query) self.assertTrue(created.ok) # update updates = [{ "$id": { "value": record_keys[0].record_id }, "$revision": { "value": record_keys[0].revision }, "radio": { "value": "radio2" } }, { "$id": { "value": record_keys[1].record_id }, "$revision": { "value": record_keys[1].revision }, "radio": { "value": "radio1" } }] result = app.batch_update(updates) self.assertTrue(result.ok) for r in result.keys: prev = [k for k in record_keys if k.record_id == r.record_id] self.assertTrue(len(prev) == 1) self.assertTrue(prev[0].revision < r.revision) # delete result = app.delete(ids) self.assertTrue(result.ok)
def test_options(self): app = pykintone.load(envs.FILE_PATH).app() app.requests_options = {"verify": True} result = app.select() self.assertTrue(result.ok) self.assertTrue(len(result.records) > 0)
def setUpClass(cls): account = pykintone.load(envs.FILE_PATH).account admin = Administrator(account) cls.TEST_APP = admin.create_application("test form edit")
def test_batch(self): app = pykintone.load(envs.FILE_PATH).app() records = [ { "my_key": { "value": "test_m0" }, "radio": { "value": "radio1" } }, { "my_key": { "value": "test_m1" }, "radio": { "value": "radio2" } } ] # create result = app.batch_create(records) self.assertTrue(result.ok) record_keys = result.keys ids = [str(k.record_id) for k in record_keys] query = "レコード番号 in ({0})".format(",".join(ids)) created = app.select(query) self.assertTrue(created.ok) # update updates = [ { "$id": { "value": record_keys[0].record_id }, "$revision": { "value": record_keys[0].revision }, "radio": { "value": "radio2" } }, { "$id": { "value": record_keys[1].record_id }, "$revision": { "value": record_keys[1].revision }, "radio": { "value": "radio1" } } ] result = app.batch_update(updates) self.assertTrue(result.ok) for r in result.keys: prev = [k for k in record_keys if k.record_id == r.record_id] self.assertTrue(len(prev) == 1) self.assertTrue(prev[0].revision < r.revision) # delete result = app.delete(ids) self.assertTrue(result.ok)