def create_team(*,
db_session: Session = Depends(get_db),
team_contact_in: TeamCreate,
current_user: DispatchUser = Depends(get_current_user)):
"""
Create a new team. All jobs and workers must be assigned to one team.
"""
# limit max
org_data = orgService.get(db_session=db_session,
org_code=current_user.org_code)
if not org_data:
raise HTTPException(status_code=400, detail="org not exists")
max_nbr_teams = org_data.max_nbr_teams
job_all_count = get_by_org_id_count(db_session=db_session,
org_id=current_user.org_id)
if job_all_count >= max_nbr_teams:
raise HTTPException(status_code=400,
detail="Team Reached the upper limit")
if current_user.role == UserRoles.WORKER:
raise HTTPException(status_code=400, detail="No create permission")
team_contact_in.org_id = current_user.org_id
if team_contact_in.planner_service is not None:
team_contact_in.planner_service.org_id = current_user.org_id
team = get_by_code(db_session=db_session, code=team_contact_in.code)
if team:
raise HTTPException(status_code=400,
detail="The team with this email already exists.")
team = create(db_session=db_session, team_contact_in=team_contact_in)
return team
def post_job_to_kafka(job: Job, message_type, db_session, org_code=None):
job_dict = {c.key: getattr(job, c.key) for c in inspect(job).mapper.column_attrs}
job_dict["requested_primary_worker_code"] = None
if job.requested_primary_worker is not None:
job_dict["requested_primary_worker_code"] = job.requested_primary_worker.code
job_dict["scheduled_secondary_worker_codes"] = [w.code for w in job.scheduled_secondary_workers]
job_dict["location_code"] = job.location.location_code
job_dict["geo_longitude"] = job.location.geo_longitude
job_dict["geo_latitude"] = job.location.geo_latitude
if job.scheduled_primary_worker:
job_dict["scheduled_primary_worker_code"] = job.scheduled_primary_worker.code
else:
job_dict["scheduled_primary_worker_code"] = None
kem = KafkaEnvMessage(
message_type=message_type,
message_source_type=KandboxMessageSourceType.ENV,
message_source_code="USER.Web",
payload=[job_dict],
)
if not org_code:
org_data = orgService.get(db_session=db_session, org_id=job.org_id)
org_code = org_data.code
topic_name = f"{KandboxMessageTopicType.ENV_WINDOW}.env_{org_code}_{job.team.id}"
offset = kafka_server.post_message(topic_name=topic_name, m=kem)
job.team.latest_env_kafka_offset = offset
db_session.add(job.team)
db_session.commit()
def update_org(
*,
db_session: Session = Depends(get_db),
org_id: int,
org_in: OrganizationBase,
current_user: DispatchUser = Depends(get_current_user),
background_tasks: BackgroundTasks,
):
"""
Update an worker job.
"""
if current_user.role != UserRoles.OWNER:
raise HTTPException(
status_code=404,
detail=
"Normal user is not allowed to modify settings. Only Owner can modify it."
)
org = get(db_session=db_session, org_id=org_id)
old_org_code = copy.copy(org.code)
if not org:
raise HTTPException(status_code=404,
detail="This organization is not found.")
org_by_code_list = get_list(db_session=db_session, org_code=org_in.code)
if [i for i in org_by_code_list if str(i.id) != str(org_id)]:
raise HTTPException(
status_code=404,
detail=f"Organization code {org_in.code} does not match")
# NOTE: Order matters we have to get the previous state for change detection
org_update = update(db_session=db_session, org=org, org_in=org_in)
# change auth org code
if old_org_code != org_in.code:
authService.update_by_org_code(db_session=db_session,
org_id=org.id,
org_code=org_in.code)
try:
# zulip change
if org_update.id in all_zulip_client_dict:
del all_zulip_client_dict[org_update.id]
if org_update.zulip_is_active:
refresh = False if org_update.zulip_user_name == org.zulip_user_name and org_update.zulip_password == org.zulip_password and org_update.zulip_site == org.zulip_site else True
config = get_api(org_update.zulip_user_name,
org_update.zulip_password,
org_update.zulip_site,
refresh=refresh)
client = zulip.Client(email=config.get('email'),
api_key=config.get('api_key'),
site=org_update.zulip_site)
all_zulip_client_dict[org_update.id] = {
"org_obj": org_update,
"client": ZulipCore(org_update, client),
}
except Exception as e:
raise HTTPException(status_code=400, detail=f"zulip init error ,{e}")
return org_update
def get_org_by_code(
*,
db_session: Session = Depends(get_db),
org_code: str,
current_user: DispatchUser = Depends(get_current_user),
):
"""
Retrieve details about a specific job.
"""
org = get(db_session=db_session, org_code=org_code)
return org if org else {}
def create_job(
*,
db_session: Session = Depends(get_db),
job_in: JobCreate,
current_user: DispatchUser = Depends(get_current_user),
background_tasks: BackgroundTasks,
):
"""
Create a new job.
"""
try:
# limit max job
org_data = orgService.get(db_session=db_session,
org_code=current_user.org_code)
if not org_data:
raise HTTPException(status_code=400, detail="org not exists")
max_nbr_job = org_data.max_nbr_jobs
job_all_count = get_by_org_id_count(db_session=db_session,
org_id=current_user.org_id)
if job_all_count >= max_nbr_job:
raise HTTPException(status_code=400,
detail="Org Reached the upper limit")
job_in.org_id = current_user.org_id
job = get_by_code(db_session=db_session, code=job_in.code)
if job:
return {
"state": -1,
"msg": "The job with this code already exists.",
"data": job
}
if job_in.requested_skills:
job_in.flex_form_data['requested_skills'] = job_in.requested_skills
if job_in.requested_items:
job_in.flex_form_data['requested_items'] = job_in.requested_items
job = create(db_session=db_session,
org_code=current_user.org_code,
**job_in.dict())
# background_tasks.add_task(job_create_flow, job_id=job.id)
return {"state": 1, "msg": "The job add succeed", "data": job}
except Exception as e:
return {"state": -1, "msg": f"add job error,{e}", "data": None}
def create_org(
*,
db_session: Session = Depends(get_db),
org_in: OrganizationBase,
):
"""
register add org , no login info
"""
org = org_service.get(db_session=db_session, org_code=org_in.code)
if org:
raise HTTPException(status_code=400,
detail="add user org error .code exist")
org_in_dict = org_in.dict()
org_in_dict['id'] = SHORTUUID.random(length=9)
org = org_service.create(db_session=db_session, **org_in_dict)
en_code = encrypt(org.id)
return en_code
def create_depot(*,
db_session: Session = Depends(get_db),
depot_in: DepotCreate,
current_user: DispatchUser = Depends(get_current_user)):
"""
Create a new depot contact.
"""
# limit max
org_data = orgService.get(db_session=db_session,
org_code=current_user.org_code)
if not org_data:
raise HTTPException(status_code=400, detail="org not exists")
depot_in.org_id = current_user.org_id
depot = get_by_code_org_id(db_session=db_session,
code=depot_in.code,
org_id=current_user.org_id)
if depot:
raise HTTPException(status_code=400,
detail="The depot with this code already exists.")
depot = create(db_session=db_session, depot_in=depot_in)
return depot
def get_orgs(
db_session: Session = Depends(get_db),
current_user: DispatchUser = Depends(get_current_user),
):
"""
Retrieve a list of all jobs.
"""
data = get(db_session=db_session,
org_id=current_user.org_id,
org_code=None)
if data:
job_all_count = jobService.get_by_org_id_count(
db_session=db_session, org_id=current_user.org_id)
team_all_count = teamService.get_by_org_id_count(
db_session=db_session, org_id=current_user.org_id)
worker_all_count = workerService.get_by_org_id_count(
db_session=db_session, org_id=current_user.org_id)
data = OrganizationBaseRead(**data.__dict__)
data.worker_count = worker_all_count
data.team_count = team_all_count
data.job_count = job_all_count
return data
def create_org(
*,
db_session: Session = Depends(get_db),
org_in: OrganizationBase,
current_user: DispatchUser = Depends(get_current_user),
):
"""
Create a new org.
"""
if current_user.role == UserRoles.WORKER:
raise HTTPException(status_code=400, detail="No create permission")
org = get(db_session=db_session, org_code=org_in.code)
if org:
return update(db_session=db_session, org=org, org_in=org_in)
org_in_dict = org_in.dict()
org_in_dict['id'] = current_user.org_id
org_in_dict['max_nbr_jobs'] = 100
org_in_dict['max_nbr_workers'] = 10
org_in_dict['max_nbr_teams'] = 2
org = create(db_session=db_session, **org_in_dict)
return org
def __init__(self, org_code=None, team_id=None):
# Create the database connection.
self.db_session = get_schema_session(org_code)
self.cnx = self.db_session
self.db_schema = f"dispatch_organization_{org_code}"
self.org_id = None
if team_id is None:
# TODO In future, I get default from db
raise HTTPException(
status_code=400,
detail=
f"internal error: team_id can not be None, or is not in your organization.",
)
team = team_service.get(db_session=self.db_session, team_id=team_id)
if team is None:
raise HTTPException(
status_code=400,
detail=f"The team is not found in your organization.",
)
org = org_service.get(db_session=self.db_session, org_code=org_code)
if (org is None) or (org.id != team.org_id):
raise HTTPException(
status_code=400,
detail=f"The team is not in your organization ( { org_code}).",
)
self.team = team
self.team_id = team_id
self.team_code = team.code
self.org_code = org_code
self.org_id = org.id
self.workers_dict_by_id = {} # Dictionary of dict
self.workers_by_code_dict = {} # Dictionary of dict
self.workers_db_dict = {}
self.jobs_db_dict = {}
def create_item(*,
db_session: Session = Depends(get_db),
item_in: ItemCreate,
current_user: DispatchUser = Depends(get_current_user)):
"""
Create a new item contact.
"""
# limit max
org_data = orgService.get(db_session=db_session,
org_code=current_user.org_code)
if not org_data:
raise HTTPException(status_code=400, detail="org not exists")
# max_nbr_item = org_data.max_nbr_items
# job_all_count = get_by_org_id_count(db_session=db_session, org_id=current_user.org_id)
# if job_all_count >= max_nbr_item:
# raise HTTPException(status_code=400, detail="Item Reached the upper limit")
item_in.org_id = current_user.org_id
item = get_by_code(db_session=db_session, code=item_in.code)
if item:
raise HTTPException(status_code=400,
detail="The item with this code already exists.")
item = create(db_session=db_session, item_in=item_in)
return item
def update_job_no_token(
*,
db_session: Session = Depends(get_db),
job_id: str,
job_in: JobUpdate,
background_tasks: BackgroundTasks,
):
"""
Update an worker job.
"""
org_id = int(job_in.org_id)
org_obj = orgService.get(db_session=db_session, org_id=org_id)
job = get(db_session=db_session, job_id=job_id)
token = job_in.token
flag = check_edit_job_token(job.id, token)
if not flag:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
detail="Permission verification failed.")
if not job:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="The requested job does not exist.")
if job.planning_status == JobPlanningStatus.FINISHED:
raise HTTPException(status_code=404,
detail="Finish (F) job can not be updated.")
if job_in.requested_skills:
job_in.flex_form_data['requested_skills'] = job_in.requested_skills
if job_in.requested_items:
job_in.flex_form_data['requested_items'] = job_in.requested_items
if job_in.planning_status == JobPlanningStatus.FINISHED:
if job.planning_status == JobPlanningStatus.UNPLANNED:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Unplanned job can be changed to Finished (F).")
# I will deduct items from
item_list = job.flex_form_data.get("requested_items", [])
if len(item_list) > 0:
item_dict = from_item_list_to_dict(item_list)
depot = depot_service.get_default_depot(db_session=db_session)
depot_code = depot.code
for item_code in item_dict.keys():
item = item_service.get_by_code(db_session=db_session,
code=item_code)
inv = inventory_service.get_by_item_depot(
db_session=db_session,
item_id=item.id,
depot_id=depot.id,
org_id=org_id).first()
inv.allocated_qty -= item_dict[item_code]
if inv.allocated_qty < 0:
inv.curr_qty += inv.allocated_qty
inv.allocated_qty = 0
if inv.curr_qty < 0:
e_msg = f"Not enough inventory for item: {item_code}, depot: {depot_code}, org.id: {org_id}"
# log.error(e_msg)
raise HTTPException(status_code=404, detail=e_msg)
db_session.add(inv)
inventory_event_service.log(
db_session=db_session,
source="Web",
description=
f"Finished/Deducted {item_dict[item_code]} {item_code} from depot: {depot_code}",
item_code=item_code,
depot_code=depot_code,
item_id=item.id,
depot_id=depot.id)
db_session.commit()
# previous_job = JobRead.from_orm(job)
# NOTE: Order matters we have to get the previous state for change detection
job = update(db_session=db_session,
job=job,
job_in=job_in,
org_code=org_obj.code)
return job
def register_user(
req: Request,
user_in: UserRegister,
db_session: Session = Depends(get_db), #
):
# TODO
# if ENABLE_REGISTER != "yes":
# raise HTTPException(status_code=401, detail="Registration is disabled.")
# # check user is null
try:
if user_in.email:
# 正常新增
user_info = get_by_email(db_session=db_session,
email=user_in.email)
if user_info:
raise HTTPException(
status_code=400,
detail=f"User ({user_in.email}) already exists")
else:
raise HTTPException(status_code=400,
detail="Email can not be empty")
if user_in.org_code:
# check org table is null
# add org, org_user,user
org_data = org_service.get(db_session=db_session,
org_code=user_in.org_code)
if org_data is None:
org_id = SHORTUUID.random(length=9)
# add user
user_in.role = UserRoles.OWNER
user_in.is_org_owner = True
user_in.is_active = True
user_in.org_id = org_id
user_in.default_team_id = org_id
user = create(db_session=db_session, user_in=user_in)
# create org_user relationship
org_service.add_user(db_session=db_session,
organization_id=org_id,
dispatch_user_id=user.id,
role=user.role,
team_id=org_id)
org_in = OrganizationBase(
code=user_in.org_code,
id=org_id,
max_nbr_jobs=100,
max_nbr_workers=10,
max_nbr_teams=2,
team_flex_form_schema=team_flex_form_schema,
worker_flex_form_schema=worker_flex_form_schema,
job_flex_form_schema=job_flex_form_schema)
org_in_dict = org_in.dict()
org_in_dict['id'] = org_id
org_service.create(db_session=db_session, **org_in_dict)
return user
else:
if not org_data.public_registration:
raise HTTPException(
status_code=400,
detail="This organization already exists")
else:
# create invitation code dynamically by the team
user_in.id = SHORTUUID.random(length=9)
user_in.org_id = org_data.id
if user_in.role == UserRoles.WORKER:
# Requires activation.
user_in.is_active = False
elif user_in.role == UserRoles.CUSTOMER:
# Requires activation.
user_in.is_active = True
user = create(db_session=db_session, user_in=user_in)
# user_in.en_code = org_service.add_user(
# db_session=db_session,
# organization_id=org_data.id,
# dispatch_user_id=user_id,
# role=UserRoles.WORKER,
# team_id=user_in.default_team_id
# )
return user
if user_in.en_code:
# check org table have data
# check org_user table have data
# add user data
try:
de_code = decrypt(user_in.en_code)
except Exception:
raise HTTPException(
status_code=400,
detail=
"Please enter the correct organization Invitation code")
user_in.id = int(de_code.split("|")[0])
user_in.org_id = int(de_code.split("|")[1])
org_data = org_service.get(db_session=db_session,
org_id=user_in.org_id)
if not org_data:
raise HTTPException(status_code=401,
detail="The organization does not exist.")
org_user = get_org_user(db_session=db_session,
user_id=user_in.id,
org_id=user_in.org_id)
if not org_user:
raise HTTPException(status_code=401,
detail="User role does not exist")
user_in.org_code = org_data.code
user_in.org_id = org_data.id
user_in.default_team_id = org_user.team_id
user_in.role = org_user.role
user_in.is_active = True
user_in.is_org_owner = True if org_user.role == UserRoles.OWNER else False
user = create(db_session=db_session, user_in=user_in)
# Remove the record by changing id.
org_user.organization_id = 0 - org_user.organization_id
db_session.add(org_user)
db_session.commit()
return user
else:
raise HTTPException(
status_code=400,
detail="Please enter the correct organization Invitation code")
except Exception as e:
raise HTTPException(status_code=400,
detail=f"Registration Error: {e.detail}")
def create_worker(*,
db_session: Session = Depends(get_db),
worker_in: WorkerCreate,
current_user: DispatchUser = Depends(get_current_user)):
"""
Create a new worker contact.
"""
# limit max
org_data = orgService.get(db_session=db_session,
org_code=current_user.org_code)
if not org_data:
raise HTTPException(status_code=400, detail="org not exists")
max_nbr_worker = org_data.max_nbr_workers
if worker_in.skills:
worker_in.flex_form_data['skills'] = worker_in.skills
if worker_in.loaded_items:
worker_in.flex_form_data['loaded_items'] = worker_in.loaded_items
job_all_count = get_by_org_id_count(db_session=db_session,
org_id=current_user.org_id)
if job_all_count >= max_nbr_worker:
raise HTTPException(status_code=400,
detail="Worker Reached the upper limit")
worker_in.org_id = current_user.org_id
worker = get_by_code_org_id(db_session=db_session,
code=worker_in.code,
org_id=current_user.org_id)
team = team_service.get_by_code(db_session=db_session,
code=worker_in.team.code)
# use zulip
zulip_user_id = worker_in.flex_form_data.get("zulip_user_id", None)
result = None
zulip_dict = get_zulip_client_by_org_id(current_user.org_id)
if zulip_dict and zulip_user_id and worker_in.team.flex_form_data.get(
'use_zulip', False):
flag, worker_code = check_zulip_user_id(db_session=db_session,
zulip_user_id=zulip_user_id,
team_id=team.id)
if not flag:
raise HTTPException(
status_code=400,
detail=
f"The worker zulip_user_id already exists in {worker_code}")
zulip_core = zulip_dict['client']
result = zulip_core.update_add_subscribe_user_group(
worker_in,
org_code=current_user.org_code,
team_code=team.code,
flag=True)
if result and result['result'] != 'success':
raise HTTPException(status_code=400, detail=f"{result['msg']}")
# add worker
if worker:
raise HTTPException(status_code=400,
detail="The worker with this code already exists.")
worker = create(db_session=db_session, worker_in=worker_in)
# change to env
if current_user.org_code and team.id:
message_dict = transfrom_worker_data(worker, team)
post_worker_to_env(message_dict, current_user.org_code, team.id, False)
return worker
