from ppms import ppms from ppms import ppms_cu from ppms.constants import * def get_pr_areas(mod_obj): pr_id_list = [] #get project ids of current module for da_obj in mod_obj.get_das(): if ppms_cu.Access.get_dt_id_of_ddi(da_obj) == "461": for mts_rec_obj in da_obj.get_records(): try: if mts_rec_obj.get_dtp_record().pr_id.get_value() not in pr_id_list: pr_id_list.append(mts_rec_obj.get_dtp_record().pr_id.get_value()) except: pass return pr_id_list def get_main_project(pr_id): pr_record = ppms.search_record(461, [pr_id], [1052], True) return pr_record.main_pr_id.get_value() def get_main_projects(mod_obj): main_projects = {} for pr_id in get_pr_areas(mod_obj): main_projects[get_main_project(pr_id)] = None return list(main_projects.keys()) def fill_temp_table(projects): MAX_VALUE = 1000 if ppms.db_get_auto_commit(): ppms.db_set_auto_commit(False) try: ppms.db_modify(ppms.get_query("000912")) # clear temp table except ppms.DatabaseError: pass # table doesn't exist, nothing to clear fill_temptable = ppms.get_query("000647") if len(projects) < MAX_VALUE: sql_string = fill_temptable.format("'" + "','".join(projects) + "'") else: sql_string = fill_temptable.format(ppms.get_query("000794")) ppms.db_modify(sql_string) def create_project_by_type(pr_type): ppms.echo_off() # Moduldaten mod_obj = ppms.get_target_module() # Module call settings module = ppms_cu.Helper.get_global_setting("create_project_by_type").alpha120.get_value() skip_macro = 0 forced_status = 2 dock_to = -1 dock_style = 3 dock_proportion = 0.05 foreground = 0 auto_hide = 1 target_obj = mod_obj.open_module(module, skip_macro, forced_status, dock_to, dock_style, dock_proportion, foreground, auto_hide) pr_id = target_obj.create_project_by_type(pr_type) target_obj.menu(49) #Call project call_project_by_type(pr_id) # pr_id = Internal Project ID that is opened (key field 001001 of DT 461) # focus_module_name = Python ID of the module that should be focused. Found in Module->Globale Einstellungen # disabled_subs = List of sub module IDs of module 0099JT that should NOT be loaded/displayed def call_project_by_type(pr_id, focus_module_name="", disabled_subs=""): # Moduldaten mod_obj = ppms.get_target_module() call = {} #Get project record rec461 = ppms.search_record(461, [pr_id], [1001, 1052, 1003, 23220, 264, 29448], True) project_type = rec461.pr_type.get_value() main_pr_id = rec461.main_pr_id.get_value() psp_code = rec461.psp_code.get_value() if not psp_code: psp_code = pr_id psp_code += "*" #Set @L variables mod_obj.set_new_L_var(30, [pr_id]) mod_obj.set_new_L_var(74, [main_pr_id]) mod_obj.set_new_L_var(70, [psp_code]) # project rights rights = get_project_rights(pr_id) #get global settings project_mod = ppms_cu.Helper.get_global_setting("project_startmodule").alpha120.get_value() idea_mod = ppms_cu.Helper.get_global_setting("idea_startmodule").alpha120.get_value() intention_mod = ppms_cu.Helper.get_global_setting("intention_startmodule").alpha120.get_value() request_mod = ppms_cu.Helper.get_global_setting("request_startmodule").alpha120.get_value() if rights == 2: #call dict for full edit mode call["0"] = project_mod call["3"] = project_mod call["4"] = project_mod call["5"] = project_mod call["6"] = project_mod call["1"] = intention_mod call["2"] = idea_mod call["10"] = request_mod elif rights == 1: #call dict for part edit mode call["0"] = project_mod call["3"] = project_mod call["4"] = project_mod call["5"] = project_mod call["6"] = project_mod call["1"] = intention_mod call["2"] = idea_mod call["10"] = request_mod elif rights == 0: #call dict for view mode call["0"] = project_mod call["3"] = project_mod call["4"] = project_mod call["5"] = project_mod call["6"] = project_mod call["1"] = intention_mod call["2"] = idea_mod call["10"] = request_mod # set focus on project module when project is already opened continue_process = True for panel_obj in ppms.get_panels(): if hasattr(panel_obj.get_main_module(), 'pr_id'): if panel_obj.get_main_module().pr_id == pr_id and panel_obj.get_main_module().get_id() == call[ str(project_type)]: panel_obj.get_main_module().focus() target_mod_obj = panel_obj.get_main_module() continue_process = False # call project workflow and define pr_id as attribute for each module object if continue_process == True: target_mod_obj = mod_obj.open_module(call[str(project_type)], disable_submodules=disabled_subs) [setattr(target_sub_mod_obj, 'pr_id', pr_id) for target_sub_mod_obj in target_mod_obj.get_panel().get_modules()] # focus module given in focus_module_name if focus_module_name != "": focus_mod_id = ppms_cu.Helper.get_global_setting(focus_module_name).alpha120.get_value() sub_mods = ppms_cu.Access(target_mod_obj).get_submodules() if focus_mod_id in sub_mods.keys(): sub_mods[focus_mod_id].focus() return target_mod_obj def get_project_rights(pr_id): """ This function returns the rights of the current user in a project mpm values 0 - normal user 1 - multi project manager 2 - portfoliomanager 3 - multi request manager 4 - multi project manager AND multi request manager right values 0 - Viewing mode e.g. watcher 1 - Partyly edit mode e.g. project manager 2 - Full edit mode e.g. multi-project manager """ user = ppms.uvar_get("@1") rights = 0 # get project record rec461 = ppms.search_record(461, [pr_id], [1001, 1052, 1003, 23220, 264, 29448], True) pr_type = rec461.pr_type.get_value() # case: pr type request if pr_type == 10 and current_user_is_multi_req_manager() == True: rights = 2 # case: other pr types elif pr_type != 10 and current_user_is_mpm() == True: rights = 2 else: sel_project_manager = ppms.db_select(ppms.get_query("000338").format(pr_id, user))[0][0] sel_change_rights = ppms.db_select(ppms.get_query("000339").format(pr_id, user))[0][0] if sel_project_manager > 0 or sel_change_rights > 0: rights = 1 if ppms_cu.Helper.get_global_setting("show_rights_as_message").alpha120.get_value() == "1": ppms.ui_message_box(rights) return rights def exec_project_rights(mod_obj, right_setting): """ modify data area settings depending on right settings""" # Store the right_settings so mv switches can reapply them setattr(mod_obj, 'right_setting', right_setting) if mod_obj.get_id() != mod_obj.get_panel().get_main_module().get_id(): # Get list variables source from invoker list_vars_source = mod_obj.get_invoker_module().get_current_L_var() # Get current list variables for key, value in list_vars_source.items(): try: mod_obj.set_current_L_var(key, value) except: pass # get current pr_id and calculate project rights if 30 in mod_obj.get_current_L_var().keys(): pr_id = mod_obj.get_current_L_var()[30][0] rights = get_project_rights(pr_id) else: rights = PROJECT_RIGHTS_FORBIDDEN # execute right settings """ - right_setting dictionary contains the right keys and a list of data areas that have to be set to output - if the content of a right key in right_setting is an empty list all data areas will be set to output """ execute_project_rights_customizing_changes(mod_obj=mod_obj, right_setting=right_setting, rights=rights) def execute_project_rights_customizing_changes(mod_obj, right_setting, rights): """Execute the customizing changes as defined by the right_setting""" # execute right settings # right_setting dictionary contains the right keys and a list of data areas that have to be set to output # if the content of a right key in right_setting is an empty list all data areas will be set to output ppms_cu_action = ppms_cu.Action(mod_obj) if rights in right_setting: ppms_cu_action.set_dataarea_to_output(mod_obj, right_setting[rights]) ppms_cu_action.unset_permission_create(mod_obj, right_setting[rights]) def get_report_rights(pr_id, report_id, user=ppms.uvar_get("@1")): # calculate report rights rec823 = ppms.search_record(823, [pr_id, report_id], [8821], True) if rec823: if rec823.report_approval_date.get_value() > 0: return 0 return get_project_rights(pr_id) def exec_report_rights(mod_obj, right_setting): """ modify data area settings depending on right settings""" pr_id = mod_obj.get_current_L_var()[30][0] try: report_id = mod_obj.get_current_L_var()[78][0] rights = get_report_rights(pr_id, report_id) except: rights = get_project_rights(pr_id) if rights in right_setting: #set data area settings ppms_cu_action = ppms_cu.Action(mod_obj) ppms_cu_action.set_dataarea_to_output(mod_obj, right_setting[rights]) ppms_cu_action.unset_permission_create(mod_obj, right_setting[rights]) def get_open_item_rights(pr_id, open_item_id, user=ppms.uvar_get("@1")): # calculate report rights pr_rights = get_project_rights(pr_id) if pr_rights == 0: count_open_items = ppms.db_select(ppms.get_query("000340").format(pr_id, open_item_id, user)) if count_open_items[0][0] > 0: return 1 else: return 0 return pr_rights def exec_open_item_rights(mod_obj, right_setting): """ modify data area settings depending on right settings""" l_var = mod_obj.get_current_L_var() if 30 in l_var and 76 in l_var: pr_id = l_var[30][0] open_item_id = l_var[76][0] rights = get_open_item_rights(pr_id, open_item_id) if rights < PROJECT_RIGHTS_PARTLY_EDIT: execute_project_rights_customizing_changes(mod_obj=mod_obj, right_setting=right_setting, rights=rights) else: exec_project_rights(mod_obj, right_setting) def evaluate_pr_lock_options(pr_id, di_obj=None, mode="get_value"): rec461 = ppms.search_record(461, [pr_id], [1001, 1052, 1003, 23220, 264, 29448, 59322], True) if not di_obj or not rec461: return 0 # read current_lock_value current_lock_value = rec461.tdi_bit_field_for_lock_options.get_value() # dataitems and its values for the calculation of bit values data_item_dict = {} data_item_dict["059323"] = 1 # psp_modification_locked # evaluate mode if mode == "set_value": inv_di_id = di_obj.get_id() new_di_value = di_obj.get_value() if inv_di_id in data_item_dict.keys(): if new_di_value == 1: current_lock_value += data_item_dict[inv_di_id] rec461.tdi_bit_field_for_lock_options.set_value(current_lock_value) return 1 else: current_lock_value -= data_item_dict[inv_di_id] rec461.tdi_bit_field_for_lock_options.set_value(current_lock_value) return 0 if mode == "get_value": if current_lock_value & data_item_dict[di_obj.get_id()]: return 1 return 0 def current_user_is_mpm(): if ppms.uvar_get("@31") in ["1", "4", "2"]: return True else: return False def current_user_is_multi_req_manager(): if ppms.uvar_get("@31") in ["3", "4"]: return True else: return False def get_project_is_main_project(pr_id): # compare if current project is main project rec461 = ppms.search_record(461, [pr_id], [1001, 1052, 1003], True) main_pr_id = rec461.main_pr_id.get_value() if pr_id == main_pr_id: return True else: return False def change_functional_key(pr_id): #get project information rec461 = ppms.search_record(461, [pr_id], [1001, 1052, 1003, 23220, 264, 29448, 41317], True) project_type = rec461.pr_type.get_value() main_pr_id = rec461.main_pr_id.get_value() max_di_length = ppms.search_record(412, ["041317"], [246], True).df_length.get_value() def change_value(pr_id, new_value): if ppms_cu.Helper.get_global_setting("change_project_functional_global").alpha120.get_value() == "1": ppms.db_modify(ppms.get_query("000352").format(pr_id, new_value)) entire_project_structure = ppms.db_select(ppms.get_query("000271").format(main_pr_id)) max_level = ppms.db_select(ppms.get_query("000438").format(main_pr_id))[0][0] max_levl_msg_obj = 1 if (max_level * 2) + len(new_value) > max_di_length: title = ppms_cu.Helper.get_const_title("001174") ole_id = ppms_cu.Helper.get_global_setting("ole_question_mark").alpha120.get_value() button_list = [ppms_cu.Helper.get_const_title("000032"), ppms_cu.Helper.get_const_title("001417"), ppms_cu.Helper.get_const_title("000884")] message = ppms_cu.Helper.get_const_title("001416") ppms.ui_message_box(title, message, 1, ole_id, button_list) max_levl_msg_obj = ppms.msg_pop().get_reply() if max_levl_msg_obj == 2: call_input_message(pr_id) elif max_levl_msg_obj == 3: return None elif max_levl_msg_obj == 1: message = ppms_cu.Helper.get_const_title("001275") #Sure? button_list = [ppms_cu.Helper.get_const_title("000030"), ppms_cu.Helper.get_const_title("000031")] ppms.ui_message_box(title, message, 1, ole_id, button_list) sure_msg_obj = ppms.msg_pop().get_reply() if sure_msg_obj > 1: return None """ Change value of all sub projects """ if len(entire_project_structure) >= 1 and max_levl_msg_obj == 1: rec461.pr_functional.set_value(new_value) for pr_rec in entire_project_structure: current_pr_rec = ppms.search_record(461, [pr_rec[0]], [41317], True) if not current_pr_rec: return None current_pr_func = current_pr_rec.pr_functional.get_value() # get direct childs and set functional key by pos direct_childs = ppms.db_select(ppms.get_query("000392").format(pr_rec[0])) pos_counter = 0 for child_pr_rec in direct_childs: pos_counter += 1 direct_child_rec = ppms.search_record(461, [child_pr_rec[0]], [41317], True) if direct_child_rec: new_value = current_pr_func + "." + str(pos_counter) if len(new_value) <= max_di_length: direct_child_rec.pr_functional.set_value(new_value) direct_child_rec.save() ppms.db_modify(ppms.get_query("000352").format(child_pr_rec[0], new_value)) rec461.save() def call_input_message(pr_id): # Create option message title = ppms_cu.Helper.get_const_title("001174") ole_id = ppms_cu.Helper.get_global_setting("ole_question_mark").alpha120.get_value() button_list = [ppms_cu.Helper.get_const_title("000032"), ppms_cu.Helper.get_const_title("000884")] message = ppms_cu.Helper.get_const_title("001251") ppms.ui_message_box(title, message, 1, ole_id, button_list, 1) msg_obj = ppms.msg_pop() if msg_obj.get_reply() != 2: new_value = msg_obj.get_input()[0] max_di_length = ppms.search_record(412, ["041317"], [246], True).df_length.get_value() # check length of input value vs. length of di041317 "pr functional" if len(new_value) > max_di_length: msg = ppms_cu.Helper.get_const_title("001256").replace("@max_length", str(max_di_length)) ppms.ui_message_box(title, msg, 0, ole_id) call_input_message(pr_id) else: if new_value != "": new_value = new_value.upper() #check whether functional key already exists if ppms.db_select(ppms.get_query("000341").format(new_value))[0][0] < 1: #Ideas and Plans if project_type == 1 or project_type == 2: change_value(pr_id, new_value) #Projects can only be changed by MPM elif ppms.uvar_get("@31") != 1: change_value(pr_id, new_value) else: ppms.ui_message_id("0746") # wished key already exists call_input_message(pr_id) else: ppms.ui_message_id("0489") # new key can not be empty call_input_message(pr_id) ppms.ui_message_id("0782") # change key sytem-wide if ppms.msg_pop().get_reply() == 1: call_input_message(pr_id) def call_project_report(pr_id, report_id): #Declaration mod_obj = ppms.get_target_module() rec823 = ppms.search_record(823, [pr_id, report_id], [8578, 8706, 8702, 34525, 8821, 28506, 8702, 59231, 29447], True) main_pr_id = rec823.main_pr_id.get_value() prsp_code_823_co = rec823.prsp_code_823_co.get_value() acitve_baseline = rec823.acitve_baseline.get_value() report_approval_date = rec823.report_approval_date.get_value() final_report = rec823.final_report.get_value() project_application = rec823.project_application.get_value() report_type = 0 call = {} focus_variant = {} """ calculate report type 0 - status report 1 - baseline report 2 - open status report 3 - final report 4 - project application """ if acitve_baseline == 0: if project_application != 0: report_type = 4 elif final_report == 0: if report_approval_date < 1: report_type = 2 else: report_type = 0 else: report_type = 3 else: report_type = 1 #Set @L variables mod_obj.set_new_L_var(30, [pr_id]) mod_obj.set_new_L_var(74, [main_pr_id]) mod_obj.set_new_L_var(78, [report_id]) mod_obj.set_new_L_var(85, [prsp_code_823_co]) #call dict for report type call["0"] = ppms_cu.Helper.get_global_setting("status_report_edit").alpha120.get_value() call["1"] = ppms_cu.Helper.get_global_setting("status_report_edit").alpha120.get_value() call["2"] = ppms_cu.Helper.get_global_setting("status_report_edit").alpha120.get_value() call["3"] = ppms_cu.Helper.get_global_setting("status_report_edit").alpha120.get_value() call["4"] = ppms_cu.Helper.get_global_setting("status_report_project_application").alpha120.get_value() #variant_ids focus_variant["4"] = ppms_cu.Helper.get_global_setting("status_report_project_application").parameter.get_value() # Module call settings skip_macro = 0 forced_status = 2 dock_to = mod_obj.get_uid() dock_style = 0 dock_proportion = 0.45 foreground = 1 auto_hide = 0 # set focus on report module when module is already opened continue_process = True for sub_mod_obj in mod_obj.get_panel().get_modules(): if hasattr(sub_mod_obj, 'report_pr_id'): if sub_mod_obj.report_pr_id == [pr_id, report_id]: sub_mod_obj.focus() target_mod_obj = sub_mod_obj continue_process = False # call report module and define report_pr_id as attribute for module object if continue_process == True: target_mod_obj = mod_obj.open_module(call[str(report_type)], skip_macro, forced_status, dock_to, dock_style, dock_proportion, foreground, auto_hide) target_mod_obj.menu(34) setattr(target_mod_obj, 'report_pr_id', [pr_id, report_id]) # apply varinat by report type if str(report_type) in focus_variant.keys(): target_mod_obj.apply_mv_by_id(focus_variant[str(report_type)]) def fix_planing_status(type="last_pl", pr_id=""): rec461 = ppms.search_record(461, [pr_id], [1052], True) if not rec461: return None main_pr_id = rec461.main_pr_id.get_value() if not main_pr_id: return None if type == "pl1": #Project kat = "di001027" ket = "di001028" aufw = "di005433" kosten = "di005438" fix_date = "di005443" fix_user = "di005448" #Task vg_kat = "di001125" vg_ket = "di001126" vg_aufw = "di002506" vg_kosten = "di002526" elif type == "pl2": #Project kat = "di001278" ket = "di001286" aufw = "di005434" kosten = "di005439" fix_date = "di005444" fix_user = "di005449" #Task vg_kat = "di001938" vg_ket = "di001939" vg_aufw = "di002513" vg_kosten = "di002527" elif type == "pl3": #Project kat = "di001280" ket = "di001287" aufw = "di005435" kosten = "di005440" fix_date = "di005445" fix_user = "di005450" #Task vg_kat = "di001940" vg_ket = "di001941" vg_aufw = "di002514" vg_kosten = "di002528" elif type == "last_pl": #Project kat = "di001285" ket = "di001289" aufw = "di005437" kosten = "di005442" fix_date = "di005447" fix_user = "di005452" #Task vg_kat = "di001944" vg_ket = "di001945" vg_aufw = "di002525" vg_kosten = "di002530" #Get project structure pr_struc = ppms.db_select(ppms.get_query("000271").format(main_pr_id)) #Execute for each project in project structure for pr in pr_struc: pr_id = pr[0] # get SQL PLS_pr = ppms.get_query("000383").format(kat, ket, aufw, kosten, fix_date, fix_user, ppms.uvar_get("@1"), pr_id) PLS_task = ppms.get_query("000384").format(vg_kat, vg_ket, vg_aufw, vg_kosten, pr_id) # execute SQL ppms.db_modify(PLS_pr) ppms.db_modify(PLS_task) def approve_report(main_pr_id, pr_id, report_id): cur_user = ppms.uvar_get("@1") rec823 = ppms.search_record(823, [pr_id, report_id], [8578, 8706, 8702, 34525, 8821, 28506, 8702, 59231], True) project_application = rec823.project_application.get_value() #question approval if project_application == 1: ppms.ui_message_id("0811") else: ppms.ui_message_id("0472") if ppms.msg_pop().get_reply() == 1: #unset current former report (also baseline) ppms.db_modify(ppms.get_query("000342").format(main_pr_id, cur_user)) #unset current active report (also baseline) ppms.db_modify(ppms.get_query("000343").format(main_pr_id, cur_user)) #set current report as active report ppms.db_modify(ppms.get_query("000344").format(main_pr_id, report_id, cur_user)) #execute sql procedure refresh_report_costs_details(pr_id) refresh_costs_details(pr_id) #update earned value count_baseline = ppms.db_select(ppms.get_query("000345").format(pr_id)) if len(count_baseline) > 0: pass else: update_earned_value(main_pr_id, report_id) return True else: return False def update_earned_value_analysis(do_complete=1, pr_id='', report_id=''): license_rec = ppms_cu.Helper.get_active_license_model() if license_rec: if license_rec.earned_value_active.get_value(): if do_complete or hql.query("SELECT 1 FROM Load l WHERE l.pr_id = '{pr_id}'".format( pr_id=pr_id)): # calculation over all projects or project has load records ppms.db_modify( ppms.get_query('000401').format(do_complete=do_complete, pr_id=pr_id, report_id=report_id)) def update_earned_value(main_pr_id, report_id): update_earned_value_analysis(do_complete=0, pr_id=main_pr_id, report_id=report_id) def check_for_active_planing(): license_rec = ppms_cu.Helper.get_active_license_model() if license_rec: if license_rec.cs_currently_active.get_value() != 0: return True return False def check_cost_details_toggle(pr_id=""): # check whether the project costs are registered manually or by TCALC if pr_id == "": # get active license model license_rec = ppms_cu.Helper.get_active_license_model() if license_rec: if license_rec.manual_cost_registration.get_value() == 1: return True return False def create_project_list(pr_id): """ In case of an empty module we need to use that project It's much saver the fetch all main projects from the module""" if pr_id: projects = [pr_id] else: mod_obj = ppms.get_target_module() projects = get_main_projects(mod_obj) return projects def refresh_costs_details(pr_id=""): projects = create_project_list(pr_id) if check_cost_details_toggle() == False: # execute procedure p_verdichte_pr_akt fill_temp_table(projects) ppms.db_modify(ppms.get_query("000348")) ppms.db_commit() ppms.db_set_auto_commit(True) def aggregate_costs_dt493(pr_id=""): projects = create_project_list(pr_id) fill_temp_table(projects) # delete current state of dt493 ppms.db_modify(ppms.get_query("000346")) # insert new values into dt493 ppms.db_modify(ppms.get_query("000347")) ppms.db_commit() ppms.db_set_auto_commit(True) def update_project_costs_from_year_slices(): projects = create_project_list(None) fill_temp_table(projects) man_cost_registration = int(check_cost_details_toggle()) for pr_id in projects: pr_tree = get_pr_tree_desc(pr_id, 'db') aggregate_costs(pr_id, pr_tree, man_cost_registration) for sub_pr in get_pr_tree_desc(pr_id, 'py'): sub_pr_tree = get_pr_tree_desc(sub_pr, 'db') aggregate_costs(sub_pr, sub_pr_tree, man_cost_registration) ppms.db_commit() ppms.db_set_auto_commit(True) def aggregate_costs(pr_id, pr_tree, man_cost_registration): # aggregate subproject costs from pr_treee to pr_id sql = ppms.get_query("000368").format(**locals()) ppms.db_modify(sql) def get_pr_tree_desc(proj_id, list_format='py'): # returns descending list of child projects # list_format=py -> return projects as list # list_format=db -> return projects as tuple to in sql pr_select = ppms.get_query("000914") subprojects = ppms.db_select(pr_select.format(proj_id)) scanned_projects = [proj_id] for project in subprojects: for next_subproj in ppms.db_select(pr_select.format(project[0])): if next_subproj not in subprojects: subprojects.append(next_subproj) scanned_projects.append(project[0]) if list_format == 'db': scanned_projects = tuple(scanned_projects) if len(scanned_projects) == 1: # prepare list of exactly one subproject for sql "in" statement scanned_projects = (scanned_projects[0], scanned_projects[0]) return scanned_projects def refresh_report_costs_details(pr_id=""): """Best to be used without a pr_id""" projects = create_project_list(pr_id) current_user = ppms.uvar_get("@1") # execute procedure p_verdichte_pr_sb fill_temp_table(projects) ppms.db_modify(ppms.get_query("000349").format(current_user)) ppms.db_commit() ppms.db_set_auto_commit(True) def refresh_baseline_costs_details(pr_id=""): """Best to be used without a pr_id""" projects = create_project_list(pr_id) # execute procedure p_upd_budget_bl fill_temp_table(projects) ppms.db_modify(ppms.get_query("000350")) ppms.db_commit() ppms.db_set_auto_commit(True) def get_report_mapping_definition(): """ mapping of tables and primary keys for project report creation - for each table in source_dt it is required to register a value in target_dt and data_items """ mapping_dict = {} # source, target and dataitems mapping_dict["source_dt"] = ['DT461', 'DT463', 'DT466', 'DT472', 'DT810', 'DT811', 'DT804', 'DT805', 'DT861', 'DT868', 'DT812', 'DT813'] mapping_dict["target_dt"] = ['DT823', 'DT824', 'DT826', 'DT827', 'DT831', 'DT832', 'DT833', 'DT834', 'DT835', 'DT836', 'DT872', 'DT873'] mapping_dict["data_items"] = ['DI001001', 'DI001097', 'DI001390', 'DI001395', 'DI007696', 'DI007717', 'DI006841', 'DI006455', 'DI023119', 'DI028632', 'DI029557', 'DI029584'] return mapping_dict def set_report_title(pr_id, report_id, current_report_title=""): # set report default title main_pr_id = ppms.search_record(461, [pr_id], [1001, 1052, 1003, 23220, 264, 29448], True).main_pr_id.get_value() default_title = ppms_cu.Helper.get_const_title("000780") + " " + report_id if current_report_title == "": title = default_title else: title = current_report_title ppms.db_modify(ppms.get_query("000351").format(main_pr_id, report_id, title)) def exec_define_baseline(main_pr_id, pr_id, report_id): """Change the given report to be the new baseline for a main project""" # Set old baseline ppms.db_modify(ppms.get_query("000275").format(main_pr_id)) # Set current report as new baseline ppms.db_modify(ppms.get_query("000276").format(main_pr_id, report_id)) refresh_costs_details(pr_id) refresh_baseline_costs_details(pr_id)