294 lines
15 KiB
Python
294 lines
15 KiB
Python
from ..core import InstanceKey, InstanceReference, TenantReference
|
|
from ..definitions import KnownClassGuids, KnownInstanceGuids, KnownAttributeGuids, KnownRelationshipGuids
|
|
|
|
from framework import Guid
|
|
|
|
from .OmsResult import OmsResult
|
|
|
|
class Oms:
|
|
def __init__(self):
|
|
pass
|
|
|
|
def get_user_by_username(self, username : str):
|
|
|
|
ik_User = self.get_instance_by_global_identifier(KnownClassGuids.User)
|
|
if ik_User is None:
|
|
print ("error: class `User` is not defined")
|
|
return None
|
|
|
|
users = self.get_instances(ik_User)
|
|
for user in users:
|
|
un = self.get_attribute_value(user, self.get_instance_by_global_identifier(KnownAttributeGuids.UserName))
|
|
if un == username:
|
|
return user
|
|
|
|
return None
|
|
|
|
def create_class(self, class_id : int, inst_id : int, name : str, global_identifier : Guid):
|
|
pass
|
|
|
|
def create_relationship(self, src_class : InstanceReference, type : str, dst_class : InstanceReference, singular : bool = False, sibling_relationship : InstanceReference = None, global_identifier : Guid = None):
|
|
|
|
ik_current = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.Relationship), global_identifier)
|
|
|
|
self.assign_relationship(ik_current, self.get_instance_by_global_identifier(KnownRelationshipGuids.Relationship__has_source__Class), src_class)
|
|
self.assign_attribute(ik_current, self.get_instance_by_global_identifier(KnownAttributeGuids.RelationshipType), type)
|
|
self.assign_relationship(ik_current, self.get_instance_by_global_identifier(KnownRelationshipGuids.Relationship__has_destination__Class), dst_class)
|
|
self.assign_attribute(ik_current, self.get_instance_by_global_identifier(KnownAttributeGuids.Singular), singular)
|
|
|
|
if sibling_relationship is not None:
|
|
self.assign_relationship(ik_current, self.get_instance_by_global_identifier(KnownRelationshipGuids.Relationship__has_sibling__Relationship), sibling_relationship)
|
|
|
|
return ik_current
|
|
|
|
def get_parent_class(self, instance : InstanceReference) -> InstanceReference:
|
|
ik = InstanceKey(1, instance.get_instance_key().get_class_index())
|
|
return self.get_instance_by_key(ik)
|
|
|
|
def assign_attribute(self, instance : InstanceReference, attribute : InstanceReference, value : str):
|
|
pass
|
|
|
|
def assign_relationship(self, instance : InstanceReference, relationship : InstanceReference, related_instances : InstanceReference|list):
|
|
pass
|
|
|
|
def get_attribute_value_internal(self, inst : InstanceReference, att : InstanceReference, default_value = None):
|
|
pass
|
|
|
|
def get_attribute_value(self, inst : InstanceReference, att : InstanceReference, default_value = None):
|
|
value = self.get_attribute_value_internal(inst, att, default_value)
|
|
if value is None:
|
|
return default_value
|
|
|
|
pclass = self.get_parent_class(att)
|
|
if pclass is not None:
|
|
if pclass.get_global_identifier() == KnownClassGuids.NumericAttribute:
|
|
return float(value)
|
|
|
|
return value
|
|
|
|
def set_attribute_value_internal(self, inst : InstanceReference, att : InstanceReference, value):
|
|
pass
|
|
|
|
def set_attribute_value(self, inst : InstanceReference, att : InstanceReference, value) -> OmsResult:
|
|
|
|
if inst is None or att is None:
|
|
return OmsResult(False, "no value specified for instance reference: inst | att")
|
|
|
|
pclass = self.get_parent_class(att)
|
|
if pclass is not None:
|
|
if pclass.get_global_identifier() == KnownClassGuids.NumericAttribute:
|
|
try:
|
|
val = float(value)
|
|
max_val = self.get_attribute_value(att, self.get_instance_by_global_identifier(KnownAttributeGuids.MaximumValue))
|
|
min_val = self.get_attribute_value(att, self.get_instance_by_global_identifier(KnownAttributeGuids.MinimumValue))
|
|
|
|
if (min_val is not None and val < min_val) or (max_val is not None and val > max_val):
|
|
return OmsResult(False, "parameter out of range: value")
|
|
|
|
except ValueError:
|
|
return OmsResult(False, "parameter type mismatch: expected int, got " + str(type(value)))
|
|
|
|
self.set_attribute_value_internal(inst, att, value)
|
|
return OmsResult.SUCCESS
|
|
|
|
def get_instance_by_key(self, key : InstanceKey):
|
|
pass
|
|
|
|
def get_instance_by_global_identifier(self, global_identifier : Guid):
|
|
pass
|
|
|
|
def get_instances(self, of_class : InstanceReference = None):
|
|
pass
|
|
|
|
def get_tenant_by_name(self, tenant_name : str) -> TenantReference:
|
|
pass
|
|
|
|
def get_related_instances(self, inst : InstanceReference, rel : InstanceReference) -> list[InstanceReference]:
|
|
pass
|
|
|
|
def get_related_instance(self, inst : InstanceReference, rel : InstanceReference) -> InstanceReference | None:
|
|
rels = self.get_related_instances(inst, rel)
|
|
if len(rels) == 0:
|
|
return None
|
|
|
|
return rels[0]
|
|
|
|
def assign_attribute(self, instance : InstanceReference, attribute : InstanceReference, value : str):
|
|
pass
|
|
|
|
def assign_relationship(self, instance : InstanceReference, relationship : InstanceReference, related_instances : InstanceReference|list):
|
|
pass
|
|
|
|
def get_instance_text(self, inst : InstanceReference) -> str:
|
|
# first see if we have a parent class with `Class.instance labeled by Executable returning Attribute`
|
|
pclasz = self.get_parent_class(inst)
|
|
if pclasz is not None:
|
|
rel = self.get_instance_by_global_identifier(KnownRelationshipGuids.Class__instances_labeled_by__Executable_returning_Attribute)
|
|
relinst = self.get_related_instance(pclasz, rel)
|
|
if relinst is not None:
|
|
text = "EXEC:" + str(relinst.get_instance_key()) # self.execute(relinst)
|
|
return text
|
|
|
|
|
|
# if all else fails, try getting the `Name` attribute
|
|
attr = self.get_instance_by_global_identifier(KnownAttributeGuids.Name)
|
|
text = self.get_attribute_value(inst, attr)
|
|
|
|
if text is None:
|
|
text = ""
|
|
|
|
return text
|
|
|
|
def _create_instance_of(self, class_inst : InstanceReference, global_identifier : Guid = None):
|
|
pass
|
|
|
|
def create_instance_of(self, class_inst : InstanceReference, global_identifier : Guid = None):
|
|
|
|
inst = self._create_instance_of(class_inst, global_identifier)
|
|
|
|
rel_Class__has__Instance = self.get_instance_by_global_identifier(KnownRelationshipGuids.Class__has__Instance)
|
|
if rel_Class__has__Instance is None:
|
|
return inst
|
|
rel_Instance__for__Class = self.get_instance_by_global_identifier(KnownRelationshipGuids.Instance__for__Class)
|
|
if rel_Instance__for__Class is None:
|
|
return inst
|
|
|
|
self.assign_relationship(class_inst, rel_Class__has__Instance, inst)
|
|
self.assign_relationship(inst, rel_Instance__for__Class, class_inst)
|
|
|
|
return inst
|
|
|
|
def set_user_password(self, user : InstanceReference, password : str):
|
|
|
|
ik_UserName = self.get_instance_by_global_identifier(KnownAttributeGuids.UserName)
|
|
ik_PasswordHash = self.get_instance_by_global_identifier(KnownAttributeGuids.PasswordHash)
|
|
ik_PasswordSalt = self.get_instance_by_global_identifier(KnownAttributeGuids.PasswordSalt)
|
|
|
|
username = self.get_attribute_value(user, self.get_instance_by_global_identifier(KnownAttributeGuids.UserName))
|
|
salt = Guid.create().strip()
|
|
|
|
passsalt = str(password + salt).encode("utf-8")
|
|
import hashlib
|
|
passhash = hashlib.sha512(passsalt).hexdigest()
|
|
|
|
self.assign_attribute(user, ik_UserName, username)
|
|
self.assign_attribute(user, ik_PasswordHash, passhash)
|
|
self.assign_attribute(user, ik_PasswordSalt, salt)
|
|
|
|
def create_user(self, username : str, password : str, global_identifier : Guid = None):
|
|
user = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.User), global_identifier)
|
|
|
|
if password is not None:
|
|
self.set_user_password(user, password)
|
|
|
|
def before_init(self):
|
|
pass
|
|
|
|
def _init(self):
|
|
ik_Class = self.create_class(1, 1, 'Class', KnownClassGuids.Class)
|
|
self.create_class(1, 2, 'Attribute', KnownClassGuids.Attribute)
|
|
ik_Relationship = self.create_class(1, 3, 'Relationship', KnownClassGuids.Relationship)
|
|
|
|
ik_TextAttribute = self.create_class(1, 4, 'Text Attribute', KnownClassGuids.TextAttribute)
|
|
ik_BooleanAttribute = self.create_class(1, 5, 'Boolean Attribute', KnownClassGuids.BooleanAttribute)
|
|
self.create_class(1, 6, 'Element', KnownClassGuids.Element)
|
|
ik_NumericAttribute = self.create_class(1, 20, 'Numeric Attribute', KnownClassGuids.NumericAttribute)
|
|
ik_RichTextAttribute = self.create_class(1, 2737, 'Rich Text Attribute', KnownClassGuids.RichTextAttribute)
|
|
|
|
att_Name = self.create_instance_of(ik_TextAttribute, KnownAttributeGuids.Name)
|
|
att_Value = self.create_instance_of(ik_TextAttribute, KnownAttributeGuids.Value)
|
|
att_Token = self.create_instance_of(ik_TextAttribute, KnownAttributeGuids.Token)
|
|
|
|
rel_Relationship__has_source__Class = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.Relationship), KnownRelationshipGuids.Relationship__has_source__Class)
|
|
rel_Relationship__has_destination__Class = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.Relationship), KnownRelationshipGuids.Relationship__has_destination__Class)
|
|
rel_Relationship__has_sibling__Relationship = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.Relationship), KnownRelationshipGuids.Relationship__has_sibling__Relationship)
|
|
|
|
ik_Singular = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.BooleanAttribute), KnownAttributeGuids.Singular)
|
|
ik_RelationshipType = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.TextAttribute), KnownAttributeGuids.RelationshipType)
|
|
|
|
|
|
ik_Instance = self.create_class(1, 17, "Instance", KnownClassGuids.Instance)
|
|
ik_User = self.create_class(1, 39, 'System User', KnownClassGuids.User)
|
|
ik_UserLogin = self.create_class(1, 4328, 'System Account Signon', KnownClassGuids.UserLogin)
|
|
|
|
ik_UserName = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.TextAttribute), KnownAttributeGuids.UserName)
|
|
self.assign_attribute(ik_UserName, self.get_instance_by_global_identifier(KnownAttributeGuids.Name), "User Name")
|
|
|
|
ik_PasswordHash = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.TextAttribute), KnownAttributeGuids.PasswordHash)
|
|
self.assign_attribute(ik_PasswordHash, self.get_instance_by_global_identifier(KnownAttributeGuids.Name), "Password Hash")
|
|
|
|
ik_PasswordSalt = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.TextAttribute), KnownAttributeGuids.PasswordSalt)
|
|
self.assign_attribute(ik_PasswordSalt, self.get_instance_by_global_identifier(KnownAttributeGuids.Name), "Password Salt")
|
|
|
|
superuser = self.create_instance_of(self.get_instance_by_global_identifier(KnownClassGuids.User), KnownInstanceGuids.User.superuser)
|
|
self.assign_attribute(superuser, ik_UserName, "superuser")
|
|
self.assign_attribute(superuser, ik_PasswordHash, "0bdbeeecd24e93a0d84ff2946c519761d4db2c52d9449d2de5bf3b74a8bcdfbee9d72bb88121a63700d09554983e7f881021ecf493f83dec19e8f7e465529c34")
|
|
self.assign_attribute(superuser, ik_PasswordSalt, "5e28b86839ed4ca9838c112723aeaa27")
|
|
|
|
self.create_user("zq-configurator", "Florida407!", KnownInstanceGuids.User.zq_configurator)
|
|
self.create_user("zq-developer", "Florida407!", KnownInstanceGuids.User.zq_developer)
|
|
self.create_user("zq-environments", "Florida407!", KnownInstanceGuids.User.zq_environments)
|
|
self.create_user("zq-implementer", "Florida407!", KnownInstanceGuids.User.zq_implementer)
|
|
self.create_user("zq-support", "Florida407!", KnownInstanceGuids.User.zq_support)
|
|
|
|
self.assign_attribute(self.get_instance_by_key(InstanceKey(1, 2)), self.get_instance_by_key(InstanceKey(4, 1)), 'Attribute')
|
|
self.assign_attribute(self.get_instance_by_key(InstanceKey(1, 3)), self.get_instance_by_key(InstanceKey(4, 1)), 'Relationship')
|
|
self.assign_attribute(self.get_instance_by_key(InstanceKey(1, 4)), self.get_instance_by_key(InstanceKey(4, 1)), 'Text Attribute')
|
|
self.assign_attribute(self.get_instance_by_key(InstanceKey(4, 1)), self.get_instance_by_key(InstanceKey(4, 1)), 'Name')
|
|
self.assign_attribute(self.get_instance_by_key(InstanceKey(4, 2)), self.get_instance_by_key(InstanceKey(4, 1)), 'Value')
|
|
self.assign_attribute(self.get_instance_by_key(InstanceKey(4, 3)), self.get_instance_by_key(InstanceKey(4, 1)), 'Token')
|
|
|
|
ik_User_Login__for__User = self.create_relationship(ik_UserLogin, "for", ik_User, False, None, KnownRelationshipGuids.User_Login__has__User)
|
|
# self.create_relationship(ik_User, "has", ik_UserLogin, False, ik_User_Login__for__User, KnownRelationshipGuids.User__has__User_Login)
|
|
|
|
self.update_relationship(rel_Relationship__has_source__Class, ik_Relationship, "has source", ik_Class, True, None)
|
|
self.update_relationship(rel_Relationship__has_destination__Class, ik_Relationship, "has destination", ik_Class, True, None)
|
|
self.update_relationship(rel_Relationship__has_sibling__Relationship, ik_Relationship, "has sibling", ik_Relationship, True, None)
|
|
|
|
rel_Class__has__Instance = self.create_relationship(ik_Class, "has", ik_Instance, False, None, KnownRelationshipGuids.Class__has__Instance)
|
|
rel_Instance__for__Class = self.create_relationship(ik_Instance, "for", ik_Class, True, None, KnownRelationshipGuids.Instance__for__Class)
|
|
self.update_relationship(rel_Class__has__Instance, None, None, None, None, rel_Instance__for__Class)
|
|
self.update_relationship(rel_Instance__for__Class, None, None, None, None, rel_Class__has__Instance)
|
|
|
|
ik_MaximumLength = self.create_instance_of(ik_NumericAttribute, KnownAttributeGuids.MaximumLength)
|
|
self.set_attribute_value(ik_MaximumLength, att_Name, "Maximum Length")
|
|
|
|
ik_MinimumValue = self.create_instance_of(ik_NumericAttribute, KnownAttributeGuids.MinimumValue)
|
|
self.set_attribute_value(ik_MinimumValue, att_Name, "Minimum Value")
|
|
ik_MaximumValue = self.create_instance_of(ik_NumericAttribute, KnownAttributeGuids.MaximumValue)
|
|
self.set_attribute_value(ik_MaximumValue, att_Name, "Maximum Value")
|
|
|
|
self.set_attribute_value(ik_Class, att_Name, "Class")
|
|
self.update_class_instances()
|
|
|
|
def update_relationship(self, relationship : InstanceReference, src_class : InstanceReference, type : str, dst_class : InstanceReference, singular: bool, sibling_relationship : InstanceReference):
|
|
if src_class is not None:
|
|
self.assign_relationship(relationship, self.get_instance_by_global_identifier(KnownRelationshipGuids.Relationship__has_source__Class), src_class)
|
|
if type is not None:
|
|
self.assign_attribute(relationship, self.get_instance_by_global_identifier(KnownAttributeGuids.RelationshipType), type)
|
|
if dst_class is not None:
|
|
self.assign_relationship(relationship, self.get_instance_by_global_identifier(KnownRelationshipGuids.Relationship__has_destination__Class), dst_class)
|
|
if singular is not None:
|
|
self.assign_attribute(relationship, self.get_instance_by_global_identifier(KnownAttributeGuids.Singular), singular)
|
|
if sibling_relationship is not None:
|
|
self.assign_relationship(relationship, self.get_instance_by_global_identifier(KnownRelationshipGuids.Relationship__has_sibling__Relationship), sibling_relationship)
|
|
|
|
def update_class_instances(self):
|
|
|
|
ik_Class = self.get_instance_by_global_identifier(KnownClassGuids.Class)
|
|
rel_Class__has__Instance = self.get_instance_by_global_identifier(KnownRelationshipGuids.Class__has__Instance)
|
|
rel_Instance__for__Class = self.get_instance_by_global_identifier(KnownRelationshipGuids.Instance__for__Class)
|
|
|
|
insts = self.get_instances()
|
|
for inst in insts:
|
|
clasz = self.get_instance_by_key(InstanceKey(1, inst.get_instance_key().get_class_index() ))
|
|
self.assign_relationship(clasz, rel_Class__has__Instance, inst)
|
|
self.assign_relationship(inst, rel_Instance__for__Class, clasz)
|
|
|
|
def after_init(self):
|
|
pass
|
|
|
|
def init(self):
|
|
self.before_init()
|
|
self._init()
|
|
self.after_init() |