/// <summary>
/// Log 기록
/// </summary>
/// <param name="log">Modbus Log</param>
public void Log(ModbusLog log)
{
if ((CategoryFilter & log.Category) != 0)
{
Logged?.Invoke(this, new ModbusLoggedEventArgs(log));
}
}
public void Warn(string message)
{
var m = $"\nWARN:\n{message}";
Log += m;
Logged?.Invoke(this, m);
}
public EmployeePage()
{
InitializeComponent();
//Busca a pessoa que logou no sistema
socorrista = Logged.GetLogged();
LabelEmployee.Text = "QRA: " + socorrista.QRA.ToString();
}
public void Info(string message)
{
var m = $"\n{message}";
Log += m;
Logged?.Invoke(this, m);
}
public void Error(string message)
{
var m = $"\nERROR:\n{message}";
Log += m;
Logged?.Invoke(this, m);
}
public void WriteLine(params string[] text)
{
foreach (var line in text)
{
Logged?.Invoke(this, new FormConsoleEventArgs(line + Environment.NewLine));
}
}
public void Echo(string message)
{
var m = $"\nECHO:\n{message}";
Log += m;
Logged?.Invoke(this, m);
}
public void notify(params object[] arguments)
{
string messageType = (string)arguments[0];
LevinSearchTask task = (LevinSearchTask)arguments[1];
string taskName = (string)arguments[2];
string message = "";
if (messageType == "success")
{
ulong iteration = task.levinSearchContext.searchIterations;
message = string.Format("< Task:{0} (no meta)> success, {0} required< #iterations={1}, cputime=?, realtime=?>", taskName, iteration);
}
else if (messageType == "increaseProgramsize")
{
message = string.Format("<Task:{0} (no meta)> increaseProgramsize, {1}", taskName, task.levinSearchContext.numberOfInstructions);
}
else if (messageType == "failed")
{
message = string.Format("<Task:{0} (no meta)> failed, {1}", taskName, "?");
}
Logged logged = new Logged();
logged.message = message;
logged.notifyConsole = Logged.EnumNotifyConsole.YES;
logged.origin = new string[] { "search", "ALS" };
logged.serverity = Logged.EnumServerity.INFO;
log.write(logged);
}
private static void DevLog(string message, string channel, LogType logType)
{
if (!IsEnable)
{
return;
}
foreach (var filter in _filters)
{
if (!filter.IsNeedShow(channel, logType))
{
return;
}
}
var resultMessage = string.Format("<b>[{0}][{1:HH:mm:ss:fff}]</b> {2}", channel, DateTime.Now, message);
if (!string.IsNullOrEmpty(Header))
{
resultMessage = string.Format("{0}: {1}", Header, resultMessage);
}
if (_logColorSetter != null)
{
var color = _logColorSetter.GetColor(channel);
var colorHexCode = ToRGBHex(color);
resultMessage = string.Format("<color=\"{0}\">{1}</color>", colorHexCode, resultMessage);
}
if (IsNeedLogInConsole)
{
LogInConsole(resultMessage, logType);
}
Logged.SafeRaise(resultMessage, logType);
}
private void TryToAuth(object parameter)
{
bool result = CheckConnection("http://vk.com/");
if (result == false)
{
CustomMessageBox.Show("Connection error", "You are currently offline");
return;
}
var passbox = parameter as PasswordBox;
if (Login == null || passbox.Password == null)
{
CustomMessageBox.Show("Login error", "One of field is empty");
return;
}
try
{
api.Authorize(new ApiAuthParams // trying to auth
{
ApplicationId = 5865343,
Login = Login,
Password = passbox.Password,
Settings = Settings.All,
});
api.Stats.TrackVisitor();
Logged?.Invoke();
api.Account.SetOffline();
Opened = Visibility.Collapsed;
}
catch
{
CustomMessageBox.Show("Login error", "Invalid login or password"); //got exeption => notifying users
}
}
public Logged postLog(string post, int i)
{
Logged result3;
if (i < this.servers.Length)
{
byte[] rv = System.Text.Encoding.UTF8.GetBytes(post);
System.Uri target = new System.Uri(this.servers[i] + "users/login");
System.Net.WebRequest req = System.Net.WebRequest.Create(target);
req.Timeout = this.timeout;
req.Method = "POST";
req.PreAuthenticate = true;
req.ContentType = "application/x-www-form-urlencoded";
req.ContentLength = (long)rv.Length;
System.IO.Stream os = req.GetRequestStream();
os.Write(rv, 0, rv.Length);
os.Close();
try
{
System.Net.HttpWebResponse response = (System.Net.HttpWebResponse)req.GetResponse();
string a = "";
if (response == null)
{
i++;
result3 = this.postLog(post, i);
return(result3);
}
System.IO.Stream receiveStream = response.GetResponseStream();
System.Text.Encoding encode = System.Text.Encoding.GetEncoding("utf-8");
System.IO.StreamReader readStream = new System.IO.StreamReader(receiveStream, encode);
char[] read = new char[256];
for (int count = readStream.Read(read, 0, 256); count > 0; count = readStream.Read(read, 0, 256))
{
string str = new string(read, 0, count);
a += str;
}
if (a != "0")
{
Logged result = new Logged();
result.getLoggetFromJson(a);
result3 = result;
return(result3);
}
response.Close();
result3 = new Logged();
return(result3);
}
catch (System.Net.WebException)
{
i++;
result3 = this.postLog(post, i);
return(result3);
}
}
Logged result2 = new Logged();
result3 = result2;
return(result3);
}
public void Write(Level level, string tag, string content)
{
if (Level.HasFlag(level))
{
Logged?.Invoke(level, tag, content);
Out?.WriteLine($"[{DateTime.Now.ToString(DateTimeFormat)}][{level}][{tag}]: {content}");
}
}
private void LogChannelClosed(object sender, EventArgs args)
{
Logged?.Invoke(sender, new Log
{
Level = SmartLife.Log.LevelEnum.Info,
Message = $"ZWaveController ChannelClosed {args}"
});
}
public void Log(CultureStringsBase message, MessageType messageType = MessageType.Default, IEnumerable <Object> formatList = null,
ConsoleColor?messageColor = null, Int32 priority = 0, MessageAdditions messageAdditions = MessageAdditions.None)
{
LogMessage logMessage = new LogMessage(message, messageType, formatList, messageColor, priority, messageAdditions);
Messages.Add(logMessage);
Logged?.Invoke(logMessage);
}
public void write(Logged logged)
{
if (logged.notifyConsole != Logged.EnumNotifyConsole.YES)
{
return;
}
logDelegate(logged.message);
}
private void LogError(object sender, ErrorEventArgs args)
{
Logged?.Invoke(sender, new Log
{
Level = SmartLife.Log.LevelEnum.Error,
Exception = args.Error,
Message = $"ZWaveController Error {args.Error.Message}"
});
}
private void ForwardLogEntry(object sender, LoggedEventArgs loggedEventArgs)
{
if (!IsEnabled)
{
return;
}
Logged?.Invoke(this, loggedEventArgs);
}
public void Log(LogLevel level, string message)
{
Log log = new Log(level, message);
if ((int)level >= (int)Level)
{
Logged?.Invoke(log);
}
}
public void AddEntry(Entry entry)
{
addEntrySafe(entry);
// event is raised here, since if it was called inside lock, it could result in deadlock
if (RaiseEvents)
{
Logged?.Invoke(entry);
}
}
public void LogLine(string str)
{
if (Logging)
{
var line = str + "\n";
logStringBuilder.Append(line);
LogBuffers.ForEach(b => b.Append(line));
Logged?.Invoke(line);
}
}
public static void Log(LogLevel level, string text)
{
string formattedText = $"[{DateTime.Now}] <{level}> {text}";
if (CanLogToFile)
{
File.AppendAllText(FileName, formattedText + "\n");
}
Logged?.Invoke(level, text, formattedText);
}
private void Log(LogEntrySeverity severity, string message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var entry = new LogEntry(severity, DateTime.Now, message);
Logged?.Invoke(this, new LoggedEventArgs(entry));
}
//Essa classe contém a lógica para realizar o login do usuário no sistema
public async static Task CheckLoginAndPassword(string Qra, string Password)
{
//Essa função faz a correspondência dos dados de QRA e senha com o banco de dados para validar a entrada do usuário
//Os dados de QRA e senha foram erroneamente setados como int no banco de dados de teste
//Um banco de dados definivo será construído com QRA e senha com o tipo varchar
int qra = int.Parse(Qra);
int password = int.Parse(Password);
//Realiza uma Querry utilizando LINQ para buscar o usuário correspondente no banco de dados através de uma aplicação Web que conecta ao banco de dados
try
{
Pessoa user = (await App.client.GetTable <Pessoa>().Where(u => u.QRA == qra).ToListAsync()).FirstOrDefault();
//Se houve correspondência
if (user != null)
{
//Verifica se a senha corresponde à senha designada ao usuário no banco de dados
if (user.SENHA == password)
{
//Se a senha for correta, salva no programa qual usuário está loggado e salva as credenciais para o próximo login
Logged.SetLogged(user);
KeepLoginAndPassword.UserQRA = user.QRA.ToString();
KeepLoginAndPassword.UserPassword = user.SENHA.ToString();
//Verifica a função do usuário para ser encaminhado à página correta
if (user.FUNCAO == "Adm")
{
await Application.Current.MainPage.Navigation.PushAsync(new ManagerPage());
}
else
{
await Application.Current.MainPage.Navigation.PushAsync(new EmployeePage());
}
}
else
{
//Se o usuário for correto, mas a senha não tiver correspondência:
await Application.Current.MainPage.DisplayAlert("Erro", "Senha inválida", "OK");
}
}
else
{
//Se o usuário digitado não for encontrado:
await Application.Current.MainPage.DisplayAlert("Erro", "Usuário não encontrado", "OK");
}
}
catch (Exception e)
{
await Application.Current.MainPage.DisplayAlert("Erro", e.Message, "OK");
}
}
public void Log(object sender, LogEventArgs e)
{
if (sender == null)
{
throw new ArgumentNullException(nameof(sender));
}
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
if (e.Severity < minLogLevel)
{
return;
}
lock (_lock)
{
var oldColor = Console.ForegroundColor;
Console.ForegroundColor = GetSeverityColor(e.Severity);
Console.WriteLine(e);
Console.ForegroundColor = oldColor;
}
var handlers = Logged?.GetInvocationList();
if (handlers == null)
{
return;
}
for (var i = 0; i < handlers.Length; i++)
{
var handler = handlers[i] as EventHandler <LogEventArgs>;
try
{
handler(sender, e);
}
catch (Exception ex)
{
lock (_lock)
{
var oldColor = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"An exception occurred in one of the logging handlers.\n{ex}");
Console.ForegroundColor = oldColor;
}
}
}
}
public HttpServerConnection Connect()
{
ServerConnection = IomFactory.CreateHttpServerConnection(
Config[0].Value, Config[1].Value, Config[2].Value, Config[3].Value
);
ServerConnection.Timeout = 100000;
ServerConnection.ReadWriteTimeout = 100000;
Logged?.Invoke(this, new LogEventArgs {
Message = $"Connected to ARAS with following parameters\r\nServer: {Config[0].Value}\r\nDatabase: {Config[1].Value}\r\nUser: {Config[2].Value}\r\nPass: ", LogEntryType = EventLogEntryType.Information
});
return(ServerConnection);
}
public bool CheckLogin(string username, string password)
{
Logged log = new Logged();
var LogObj = log.UserList.Find(q => q.Username == username);
if (LogObj != null)
{
if (LogObj.Password == password)
{
return(true);
}
}
return(false);
}
// for experimentation
public static void debug <Type>(ILogger log, IEnumerable <Type> list)
{
string message = "";
foreach (Type iValue in list)
{
message += string.Format("{0} ", iValue);
}
Logged logged = new Logged();
logged.notifyConsole = Logged.EnumNotifyConsole.YES;
logged.message = message;
logged.origin = new string[] { "search", "ALS", "debug" };
logged.serverity = Logged.EnumServerity.INFO;
log.write(logged);
}
void log(string origin, string message)
{
Logged logged = new Logged();
logged.notifyConsole = Logged.EnumNotifyConsole.YES;
logged.message = string.Format("t={0,20:###.0000_0000}, t.expectedUtilityMaximization={1,20:###.0000_0000}: {2}",
systemTime.Elapsed.TotalSeconds,
utilityAndSearchCpuTime.Elapsed.TotalSeconds,
message
);
logged.origin = new string[] { origin };
logged.serverity = Logged.EnumServerity.INFO;
logger.write(logged);
}
public void CheckLogin()
{
if (!String.IsNullOrEmpty(Properties.Settings.Default.AppInfo))
{
app = JsonConvert.DeserializeObject <AppRegistration>(Properties.Settings.Default.AppInfo);
client = new AuthenticationClient(app);
if (!String.IsNullOrEmpty(Properties.Settings.Default.AuthToken))
{
auth = JsonConvert.DeserializeObject <Auth>(Properties.Settings.Default.AuthToken);
Logged?.Invoke(this, new LoggedEventArgs(app, auth));
}
else
{
OpenLogin();
}
}
}
private async void browser_Navigating(object sender, NavigatingCancelEventArgs e)
{
var uri = e.Uri.AbsoluteUri;
var m = authRegex.Match(uri);
if (m.Success)
{
var code = m.Groups[1].Value;
auth = await client.ConnectWithCode(code);
Properties.Settings.Default.AuthToken = JsonConvert.SerializeObject(auth);
Properties.Settings.Default.Save();
Logged?.Invoke(this, new LoggedEventArgs(app, auth));
}
}
