Add models for dataset and energy-model

docs/source/index.rst

@@ -25,6 +25,4 @@ Indices and tables
 
    usage
    endpoints
-   modelUser
-   api
    projectStructure

ensysmod/api/api.py

@@ -1,7 +1,21 @@
 from fastapi import APIRouter
 
-from .endpoints import users, authentication
+from .endpoints import users, authentication, energy_sources, datasets, energy_commodities, energy_sinks, \
+    energy_storages, energy_transmissions, energy_conversions, regions, ts_capacity_max, ts_operation_rate_fix, \
+    ts_operation_rate_max
 
 api_router = APIRouter()
 api_router.include_router(authentication.router, prefix="/auth", tags=["Authentication"])
 api_router.include_router(users.router, prefix="/users", tags=["Users"])
+api_router.include_router(datasets.router, prefix="/datasets", tags=["Datasets"])
+api_router.include_router(regions.router, prefix="/regions", tags=["Regions"])
+api_router.include_router(energy_commodities.router, prefix="/commodities", tags=["Commodities"])
+api_router.include_router(energy_conversions.router, prefix="/conversions", tags=["Energy Conversions"])
+api_router.include_router(energy_sinks.router, prefix="/sinks", tags=["Energy Sinks"])
+api_router.include_router(energy_sources.router, prefix="/sources", tags=["Energy Sources"])
+api_router.include_router(energy_storages.router, prefix="/storages", tags=["Energy Storages"])
+api_router.include_router(energy_transmissions.router, prefix="/transmissions", tags=["Energy Transmissions"])
+
+api_router.include_router(ts_capacity_max.router, prefix="/max-capacities", tags=["TS Capacities Max"])
+api_router.include_router(ts_operation_rate_fix.router, prefix="/fix-operation-rates", tags=["TS Operation Rates Fix"])
+api_router.include_router(ts_operation_rate_max.router, prefix="/max-operation-rates", tags=["TS Operation Rates Max"])

ensysmod/api/endpoints/authentication.py

