async def enable(project: str, id: str, enable: bool):
logging.info(">>> " + __name__ + ":enable")
collection = get_collection(DOCTYPE_PROJECT)
rs = await collection.find_one_and_update(
{
"_id": ObjectId(project),
"modules": {
"$elemMatch": {
"ref": id
}
}
}, {
"$set": {
"modules.$.enabled": enable,
"updatedAt": datetime.utcnow()
}
}, {
"_id": False,
"modules": {
"$elemMatch": {
"ref": id
}
}
},
return_document=ReturnDocument.AFTER)
if rs == None:
raise_not_found()
if rs and rs["modules"] and len(rs["modules"]) > 0:
return rs["modules"][0]
raise_server_error()
async def create_doc(license: str, projectId: str, personaId: str,
fullname: str) -> GPQEvidence:
logging.info(">>> " + __name__ + ":create_doc")
# Check item numbers from project
# Assume it is 30
items = 30
# Per item = 3 minutes
maxTime = items * 3 * 60 * 1000
seqs = [i for i in range(1, items + 1)]
shuffle(seqs)
strSeqs = ' '.join(map(str, seqs))
logging.info(strSeqs)
model = GPQEvidenceCreate(license=license,
projectId=projectId,
personaId=personaId,
fullname=fullname,
items=items,
maxTime=maxTime,
sequence=strSeqs)
props = fields_in_create(model)
try:
collection = get_collection(DOCTYPE_EV_GPQ)
rs = await collection.insert_one(props)
if rs.inserted_id:
return await collection.find_one({"_id": rs.inserted_id})
except Exception as e:
raise_server_error(str(e.detail))
async def insert(
license: str,
creator: str,
data: ProjectCreate,
client: str = None,
contract: str = None
):
logging.info(">>> " + __name__ + ":insert")
logging.info(data)
# Project otomatis memiliki seluruh modul yang tersedia
aces_modules = await find_project_modules()
logging.info(aces_modules)
try:
project = ProjectInDB(
**data.dict(),
license=license,
clientId=client,
contractId=contract,
# admin=creator,
createdBy=creator,
modules=aces_modules,
)
logging.info("======")
logging.info(project)
props = fields_in_create(project)
collection = get_collection(DOCTYPE_PROJECT)
rs = await collection.insert_one(props)
if rs.inserted_id:
return await collection.find_one({"_id": rs.inserted_id})
except Exception as e:
raise_server_error(str(e))
async def update_one(project: str, id: str, data: ProjectModuleUpdate):
logging.info(">>> " + __name__ + ":update_one")
props = {"updatedAt": datetime.utcnow()}
if data.title:
props["modules.$.title"] = data.title
if data.description:
props["modules.$.description"] = data.description
collection = get_collection(DOCTYPE_PROJECT)
rs = await collection.find_one_and_update(
{
"_id": ObjectId(project),
"modules": {
"$elemMatch": {
"ref": id
}
}
}, {"$set": props}, {
"_id": False,
"modules": {
"$elemMatch": {
"ref": id
}
}
},
return_document=ReturnDocument.AFTER)
if rs == None:
raise_not_found()
if rs and rs["modules"] and len(rs["modules"]) > 0:
return rs["modules"][0]
raise_server_error()
async def delete(slug: str, id: str):
logging.info(">>> " + __name__ + ":delete")
collection = get_collection(DOCUMENT_TYPE)
seek = {"license": slug, "_id": ObjectId(id)}
client = await collection.find_one_and_delete(seek, {"_id": True})
if client:
return {"message": "Client deleted."}
raise_server_error(ERROR_MONGODB_DELETE)
async def insert(data: ModuleCreate):
try:
props = fields_in_create(data)
collection = get_collection(DOCTYPE_MODULE)
rs = await collection.insert_one(props)
if rs.inserted_id:
return await collection.find_one({"_id": rs.inserted_id})
except Exception as e:
raise_server_error(str(e))
async def delete(id: str):
try:
collection = get_collection(DOCTYPE_MODULE)
module = await collection.find_one_and_delete({"_id": ObjectId(id)},
{"_id": True})
if module:
return {"message": "Module has been deleted."}
except Exception as e:
raise_server_error(str(e))
async def delete_one(project: str, search: str):
try:
collection = get_collection(DOCTYPE_PROJECT_MEMBER)
seek = seek_by_search(project, search)
member = await collection.find_one_and_delete(seek, {"_id": True})
if member:
return {"message": "Member has been deleted."}
except Exception as e:
raise_server_error(str(e))
async def insert(slug: str, client: str, data: ContractCreate):
try:
contract = ContractInDB(**data.dict(), license=slug, clientId=client)
props = fields_in_create(contract)
collection = get_collection(DOCTYPE_CONTRACT)
rs = await collection.insert_one(props)
if rs.inserted_id:
return await collection.find_one({"_id": rs.inserted_id})
except Exception as e:
raise_server_error(str(e))
async def delete(license: str, id: str):
try:
collection = get_collection(DOCTYPE_PROJECT)
project = await collection.find_one_and_delete(
{"_id": ObjectId(id), "license": license},
{"_id": True}
)
if project:
return {"message": "Project has been deleted."}
except Exception as e:
raise_server_error(str(e))
async def update(id: str, data: ModuleUpdate):
try:
props = delete_empty_keys(data)
collection = get_collection(DOCTYPE_MODULE)
module = await collection.find_one_and_update(
{"_id": ObjectId(id)}, {"$set": fields_in_update(props)},
return_document=ReturnDocument.AFTER)
if module:
return module
except Exception as e:
raise_server_error(str(e))
async def insert(slug: str, data: ClientCreate):
logging.info(">>> " + __name__ + ":insert")
collection = get_collection(DOCUMENT_TYPE)
client = ClientWithLicense(**data.dict(), license=slug)
props = fields_in_create(client)
try:
rs = await collection.insert_one(props)
if rs.inserted_id:
client = await collection.find_one({"_id": rs.inserted_id})
return client
except Exception as e:
raise_server_error(str(e))
async def delete(slug: str, id: str):
try:
collection = get_collection(DOCTYPE_CONTRACT)
contract = await collection.find_one_and_delete(
{
"_id": ObjectId(id),
"license": slug
}, {"_id": True})
if contract:
return {"message": "Contract has been deleted."}
except Exception as e:
raise_server_error(str(e))
async def update(license: str, id: str, data: ProjectUpdate):
try:
props = delete_empty_keys(data)
collection = get_collection(DOCTYPE_PROJECT)
project = await collection.find_one_and_update(
{"_id": ObjectId(id), "license": license},
{"$set": fields_in_update(props)},
return_document=ReturnDocument.AFTER
)
if project:
return project
except Exception as e:
raise_server_error(str(e))
async def insert_one(data: LicenseCreate):
logging.info(">>> " + __name__ + ":insert_one")
collection = get_collection(DOCUMENT_TYPE)
props = fields_in_create(data)
logging.info(props)
try:
rs = await collection.insert_one(props)
if rs.inserted_id:
license = await collection.find_one({"_id": rs.inserted_id})
return license
except Exception as e:
logging.info(e)
raise_server_error(str(e))
async def update_one(project: str, search: str, data: PersonaUpdate):
logging.info(">>> " + __name__ + ":update_one")
try:
props = delete_empty_keys(data)
collection = get_collection(DOCTYPE_PERSONA)
seek = seek_by_search(project, search)
persona = await collection.find_one_and_update(
seek, {"$set": fields_in_update(props)},
return_document=ReturnDocument.AFTER)
if persona:
return persona
except Exception as e:
raise_server_error(str(e))
async def update(slug: str, id: str, data: ClientUpdate):
logging.info(">>> " + __name__ + ":update")
props = delete_empty_keys(data)
if len(props) == 0:
raise_bad_request("No data supplied.")
collection = get_collection(DOCUMENT_TYPE)
seek = {"license": slug, "_id": ObjectId(id)}
client = await collection.find_one_and_update(
seek, {"$set": fields_in_update(props)},
return_document=ReturnDocument.AFTER)
if client:
return client
raise_server_error(ERROR_MONGODB_UPDATE)
async def update_module(license: str, id: str, module: str, data: ModuleInfo):
try:
collection = get_collection(DOCTYPE_PROJECT)
update = await collection.find_one_and_update(
{"_id": ObjectId(id), "modules": {"$elemMatch": {"oid": module}}},
{"$set": {
"modules.$.title": data.title,
"modules.$.description": data.description
}},
{"_id": False, "modules": {"$elemMatch": {"oid": module}}},
return_document=ReturnDocument.AFTER
)
if update and len(update["modules"]) > 0:
return update["modules"][0]
except Exception as e:
raise_server_error(str(e))
async def o_insert(license: str, project: str, data: PersonaCreate):
hashed_password = get_password_hash(data.password)
model = PersonaInDB(**data.dict(),
license=license,
projectId=project,
hashed_password=hashed_password)
props = fields_in_create(model)
try:
collection = get_collection(DOCTYPE_PERSONA)
rs = await collection.insert_one(props)
if rs.inserted_id:
member = await collection.find_one({"_id": rs.inserted_id})
return member
except Exception as e:
logging.info(e)
raise_server_error(str(e))
async def insert(project: str, data: MemberCreate):
fpwd = create_fpwd(data.username)
hashed_password = get_password_hash(fpwd)
model = MemberInDB(**data.dict(),
projectId=project,
hashed_password=hashed_password)
props = fields_in_create(model)
props["xfpwd"] = fpwd[::-1]
try:
collection = get_collection(DOCTYPE_PROJECT_MEMBER)
rs = await collection.insert_one(props)
if rs.inserted_id:
member = await collection.find_one({"_id": rs.inserted_id})
return member
except Exception as e:
logging.info(e)
raise_server_error(str(e))
async def add_modules(license: str, id: str, module_ids: List[str]):
# modules => module str ids
modules = await find_modules(module_ids)
try:
collection = get_collection(DOCTYPE_PROJECT)
rs = await collection.find_one_and_update(
{"_id": ObjectId(id), "license": license},
{"$set": {"modules": modules}},
{"_id": False, "modules": True},
return_document=ReturnDocument.AFTER
)
logging.info(rs)
if rs and rs["modules"]:
return rs["modules"]
except Exception as e:
raise_server_error(str(e))
async def insert_one(license: str, data: UserCreate, license_owner: bool):
logging.info(">>> " + __name__ + ":insert_one")
collection = get_collection(DOCUMENT_TYPE)
fpwd = create_fpwd(data.username)
hashed_password = get_password_hash(fpwd)
model = UserSave(**data.dict(),
license=license,
hashed_password=hashed_password)
props = fields_in_create(model)
props["xfpwd"] = fpwd[::-1]
try:
rs = await collection.insert_one(props)
if rs.inserted_id:
user = await collection.find_one({"_id": rs.inserted_id})
return user
except Exception as e:
logging.info(e)
raise_server_error(str(e))
async def delete(term: str):
logging.info(">>> " + __name__ + ":delete")
collection = get_collection(DOCUMENT_TYPE)
seek = seek_by_term(term)
found = await collection.find_one_and_delete(seek, {"_id": True})
logging.info(found)
message = {"message": "User deleted"}
return message if found else raise_server_error(ERROR_MONGODB_DELETE)
async def set_simulations(project: str, search: str, sims: List[str]):
logging.info(">>> " + __name__ + ":set_simulations")
try:
collection = get_collection(DOCTYPE_PERSONA)
seek = seek_by_search(project, search)
persona = await collection.find_one_and_update(
seek,
{
"$set": {
"simulations": sims,
# "nextSim": sims[0],
"updatedAt": datetime.utcnow()
}
},
return_document=ReturnDocument.AFTER)
if persona:
return persona
except Exception as e:
raise_server_error(str(e))
async def start(projectId: str, personaId: str) -> Any:
logging.info(">>> " + __name__ + ":start")
try:
collection = get_collection(DOCTYPE_EV_GPQ)
ts = round(time() * 1000)
now = datetime.utcnow()
props = {"started": ts, "touched": ts, "updatedAt": now}
rs = await collection.find_one_and_update(
{
"projectId": projectId,
"personaId": personaId
}, {"$set": props}, {
"_id": 0,
"touched": 1
},
return_document=ReturnDocument.AFTER)
logging.info(rs)
return {"touched": rs["touched"], "next": 1}
except Exception as e:
raise_server_error(str(e))
async def insert_one(data: UserCreate):
logging.info(">>> " + __name__ + ":insert_one")
# Check license
valid = await is_license_valid(data.license)
if not valid:
raise_bad_request("License is not valid")
collection = get_collection(DOCUMENT_TYPE)
hashed_password = get_password_hash(data.password)
model = UserInDB(**data.dict(), hashed_password=hashed_password)
props = fields_in_create(model)
try:
rs = await collection.insert_one(props)
if rs.inserted_id:
user = await collection.find_one({"_id": rs.inserted_id})
return user
except Exception as e:
logging.info(e)
raise_server_error(str(e))
async def delete(license: str, search: str):
logging.info(">>> " + __name__ + ":delete")
collection = get_collection(DOCUMENT_TYPE)
seek = _seek_user(license, search)
# Do not delete license owner
seek["licenseContact"] = False
found = await collection.find_one_and_delete(seek, {"_id": True})
logging.info(found)
message = {"message": "User deleted"}
return message if found else raise_server_error(ERROR_MONGODB_DELETE)
async def update_row(projectId: str, personaId: str,
data: GPQRowUpdate) -> Any:
logging.info(">>> " + __name__ + ":update_row")
try:
collection = get_collection(DOCTYPE_EV_GPQ)
ts = round(time() * 1000)
now = datetime.utcnow()
elapsed = ts - data.lastTouch
model = GPQRow(**data.dict(), saved=ts, elapsed=ts - data.lastTouch)
props = {"done": data.seq, "touched": ts, "updatedAt": now}
if data.seq == data.total:
props["finished"] = ts
rs = await collection.find_one_and_update(
{
"projectId": projectId,
"personaId": personaId
}, {
"$set": props,
"$inc": {
"netTime": elapsed,
"remains": -elapsed
},
"$push": {
"rows": model.dict()
}
}, {
"_id": 0,
"touched": 1
},
return_document=ReturnDocument.AFTER)
logging.info(rs)
if data.seq < data.total:
return {"touched": rs["touched"], "next": data.seq + 1}
else:
return {"touched": rs["touched"], "next": None}
return rs
except Exception as e:
raise_server_error(str(e))
async def create_evidence_doc(
project: str,
personaId: str,
current_user: User = Depends(get_current_active_user)
) -> Any:
'''TEST'''
logging.info(">>> " + __name__ + ":create_evidence_doc")
projectId = project.strip().lower()
personaId = personaId.strip().lower()
# Check if persona exists
persona = await find_persona(projectId, personaId)
if not persona:
raise_not_found("Could not find persona.")
# Check if doc has been created before
doc = await crud.find_one(projectId, personaId)
if doc:
raise_server_error("Doc already exists in the sytem.")
fullname = persona["fullname"]
doc = await crud.create_doc(current_user.license, projectId, personaId, fullname)
return doc
async def update_one(term: str, data: BaseModel):
logging.info(">>> " + __name__ + ":update_one")
props = delete_empty_keys(data)
logging.info(props)
if len(props) == 0:
raise_bad_request("No data supplied.")
collection = get_collection(DOCUMENT_TYPE)
seek = seek_by_term(term)
rs = await collection.find_one_and_update(
seek, {"$set": fields_in_update(props)},
return_document=ReturnDocument.AFTER)
return rs if rs else raise_server_error(ERROR_MONGODB_UPDATE)
