def create_entity_from_type_dict(
class_name: str,
identifier_column_name: str,
type_dict: Dict,
foreign_keys: Set[Tuple[str, str, str]] = set(),
indexes: Set[str] = set(),
operations: Optional[Set[OperationOption]] = None,
relationships: Optional[List[Relationship]] = None,
table_name: Optional[str] = None,
uniques: Optional[List[List[str]]] = None,
api_paths: Optional[List[APIPath]] = None,
model_alias: Optional[ImportAlias] = None,
additional_properties: Optional[List[AdditionalProperty]] = None,
) -> Entity:
columns = []
foreign_keys_dict = {}
for fk_key, fk_value, fk_type in foreign_keys:
foreign_keys_dict[fk_key] = ForeignKeyRelationship(
f'{pythonize(fk_value)}', string_to_type_option(fk_type))
identifier_column = None
for k, v in type_dict.items():
nullable = v.endswith('?')
v = v.replace('?', '')
type_option = string_to_type_option(v)
foreign_key = foreign_keys_dict[k] if k in foreign_keys_dict else None
index = k in indexes
if pythonize(k) == pythonize(identifier_column_name):
identifier_column = create_identifier_column(k, type_option)
else:
column = create_column(name=k,
type_option=type_option,
foreign_key_relationship=foreign_key,
index=index,
nullable=nullable,
identifier=False)
columns.append(column)
if identifier_column is None:
raise GenyratorError('Entity must have an identifier column')
return create_entity(
class_name=class_name,
identifier_column=identifier_column,
columns=columns,
operations=operations if operations is not None else all_operations,
relationships=relationships if relationships else [],
table_name=table_name,
uniques=uniques if uniques else [],
api_paths=api_paths,
model_alias=model_alias,
additional_properties=additional_properties
if additional_properties is not None else [],
)
def create_entity_from_type_dict(
class_name: str,
identifier_column_name: str,
type_dict: Dict,
foreign_keys: Set[Tuple[str, str]]=set(),
indexes: Set[str]=set(),
operations: Optional[Set[OperationOption]]=None,
relationships: Optional[List[Relationship]]=None,
table_name: Optional[str]=None,
uniques: Optional[List[List[str]]]=None,
api_paths: Optional[APIPaths]=None,
model_alias: Optional[ImportAlias]=None,
) -> Entity:
columns = []
foreign_keys_dict = {}
for fk_key, fk_value in foreign_keys:
foreign_keys_dict[fk_key] = '{table}.{fk_column}'.format(
table=fk_value, fk_column=pythonize(fk_key)
)
identifier_column = None
for k, v in type_dict.items():
nullable = v.endswith('?')
v = v.replace('?', '')
type_option = string_to_type_option(v)
foreign_key = foreign_keys_dict[k] if k in foreign_keys_dict else None
index = k in indexes
if k == identifier_column_name:
identifier_column = create_identifier_column(k, type_option)
else:
column = create_column(
name=k,
type_option=type_option,
foreign_key_relationship=foreign_key,
index=index,
nullable=nullable,
identifier=False
)
columns.append(column)
return create_entity(
class_name=class_name,
identifier_column=identifier_column,
columns=columns,
operations=operations if operations is not None else all_operations,
relationships=relationships if relationships else [],
table_name=table_name,
uniques=uniques if uniques else [],
api_paths=api_paths,
model_alias=model_alias,
)
import dateutil
from genyrator.entities.Column import create_column, create_identifier_column
from genyrator.entities.Entity import create_entity, create_entity_from_type_dict, APIPath, APIPaths, create_api_path, \
create_additional_property
from genyrator.entities.Relationship import create_relationship, JoinOption
from genyrator.entities.Schema import Schema, create_schema
from genyrator.types import TypeOption
treat_entity = create_entity(
class_name='Treat',
columns=[],
identifier_column=create_column('name', TypeOption.string),
relationships=[
create_relationship('Dog', True, True, JoinOption.to_many, 'favourite_treats', 'dogs')
],
)
owner_dogs_entity = create_entity(
'OwnerDogs',
columns=[
create_column('owner_id', TypeOption.string, 'owner.id'),
create_column('dog_id', TypeOption.string, 'dog.id'),
create_column('current_owner', TypeOption.bool),
],
identifier_column=create_identifier_column('ownerDogId', TypeOption.int),
relationships=[
create_relationship('Dog', True, False, JoinOption.to_one, None, None,),
create_relationship('Owner', True, False, JoinOption.to_one, None, None,),
],
table_name='owner_dogs',
additional_properties=[create_additional_property(property_name='__versioned__', property_value='{}')]
from mamba import description, it
from expects import expect, equal
from genyrator.entities.Entity import create_entity
from genyrator.entities.Column import create_column, create_identifier_column
from genyrator.types import TypeOption
with description('create_entity'):
with it('adds unique on identifier if it does not exist'):
entity = create_entity(
'Test',
create_identifier_column('test_id', TypeOption.string),
[
create_column('id', TypeOption.int, index=True,
nullable=False),
create_column(
'name', TypeOption.string, index=False, nullable=True),
],
uniques=[],
)
expect(entity.uniques).to(equal([['test_id']]))
with it('does not add unique on identifier if it does exist'):
entity = create_entity(
'Test',
create_identifier_column('test_id', TypeOption.string),
[
create_column('id', TypeOption.int, index=True,
nullable=False),
create_column(