@@ -30,7 +30,8 @@ def login(
     return schemas.Token(access_token=token, token_type="bearer")
 
 
-@router.post("/register", response_model=schemas.User)
+@router.post("/register", response_model=schemas.User,
+             responses={409: {"description": "User with same name already exists."}})
 def register(
         request: schemas.UserCreate,
         db: Session = Depends(deps.get_db)
@@ -40,7 +41,7 @@ def register(
     """
     user = crud.user.get_by_username(db, username=request.username)
     if user:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT,
                             detail="User with that username already exists!")
 
     user = crud.user.create(db, obj_in=request)

ensysmod/api/endpoints/datasets.py

@@ -0,0 +1,74 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from ensysmod import schemas, model, crud
+from ensysmod.api import deps
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[schemas.Dataset])
+def all_datasets(db: Session = Depends(deps.get_db),
+                 current: model.User = Depends(deps.get_current_user),
+                 skip: int = 0,
+                 limit: int = 100) -> List[schemas.Dataset]:
+    """
+    Retrieve all datasets.
+    """
+    return crud.dataset.get_multi(db=db, skip=skip, limit=limit)
+
+
+@router.get("/{dataset_id}", response_model=schemas.Dataset)
+def get_dataset(dataset_id: int,
+                db: Session = Depends(deps.get_db),
+                current: model.User = Depends(deps.get_current_user)):
+    """
+    Retrieve a dataset.
+    """
+    # TODO Check if user has permission for dataset
+    return crud.dataset.get(db, dataset_id)
+
+
+@router.post("/", response_model=schemas.Dataset,
+             responses={409: {"description": "Dataset with same name already exists."}})
+def create_dataset(request: schemas.DatasetCreate,
+                   db: Session = Depends(deps.get_db),
+                   current: model.User = Depends(deps.get_current_user)):
+    """
+    Create a new dataset.
+    """
+    # TODO Check if user has permission for dataset
+    existing_ds = crud.dataset.get_by_name(db=db, name=request.name)
+    if existing_ds is not None:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=f"Dataset {request.name} already exists!")
+
+    return crud.dataset.create(db=db, obj_in=request)
+
+
+@router.put("/{dataset_id}", response_model=schemas.Dataset)
+def update_dataset(dataset_id: int,
+                   request: schemas.DatasetUpdate,
+                   db: Session = Depends(deps.get_db),
+                   current: model.User = Depends(deps.get_current_user)):
+    """
+    Update a dataset.
+    """
+    # TODO Check if user has permission for dataset
+    dataset = crud.dataset.get(db=db, id=dataset_id)
+    if dataset is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Dataset {dataset_id} not found!")
+    return crud.dataset.update(db=db, db_obj=dataset, obj_in=request)
+
+
+@router.delete("/{dataset_id}", response_model=schemas.Dataset)
+def remove_dataset(dataset_id: int,
+                   db: Session = Depends(deps.get_db),
+                   current: model.User = Depends(deps.get_current_user)):
+    """
+    Delete a dataset.
+    """
+    # TODO Check if user has permission for dataset
+    # TODO remove all components, commodities, regions, etc.
+    return crud.dataset.remove(db=db, id=dataset_id)

ensysmod/api/endpoints/energy_commodities.py

@@ -0,0 +1,83 @@
+from typing import List, Union
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from ensysmod import schemas, model, crud
+from ensysmod.api import deps
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[schemas.EnergyCommodity])
+def all_commodities(db: Session = Depends(deps.get_db),
+                    current: model.User = Depends(deps.get_current_user),
+                    skip: int = 0,
+                    limit: int = 100,
+                    dataset: Union[None, int] = None) -> List[schemas.EnergyCommodity]:
+    """
+    Retrieve all energy commodities.
+    """
+    if dataset is None:
+        return crud.energy_commodity.get_multi(db, skip=skip, limit=limit)
+    else:
+        return crud.energy_commodity.get_multi_by_dataset(db, dataset_id=dataset, skip=skip, limit=limit)
+
+
+@router.get("/{commodity_id}", response_model=schemas.EnergyCommodity)
+def get_commodity(commodity_id: int,
+                  db: Session = Depends(deps.get_db),
+                  current: model.User = Depends(deps.get_current_user)):
+    """
+    Retrieve a energy commodity.
+    """
+    # TODO Check if user has permission for dataset and commodity
+    return crud.energy_commodity.get(db, commodity_id)
+
+
+@router.post("/", response_model=schemas.EnergyCommodity,
+             responses={409: {"description": "EnergyCommodity with same name already exists."}})
+def create_commodity(request: schemas.EnergyCommodityCreate,
+                     db: Session = Depends(deps.get_db),
+                     current: model.User = Depends(deps.get_current_user)):
+    """
+    Create a new energy commodity.
+    """
+    dataset = crud.dataset.get(db=db, id=request.ref_dataset)
+    if dataset is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Dataset {request.ref_dataset} not found!")
+
+    # TODO Check if user has permission for dataset
+
+    existing = crud.energy_commodity.get_by_dataset_and_name(db=db, dataset_id=request.ref_dataset, name=request.name)
+    if existing is not None:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT,
+                            detail=f"EnergyCommodity {request.name} already for dataset {request.ref_dataset} exists!")
+
+    return crud.energy_commodity.create(db=db, obj_in=request)
+
+
+@router.put("/{commodity_id}", response_model=schemas.EnergyCommodity)
+def update_commodity(commodity_id: int,
+                     request: schemas.EnergyCommodityUpdate,
+                     db: Session = Depends(deps.get_db),
+                     current: model.User = Depends(deps.get_current_user)):
+    """
+    Update a energy commodity.
+    """
+    # TODO Check if user has permission for commodity
+    commodity = crud.energy_commodity.get(db=db, id=commodity_id)
+    if commodity is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"EnergyCommodity {commodity_id} not found!")
+    return crud.energy_commodity.update(db=db, db_obj=commodity, obj_in=request)
+
+
+@router.delete("/{commodity_id}", response_model=schemas.EnergyCommodity)
+def remove_commodity(commodity_id: int,
+                     db: Session = Depends(deps.get_db),
+                     current: model.User = Depends(deps.get_current_user)):
+    """
+    Delete a energy commodity.
+    """
+    # TODO Check if user has permission for dataset
+    return crud.energy_commodity.remove(db=db, id=commodity_id)

ensysmod/api/endpoints/energy_conversions.py

@@ -0,0 +1,51 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi import status
+from sqlalchemy.orm import Session
+
+from ensysmod import schemas, model, crud
+from ensysmod.api import deps
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[schemas.EnergyConversion])
+def all_energy_conversions(db: Session = Depends(deps.get_db),
+                           current: model.User = Depends(deps.get_current_user),
+                           skip: int = 0,
+                           limit: int = 100) -> List[schemas.EnergyConversion]:
+    """
+    Retrieve all energy conversions.
+    """
+    return crud.energy_conversion.get_multi(db, skip, limit)
+
+
+@router.post("/", response_model=schemas.EnergyConversion,
+             responses={409: {"description": "EnergyConversion with same name already exists."}})
+def create_conversion(request: schemas.EnergyConversionCreate,
+                      db: Session = Depends(deps.get_db),
+                      current: model.User = Depends(deps.get_current_user)):
+    """
+    Create a new energy conversion.
+    """
+    dataset = crud.dataset.get(db=db, id=request.ref_dataset)
+    if dataset is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Dataset {request.ref_dataset} not found!")
+
+    # TODO Check if user has permission for dataset
+
+    existing = crud.energy_conversion.get_by_dataset_and_name(db=db, dataset_id=request.ref_dataset, name=request.name)
+    if existing is not None:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT,
+                            detail=f"EnergyConversion {request.name} already for dataset {request.ref_dataset} exists!")
+
+    # Check if energy commodity exists
+    commodity = crud.energy_commodity.get_by_dataset_and_name(db=db, dataset_id=request.ref_dataset,
+                                                              name=request.commodity_unit)
+    if commodity is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
+                            detail=f"EnergyCommodity {request.commodity_unit} "
+                                   f"in dataset {request.ref_dataset} not found!")
+
+    return crud.energy_conversion.create(db=db, obj_in=request)

ensysmod/api/endpoints/energy_sinks.py

@@ -0,0 +1,50 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi import status
+from sqlalchemy.orm import Session
+
+from ensysmod import schemas, model, crud
+from ensysmod.api import deps
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[schemas.EnergySink])
+def all_energy_sinks(db: Session = Depends(deps.get_db),
+                     current: model.User = Depends(deps.get_current_user),
+                     skip: int = 0,
+                     limit: int = 100) -> List[schemas.EnergySink]:
+    """
+    Retrieve all energy sinks.
+    """
+    return crud.energy_sink.get_multi(db, skip, limit)
+
+
+@router.post("/", response_model=schemas.EnergySink,
+             responses={409: {"description": "EnergySink with same name already exists."}})
+def create_sink(request: schemas.EnergySinkCreate,
+                db: Session = Depends(deps.get_db),
+                current: model.User = Depends(deps.get_current_user)):
+    """
+    Create a new energy sink.
+    """
+    dataset = crud.dataset.get(db=db, id=request.ref_dataset)
+    if dataset is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Dataset {request.ref_dataset} not found!")
+
+    # TODO Check if user has permission for dataset
+
+    existing = crud.energy_sink.get_by_dataset_and_name(db=db, dataset_id=request.ref_dataset, name=request.name)
+    if existing is not None:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT,
+                            detail=f"EnergySink {request.name} already for dataset {request.ref_dataset} exists!")
+
+    # Check if energy commodity exists
+    commodity = crud.energy_commodity.get_by_dataset_and_name(db=db, dataset_id=request.ref_dataset,
+                                                              name=request.commodity)
+    if commodity is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
+                            detail=f"EnergyCommodity {request.commodity} in dataset {request.ref_dataset} not found!")
+
+    return crud.energy_sink.create(db=db, obj_in=request)

ensysmod/api/endpoints/energy_sources.py

@@ -0,0 +1,50 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi import status
+from sqlalchemy.orm import Session
+
+from ensysmod import schemas, model, crud
+from ensysmod.api import deps
+
+router = APIRouter()
+
+
+@router.get("/", response_model=List[schemas.EnergySource])
+def all_energy_sources(db: Session = Depends(deps.get_db),
+                       current: model.User = Depends(deps.get_current_user),
+                       skip: int = 0,
+                       limit: int = 100) -> List[schemas.EnergySource]:
+    """
+    Retrieve all energy sources.
+    """
+    return crud.energy_source.get_multi(db, skip, limit)
+
+
+@router.post("/", response_model=schemas.EnergySource,
+             responses={409: {"description": "EnergySource with same name already exists."}})
+def create_source(request: schemas.EnergySourceCreate,
+                  db: Session = Depends(deps.get_db),
+                  current: model.User = Depends(deps.get_current_user)):
+    """
+    Create a new energy source.
+    """
+    dataset = crud.dataset.get(db=db, id=request.ref_dataset)
+    if dataset is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Dataset {request.ref_dataset} not found!")
+
+    # TODO Check if user has permission for dataset
+
+    existing = crud.energy_source.get_by_dataset_and_name(db=db, dataset_id=request.ref_dataset, name=request.name)
+    if existing is not None:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT,
+                            detail=f"EnergySource {request.name} already for dataset {request.ref_dataset} exists!")
+
+    # Check if energy commodity exists
+    commodity = crud.energy_commodity.get_by_dataset_and_name(db=db, dataset_id=request.ref_dataset,
+                                                              name=request.commodity)
+    if commodity is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
+                            detail=f"EnergyCommodity {request.commodity} in dataset {request.ref_dataset} not found!")
+
+    return crud.energy_source.create(db=db, obj_in=request)