def __init__(self):
     self.utility = Utility();
     self.urlUtility = URLUtility();
      
     
     
     self.sourceHtml = model.SystemEnvironment.getScoreViewHtml();
     self.answerQuestionService = AnswerQuestionService(mymodel = model)
     
     dh = LogDBHandler( config=config,request=request);        
     log.addHandler(dh)
class AnswerQuestionController(BaseController):#RestController): #
    
    def __init__(self):
        self.utility = Utility();
        self.urlUtility = URLUtility();
         
        
        
        self.sourceHtml = model.SystemEnvironment.getScoreViewHtml();
        self.answerQuestionService = AnswerQuestionService(mymodel = model)
        
        dh = LogDBHandler( config=config,request=request);        
        log.addHandler(dh)
        
       
    
    @expose()
    def _default(self, *args, **kw):
        return 'This page is not ready'
    
    def _before(self, *args, **kw):
        tmpl_context.project_name = 'pollandsurvey'
    
            
    @expose('pollandsurvey.templates.view.multiquestion')
    def questionnaire(self,key=0,ready='no',**kw):
        reload(sys).setdefaultencoding('utf8')
        log.info("key %s , ready %s" %( key,ready) );
        print ("key %s , ready %s" %( key,ready) );
        self.header = '';
        self.footer = '';
        self.nextQuestion ='';
        self.template ='';
        self.userName='';
        
        
        self.respondents = model.Respondents.getByKey(keyGen=key);
        if self.respondents :
            
            self.urlReply = self.urlUtility.URL_REPLY.format( model.SystemEnvironment.getServerUrl() , str(self.respondents.id_question_project), str(self.respondents.id_question_option), str(self.respondents.id_voter))  ; #request.application_url
            log.info("iframe url to %s" %self.urlReply);
            
            #check finish
            self.isRedirect ,self.redirect  = self.answerQuestionService.checkFinish(respondent = self.respondents, urlUtility = self.urlUtility)
            if self.isRedirect:
                redirect(self.redirect) ;
            
            #check Expire
            self.questionOption,self.redirect = self.__checkOptionExpired(self.respondents.id_question_option);    
            
            
            if str(ready).lower() == 'no':    
                #check have welcome page
                if( not self.utility.isEmpty(self.questionOption.welcome_message) ) :
                    #redirect('/ans' + '/welcome?id='+ str(self.questionOption.id_question_option) );
                    log.info("show message welcome : ");
                    redirect( self.urlUtility.URL_WELCOME.format(key = str(key)) )#   self.URL_WELCOME_NEW.format(str(key))  );
                else:
                    log.info("show questionnaire : ");
                    self.template =  self.questionOption.theme.template;
                    override_template(AnswerQuestionController.questionnaire, self.template) ;    
                    
            elif str(ready).lower() == 'yes':
                self.header = self.questionOption.header_message;
                self.footer = self.questionOption.footer_message;
                self.urlName = self.utility.spritValue(request.path_info,'/');
                self.template =  self.questionOption.theme.template
                if(len(self.urlName) >= 1 ) :
                    self.nextQuestion = '/' + self.urlName[0] + '/saveQuestion' + '?id='+ str(self.questionOption.id_question_option);
                
                
                if(self.template is not None and len(self.template) > 0):    
                    log.info("template used : %s"   %self.template );     
                    
                    override_template(AnswerQuestionController.questionnaire, self.template) 
                    
                self.ip=request.environ.get("X_FORWARDED_FOR", request.environ["REMOTE_ADDR"]);
                self.browser = request.environ.get('HTTP_USER_AGENT');
                
            self.header = self.questionOption.header_message;
            self.footer = self.questionOption.footer_message;
            self.urlName = self.utility.spritValue(request.path_info,'/');
            self.template =  self.questionOption.theme.template 
            if self.respondents.voter:
                self.userName =  "******"%(self.respondents.voter.firstname,self.respondents.voter.lastname);            
        else:
            log.warning("find not found key %s" %str(key));
            redirect(self.urlUtility.URL_EXPIRED) ;       
        
        print "header : %s" %self.header
        return dict(page='view', header = Markdown(self.header).convert() , 
                        footer = Markdown(self.footer).convert()  , 
                        action = self.nextQuestion, template= self.template,
                        #urldata = self.URL_GETDATAQUESTION.format(self.idPublic),
                        urldata =  self.urlUtility.URL_GETDATAQUESTION.format(key=str(key)),#  self.URL_GETDATAQUESTION.format(key),  
                        idproject = self.questionOption.id_question_option ,
                        idresp = self.respondents.id_respondents,
                        username = self.userName,
                        shownavigator = bool(self.questionOption.show_navigator) ); 
    
     
    
    @expose('pollandsurvey.templates.view.welcome')
    def welcome(self,key=0,came_from=lurl('/')):
        reload(sys).setdefaultencoding("utf-8");
         
        
        log.info('preview id : ' + str(key));
        
        self.respondents = model.Respondents.getByKey(key);
        #self.idProject,self.idPublic,self.idVoter,self.redirect = self.__checkExpire(id);
        if (self.respondents):
        
            self.welcome_message = '';
            
            self.questionOption,self.redirect = self.__checkOptionExpired(self.respondents.id_question_option);
                    
            self.welcome_message= self.questionOption.welcome_message;
            self.nextQuestion  = '';
             
            self.urlName = self.utility.spritValue(request.path_info,'/');
             
            if(len(self.urlName) >= 1 ) :
                #self.nextQuestion = '/' + self.urlName[0]+ '?id='+ str(self.questionOption.id_question_option);
                #self.nextQuestion = '/' + 'ans/reply/'+  str(self.questionOption.id_question_option);
                #self.nextQuestion = self.URL_REPLY.format(id)
                self.nextQuestion = self.urlUtility.URL_REPLY_QUESTIONNAIRE.format(key=str(key)); 
        else:
            log.error("find not found respondent with key %s ", str(key));
            redirect(self.urlUtility.URL_EXPIRED) ;       
            
               
            
        #self.welcome_message
        return dict(page='view', ready = 'yes',welcome_message = Markdown(self.welcome_message).convert(), nextQuestion= self.nextQuestion);
    
            
     
    
    @expose('pollandsurvey.templates.view.goodbye')
    def thankyou(self,key=0,came_from=lurl('/')):
        reload(sys).setdefaultencoding("utf-8");
        
        log.info('thankyou preview id : %s' %str(key));
        self.isRedirect = True
        self.goodbye = '';
        self.nextQuestion  = '';
        self.urlRedirect = ''; 
        self.showScore = False
        self.respondents = model.Respondents.getByKey(keyGen=key);
        if(self.respondents):
            self.urlName = self.utility.spritValue(request.path_info,'/');
            log.info( "path %s" %self.urlName)
            self.questionOption = self.respondents.question_option
            if self.questionOption :
                self.goodbye= self.questionOption.end_message
                self.showScore = self.utility.convertToBool(self.questionOption.show_score)
                self.urlRedirect = self.questionOption.redirect_url
                if self.utility.convertToBool(self.respondents.redirect_other_url):
                    self.urlRedirect = self.questionOption.redirect_other_url
                
                self.isRedirect = False
            
            self.projectType = self.respondents.question_project.id_question_project_type
            del self.questionOption
        
        if self.isRedirect :
            log.error("find not found respondent with key %s " % str(key));
            redirect(self.urlUtility.URL_EXPIRED) ;  
            
    
        return dict(page='goodbye', ready = 'yes',goodbye = Markdown(self.goodbye).convert(),nextQuestion = self.nextQuestion ,urlRedirect= self.urlRedirect,
                    showScore = self.showScore  ,projectType = self.projectType,imageId = self.respondents.id_respondents);
    
    
    
    @expose('json')
    def getDataPreview(self, key=0,   *args, **kw):   
            
        reload(sys).setdefaultencoding("utf-8");
        log.info("function getDataPreview");
        
        self.respondents = model.Respondents.getByKey(key);
        
        if(self.respondents is None):
            return dict(questions = [],timer = 0);
        
        
        self.idProject=self.respondents.id_question_project;
        self.idPublic=self.respondents.id_question_option;
        self.questionOption = model.QuestionOption.getId(self.idPublic);
        
        log.info("idProject : %s,  idPublic : %s, idVoter : %s, id_respondents : %s"  %( str(self.idProject), str(self.idPublic), str(self.respondents.id_voter) , str(self.respondents.id_respondents) ) );
        
               
        #get old question
        self.answerQuestionService.renewQuestionForUser( respondents = self.respondents, id_close_type = self.questionOption.id_close_type)
        
        self.listReply = model.RespondentReply.listQuestionForUser(self.respondents.id_respondents); #questionobject by id_respondents
        self.respondents.respondent_data = datetime.now();
        
        question = [];
        self.listquestion = [];
        self.order =1
        log.info("Random Question And Answer : " );
        
        if( len(self.listReply) > 0 ):
            
            log.info("Random new");
            self.listquestion = self.answerQuestionService.getQuestionGroupWithReply(listReply= self.listReply)
        else:
          
            log.info( "Get New Question")             
            self.listquestion = self.answerQuestionService.getQuestionGroupWithQuestionOption(self.questionOption)
            self.answerQuestionService.createQuestionForUser(listQuestion=self.listquestion, id_close_type= self.questionOption.id_close_type)
            
        self.listquestion, self.order = self.answerQuestionService.genSeq(listQuestion = self.listquestion)
                 
        
        #question = self.__randomQuestionAndAnswer(question,self.questionOption);    
        #self.__setSequenceQuestion(question); 
        
         
        questions = [];
        questions.append({'id': self.idProject, 'question' : self.listquestion, 'total': self.order});
        
        return dict(questions = questions,timer = self.questionOption.duration_time);
    
    
    @expose('json')
    def saveQuestion(self, *args, **kw):
        reload(sys).setdefaultencoding("utf-8");
        log.info( "function save Question answer");
        log.info( request.body);
        
        self.saveQuests = JsontoObject(json.loads(request.body, encoding=request.charset))        
        self.finished = self.saveQuests.finished
        self.idresp = None
        self.redirect = ''
        
        if (len(self.saveQuests.value) >0):
            for item in self.saveQuests.value:
                if(item):
                    self.idresp = item.idresp
                    self.questionOption,self.redirect = self.__checkOptionExpired(item.idproject,False);#check Expired
                    self.respondent,self.redirect = self.__checkRespondentFinished( None,  None,item.idresp,False);#check finished
                    if(self.respondent):
                        self.respondent.finished = self.finished;
                        self.respondent.finished_date = datetime.now();
        
                        self.question = model.Question.getById(item.id);#getQuestion                         
                        if(self.question):
                            self.respondentreply = model.RespondentReply.getByRespondentAndQuestion(item.idresp,item.id);
                            
                            
                            if (self.respondentreply is None):
                                self.respondentreply = model.RespondentReply(id_respondents = item.idresp,id_question = item.id);                                
                                self.respondentreply.save();
                                
                                log.info("save answer respondentreply : " +str( self.respondentreply.id_respondents ) + " and " + str( self.respondentreply.id_question ) + " success");
                            
                            if (len(self.respondentreply.childenAnswer) == 0):
                                #save
                                for v in item.value:                                    
                                    self.replyquestion = model.ReplyBasicQuestion(id_resp_reply = self.respondentreply.id_resp_reply,
                                                                                  id_basic_data = v.id,
                                                                                  answer_text = v.value
                                                                                  ); 
                                    self.replyquestion.save();
                                    v = None
                                    del v
                                    log.info("save answer replyquestion : " +str( self.respondentreply.id_resp_reply ) + " and " + str( self.replyquestion.id_basic_data ) + " success");
                            else:
                                log.info('user %s do this question : %s Already'%(item.idresp,item.id));
                        else:
                            log.info('find not found question id : : %s' %(item.id));
                    else:
                        log.info('find not found respondent id : : %s' %(item.idresp));
                    
                    item = None
            
            model.DBSession.flush()
            #calculate score        
            if(self.finished):  
                log.info('finished : calculate score ')
                
                model.Respondents.updateScoreByIdRespondents(self.idresp)
                model.Respondents.updatePersonalityScoreByIdRespondents(self.idresp)
                transaction.commit()
                self.answerQuestionService.createScoreFileImage(self.idresp)
                #self.__createScoreFile(self.idresp);
                self.redirect = self.urlUtility.URL_GOODBYE.format( key=  self.utility.splitNameWithOutExtention(basename(request.environ.get("HTTP_REFERER" )))  );
        
        return dict(success = True,redirect = self.redirect, finished = self.finished  );
    
    
    @expose('json')
    def getresult(self, *args, **kw):
        reload(sys).setdefaultencoding("utf-8");
        self.result = model.Respondents.getResultPersonality(id_respondents=124)
        #for r in self.result:
        print   self.result
     
    
    
    @expose('pollandsurvey.templates.certificate.index')   
    def viewCertScore(self,key=0,**kw):
        reload(sys).setdefaultencoding('utf8')
        certificateUser = dict(
                               title='Certificate Of Jobsmatcher',
                               label_score='scored', 
                               label_date='Date', 
                               name='', 
                               score='0/0', 
                               type='', 
                               finishDate=''
                               )
        self.respondents = model.Respondents.getId(key)
        
        if self.respondents:
            self.result = model.Respondents.getScoreByIdRespondents(id_respondents=key)
            certificateUser['name'] =   (' ').join([self.respondents.voter.prefix, self.respondents.voter.firstname, self.respondents.voter.lastname])
            certificateUser['finishDate']  =  self.utility.getDateByFormat(date = self.respondents.finished_date)  
            certificateUser['score'] = self.result
            certificateUser['type'] = self.respondents.question_project.name
            log.info( "respondents %s , score %s" %(key, self.result))
        
        return dict(page = 'certificate',certificateUser = certificateUser)
    
    def __checkExpire(self,id):
        #sprint 10.2.1.0.html     idproject.idpublic.idvoter.
        self.value = self.utility.spritValue(id,'.');
         
        self.idProject =0;
        self.idPublic = 0;
        self.idVoter = 0;
        
        self.redirect = '';
        
        
        
        if(len(self.value)  == 4):
            self.idProject =self.value[0];
            self.idPublic = self.value[1];
            self.idVoter = self.value[2];
        else:
            self.idProject =None;
            self.idPublic = None;
            self.idVoter = None;
            
            log.info('parameter not have 4 parameter : %s', ','.join(self.value));
            self.redirect = self.urlUtility.URL_EXPIRED;
            redirect(self.urlUtility.URL_EXPIRED) ;
        
        self.voter = model.Voter.getId(self.idVoter);
        if(self.voter is None):
            log.info('find not voter in id : %s',self.idVoter);
            self.redirect = self.urlUtility.URL_HOME;
            redirect(self.urlUtility.URL_HOME) ;
        
        self.project = model.QuestionProject.getId(self.idProject);
        if(self.project is None):
            log.info('find not project in id project : %s',self.idProject);
            self.redirect = self.urlUtility.URL_HOME;
            redirect(self.urlUtility.URL_HOME) ;
            
        return self.idProject,self.idPublic,self.idVoter, self.redirect;
            
    def __checkOptionExpired(self,idPublic,isRedirect = True):
        #print 'public option id ',idPublic;
        self.questionOption = model.QuestionOption.getId( idPublic);           
        self.redirect = '';
        if  self.questionOption is None or ( not self.utility.isActiveFromDate(None,self.questionOption.activate_date,self.questionOption.expire_date) ):
            self.redirect = self.urlUtility.URL_EXPIRED;
            if (isRedirect):
                #print 'redirect ',self.URL_EXPIRED; 
                redirect(self.urlUtility.URL_EXPIRED) ;
      
                
        #print 'id option : ', self.questionOption.welcome_message;
        
        return self.questionOption,self.redirect;    
            
    def __checkRespondentFinished(self,idVoter,idPublic,idResp,isRedirect = True): 
        self.respondent = None;
        self.redirect = '';
        if(idVoter and idPublic):           
            self.respondent = model.Respondents.getByVoterAndPublicId(idVoter,idPublic);
        elif (idResp):           
            self.respondent = model.Respondents.getId(idResp);            
        if(self.respondent  is not None and self.respondent.finished == CheckFinish.finished.value): #finished = 1            
            log.info('voter finished in id public : %s',idPublic);
            self.redirect = self.urlUtility.URL_THANKYOU;
            if (isRedirect):
                redirect(self.urlUtility.URL_THANKYOU) ;
        elif (self.respondent is None):           
            log.error("System can not find idVoter : %s , idPublic : %s" , idVoter, idPublic);
            
            redirect(self.urlUtility.URL_THANKYOU) ;
        
        return self.respondent,self.redirect;
    
    def __getQuestion(self,idPublic,questionOption):
        
        question = [];
        #get Project Option
        
        if self.questionOption :
            #get Question 
            self.listQuestions = model.Question.getByProjectId(questionOption.id_question_project);
            
            
            #get to object json
            for self.question in self.listQuestions:
                question.append(self.question.to_json(randomAnswer = questionOption.random_answer));
            
            
            
            #clear sequence 
               
        return question ;
    
    def __getQuestionFromReply(self,reply,questionOption):
        question = [];
        for re in reply:
            #re.question
            question.append(re.question.to_json(randomAnswer= questionOption.random_answer));
        
        return question;
    
    def __randomQuestionAndAnswer(self,question,questionOption):       
        #option Randon Question       
        if( questionOption.id_fix_random_type == RandomType.simple_random.value):   #id_fix_random_type == 2          
            question = random.sample(question,len(question));#,self.questionOption.use_question_no );
        
        
        question = question[0:questionOption.use_question_no];
            
        return question;
    
    def __setSequenceQuestion(self,question):
        row = 1;
        for q in question:
            q['seq'] = row;
            row = row +1; 
        row =None;
        
        return question;