def estimate_federal_taxes(self): number_of_quarters_in_consideration = (self.quarter_of_year % 4) + 1 fraction_of_year = (float(number_of_quarters_in_consideration)) / 4.0 long_term_capital_gains = self.long_term_capital_gain_per_year.get(self.year) long_term_capital_gains_before_capital_loss_application = long_term_capital_gains long_term_capital_loss_application = min(long_term_capital_gains, self.capitalLossYearlyMaxFederal, self.totalLongTermCapitalLossFederal) short_term_capital_gains = self.short_term_capital_gain_per_year.get(self.year) dividends = self.dividends_per_year.get(self.year) long_term_capital_gains = long_term_capital_gains - long_term_capital_loss_application estimate_of_taxes = self.estimate_of_federal_taxes_so_far_this_year(fraction_of_year, long_term_capital_gains, short_term_capital_gains, dividends) if number_of_quarters_in_consideration == 4: total_income = (short_term_capital_gains+dividends+long_term_capital_gains_before_capital_loss_application- long_term_capital_loss_application) if total_income == 0: effectiveTaxRate = "N/A" else: effectiveTaxRate = "%s%%"%(int(100*estimate_of_taxes/total_income )) self.totalLongTermCapitalLossFederal = self.totalLongTermCapitalLossFederal - long_term_capital_loss_application log("%s Year Federal Tax Summary: Long-Term Cap Gain: %s - %s Income: %s Yearly Federal Tax: %s (%s) Carry For. Cap. Loss:%s"%(self.year, printCash(long_term_capital_gains_before_capital_loss_application),printCash(long_term_capital_loss_application), printCash(dividends + short_term_capital_gains ) , printCash(estimate_of_taxes),effectiveTaxRate ,printCash(self.totalLongTermCapitalLossFederal))) if estimate_of_taxes < 0: estimate_of_taxes = 0 previous_quarter_to_subtract = self.quarter previous_quarter_of_year_to_subtract = self.quarter_of_year while previous_quarter_of_year_to_subtract >= 0 and previous_quarter_to_subtract >= 0 : prev_paid = self.estimated_taxes_paid_per_quarter.get(previous_quarter_to_subtract) #log("subtracting %s from estimated taxes (paid Q%s (quarter %s))"%(prev_paid, previous_quarter_of_year_to_subtract + 1, previous_quarter_to_subtract)) estimate_of_taxes = estimate_of_taxes - prev_paid previous_quarter_to_subtract = previous_quarter_to_subtract - 1 previous_quarter_of_year_to_subtract = previous_quarter_of_year_to_subtract - 1 estimate_of_taxes = max(estimate_of_taxes, 0) return roundCash(estimate_of_taxes)
def volume(self, level): if not self.working: self.working = True self._send(self._volume(level)) self.working = False else: log("Timebox: working..")
def testFormats(self): log(3, 'testing Formats') assert formats.count() > 0 assert not formats['xml'] == None assert formats['xml'].name['EN'] > '' assert formats['xml'].description['EN'] > '' log(3, 'testing Formats done')
def setTimeColor(self, r, g, b, x=0x00): if not self.working: self.working = True self._send(self._set_time_color(r, g, b, x)) self.working = False else: log("Timebox: working..")
def login(req, username, password): user = dms.username.get_by_id(username) if user and user.username==username: if user.password == password: if not sessions.has_key(username): sessions.add(username, req.connection.remote_addr[0]) # establish random 20 character session_id. # chars = string.letters + string.digits session_id = '' for x in range(20): session_id += whrandom.choice(chars) user.session_id = session_id user.save() log(3, 'setting cookie') req.headers_out['Set-Cookie']='lampadas=' + session_id + '; path=/; expires=Wed, 09-Nov-2030 23:59:00 GMT' uri = URI('home' + referer_lang_ext(req)) uri.base = '../../' return page_factory.page(uri) else: return "Wrong password" else: return "User not found"
def testFormats(self): log(3, 'testing Formats') assert formats.count() > 0 assert not formats['xml']==None assert formats['xml'].name['EN'] > '' assert formats['xml'].description['EN'] > '' log(3, 'testing Formats done')
def computeError(self, Res, method="None"): """ Compute median absolute and relative errors """ absErr = np.abs(Res - self.trueRes) idx_nonzero = np.where(self.trueRes != 0) absErr_nonzero = absErr[idx_nonzero] true_nonzero = self.trueRes[idx_nonzero] relErr = absErr_nonzero / true_nonzero # log_str_rel = "\n".join(map(str, relErr)) # log_str_abs = "\n".join(map(str, absErr)) if Params.IS_LOGGING: log_str = "" for i in range(len(self.query_list)): area = rect_area(self.query_list[i]) query_str = str(self.query_list[i][0][0]) + "\t" + str(self.query_list[i][0][1]) + "\t" + str( self.query_list[i][1][0]) + "\t" + str(self.query_list[i][1][1]) + "\t" + str(area) err_str = str(self.trueRes[i]) + "\t" + str(Res[i]) + "\t" + str(absErr[i]) + "\t" + str(relErr[i]) log_str = log_str + query_str + "\t" + err_str + "\n" log(method, log_str) absErr = np.sort(absErr) relErr = np.sort(relErr) n_abs = len(absErr) n_rel = len(relErr) return absErr[int(n_abs / 2)], relErr[int(n_rel / 2)]
def signOut(): global currentTitle, currentUser, currentEmployee """ Sign out """ log(ID, "{} Signed out".format(currentUser)) currentTitle = None currentUser = None currentEmployee = None
def selectSpecificStore(code): store_selectSql = f"Select * from store where code = {code}" DB_PATH = ProjectStaticData.DB_PATH try: conn = sqlite3.connect(DB_PATH) conn.row_factory = sqlite3.Row cur = conn.cursor() cur.execute(store_selectSql) data = cur.fetchone() if data is not None: resultData = { 'code' : data['code'], 'name' : data['name'], 'lat' : data['lat'], 'lng' : data['lng'], 'remain_stat' : data['remain_stat'], 'stock_at' : data['stock_at'], 'created_at' : data['created_at'], 'remain_num' : data['remain_num'] } log(f"resultData : {resultData}") return resultData except Error as e: log((str(e))) finally: if conn: conn.close()
def dumpSequenceCounts(self, actual, filename): """ Dump counts for each left node across multiple time instances :param actual: actual count, otherwise noisy count :param filename: dump file :return: """ sequences = [] for x1 in range(len(self.root.children)): for y1 in range(len(self.root.children)): child_l1 = self.root.children[x1][y1] if child_l1.n_isLeaf or child_l1.children is None: if actual: sequences.append(child_l1.a_count) else: sequences.append(child_l1.l_count) else: for x2 in range(len(child_l1.children)): for y2 in range(len(child_l1.children)): if actual: sequences.append(self.root.children[x1][y1].children[x2][y2].a_count) else: sequences.append(child_l1.self.root.children[x1][y1].children[x2][y2].l_count) content = "" for s in sequences: if not actual: content += "\t".join([str(float("%.1f" % n)) for n in s]) else: content += "\t".join([str(n) for n in s]) content = content + "\n" log(filename, content) return sequences
async def _dispatch(self, message): if message.writeToLog: logMessage(message) log("Bot: logging message %s" % message) if message.destination == TARGETS.SYSTEM: message.sourceSocket.write_message( Factory.toClient(System.answer(message))) elif message.destination == TARGETS.CLIENT or message.destination == TARGETS.BOT: #log("Bot._dispatch() %s to %s " % (message, sockets)) data = Factory.toClient(message) if message.destinationSocket: message.destinationSocket.write_message(data) else: print("Writing to sockets: %s" % data.__str__()) for socket in sockets: socket.write_message(data) elif message.destination == TARGETS.PHONE: msg = Factory.toPhone(message) print("Writing to phone: %s" % msg) PhoneLLA.connection.transport.write(msg) await gen.sleep(0.1)
def readMoveCoordinates(self): ''' Alog:- 1. Get board state 2. if board state not present add it 3. *Get all possible moves from ai_moves of current board state 4. Get best move 5. get final coordinate 5. move it 6. save last move :return: (row, col, final_row, final_col) ''' log(str(CLASS_NAME) + ": readMoveCoordinates()") print("Playing:", self.name) board_state = self.boardState() self.addBoardState() best_move = self.bestMove(board_state) log("best_move = " + str(best_move)) row, col, move_type = best_move print("Select Pawn:-") print("Row:", row) print("Column:", col) final_row, final_col = self.board.finalCoordinateForMove( self.player, row, col, move_type) self.setLastState(board_state, best_move) print("Select Position to move to:-") print("Row:", final_row) print("Column", final_col) return int(row), int(col), int(final_row), int(final_col)
def close(): global conn, cur if not conn: log(ID, "Not connected!") return cur.close() conn.close()
def dumpSequenceCounts(self, actual, filename): """ Dump counts for each left node across multiple time instances :param actual: actual count, otherwise noisy count :param filename: dump file :return: """ sequences = [] for x1 in range(len(self.AGs[0].root.children)): for y1 in range(len(self.AGs[0].root.children)): child_l1 = self.AGs[0].root.children[x1][y1] if child_l1.n_isLeaf or child_l1.children is None: sequence_l1 = [self.getCountAt(actual, i, x1, y1) for i in range(self.instances)] sequences.append(sequence_l1) else: for x2 in range(len(child_l1.children)): for y2 in range(len(child_l1.children)): # child_l2 = child_l1.children[x2][y2] sequence_l2 = [self.getCountAt(actual, i, x1, y1, x2, y2) for i in range(self.instances)] sequences.append(sequence_l2) content = "" for s in sequences: if not actual: content += "\t".join([str(float("%.1f" % n)) for n in s]) else: content += "\t".join([str(n) for n in s]) content = content + "\n" log(filename, content) del sequences
def finalCoordinateForMove(self, player, row, col, move): ''' :param player: :param row: :param col: :param move: :return: ''' log(CLASS_NAME + ": finalCoordinateForMove()") log("Initial: " + str(row) + ", " + str(col) + "; Move: " + MOVE_NAMES[move]) self.checkPlayerValidity(player) self.checkCoordinateValidity(row, col) self.checkPlayerMoveValidity(player, move) if move == UP: final_row, final_col = (row - 1, col) elif move == DOWN: final_row, final_col = (row + 1, col) elif move == DIAGONAL_UP_LEFT: final_row, final_col = (row - 1, col - 1) elif move == DIAGONAL_UP_RIGHT: final_row, final_col = (row - 1, col + 1) elif move == DIAGONAL_DOWN_LEFT: final_row, final_col = (row + 1, col - 1) elif move == DIAGONAL_DOWN_RIGHT: final_row, final_col = (row + 1, col + 1) return final_row, final_col
def draw(self, bw, red): one_bit_bw = bw.convert("1", dither=Image.NONE) one_bit_red = red.convert("1", dither=Image.NONE) log(LogLevel.INFO, LogCategory.EINK, "Drawing to display") self.epd.display(self.epd.getbuffer(one_bit_bw), self.epd.getbuffer(one_bit_red))
def send_fcm_notification(self, ids, title, body, data): log(f"{ids},{title}, {body}, {data}") # fcm 푸시 메세지 요청 주소 url = 'https://fcm.googleapis.com/fcm/send' # 인증 정보(서버 키)를 헤더에 담아 전달 headers = { 'Authorization': 'key=AAAAqXiHCc8:APA91bG4e3EziToT1lyD1RifljyBTOmTdi1PJ4Lqq5OYWqlq-Dwr8i8Q5Ca4ho8XdRzicorNgGivm8togjBMgitOHEMW3y9UA0sq6Tv-snuq2DDJOt6_T54Uaju5Qmtwn3uGHDngIt1C', 'Content-Type': 'application/json; UTF-8', } data['title'] = title data['body'] = body # 보낼 내용과 대상을 지정 content = { 'to': ids, 'notification': { "sound": "default", 'title': title, 'body': body, "content_available": True }, 'data': data, "priority": "high" } log(content) # json 파싱 후 requests 모듈로 FCM 서버에 요청 response = requests.post(url, data=json.dumps(content), headers=headers) print(response.json)
def fromClient(text:str, sourceSocket) -> Message: try: #log("Factory.fromClient(): %s" % text) array = text.split(',') type = array[0] if type == "phone": return Message( type=TYPES.PHONE_REQUEST, source=TARGETS.CLIENT, destination=TARGETS.PHONE, sourceSocket=sourceSocket, data={"cmd":",".join(array[1:])}) elif type == "phonelog": return Message( type=TYPES.PHONELOG, source=TARGETS.CLIENT, destination=TARGETS.SYSTEM, sourceSocket=sourceSocket) except Exception as e: log("MessageFactory: invalid client request, data: %s" % text) return Message( type=TYPES.PHONE_INVALID_REQUEST, source=TARGETS.BOT, destination=TARGETS.CLIENT, sourceSocket=sourceSocket, data={ "error" : "invalid request"} )
def start(self): data = cherrypy.request.json snake_id = data['you']['id'] self.strategy[snake_id] = BasicStrategy(data) log("START") log(data) return {"color": "#9BC4E2", "headType": "bendr", "tailType": "bolt"}
def initializeSession(existingSessionID, request, response): print(f'initializeSession: type of sessionID = {type(existingSessionID)}') log('initializeSession', f'oldSessionID = {existingSessionID}', sessionID=existingSessionID) print(type(existingSessionID)) if isNone(existingSessionID): sessionID = makeNewSessionID() else: sessionID = existingSessionID if not ifSessionExistsInDB(sessionID): # response.log.append(f'initializeSession: ifSessionExistsInDB = True<br/>') # deleteSession(oldSessionID, request, response) # remove session from db and cookie (failsafe) # newSessionID = makeNewSessionID() _initializeDbSession(sessionID) if HTTPCookie.getSessionCookie(request) != sessionID: HTTPCookie.setSessionCookie(response, sessionID) # cookieID = HTTPCookie.getSessionCookie(request) # response.log.append(f'initializeSession: after initialization of newSessionID getSessionCookie = {cookieID}<br/>') # else: # response.log.append(f'initializeSession: cookieID is not in DB<br/>') # HTTPCookie.setSessionCookie(response, sessionID) # response.log.append(f'initializeSession: after setSessionCookie to sessionID, getSessionCookie = {HTTPCookie.getSessionCookie(request)}<br/>') # if cookieID and cookieID != sessionID: # HTTPCookie.deleteSessionCookie(response) # HTTPCookie.setSessionCookie(response, cookieID) # response.log.append(f'initializeSession: after setSessionCookie, getSessionCookie = {HTTPCookie.getSessionCookie(request)}<br/>') log('initializeSession', f'exit', sessionID=sessionID) return sessionID
def update(self): self.normalize() if self.badSetup: log(self.ID, "Employee is invalid") return if not self.exists: log(self.ID, "Employee does not exist yet, did you mean to create?") return _first_name = "first_name='{}'".format(self.first_name) _last_name = "last_name='{}'".format(self.last_name) _ssn = "ssn='{}'".format(self.ssn) _job_title = "job_title='{}'".format(self.job_title) _salary_type = "salary_type='{}'".format(self.salary_type) _insurancePlan = "insurancePlan='{}'".format(self.insurancePlan) _email = "email='{}'".format(self.email) _country = "country='{}'".format(self.country) _state = "state='{}'".format(self.state) _street_name = "street_name='{}'".format(self.street_name) _postal_code = "postal_code='{}'".format(self.postal_code) _F01k_deduction = "F01k_deduction='{}'".format(self.F01k_deduction) _rate = "rate='{}'".format(self.rate) _hours = "hours='{}'".format(self.hours) DB.execute( Query.UPDATE_SINGLE( Entity.EMPLOYEE, self.e_id, _first_name, _last_name, _ssn, _job_title, _salary_type, _insurancePlan, _email, _country, _state, _street_name, _postal_code, _F01k_deduction, _rate, _hours, ) ) # TODO: Only modify tables that actually changed DB.execute(Query.DELETE(Relation.HAS, "e_id='{}'".format(self.e_id))) DB.execute(Query.DELETE(Multivalue.EMPLOYEE_PHONE, "e_id='{}'".format(self.e_id))) DB.execute(Query.DELETE(Multivalue.EMPLOYEE_BENEFIT_SELECTION, "e_id='{}'".format(self.e_id))) for d in self.Dependents: DB.execute(Query.CREATE(Relation.HAS, self.e_id, d)) for p in self.PhoneNumbers: DB.execute(Query.CREATE(Multivalue.EMPLOYEE_PHONE, self.e_id, p)) for b in self.Benefits: DB.execute(Query.CREATE(Multivalue.EMPLOYEE_BENEFIT_SELECTION, self.e_id, b))
def switchView(self, type): log("Timebox.switchView() %s" % (type)) if not self.working: self.working = True self._send(self._switch_view(type)) else: log("Timebox: working..")
def newNote(self, handler, note): lines = [ "task: %s" % note.task.link(), "user: %s" % note.user, "body: %s" % note.safe.body ] log(handler, 'note.new', "\n".join(lines))
def close_browser(self): if self.browser is None: log('Browser already closed or not created') return self.browser.quit() self.browser = None log('Browser closed') return
def make(self, name='all'): log(3, 'Running project Makefile target: ' + name) for doc_id in self.sort_by('doc_id'): doc = dms.document.get_by_id(doc_id) if doc.pub_status_code<>'N': continue log(3, 'Making document: ' + str(doc_id)) self[doc_id].make(name)
def randomClockColor(self): if not self.working: self.working = True self.setTimeColor(random.randint(0, 8), random.randint(0, 8), random.randint(0, 8)) self.working = False else: log("Timebox: working..")
def run(): if not Bot.instance: log("Bot: starting") Bot.instance = Bot() try: IOLoop.current().start() except: IOLoop.current().stop()
def refresh(self, ip_address, uri=''): sql = 'UPDATE session SET updated=now(), ip_address=' + wsq(ip_address) + ', uri=' + wsq(uri) + ' WHERE username='******'\'s session expired, recreating it.') sql = 'INSERT INTO session(username) VALUES (' + wsq(self.username) + ')' db.runsql(sql) db.commit()
def send_Text(req, text): """ Send a text message. """ log(3, 'Sending text') req.content_type = 'text/plain' add_headers(req, len(text)) req.send_http_header() req.write(text)
def scan(): rfidTag = rfidRead(serial) #From RFID.py returns tag scanned as a string name = lookUpName(rfidTag, database) #Returns 0 if no match in database. if name: log(rfidTag, database) #Simply adds log file with time and tag to database. hours = update_logged_in(rfidTag, database)#Logs in/out person and updates hours if needed. display(rfidTag, hours, name, database)#Runs BeagleDisplay1 as subprocess and pipes over data. else: print "Unknown Tag or Noise"
def testLicenses(self): log(3, 'testing Licenses') assert licenses.count() > 0 for key in licenses.keys(): license = licenses[key] assert license.short_name['EN'] > '' assert license.name['EN'] > '' assert license.description['EN'] > '' log(3, 'testing Licenses done')
def newGroup(self, handler, group): lines = [ group.safe.name, "sprint: %s" % group.sprint.link(None), "seq: %d" % group.seq, "deletable: %s" % group.deletable ] log(handler, 'group.new', "\n".join(lines))
def testTopics(self): log(3, 'testing Topics') assert not topics==None assert topics.count() > 0 keys = topics.keys() for key in keys: topic = topics[key] assert topic.name['EN'] > '' log(3, 'testing Topics done')
def testTopics(self): log(3, 'testing Topics') assert not topics == None assert topics.count() > 0 keys = topics.keys() for key in keys: topic = topics[key] assert topic.name['EN'] > '' log(3, 'testing Topics done')
def page(self, uri): if state.session: log(3, 'user: '******'404') html = self.build_page(page, uri) return html
def page(self, uri): if state.session: log(3, "user: "******"404") html = self.build_page(page, uri) return html
def testUserDocs(self): log(3, 'testing Sections') for key in sections.keys(): section = sections[key] assert section.static_count > -1 assert section.nonregistered_count > -1 assert section.nonadmin_count > -1 assert section.nonsysadmin_count > -1 assert section.name['EN'] > '' log(3, 'testing Sections done')
def _firetestcoords(self, arenawidth, arenaheight): # TODO: randomize aim a bit, have weapons with better accuracy a = self.aim x = self.bot.get('x') y = self.bot.get('y') l = max(arenawidth, arenaheight) * 2 x2 = int(round(x + l * math.cos(a))) y2 = int(round(y + l * math.sin(a))) log('fire: (' + str(self.aim) + '): ' + str(x) + ',' + str(y) + ' => ' + str(x2) + ',' + str(y2)) return (bresenham_line((x, y), (x2, y2)), x2, y2, l)
def result(): global conn, cur """Returns whatever result an execution returns, if any""" if not conn: log(ID, "Not connected!") return try: return cur.fetchall() except psycopg.ProgrammingError: return None
def dither(img): working_image_path = f"{image_path}/temp.png" img.save(working_image_path) log(LogLevel.INFO, LogCategory.DITHERING, "Dithering album art") dither_return_code = subprocess.call( [dither_path, working_image_path, working_image_path]) if not dither_return_code == 0: log(LogLevel.ERROR, LogCategory.DITHERING, "Dithering failed") exit(1) return Image.open(working_image_path)
def getTaxRate(self): self.normalize() if self.badSetup: log(self.ID, "Employee is invalid") return if not self.exists: log(self.ID, "Employee does not exist yet, did you mean to create?") return DB.execute(Query.FIND(Entity.STATE, self.state, "tax_rate")) return float(DB.result()[0][0])
def run(self): while self.program.poll() == None: try: self.input = self.program.stdout.readline().strip() if not self.input: try: self.error = self.program.stderr.readline().strip() except: pass break except: self.error = self.program.stderr.readline().strip() log("bot exit: " + str(self.error if self.error else self.input))
def testSourcefiles(self): log (3, 'testing Sourcefiles') for key in sourcefiles.keys(): sourcefile = sourcefiles[key] for key in sourcefile.documents.keys(): docfile = sourcefile.documents[key] assert docfile.filename==sourcefile.filename for key in sourcefile.errors.keys(): docerr = sourcefile.errors[key] assert docerr.filename==sourcefile.filename log (3, 'testing Sourcefiles done')
def newSprint(self, handler, sprint): lines = [ sprint.link(None), "project: %s" % sprint.project, "name: %s" % sprint.safe.name, "owner: %s" % sprint.owner, "active: %s - %s" % (tsToDate(sprint.start), tsToDate(sprint.end)), "members: %s" % ', '.join(map(str, sprint.members)) ] log(handler, 'sprint.new', "\n".join(lines))
def check_doc(self, doc_id): """ Check for errors at the document level. """ log(3, 'Running Lintadas on document ' + str(doc_id)) doc = dms.document.get_by_id(doc_id) # See if the document is maintained maintained = 0 for key in doc.users.keys(): docuser = doc.users[key] if docuser.active==1 and (docuser.role_code=='author' or docuser.role_code=='maintainer'): maintained = 1 doc.maintained = maintained # Clear any existing errors doc.errors.delete_by_keys([['err_type_code', '=', 'doc']]) # If document is not active or archived, do not flag # any errors against it. if doc.pub_status_code<>'N': return # Flag an error against the *doc* if there are no files. if doc.files.count()==0: err = doc.errors.new() err.doc_id = doc.id err.err_id = ERR_NO_SOURCE_FILE err.notes = '' doc.errors.add(err) else: # Count the number of top files. There muse be exactly one. # This takes advantage of the fact that true=1 and false=0. top = 0 for key in doc.files.keys(): if doc.files[key].top: top = top + 1 if top==0: err = doc.errors.new() err.doc_id = doc.id err.err_id = ERR_NO_PRIMARY_FILE err.notes = '' doc.errors.add(err) if top > 1: err = doc.errors.new() err.doc_id = doc.id err.err_id = ERR_TWO_PRIMARY_FILES err.notes = '' doc.errors.add(err) doc.lint_time = now_string() log(3, 'Lintadas run on document ' + str(doc_id) + ' complete')
def sprintInfoUpdate(self, handler, sprint, changes): lines = [sprint.link(None)] for k, v in changes.iteritems(): if v: if isinstance(v, (list, set)): v = ', '.join(map(str, v)) if k not in ('addMembers', 'delMembers'): v = stripTags(str(v)) lines.append("%s: %s" % (k, str(v))) log(handler, 'sprint.info.update', "\n".join(lines))
def logout(req, username): sessions.delete(username) user = dms.username.get_by_id(username) user.session_id = '' user.save() log(3, 'clearing cookie') req.headers_out['Set-Cookie']='lampadas=foo; path=/; expires=Wed, 09-Nov-1980 23:59:00 GMT' uri = URI('home' + referer_lang_ext(req)) uri.base = '../../' return page_factory.page(uri)
def testLanguages(self): log(3, 'testing Languages') assert not languages==None assert not languages['EN']==None assert languages['EN'].supported assert languages['EN'].name['EN']=='English' assert languages['FR'].supported assert languages['FR'].name['EN']=='French' assert languages['DE'].supported assert languages['DE'].name['EN']=='German' assert languages.count()==136 log(3, 'testing Languages done')
def testUserDocs(self): log(3, 'testing UserDocs') user = users['david'] assert user.documents.count() > 0 assert not user.documents==None for key in user.documents.keys(): userdoc = user.documents[key] assert not userdoc==None assert not userdoc.doc_id==None assert userdoc.doc_id > 0 assert userdoc.active==1 or userdoc.active==0 log(3, 'testing UserDocs done')
def newTask(self, handler, task): lines = [ task.name, "sprint: %s" % task.sprint.link(None), "group: %s" % task.group.safe.name, "creator: %s" % task.creator, "assigned: %s" % ' '.join(map(str, task.assigned)), "status: %s" % task.getStatus().text, "hours: %d" % task.hours, "seq: %d" % task.seq ] log(handler, 'task.new', "\n".join(lines))
def check_file(self, filename): log(3, 'Running Lintadas on file ' + filename) sourcefile = dms.sourcefile.get_by_id(filename) sourcefile.read_metadata() # CLear out errors before checking sourcefile.errors.clear() # Do not check remote files. # FIXME: It should check the local file if it has been # downloaded already. if sourcefile.local==0: log(3, 'Skipping remote file ' + filename) return filename = sourcefile.localname # If file the is missing, flag error and stop. if os.access(filename, os.F_OK)==0: err = dms.file_error.new() err.err_id = ERR_FILE_NOT_FOUND err.filename = sourcefile.filename sourcefile.errors.add(err) return # If file is not readable, flag error and top. if os.access(filename, os.R_OK)==0: err = dms.file_error.new() err.err_id = ERR_FILE_NOT_READABLE err.filename = sourcefile.filename sourcefile.errors.add(err) return # Read file information filestat = os.stat(filename) sourcefile.filesize = filestat[stat.ST_SIZE] sourcefile.filemode = filestat[stat.ST_MODE] sourcefile.modified = time.ctime(filestat[stat.ST_MTIME]) sourcefile.read_metadata() if stat.S_ISDIR(sourcefile.filemode)==1: sourcefile.format_code = 'dir' # If we were able to read format code, post it to the document, if sourcefile.format_code=='': err = dms.file_error.new() err.err_id = ERR_FILE_FORMAT_UNKNOWN err.filename = sourcefile.filename sourcefile.errors.add(err)
def testPages(self): log(3, 'testing Pages') for key in pages.keys(): page = pages[key] assert page.menu_name['EN'] > '' assert page.title['EN'] > '' assert page.page['EN'] > '' assert page.version['EN'] > '' if page.section_code > '': assert not page.section==None assert page.section.code==page.section_code if page.template_code > '': assert not page.template==None assert page.template.code==page.template_code log(3, 'testing Pages done')
def testDocFiles(self): log(3, 'testing DocFiles') for key in docs.keys(): doc = docs[key] docfiles = doc.files for docfilekey in docfiles.keys(): docfile = docfiles[docfilekey] sourcefile = sourcefiles[docfile.filename] if docfile==None: break assert docfile.doc_id==doc.id assert docfile.filename > '' assert docfile.filename==sourcefile.filename assert docfile.filename==docfile.sourcefile.filename log(3, 'testing DocFiles done')
def testPubStatuses(self): log(3, 'testing PubStatuses') assert not pub_statuses==None assert pub_statuses.count() > 0 # Ensure that the default publication statuses are in the database # for all supported languages, and that they all have names and # descriptions. for pub_status in ('C', 'D', 'N', 'P', 'W'): assert not pub_statuses[pub_status]==None supported = dms.language.get_by_keys([['supported', '=', YES]]) for key in supported.keys(): language = languages[key] assert pub_statuses[pub_status].name[language.code] > '' assert pub_statuses[pub_status].description[language.code] > '' log(3, 'testing PubStatuses done')
def testDocVersions(self): log(3, 'testing DocVersions') found = 0 for key in docs.keys(): doc = docs[key] assert not doc==None if doc.versions.count() > 0: found = 1 for vkey in doc.versions.keys(): version = doc.versions[vkey] assert not version==None assert version.pub_date > '' assert version.initials > '' assert found==1 log(3, 'testing DocVersions done')