| /branches/v3/impl/conf/template/email/message_ipp_pt_certificated.txt |
|---|
| New file |
| 0,0 → 1,28 |
| |
| <html> |
| <head> |
| <title>{1}</title> |
| </head> |
| <body> |
| <p>Olá <b>@USER_NOME@</b></p> |
| <p><i>Mensagem de:</i> {0}</p> |
| <p><i>Assunto:</i> <b><u>{1}</u></b></p> |
| {2} |
| <hr/> |
| <p>Informação Automática PAE:</p> |
| <p><i>@USER_NOME@</i>, pode responder a esta solicitação acedendo directamente à sua conta no sistema PAE através do seguinte endereço: </a> |
| <a href="@URL@">@URL@</a> |
| <p>Se pretender contactar a entidade que lhe enviou a mensagem, use por favor o seguinte endereço de email: {3}</p> |
| --------------------------------------------- |
| <p>Instituto Politécnico de Portalegre - Sistema PAE</p> |
| <p><a href="http://pae.ipportalegre.pt">http://pae.ipportalegre.pt</a></p> |
| </body> |
| </html> |
| /branches/v3/impl/conf/template/email/message_ipp_pt.txt |
|---|
| 5,17 → 5,18 |
| </head> |
| <body> |
| <p>Olá <b>@USER_NOME@</b></p> |
| <p><i>Mensagem de:</i> {0}</p> |
| <p><i>Assunto:</i> <b><u>{1}</u></b></p> |
| {2} |
| <p>Cumprimentos</p> |
| <p>{0}</p> |
| <hr/> |
| <p>Se pretender responder, use o email: {3}</p> |
| --------------------------------------------- |
| <p>Instituto Politécnico de Portalegre - Sistema PAE</p> |
| /branches/v3/impl/src/java/pt/estgp/estgweb/utils/EmailPersonalizedCertificated.java |
|---|
| New file |
| 0,0 → 1,131 |
| package pt.estgp.estgweb.utils; |
| import org.apache.log4j.Logger; |
| import pt.estgp.estgweb.Globals; |
| import javax.mail.Message; |
| import java.io.Serializable; |
| import java.util.ArrayList; |
| import java.util.List; |
| /** |
| * @author Jorge Machado |
| * @date 20/Mar/2008 |
| * @time 18:32:21 |
| * @see pt.estgp.estgweb.utils |
| */ |
| public class EmailPersonalizedCertificated extends Email implements Serializable |
| { |
| private static final Logger logger = Logger.getLogger(EmailPersonalizedCertificated.class); |
| /**FIELDS FOR PERSONALIZED EMAILS**/ |
| private String urlPatternWithoutCetificate = null; |
| private List<Long> userIds = null; |
| public EmailPersonalizedCertificated cloneEmailForJob(){ |
| EmailPersonalizedCertificated email = new EmailPersonalizedCertificated(subject, from, emailTemplateName, arguments); |
| email = (EmailPersonalizedCertificated) super.cloneEmailForJob(email); |
| email.urlPatternWithoutCetificate = this.urlPatternWithoutCetificate; |
| if(this.userIds != null) |
| { |
| email.userIds = new ArrayList<Long>(); |
| email.userIds.addAll(this.userIds); |
| } |
| return email; |
| } |
| public EmailPersonalizedCertificated() |
| { |
| } |
| public EmailPersonalizedCertificated(String urlPatternWithoutCetificate, |
| List<Long> userIds) |
| { |
| this.urlPatternWithoutCetificate = urlPatternWithoutCetificate; |
| this.userIds = filterUserIds(userIds); |
| } |
| public EmailPersonalizedCertificated(String subject, String from, String mailTemplateName, List<String> arguments) |
| { |
| super( subject, new ArrayList<String>(), from, mailTemplateName, arguments, Message.RecipientType.TO); |
| } |
| public EmailPersonalizedCertificated(String subject, String from, String mailTemplateName, List<String> arguments, |
| String urlPatternWithoutCetificate, |
| List<Long> userIds) |
| { |
| super( subject, new ArrayList<String>(), from, mailTemplateName, arguments, Message.RecipientType.TO); |
| this.urlPatternWithoutCetificate = urlPatternWithoutCetificate; |
| this.userIds = filterUserIds(userIds); |
| } |
| public boolean isSystemAssumingTestEmail() { |
| return systemAssumingTestEmail; |
| } |
| public String getFromName() { |
| return fromName; |
| } |
| public void setFromName(String fromName) { |
| this.fromName = fromName; |
| } |
| public String getSubject() |
| { |
| return subject; |
| } |
| public List<String> getRecipients() |
| { |
| return recipients; |
| } |
| public void setRecipients(List<String> recipients) |
| { |
| systemAssumingTestEmail = true;//ja nao estao sobre |
| this.recipients = filterRecipients(recipients); |
| } |
| public String getUrlPatternWithoutCetificate() { |
| return urlPatternWithoutCetificate; |
| } |
| public void setUrlPatternWithoutCetificate(String urlPatternWithoutCetificate) { |
| this.urlPatternWithoutCetificate = urlPatternWithoutCetificate; |
| } |
| public List<Long> getUserIds() { |
| return userIds; |
| } |
| public void setUserIds(List<Long> userIds) { |
| this.userIds = filterUserIds(userIds); |
| } |
| /** |
| * Garante que os users Idss não são usados em testes |
| * @return |
| */ |
| protected List<Long> filterUserIds(List<Long> userIds) |
| { |
| if(Globals.TEST_ENVIRONEMENT) |
| { |
| userIds = new ArrayList<Long>(); |
| userIds.add(new Long(1));//Adding super user |
| } |
| return userIds; |
| } |
| } |
| /branches/v3/impl/src/java/pt/estgp/estgweb/utils/Email.java |
|---|
| 23,19 → 23,27 |
| private static final Logger logger = Logger.getLogger(Email.class); |
| private boolean systemAssumingTestEmail = false; |
| private boolean isHtml = false; |
| private String subject; |
| private List<String> recipients; |
| private Message.RecipientType type = Message.RecipientType.TO; |
| private String from; |
| private String emailTemplateName; |
| private List<String> arguments; |
| private String fromName = null; |
| protected boolean systemAssumingTestEmail = false; |
| protected boolean isHtml = false; |
| protected String subject; |
| protected List<String> recipients; |
| protected List<String> recipientsCC = null; |
| protected Message.RecipientType type = Message.RecipientType.TO; |
| protected String from; |
| protected String emailTemplateName; |
| protected List<String> arguments; |
| protected String fromName = null; |
| public Email cloneEmailForJob(){ |
| Email email = new Email(subject,recipients,from,emailTemplateName,arguments,type); |
| return cloneEmailForJob(email); |
| } |
| public Email cloneEmailForJob(Email email){ |
| email.systemAssumingTestEmail = this.systemAssumingTestEmail; |
| email.isHtml = this.isHtml; |
| email.subject = this.subject; |
| 57,6 → 65,9 |
| isHtml = html; |
| } |
| public Email() { |
| } |
| public Email(String subject, List<String> recipients, String from, String mailTemplateName, List<String> arguments) |
| { |
| this.subject = subject; |
| 78,7 → 89,7 |
| } |
| private List<String> filterRecipients(List<String> recipients,List<String> arguments,String template) |
| protected List<String> filterRecipients(List<String> recipients,List<String> arguments,String template) |
| { |
| if(Globals.TEST_ENVIRONEMENT) |
| { |
| 93,7 → 104,7 |
| } |
| return recipients; |
| } |
| private List<String> filterRecipients(List<String> recipients) |
| protected List<String> filterRecipients(List<String> recipients) |
| { |
| if(Globals.TEST_ENVIRONEMENT) |
| { |
| 190,4 → 201,11 |
| } |
| public List<String> getRecipientsCC() { |
| return recipientsCC; |
| } |
| public void setRecipientsCC(List<String> recipientsCC) { |
| this.recipientsCC = recipientsCC; |
| } |
| } |
| /branches/v3/impl/src/java/pt/estgp/estgweb/Globals.java |
|---|
| 364,6 → 364,7 |
| public static final String EMAIL_MESSAGE_TEMPLATE_PT = "message_pt.txt"; |
| public static final String EMAIL_MESSAGE_IPP_TEMPLATE_PT_CERTIFICATED = "message_ipp_pt_certificated.txt"; |
| public static final String EMAIL_MESSAGE_IPP_TEMPLATE_PT = "message_ipp_pt.txt"; |
| public static final String EMAIL_COURSEUNIT_WORK_SUBJECT_PT = ConfigProperties.getProperty("email.courseunit.work.subject.pt"); |
| /branches/v3/impl/src/java/pt/estgp/estgweb/services/email/SendEmailService.java |
|---|
| 8,6 → 8,7 |
| import pt.estgp.estgweb.services.expceptions.ServiceException; |
| import pt.estgp.estgweb.utils.ConfigProperties; |
| import pt.estgp.estgweb.utils.Email; |
| import pt.estgp.estgweb.utils.EmailPersonalizedCertificated; |
| import pt.estgp.estgweb.web.utils.DatesUtils; |
| import pt.utl.ist.berserk.logic.serviceManager.IService; |
| 49,8 → 50,14 |
| } |
| return serverEmails[serverEmailPos]; |
| } |
| public void sendEmail(Email email) throws ServiceException |
| { |
| sendEmail(email,null,null); |
| } |
| public void sendEmail(Email email,String url,String nome) throws ServiceException |
| { |
| if(Globals.TEST_ENVIRONEMENT && !email.isSystemAssumingTestEmail()) |
| { |
| String warn = "System in TEST Environement - will not send EMAIL"; |
| 114,17 → 121,37 |
| if(Email.validEmail(recipient)) |
| { |
| valid=true; |
| message.addRecipient(email.getType(),new InternetAddress(recipient)); |
| message.addRecipient(Message.RecipientType.TO,new InternetAddress(recipient)); |
| logger.info("Adding recipient (" + email.getType().toString() + ") to transport:"+recipient); |
| } |
| } |
| if(email.getRecipientsCC() != null) |
| { |
| for (String recipient : email.getRecipientsCC()) |
| { |
| if(Email.validEmail(recipient)) |
| { |
| //valid=true; |
| message.addRecipient(Message.RecipientType.CC,new InternetAddress(recipient)); |
| logger.info("Adding recipient CC (" + email.getType().toString() + ") to transport:"+recipient); |
| } |
| } |
| } |
| if(valid) |
| { |
| String fullMessage = getEmailTextMessage(email); |
| if(url != null && nome != null) |
| { |
| logger.info("Requesting certificated Email, will replace fields in template"); |
| fullMessage = fullMessage.replaceAll("@USER_NOME@",nome); |
| fullMessage = fullMessage.replaceAll("@URL@",url); |
| } |
| logger.info("FROM:" + email.getFrom() + " but using: " + sendFromAddress); |
| //if(email.getFromName() != null) |
| try { |
| 309,7 → 336,8 |
| // # 0 : From |
| // # 1 : Subject |
| // # 2 : Text |
| // # 2 : FromEmail Adultered in message |
| // # 3 : FromEmail Adultered in message |
| // # 4 : URL todo with certificate |
| List<String> arguments = new ArrayList<String>(); |
| arguments.add(from); |
| arguments.add(subject); |
| 342,13 → 370,56 |
| logger.info(rec); |
| logger.info("arguments end"); |
| fromEmail = fromEmail == null ? user.getEmail() : fromEmail; |
| Email email = new Email(subject ,recipients,fromEmail,template,arguments,Message.RecipientType.BCC); |
| Email email = new Email(subject ,recipients,fromEmail,template,arguments,Message.RecipientType.TO); |
| email.setFromName(from + " (PAE-IPP)"); |
| return email; |
| } |
| public EmailPersonalizedCertificated getMessageEmailAdulteredFromEmailIppCertificated( |
| String fromEmail, String from, String subject,String text, User user, |
| List<Long> userIds, |
| String url |
| ) |
| { |
| // # 0 : From |
| // # 1 : Subject |
| // # 2 : Text |
| // # 3 : FromEmail Adultered in message |
| // # 4 : URL todo with certificate |
| List<String> arguments = new ArrayList<String>(); |
| arguments.add(from); |
| arguments.add(subject); |
| arguments.add(text); |
| arguments.add(fromEmail); |
| String template; |
| template = Globals.EMAIL_MESSAGE_IPP_TEMPLATE_PT_CERTIFICATED; |
| logger.info("Preparing batch work for Personalized Emails Certificated"); |
| logger.info("subject: " + subject); |
| if(fromEmail == null) |
| logger.info("user: " + user.getEmail()); |
| else |
| logger.info("user altered to: " + fromEmail); |
| logger.info("template: " + template); |
| logger.info("arguments:"); |
| for(String arg: arguments) |
| logger.info(arg); |
| logger.info("userIds:" + userIds); |
| logger.info("arguments end"); |
| fromEmail = fromEmail == null ? user.getEmail() : fromEmail; |
| EmailPersonalizedCertificated email = new EmailPersonalizedCertificated(subject ,fromEmail,template,arguments, |
| url, |
| userIds); |
| email.setFromName(from + " (PAE-IPP)"); |
| return email; |
| } |
| public Email getMessageEmailOld(String from, String subject,String text, LangEnum langEnum, String target, List<User> users, User user) |
| { |
| // # 0 : From |
| /branches/v3/impl/src/java/pt/estgp/estgweb/services/email/Emails.bmp |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
| Property changes: |
| Added: svn:mime-type |
| + application/octet-stream |
| /branches/v3/impl/src/java/pt/estgp/estgweb/services/email/EMAILJobPersonalizedCertificated.java |
|---|
| New file |
| 0,0 → 1,137 |
| package pt.estgp.estgweb.services.email; |
| import jomm.dao.impl.AbstractDao; |
| import org.apache.log4j.Logger; |
| import pt.estgp.estgweb.Globals; |
| import pt.estgp.estgweb.domain.User; |
| import pt.estgp.estgweb.domain.dao.DaoFactory; |
| import pt.estgp.estgweb.services.authenticate.AuthenticateService; |
| import pt.estgp.estgweb.services.jobs.JobHandler; |
| import pt.estgp.estgweb.utils.Email; |
| import pt.estgp.estgweb.utils.EmailPersonalizedCertificated; |
| import java.io.Serializable; |
| import java.util.ArrayList; |
| import java.util.List; |
| /** |
| * @author Jorge Machado |
| * @date 11/Jul/2008 |
| * @see pt.estgp.estgweb.services.sms |
| */ |
| public class EMAILJobPersonalizedCertificated implements JobHandler, Serializable |
| { |
| private static final Logger logger = Logger.getLogger(EMAILJobPersonalizedCertificated.class); |
| private EmailPersonalizedCertificated email; |
| public EMAILJobPersonalizedCertificated(EmailPersonalizedCertificated email) |
| { |
| this.email = email; |
| } |
| private static final int pauseTime = 1000; |
| public void runJob() |
| { |
| final EmailPersonalizedCertificated cloned = email.cloneEmailForJob(); |
| logger.info("Opening new Thread to send emails"); |
| new Thread( |
| new Runnable() { |
| @Override |
| public void run() { |
| if(Globals.TEST_ENVIRONEMENT && !cloned.isSystemAssumingTestEmail()) |
| { |
| String warn = "System in TEST Environement - will not send EMAIL"; |
| logger.warn(warn); |
| return; |
| } |
| try |
| { |
| String URL_PREFIX = cloned.getUrlPatternWithoutCetificate(); |
| if(URL_PREFIX.indexOf("?") < 0) |
| URL_PREFIX = URL_PREFIX + "?certificate="; |
| else |
| URL_PREFIX = URL_PREFIX + "&certificate="; |
| cloned.setRecipients(new ArrayList<String>()); |
| for(long userId: cloned.getUserIds()) |
| { |
| try{ |
| AbstractDao.getCurrentSession().beginTransaction(); |
| AbstractDao.getCurrentSession().clear(); |
| User user = DaoFactory.getUserDaoImpl().load(userId); |
| String certificate = new AuthenticateService().createCertificate(user); |
| String emailStr = user.getEmail(); |
| String outEmail = user.getOutEmail(); |
| String preferrefEmail = user.getPreferrefEmail(); |
| String toEmail = null; |
| if(preferrefEmail != null && Email.validEmail(preferrefEmail)) |
| toEmail = preferrefEmail; |
| else if(emailStr != null && Email.validEmail(emailStr)) |
| toEmail = emailStr; |
| else if(outEmail != null && Email.validEmail(outEmail)) |
| toEmail = outEmail; |
| String nome = user.getName(); |
| AbstractDao.getCurrentSession().getTransaction().commit(); |
| if(toEmail != null) |
| { |
| List<String> ccEmails = new ArrayList<String>(); |
| if(emailStr != null && Email.validEmail(emailStr) && !toEmail.equals(emailStr)) |
| ccEmails.add(emailStr); |
| if(outEmail != null && Email.validEmail(outEmail) && !toEmail.equals(outEmail)) |
| ccEmails.add(outEmail); |
| cloned.setRecipientsCC(ccEmails); |
| cloned.getRecipients().clear(); |
| cloned.getRecipients().add(toEmail); |
| String finalUrl = URL_PREFIX + certificate; |
| new SendEmailService().sendEmail(cloned,finalUrl,nome); |
| try { |
| logger.info("Watting to send another email: sent to" + toEmail); |
| //Thread.sleep(pauseTime); |
| Thread.sleep(pauseTime); |
| } catch (InterruptedException e) { |
| logger.error(e,e); |
| } |
| } |
| }catch(Throwable e) |
| { |
| logger.error(e,e); |
| } |
| } |
| logger.info("No more user ids to send email. exiting"); |
| } |
| catch (Throwable e) |
| { |
| logger.error("Sending EMAIL:" + e.toString(),e); |
| } |
| } |
| } |
| ).start(); |
| } |
| } |
| /branches/v3/impl/src/java/pt/estgp/estgweb/services/questionarios/QuestionariosService.java |
|---|
| 1,14 → 1,17 |
| package pt.estgp.estgweb.services.questionarios; |
| import org.apache.log4j.Logger; |
| import pt.estgp.estgweb.Globals; |
| import pt.estgp.estgweb.domain.*; |
| import pt.estgp.estgweb.domain.dao.DaoFactory; |
| import pt.estgp.estgweb.domain.dao.impl.AnnouncementDaoImpl; |
| import pt.estgp.estgweb.domain.views.QuestionarioView; |
| import pt.estgp.estgweb.services.email.EMAILJob; |
| import pt.estgp.estgweb.services.email.EMAILJobPersonalizedCertificated; |
| import pt.estgp.estgweb.services.email.SendEmailService; |
| import pt.estgp.estgweb.services.jobs.JobScheduleService; |
| import pt.estgp.estgweb.utils.Email; |
| import pt.estgp.estgweb.utils.EmailPersonalizedCertificated; |
| import pt.estgp.estgweb.web.exceptions.NotAuthorizedException; |
| import pt.utl.ist.berserk.logic.serviceManager.IService; |
| 202,7 → 205,7 |
| public int sendMessage(boolean onlyNotAnswered,Long id,String msg,String emailFrom,String personFrom, String subject,UserSession userSession) |
| { |
| String source = "questionario message"; |
| AnnouncementDaoImpl.FindUsersResult result = DaoFactory.getQuestionarioDaoImpl().findUsersEmails(id,onlyNotAnswered); |
| AnnouncementDaoImpl.FindUsersIdResult result = DaoFactory.getQuestionarioDaoImpl().findUsersIds(id, onlyNotAnswered); |
| return sendEmails(id, msg, emailFrom, personFrom, subject, userSession, source, result); |
| } |
| 210,19 → 213,19 |
| public int sendMessageCursoAfeto(boolean onlyNotAnswered,Long id,String msg,String emailFrom,String personFrom, String subject,UserSession userSession) |
| { |
| String source = "questionario curso message"; |
| AnnouncementDaoImpl.FindUsersResult result = DaoFactory.getQuestionarioDaoImpl().findUsersEmailsPedagogico(onlyNotAnswered,id,0); |
| AnnouncementDaoImpl.FindUsersIdResult result = DaoFactory.getQuestionarioDaoImpl().findUsersIdsPedagogico(onlyNotAnswered, id, 0); |
| return sendEmails(id, msg, emailFrom, personFrom, subject, userSession, source, result); |
| } |
| public int sendMessageUnidadeAfeta(boolean onlyNotAnswered,Long id,String msg,String emailFrom,String personFrom, String subject,UserSession userSession) |
| { |
| String source = "questionario unidade message"; |
| AnnouncementDaoImpl.FindUsersResult result = DaoFactory.getQuestionarioDaoImpl().findUsersEmailsPedagogico(onlyNotAnswered,0,id); |
| AnnouncementDaoImpl.FindUsersIdResult result = DaoFactory.getQuestionarioDaoImpl().findUsersIdsPedagogico(onlyNotAnswered, 0, id); |
| return sendEmails(id, msg, emailFrom, personFrom, subject, userSession, source, result); |
| } |
| private int sendEmails(Long id, String msg, String emailFrom, String personFrom, String subject, UserSession userSession, String source, AnnouncementDaoImpl.FindUsersResult result) { |
| List<String> usersToConsume = result.emails; |
| private int sendEmails(Long id, String msg, String emailFrom, String personFrom, String subject, UserSession userSession, String source, AnnouncementDaoImpl.FindUsersIdResult result) { |
| List<Long> usersToConsume = result.userIds; |
| logger.info("Scheduling mail jobs to " + result.users + " users: " + usersToConsume.size() + " recipients"); |
| 238,15 → 241,16 |
| // contador++; |
| // } |
| Email e = sendEmailService.getMessageEmailAdulteredFromEmailIpp(emailFrom, |
| EmailPersonalizedCertificated e = sendEmailService.getMessageEmailAdulteredFromEmailIppCertificated(emailFrom, |
| personFrom, |
| subject, |
| msg, |
| userSession.getUser(), |
| usersToConsume, |
| userSession.getUser()); |
| Globals.SITE_URL + "/user/homePae.do"); |
| e.setHtml(true); |
| EMAILJob emailJob = new EMAILJob(e); |
| EMAILJobPersonalizedCertificated emailJob = new EMAILJobPersonalizedCertificated(e); |
| JobScheduleService.getInstance().scheduleNow(emailJob,"Message Email (" + source + ":id " + id + ") from " + userSession.getUsername() + " as " + personFrom + " - subject:" + subject ,userSession); |
| //} |
| enviarComprovativoAoRemetente(id, msg, emailFrom, personFrom, subject, userSession, source,usersToConsume.size()); |
| /branches/v3/impl/src/java/pt/estgp/estgweb/services/authenticate/AuthenticateService.java |
|---|
| 329,6 → 329,15 |
| User u = DaoFactory.getUserDaoImpl().load(userId); |
| return createCertificate(u, usersession); |
| } |
| public String createCertificateForId(long userId) |
| { |
| User u = DaoFactory.getUserDaoImpl().load(userId); |
| return createCertificate(u); |
| } |
| public String createCertificate(User user) |
| { |
| return createCertificate(user,null); |
| } |
| /** |
| * Create a new Certificate for usage in URL auto login |
| * |
| /branches/v3/impl/src/java/pt/estgp/estgweb/domain/dao/impl/QuestionarioDaoImpl.java |
|---|
| 10,9 → 10,7 |
| import pt.estgp.estgweb.domain.*; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import static org.hibernate.criterion.Restrictions.*; |
| 144,6 → 142,7 |
| return 0; |
| } |
| /* |
| public AnnouncementDaoImpl.FindUsersResult findUsersEmails(Long id,boolean onlyNotAnswered) |
| { |
| 170,16 → 169,46 |
| } |
| */ |
| public AnnouncementDaoImpl.FindUsersResult findUsersEmailsPedagogico(boolean onlyNotAnswered,long cursoAfetoId,long unidadeAfetaId) |
| public AnnouncementDaoImpl.FindUsersIdResult findUsersIds(Long id,boolean onlyNotAnswered) |
| { |
| AnnouncementDaoImpl.FindUsersResult findUsersResult = new AnnouncementDaoImpl.FindUsersResult(); |
| List<String> users = new ArrayList<String>(); |
| findUsersResult.emails = users; |
| AnnouncementDaoImpl.FindUsersIdResult findUsersResult = new AnnouncementDaoImpl.FindUsersIdResult(); |
| List<Long> users = new ArrayList<Long>(); |
| findUsersResult.userIds = users; |
| Query q = AbstractDao.getCurrentSession().createQuery("SELECT " + |
| " u.outEmail, u.preferrefEmail, u.email " + |
| " u.id " + |
| "from " + QuestionarioRespostaRequisitada.class.getName() + " rR " + |
| "JOIN rR.questionario q " + |
| "JOIN rR.user u " + |
| "WHERE q.id = :id " + |
| (onlyNotAnswered? " AND rR.resposta is null " : "" ) + |
| "GROUP BY u.id"); |
| q.setLong("id",id); |
| List<Object> results = (List<Object>) q.list(); |
| for(Object result: results) |
| { |
| findUsersResult.userIds.add((Long) result); |
| } |
| findUsersResult.users = results.size(); |
| return findUsersResult; |
| } |
| public AnnouncementDaoImpl.FindUsersIdResult findUsersIdsPedagogico(boolean onlyNotAnswered,long cursoAfetoId,long unidadeAfetaId) |
| { |
| AnnouncementDaoImpl.FindUsersIdResult findUsersResult = new AnnouncementDaoImpl.FindUsersIdResult(); |
| List<Long> users = new ArrayList<Long>(); |
| findUsersResult.userIds = users; |
| Query q = AbstractDao.getCurrentSession().createQuery("SELECT " + |
| " u.id " + |
| "from " + QuestionarioPedagogicoAlunoRequisitado.class.getName() + " aR " + |
| "JOIN aR.respostaRequisitada rR " + |
| "JOIN rR.user u " + |
| 190,35 → 219,18 |
| (onlyNotAnswered? " AND rR.resposta is null " : "" ) + |
| "GROUP BY u.id"); |
| List<Object[]> results = (List<Object[]>) q.list(); |
| List<Object> results = (List<Object>) q.list(); |
| fullFillResults(findUsersResult, results); |
| for(Object result: results) |
| { |
| findUsersResult.userIds.add((Long) result); |
| } |
| findUsersResult.users = results.size(); |
| return findUsersResult; |
| } |
| private void fullFillResults(AnnouncementDaoImpl.FindUsersResult findUsersResult, List<Object[]> results) { |
| Map<String,String> emailsSet = new HashMap<String, String>(); |
| for(Object[] result: results) |
| { |
| if(result[0] != null) |
| { |
| emailsSet.put((String) result[0],""); |
| } |
| if(result[1] != null) |
| { |
| emailsSet.put((String) result[1],""); |
| } |
| if(result[2] != null) |
| { |
| emailsSet.put((String) result[2],""); |
| } |
| } |
| findUsersResult.emails.addAll(emailsSet.keySet()); |
| findUsersResult.users = results.size(); |
| } |
| public static class QuestionarioStatsVars |
| /branches/v3/impl/src/java/pt/estgp/estgweb/domain/dao/impl/AnnouncementDaoImpl.java |
|---|
| 41,6 → 41,13 |
| public int users; |
| public List<String> emails; |
| } |
| public static class FindUsersIdResult |
| { |
| public int users; |
| public List<Long> userIds; |
| } |
| public FindUsersResult findUsersEmails(String year, String department, long courseId, long courseUnitId, String semestre, CreateAnnouncementService.MessageTarget target) |
| { |
| FindUsersResult findUsersResult = new FindUsersResult(); |
| /branches/v3/impl/src/doc/estgweb.eap |
|---|
| Cannot display: file marked as a binary type. |
| svn:mime-type = application/octet-stream |
