class InterfaceServiceController(RestController):
def __init__(self):
dh = LogDBHandler( config=config,request=request);
log.addHandler(dh)
self.utility = Utility();
self.urlUtility = URLUtility();
self.urlServer = model.SystemEnvironment.getServerUrl();
@with_trailing_slash
@expose('json')
#@require(predicates.in_any_group('voter','managers', msg=l_('Only for voter')))
def get_all(self,*args,**kw):
log.info( "get_all");
log.info( "args : %s ", args);
log.info( "kw : %s", kw);
#print len(request.headers);
#for h in request.headers:
# print h , request.headers[h];
#log.info( "body : %s" ,request.body);
print ("body : %s" ,request.body);
try:
if (kw):
self.client_id = kw['clientId'];
self.client_secret = kw['clientSecret'];
self.UserClientAuthen = model.UserClientAuthen.getUserClientAuthen(self.client_id, self.client_secret);
samples = kw;
if (self.UserClientAuthen):
log.info("user Client Auth %s" , str(self.UserClientAuthen.user_id)) ;
self.keyAuthorize = self.utility.my_random_string(15);
samples['keyAuthorize'] = self.keyAuthorize #; "#987654321";
self.startDate = self.utility.getCurrentDate();
self.expireDate = self.utility.plusTime(self.startDate, 5)
model.UserSessionAuthen.createSessionAuthen( self.keyAuthorize,self.startDate, self.expireDate ) ;
else:
if( request.body):
self.df = json.loads(request.body, encoding=request.charset);
log.info( "get value : request.body " + self.df);
#print self.df;
#set keyAuthorize
self.client_id = self.df['clientId'];
self.client_secret = self.df['clientSecret'];
samples = self.df;
else:
samples = {u'userName': u'tong', u'keyAuthorize': None, u'password': u'tong', u'dataTestSurfvey': None, u'passKey': u'#13456789'};
self.client_id = kw['clientId'];
self.client_secret = kw['clientSecret'];
except Exception as e:
log.error(e);
if kw:
samples = kw;
samples['keyAuthorize'] = "#987654321";
#samples = {u'userName': u'tong', u'keyAuthorize': None, u'password': u'tong', u'dataTestSurfvey': None, u'passKey': u'#13456789'};
return samples;#dict(surfveyAuthorize=samples);
@with_trailing_slash
@expose('json')
def createTest(self,*args,**kw):
print "args " ,args;
print "kw " ,kw;
for h in request.headers:
print "%s , %s " %(h,request.headers[h]);
self.Keyauthorize = request.headers['Keyauthorize'];
samples = kw;
print "createTest key authorize : " , self.Keyauthorize;
if model.UserSessionAuthen.currentSessionAuthen(self.Keyauthorize):
#if self.Keyauthorize == "459987456":
self.userExtenal = model.UseExtenalLink(id_user = kw.get("idUser"),
user_type =kw.get("userType"),
id_test = kw.get("idTest"),
# id_theme = kw.get("idTheme"),
no_test = kw.get("noTest"),
user_name = kw.get("userName")
);
self.userExtenal.save();
#x = json.loads(kw, object_hook=lambda d: namedtuple('X', d.keys())(*d.values()))
#1 create public
self.defaultOption = model.QuestionOption.getByProjectDefault(self.userExtenal.id_test,'1');
if(self.defaultOption is None):
print "defaultOption is null"
self.defaultOption = model.QuestionOption();
self.activate_date = self.utility.getStartDate()
self.option = model.QuestionOption(id_question_project = self.defaultOption.id_question_project,
id_question_theme = self.defaultOption.id_question_theme,
name_publication = str(self.defaultOption.name_publication.encode('utf8')) + "-" + str(self.userExtenal.user_name.encode('utf8')),
id_fix_random_type = self.defaultOption.id_fix_random_type,
activate_date = self.activate_date,
expire_date = self.utility.plusDate(self.activate_date, 365),
id_close_type = self.defaultOption.id_close_type,
id_question_invitation = self.defaultOption.id_question_invitation,
header_message =self.defaultOption.header_message,
footer_message = self.defaultOption.footer_message,
welcome_message = self.defaultOption.welcome_message,
end_message = self.defaultOption.end_message,
use_question_no = self.defaultOption.use_question_no,
duration_time = self.defaultOption.duration_time,
random_answer = self.defaultOption.random_answer,
show_navigator = self.defaultOption.show_navigator,
redirect_url = self.defaultOption.redirect_url,
redirect_other_url = self.defaultOption.redirect_other_url,
no_use = self.userExtenal.no_test,
show_score = self.defaultOption.show_score,
use_general_information = self.defaultOption.use_general_information
);
self.option.save();
print "leng : %s " %(len(self.defaultOption.numberquestion))
for defaultOp in self.defaultOption.numberquestion:
self.numberQuestionGroup = model.NumberQuestionGroup(id_question_option = self.option.id_question_option,
id_question_group = defaultOp.id_question_group,
amount = defaultOp.amount)
self.numberQuestionGroup.save()
del defaultOp
self.userExtenal.id_question_option = self.option.id_question_option;
#2
samples['idPublic'] = self.option.id_question_option;
samples['status'] = True;
samples['message'] = "create success";
samples['urlTest'] = "create success";
samples['createDate'] = self.option.activate_date ;#datetime.now() ; #"2015-06-23 12:02:57" ;#
samples['expireDate'] = self.option.expire_date;#datetime.now() + timedelta(days=30 ) ; #"2015-07-23 12:02:57";#
else :
log.warning("Keyauthorize %s is expired" %self.Keyauthorize);
samples['status'] = False;
samples['message'] = "Keyauthorize %s is expired" %self.Keyauthorize;
response.headers['KeyAuthorize'] = self.Keyauthorize
return samples;
@with_trailing_slash
@expose('json')
def evaluate(self,*args,**kw):
log.info("evaluate")
log.info( "---------evaluate-----------------")
log.info( args);
log.info ( "kw = %s " %kw);
samples = kw;
if('Keyauthorize' in request.headers):
self.Keyauthorize = request.headers['Keyauthorize'];
else:
self.Keyauthorize = '0000000000';
log.info( "11 key authorize : " + self.Keyauthorize);
if model.UserSessionAuthen.currentSessionAuthen(self.Keyauthorize): #self.Keyauthorize == "#987654321" :
log.info( "idOwnerTest : %s , idTest : %s , idPublic : %s" %(kw.get("idOwnerTest") , kw.get("idTest"),kw.get("idPublic") ) );
self.userExtenal = model.UseExtenalLink.getUserLinkBy( idUser= kw.get("idOwnerTest"),idTest = kw.get("idTest"),idPublic = kw.get("idPublic"));
if self.userExtenal :
log.info( "create userExtenal")
#create sur_voter
self.mapExtenal = model.MapVoterExtenalLink.getUserLinkVoterBy(self.userExtenal.id_use_external_link, kw.get("idUser"));
self.voter = model.Voter();
if( self.mapExtenal is None or self.mapExtenal.voter is None):
log.info( "create voter")
log.info("user external is not voter %s",kw.get("email"));
self.voter = model.Voter.getVoterByEmail(kw.get("email"));
if self.voter is None:
log.info("voter %s is not existed",kw.get("email"));
self.voter = model.Voter(email = kw.get("email"), prefix = kw.get("idPrefix"), firstname = kw.get("firstname"),
lastname = kw.get("lastname"), user_id_owner = 3, id_marriage_status = kw.get("idMarriageStatus"),
birthdate = kw.get("birthdate"), id_gender = kw.get("idGender")
);
self.voter.save();
self.mapExternalLink = model.MapVoterExtenalLink(id_use_external_link = self.userExtenal.id_use_external_link,
id_voter= self.voter.id_voter,
id_user_ref= kw.get("idUser")
);
self.mapExternalLink.save();
#self.userExtenal.id_voter = self.voter.id_voter;
#create sur_respondents
self.respondents = model.Respondents(id_voter = self.voter.id_voter,
id_question_project = kw.get("idTest"),
id_question_option = kw.get("idPublic"),
key_gen = self.utility.my_random_string(string_length=25),
redirect_other_url = self.utility.convertToBit (kw.get("configUrlTest"))
);
#self.respondents.finished =0;
#self.respondents.score_exam =0;
self.respondents.save();
#create link
else:
self.voter = self.mapExtenal.voter;
self.respondents = model.Respondents.getByVoterIdAndPublicId(str(self.voter.id_voter), str(kw.get("idPublic")));
log.info( "id voter : %s" %self.voter.id_voter);
samples['urlTest'] = self.urlUtility.URL_QUESTIONNAIRE.format(nameserver=self.urlServer,key=self.respondents.key_gen) ;
print samples['urlTest']
#("{0}/ans/reply/{1}.{2}.{3}.0.html").format(request.application_url,str(kw.get("idTest")) ,str(kw.get("idPublic")) , str(self.voter.id_voter)) ;
samples['status'] = True;
samples['errorCode'] = 'S0001';
samples['message'] = "Create Success ";
else:
samples['status'] = False;
samples['errorCode'] = 'E0002';
samples['message'] = "Find not found ";
else:
log.error( "Keyauthorize : is not same " );
response.headers['KeyAuthorize'] = self.Keyauthorize;
print "------------end evaluate---------------------"
print samples
return samples;
@with_trailing_slash
@expose('json')
def getScore(self,*args,**kw):
log.info("getScore")
samples = kw;
print "-------------------------";
print kw['idUser'];
print kw['idPublic'];
print "-------------------------";
for h in request.headers:
print "header : %s , %s " %(h,request.headers[h]);
self.Keyauthorize = request.headers['Keyauthorize'];
if('Keyauthorize' in request.headers):
self.Keyauthorize = request.headers['Keyauthorize'];
else:
self.Keyauthorize = '0000000000';
log.info( "11 key authorize : " + self.Keyauthorize);
samples['score'] = None;
samples['urlscore'] = '';
if model.UserSessionAuthen.currentSessionAuthen(self.Keyauthorize): #self.Keyauthorize == "#987654321" :
print "success %s " %self.Keyauthorize ;
self.respondents = model.Respondents.getByidUserandPublicId(kw['idUser'],kw['idPublic']);
if (self.respondents):
print 'score : %s, %s , %s' %(self.respondents.score_exam,self.respondents.full_score,self.respondents.personality_score) ;
if self.respondents.personality_score is not None :
samples['score'] = self.respondents.personality_score
samples['fullScore'] = None
else:
samples['score'] = self.respondents.score_exam
samples['fullScore'] = self.respondents.full_score
samples['urlScore'] = '';
samples['status'] = True;
samples['errorCode'] = 'S0001';
samples['message'] = "";
else:
samples['status'] = False;
samples['errorCode'] = 'E0002';
samples['message'] = "Session is not match ";
response.headers['KeyAuthorize'] = self.Keyauthorize;
return samples;
class RegisterService(object):
def __init__(self):
print "init RegisterService"
self.urlServer = model.SystemEnvironment.getServerUrl();
self.utility = Utility();
pass;
def insertOrUpdateUserWithFacebook(self,user,fuser,accessToken):
self.fullname = fuser['first_name']
self.fulllastname = fuser['last_name']
self.email =fuser['email']
self.tnc = 1
self.id_gender = model.Gender.getIdGender(fuser['gender'])
self.displayname = fuser['name']
self.provider_user_id = fuser['id']
self.access_token = accessToken['accessToken']
self.profile_url =fuser['link']
self.expiresin = str(accessToken['expiresIn'])
self.singed_request = accessToken['signedRequest']
locale = self.utility.spritValue(fuser['locale'], '_')
self.language = locale[0]
self.country = locale[1]
self.insert = False;
if(user is None):
user = model.User()
self.insert= True;
user.user_name = self.email
user.email_address = self.email
user.display_name = self.displayname
if(self.insert ):
user.save()
self.user_id = user.user_id
self.userservice = model.UserService.getByUserId(self.user_id)
self.usersocial = model.UserSocialNetwork.getByUserIdAndSocialId(self.user_id, '1');
if(self.userservice is None):
self.userservice = model.UserService();
self.insert= True;
self.userservice.user_name = self.email;
self.userservice.email_address = self.email;
self.userservice.display_name = self.displayname ;
#self.user._set_password(self.password);
self.userservice.first_name = self.fullname
self.userservice.last_name = self.fulllastname
#self.user.address =self.address
#self.user.city =self.city
#self.user.country = self.country
self.userservice.id_gender = self.id_gender
self.userservice.accept_tnc = self.tnc
self.userservice.language = self.language
self.userservice.country = self.country
self.userservice.user_id = self.user_id
if(self.insert ):
self.userservice.save();
self.userservice.updateGroupUserVoter();
if (self.usersocial is None):
self.usersocial = model.UserSocialNetwork();
self.insert= True;
self.usersocial.user_id = self.user_id
self.usersocial.id_social_type = 1
self.usersocial.provider_user_id = self.provider_user_id
self.usersocial.access_token = self.access_token
self.usersocial.display_name = self.displayname
self.usersocial.profile_url =self.profile_url
self.usersocial.expiresin = self.expiresin
self.usersocial.singed_request = self.singed_request
if(self.insert ):
self.usersocial.save()
return user;
def createUserWithFacebook(self,fuser,accessToken):
self.fullname = fuser['first_name']
self.fulllastname = fuser['last_name']
self.email =fuser['email']
self.tnc = 1
self.id_gender = model.Gender.getIdGender(fuser['gender'])
locale = self.utility.spritValue(fuser['locale'], '_')
user = model.User()
user.user_name = self.email
user.email_address = self.email
user.display_name = fuser['name']
user.save()
self.userservice = model.UserService();
self.userservice.user_name = self.email;
self.userservice.email_address = self.email;
self.userservice.display_name = fuser['name'];
#self.user._set_password(self.password);
self.userservice.first_name = self.fullname
self.userservice.last_name = self.fulllastname
#self.user.address =self.address
#self.user.city =self.city
#self.user.country = self.country
self.userservice.id_gender = self.id_gender;
self.userservice.accept_tnc = self.tnc
self.userservice.language = locale[0]
self.userservice.country = locale[1]
self.userservice.user_id = user.user_id
self.userservice.save();
self.userservice.updateGroupUserVoter();
self.usersocial = model.UserSocialNetwork();
self.usersocial.user_id = user.user_id
self.usersocial.id_social_type = 1
self.usersocial.provider_user_id = fuser['id']
self.usersocial.access_token = accessToken['accessToken']
self.usersocial.display_name = fuser['name']
self.usersocial.profile_url =fuser['link']
self.usersocial.expiresin = str(accessToken['expiresIn'])
self.usersocial.singed_request = accessToken['signedRequest']
self.usersocial.save()
def createUser(self, kw):
self.registerObject = RegisterObject(**kw);
self.user = self.registerObject.getUser()
self.user.save();
self.userservice = self.registerObject.getUserService();
self.userservice.user_id = self.user.user_id
self.userservice.accept_tnc = self.utility.convertToBit(self.userservice.accept_tnc);
self.userservice.save();
self.userservice.updateGroupUserVoter()
self.userservice.updateGroupUserCreator()
self.userGenCode = self.createUserGenCode(self.user);
return self.user,self.userGenCode;
def createUserGenCode(self,user):
self.userGenCode = model.UserGenCode();
self.userGenCode.user_id = user.user_id;
self.userGenCode.id_gen_code_type = 2 ;# register
self.userGenCode.code = str(self.userGenCode.user_id)+ self.utility.my_random_string(15);
self.userGenCode.expire_date = self.utility.plusDate(datetime.today(),30);
self.userGenCode.save();
return self.userGenCode;
def reActivateUserGenCode(self,userGenCode,user):
if(userGenCode):
self.userGenCode = userGenCode;
self.userGenCode.code = str(self.userGenCode.user_id)+ self.utility.my_random_string(15);
self.userGenCode.expire_date = self.utility.plusDate(datetime.today(),30);
self.userGenCode.create_date = datetime.today();
self.userGenCode.count = self.userGenCode.count +1;
self.userGenCode.success = 0;
return self.userGenCode;
return userGenCode;
def deActivateUserGenCode(self,user):
self.userGenCode = model.UserGenCode()
self.userGenCode.user_id = user.user_id
self.userGenCode.id_gen_code_type = 6 ;# deactivate
self.userGenCode.code = str(self.userGenCode.user_id)+ self.utility.my_random_string(15)
self.userGenCode.expire_date = self.utility.plusDate(datetime.today(),30)
self.userGenCode.success = 1
self.userGenCode.save()
return self.userGenCode;
def reActivateUser(self,user):
self.userGenCode = None
self.user = user
if(self.user):
self.userGenCode = self.createUserGenCode(self.user)
self.emailValues={};
self.emailValues['user_name'] = self.user.display_name;
self.emailValues['email'] = self.user.email_address;
self.emailValues['password'] = '';
self.emailValues['activate_url'] = request.scheme + '://' + self.urlServer + "/activate/" + str(self.userGenCode.code); #request.application_url
self.sendMailService = SendMailService();
self.sendMailService.sendreActivate(self.emailValues);
self.sendMailService.start();
return self.user, self.userGenCode
class SurveyController(BaseController):
def __init__(self):
self.utility = Utility();
self.urlUtility = URLUtility();
self.UPLOAD_DIR = config['path_upload_file'] ;
dh = LogDBHandler( config=config,request=request);
log.addHandler(dh)
def _before(self, *args, **kw):
tmpl_context.project_name = "pollandsurvey"
#proved
@expose('pollandsurvey.templates.survey.index')
@require(predicates.in_any_group('creator','managers', msg=l_('Only for creator')))
def index(self, *args, **kw):
"""Handle the front-page."""
reload(sys).setdefaultencoding("utf-8");
log.info("survey controller index");
return dict(page='index')
#proved
@expose('pollandsurvey.templates.surveyjs.index')
#@expose('pollandsurvey.templates.listsurvey.index')
@require(predicates.not_anonymous( msg=l_('Only for Authen')))
def listsetup(self, came_from=lurl('/'), *args, **kw):
"""Handle the front-page."""
reload(sys).setdefaultencoding("utf-8");
return dict(page='survey')
@expose('pollandsurvey.templates.surveyjs.manageproject')
@require(predicates.not_anonymous( msg=l_('Only for Authen')))
def manage(self, projectId,came_from=lurl('/'), **kw):
"""Handle the front-page."""
reload(sys).setdefaultencoding("utf-8");
self.user = request.identity['user'];
self.project, self.total = model.QuestionProject.getAllByUser(1,self.user.user_id,0,1 );
if len(self.project) == 0:
flash(_('Please create a project.'), 'warning')
raise HTTPFound(location='/survey/listsetup');
return dict(page='manageproject')
#proved
@expose('json')
@require(predicates.not_anonymous( msg=l_('Only for Authen')))
def getProjectByUser(self, came_from=lurl('/'),*args, **kw):
reload(sys).setdefaultencoding("utf-8");
user = request.identity['user'];
quest_project = model.QuestionProject.getAllByUser(1,user.user_id);
log.info("getProjectByUser");
return dict(survey=quest_project , total = len(quest_project));
#proved
@expose('json')
def deleteProject(self, came_from=lurl('/'), *args, **kw):
reload(sys).setdefaultencoding("utf-8");
self.success = True;
self.message = "success";
self.df = json.loads(request.body, encoding=request.charset);
self.idProject = self.df.get('id_question_project');
self.listQuestion = model.Question.getByProjectId(self.idProject);
self.listQuestionGroup = model.QuestionGroup.getByProject(self.idProject);
for questionGroup in self.listQuestionGroup:
#remove sur_map_question_group
model.MapQuestionGroup.deleteByQuestionGroup(questionGroup.id_question_group)
#remove question_group
model.QuestionGroup.delete(questionGroup)
del questionGroup
for self.question in self.listQuestion:
if(self.question):
self.idQuestion = self.question.id_question;
model.Question.deleteQuestoin(self.idQuestion);
model.QuestionProject.deleteById(self.idProject);
return dict(success=self.success, message = self.message);
#proved
@expose('json')
@require(predicates.not_anonymous( msg=l_('Only for Authen')))
def saveProject(self, came_from=lurl('/'), *args, **kw):
reload(sys).setdefaultencoding("utf-8");
self.success = True;
self.message = "success";
print 'Session Language : %s' %(ManageSession.getLanguage())
self.project = model.QuestionProject(**kw);
self.project.id_question_project = self.utility.setIfEmpty(self.project.id_question_project)
user = request.identity['user'];
self.project.user_id = user.user_id;
if self.project.id_question_project :
self.project.updateall();
else:
self.project.save();
self.addQuestionGroup( id_question_project=self.project.id_question_project,
question_group_name='default',
question_group_description='default',
id_question_result_group = '',
order=0 );
return dict(success=self.success, message = self.message, project_id=self.project.id_question_project);
#proved
@expose('json')
def deleteQuestion(self, came_from=lurl('/'), *args, **kw):
reload(sys).setdefaultencoding("utf-8");
self.success = True;
self.message = "Save Success";
df = json.loads(request.body, encoding=request.charset);
log.info(df);
idQuestion = df.get('id_question');
self.success, self.message = model.Question.deleteQuestoin(idQuestion);
return dict(success=self.success, message = self.message);
#proved
@expose('json',content_type="text/plain" )
@require(predicates.not_anonymous( msg=l_('Only for Authen')))
def addQuestion(self, came_from=lurl('/'), *args, **kw):
reload(sys).setdefaultencoding("utf-8");
self.success = True;
self.message = "success";
self.result = True;
log.info("add Question");
self.dataValue = kw;
log.info(kw);
log.info(args);
user = request.identity['user'];
#model.Question.createQuestion(self.dataValue,user.user_id);
log.info("check");
self.isCreate = self.dataValue.get('id_question') is None or ( len(self.dataValue.get('id_question')) == 0 );
self.id_question_type = self.dataValue.get('id_question_type')
#create or update question
self.questionObject = QuestionObject(**kw)
question = self.questionObject.question
question.user_id = user.user_id;
question.id_question = self.utility.setIfEmpty(question.id_question)
if question.id_question :
question.updateOrdering();
question.updateall();
else:
question.save();
log.info("save Question");
# create or update questionMedia
imageFile = self.questionObject.image_upload #self.dataValue.get('image_upload');
if type(imageFile) is types.InstanceType:
self.file_name = imageFile.filename;
self.file_data = imageFile.value;
self.target_file_name = self.utility.joinPathFileAndCreatePath(self.UPLOAD_DIR, str(question.id_question), self.file_name);
self.utility.saveFile(self.target_file_name,self.file_data);
questionMedia = model.QuestionMedia(id_question = question.id_question, value = self.file_name, media_type = imageFile.type, media_path_file = self.target_file_name )
questionMedia = model.QuestionMedia.getId(question.id_question);
if(questionMedia is None):
questionMedia = model.QuestionMedia();
questionMedia.id_question = question.id_question;
else:
self.utility.removeFile(questionMedia.media_path_file);
log.info('remove file : ' + questionMedia.media_path_file );
questionMedia.value = self.file_name;
questionMedia.media_type = imageFile.type;
questionMedia.media_path_file = self.target_file_name;
questionMedia.save();
log.info("save questionMedia");
#Step 2 create
datagrid = json.loads(self.questionObject.datagrid ); #json.loads(self.dataValue.get('datagrid'));
for basic_datas in datagrid:
log.info(basic_datas);
self.isCreate = basic_datas.get('id_question') is not None and len( str(basic_datas.get('id_question')).strip() ) > 0 ;
basicData = model.BasicData();
basicQuestion = model.BasicQuestion();
log.info("-----------------------Basic data-----------------------------------");
if (not self.isCreate ):
log.info ("create basic data");
basicData.id_basic_data_type = self.id_question_type; #image
basicData.save();
log.info ("create basic question");
basicQuestion.id_question = question.id_question;
basicQuestion.id_basic_data = basicData.id_basic_data;
basicQuestion.answer = basic_datas.get('answer') ;# ({True: True, False: False}[ basic_datas.get('answer') in 'true']);
basicQuestion.score = basic_datas.get('score') ;
basicQuestion.order = basic_datas.get('seq');
basicQuestion.id_question_result = basic_datas.get('id_question_result');
basicQuestion.save();
else:
log.info ("update basic data : " + str( basic_datas.get('id_basic_data')) );
basicData.id_basic_data = basic_datas.get('id_basic_data');
basicQuestion = model.BasicQuestion.getByQuestionAndBasic(question.id_question, basicData.id_basic_data);
if(basicQuestion):
basicQuestion.answer = basic_datas.get('answer') ;
basicQuestion.score = basic_datas.get('score') ;
basicQuestion.order = basic_datas.get('seq');
basicQuestion.id_question_result = basic_datas.get('id_question_result')
else:
log.info("error load basicQuestion");
log.info("------------------------basic Data type----------------------------------" );
log.info('self.id_question_type : ' + str(self.id_question_type) + ' type : ' + type(self.id_question_type).__name__ ) ;
if (self.id_question_type and int(self.id_question_type) in [QuestionType.single_choice.value,
QuestionType.multi_choice.value,
QuestionType.drop_down_menu.value,
QuestionType.text.value,
QuestionType.multitext.value,
QuestionType.number.value
]): # 1,2,3,5,6,7
log.info("case text");
basicText = model.BasicTextData();
if (not self.isCreate ):
log.info("create basic text");
basicText.id_basic_data = basicData.id_basic_data;
basicText.value = basic_datas.get('value');
basicText.save();
else:
log.info("update basic text");
basicText = model.BasicTextData.getByBasicDataId(basicData.id_basic_data);
if(basicText):
basicText.value = basic_datas.get('value');
else:
log.info("error load BasicTextData");
elif (self.id_question_type and int(self.id_question_type) == QuestionType.image.value ): #4
log.info("case image");
answerimage = self.dataValue.get('answer_image'); #self.questionObject.answer_image
log.info(basic_datas.get('answer_image'));
log.info(type(answerimage));
log.info('basicData.id_basic_data : ' + str(basicData.id_basic_data));
if (type(answerimage) is types.InstanceType or type(answerimage) is types.ListType) :
if type(answerimage) is types.InstanceType:
log.info('single file');
log.info(answerimage.type);
file = answerimage;
if( self.utility.isPartOf(file.filename,basic_datas.get('answer_image')) ):
#if (basic_datas.get('answer_image') == file.filename ) :
basicMedia = model.BasicMultimediaData();
self.file_name = file.filename;
self.file_data = file.value;
self.media_type = file.type;
self.target_file_name= self.utility.joinPathFileAndCreatePath(self.UPLOAD_DIR, str(question.id_question), self.file_name);
self.utility.saveFile(self.target_file_name,self.file_data);
if ( not self.utility.isNumber( basic_datas.get('id_basic_data') ) ):
log.info('create basic media');
basicMedia.id_basic_data = basicData.id_basic_data;
basicMedia.value = self.file_name;
basicMedia.media_type = self.media_type;
basicMedia.media_path_file = self.target_file_name;
basicMedia.save();
else:
log.info('update basic media');
basicMedia = model.BasicMultimediaData.getByBasicDataId(basic_datas.get('id_basic_data') );
self.utility.removeFile(basicMedia.media_path_file);
basicMedia.value = self.file_name;
basicMedia.media_type = self.media_type;
basicMedia.media_path_file = self.target_file_name;
else:
for file in answerimage:
log.info('type list file');
log.info(type(file));
if type(file) is not types.UnicodeType:
#print file.type;
if( self.utility.isPartOf(file.filename,basic_datas.get('answer_image')) ):
#if (basic_datas.get('answer_image') == file.filename) :
self.file_name = file.filename;
self.file_data = file.value;
self.media_type = file.type;
self.target_file_name= self.utility.joinPathFileAndCreatePath(self.UPLOAD_DIR, str(question.id_question), self.file_name);
self.utility.saveFile(self.target_file_name,self.file_data);
basicMedia = model.BasicMultimediaData();
if ( not self.utility.isNumber( basic_datas.get('id_basic_data') ) ):
log.info('create basic media');
basicMedia.id_basic_data = basicData.id_basic_data;
basicMedia.value = self.file_name;
basicMedia.media_type = self.media_type;
basicMedia.media_path_file = self.target_file_name;
basicMedia.save();
else:
log.info('update basic media');
basicMedia = model.BasicMultimediaData.getByBasicDataId(basic_datas.get('id_basic_data') );
self.utility.removeFile(basicMedia.media_path_file);
basicMedia.value = self.file_name;
basicMedia.media_type = self.media_type;
basicMedia.media_path_file = self.target_file_name;
else:
log.info("Other type");
pass;
log.info("save object");
return dict(success=self.success, message = self.message, result = self.result);
#proved
@expose('json')
def updateQuestionData(self, **kw):
reload(sys).setdefaultencoding("utf-8");
self.success = True;
self.message = "success";
#log.info(request.method );
#log.info(request.params );
self.df = json.loads(request.body, encoding=request.charset);
self.data = JsontoObject(self.df);
for obj in self.data.dict:
print obj.to_json()
self.success, self.message = model.Question.updateOrderById(order=obj.order, id= obj.id_question );
#for d in self.df:
# self.success, self.message = model.Question.updateOrderById(d.get(u'order'), d.get(u'id_question'));
return dict(success=self.success, message = self.message, survey = self.data.to_json());
#proved
@expose('json')
def deleteMediaQuestion(self, came_from=lurl('/'), *args, **kw):
reload(sys).setdefaultencoding("utf-8");
self.success = True;
self.message = "success";
log.info('---------1--------------');
df = json.loads(request.body, encoding=request.charset);
model.QuestionMedia.deleteByQuestion(df.get('id'));
del df
return dict(success=self.success, message = self.message);
#proved
@expose('json')
def deleteQuestionData(self, came_from=lurl('/'), *args, **kw):
reload(sys).setdefaultencoding("utf-8");
self.success = True;
self.message = "success";
log.info('---------1--------------');
df = json.loads(request.body, encoding=request.charset);
# remark : remove file
self.success,self.message = model.BasicQuestion.deleteData(df.get('id'), deleteBasicQuestion=True) ;
del df
return dict(success=self.success, message = self.message);
#proved
@expose('json')
def addOptions(self, came_from=lurl('/'), *args, **kw):
reload(sys).setdefaultencoding("utf-8");
self.success = True;
self.message = "success";
self.result = True;
self.optionobject = OptionObject(**kw);
self.option = self.optionobject.options
self.option.random_answer = self.utility.convertToBit(self.option.random_answer)
self.option.activate_date = self.utility.startDate( self.option.activate_date)
self.option.expire_date = self.utility.finishDate( self.option.expire_date)
self.option.show_score = self.utility.convertToBit( self.option.show_score )
self.option.show_navigator = self.utility.convertToBit( self.option.show_navigator )
self.option.id_question_option = self.utility.setIfEmpty(self.option.id_question_option)
if (self.utility.isEmpty(self.option.id_question_option)):
log.info("save option")
self.option.save()
else:
log.info("update option")
self.option.updateall()
self.groupamount = model.NumberQuestionGroup();
#number_question != 0
if self.optionobject.number_question:
for group_amount in self.optionobject.number_question :
data = JsontoObject(group_amount);
if (not self.utility.isNumber(data.id_question_group_amount)) :
data.id_question_group_amount = None
self.groupamount.id_question_group_amount = data.id_question_group_amount;
self.groupamount.id_question_option = self.option.id_question_option;
self.groupamount.id_question_group = data.id_question_group;
if data.amount == '' :
data.amount = 0
self.groupamount.amount = data.amount;
self.groupamount.updateall()
#number_question = 0
else :
self.numberquestiondata = []
self.group_project = []
self.numberquestiondata = model.NumberQuestionGroup.getByOptionFirst(self.option.id_question_option);
self.group_project = model.QuestionGroup.getByProject(self.option.id_question_project);
if self.optionobject.project_type == "1":#poll
#edit poll
if self.numberquestiondata:
self.groupamount.id_question_group_amount = self.numberquestiondata.id_question_group_amount;
self.groupamount.id_question_option = self.numberquestiondata.id_question_option;
self.groupamount.id_question_group = self.numberquestiondata.id_question_group;
self.groupamount.amount = self.optionobject.use_question_no;
self.groupamount.updateall()
#new poll
else :
for question_group in self.group_project:
self.groupamount.id_question_group_amount = None;
self.groupamount.id_question_option = self.option.id_question_option;
self.groupamount.id_question_group = question_group.id_question_group;
self.groupamount.amount = self.optionobject.use_question_no;
self.groupamount.updateall()
else : #not poll
if (not self.numberquestiondata) : #add
for question_group in self.group_project:
self.groupamount.id_question_group_amount = None;
self.groupamount.id_question_option = self.option.id_question_option;
self.groupamount.id_question_group = question_group.id_question_group;
self.groupamount.amount = len(question_group.questions);
self.groupamount.updateall()
return dict(success=self.success, message = self.message,result = self.result);
#proved
@expose('json')
def deleteOptions(self, came_from=lurl('/'), *args, **kw):
reload(sys).setdefaultencoding('utf8')
self.success = True;
self.message = "Save Success";
df = json.loads(request.body, encoding=request.charset);
log.info(df);
idQuestion = df.get('id_question_option');
self.success, self.message = model.QuestionOption.deleteById(idQuestion);
del df
return dict(success=self.success, message =self.message);
#proved
@expose('json')
def addInvitation(self, **kw):
reload(sys).setdefaultencoding('utf8')
log.info( kw);
self.success = True;
self.message = "Save Success";
self.result = True;
try:
user = request.identity['user'];
kw['user_id'] = user.user_id
self.template = model.Invitation(**kw);
self.template.id_question_invitation = self.utility.setIfEmpty(self.template.id_question_invitation)
#self.template.create_date = self.utility.today( self.template.create_date)
if ( self.utility.isEmpty( self.template.id_question_invitation )):
log.info("save option")
self.template.save()
else:
log.info("update option")
self.template.updateall()
except Exception as e:
self.result = False;
self.message = '' + str(e);
log.info( self.message);
return dict(success=self.success, message = self.message, result= self.result);
#proved
@expose('json')
@require(predicates.in_any_group('voter', 'managers', msg=l_('Only for voter')))
def deleteInvitation(self, **kw):
reload(sys).setdefaultencoding('utf8')
self.success = True;
self.result = True;
self.message = 'Delete Success';
try:
df = json.loads(request.body, encoding=request.charset);
log.info(df);
self.result =model.Invitation.deleteById(df.get('id_question_invitation'));
if not self.result:
self.message = 'Can not Delete.';
except Exception as e:
self.result =False;
self.message = '' + str(e);
return dict(success=self.success, result =self.result, message =self.message);
#proved
@expose('json')
@require(predicates.in_any_group('voter', 'managers', msg=l_('Only for voter')))
def sendSurvey(self, **kw):
reload(sys).setdefaultencoding('utf8')
self.success = True;
self.result = True;
self.message = 'Send Success';
try:
df = json.loads(request.body, encoding=request.charset);
log.info(df);
self.option = model.QuestionOption.getId(df.get('id_question_option'));
if self.option.send_status == 0:
self.emailtemplate = model.Invitation.getId(df.get('id_question_invitation'));
if(self.emailtemplate is not None):
#self.sendSurveyService = SendSurveyService();
#self.sendSurveyService.setEmailToVoter(model,self.option,self.emailtemplate);
#self.sendSurveyService.start();
user = request.identity['user'];
self.voters, self.leng = model.Voter.getVoter(user.user_id, page=0, page_size=100);
self.urlServer = model.SystemEnvironment.getServerUrl();
for v in self.voters:
#print v;
self.resp = model.Respondents.getByVoterIdAndPublicId(v.id_voter,self.option.id_question_option);
if (self.resp is None):
self.resp = model.Respondents();
self.resp.id_voter = v.id_voter;
self.resp.id_question_project = self.option.id_question_project;
self.resp.id_question_option =self.option.id_question_option;
self.resp.key_gen = self.utility.my_random_string(string_length=25)
self.resp.save();
if (self.resp.key_gen is None):
self.resp.key_gen = self.utility.my_random_string(string_length=25)
self.emailValues={};
self.emailValues['name'] = str(v.firstname) + " " + str(v.lastname);
self.emailValues['email'] = v.email;
self.emailValues['subject'] = self.emailtemplate.subject;
self.emailValues['from'] = self.emailtemplate.from_name;
#self.emailValues['url'] = self.urlUtility.URL_REPLY.format(self.urlServer, str(self.option.id_question_project), str(self.option.id_question_option), str(v.id_voter)) ; #request.application_url
self.emailValues['url'] = self.urlUtility.URL_QUESTIONNAIRE.format(nameserver=self.urlServer,key=self.resp.key_gen); #self.urlUtility.URL_REPLY.format(self.urlServer, str(self.option.id_question_project), str(self.option.id_question_option), str(v.id_voter)) ; #request.application_url
self.emailValues['initialDate'] = str(self.option.activate_date);
self.emailValues['finishDate'] = str(self.option.expire_date);
template = self.emailtemplate.content;
for k, va in self.emailValues.iteritems():
template = template.replace('[%s]' % k, va)
self.sendmail = model.SendMail(id_question_option = self.resp.id_question_option,
id_voter = self.resp.id_voter,
user_id =None,
sender_name = self.emailtemplate.from_name,
receive = v.email,
subject = self.emailtemplate.subject,
content = template,
gen_code = self.resp.key_gen );
self.sendmail.save();
#sendmail = SendMailService();
#sendmail.sentEmail(self.emailValues, template);
#self.sendmail.sended_date = datetime.now();
#self.sendmail.status = 'F';
else:
self.result = False;
self.message = "Please select template email.";
#self.result,self.message = model.QuestionOption.updateSendStatus(1,df.get('id_question_option'));
log.info( "\n send to thread");
else:
self.result = False;
self.message = "system found send already";
#model.Invitation.deleteById(df.get('id_question_invitation'));
except Exception as e:
log.error(e);
self.result = False;
self.message = '' + str(e);
return dict(success=self.success, result=self.result, message=self.message);
#proved
@expose('json')
@require(predicates.in_any_group('voter', 'managers', msg=l_('Only for voter')))
def addQuestionGroup(self,**kw):
reload(sys).setdefaultencoding('utf8')
log.info("add Question Group")
self.questionGroup = model.QuestionGroup(**kw);
self.questionGroup.id_question_group = self.utility.setIfEmpty(self.questionGroup.id_question_group)
self.questionGroup.id_question_result_group = self.utility.setIfEmpty(kw['id_question_result_group'])
if (self.utility.isEmpty(self.questionGroup.id_question_group)):
log.info("save group")
self.questionGroup.save()
else:
log.info("update group")
self.questionGroup.updateall()
return dict(success=True, result='success', message='sucess',questionGroup=self.questionGroup.json );
@expose('json')
@require(predicates.in_any_group('voter', 'managers', msg=l_('Only for voter')))
def deleteGroupQuestion(self, *args, **kw):
self.questionGroup = json.loads(request.body, encoding=request.charset, object_hook=model.QuestionGroup.setId)
self.message = ""
self.status = True
if(self.questionGroup):
self.questions = model.Question.getQuestionByGroupId(self.questionGroup.id_question_group)
if(self.questions and len(self.questions) > 0):
log.info("can not delete ");
self.message = "Cann't delete. Please delete all questions."
self.status = False
else:
model.QuestionGroup.delete(self.questionGroup);
return dict(success=self.status, message=self.message);
@expose('json')
def saveResultGroup(self,*args,**kw):
reload(sys).setdefaultencoding('utf8')
self.message = "Save Success"
self.status = True
data = JsontoObject(kw);
#model.QuestionResultGroup.load_data(data)
questionResultGroup = model.QuestionResultGroup(
id_question_result_group = self.utility.setIfEmpty(data.id_question_result_group),
id_question_project = data.id_question_project,
question_result_group_description = data.question_result_group_description,
question_result_group_name = data.question_result_group_name)
if questionResultGroup.id_question_result_group:
questionResultGroup.updateall()
else:
questionResultGroup.save()
datagrid = json.loads(data.datagrid,encoding='UTF-8')
#datagrid = JsontoObject(datagrid);
for value in datagrid:
value = JsontoObject(value);
questionResult = model.QuestionResult(id_question_result=self.utility.setIfEmpty(value.id_question_result),
question_result_name=value.question_result_name,
question_result_description=value.question_result_description,
id_question_result_group=questionResultGroup.id_question_result_group)
questionResult.updateall()
return dict(success= self.status, message = self.message);
@expose('json')
def deleteresultgroup(self, *args, **kw):
reload(sys).setdefaultencoding('utf8')
self.message = ""
self.status = True
self.df = json.loads(request.body, encoding=request.charset);
data = JsontoObject(self.df);
self.questionResult = model.QuestionResult.deleteByGroupId(data.id_question_result_group)
self.questionResultGroup = model.QuestionResultGroup.deleteById(data.id_question_result_group)
return dict(success= self.status, message = self.message);
@expose('json')
def deleteresult(self, *args, **kw):
reload(sys).setdefaultencoding('utf8')
self.message = ""
self.status = True
self.df = json.loads(request.body, encoding=request.charset);
data = JsontoObject(self.df);
print data
self.questionResult = model.QuestionResult.deleteById(data.id_question_result)
print self.questionResult
#self.questionResultGroup = model.QuestionResultGroup.deleteById(data.id_question_result_group)
#print self.questionResultGroup
return dict(success= self.status, message = self.message);
@expose('json')
def deleteQuestionGeneralInformation(self, *args, **kw):
reload(sys).setdefaultencoding('utf8')
self.message = ""
self.status = True
self.df = json.loads(request.body, encoding=request.charset)
data = JsontoObject(self.df)
model.QuestionGeneralInformation.deleteById(data.id)
return dict(success= self.status, message = self.message, survey = [])
@expose('json')
def updateQuestionGeneralInformation(self, *args, **kw):
reload(sys).setdefaultencoding('utf8')
self.message = ""
self.status = True
self.df = json.loads(request.body, encoding=request.charset);
data = JsontoObject(self.df);
for obj in data.dict:
print obj.to_json()
result = model.QuestionGeneralInformation.updateOrder(id=obj.id, order=obj.order)
print "result %s " %result
return dict(success= self.status, message = self.message, survey = data.to_json() )
@expose('json')
def createQuestionGeneralInformation(self, *args, **kw):
reload(sys).setdefaultencoding('utf8')
self.message = ""
self.status = True
self.df = json.loads(request.body, encoding=request.charset);
data = JsontoObject(self.df);
self.generalInformation = model.QuestionGeneralInformation(id_question_general_information=None, id_data_profile_field=data.data_id, id_question_project=data.id_question_project, order=data.order, active=1)
self.generalInformation.save()
data.id = self.generalInformation.id_question_general_information
return dict(success= self.status, message = self.message, survey = {'id':data.id} )#data.to_json())#data = {'data_id':data.data_id} )
