def validate_multi_eng(user_content, checklist_content, newEL_content,
actualVfNameid):
query = "UPDATE ice_user_profile SET role_id=2 WHERE email = '" + \
str(newEL_content['email']) + "';"
DBGeneral.update_by_query(query)
FEWizard.invite_team_members_modal(newEL_content['email'])
# Fetch one AT&T user ID.
enguuid = DBGeneral.select_where("uuid", "ice_engagement",
"engagement_manual_id",
user_content['engagement_manual_id'],
1)
invitation_token = DBUser.select_invitation_token(
"invitation_token", "ice_invitation", "engagement_uuid", enguuid,
newEL_content['email'], 1)
URL = Constants.Default.InviteURL.Login.TEXT + invitation_token
FEGeneral.re_open(URL)
FEUser.login(newEL_content['email'],
Constants.Default.Password.TEXT,
expected_element=actualVfNameid)
Click.id(actualVfNameid, wait_for_page=True)
count = None
try:
session.ice_driver.find_element_by_id("checklist-" +
checklist_content['uuid'])
count += 1
except BaseException:
logger.debug("check list not visible for EL invited : " +
str(newEL_content['email']))
assertTrue(count is None)
query = "UPDATE ice_user_profile SET role_id=1 WHERE email = '" + \
str(newEL_content['email']) + "';"
DBGeneral.update_by_query(query)
def state_changed(identify_field, field_value, expected_state):
get_state = DBGeneral.select_where_order_by_desc(
"state", Constants.DBConstants.IceTables.CHECKLIST, identify_field,
field_value, "create_time")[0]
counter = 0
while get_state != expected_state and \
counter <= Constants.DBConstants.RETRIES_NUMBER:
time.sleep(session.wait_until_time_pause_long)
logger.debug(
"Checklist state not changed yet ," +
"expecting state: %s, current result: %s (attempt %s of %s)" %
(expected_state, get_state, counter,
Constants.DBConstants.RETRIES_NUMBER))
counter += 1
get_state = DBGeneral.select_where_order_by_desc(
"state", Constants.DBConstants.IceTables.CHECKLIST,
identify_field, field_value, "create_time")[0]
if get_state == expected_state:
logger.debug("Checklist state was successfully changed into: " +
expected_state + ", and was verified over the DB")
return expected_state
raise Exception(
"Expected checklist state never arrived " + expected_state,
get_state)
def remove_vfc(user_content):
vf_id = DBGeneral.select_where("uuid", "ice_vf", "name",
user_content['vfName'], 1)
djoni_uuid = None
counter = 0
while not djoni_uuid and counter <= Constants.DBConstants.\
RETRIES_NUMBER:
time.sleep(session.wait_until_time_pause_long)
djoni_uuid = DBGeneral.select_where_and("uuid", "ice_vfc", "vf_id",
vf_id, "name", "djoni", 1)
logger.debug("Checklist state not changed yet (%s of %s)" %
(counter, Constants.DBConstants.RETRIES_NUMBER))
counter += 1
logger.debug("VFC_UUID was successfully selecteded : " + djoni_uuid +
", and was verified over the DB")
Wait.text_by_id(Constants.Dashboard.DetailedView.VFC.ID + "djoni",
"djoni (loka)",
wait_for_page=True)
Wait.text_by_id(Constants.Dashboard.DetailedView.VFC.ID + "djoni2",
"djoni2 (loka2)",
wait_for_page=True)
Click.id(Constants.Dashboard.DetailedView.VFC.ID + "djoni",
wait_for_page=True)
Click.id(Constants.Dashboard.DetailedView.VFC.Remove.ID + djoni_uuid,
wait_for_page=True)
def get_not_seen_notifications_number_by_email(
user_email, is_negative=False):
user_id = DBGeneral.select_where_email(
"id", Constants.DBConstants.IceTables.USER_PROFILE, user_email)
notifications_number = DBGeneral.select_where_and(
Constants.DBConstants.Queries.COUNT,
Constants.DBConstants.IceTables.NOTIFICATION,
"user_id",
user_id,
"is_read",
"False",
1)
if is_negative:
counter = 0
while notifications_number != "0" and counter <= Constants.\
Dashboard.Avatar.Notifications.Count.RETRIES_NUMBER:
notifications_number = DBGeneral.select_where_and(
Constants.DBConstants.Queries.COUNT,
Constants.DBConstants.IceTables.NOTIFICATION,
"user_id",
user_id,
"is_read",
"False",
1)
time.sleep(1)
counter += 1
return notifications_number
def rollback_for_el_not_in_engagement():
query_str = "select uuid from ice_user_profile where full_name = " +\
"'el_for_test';"
user_uuid = DBGeneral.select_query(query_str)
fullName = DBBridge.helper_rand_string("randomString")
updatequery = "UPDATE ice_user_profile SET role_id=1,full_name " +\
"= '%s' WHERE uuid = '%s' ;" % (fullName, user_uuid)
DBGeneral.update_query(updatequery)
def validate_feedback(description, user_email):
query = "SELECT user_id FROM ice_feedback where " +\
"description = '{desc}'".format(
desc=description)
feedback_user_uuid = DBGeneral.select_query(query)
query = "SELECT id FROM ice_user_profile where " +\
"email = '{email}'".format(
email=user_email)
user_uuid = DBGeneral.select_query(query)
Helper.internal_assert(user_uuid, feedback_user_uuid)
def get_eng_lead_email_per_enguuid(enguuid):
reviewer_id = DBGeneral.select_where(
"reviewer_id",
Constants.DBConstants.IceTables.ENGAGEMENT,
"uuid",
enguuid,
1)
engLeadEmail = DBGeneral.select_where(
"email", Constants.DBConstants.IceTables.USER_PROFILE, "id",
reviewer_id, 1)
return engLeadEmail
def set_new_temp_password(email):
encodePass = DBGeneral.select_where_email(
"password", "auth_user", Constants.Users.Admin.EMAIL)
# Fetch one user ID.
index = DBGeneral.select_where_email("id", "auth_user", email)
DBGeneral.update_where(
"ice_custom_user",
"temp_password",
encodePass,
"user_ptr_id",
index)
def add_admin_to_eng_team(eng_uuid):
admin_db_id = DBGeneral.select_where(
'id',
Constants.DBConstants.IceTables.USER_PROFILE,
'email',
Constants.Users.Admin.EMAIL,
1)
queryStr = "INSERT INTO public.ice_engagement_engagement_team" +\
"(engagement_id, iceuserprofile_id) VALUES ('%s', '%s');" % (
eng_uuid, admin_db_id)
logger.debug("add_admin_to_eng_team Query: %s" % queryStr)
DBGeneral.insert_query(queryStr)
def select_engagment_uuid_by_vf_name(vfName):
engagement_id = DBGeneral.select_where(
"engagement_id", "ice_vf", "name", vfName, 1)
engagement_manual_id = DBGeneral.select_where(
"engagement_manual_id", "ice_engagement", "uuid", engagement_id, 1)
enguuid = DBGeneral.select_where(
"uuid",
"ice_engagement",
"engagement_manual_id",
engagement_manual_id,
1)
return enguuid
def set_engagement_peer_reviewer(engagement_uuid, email):
user_uuid = DBUser.select_user_uuid(email)
update_query = "UPDATE ice_user_profile SET role_id=2 WHERE " +\
"uuid = '%s';" % user_uuid
DBGeneral.update_query(update_query)
user_id = DBGeneral.select_query(
"SELECT id FROM ice_user_profile WHERE uuid = '%s';" % user_uuid)
update_query = "UPDATE ice_engagement SET peer_reviewer_id=%s " +\
"WHERE uuid = '%s';" % (
user_id, engagement_uuid)
DBGeneral.update_query(update_query)
def create_new_checklist(newObj):
try:
newObjWithChecklist = None
vfName = newObj[0]
uuid = newObj[1]
inviteEmail = newObj[2]
# Fetch one AT&T user ID.
vfuuid = DBGeneral.select_where("uuid", "ice_vf", "name", vfName,
1)
engagement_id = DBVirtualFunction.select_eng_uuid(vfName)
engLeadEmail = DBUser.select_el_email(vfName)
logger.debug("EL email: " + engLeadEmail)
engagement_manual_id = DBGeneral.select_where(
"engagement_manual_id", "ice_engagement", "uuid",
engagement_id, 1)
# Click on all default next steps
myVfName = engagement_manual_id + ": " + vfName
actualVfNameid = "clickable-" + myVfName
actualVfName = Get.by_id(actualVfNameid)
Helper.internal_assert(myVfName, actualVfName)
# NEXT STEP ID
Click.id(actualVfNameid, wait_for_page=True)
FEOverview.complete_defaults_nextsteps(engagement_id)
inviterURL = Constants.Default.InviteURL.Signup.TEXT + \
vfuuid + "&inviter_uuid=" + uuid + "&email=" + inviteEmail
# time.sleep(2)
FEGeneral.re_open(inviterURL)
FEGeneral.form_validate_email(inviteEmail)
# Login with EL role
FEGeneral.re_open(Constants.Default.LoginURL.TEXT)
FEUser.login(engLeadEmail, Constants.Default.Password.TEXT)
Wait.id(Constants.Dashboard.Statuses.Title.ID)
Wait.id(engagement_manual_id) # cheklist
# VALIDATE SCROLLING
actualVfName = Get.by_id(actualVfNameid)
myVfName = engagement_manual_id + ": " + vfName
# Wait.id(actualVfNameid)
Wait.id(engagement_manual_id, wait_for_page=True)
Click.id(actualVfNameid, wait_for_page=True)
# Create new checklist
checklistName = FEChecklist.create_checklist(
engagement_id, vfName, actualVfName, engagement_manual_id)
checklistUuid = DBGeneral.select_where("uuid", "ice_checklist",
"name", checklistName, 1)
newObjWithChecklist = [
checklistUuid, engLeadEmail, engagement_manual_id,
actualVfNameid, myVfName, checklistName
]
return newObjWithChecklist
# If failed - count the failure and add the error to list of errors.
except Exception as e:
errorMsg = "Failed to create checklist." + str(e)
raise Exception(errorMsg, "create_new_checklist")
def update_to_el_not_in_engagement():
query_str = "select uuid from ice_user_profile where role_id = 1 ;"
user_uuid = DBGeneral.select_query(query_str)
updatequery = "UPDATE ice_user_profile SET role_id=2 ,full_name" +\
" = 'el_for_test' WHERE uuid = '%s' ;" % (
user_uuid)
DBGeneral.update_query(updatequery)
updatequery = "UPDATE ice_user_profile SET role_id=2 WHERE " +\
"full_name = '%s' ;" % (
'el_for_test')
DBGeneral.update_query(updatequery)
return 'el_for_test'
def select_user_profile_property(user_email, property_name):
return DBGeneral.select_where(
property_name,
"ice_user_profile",
"email",
user_email,
1)
def select_next_step_description(next_step_uuid):
return DBGeneral.select_where(
"description",
"ice_next_step",
"uuid",
next_step_uuid,
1)
def get_engagement():
"""Use this function instead of creating a new """ +\
"""engagement where no need to"""
queryStr = "SELECT DISTINCT ice_engagement.uuid, " +\
"engagement_manual_id, ice_vf.name, ice_user_profile.full_name, \
ice_user_profile.email, reviewer_table.full_name, " +\
"reviewer_table.email, \
ice_deployment_target.version, ice_ecomp_release.name \
FROM ice_engagement LEFT JOIN ice_vf ON engagement_id " +\
"= ice_engagement.uuid \
LEFT JOIN ice_user_profile reviewer_table ON " +\
"reviewer_table.id = ice_engagement.reviewer_id \
LEFT JOIN ice_user_profile ON ice_user_profile.id = " +\
"ice_engagement.peer_reviewer_id \
LEFT JOIN ice_deployment_target ON " +\
"ice_deployment_target.uuid = " +\
"ice_vf.deployment_target_id \
LEFT JOIN ice_ecomp_release ON " +\
"ice_ecomp_release.uuid = ice_vf.ecomp_release_id \
WHERE ice_user_profile.id IS NOT NULL LIMIT 1;"
list_of_values = DBGeneral.select_query(queryStr, return_type="list")
list_of_keys = [
"engagement_uuid",
"engagement_manual_id",
"vfName",
"pr_name",
"pr_email",
"el_name",
"el_email",
"target_aic",
"ecomp_release"]
return dict(zip(list_of_keys, list_of_values))
def select_user_engagements_by_stage(stage, engLeadID):
try:
dbConn = psycopg2.connect(
DBGeneral.return_db_native_connection('em_db'))
dbConn = dbConn
cur = dbConn.cursor()
queryStr = "select count(*) from ice_engagement INNER JOIN " +\
"ice_engagement_engagement_team ON " +\
"ice_engagement_engagement_team.engagement_id= " +\
"ice_engagement.uuid Where " +\
"(ice_engagement.engagement_stage " +\
"= '%s') and " % stage +\
"(ice_engagement_engagement_team.iceuserprofile_id = " +\
"%s );" % engLeadID
logger.debug("Query : " + queryStr)
cur.execute(queryStr)
result = cur.fetchall()
dbConn.close()
logger.debug("Query result: " + str(result))
logger.debug(result[0][0])
return result[0][0]
# If failed - count the failure and add the error to list of errors.
except BaseException:
errorMsg = "select_user_engagements_by_stage FAILED "
raise Exception(errorMsg, "select_user_engagements_by_stage")
def select_recent_vf_of_user(user_uuid, fetchNum):
try:
dbConn = psycopg2.connect(
DBGeneral.return_db_native_connection('em_db'))
dbConn = dbConn
cur = dbConn.cursor()
queryStr = "SELECT vf_id FROM public.ice_recent_engagement " +\
"where user_uuid = '%s' order by last_update " % user_uuid +\
"desc limit 20;"
logger.debug("Query : " + queryStr)
cur.execute(queryStr)
if (fetchNum == 0):
result = str(cur.fetchall())
elif (fetchNum == 1):
result = str(cur.fetchone())
if(result.find("',)") != -1): # formatting strings e.g uuid
result = result.partition('\'')[-1].rpartition('\'')[0]
elif(result.find(",)") != -1): # formatting ints e.g id
result = result.partition('(')[-1].rpartition(',')[0]
dbConn.close()
logger.debug("Query result: " + str(result))
return result
# If failed - count the failure and add the error to list of errors.
except BaseException:
errorMsg = "select_where FAILED "
raise Exception(errorMsg, "select_where")
def insert_ecomp_release(uuid, name, ui_visibility="TRUE"):
try:
queryTableName = "ice_ecomp_release"
# Connect to General 'default'.
dbConn = psycopg2.connect(
DBGeneral.return_db_native_connection("em_db"))
dbConn = dbConn
cur = dbConn.cursor()
logger.debug("DATABASE_TYPE: " + settings.DATABASE_TYPE)
except Exception as e:
errorMsg = "Failed to create connection to General: " + str(e)
raise Exception(errorMsg)
try:
logger.debug("DATABASE_TYPE: " + settings.DATABASE_TYPE)
# Create INSERT query.
queryStr = "INSERT INTO %s " % queryTableName +\
"(""uuid, name, weight, ui_visibility"") VALUES " +\
"('%s', '%s', " % (uuid, name) +\
"'%s', '%s');" % (0, ui_visibility)
logger.debug("Query: " + queryStr)
cur.execute(queryStr) # Execute query.
dbConn.commit()
logger.debug("Test results are in General now.")
except Exception as e:
errorMsg = "Failed to insert ECOMP release to General:" + str(e)
raise Exception(errorMsg)
dbConn.close()
def select_where_pr_state(queryColumnName, queryTableName,
whereParametrType, whereParametrValue, fetchNum):
try:
dbConn = psycopg2.connect(
DBGeneral.return_db_native_connection('em_db'))
dbConn = dbConn
cur = dbConn.cursor()
queryStr = \
"select %s from %s " % (queryColumnName, queryTableName) +\
"Where %s = '%s' and " % (
whereParametrType, whereParametrValue) +\
"state = 'peer_review';"
logger.debug("Query : " + queryStr)
cur.execute(queryStr)
if (fetchNum == 0):
result = str(cur.fetchall())
elif (fetchNum == 1):
result = str(cur.fetchone())
if (result.find("',)") != -1): # formatting strings e.g uuid
result = result.partition('\'')[-1].rpartition('\'')[0]
elif (result.find(",)") != -1): # formatting ints e.g id
result = result.partition('(')[-1].rpartition(',')[0]
dbConn.close()
if result is None:
errorMsg = "select_where_pr_state FAILED "
logger.error(errorMsg)
raise
logger.debug("Query result: " + str(result))
return result
# If failed - count the failure and add the error to list of errors.
except BaseException:
errorMsg = "select_where FAILED "
raise Exception(errorMsg, "select_where")
def delete_ecomp_release(uuid, name):
try:
queryTableName = "ice_ecomp_release"
# Connect to General 'default'.
dbConn = psycopg2.connect(
DBGeneral.return_db_native_connection("em_db"))
dbConn = dbConn
cur = dbConn.cursor()
except Exception as e:
errorMsg = "Failed to create connection to DBGeneral.because :" + \
str(e)
raise Exception(errorMsg)
try:
# Create INSERT query.
queryStr = "DELETE FROM %s WHERE uuid = '%s';" % (
queryTableName, uuid)
logger.debug("Query: " + queryStr)
cur.execute(queryStr) # Execute query.
dbConn.commit()
logger.debug("Test results are in General now.")
except Exception as e:
errorMsg = "Failed to delete ECOMP release from General ." +\
" because :" + \
str(e)
raise Exception(errorMsg)
raise
dbConn.close()
def invite_team_member(user_content):
r1 = None
postURL = settings.ICE_EM_URL + '/v1/engmgr/invite-team-members/'
logger.debug("Post invite user URL: " + postURL)
headers = dict() # Create header for post request.
headers['Content-type'] = 'application/json'
headers['Authorization'] = user_content['session_token']
data = dict() # Create JSON data for post request.
data['email'] = Helper.rand_string(
'randomString') + "@" + ServiceProvider.email
data['eng_uuid'] = user_content['engagement_uuid']
list_data = []
list_data.append(data)
try:
r1 = requests.post(postURL,
json=list_data,
headers=headers,
verify=False)
Helper.internal_assert_boolean(r1.status_code, 200)
logger.debug("Invite sent successfully to email " + data['email'])
invite_token = DBGeneral.select_where_and(
"invitation_token", "ice_invitation", "email", data['email'],
"engagement_uuid", user_content['engagement_uuid'], 1)
invite_url = settings.ICE_PORTAL_URL + "/#/signUp?invitation=" + \
invite_token + "&email=" + data['email']
logger.debug("Invitation URL is: " + invite_url)
return data['email'], invite_token, invite_url
except BaseException:
if r1 is None:
logger.error("Failed to invite team member.")
else:
logger.error("POST request failed to invite team member, " +
"see response >>> %s %s" %
(r1.status_code, r1.reason))
raise
def select_el_not_in_engagement(el_name, pr_name):
query_str = "select full_name from ice_user_profile where " +\
"role_id = 2 and full_name != '%s' and full_name != '%s';" % (
el_name, pr_name)
new_user = DBGeneral.select_query(query_str)
if new_user == 'None':
new_user = DBUser.update_to_el_not_in_engagement()
return new_user
def create_editing_cl_template_if_not_exist():
template_id = DBGeneral.select_query(
("""SELECT uuid FROM public.ice_checklist_template """ +
"""where name = '{s}'""").format(
s=Constants.Dashboard.LeftPanel.EditChecklistTemplate.HEAT))
if template_id == 'None':
DBChecklist.create_default_heat_teampleate()
session.createTemplatecount = True
def update_decisions(checklistUuid, checklistName):
checklistTempid = DBGeneral.select_where("template_id",
"ice_checklist", "name",
checklistName, 1)
checklistLineItems = DBGeneral.select_where_and(
"uuid", "ice_checklist_line_item", "line_type", "auto",
"template_id", checklistTempid, 0)
for lineItem in checklistLineItems:
setParametrType2 = "peer_review_value"
setParametrValue2 = "approved"
whereParametrType2 = "lineitem_id"
whereParametrValue2 = lineItem
DBGeneral.update_where_and("ice_checklist_decision",
"review_value", checklistUuid,
"approved", "checklist_id",
setParametrType2, setParametrValue2,
whereParametrType2, whereParametrValue2)
def checkChecklistIsUpdated():
query = "select uuid from ice_checklist_section where template_id " +\
"in (select template_id from ice_checklist_template where " +\
"name='{template_name}') and name='{section_name}'".format(
template_name=Constants.Dashboard.LeftPanel.
EditChecklistTemplate.HEAT, section_name=Constants.
Dashboard.LeftPanel.EditChecklistTemplate.HEAT)
return DBGeneral.select_query(query)
def click_on_checklist(user_content, checklistName, checklist_uuid=None):
FEOverview.click_on_vf(user_content)
if checklist_uuid is None:
checklist_uuid = DBGeneral.select_where_not_and_order_by_desc(
'uuid', Constants.DBConstants.IceTables.CHECKLIST, 'name',
checklistName, 'state', Constants.ChecklistStates.Archive.TEXT,
'create_time')[0]
Click.id("checklist-" + checklist_uuid, True)
def validations_for_user2(user_content, inviteEmail, vflist):
# Fetch one AT&T user ID.
engagement_id = DBGeneral.select_where("engagement_id", "ice_vf",
"name", vflist[0], 1)
engagement_manual_id = DBGeneral.select_where("engagement_manual_id",
"ice_engagement", "uuid",
engagement_id, 1)
engLeadEmail = DBUser.select_el_email(vflist[0])
user_content['engagement_uuid'] = engagement_id
user_content['el_email'] = engLeadEmail
uuid = DBGeneral.select_where_email("uuid", "ice_user_profile",
user_content['email'])
sponsor = [
ServiceProvider.MainServiceProvider, 'aaaaaa', inviteEmail,
'3058000000'
]
invitation_token = DBUser.select_invitation_token(
"invitation_token", "ice_invitation", "engagement_uuid",
engagement_id, inviteEmail, 1)
signUpURLforContact = DBUser.get_contact_signup_url(
invitation_token, uuid, sponsor[2], sponsor[1], sponsor[3],
sponsor[0])
APIUser.signup_invited_user(sponsor[0],
inviteEmail,
invitation_token,
signUpURLforContact,
user_content,
True,
wait_for_gitlab=False)
activationUrl2 = DBUser.get_activation_url(sponsor[2])
FEGeneral.re_open(activationUrl2) # Login with 2nd user #
engName = engagement_manual_id + ": " + vflist[0]
title_id = "clickable-" + engName
FEUser.login(inviteEmail, Constants.Default.Password.TEXT, title_id)
for vfName in vflist:
# Fetch one AT&T user ID.
engagement_id = DBGeneral.select_where("engagement_id", "ice_vf",
"name", vfName, 1)
engagement_manual_id = DBGeneral.select_where(
"engagement_manual_id", "ice_engagement", "uuid",
engagement_id, 1)
engName = engagement_manual_id + ": " + vfName
vf_left_nav_id = "clickable-" + engName
Click.id(vf_left_nav_id, wait_for_page=True)
