Notes

import redis

from datetime import datetime
class Class:

def __init__(self):
rhost = 'localhost'
rport = 6379
self.r = redis.Redis(host=rhost, port=rport, decode_responses=True)

def record_event(self, event):
self.r.sadd("events", event)

def list_all_events(self):
return self.r.smembers("events")

def new_event(self, beginning_of_the_event, end_of_the_event, name, responible_person_name, responsible_person_phone):
event_id = str(self.r.incrby("e_id", 1))
self.r.hmset("event_" + event_id, {'beginning_of_the_event': beginning_of_the_event,
'end_of_the_event': end_of_the_event,
'events': name,
'responible_person_name': responible_person_name,
'responsible_person_phone ': responsible_person_phone , })

self.r.sadd("events", 'event_' + event_id)
self.r.zadd("event_time", {'event_'+event_id: beginning_of_the_event})
self.r.zadd("liked_events", {'event_'+event_id: 0})

def list_events_in_given_time(self, given_time):
for event_id in self.r.smembers("events"):
if self.r.hget(event_id, 'beginning_of_the_event') == given_time:
beginning_of_the_event = self.r.hget(event_id, 'beginning_of_the_event').strptime("%Y%m%d%H%M%S")
end_of_the_event = self.r.hget(event_id, 'end_of_the_event').strptime("%Y%m%d%H%M%S")
event_name = self.r.hget(event_id, 'name')
person_name = self.r.hget(event_id, 'responible_person_name')
person_phone = self.r.hget(event_id, 'responible_person_phone')
print(event_id, beginning_of_the_event, end_of_the_event, event_name, person_name, person_phone)


def list_event_by_time(self):
for event_id in self.r.zrevrangebyscore("beginning_of_the_event", '+inf', '-inf'):
print(self.r.hgetall(event_id))


def record_ticket_type(self, name, price, description):
ticket_id = str(self.r.incrby('t_id', 1))
self.r.hmset('ticket_' + ticket_id, {'name': name,
'price': price,
'description': description})

self.r.sadd("total_tickets", 'ticket_' + ticket_id)

def list_ticket_type(self):
for ticket in self.r.smembers("total_tickets"):
print(self.r.hgetall(ticket))


def guest_buy_ticket(self, email, name, birth_date, gender, ticket_type):
guest_id = str(self.r.incrby('g_id', 1))
if not self.r.hget('guest_' + guest_id):
self.r.hmset('guest_' + guest_id, {'email':email ,'name': name, 'birth_date':birth_date, 'gender':gender, 'ticket_type': ticket_type})
self.r.sadd("total_guests", 'guest_' + guest_id)
else:
print('guest already have one ticket')

def list_all_guests(self):
for guest_id in self.r.smembers("total_guests"):
print(self.r.hgetall(guest_id))


def like_event(self, guest_id, event_id):
self.r.zincrby('liked_events', 1, event_id)
self.r.sadd("guest_likes_" + guest_id, event_id)

def event_by_likes(self):
return self.r.zrevrangebyscore('liked_events', 0, -1, withscores=True)

def event_liked_by_guest(self, guest_id):
return self.r.smembers("guest_likes_" + guest_id)


# -*- coding: windows-1250 -*-
#for hungarian letter, like ö

import redis
from _datetime import datetime
import pdb


class HDClass():

def __init__(self):

rhost='172.22.230.198'
rport=6379
self.r=redis.Redis(host=rhost, port=rport,decode_responses=True)

def new_emp(self, email):
self.r.sadd('s_emp',email)

def del_emp(self, email):
self.r.srem('s_emp',email)

def list_emp(self):
print(self.r.smembers('s_emp'))

def choose_manager(self, email):
if not(self.r.sismember('s_emp',email)):
print('He/she is not an employee')
else:
self.r.set('st_manager',email)

def who_is_manager(self):
return self.r.get('st_manager')
#6
def new_task(self, email, task_name, description):
if not(self.r.sismember('s_emp',email)):
print('no such employee')
else:
t_id=self.r.incr('st_task_id')
self.r.hmset('h_'+str(t_id),
{'email':email,
'task_name':task_name,
'description':description})
self.r.zadd('z_task_by_priority',t_id, 0)
v_time=datetime.now().strftime("%Y%m%d%H%M%S")
self.r.zadd('z_task_by_time',t_id, v_time)

#7
def task_details(self, task_id):
print(self.r.hgetall('h_'+str(task_id)))
print(self.r.zscore('z_task_by_priority',task_id))
print(self.r.zscore('z_task_by_time',task_id))

#11
def task_list_by_recording_times(self):
print(self.r.zrange('z_task_by_time', 0, -1, withscores=True))


#12
def task_list_by_priority(self):
print(self.r.zrange('z_task_by_priority', 0, -1, withscores=True))

