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