moved winix directories to winixdsubdirectory

git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1028 e52654a7-88a9-db11-a3e9-0013d4bc506e

winixd/notify/notifythread.cpp

@@ -0,0 +1,301 @@
+/*
+ * This file is a part of Winix
+ * and is distributed under the 2-Clause BSD licence.
+ * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ */
+
+/* 
+ * Copyright (c) 2008-2014, Tomasz Sowa
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+#include "notifythread.h"
+
+
+namespace Winix
+{
+
+
+// first thread (objects are locked)
+NotifyThread::NotifyThread()
+{
+	patterns_changed = true;
+}
+
+
+// first thread (objects are locked)
+void NotifyThread::SetConfig(Config * pconfig)
+{
+	config = pconfig;
+}
+
+
+
+// first thread (objects are locked)
+void NotifyThread::SetUsers(Users * pusers)
+{
+	users = pusers;
+}
+
+
+
+// first thread (objects are locked)
+void NotifyThread::SetNotifyPool(NotifyPool * pool)
+{
+	notify_pool = pool;
+}
+
+
+// first thread (objects are locked)
+void NotifyThread::SetPatterns(Patterns * pat)
+{
+	pat_global = pat;
+}
+
+
+// first thread (objects are locked)
+void NotifyThread::PatternsChanged()
+{
+	patterns_changed = true;
+}
+
+
+// first thread (objects are locked)
+bool NotifyThread::Init()
+{
+	TemplatesNotifyFunctions::CreateFunctions();
+
+return true;
+}
+
+
+
+// first thread (objects are locked)
+bool NotifyThread::SignalReceived()
+{
+	if( patterns_changed )
+	{
+		patterns = *pat_global;
+		patterns_changed = false;
+	}
+
+return !notify_pool->Empty();
+}
+
+
+
+
+
+// second thread (objects are not locked)
+// return true if there is something to send from the first queue (notify_pool)
+bool NotifyThread::AddNextNotify()
+{
+Users::Iterator i;
+bool res = false;
+
+	Lock();
+
+	if( !notify_pool->Empty() )
+	{
+		TemplatesNotifyFunctions::notify_msg = notify_pool->GetFirst();
+		notify_pool->DeleteFirst();
+
+		if( TemplatesNotifyFunctions::notify_msg.code == WINIX_NOTIFY_CODE_CONFIRM_ACCOUNT ||
+			TemplatesNotifyFunctions::notify_msg.code == WINIX_NOTIFY_CODE_RESET_PASSWORD )
+		{
+			msg.email = TemplatesNotifyFunctions::notify_msg.email;
+			msg.name  = TemplatesNotifyFunctions::notify_msg.name;
+			msg.lang  = TemplatesNotifyFunctions::notify_msg.lang;
+
+			notify_user.push_back(msg);
+			res = true;
+		}
+		else
+		{
+			for(i=users->Begin() ; i != users->End() ; ++i)
+			{
+				if( (i->notify & TemplatesNotifyFunctions::notify_msg.code) != 0 )
+				{
+					msg.name  = i->name;
+					msg.email = i->email;
+					msg.lang  = config->locale_default_id; // !! IMPROVE ME bedzie osobno dla kazdego uzytkownika
+
+					notify_user.push_back(msg);
+					res = true;
+				}
+			}
+		}
+	}
+
+	Unlock();
+
+return res;
+}
+
+
+
+// second thread -- here we must use Lock() and Unlock() explicitly
+void NotifyThread::Do()
+{
+NotifyUser::iterator i;
+bool queue_end;
+
+	while( AddNextNotify() )
+	{
+		Lock();
+		i = notify_user.begin();
+		queue_end = notify_user.empty();
+		Unlock();
+
+		while( !queue_end )
+		{
+			Lock();
+			TemplatesNotifyFunctions::notify_user_msg = *i;
+			log << log3 << "NotifyThread: sending notification to: " << i->name << ", email: " << i->email << logend;
+			Unlock();
+
+			SendMail();
+
+			Lock();
+			WaitForSignalSleep(2); // automatically unlock and lock again when returns
+			bool stop = synchro->was_stop_signal;
+			Unlock();
+
+			if( stop )
+				return;
+
+			Lock();
+			notify_user.erase(i++);
+			queue_end = (i == notify_user.end());
+			Unlock();
+		}
+	}
+}
+
+
+
+// second thread
+void NotifyThread::SendMail()
+{
+	notify_stream.Clear();
+	
+	size_t lang_id = TemplatesNotifyFunctions::notify_user_msg.lang;
+	size_t template_index = TemplatesNotifyFunctions::notify_msg.template_index;
+
+	Lock();
+	// 'patterns' object can use logger or other stuff so we use Lock() before
+
+	Ezc::Pattern * pat = patterns.Get(template_index, lang_id);
+
+	if( !pat )
+		log << log1 << "NotifyThread: I don't have a template with index: " << template_index
+			<< " and locale id: " << lang_id << logend;
+
+
+	Unlock();
+
+	if( pat )
+	{
+		generator.RecognizeSpecialChars(true);
+		generator.TrimWhite(true);
+		generator.SkipNewLine(true);
+		generator.SetFunctions(TemplatesNotifyFunctions::ezc_functions);
+		generator.SetPattern(*pat);
+
+		/*
+		 * don't use cache
+		 * 'pat' pattern is stored in 'patterns' object for all templates and by default
+		 * all functions/blocks are cached, but we are in a second thread
+		 * and cannot use such functions without locking
+		 *
+		 * IMPROVE ME
+		 * blocks are parsed to the container from the main thread
+		 * and we cannot just use it here (another thread)
+		 * so may should we have our own 'patterns' object here?
+		 *
+		 */
+		generator.CanUseCache(false);
+		generator.Generate(notify_stream);
+
+		SendMail(TemplatesNotifyFunctions::notify_user_msg.email, notify_stream.Str());
+	}
+}
+
+
+// second thread
+void NotifyThread::SendMail(const std::wstring & email, const std::wstring & message)
+{
+	nlog << log1 << PT::Date(std::time(0)) << ' ';
+	
+	if( !ValidateEmail(email) )
+	{
+		nlog << log1 << "NotifyThread: email adress: " << email << " is not correct" << logend;
+		return;
+	}
+	
+	sendmail_command = "sendmail ";
+	PT::WideToUTF8(email, sendmail_command, false);
+	FILE * sendmail = popen(sendmail_command.c_str(), "w");
+	
+	if( !sendmail )
+	{
+		nlog << log1 << "NotifyThread: can't run sendmail" << logend;	
+		return;	
+	}
+
+	SendMail(sendmail, message);
+	pclose(sendmail);
+	
+	nlog << log1 << "NotifyThread: email to: " << email << " has been sent" << logend << logsave;
+}
+
+
+// second thread
+void NotifyThread::SendMail(FILE * sendmail, const std::wstring & message)
+{
+char buf[10];
+size_t len;
+
+	for(size_t i=0 ; i<message.length() ; ++i)
+	{
+		if( message[i] == '\n' )
+		{
+			fprintf(sendmail, "\r\n");
+		}
+		else
+		{
+			len = PT::IntToUTF8(int(message[i]), buf, sizeof(buf) / sizeof(char));
+
+			for(size_t a=0 ; a<len ; ++a)
+				fputc(buf[a], sendmail);
+		}
+	}
+}
+
+
+
+} // namespace Winix
+