#14
def newest_task_id(self):
print(self.r.get('st_task_id'))

#15
def task_priority(self, task_id):
print(self.r.zscore('z_task_by_priority',task_id))

#8
def change_priority(self, email, task_id, priority):
if self.r.get('st_manager')!=email:
print('He/she is not the manager')
else:
if self.r.zscore('z_task_by_priority',task_id)!=None:
self.r.zadd('z_task_by_priority',task_id,priority)
assigned_email=self.r.hget('h_'+str(task_id),'assigned_email')
if assigned_email!=None:
self.r.zadd('z_'+assigned_email+'_task',
task_id, priority)
else:
print('wrong task_id')

#9
def assign_employe_to_task(self,task_id,
assigner_email,
assigned_email):
if not(self.r.exists('h_'+str(task_id))):
print('No such task')
return -1
if not(self.r.sismember('s_emp',assigner_email)):
print('No such assigner emp')
return -1
if not(self.r.sismember('s_emp',assigned_email)):
print('No such assigned emp')
return -1

self.r.hmset('h_'+str(task_id),
{'assigner_email':assigner_email,
'assigned_email':assigned_email})

priority=self.r.zscore('z_task_by_priority',task_id)
self.r.zadd('z_'+assigned_email+'_task',
task_id, priority)

#13
def list_emloyees_tasks(self, email):
print(self.r.zrevrange('z_'+email+'_task', 0, -1,withscores=True))

#10
def perform_task(self, email, task_id):
print(task_id)
print(self.task_details(task_id))
print(email)
print(self.r.get('st_manager'))
print(datetime.now().strftime("%Y%m%d%H%M%S"))

assigned_email=self.r.hget('h_'+str(task_id),'assigned_email')
if assigned_email!=None:
self.r.zrem('z_'+assigned_email+'_task',task_id)

self.r.delete('h_'+str(task_id))

self.r.zrem('z_task_by_priority',task_id)
self.r.zrem('z_task_by_time',task_id)


# -*- coding: windows-1250 -*-
#for hungarian letter, like ö

import redis
from _datetime import datetime
from datetime import timedelta


class VAClass():

def __init__(self):

rhost='172.22.230.198'
rport=6379
self.r=redis.Redis(host=rhost, port=rport,decode_responses=True)

def post_article(self, title, link, post_person):
a_id=self.r.incr('aricle_id')
v_time=datetime.now().strftime("%Y%m%d%H%M%S")
self.r.zadd('z_articles', a_id, v_time)

self.r.hmset('h_'+str(a_id),
{'title':title,
'link':link,
'post_person':post_person})

def article_info(self, a_id):
print(self.r.hgetall('h_'+str(a_id)))

def list_articles(self):
print(self.r.zrange('z_articles',0,-1))

def list_articles_details(self):
for i in self.r.zrange('z_articles',0,-1):
print(i)
print(self.r.hgetall('h_'+str(i)))

def last_posted_article(self):
print(self.r.zrevrange('z_articles', 0, 0))

def list_articles_by_post_time(self):
print(self.r.zrevrange('z_articles',0,-1, withscores=True))

def vote(self, username, article):
p_expiration=10 #minute
pt=self.r.zscore('z_articles', article)
if pt==None:
print('The article does not exists')
return -1
pt_dt=datetime.strptime(str(int(pt)),"%Y%m%d%H%M%S")
v2_time=(datetime.now()-timedelta(minutes=p_expiration))
if v2_time>pt_dt:
print('Old post, it cannot be voted')
return -1
# if not(self.r.exists('h_'+str(article))):
# print('The article does not exists')
# return -1
if self.r.sismember('s_'+str(article)+'_voters', username):
print('The user voted to this article')
return -1
self.r.sadd('s_'+str(article)+'_voters', username)
self.r.expire('s_'+str(article)+'_voters', p_expiration*60)
self.r.zincrby('z_article_votes', article,1)

def most_voted_article(self):
print(self.r.zrevrange('z_article_votes',0,0))

def list_articles_by_votes(self):
print(self.r.zrevrange('z_article_votes',0,-1, withscores=True))

def create_group(self, group):
self.r.sadd('s_groups', group)

def assign_article_to_group(self, group, article):
if not(self.r.sismember('s_groups', group)):
print('The group does not exist')
return -1
self.r.sadd('s_group_'+group,article)

def list_groups(self):
print(self.r.smembers('s_groups'))

def list_article_of_a_group(self, group):
print(self.r.smembers('s_group_'+group))

def group_articles_by_votes(self, group):
self.r.zinterstore('z_gr', {'z_article_votes', 's_group_'+group})
print(self.r.zrevrange('z_gr',0,-1, withscores=True))
self.r.delete('z_gr')