def __apply_click_event(self, event): ''' get the entities according to the input project path ''' fileconstant = File_constant() proj_dir = self.__input01.get() #verify the input directory if not File_processor.verify_dir_existing(proj_dir): showerror('Error', 'Please select a valid directory.') if not File_processor.verify_dir_format(proj_dir): showerror('Error', 'Please select a valid forlder, not a file.') return if not File_processor.verify_file(proj_dir + fileconstant.POM_PATH): showerror( 'Error', 'Please select a valid project directory\n(the directory of pom.xml in webui).' ) return #read the entity metadatas result, metas, err_message = Xmlfile_processor.read_proj_dir(proj_dir) if result: #clear the list box first self.__listboxleft.delete(0, END) #backup the list self.__filelists = metas #add items into list box for name in metas.keys(): self.__listboxleft.insert(END, name) else: showerror('Error', err_message)
def get_file_type(dir_path): ''' get the file type @param dir_path: file directory @return: return file type ''' fileconstant = File_constant() #open file as bytes bytefile = open(dir_path, 'rb') ftype = 'unknown' #read the file header bins = bytefile.read(20) #close file bytefile.close() #convert bytes to 16 bit bins = File_processor.__bytes2hex(bins) #keys comparing for hcode in fileconstant.FILE_TYPE.keys(): lens = len(hcode) #length of key if bins[0:lens] == hcode: ftype = fileconstant.FILE_TYPE[hcode] break return ftype
def load_connection_parameters(self, event): ''' load connection parameters from workspace ''' # combine the workspace path fileconstant = File_constant() workspacepath = self.get_trans().get_workspacepath() cassandra_conection_file = workspacepath + fileconstant.CASSANDRA_CONFIG_FOLDER + fileconstant.CASSANDRA_CONNECTION_FILE # verify connection file existing if not File_processor.verify_file(cassandra_conection_file): showerror('Error', 'Cassandra connection file does not exist!') return # load connection parameters connection_params = Database_connection_file_processor.read_connection_params( cassandra_conection_file, self.__comboxlist.get()) # set parameters self.__input02.delete(0, END) self.__input02.insert(END, connection_params['host']) self.__input03.delete(0, END) self.__input03.insert(END, connection_params['port']) self.__input04.delete(0, END) self.__input04.insert(END, connection_params['username']) self.__input05.delete(0, END) self.__input05.insert(END, connection_params['password'])
def set_maintain_mode(self): ''' verify the initial maintain mode (create or load) ''' self.__maintain_mode = MATAIN_MODE_LOAD # setup the connection file path into workspace folder fileconstant = File_constant() workspacepath = self.get_trans().get_workspacepath() cassandra_conection_folder = workspacepath + fileconstant.CASSANDRA_CONFIG_FOLDER if not File_processor.verify_dir_existing(cassandra_conection_folder): self.__maintain_mode = MATAIN_MODE_NEW return cassandra_conection_file = cassandra_conection_folder + fileconstant.CASSANDRA_CONNECTION_FILE # verify the connection file if not File_processor.verify_file(cassandra_conection_file): self.__maintain_mode = MATAIN_MODE_NEW return # load connection names connection_names = Database_connection_file_processor.read_connection_names( cassandra_conection_file) # set tuple to combox list templist = tuple(connection_names) if len(templist) == 0: self.__maintain_mode = MATAIN_MODE_NEW return
def before_next(self): ''' overwrite the function in super class verify the input directory ''' if self.__listboxright.size() > 0: #the dict.items() will convert to tuple for index in range(self.__listboxright.size()): for tup in self.__filelists.items(): if tup[0] == self.__listboxright.get(index): #save the entity info self.get_dtos().set_entityname(tup[0]) self.get_dtos().set_viewfullpath(tup[1]) if self.get_dtos().get_entityname() and self.get_dtos( ).get_viewfullpath(): #--- save the project path self.get_trans().set_projectpath(self.__input01.get()) #--- update default file fileconstant = File_constant() userdefault = File_processor.get_home_dir() userdefault = userdefault + fileconstant.USER_DEFAULT User_default_file_processor.update_default_file( userdefault, 'project', self.__input01.get()) return True else: showerror('Error', 'You must select an existing entity!') return False
def create_widges(self): fileconstant = File_constant() #frame self.__frame1 = FormatableFrame(self) self.__frame1.pack(side=TOP) #Title self.__label01 = Label(self.__frame1, text="Mock DTO generator options", width=45) self.__label01.pack(side=TOP, fill=X, ipady=10) #---- panel 01 ---------- canv1 = Canvas(self, height=30, width=550) #label self.__label01 = Label(canv1, text='Mock DTO name :') self.__label01.place(height=20, width=130, relx=0.03, rely=0.2) #input self.__feet = StringVar() self.__dicinput = Entry(canv1, textvariable=self.__feet, borderwidth=3, bg='black', foreground='yellow', highlightcolor='red', insertbackground='red') self.__dicinput.place(height=20, width=250, relx=0.3, rely=0.2) canv1.pack() #---- panel 02 ---------- canv2 = Canvas(self, height=100, width=550) #label label1 = Label(canv2, text='Options:') label1.place(height=20, width=60, relx=0, rely=0) #radio box self.__vari1 = IntVar() self.__rad1 = Radiobutton(canv2, text='Copy from the standard DTO(generated)', variable=self.__vari1, value=1) self.__rad1.place(height=20, width=270, relx=0.1, rely=0.2) self.__rad1.select() self.__rad2 = Radiobutton(canv2, text='Generated from fin-impl.jar', variable=self.__vari1, value=2) self.__rad2.place(height=20, width=210, relx=0.1, rely=0.45) self.__rad2.deselect() canv2.pack() if self.get_dtos().get_businessentityname(): # get the main table interface name main_tb_name = self.get_dtos().get_maintableInterDTO( ).get_class_name() # get the mock ds name mock_ds_name = fileconstant.TS_DATASET_PREFIX + main_tb_name + fileconstant.TS_MOCK_DS_SUFFIX + fileconstant.TS_SUFFIX self.__feet.set(mock_ds_name)
def before_next(self): ''' overwrite the function in super class verify the input directory generating the next frames according to the selections ''' tempdir = None #--- verify the input value if self.__dicinput.get(): if not Xmlfile_processor.verify_dir_format(self.__dicinput.get()): showerror('Error', 'The directory format is incorrect!') return False if not Xmlfile_processor.verify_dir_existing( self.__dicinput.get()): Xmlfile_processor.create_folder(self.__dicinput.get()) showinfo( 'Note', 'A new folder has been created in your workspace path.') #--- set the workspace path into transaction dto self.get_trans().set_workspacepath(self.__dicinput.get()) tempdir = self.__dicinput.get() else: tempdir = os.path.join(os.path.expanduser('~'), "Desktop") + '\\PyWorkspace' #--- desktop temp folder already existing self.__feet.set(tempdir) if Xmlfile_processor.verify_dir_existing(tempdir): showinfo( 'Note', 'The temp folder(PyWorkspace) on your desktop has been set as the default workspace.' ) else: Xmlfile_processor.create_folder(tempdir) showinfo( 'Note', 'A temp folder(PyWorkspace) has been created on your desktop.' ) #--- set the workspace path into transaction dto self.get_trans().set_workspacepath(tempdir) #--- update default file fileconstant = File_constant() userdefault = File_processor.get_home_dir() userdefault = userdefault + fileconstant.USER_DEFAULT User_default_file_processor.update_default_file( userdefault, 'workspace', tempdir) #--- set the process flow according to the selection self.get_trans().remove_subsequent_process_flows_exclude_current() self.get_trans().update_process_flow_by_start_selection( self.__vari1.get()) return True
def create_widges(self): fileconstant = File_constant() #frame self.__frame1 = FormatableFrame(self) self.__frame1.pack(side=TOP) #Title self.__label01 = Label(self.__frame1, text="TS CommonService generator options", width=45) self.__label01.pack(side=TOP, fill=X, ipady=10) #---- panel 01 ---------- canv1 = Canvas(self, height=30, width=550) #label self.__label01 = Label(canv1, text='CommonService name :') self.__label01.place(height=20, width=130, relx=0.03, rely=0.2) #input self.__feet = StringVar() self.__dicinput = Entry(canv1, textvariable=self.__feet, borderwidth=3, bg='black', foreground='yellow', highlightcolor='red', insertbackground='red') self.__dicinput.place(height=20, width=250, relx=0.3, rely=0.2) canv1.pack() #---- panel 02 ---------- canv2 = Canvas(self, height=100, width=550) self.__label02 = Label(canv2, text='Please select the imports:', width=30) self.__label02.place(height=20, width=200, relx=0.05, rely=0.02) canv2.pack() # TODO: add import options: constant, MockDTO #---- panel 03 ---------- canv3 = Canvas(self, height=150, width=550) self.__label03 = Label(canv3, text='Please select the contents:', width=30) self.__label03.place(height=20, width=200, relx=0.05, rely=0.02) canv3.pack() if self.get_dtos().get_businessentityname(): # get the mock ds name mock_ds_name = self.get_dtos().get_businessentityname( ) + fileconstant.TS_COMMON_SERVICE_SUFFIX + fileconstant.TS_SUFFIX self.__feet.set(mock_ds_name)
def before_next(self): ''' overwrite the function in super class verify the input directory ''' if not self.__result: showwarning( 'Warning', 'There are error existing, the CommonService cannot be generated.' ) return # --------------------- analysis the DTO if needed --------------------- # if not self.get_dtos().get_tsdtos() or not self.get_dtos( ).get_tsdto_value('TSDtoDTO'): #path constant fileconstant = File_constant() proj_path = self.get_trans().get_projectpath() # get the main table interface name main_tb_name = self.get_dtos().get_maintableInterDTO( ).get_class_name() # get the generated ds name gene_ds_name = fileconstant.TS_DATASET_PREFIX + main_tb_name + fileconstant.TS_SUFFIX # get the generated ds full path gene_ds_filefullpath = proj_path + fileconstant.RESOURCE_TS_MAIN_PATH + fileconstant.RESOURCE_TS_DTO_BL_FOLDER + gene_ds_name # get the mock ds full path mock_ds_filefullpath = proj_path + fileconstant.RESOURCE_TS_MAIN_PATH + fileconstant.RESOURCE_TS_DTO_UI_FOLDER + gene_ds_name.replace( fileconstant.TS_SUFFIX, fileconstant.TS_MOCK_DS_SUFFIX + fileconstant.TS_SUFFIX) # use MockDTO if existing if File_processor.verify_dir_existing(mock_ds_filefullpath): TS_processor.analysis_DTO(self.get_dtos(), mock_ds_filefullpath) elif File_processor.verify_dir_existing(gene_ds_filefullpath): TS_processor.analysis_DTO(self.get_dtos(), gene_ds_filefullpath) else: showerror( 'Error', 'The DTO interface TS is not existing, please check.') return False # create the observable object self.__result, self.__message = TS_processor.create_TS_CommonService( self.get_dtos(), self.get_trans(), self.__feet.get()) if not self.__result: showerror('Error', self.__message) return False return True
def set_stylesheet(self): ''' set the style sheet from qss and icons ''' # get the relative project path fileconstant = File_constant() root_path = os.path.dirname(os.path.abspath(__file__)) proj_path = root_path[:root_path.index(fileconstant.MY_PROJECT_PACKAGE)] # set the qss qss_path = proj_path + "\\src\\main\\pydev\\com\\ftd\\resource\\style\\StyleSheet.qss" self.setStyleSheet(open(qss_path, "r").read()) # set the window icon icon_path = proj_path + "\\src\\main\\pydev\\com\\ftd\\resource\\icons\\title_icon.jpg" self.setWindowIcon(QIcon(icon_path))
def load_connection_names(self): ''' load all connection names from workspace @return: count of connections ''' # setup the connection file path into workspace folder fileconstant = File_constant() workspacepath = self.get_trans().get_workspacepath() cassandra_conection_folder = workspacepath + fileconstant.CASSANDRA_CONFIG_FOLDER if not File_processor.verify_dir_existing(cassandra_conection_folder): File_processor.create_folder(cassandra_conection_folder) cassandra_conection_file = cassandra_conection_folder + fileconstant.CASSANDRA_CONNECTION_FILE # verify connection file existing if not File_processor.verify_file(cassandra_conection_file): showerror('Error', 'Cassandra connection file does not exist!') return 0 # load connection names connection_names = Database_connection_file_processor.read_connection_names( cassandra_conection_file) # set tuple to combox list self.__comboxlist["values"] = tuple(connection_names) if len(self.__comboxlist["values"]) == 0: showerror('Error', 'No valid connection, please add one first!') return 0 # default the first one self.__comboxlist.current(0) # load connection parameters connection_params = Database_connection_file_processor.read_connection_params( cassandra_conection_file, self.__comboxlist.get()) # set parameters self.__input02.delete(0, END) self.__input02.insert(END, connection_params['host']) self.__input03.delete(0, END) self.__input03.insert(END, connection_params['port']) self.__input04.delete(0, END) self.__input04.insert(END, connection_params['username']) self.__input05.delete(0, END) self.__input05.insert(END, connection_params['password']) return len(self.__comboxlist["values"])
def read_proj_dir(dir_path): ''' read the all view metadata xml files from the project directory @param dir_path: the full path of the project @return: return status @return: viewMetadataNames in list @return: message if validation failed ''' # verify if file is existing if not File_processor.verify_dir_existing(dir_path): return False, None, "File not exist!" try: fileconstant = File_constant() #view metadata file list viewMetadataNames = {} #change the work path os.chdir(dir_path) #go through the inner files for fullname in File_processor.dir_iterbrowse(dir_path): #get the view metadata files if (fullname.startswith(dir_path + fileconstant.VIEW_METADATA_PATH)): #trim the file name filename = os.path.basename(fullname) #remove the suffix filename = filename[:-4] #insert into file list viewMetadataNames[filename] = fullname #no files if len(viewMetadataNames) == 0: return False, None, 'There is no correct view metadata.' return True, viewMetadataNames, None except OSError as e: print('Caught exception:', e.message()) return False, None, e.message() except FileNotFoundError as e: print('Caught exception:', e.message()) return False, None, e.message() finally: pass
def load_user_default(self): ''' load the local user default ''' fileconstant = File_constant() userdefault = File_processor.get_home_dir() userdefault = userdefault + fileconstant.USER_DEFAULT #create default file if not existing if not File_processor.verify_dir_existing(userdefault): User_default_file_processor.create_default_file(userdefault) #read default file default_info = User_default_file_processor.read_default_file( userdefault) if default_info['project'] and default_info['project'] != "": self.get_trans().set_projectpath(default_info['project']) self.__dicinput.delete(0, END) self.__dicinput.insert(END, default_info['project'])
def multiprocessing_service(transDTO): ''' Multiple processing service ''' fileconstant = File_constant() #jar full path impljarfullpath = transDTO.get_finImplJarPath() apijarfullpath = transDTO.get_finApiJarPath() #workspace full path unzip_path = transDTO.get_workspacepath( ) + fileconstant.UNZIP_JAR_FOLDER #remove the legacy folder if File_processor.verify_dir_existing(unzip_path): if not askyesno( 'Confirm', 'The decompile folder existing, do you want to skip decompile?' ): File_processor.remove_folder(unzip_path) else: return print('Parent process %s.' % os.getpid()) #process the child processing p1 = Process(target=Multiple_processor.jar_decompile_proc, args=( 'JarDecompile', impljarfullpath, unzip_path + fileconstant.IMPL_FOLDER, )) p1.start() p2 = Process(target=Multiple_processor.jar_decompile_proc, args=( 'JarDecompile', apijarfullpath, unzip_path + fileconstant.API_FOLDER, )) p2.start() # p.join() join will be waiting for the child process print('Child process end.')
def create_widges(self): fileconstant = File_constant() #frame self.__frame1 = FormatableFrame(self) self.__frame1.pack(side=TOP) #Title self.__label01 = Label(self.__frame1, text="TS Constants generator options", width=45) self.__label01.pack(side=TOP, fill=X, ipady=10) #---- panel 01 ---------- canv1 = Canvas(self, height=30, width=550) #label self.__label01 = Label(canv1, text='TS Constants name :') self.__label01.place(height=20, width=130, relx=0.03, rely=0.2) #input self.__feet = StringVar() self.__dicinput = Entry(canv1, textvariable=self.__feet, borderwidth=3, bg='black', foreground='yellow', highlightcolor='red', insertbackground='red') self.__dicinput.place(height=20, width=250, relx=0.3, rely=0.2) if self.get_dtos().get_businessentityname(): temp_name = self.get_dtos().get_businessentityname( ) + fileconstant.TS_CONSTANT_SUFFIX + fileconstant.TS_SUFFIX self.__feet.set(temp_name) else: self.__result, self.__error, business_entity_name, self.__classlist = Java_processor.validate_lib_javas( self.get_trans(), self.get_dtos()) if not self.__result: #---- panel 02 ---------- self.__pack_errorpanel() return if business_entity_name: self.get_dtos().set_businessentityname(business_entity_name) temp_name = self.get_dtos().get_businessentityname( ) + fileconstant.TS_CONSTANT_SUFFIX + fileconstant.TS_SUFFIX self.__feet.set(temp_name) canv1.pack() #---- panel 02 ---------- canv2 = Canvas(self, height=100, width=550) #label label1 = Label(canv2, text='Options:') label1.place(height=20, width=60, relx=0, rely=0) #radio box self.__vari1 = IntVar() self.__rad1 = Radiobutton(canv2, text='Re-write the previous file', variable=self.__vari1, value=1) self.__rad1.place(height=20, width=170, relx=0.1, rely=0.2) self.__rad1.select() self.__rad2 = Radiobutton(canv2, text='Attach new functions to the file', variable=self.__vari1, value=2) self.__rad2.place(height=20, width=210, relx=0.1, rely=0.45) self.__rad2.deselect() self.__rad3 = Radiobutton(canv2, text='Save the previous file as backup', variable=self.__vari1, value=3) self.__rad3.place(height=20, width=220, relx=0.1, rely=0.7) self.__rad3.deselect() canv2.pack()
def before_next(self): ''' overwrite the function in super class generating the next frames according to the selections ''' #check box flag frame_constant = Frame_constant() checkFlag = False selections = dict(self.__checkvalues01, **self.__checkvalues02, **self.__checkvalues03) for val in selections.values(): if val.get() == 1: checkFlag = True break if checkFlag: #merge the selections into process flow self.get_trans().update_process_flow_by_gene_selection(selections) # --------- analysis the serviceImpl and datacontroller class if needed fileconstant = File_constant() tempstr01, tempstr02, parent_pack, tempstr03 = Java_processor.analysis_jar_package_name( self.get_dtos().get_serviceInterDTO().get_class_package()) self.__result, self.__error, business_entity_name, self.__classlist = Java_processor.validate_lib_javas( self.get_trans(), self.get_dtos()) proc = self.get_trans().get_processflow() if self.__checkvalues02[frame_constant.DATA_CONTROLLER].get( ) == 1 and self.__checkvalues02[ frame_constant.SERVICE_IMPL].get() != 1 in proc: if not self.get_dtos().get_serviceImplPath(): serviceImpl_path = self.get_trans().get_projectpath( ) + fileconstant.JAVA_SERVICEIMPL_PATH % ( parent_pack, business_entity_name + fileconstant.SERVICEIMPL_SUFFIX + fileconstant.JAVA_SUFFIX) self.__result, self.__error, dcJavaDTO = Java_processor.analysis_serviceImpl( business_entity_name + fileconstant.SERVICEIMPL_SUFFIX, serviceImpl_path, self.get_dtos()) if not self.__result: #---- panel 02 ---------- self.__pack_errorpanel() return else: self.get_dtos().set_serviceImplInfo( business_entity_name + fileconstant.SERVICEIMPL_SUFFIX + fileconstant.JAVA_SUFFIX, serviceImpl_path, dcJavaDTO) if (self.__checkvalues03[frame_constant.TS_HANDLER].get() == 1 or self.__checkvalues03[frame_constant.OBSERVABLE_OBJ].get() == 1) and \ self.__checkvalues02[frame_constant.DATA_CONTROLLER].get() != 1: if not self.get_dtos().get_dataControllerPath(): dataController_path = self.get_trans().get_projectpath( ) + fileconstant.JAVA_DATACONTROLLER_PATH % ( parent_pack, business_entity_name + fileconstant.DATACONTROLLER_SUFFIX + fileconstant.JAVA_SUFFIX) self.__result, self.__error, dcJavaDTO = Java_processor.analysis_dataController( business_entity_name + fileconstant.DATACONTROLLER_SUFFIX, dataController_path, self.get_dtos()) if not self.__result: #---- panel 02 ---------- self.__pack_errorpanel() return else: self.get_dtos().set_dataControllerInfo( business_entity_name + fileconstant.DATACONTROLLER_SUFFIX + fileconstant.JAVA_SUFFIX, dataController_path, dcJavaDTO) return True else: showerror('Error', 'You must select at least one generation file!') return False
def create_widges(self): fileconstant = File_constant() #frame self.__frame1 = FormatableFrame(self) self.__frame1.pack(side=TOP) #Title self.__label01 = Label(self.__frame1, text="Observable Obj generator options", width=45) self.__label01.pack(side=TOP, fill=X, ipady=10) #---- panel 01 ---------- canv1 = Canvas(self, height=30, width=550) #label self.__label01 = Label(canv1, text='Observable Obj name :') self.__label01.place(height=20, width=130, relx=0.03, rely=0.2) #input self.__feet = StringVar() self.__dicinput = Entry(canv1, textvariable=self.__feet, borderwidth=3, bg='black', foreground='yellow', highlightcolor='red', insertbackground='red') self.__dicinput.place(height=20, width=250, relx=0.3, rely=0.2) canv1.pack() #---- panel 02 ---------- canv2 = Canvas(self, height=100, width=550) #label label1 = Label(canv2, text='Options:') label1.place(height=20, width=60, relx=0, rely=0) #radio box self.__vari1 = IntVar() self.__rad1 = Radiobutton(canv2, text='Re-write the previous file', variable=self.__vari1, value=1) self.__rad1.place(height=20, width=170, relx=0.1, rely=0.2) self.__rad1.select() self.__rad2 = Radiobutton(canv2, text='Attach new functions to the file', variable=self.__vari1, value=2) self.__rad2.place(height=20, width=210, relx=0.1, rely=0.45) self.__rad2.deselect() self.__rad3 = Radiobutton(canv2, text='Save the previous file as backup', variable=self.__vari1, value=3) self.__rad3.place(height=20, width=220, relx=0.1, rely=0.7) self.__rad3.deselect() canv2.pack() if self.get_dtos().get_businessentityname(): temp_name = self.get_dtos().get_businessentityname( ) + fileconstant.TS_OBSERVABLE_OBJECT_SUFFIX + fileconstant.TS_SUFFIX self.__feet.set(temp_name)
def before_next(self): ''' overwrite the function in super class verify the input directory generating the next frames according to the selections ''' # verify the connection name if not self.__input01.get( ) and self.__maintain_mode == MATAIN_MODE_NEW: showerror('Error', 'Please provide the connection name!') return False # verify the input value if not self.__input02.get() or not self.__input03.get( ) or not self.__input04.get() or not self.__input05.get(): showerror('Error', 'Please provide the complete info!') return False # setup the connection file path into workspace folder fileconstant = File_constant() workspacepath = self.get_trans().get_workspacepath() cassandra_conection_folder = workspacepath + fileconstant.CASSANDRA_CONFIG_FOLDER if not File_processor.verify_dir_existing(cassandra_conection_folder): File_processor.create_folder(cassandra_conection_folder) cassandra_conection_file = cassandra_conection_folder + fileconstant.CASSANDRA_CONNECTION_FILE # combine the connection parameter # TODO: this should be implemented as toString() in Cassandra_connection_dto if self.__maintain_mode == MATAIN_MODE_NEW: connection_name = self.__input01.get() connection_param = self.__input01.get( ) + ':' + 'host=' + self.__input02.get( ) + ',port=' + self.__input03.get( ) + ',username='******',password='******':' + 'host=' + self.__input02.get( ) + ',port=' + self.__input03.get( ) + ',username='******',password='******'Warning', 'The connection name is existing, do you confirm to overwrite?' ): return False Database_connection_file_processor.update_connection_file( cassandra_conection_file, connection_name, connection_param) return True
def create_TS_CommonService(entityDto, transDto, ts_name): ''' This method is used to create the CommonService TSHandler ''' #path constant fileconstant = File_constant() tsconstant = TS_constant() proj_path = transDto.get_projectpath() # get the main table interface name controller_dto = entityDto.get_dataControllerDTO() business_entity_name = entityDto.get_businessentityname() # get the parent package name parent_pack = Java_processor.analysis_dataController_package_name( controller_dto.get_class_package()) # get the generated constant full path commsev_filefullpath = proj_path + fileconstant.RESOURCE_TS_MAIN_PATH + parent_pack + '\\' + business_entity_name.lower( ) + '\\' + ts_name # create the header for constant file temp_lines = [] additional_reference = [] import_list = [] # ------------------------------------------------------- # # ----- Prepare the imports ----- # ------------------------------------------------------- # import_list.append(tsconstant.TS_TAB + tsconstant.TS_FIN_COMMONSERVICE_IMPORT) # DTO import #tempStr = tsconstant.TS_DTO_IMPORT_TEMP % (dsName,parent_pack,business_entity_name.lower(),business_entity_name,) #import_list.append(tsconstant.TS_TAB + tempStr) # ------------------------------------------------------- # # ----- Create the file ----- # ------------------------------------------------------- # if not File_processor.verify_dir_existing(commsev_filefullpath): # create file Path(commsev_filefullpath).touch() # ------------------------------------------------------- # # ----- open the observable object file ----- # ------------------------------------------------------- # file = open(commsev_filefullpath, 'w') # ------------------------------------------------------- # # ----- write the common references ----- # ------------------------------------------------------- # for temp_ref in tsconstant.TS_REFERENCE_COMMON_REFERENCES: file.write(temp_ref) file.write('\n') for temp_ref in tsconstant.TS_REFERENCE_UTIL_REFERENCES: file.write(temp_ref) file.write('\n') # ------------------------------------------------------- # # ----- write the common references ----- # ------------------------------------------------------- # for temp_ref in additional_reference: file.write(temp_ref) file.write('\n') file.write('\n') # ------------------------------------------------------- # # ----- write the observable object header ----- # ------------------------------------------------------- # temp_header = tsconstant.TS_COMMONSERVICE_HEADER % ( parent_pack, business_entity_name.lower()) file.write(temp_header) file.write('\n') # ------------------------------------------------------- # # ----- write the imports ----- # ------------------------------------------------------- # for temp_ref in import_list: file.write(temp_ref) file.write('\n') file.write('\n') # ------------------------------------------------------- # # ----- write the observable object content ----- # ------------------------------------------------------- # for sub_line in temp_lines: file.write(sub_line) file.write(tsconstant.TS_RIGHT_BRACE) file.close() return True, None
def create_TS_Constant(entityDto, transDto, tsConstant_name): ''' create TS Constant ''' #path constant fileconstant = File_constant() tsconstant = TS_constant() proj_path = transDto.get_projectpath() # get the main table interface name controller_dto = entityDto.get_dataControllerDTO() business_entity_name = entityDto.get_businessentityname() # get the parent package name parent_pack = Java_processor.analysis_dataController_package_name( controller_dto.get_class_package()) # get the generated constant full path const_filefullpath = proj_path + fileconstant.RESOURCE_TS_MAIN_PATH + parent_pack + '\\' + business_entity_name.lower( ) + '\\' + tsConstant_name # create the header for constant file tempLines = [] fieldLines = [] gridLines = [] gridfieldLines = {} tempStr = tsconstant.TS_CONSTANT_HEADER % ( parent_pack, business_entity_name.lower()) tempLines.append(tempStr) tempLines.append('\n') viewMetaDataDTO = entityDto.get_viewDTO() if not viewMetaDataDTO: return False, 'The View Metadata has not been analyzed, please do it first.' # ------------------------------------------------------- # # ----- prepare the field & labels ----- # ------------------------------------------------------- # for datafield in viewMetaDataDTO.get_datafields(): if datafield.get_name(): tempName = datafield.get_name() constName = TS_processor.convertConstName(tempName) # add fields into const file fieldLines.append(tsconstant.TS_CONSTANT_FIELD_LINE_TEMP % (constName, tempName)) for datalabels in viewMetaDataDTO.get_datalabels(): if datalabels.get_name(): tempName = datalabels.get_name() constName = TS_processor.convertConstName(tempName) # add fields into const file fieldLines.append(tsconstant.TS_CONSTANT_FIELD_LINE_TEMP % (constName, tempName)) # create field&label constant if len(fieldLines) > 0: fieldContent = '' for fieldLine in fieldLines: fieldContent = fieldContent + fieldLine tempLines.append(tsconstant.TS_CONSTANT_FIELDS_TEMP % (business_entity_name, fieldContent)) # ------------------------------------------------------- # # ----- prepare the grids ----- # ------------------------------------------------------- # for datagrids in viewMetaDataDTO.get_datagrids(): if datagrids.get_name(): tempGridName = datagrids.get_name() constGridName = TS_processor.convertConstName(tempGridName) # add fields into const file gridLines.append(tsconstant.TS_CONSTANT_FIELD_LINE_TEMP % (constGridName, tempGridName)) # ------------------------------------------------------- # # ----- prepare the grid fields ----- # ------------------------------------------------------- # if datagrids.get_datagridtable( ) and datagrids.get_datagridtable().get_datagridfields( ) and len(datagrids.get_datagridtable().get_datagridfields() ) > 0: tempGridFieldList = [] for datagridfield in datagrids.get_datagridtable( ).get_datagridfields(): if datagridfield.get_fieldname(): tempFieldName = datagridfield.get_fieldname() constFieldName = TS_processor.convertConstName( tempFieldName) # add grid fields into const file tempGridFieldList.append( tsconstant.TS_CONSTANT_FIELD_LINE_TEMP % (constFieldName, tempFieldName)) gridfieldLines[tempGridName] = tempGridFieldList # create grid constant if len(gridLines) > 0: gridContent = '' for gridLine in gridLines: gridContent = gridContent + gridLine tempLines.append(tsconstant.TS_CONSTANT_GRIDS_TEMP % (business_entity_name, gridContent)) # create gridfield constant for key, value in gridfieldLines.items(): gridFieldContent = '' for gridFieldLine in value: gridFieldContent = gridFieldContent + gridFieldLine tempLines.append(tsconstant.TS_CONSTANT_GRIDFIELD_TEMP % (key, gridFieldContent)) # write the constant file if not File_processor.verify_dir_existing(const_filefullpath): # create file Path(const_filefullpath).touch() # ------------------------------------------------------- # # ----- open the constant file ----- # ------------------------------------------------------- # newfile = open(const_filefullpath, 'w') for line in tempLines: newfile.write(line) newfile.write(tsconstant.TS_RIGHT_BRACE) newfile.close() return True, None
def before_next(self): fileconstant = File_constant() curDtos = self.get_dtos() curTrans = self.get_trans() const = Frame_constant() #--- update the process options in transaction dto ---- result, message = curTrans.update_options( {'Xml':{'EntityMap':self.__vari1.get(), 'BeanAppContext':self.__vari2.get()}}, const.ACTION_UPDATE) if not result: showerror('Error', message) return False #--- read the resource metadata resDTO = curDtos.get_resourceDTO() #--- process beans-app-context.xml bean_path = curTrans.get_projectpath() + fileconstant.BEAN_APP_CONTEXT_PATH status01, beanDTO, message01 = Xmlfile_processor.read_beans_app_context(bean_path) if status01: #--- verify if the target entity uri is existing in the beans-app-context if resDTO.get_primary_secure_uri() in beanDTO.get_entity_uri_mapstring(): showwarning('Note', 'The entity uri had been added in the beans-app-context.xml.') else: #--- backup beans-app-context Xmlfile_processor.copy_file(bean_path, curTrans.get_workspacepath() + beanDTO.get_filename() + fileconstant.BACKUP_SUFFIX) #--- format the new uri value = resDTO.get_primary_secure_uri() + ',' + resDTO.get_meta_uri() #--- update beans-app-context status01, message01 = Xmlfile_processor.write_beans_app_context(bean_path, value) #--- clean the backup if needed if self.__vari1.get() == 2: status01, message01 = Xmlfile_processor.remove_file(curTrans.get_workspacepath() + beanDTO.get_filename() + fileconstant.BACKUP_SUFFIX) if not status01: showerror('Error', message01) return False #--- process entityMap.xml entmap_path = curTrans.get_projectpath() + fileconstant.ENTITY_MAP_PATH status02, entMapDTO, message02 = Xmlfile_processor.read_entity_map(entmap_path) if status02: #--- verify if the target entity uri is existing in the entityMap if resDTO.get_primary_secure_uri() in entMapDTO.get_entitymap_uris(): showwarning('Note', 'The entity uri had been added in the entityMap.xml.') else: #--- backup entityMap Xmlfile_processor.copy_file(entmap_path, curTrans.get_workspacepath() + entMapDTO.get_filename() + fileconstant.BACKUP_SUFFIX) #--- write entityMap status02, message02 = Xmlfile_processor.write_entity_map(entmap_path, resDTO.get_primary_secure_uri(), self.__varc3.get(), self.__varc5.get(), self.__varc4.get()) #--- clean the backup if needed if self.__vari2.get() == 2: status02, message02 = Xmlfile_processor.remove_file(curTrans.get_workspacepath() + entMapDTO.get_filename() + fileconstant.BACKUP_SUFFIX) if not status02: showerror('Error', message02) return False # --- Info message showinfo('Note', 'The xml files are processed, please verify them later.') return True
def create_MockDTO(entityDto, transDto, mock_ds_name, isCopy): ''' create Observable Object @param copyFromBlDto: if the mock DTO is copied from the generated one ''' #path constant fileconstant = File_constant() tsconstant = TS_constant() proj_path = transDto.get_projectpath() # get the main table interface name main_tb_name = entityDto.get_maintableInterDTO().get_class_name() # copy from the generated ds if isCopy == 1: # get the generated ds name gene_ds_name = fileconstant.TS_DATASET_PREFIX + main_tb_name + fileconstant.TS_SUFFIX # get the generated ds full path gene_ds_filefullpath = proj_path + fileconstant.RESOURCE_TS_MAIN_PATH + fileconstant.RESOURCE_TS_DTO_BL_FOLDER + gene_ds_name # get the mock ds full path mock_ds_filefullpath = proj_path + fileconstant.RESOURCE_TS_MAIN_PATH + fileconstant.RESOURCE_TS_DTO_UI_FOLDER + mock_ds_name if not File_processor.verify_dir_existing(gene_ds_filefullpath): # throw error return False, 'The DTO %s does not generated in bl folder, please check.' % gene_ds_name # buffer the content of generated ds with open(gene_ds_filefullpath, 'r') as file: lines = file.readlines() # write the mock ds if not File_processor.verify_dir_existing(mock_ds_filefullpath): # create file Path(mock_ds_filefullpath).touch() # ------------------------------------------------------- # # ----- open the mock ds file ----- # ------------------------------------------------------- # newfile = open(mock_ds_filefullpath, 'w') comment_flag = False for line in lines: if tsconstant.TS_LEFT_COMMENT in line: comment_flag = True elif tsconstant.TS_RIGHT_COMMENT in line: comment_flag = False if line[:6] == tsconstant.TS_KEYWORD_MODULE: line = line.replace(tsconstant.TS_DTO_MODULE, tsconstant.TS_DTO_UI_MODULE) if not comment_flag and tsconstant.TS_COLON in line: line = line.replace( tsconstant.TS_COLON, tsconstant.TS_QUESTION_MARK + tsconstant.TS_COLON) newfile.write(line) newfile.close() return True, None
def create_TS_ObserObj(entityDto, transDto, filename): ''' create Observable Object ''' #path constant fileconstant = File_constant() tsconstant = TS_constant() business_entity_name = entityDto.get_businessentityname() proj_path = transDto.get_projectpath() controller_dto = entityDto.get_dataControllerDTO() # get the parent package name parent_pack = Java_processor.analysis_dataController_package_name( controller_dto.get_class_package()) # get the file full path filefullpath = proj_path + fileconstant.RESOURCE_TS_MAIN_PATH + fileconstant.RESOURCE_TS_DTO_UI_FOLDER + filename # additional references additional_reference = [] # imports import_list = [] # temp lines temp_lines = [] # ------------------------------------------------------- # # ----- preparation ----- # TODO: grid obj # ------------------------------------------------------- # for ajaxMtd in controller_dto.get_class_methods(): # skip the method without parameters if len(ajaxMtd.get_method_ajax_resp()) == 0: continue # get the response parameters ajax_temp = '' for ajaxResp in ajaxMtd.get_method_ajax_resp(): # convert the java type to TS type ajax_para_type_temp = TS_processor.convertJavaTypeToTSType( ajaxResp.get_parameter_type()) # verify and convert container type if ajax_para_type_temp.endswith( fileconstant.JAVA_CONTAINER_SUFFIX): # add import import_name = ajax_para_type_temp[:-9] import_prefix_part = '' import_cells = ajaxResp.get_parameter_import().split( tsconstant.TS_DOT_MARK) idx = 0 while idx < len(import_cells): if idx != len(import_cells) - 1: import_prefix_part = import_prefix_part + import_cells[ idx] + tsconstant.TS_DOT_MARK idx = idx + 1 import_temp = tsconstant.TS_OBSERVABLE_OBJ_NAMESPACE_TEMP % ( import_name, import_prefix_part, business_entity_name, import_name + 's') import_list.append(tsconstant.TS_TAB + import_temp) # add additional references reference_temp = tsconstant.TS_OBSERVABLE_OBJ_REFERENCE_TEMP % ( 'bl', import_name) additional_reference.append(reference_temp) # convert the Container type to import name ajax_para_type_temp = import_name ajax_temp = ajax_temp + '\n' + tsconstant.TS_TAB + tsconstant.TS_TAB + ajaxResp.get_parameter_name( ) + ': ' + ajax_para_type_temp + tsconstant.TS_END_MARK ajaxMtd_name = ajaxMtd.get_method_name() ajaxMtd_name = ajaxMtd_name[:1].upper() + ajaxMtd_name[1:] line = tsconstant.TS_TAB + tsconstant.TS_OBSERVABLE_OBJ_RESPONSE_TEMPLATE % ( ajaxMtd_name, ajax_temp) temp_lines.append(line) temp_lines.append('\n') if not File_processor.verify_dir_existing(filefullpath): # create file Path(filefullpath).touch() # ------------------------------------------------------- # # ----- open the observable object file ----- # ------------------------------------------------------- # file = open(filefullpath, 'w') # ------------------------------------------------------- # # ----- write the common references ----- # ------------------------------------------------------- # for temp_ref in tsconstant.TS_REFERENCE_COMMON_REFERENCES: file.write(temp_ref) file.write('\n') # ------------------------------------------------------- # # ----- write the common references ----- # ------------------------------------------------------- # for temp_ref in additional_reference: file.write(temp_ref) file.write('\n') file.write('\n') # ------------------------------------------------------- # # ----- write the observable object header ----- # ------------------------------------------------------- # temp_header = tsconstant.TS_OBSERVABLE_OBJ_HEADER % ( parent_pack, business_entity_name.lower(), business_entity_name) file.write(temp_header) file.write('\n') # ------------------------------------------------------- # # ----- write the imports ----- # ------------------------------------------------------- # for temp_ref in import_list: file.write(temp_ref) file.write('\n') file.write('\n') # ------------------------------------------------------- # # ----- write the observable object content ----- # ------------------------------------------------------- # for sub_line in temp_lines: file.write(sub_line) file.write(tsconstant.TS_RIGHT_BRACE) file.close() return True, None
def create_widges(self): javaconstant = Java_constant() #frame self.__frame1 = FormatableFrame(self) self.__frame1.pack(side=TOP) #Title self.__label01 = Label(self.__frame1, text="ServiceImpl generator options", width=45) self.__label01.pack(side=TOP, fill=X, ipady=10) #---- java validation flag self.__error = None self.__result = True #---- panel 01 ---------- canv1 = Canvas(self, height=30, width=550) #label self.__label01 = Label(canv1, text='ServiceImpl name :') self.__label01.place(height=20, width=130, relx=0.03, rely=0.2) #input self.__feet = StringVar() self.__dicinput = Entry(canv1, textvariable=self.__feet, borderwidth=3, bg='black', foreground='yellow', highlightcolor='red', insertbackground='red') self.__dicinput.place(height=20, width=250, relx=0.3, rely=0.2) canv1.pack() #---- panel 02 ---------- serviceInterDTO = self.get_dtos().get_serviceInterDTO() if not serviceInterDTO: self.__pack_errorpanel() return canv2 = Canvas(self, height=150, width=550) #label01 self.__label01 = Label(canv2, text='Select the functions :') self.__label01.place(height=20, width=150, relx=0.01, rely=0.05) #left listbox and scrollbar self.__listboxleft = Listbox(canv2, width=30) self.__scrollleft = Scrollbar(canv2) self.__listboxleft.config(yscrollcommand=self.__scrollleft.set) self.__listboxleft.place(height=120, width=220, relx=0.02, rely=0.18) self.__scrollleft.place(height=120, width=20, relx=0.42, rely=0.18) self.__scrollleft.config(command=self.__listboxleft.yview) #middle buttons self.__button01 = Button(canv2, text='>', relief=RAISED, cursor='hand2') self.__button01.bind( '<Button-1>', self.__to_right_click_event) #bind button click event self.__button01.place(height=25, width=25, relx=0.465, rely=0.2) self.__button02 = Button(canv2, text='>>', relief=RAISED, cursor='hand2') self.__button02.bind( '<Button-1>', self.__all_to_right_click_event) #bind button click event self.__button02.place(height=25, width=25, relx=0.465, rely=0.4) self.__button03 = Button(canv2, text='<', relief=RAISED, cursor='hand2') self.__button03.bind( '<Button-1>', self.__to_left_click_event) #bind button click event self.__button03.place(height=25, width=25, relx=0.465, rely=0.6) self.__button04 = Button(canv2, text='<<', relief=RAISED, cursor='hand2') self.__button04.bind( '<Button-1>', self.__all_to_left_click_event) #bind button click event self.__button04.place(height=25, width=25, relx=0.465, rely=0.8) #right listbox and scrollbar self.__listboxright = Listbox(canv2, width=30) self.__scrollright = Scrollbar(canv2) self.__listboxright.config(yscrollcommand=self.__scrollright.set) self.__listboxright.place(height=120, width=220, relx=0.52, rely=0.18) self.__scrollright.place(height=120, width=20, relx=0.92, rely=0.18) self.__scrollright.config(command=self.__listboxright.yview) canv2.pack() #---- panel 03 ---------- canv3 = Canvas(self, height=100, width=550) #label label1 = Label(canv3, text='Options:') label1.place(height=20, width=60, relx=0, rely=0) #radio box self.__vari1 = IntVar() self.__rad1 = Radiobutton(canv3, text='Re-write the previous file', variable=self.__vari1, value=1) self.__rad1.place(height=20, width=170, relx=0.1, rely=0.2) self.__rad1.select() self.__rad2 = Radiobutton(canv3, text='Attach new functions to the file', variable=self.__vari1, value=2) self.__rad2.place(height=20, width=210, relx=0.1, rely=0.45) self.__rad2.deselect() self.__rad3 = Radiobutton(canv3, text='Save the previous file as backup', variable=self.__vari1, value=3) self.__rad3.place(height=20, width=220, relx=0.1, rely=0.7) self.__rad3.deselect() canv3.pack() # set the serviceImpl name fileconstant = File_constant() serviceImpl_name = self.get_dtos().get_businessentityname( ) + fileconstant.SERVICEIMPL_SUFFIX + fileconstant.JAVA_SUFFIX self.__feet.set(serviceImpl_name) #set the function list to the left box for javaMtd in serviceInterDTO.get_class_methods(): self.__funclists[javaMtd.get_method_name()] = javaMtd # CRUD functions are mandatory if javaMtd.get_method_name( ) == javaconstant.JAVA_FUNCTION_CREATE or javaMtd.get_method_name( ) == javaconstant.JAVA_FUNCTION_UPDATE or javaMtd.get_method_name( ) == javaconstant.JAVA_FUNCTION_DELETE or javaMtd.get_method_name( ) == javaconstant.JAVA_FUNCTION_FETCH: self.__listboxright.insert(END, javaMtd.get_method_name()) continue #add items into list box self.__listboxleft.insert(END, javaMtd.get_method_name())
def verify_proj_files(self): ''' verify the project fiels ''' #path constant fileconstant = File_constant() entity_name = self.get_dtos().get_entityname() proj_path = self.get_trans().get_projectpath() #verify view metadata view_exist = False viewfullpath = self.get_dtos().get_viewfullpath() if not viewfullpath and entity_name: viewfullpath = proj_path + fileconstant.VIEW_METADATA_PATH + entity_name + fileconstant.XML_SUFFIX view_exist, self.__message = Xmlfile_processor.veriy_view_metadata( viewfullpath) elif viewfullpath: view_exist = True if view_exist: newlabel01 = "< passed >" self.__label04.config(text=newlabel01, fg='blue') self.get_dtos().set_viewfullpath(viewfullpath) self.__checkstatus['ViewMetadata'] = [True, self.__checkval01] else: newlabel01 = "< failed >" self.__label04.config(text=newlabel01, fg='red') btnlabel = 'Correct' self.__button01.config(text=btnlabel) self.__checkstatus['ViewMetadata'] = [False, self.__checkval01] self.__checkval01.set(1) #bind button click event self.__button01.bind( '<Button-1>', self.event_adapter(self.detal_button_click, iscorrect=self.__checkstatus['ViewMetadata'][0], filename=entity_name + fileconstant.XML_SUFFIX, filetype='ViewMetadata', filepath=viewfullpath)) #verify source metadata resource_exist = False resourcefullpath = self.get_dtos().get_resourcefullpath() if not resourcefullpath and entity_name: resourcefullpath = proj_path + fileconstant.RESOURCE_METADATA_PATH + entity_name + fileconstant.RESOURCE_METADATA_SUFFIX resource_exist, self.__message = Xmlfile_processor.veriy_resource_metadata( resourcefullpath) if resource_exist: newlabel = "< passed >" self.__label06.config(text=newlabel, fg='blue') self.get_dtos().set_resourcefullpath(resourcefullpath) self.__checkstatus['ResourceMetadata'] = [True, self.__checkval02] else: newlabel = "< failed >" self.__label06.config(text=newlabel, fg='red') btnlabel = 'Correct' self.__button02.config(text=btnlabel) self.__checkstatus['ResourceMetadata'] = [False, self.__checkval02] self.__checkval02.set(1) self.__button02.bind( '<Button-1>', self.event_adapter( self.detal_button_click, iscorrect=self.__checkstatus['ResourceMetadata'][0], filename=entity_name + fileconstant.RESOURCE_METADATA_SUFFIX, filetype='ResourceMetadata', filepath=resourcefullpath)) #verify pom result, self.__message = Xmlfile_processor.verify_pom( proj_path + fileconstant.POM_PATH) if result: #read the pom result, pomDto, self.__message = Xmlfile_processor.read_pom( proj_path + fileconstant.POM_PATH) newlabel = "< passed >" self.__label08.config(text=newlabel, fg='blue') self.get_trans().set_pomDto(pomDto) self.__checkstatus['Pom'] = [True, self.__checkval03] else: newlabel = "< failed >" self.__label08.config(text=newlabel, fg='red') btnlabel = 'Correct' self.__button03.config(text=btnlabel) self.__checkstatus['Pom'] = [False, self.__checkval03] self.__checkval03.set(1) self.__button03.bind( '<Button-1>', self.event_adapter(self.detal_button_click, iscorrect=self.__checkstatus['Pom'][0], filename='pom.xml', filetype='POM', filepath=proj_path + fileconstant.POM_PATH)) #verify beans-app-context result, self.__message = Xmlfile_processor.verify_beans_app_context( proj_path + fileconstant.BEAN_APP_CONTEXT_PATH) if result: newlabel = "< passed >" self.__label10.config(text=newlabel, fg='blue') self.get_trans().set_pomDto(pomDto) self.__checkstatus['beans-app-context'] = [True, self.__checkval04] else: newlabel = "< failed >" self.__label10.config(text=newlabel, fg='red') btnlabel = 'Correct' self.__button04.config(text=btnlabel) self.__checkstatus['beans-app-context'] = [ False, self.__checkval04 ] self.__checkval04.set(1) self.__button04.bind( '<Button-1>', self.event_adapter( self.detal_button_click, iscorrect=self.__checkstatus['beans-app-context'][0], filename='beans-app-server.xml', filetype='beans', filepath=proj_path + fileconstant.BEAN_APP_CONTEXT_PATH)) #verify entityMap result, self.__message = Xmlfile_processor.verify_entity_map( proj_path + fileconstant.ENTITY_MAP_PATH) if result: newlabel = "< passed >" self.__label12.config(text=newlabel, fg='blue') self.get_trans().set_pomDto(pomDto) self.__checkstatus['entityMap'] = [True, self.__checkval05] else: newlabel = "< failed >" self.__label12.config(text=newlabel, fg='red') btnlabel = 'Correct' self.__button05.config(text=btnlabel) self.__checkstatus['entityMap'] = [False, self.__checkval05] self.__checkval05.set(1) self.__button05.bind( '<Button-1>', self.event_adapter(self.detal_button_click, iscorrect=self.__checkstatus['entityMap'][0], filename='entityMap.xml', filetype='entityMap', filepath=proj_path + fileconstant.ENTITY_MAP_PATH)) #verify jar result = False jarname = None implJarfullpath = self.get_trans().get_finImplJarPath() apiJarfullpath = self.get_trans().get_finApiJarPath() #verify if jar is existing at the Maven's default repository #impl jar if not implJarfullpath: userhomepath = File_processor.get_user_home( ) + fileconstant.IMPL_JAR_LIB_PATH #jar name and full path implJarfullpath = userhomepath + pomDto.get_financials_api_version( ) + '\\' + fileconstant.FIN_IMPL_JAR_PREFIX + pomDto.get_financials_api_version( ) + fileconstant.JAR_SUFFIX jarname = fileconstant.FIN_IMPL_JAR_PREFIX + pomDto.get_financials_api_version( ) + fileconstant.JAR_SUFFIX result, self.__message = Java_processor.verify_jar_type( implJarfullpath) if result: newlabel = "< passed >" self.__label92.config(text=newlabel, fg='blue') self.get_trans().set_finImplJarPath(implJarfullpath) self.__checkstatus['ImplJAR'] = [True, self.__checkval91] else: newlabel = "< failed >" self.__label92.config(text=newlabel, fg='red') btnlabel = 'Correct' self.__button91.config(text=btnlabel) self.__checkstatus['ImplJAR'] = [False, self.__checkval91] else: newlabel = "< passed >" self.__label92.config(text=newlabel, fg='blue') self.__checkstatus['ImplJAR'] = [True, self.__checkval91] #jar name jarname = File_processor.get_file_name( self.get_trans().get_finImplJarPath()) self.__checkval91.set(1) self.__button91.bind( '<Button-1>', self.event_adapter(self.detal_button_click, iscorrect=self.__checkstatus['ImplJAR'][0], filename=jarname, filetype='ImplJAR', filepath=implJarfullpath)) # api jar if not apiJarfullpath: userhomepath = File_processor.get_user_home( ) + fileconstant.API_JAR_LIB_PATH #jar name and full path apiJarfullpath = userhomepath + pomDto.get_financials_api_version( ) + '\\' + fileconstant.FIN_API_JAR_PREFIX + pomDto.get_financials_api_version( ) + fileconstant.JAR_SUFFIX jarname = fileconstant.FIN_IMPL_JAR_PREFIX + pomDto.get_financials_api_version( ) + fileconstant.JAR_SUFFIX result, self.__message = Java_processor.verify_jar_type( apiJarfullpath) if result: newlabel = "< passed >" self.__label94.config(text=newlabel, fg='blue') self.get_trans().set_finApiJarPath(apiJarfullpath) self.__checkstatus['ApiJAR'] = [True, self.__checkval92] else: newlabel = "< failed >" self.__label94.config(text=newlabel, fg='red') btnlabel = 'Correct' self.__button92.config(text=btnlabel) self.__checkstatus['ApiJAR'] = [False, self.__checkval92] else: newlabel = "< passed >" self.__label94.config(text=newlabel, fg='blue') self.__checkstatus['ApiJAR'] = [True, self.__checkval92] #jar name jarname = File_processor.get_file_name( self.get_trans().get_finImplJarPath()) self.__checkval92.set(1) self.__button92.bind( '<Button-1>', self.event_adapter(self.detal_button_click, iscorrect=self.__checkstatus['ApiJAR'][0], filename=jarname, filetype='ApiJAR', filepath=apiJarfullpath))