def test_validate(self): fields = opengui.Fields(values={"e": 1}, fields=[{ "name": "f" }, { "name": "g" }]) self.assertFalse(fields.validate()) self.assertFalse(fields.valid) self.assertEqual(fields.errors, ["unknown field 'e'"]) self.assertEqual(fields["f"].errors, ["missing value"]) self.assertEqual(fields["g"].errors, ["missing value"]) fields = opengui.Fields(values={"e": 1}) self.assertFalse(fields.validate()) self.assertEqual(fields.errors, ["unknown field 'e'"]) fields = opengui.Fields(fields=[{"name": "f"}, {"name": "g"}]) self.assertFalse(fields.validate()) self.assertEqual(fields["f"].errors, ["missing value"]) self.assertEqual(fields["g"].errors, ["missing value"]) fields = opengui.Fields(values={ "f": 1, "g": 2 }, fields=[{ "name": "f" }, { "name": "g" }]) self.assertTrue(fields.validate()) self.assertTrue(fields.valid)
def formats(self, model): """ Generate all the formats including parent lookups """ formats = {} fields = opengui.Fields(fields=self._fields) for field in model._fields._order: relation = model._ancestor(field.name) if relation is not None: titles = relation.Parent.many( **{ f"{relation.parent_field}__in": model[field.name] }).titles() formats[field.name] = { "titles": titles.titles, "format": titles.format } elif field.format is not None or "titles" in fields[ field.name].content: formats[field.name] = {} if field.format is not None: formats[field.name]["format"] = field.format if "titles" in fields[field.name].content: formats[field.name]["titles"] = fields[ field.name].content["titles"] return formats
def fields(cls, values): fields = opengui.Fields(values, cls.load(), [{ "name": "account", "fields": [{ "name": "password" }, { "name": "ssh", "options": ["disabled", "enabled"], "default": "disabled" }] }, { "name": "network", "fields": [{ "name": "interface", "options": ["eth0", "wlan0"], "labels": { "eth0": "wired", "wlan0": "wireless" }, "trigger": True }] }, { "name": "kubernetes", "fields": [{ "name": "role", "options": ["master", "worker", "reset"], "trigger": True }] }]) if fields["kubernetes"]["role"].original is not None and fields[ "kubernetes"]["role"].original != "reset": fields["kubernetes"]["role"].options = [ fields["kubernetes"]["role"].original, "reset" ] if fields["network"]["interface"].value == "wlan0": fields["network"].extend([{ "name": "country", "default": "US" }, { "name": "ssid" }, { "name": "psk", "label": "password", "optional": True }]) if fields["kubernetes"]["role"].value and fields["kubernetes"][ "role"].value != "reset": fields["kubernetes"].append({"name": "cluster"}) if fields["kubernetes"]["role"].value == "worker": fields["kubernetes"].append({"name": "name"}) return fields
def test_ready(self): cnc = service.CnC() fields = opengui.Fields() # missing field = { "name": "moar", "requires": "some" } self.assertFalse(cnc.ready(fields, field)) # invalid fields.append({ "name": "some", "required": True }) self.assertFalse(cnc.ready(fields, field)) # requirement met fields["some"].value = "fun" self.assertTrue(cnc.ready(fields, field))
def fields(cls, values=None, originals=None): return opengui.Fields( values, originals=originals, fields=copy.deepcopy(cls.ID + cls.FIELDS + cls.integrations() + cls.YAML))
def options(self, id=None): """ Generates form for inserts or updates of a single record """ values = (flask.request.json or {}).get(self.SINGULAR) if id is None: return opengui.Fields(values=values, fields=self.fields).to_dict(), 200 originals = dict(self.MODEL.one(**{self.model._id: id})) return opengui.Fields(values=values or originals, originals=originals, fields=self.fields).to_dict(), 200
def test____len__(self): fields = opengui.Fields(fields=[ {"name": "a"}, {"name": "b"} ]) self.assertEqual(len(fields), 2)
def test___iter__(self): fields = opengui.Fields(fields=[ {"name": "a"}, {"name": "b"} ]) self.assertEqual([field.name for field in fields], ["a", "b"])
def test_extend(self): fields = opengui.Fields() fields.extend([{"name": "a"}, {"name": "b"}]) self.assertEqual(len(fields.order), 2) self.assertEqual(fields.order[0].name, "a") self.assertEqual(fields.order[1].name, "b")
def test_validate(self): fields = opengui.Fields(values={"e": 1}, fields=[ {"name": "f"}, {"name": "g"} ]) self.assertFalse(fields.validate()) self.assertFalse(fields.valid) self.assertEqual(fields.errors, ["unknown field 'e'"]) self.assertEqual(fields["f"].errors, ["missing value"]) self.assertEqual(fields["g"].errors, ["missing value"]) fields = opengui.Fields(values={"e": 1}) self.assertFalse(fields.validate()) self.assertEqual(fields.errors, ["unknown field 'e'"]) fields = opengui.Fields(fields=[ {"name": "f"}, {"name": "g"} ]) self.assertFalse(fields.validate()) self.assertEqual(fields["f"].errors, ["missing value"]) self.assertEqual(fields["g"].errors, ["missing value"]) fields = opengui.Fields(values={"f": 1, "g": 2}, fields=[ {"name": "f"}, {"name": "g"} ]) self.assertTrue(fields.validate()) self.assertTrue(fields.valid) def unequal(fields): if fields["h"].value == fields["i"].value: fields.valid = False fields.errors.append("h and i must be unequal") fields = opengui.Fields(values={"h": 1, "i": 1}, fields=[ {"name": "h"}, {"name": "i"} ], validation=unequal) self.assertFalse(fields.validate()) self.assertFalse(fields.valid) self.assertEqual(fields.errors, ["h and i must be unequal"])
def thy(cls, self=None): # pylint: disable=too-many-branches """ Base identity to be known without instantiating the class """ # If self wasn't sent, we're just providing a shell of an instance if self is None: self = ResourceIdentity() self.__dict__.update(cls.__dict__) self.model = self.MODEL.thy() if self.SINGULAR is None: if hasattr(self.model, "SINGULAR") and self.model.SINGULAR is not None: self.SINGULAR = self.model.SINGULAR else: self.SINGULAR = self.model.NAME if self.PLURAL is None: if hasattr(self.model, "PLURAL") and self.model.PLURAL is not None: self.PLURAL = self.model.PLURAL else: self.PLURAL = f"{self.SINGULAR}s" if self.FIELDS is None: self.FIELDS = [] self.fields = [] fields = opengui.Fields(fields=self.FIELDS) for model_field in self.model._fields._order: form_field = { "name": model_field.name, "kind": model_field.kind.__name__ } for attribute in ["readonly", "options", "validation"]: if getattr(model_field, attribute): form_field[attribute] = getattr(model_field, attribute) if model_field.default is not None: form_field["default"] = model_field.default() if callable( model_field.default) else model_field.default elif not model_field.none: form_field["required"] = True if model_field.name in fields.names: form_field.update(fields[model_field.name].to_dict()) self.fields.append(form_field) return self
def test_to_list(self): fields = opengui.Fields(fields=[ {"name": "a", "label": "A"}, {"name": "b"} ]) self.assertEqual(fields.to_list(), [ {"name": "a", "label": "A"}, {"name": "b"} ])
def test___init__(self): fields = opengui.Fields() self.assertEqual(fields.order, []) self.assertEqual(fields.names, {}) self.assertEqual(fields.values, {}) self.assertEqual(fields.originals, {}) fields = opengui.Fields(values={ "a": 1, "b": { "c": 2 } }, originals={ "a": 3, "b": { "c": 4 } }, fields=[{ "name": "a" }, { "name": "b", "fields": [{ "name": "c" }] }]) self.assertEqual(fields.values, {"a": 1, "b": {"c": 2}}) self.assertEqual(fields.originals, {"a": 3, "b": {"c": 4}}) self.assertEqual(fields.order[0].name, "a") self.assertEqual(fields.names["a"].value, 1) self.assertEqual(fields.names["a"].original, 3) self.assertEqual(fields.order[1].name, "b") self.assertEqual(fields.names["b"].value, {"c": 2}) self.assertEqual(fields.names["b"].original, {"c": 4}) self.assertEqual(fields.order[1].fields[0].name, "c") self.assertEqual(fields.names["b"].fields.names["c"].value, 2) self.assertEqual(fields.names["b"].fields.names["c"].original, 4)
def fields(self, values=None): fields = opengui.Fields(values, fields=[{ "name": "text" }, { "name": "language", "options": [ "en-AU", "en-CA", "en-GH", "en-GB", "en-IN", "en-IE", "en-KE", "en-NZ", "en-NG", "en-PH", "en-SG", "en-ZA", "en-TZ", "en-US" ], "labels": { "en-AU": "English (Australia)", "en-CA": "English (Canada)", "en-GH": "English (Ghana)", "en-GB": "English (United Kingdom)", "en-IN": "English (India)", "en-IE": "English (Ireland)", "en-KE": "English (Kenya)", "en-NZ": "English (New Zealand)", "en-NG": "English (Nigeria)", "en-PH": "English (Philippines)", "en-SG": "English (Singapore)", "en-ZA": "English (South Africa)", "en-TZ": "English (Tanzania)", "en-US": "English (United States)" }, "default": "en-US", "style": "select" }, { "name": "node", "options": [""], "labels": { "": "all" }, "default": "", "optional": True }]) for node in pykube.Node.objects(flask.current_app.kube).filter( selector={"speech.nandy.io/speakers": "enabled"}): fields["node"].options.append(node.obj["metadata"]["name"]) fields["node"].labels[node.obj["metadata"] ["name"]] = node.obj["metadata"]["name"] fields["node"].options.sort() return fields
def test_values(self): cnc = service.CnC() fields = opengui.Fields(fields=[ {"name": "none"}, {"name": "some", "default": "fun"} ]) self.assertEqual(cnc.values(fields), { "none": None, "some": "fun" })
def test_append(self): fields = opengui.Fields(values={"a": 1}, originals={"a": 2}) fields.append({"name": "a", "label": "A"}) self.assertEqual(fields.order[0].name, "a") self.assertEqual(fields.order[0].content["label"], "A") self.assertEqual(fields.order[0].value, 1) self.assertEqual(fields.order[0].original, 2) self.assertEqual(fields.names["a"].content["label"], "A") self.assertRaisesRegex(opengui.MissingName, "Missing name in {}", fields.append) self.assertRaisesRegex(opengui.DuplicateName, "Name a exists", fields.append, name="a")
def test____getitem__(self): fields = opengui.Fields(fields=[{ "name": "a" }, { "name": "b", "fields": [{ "name": "c" }] }]) self.assertEqual(fields[0].name, "a") self.assertEqual(fields[1][0].name, "c") self.assertEqual(fields["a"].name, "a") self.assertEqual(fields["b"]["c"].name, "c")
def fields(cls, values=None, originals=None): (person_ids, person_labels) = Person.choices() (template_ids, template_labels) = Template.choices(cls.SINGULAR) fields = opengui.Fields(values, originals=originals, fields=[ { "name": "person_id", "label": "person", "options": person_ids, "labels": person_labels, "style": "radios" }, { "name": "status", "options": cls.STATUSES, "style": "radios" }, { "name": "template_id", "label": "template", "options": template_ids, "labels": template_labels, "style": "select", "optional": True, "trigger": True }, { "name": "name" }, { "name": "yaml", "style": "textarea", "optional": True } ]) if fields["template_id"].value: template = model_out(TemplateRUD.retrieve(fields["template_id"].value)) fields["name"].value = template["name"] fields["yaml"].value = template["yaml"] return fields
def fields(cls, obj, values): fields = opengui.Fields(values, obj.get("settings", {}), obj["spec"].get("settings", []), ready=True) nodes = [] for field in fields: if field.content.get("node"): cls.node(obj["metadata"]["name"], field, nodes) if field.content.get("google") == "calendar": fields.ready = fields.ready and cls.calendar(field) return fields
def test_validate(self): fields = opengui.Fields(fields=[{ "name": "name", "value": "yup" }, { "name": "yaml", "style": "textarea", "value": "a: 1" }]) self.assertTrue(UnitTest.validate(fields)) self.assertFields(fields, [{ "name": "name", "value": "yup" }, { "name": "yaml", "style": "textarea", "value": "a: 1" }])
def response(cls, model): converted = {"data": {}} integrations = opengui.Fields({}, {}, cls.integrations()) for field in model.__table__.columns._data.keys(): if field != "data": converted[field] = getattr(model, field) for field in model.data: if field in integrations.names: converted[field] = model.data[field] else: converted["data"][field] = model.data[field] converted["yaml"] = yaml.safe_dump(dict(converted["data"]), default_flow_style=False) return converted
def fields(self, forge, values): """ Gets the dynamic fields """ values["forge"] = forge['id'] fields = opengui.Fields(values=values, fields=FIELDS, ready=True) fields["forge"].description = forge["description"] fields.extend(forge.get("input", {}).get("fields", [])) if "generate" in forge.get("input", {}): module_name, method_name = forge["input"]["generate"].rsplilt( ".", 1) module = __import__(f"tempplate.{module_name}") method = getattr(module, method_name) fields.extend(method(fields, values, forge)) return fields
def fields(self, forge, values): """ Gets the dynamic fields """ values["forge"] = forge['id'] fields = opengui.Fields(values=values, fields=FIELDS, ready=True) fields["forge"].description = forge["description"] if os.path.exists("/opt/service/forge/fields.yaml"): with open("/opt/service/forge/fields.yaml", "r") as fields_file: fields.extend(yaml.safe_load(fields_file).get("fields", [])) for field in forge.get("input", {}).get("fields", []): if field["name"] in RESERVED: raise Exception(f"field name '{field['name']}' is reserved") self.field(fields, field) return fields
def fields(cls, values=None, originals=None): (person_ids, person_labels) = Person.choices() fields = opengui.Fields(values, originals=originals, fields=cls.ID + [ { "name": "person_id", "label": "person", "options": person_ids, "labels": person_labels, "style": "radios" }, { "name": "status", "options": cls.STATUSES, "style": "radios" }, { "name": "name" }, { "name": "created", "style": "datetime", "readonly": True }, { "name": "updated", "style": "datetime", "readonly": True }, { "name": "yaml", "style": "textarea", "optional": True } ]) return fields
def request(cls, converted): values = {} integrations = opengui.Fields({}, {}, cls.integrations()) for field in converted.keys(): if field in integrations.names: values.setdefault("data", {}) values["data"][field] = converted[field] elif field != "yaml": values[field] = converted[field] if "yaml" in converted: values.setdefault("data", {}) values["data"].update(yaml.safe_load(converted["yaml"])) if "data" in converted: values.setdefault("data", {}) values["data"].update(converted["data"]) return values
def test_to_dict(self): fields = opengui.Fields( fields=[ {"name": "a", "label": "A"}, {"name": "b"} ], errors=['boo'], valid=True, ready=False ) self.assertEqual(fields.to_dict(), { "fields": [ {"name": "a", "label": "A"}, {"name": "b"} ], "errors": [ "boo" ], "valid": True, "ready": False })
def fields(self, likes, values, originals=None): """ Apply options and titles to fields """ fields = opengui.Fields(values=values, originals=originals, fields=self._fields) for field in fields: relation = self._model._ancestor(field.name) if relation is not None: like = { "like": likes[name] for name in likes if name == field.name } parent = relation.Parent.many(**like).limit() titles = parent.titles() field.content["format"] = titles.format field.content["overflow"] = parent.overflow value = field.value if field.value is not None else field.original if (not like and value is not None and value not in titles): titles = relation.Parent.one(**{ relation.parent_field: value }).titles() field.content["overflow"] = True field.options = titles.ids field.content["titles"] = titles.titles field.content.update(like) return fields
def calendar(field): # https://www.googleapis.com/auth/calendar.readonly # Successfully installed cachetools-4.1.0 google-auth-1.14.0 google-auth-httplib2-0.0.3 google-auth-oauthlib-0.4.1 httplib2-0.17.2 oauthlib-3.1.0 pyasn1-modules-0.2.8 requests-oauthlib-1.3.0 rsa-4.0 # 4/ywEX3hVZgLcTCxzQf9qAMRS_GJTLEhMtDfhTpeNCACYZWAVl31ecVho ready = False subfields = [{ "name": "credentials", "description": "\n".join([ "Go to the Link below.", "Create a new project.", "Enable Calendar API.", "Create credentials (OAuth, Other).", "Download the JSON and paste it above." ]), "link": { "name": "Google API's", "url": "https://console.developers.google.com/apis/" } }] credentials = json.loads( field.value['credentials'] ) if field.value and field.value.get("credentials") else {} if credentials and "token" not in credentials: if not field.value.get("code"): flow = google_auth_oauthlib.flow.Flow.from_client_config( credentials, scopes=[ 'https://www.googleapis.com/auth/calendar.readonly' ], redirect_uri='urn:ietf:wg:oauth:2.0:oob') url, state = flow.authorization_url( prompt='consent', access_type='offline', include_granted_scopes='true') credentials["state"] = state subfields.append({ "name": "code", "description": "\n".join([ "Go to the Link below.", "Click Advanced.", "Authorise access to your Calendars.", "Copy the Code and paste it above." ]), "link": { "name": "Authorize Calendar Access", "url": url } }) else: flow = google_auth_oauthlib.flow.Flow.from_client_config( credentials, scopes=[ 'https://www.googleapis.com/auth/calendar.readonly' ], redirect_uri='urn:ietf:wg:oauth:2.0:oob', state=credentials['state']) flow.fetch_token(code=field.value["code"]) credentials = json.loads(flow.credentials.to_json()) if credentials and "token" in credentials: service = googleapiclient.discovery.build( 'calendar', 'v3', credentials=google.oauth2.credentials.Credentials( **credentials)) options = [] labels = {} page_token = None while True: calendar_list = service.calendarList().list( pageToken=page_token).execute() for calendar in calendar_list['items']: options.append(calendar['id']) labels[calendar['id']] = calendar["summary"] page_token = calendar_list.get('nextPageToken') if not page_token: break subfields.append({ "name": "watch", "description": "The Calendar you'd like to watch.", "options": options, "labels": labels }) ready = True field.fields = opengui.Fields(field.value, field.original, subfields) if credentials: field.fields["credentials"].value = json.dumps(credentials) return ready
def thy(cls, self=None): # pylint: disable=too-many-branches """ Base identity to be known without instantiating the class """ # If self wasn't sent, we're just providing a shell of an instance if self is None: self = ResourceIdentity() self.__dict__.update(cls.__dict__) self._model = self.MODEL.thy() if self.SINGULAR is None: if hasattr(self._model, "SINGULAR") and self._model.SINGULAR is not None: self.SINGULAR = self._model.SINGULAR else: self.SINGULAR = self._model.NAME if self.PLURAL is None: if hasattr(self._model, "PLURAL") and self._model.PLURAL is not None: self.PLURAL = self._model.PLURAL else: self.PLURAL = f"{self.SINGULAR}s" if self.FIELDS is None: self.FIELDS = [] self._fields = [] fields = opengui.Fields(fields=self.FIELDS) for model_field in self._model._fields._order: form_field = { "name": model_field.name, "kind": model_field.kind.__name__ } for attribute in ["options", "validation", "init", "inject"]: if getattr(model_field, attribute): form_field[attribute] = getattr(model_field, attribute) if model_field.auto: form_field["readonly"] = True if model_field.default is not None: form_field["default"] = model_field.default() if callable( model_field.default) else model_field.default if isinstance(form_field["default"], set): form_field["default"] = sorted(list(form_field["default"])) elif not model_field.auto and (not model_field.none or model_field.name in self._model._titles): form_field["required"] = True if model_field.name in fields.names: form_field.update(fields[model_field.name].to_dict()) self._fields.append(form_field) if self.LIST is None: self.LIST = list(self._model._list) # Make sure all the list checks out for field in self.LIST: if field.split("__")[0] not in self._model._fields: raise ResourceError(self, f"cannot find field {field} from list") return self
def test_validate(self): fields = opengui.Fields(fields=[{ "name": "name" }, { "name": "yaml", "style": "textarea" }]) self.assertFalse(klotio.service.validate(fields)) self.assertFields(fields, [{ "name": "name", "errors": ["missing value"] }, { "name": "yaml", "style": "textarea", "errors": ["missing value"] }]) fields = opengui.Fields(fields=[{ "name": "name" }, { "name": "yaml", "style": "textarea", "value": "a: 1" }]) self.assertFalse(klotio.service.validate(fields)) self.assertFields(fields, [{ "name": "name", "errors": ["missing value"] }, { "name": "yaml", "style": "textarea", "value": "a: 1" }]) fields = opengui.Fields(fields=[{ "name": "name", "value": "yup" }, { "name": "yaml", "style": "textarea", "value": "a:1" }]) self.assertFalse(klotio.service.validate(fields)) self.assertFields(fields, [{ "name": "name", "value": "yup" }, { "name": "yaml", "style": "textarea", "value": "a:1", "errors": ["must be dict"] }]) fields = opengui.Fields(fields=[{ "name": "name", "value": "yup" }, { "name": "yaml", "style": "textarea", "value": "a: 1" }]) self.assertTrue(klotio.service.validate(fields)) self.assertFields(fields, [{ "name": "name", "value": "yup" }, { "name": "yaml", "style": "textarea", "value": "a: 1" }])