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)