def connect(conn):
user = Users()
while True:
data = conn.recv(1024)
if not data:
sys.exit()
else:
data = data.decode()
print(data)
info = data.split(" ")
if info[0] == "R":
if user.regist(info[1], info[2], info[3]):
conn.send(b"OK")
else:
conn.send(b"fail to regist")
elif info[0] == "L":
if user.login(info[1], info[2]):
conn.send(b"OK")
else:
conn.send(b"fail to login")
elif info[0] == "Q":
print(info)
r = user.query_word(info[1], info[2])
print("测试这一步")
if not r:
conn.send(b"fail to find")
else:
print(r)
conn.send(r.encode())
def change(filename, username, auth, myname):
if auth == -1:
for user in Users.all_users():
if user[0] != myname:
change(filename, user[0], 1, myname)
return
if auth == -2:
for user in Users.all_users():
if user[0] != myname:
change(filename, user[0], 0, myname)
return
conn = connect()
cursor = conn.cursor()
s = "SELECT auth FROM authorization WHERE filename='" + filename + "' AND username='******';"
# print s
cursor.execute(s)
ret = cursor.fetchall()
if len(ret) == 0:
s = "INSERT INTO authorization (filename, username, auth) " + \
"values ('" + filename + "', '" + username + "', " + str(auth) + ");"
cursor.execute(s)
conn.commit()
else:
s = "UPDATE authorization SET auth=" + str(auth) + \
" WHERE filename='" + filename + "' AND username='******';"
# print s
cursor.execute(s)
conn.commit()
def edit_exercise(user_id):
user = Users.find_by_id(user_id)
eid = request.form.get('eid', None)
data = {}
errors = []
data['name'] = request.form.get('name', 'Untitled')
try:
data['quantity'] = int(request.form.get('quantity', 0))
except:
errors.append('Quantity must be only digits 0-9')
try:
data['value'] = int(request.form.get('value', 0))
except:
errors.append('Value must be only digits 0-9')
if not errors:
user = Users.set_exercise(user, data, eid)
else:
print errors
flash_list(errors, 'error')
return jsonifym(user)
def VerifySorting(strColumnName):
columnIndex = GetColumnIndexByName(strColumnName)
WebObjsSort = Users.Sort(columnIndex)
WebObjsSort.Click()
Waiter.Wait(3)
strAsc = WebObjsSort.getAttribute('class')
strFirstRecord = Users.FirstRecord(columnIndex).contentText
strLastRecord = Users.LastRecord(columnIndex).contentText
WebObjsSort.Click()
Waiter.Wait(3)
strDesc = WebObjsSort.getAttribute('class')
strFirstRecord2 = Users.FirstRecord(columnIndex).contentText #textContent;
strLastRecord2 = Users.LastRecord(columnIndex).contentText #textContent;
Log.Message("Order By: {" + strColumnName + " " + strAsc +
"} First Value: {" + strFirstRecord + "}, Last Value: {" +
strLastRecord + "}")
Log.Message("Order By: {" + strColumnName + " " + strDesc +
"} First Value: {" + strFirstRecord2 + "}, Last Value: {" +
strLastRecord2 + "}")
Logger.CheckPoint("Validate Sorting On Column {" + strColumnName +
"} . Pass") if (
strFirstRecord == strLastRecord2
and strLastRecord == strFirstRecord2
) else Log.Error("Validate Sorting On Column {" +
strColumnName + "}. Failed")
def Sales(user_name):
user = Users.Datum().user(user_name)
Value = input("{}\nThe product you want to buy:".format(
Products.Datum().Products_info()))
Value2 = input("Please enter your code:")
product = Products.Datum().Products_sales(Value)
if 0 >= product.total:
print("Not have product..")
else:
if user.balance < product.price:
print("Do not have your money..")
else:
if Value2 == kod:
product_sales = user.balance - (product.price - product.price *
(20 / 100))
sales = product.total - 1
Products.Datum().Sales(sales, Value)
else:
product_sales = user.balance - product.price
sales = product.total - 1
Products.Datum().Sales(sales, Value)
Users.Datum().user_update(product_sales, user.user_name)
Admin.Admin().user_sales(
user.user_name, user.mail, product.name,
datetime.datetime.strftime(an, '%d %B %Y'))
def search_tweets(cnx, user_input,list,count):
"""
Function to search tweets with given query
:param cnx: Connection object
:param user_input: Domain to search tweets in
:param list: tags associated with the domain
:param count: Number of tweets to be returned
:return: None- Tweets and Users are added to the database
"""
cur = cnx.cursor(buffered=True)
searchUrl="https://api.twitter.com/1.1/search/tweets.json?"
countPart="count="+str(count)+"&"
for x in list:
finalUrl= searchUrl+countPart+"q="+x
getJson = connectToTwitter(finalUrl, "GET", b"", None)
parsedJson = json.loads(getJson)
for i in range(len(parsedJson["statuses"])):
try:
Users.addUsers(cur,parsedJson["statuses"][i])
cnx.commit()
addTweet(cur,parsedJson["statuses"][i])
cnx.commit()
except:
print("user or tweet skipped")
break
Tags.addTweetTags(cnx,user_input,parsedJson["statuses"][i])
Tags.removeTagDuplicates(cnx)
cnx.commit()
cnx.close()
def index():
if request.method == 'POST':
email = request.form['email']
if not email:
return render_template('index.html')
user = Users.find_one({'email': email})
if not user:
user_id = Users.create(email)
sg = sendgrid.SendGridClient("justindonato750", app.config["SMTP_PASS"])
message = sendgrid.Mail()
message.add_to(email)
message.set_subject("Welcome to Exercredit")
message.set_html(render_template('welcome-inlined.html', user_id=user_id))
message.set_from('*****@*****.**')
status, msg = sg.send(message)
print status, msg
return redirect('/user/%s/exercises?add=1' % user_id)
else:
print "flashing message"
flash('Sorry, this email has already been registered. You should already be getting a daily email.', 'error')
return render_template('index.html')
def del_exercise(user_id, eid):
user = Users.find_by_id(user_id)
if user:
Users.del_exercise(user, eid)
return jsonifym(user)
def editUserPhoto():
user = Users(get_database())
params = request.get_json()
userPhoto = params.get('userPhoto')
status, message = user.editUserPhoto(userPhoto, get_user_id())
return jsonify({'status': status, 'message': message})
def del_user(user_id):
user = Users.find_by_id(user_id)
if request.method == 'POST' and request.form.get('confirmed', '1'):
if user:
Users.delete(user)
return redirect('/')
return render_template('delete.html', user=user)
def home_menu():
a = input(" 1 to login: \n" " 2 to sign up: ")
if a == "1":
Users.login(User_details=Users.User_details)
elif a == "2":
Users.sign_up(User_details=Users.User_details)
else:
print("Please provide valid input")
home_menu()
def raw_recommendations(username, kwargs):
ANIMES = searcher.find_kwargs(**kwargs)
USER_DATA = Users.find_user_object(username).user_data
IDs = Users.find_user_object(username).complete_IDs
# print(IDs)
RECOMMENDATIONS = {}
for rec in ANIMES:
if rec['mal_id'] in IDs:
continue
RECOMMENDATIONS[rec['mal_id']] = [1]
return RECOMMENDATIONS
def profile_method():
user = Users(get_database())
# Show user data
if request.method == 'GET':
return jsonify(user.getUser(get_user_id()))
# Delete user
elif request.method == 'DELETE':
status, message = user.deleteUser(get_user_id())
return jsonify({'status': status, 'message': message})
def login(self):
if request.method == 'POST':
userId = request.form.get('userid')
myUser = Users.getUser(userId)
if myUser is not None and request.form['password'] == myUser['password']:
currUser = Users.User()
currUser.id = userId
# login with flask-login
login_user(currUser)
return redirect(url_for('index'))
# login fails
flash('Wrong username or password!')
return render_template('login.html')
def registration():
user = Users(get_database())
params = request.get_json()
login = params.get('login')
password = params.get('password')
firstName = params.get('firstName')
lastName = params.get('lastName')
email = params.get('email')
status, message = user.registerUser(login, password, firstName, lastName,
email)
return jsonify({'status': status, 'message': message})
def support(itemset): count = 0 users = Users.getUserIDs() userCount = len(users) for user in users: missing = False for item in itemset: if Users.userLikes(user, item): missing = missing else: missing = True if not missing: count = count + 1 #print str(count/userCount) #print str(count) return count / userCount
def get(self):
template_values = {
'users_client': Users.BASEURL,
'signup_url': Users.create_signup_url('/signup')
}
path = os.path.join(os.path.dirname(__file__), 'signup.html')
self.response.out.write(template.render(path, template_values))
def setUpScript(self, gid):
returnHtml = '<script>'
returnHtml += 'var stringMessage = ""; '
returnHtml += 'var tileReady = []; '
returnHtml += 'var tileImage = []; '
returnHtml += 'var tileName = []; '
users = Users.Users()
if (users.auth(gid, users.TEA)):
returnHtml += 'var TEA = true; '
else:
returnHtml += 'var TEA = false; '
iCnt = 0
for u in utils.randomSubset(list(users.imageList(gid)), 36):
returnHtml += 'tileReady["{}"] = false; '.format(
self.symbols[iCnt])
returnHtml += 'tileName["{}"] = "{}"; '.format(
self.symbols[iCnt], u[0])
returnHtml += 'tileImage["{}"] = new Image(); '.format(
self.symbols[iCnt])
returnHtml += 'tileImage["{}"].onload = function() '.format(
self.symbols[iCnt])
returnHtml += '{ '
returnHtml += 'tileReady["{}"] = true; '.format(self.symbols[iCnt])
returnHtml += '}; '
returnHtml += 'tileImage["{}"].src = "{}"; '.format(
self.symbols[iCnt], u[1])
self.names[self.symbols[iCnt]] = u[0]
self.images[self.symbols[iCnt]] = u[1]
iCnt += 1
returnHtml += '</script>'
return returnHtml
def recommendations():
# Check if an ID was provided as part of the URL.
# If ID is provided, assign it to a variable.
# If no ID is provided, display an error in the browser.
if 'name' in request.args:
name = request.args['name']
else:
return "Error: No name field provided. Please specify an name."
# print(kwargs)
kwargs = {}
for key in request.args:
if key != 'name':
kwargs[key] = request.args[key]
s_time = time.time()
kwargs = convert(kwargs)
recs = processor.enhanced_recommendations(name, kwargs)[:10]
print("Done")
USER = Users.find_user_object(name)
data = "".join(
[pretty_html(searcher.find_by_id(x[0]), USER, x[1]) for x in recs])
USER.dump()
time_stamp = round(time.time() - s_time, 1)
return render_template('recommendation.html',
name=name,
parameters=kwargs,
time=time_stamp,
recommendation_anime=data)
def __init__(
self,
ID=None,
groupID=None
): #groupID is the GroupMe groupID, not internal (ID is internal)
self.groupID = groupID
self.name = None
#The owner is not necessary, but if there are multiple users with tokens, this will resolve issues
self.owner = None #The owner is a token of the owner user
self.bot = None #This is the group's bot id that it uses to post messages
#These are just save objects to be used by other modules
self.analytics = {}
self.commands = {}
self.markedForDeletion = False #Groups can get deleted. I want to delete the ones that don't exist, just not during initialization
groupRegister(self, ID) #If no ID, will assign an id automatically
self.folderPath = Files.getGroupFolder(self)
self.filePath = Files.getFileName(
Files.join(self.folderPath, SAVE_FILE_NAME))
#This UserList should be empty and just a reference to the object
#Users should be loaded in postInit once we have gotten user data from internet
self.users = Users.UserList(self)
self.handler = Network.GroupMeHandler(self)
self.commandBuilder = Commands.CommandBuilder(self)
def render_daily_mail(user_id):
user = Users.find_by_id(user_id)
if not user:
return redirect('/')
return render_template('html_mail.html', user=user)
def do_HEAD(self):
request = NutRequest(self)
response = NutResponse(self)
request.setHead(True)
response.setHead(True)
if self.headers['Authorization'] == None:
return Response401(request, response)
id, password = base64.b64decode(
self.headers['Authorization'].split(' ')[1]).decode().split(':')
request.user = Users.auth(id, password, self.client_address[0])
if not request.user:
return Response401(request, response)
try:
if len(request.bits) > 0 and request.bits[0] in mappings:
i = request.bits[1]
methodName = 'get' + i[0].capitalize() + i[1:]
method = getattr(mappings[request.bits[0]], methodName,
Response404)
method(request, response)
else:
self.handleFile(request, response)
except BaseException as e:
self.wfile.write(Response500(request, response))
def users(self, view, query):
if Users.hasPremission(view, 3):
if query.getvalue('userId'):
view.currentUser = dbUser.User.get_by_id(int(query.getvalue('userId')))
view.userList = dbUser.User.all()
view.templateFile = 'edit/' + self.pathList[0] + '.html'
def setUpScript(self, gid, oper):
returnHtml = '<script>'
rnd = random.randrange(len(self.templates))
returnHtml += 'var PUZZLE = "{}"; '.format(self.puzzles[rnd])
returnHtml += 'var TEMPLATE = "{}"; '.format(self.templates[rnd])
returnHtml += 'var PUZZLENUM = {}; '.format(rnd)
returnHtml += 'var tileReady = []; '
returnHtml += 'var tileImage = []; '
returnHtml += 'var tileName = []; '
returnHtml += 'var message = "{}"; '.format(oper)
users = Users.Users()
if (users.auth(gid, users.TEA)):
returnHtml += 'var TEA = true; '
else:
returnHtml += 'var TEA = false; '
iCnt = 0
for u in utils.randomSubset(list(users.imageList(gid)), 9):
returnHtml += 'tileReady["{}"] = false; '.format(
self.symbols[iCnt])
returnHtml += 'tileName["{}"] = "{}"; '.format(
self.symbols[iCnt], u[0])
returnHtml += 'tileImage["{}"] = new Image(); '.format(
self.symbols[iCnt])
returnHtml += 'tileImage["{}"].onload = function() '.format(
self.symbols[iCnt])
returnHtml += '{ '
returnHtml += 'tileReady["{}"] = true; '.format(self.symbols[iCnt])
returnHtml += '}; '
returnHtml += 'tileImage["{}"].src = "{}"; '.format(
self.symbols[iCnt], u[1])
self.names[self.symbols[iCnt]] = u[0]
self.images[self.symbols[iCnt]] = u[1]
iCnt += 1
returnHtml += '</script>'
return returnHtml
def NavigateToSystemUserPage():
LoginSteps.LoginWithValidInput()
WebObjAdmin = Users.Admin()
WebObjUsrMgmt = Users.UserManagement()
WebObjAdmin.Click()
WebObjUsrMgmt.Click()
Waiter.Wait(5)
strPageUrl = BrowserFactry.GetPageUrl()
Logger.CheckPoint('Navigate To Sytem User Page Successfully: ' +
strPageUrl) if (
aqString.Find(strPageUrl, 'viewSystemUsers') != -1
) else Log.Error('Navigate To Sytem User Page Failed: ' +
strPageUrl)
def __init__(self, host, port):
""" Constructs an instance of DeadlineCon.
Params: host name of the web service (string)
port number the web service is listening on (integer)
"""
#Builds the ConnectionProperty object used for sending requests
address = host + ":" + str(port)
self.connectionProperties = ConnectionProperty(address)
#The different request groups use the ConnectionProperty object to send their requests
self.Jobs = Jobs.Jobs(self.connectionProperties)
self.SlavesRenderingJob = SlavesRenderingJob.SlavesRenderingJob(
self.connectionProperties)
self.Tasks = Tasks.Tasks(self.connectionProperties)
self.TaskReports = TaskReports.TaskReports(self.connectionProperties)
self.JobReports = JobReports.JobReports(self.connectionProperties)
self.LimitGroups = Limits.LimitGroups(self.connectionProperties)
self.Pulse = Pulse.Pulse(self.connectionProperties)
self.Repository = Repository.Repository(self.connectionProperties)
self.MappedPaths = MappedPaths.MappedPaths(self.connectionProperties)
self.MaximumPriority = MaximumPriority.MaximumPriority(
self.connectionProperties)
self.Pools = Pools.Pools(self.connectionProperties)
self.Groups = Groups.Groups(self.connectionProperties)
self.Plugins = Plugins.Plugins(self.connectionProperties)
self.Slaves = Slaves.Slaves(self.connectionProperties)
self.Users = Users.Users(self.connectionProperties)
self.Balancer = Balancer.Balancer(self.connectionProperties)
def anime(username=None, **kwargs):
if username == None:
username = input("Username> ")
USER = Users.find_user_object(username)
anime_name = input("Anime> ")
if anime_name.lower() in ['quit', 'q', 'quit()']:
return
try:
anime = searcher.find_by_id(int(anime_name))
except:
anime_name = searcher.search_by_name(anime_name)[0][0]
anime = searcher.find_by_name(anime_name)
# print(anime_name, anime)
rec_scores = processor.MAL_native_recommendation(
username, raw=True, skip_watched=False)[anime['mal_id']]
if len(rec_scores) == 0:
avg_score = 1
else:
avg_score = sum(rec_scores) / len(rec_scores)
entry = processor.score(anime, USER, avg_score)
return pretty(anime, USER, entry)
def MAL_native_recommendation(username='******',
raw=False,
skip_watched=True):
refresh_animes = []
USER = Users.find_user_object(username)
if USER.recommendations != None:
return USER.recommendations
USER_DATA = USER.user_data
RECOMMENDATIONS = defaultdict(list)
IDs = Users.find_user_object(username).complete_IDs
for user_anime in USER_DATA:
if user_anime['status'] != 2:
continue
# print(user_anime)
mal_id = user_anime['anime_id']
user_score = user_anime['score']
# Confirming we got the Anime
anime = searcher.find_by_id(mal_id)
if anime == None:
anime = add_new_anime(mal_id)
if anime == None:
print("INVALID ID")
continue
# Queue this to add to database
refresh_animes.append(anime)
score_diff = round(
user_score / anime['score'] / USER.average_difference, 2)
for rec in anime.get(
'user_recommendations',
[]) if anime.get('user_recommendations', []) != None else []:
if rec['mal_id'] in IDs and skip_watched:
continue
RECOMMENDATIONS[rec['mal_id']] += [score_diff] * int(
rec['count']) + ([1] * (1 + int(int(rec['count']) / 4)))
# for key in list(RECOMMENDATIONS.keys()):
# RECOMMENDATIONS[key] = sum(RECOMMENDATIONS[key]) / len(RECOMMENDATIONS[key]) * (1 + (len(RECOMMENDATIONS[key]) / 500))
USER.recommendations = RECOMMENDATIONS
if len(refresh_animes) != 0:
searcher.refresh(refresh_animes)
if raw:
return RECOMMENDATIONS
return sorted(RECOMMENDATIONS.items(),
key=lambda x: sum(x[1]) / len(x[1]),
reverse=True)
def makeNamedGroup(id, groupID, idTuple):
if not Groups.getGroup(id):
toRet = Groups.MainGroup(id, groupID)
user = toRet.users.addUser(Users.User(toRet, idTuple[0])).setToken(idTuple[1])
user.save()
else:
toRet = Groups.getGroup(id)
return toRet
def preparePage(self, view, query):
pages = dbPages.Pages.gql('ORDER BY sortIndex').fetch(1000)
view.currentUser = Users.getCurrentUser()
view.currentPage = None
view.pageTree = PageService.build_tree(pages)
view.pages = pages
view.settings = Settings
def details(user_id):
user = Users.find_by_id(user_id)
if not user:
return redirect('/')
return render_template('details.html', user=user, app_context=jsonifym(user))
def GetRowData(strColumnName):
columnIndex = GetColumnIndexByName(strColumnName)
rowCount = GetRowCount(strColumnName)
rowList = list()
for rowIndex in range(1, rowCount + 1):
cellValue = Users.Cell(columnIndex, rowIndex).textContent
rowList.append(cellValue)
return rowList
def createUser(user, passwd):
# create User Object
myUser = US.User(user, passwd)
status = myUser.createNewUser()
if status:
return status
else: #display error message not able to create user #future work
pass
def list():
users = Users.find()
if not users:
return redirect('/')
return render_template('list.html', users=users)
def users(req): parseQS(req) from Users import * users = Users() req.content_type = "text/html" if(params["func"] == "doLogin"): users.doLogin() if users.logged_in: users.profile() else: users.loginScreen() req.write(users.getOutput())
def application(environ, start_response):
results = []
results.append(str(moduletest.ageofqueen))
results.append(printhello())
results.append(hello())
helloWorld = HelloWorld()
results.append(helloWorld.sayHello())
user = Users()
results.append(user.sayHello())
article = Articles()
results.append(article.sayHello())
output = "<br/>".join(results)
print output
# build the response body possibly using the environ dictionary
response_body = output
# HTTP response code and message
status = '200 OK'
# These are HTTP headers expected by the client.
# They must be wrapped as a list of tupled pairs:
# [(Header name, Header value)].
response_headers = [('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))]
# Send them to the server using the supplied function
start_response(status, response_headers)
# Return the response body.
# Notice it is wrapped in a list although it could be any iterable.
return [response_body]
def __init__(self, path, *args):
self.pathList = Utils.parsePath(path[1])
args[0].statusCode = args[1].getvalue('status')
args[0].statusMessage = args[1].getvalue('message')
if not Users.isUserAuthenticated():
if not args[1].getvalue('status'):
args[0].statusCode = '-1'
args[0].statusMessage = 'You don\' have access to this page'
args[0].templateFile = 'edit/login.html'
else:
self.preparePage(*args)
func = getattr(self, self.pathList[0])
func(*args)
def view(board_id, sprint_id='current'):
'''
Get the data for a board in a Board object
arg: board_id - the id of the board to get
arg: sprint_id - the id of a sprint belonging to the board for which to get stories.
Passing in 'all' gets stories from all sprints, passing in 'current' gets
all stories in the current sprint, and passing in 'backlog' gets all stories in the
backlog.
return: the data in a Board object
'''
board_id_uuid = UUID(board_id)
sprint = None
if sprint_id == 'current':
sprint = Sprints.get_current_sprint(board_id)
if sprint is not None:
sprint_id = sprint.id
if sprint is None:
now = datetime.datetime.now()#.strftime('%Y-%m-%d')
later = now + relativedelta(weeks=2)#.strftime('%Y-%m-%d')
sprint = Sprints.create(now, later, board_id)
elif sprint_id != 'all' and sprint_id != 'backlog':
sprint_id = UUID(sprint_id).hex
sprint = Sprints.get(sprint_id)
cursor.execute('''
SELECT `name`, `id`
FROM `boards`
WHERE `id`=%s
''',
(board_id_uuid.bytes)
)
row = cursor.fetchone()
board = None
if row is not None:
board = Board(row[0], binascii.b2a_hex(row[1]), Users.get_by_board(board_id), Stories.get_by_board(board_id, sprint_id), sprint)
return board
def __init__(self):
self.Users = {}
self.UsersImplicit = {}
self.U = Users()
self.F = 0
def logout(self, view, query):
Users.doLogout()
view.statusCode = '1'
view.statusMessage = 'User has been logged out.'
view.templateFile = 'edit/login.html'
class UserMatrix(object):
def __init__(self):
self.Users = {}
self.UsersImplicit = {}
self.U = Users()
self.F = 0
def addUser(self,userID,F):
assert userID not in self.Users
assert isinstance(F, int)
assert userID not in self.UsersImplicit
self.UsersImplicit[userID] = Implicit(userID)
self.Users[userID] = np.random.random(F)
self.U.addUser(userID)
self.F= F
def addUserRating(self,uid,rating, songId, artID):
self.U.addRatings(uid, artID, songId, rating)
def getUserRatings(self,uid):
return self.U.getRatings(uid)
def getUserAverage(self, uid):
return self.U.computeAvgRatingForUser(uid)
"""
avg rating of all movies
"""
def getGlobalAverage(self):
return self.U.computeGlobalBias()
def getUserLatent(self, keyID):
return self.Users[keyID]
def getUsersDict(self):
return self.Users;
def getSizeFeatures(self, id):
assert id in self.Users[id]
return len(self.Users[id])
def getFeatures(self, uid ):
assert uid in self.Users
return self.Users[uid]
def updateFeatures(self, uid, features):
assert uid in self.Users
self.Users[uid] = np.array(features)
def updateFeature(self,uid, feature, pos):
assert uid in self.Users
assert isinstance(pos, int)
self.Users[uid][pos] = np.float(feature)
def getFeature(self, uid, pos):
assert uid in self.Users
assert isinstance(pos, int)
return self.Users[uid][pos]
def hasRatings(self,uid):
return len(self.U.getRatings(uid)) > 0
def getUsers(self):
return self.U.users
def getUser(self, uid):
assert uid in self.U.users
return self.U.users[uid]
def getBias(self, uid):
return self.U.getBias(uid)
def setBias(self, uid, bias):
self.U.setBias(uid, bias)
def login(self, view, post):
view.StatusMessage = Users.doLogin(post.get('username'), post.get('password'))
view.redirect = '/edit/?status=' + str(view.StatusMessage['status']) + '&message=' + view.StatusMessage['message']
def __init__(self,parent):
self.formsList = []
self.parent=parent
self.tableManager=Table(self)
self.formsManager=Formulaire(self)
self.users=Users(self)
class Model():
def __init__(self,parent):
self.formsList = []
self.parent=parent
self.tableManager=Table(self)
self.formsManager=Formulaire(self)
self.users=Users(self)
def getUsers(self):
return self.users.getUsers()
def createUser(self,newUser):
self.users.createUser(newUser)
def deleteUser(self, userToDelete):
self.users.deleteUsers(userToDelete)
def createTable(self,tablename,columns):
self.tableManager.createNewTable(tablename,columns)
def getGroupRights(self,id):
sqlCommand="SELECT * FROM Sys_droitsGroupes WHERE groupid=" + str(id)
result=self.parent.serverCommunication.runSQLQuery(sqlCommand,None)[0]
print(result)
rights={"motdepasseautre":result[1],"motdepassepersonnel":result[2],
"cronjobs":result[3],"regleaffaire":result[4],
"lireforms":result[5],"modifforms":result[6],"remplirformulaire":result[7],"modifusagers":result[8],"lireusagers":result[9],"modifrapport":result[10],"lirerapport":[11]}
return rights;
def getGroups(self):
sqlCommand="SELECT * FROM Sys_GroupesUtilisateurs"
return self.parent.serverCommunication.runSQLQuery(sqlCommand,None)
def saveGroup(self,group,modify):
if(modify==False): #then creates the group
sqlCommand="Insert into Sys_GroupesUtilisateurs(nom,niveau) VALUES"
self.parent.serverCommunication.runSQLQuery(sqlCommand,(group["name"],group["security"]))
else:
group["id"]=self.parent.serverCommunication.runSQLQuery("SELECT id FROM Sys_GroupesUtilisateurs WHERE nom ='"+group["oldname"]+"'",None)[0][0]
sqlCommand="UPDATE Sys_GroupesUtilisateurs SET nom='%s' ,niveau=%s WHERE id=%s" % (group["name"],group["security"],group["id"])
print(sqlCommand)
self.parent.serverCommunication.runSQLQuery(sqlCommand,None)
group["id"]=self.parent.serverCommunication.runSQLQuery("SELECT id FROM Sys_GroupesUtilisateurs WHERE nom ='"+group["name"]+"'",None)[0][0]
if(modify==False):
sqlCommand="Insert into Sys_droitsGroupes(groupid,motdepasseautre,motdepassepersonnel,cronjobs,regleaffaire,lireforms,modifforms,remplirformulaire,modifusagers,lireusagers,modifrapport,lirerapport) VALUES"
rights=group["rights"]
self.parent.serverCommunication.runSQLQuery(sqlCommand,(group["id"],rights["motdepasseautre"],rights["motdepassepersonnel"]
,rights["cronjobs"],rights["regleaffaire"],rights["lireforms"]
,rights["modifforms"],rights["remplirformulaire"],rights["modifusagers"]
,rights["lireusagers"],rights["modifrapport"],rights["lirerapport"]
))
else:
rights=group["rights"]
sqlCommand="UPDATE Sys_droitsGroupes SET motdepasseautre=%d,motdepassepersonnel=%s,cronjobs=%s,regleaffaire=%s,lireforms=%s,modifforms=%s,remplirformulaire=%s,modifusagers=%s,lireusagers=%s,modifrapport=%s,lirerapport=%s WHERE groupid=%s" %(rights["motdepasseautre"],rights["motdepassepersonnel"]
,rights["cronjobs"],rights["regleaffaire"],rights["lireforms"]
,rights["modifforms"],rights["remplirformulaire"],rights["modifusagers"]
,rights["lireusagers"],rights["modifrapport"],rights["lirerapport"],group["id"])
self.parent.serverCommunication.runSQLQuery(sqlCommand,None)
def modifyTable(self,tablename,columns):
self.tableManager.modifyTable(tablename,columns)
def deleteTable(self,tablename):
self.tableManager.deleteTable(tablename)
def testOfDestruction(self):
for i in range (50000):
bindings = [ None, "dragomir"+str(i),"allo" , "ca va", "yooo", "allo" ]
self.parent.serverCommunication.runSQLQuery('INSERT INTO Sys_Usagers values', bindings )
def tcp_link(skt, addr):
print('Accept new connection from %s:%s...' % addr)
# sock.send(b'Welcome!')
data = ''
login = 0
upload_filename = ''
while True:
if not skt:
break
data = data + skt.recv(1024)
# time.sleep(1)
if not data or data.decode('utf-8') == 'exit':
break
# sendToAll(skt, data)
# data = ''
while True:
try:
pos = data.index('\n')
except:
break
print [data[:pos]]
msg = json.loads(data[:pos])
reply = dict()
query = msg['type']
reply['type'] = query
if query == 'register':
error = Users.insert_user(msg['user'], msg['password'])
reply['error'] = error
send(skt, json.dumps(reply))
elif query == 'login':
username = msg['name']
u = Users.get_user(username)
if len(u) < 2:
error = 1
elif u[2] != hash(msg['password']):
error = 1
else:
error = 0
login = 1
onlineList.append(skt)
name_list[skt] = username
reply['error'] = error
send(skt, json.dumps(reply))
elif login == 0:
continue
if query == 'logout':
login = 0
onlineList.remove(skt)
break
elif query == 'create':
filename = msg['filename']
error = Files.create_file(filename)
reply['error'] = error
if error == 0:
Auth.change(filename, name_list[skt], 2, name_list[skt])
send(skt, json.dumps(reply))
elif query == 'edit':
filename = msg['filename']
if not Files.exist(filename):
reply['error'] = 1
send(skt, json.dumps(reply))
continue
if not Auth.have_edit_auth(filename, name_list[skt]):
reply['error'] = 2
send(skt, json.dumps(reply))
continue
reply['error'] = 0
send(skt, json.dumps(reply))
reply.clear()
reply['type'] = 'edit_content'
reply['filename'] = 'filename'
reply['isend'] = 1
content = dict()
content['oldRange'] = {'start': {'row': 0, 'column': 0}, 'end': {'row': 0, 'column': 0}}
content['oldText'] = ''
(file_content, r, c) = Files.edit_file(filename)
content['newText'] = file_content
content['newRange'] = {'start': {'row': 0, 'column': 0}, 'end': {'row': r, 'column': c}}
reply['content'] = content
send(skt, json.dump(reply))
Files.add_editor(filename, skt)
elif query == 'upload':
filename = msg['filename']
error = Files.create_file(filename)
reply['error'] = error
send(skt, json.dumps(reply))
if error == 1:
continue
upload_filename = filename
Auth.change(filename, name_list[sock], 2, name_list[skt])
elif query == 'upload_content':
if upload_filename == '':
continue
Files.up_file(upload_filename, msg['content']['newText'])
upload_filename = ''
pass
elif query == 'change_auth':
filename = msg['filename']
other_name = msg['other_name']
if not Files.exist(filename):
reply['error'] = 1
send(skt, json.dumps(reply))
continue
if not Auth.have_manage_auth(filename, other_name):
reply['error'] = 2
send(skt, json.dumps(reply))
continue
reply['error'] = 0
Auth.change(filename, other_name, msg['auth'])
send(skt, json.dumps(reply))
pass
elif query == 'rm':
filename = msg['filename']
if not Files.exist(filename):
reply['error'] = 1
send(skt, json.dumps(reply))
continue
if not Auth.have_manage_auth(filename, name_list[skt]):
reply['error'] = 2
send(skt, json.dumps(reply))
continue
reply['error'] = 0
Files.delete_file(filename)
send(skt, json.dumps(reply))
elif query == 'ls':
reply['list'] = Auth.get_edit_list(name_list[skt])
send(skt, json.dumps(reply))
pass
elif query == 'close':
Files.del_editor(msg['filename'], skt)
elif query == 'modify':
modify = msg['content']
filename = msg['filename']
send_to_all(skt, json.dumps(modify), filename)
Files.change_file(filename, modify)
skt.close()
print('Connection from %s:%s closed.' % addr)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import Media
import LoanHistories
import Users
if __name__ == "__main__":
content = ""
content += "# Users\n"
content += "#======\n"
content += Users.main()
content += "# Media\n"
content += "#======\n"
content += Media.main()
content += "# LoanHistories\n"
content += "#==============\n"
content += LoanHistories.main()
open("All.sql", "w").write(content)
