/********************************************************************************************
* Public members, functions and properties
********************************************************************************************/
public void ArchiveQQData()
{
string pathFile = QQDataPathFile;
QQDataSet dataSet = new QQDataSet(
n: QuantumNumberN,
l: QuantumNumberL,
colorState: ColorState,
potentialType: PotentialType,
temperature: Temperature_MeV,
debyeMass: DebyeMass_MeV,
displacementRMS: DisplacementRMS_fm,
softScale: SoftScale_MeV,
ultraSoftScale: UltraSoftScale_MeV,
boundMass: BoundMass_MeV,
energy: Energy_MeV,
gammaDamp: GammaDamp_MeV,
gammaDiss: GammaDiss_MeV,
gammaTot: GammaTot_MeV);
QQDataDoc.Write(pathFile, dataSet);
LogMessages.Clear();
LogMessages.AppendLine("Results have been saved to QQ-data file.");
LogMessages.AppendLine();
LogMessages.AppendLine();
}
public async Task <IActionResult> Delete(int id)
{
var location = GetControllerActionNames();
try
{
_logger.LogInfo(LogMessages.AttemptedToDelete(location, id));
if (id < 1)
{
_logger.LogWarn(LogMessages.BadData(location, id));
return(BadRequest());
}
var isExists = await _articleRepository.IsExists(id);
if (!isExists)
{
_logger.LogWarn(LogMessages.NotFound(location, id));
return(NotFound());
}
var article = await _articleRepository.FindById(id);
var isSuccess = await _articleRepository.Delete(article);
if (!isSuccess)
{
return(InternalError(LogMessages.DeleteFailed(location, id)));
}
_logger.LogInfo(LogMessages.Success(location, id));
return(NoContent());
}
catch (Exception e)
{
return(InternalError(LogMessages.InternalError(location, e.Message, e.InnerException)));
}
}
public async Task <IActionResult> Create([FromBody] ArticleCreateDTO articleCreateDTO)
{
var location = GetControllerActionNames();
try
{
_logger.LogInfo(LogMessages.AttemptedToCreate(location));
if (articleCreateDTO == null)
{
_logger.LogWarn(LogMessages.EmptyRequest(location));
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
_logger.LogWarn(LogMessages.IncompleteData(location));
return(BadRequest(ModelState));
}
var article = _mapper.Map <Article>(articleCreateDTO);
var isSuccess = await _articleRepository.Create(article);
if (!isSuccess)
{
return(InternalError(LogMessages.CreateFailed(location)));
}
_logger.LogInfo(LogMessages.Success(location));
_logger.LogInfo($"{article}");
return(Created("Create", new { article }));
}
catch (Exception e)
{
return(InternalError(LogMessages.InternalError(location, e.Message, e.InnerException)));
}
}
public ResponseData WriteToFile(string text)
{
var file = _db.FolderTrees.FirstOrDefault(file => file.Name == fileName)?.File;
if (file == null)
{
return(new ResponseData(StatusCode.ServerError, Messages.NoFile));
}
if ((file.Permission - 1) == _level || file.Permission == _level)
{
try {
byte[] textBytes = Encoding.UTF8.GetBytes(text);
byte[] data = new byte[file.Data.Length + textBytes.Length];
Buffer.BlockCopy(file.Data, 0, data, 0, file.Data.Length);
Buffer.BlockCopy(textBytes, 0, data, file.Data.Length, textBytes.Length);
file.Data = data;
_db.SaveChanges();
Logger.Log(LogMessages.Written(_user, fileName));
return(new ResponseData(StatusCode.Success, Messages.Written));
}
catch (Exception ex) {
Logger.LogError(LogMessages.WriteError(_user, fileName, ex));
return(new ResponseData(StatusCode.ServerError, Messages.WriteError));
}
}
else
{
return(PermissionError());
}
}
private void RunOpenCover()
{
try
{
if (!TestProjects.Any(t => t.IsSelected))
{
LogMessages.Add(LogMessage.Log("No selected projects found", LogMessage.LogType.Warning));
MessageBox.Show("Select the projects you want to run", "No projects selected", MessageBoxButton.OK, MessageBoxImage.Exclamation);
return;
}
if (ProjectType == ProjectType.DotNetCore)
{
RunDotNetCoreImplementation();
}
else
{
RunDotNetFrameworkImplementation();
}
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
LogMessages.Add(LogMessage.Log(e.Message, LogMessage.LogType.Error));
}
}
public ResponseData ChangeFile(string text)
{
if (fileName == null)
{
return(new ResponseData(StatusCode.ServerError, Messages.NoFile));
}
if (Code == _level)
{
// Check permisions
try
{
using (StreamWriter writer = new StreamWriter(Combine(Path, $"{fileName}"), false))
writer.WriteLine(text);
Logger.Log(LogMessages.Updated(_user, fileName));
return(new ResponseData(StatusCode.Success, Messages.Updated));
}
catch (Exception e) {
Logger.LogError(LogMessages.EditError(_user, fileName, e));
return(new ResponseData(StatusCode.ServerError, Messages.EditError));
}
}
else
{
return(PermissionError());
}
}
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception,
Func <TState, Exception, string> formatter)
{
if (eventId.Id == RelationalEventId.CommandExecuting.Id)
{
var message = formatter(state, exception);
var commandIndex = Math.Max(message.IndexOf("UPDATE"), message.IndexOf("DELETE"));
if (commandIndex >= 0)
{
var truncatedMessage = message.Substring(commandIndex, message.IndexOf(";", commandIndex) - commandIndex).Replace(Environment.NewLine, " ");
for (var i = 0; i < 4; i++)
{
var paramIndex = message.IndexOf($"@p{i}='");
if (paramIndex >= 0)
{
var paramValue = message.Substring(paramIndex + 5, 1);
if (paramValue == "'")
{
paramValue = "NULL";
}
truncatedMessage = truncatedMessage.Replace($"@p{i}", paramValue);
}
}
LogMessages.Add(truncatedMessage);
}
}
}
public bool IsRateLimitApplied(HttpContext httpContext)
{
string requesterIdentifier = GetUniqueRequesterIdentifier(httpContext) !;
if (this._recordStore.TryGetValue(requesterIdentifier, out Fail2BanRecord? record))
{
// Yes there is a potential race condition here in which a failure is recorded
// while the record expires. I don't care, it is not bad enough to worry about.
bool?applyRateLimiting = CheckApplyRateLimiting(record);
if (applyRateLimiting == false)
{
bool success = this._recordStore.TryRemove(requesterIdentifier, out _);
if (success)
{
LogMessages.OnRateLimitingRelaxed(this._logger, requesterIdentifier, null !);
}
}
return(applyRateLimiting == true);
}
// We didn't record, so its all good
return(false);
}
public ResponseData ChangeFile(string text)
{
var file = _db.FolderTrees.FirstOrDefault(file => file.Name == fileName)?.File;
if (file == null)
{
return(new ResponseData(StatusCode.ServerError, Messages.NoFile));
}
if (file.Permission == _level)
{
try {
file.Data = Encoding.UTF8.GetBytes(text);
_db.SaveChanges();
Logger.Log(LogMessages.Updated(_user, fileName));
return(new ResponseData(StatusCode.Success, Messages.Updated));
}
catch (Exception ex)
{
Logger.LogError(LogMessages.EditError(_user, fileName, ex));
return(new ResponseData(StatusCode.ServerError, Messages.EditError));
}
}
else
{
return(PermissionError());
}
}
/// <summary>
/// Creates a <see cref="PhysicalReplicationSlot"/> that wraps a PostgreSQL physical replication slot and
/// can be used to start physical streaming replication
/// </summary>
/// <param name="slotName">
/// The name of the slot to create. Must be a valid replication slot name
/// (see <a href="https://www.postgresql.org/docs/current/warm-standby.html#STREAMING-REPLICATION-SLOTS-MANIPULATION">Section 26.2.6.1</a>).
/// </param>
/// <param name="isTemporary">
/// <see langword="true"/> if this replication slot shall be a temporary one; otherwise
/// <see langword="false"/>. Temporary slots are not saved to disk and are automatically dropped on error or
/// when the session has finished.
/// </param>
/// <param name="reserveWal">
/// If this is set to <see langword="true"/> this physical replication slot reserves WAL immediately. Otherwise,
/// WAL is only reserved upon connection from a streaming replication client.
/// </param>
/// <param name="cancellationToken">
/// An optional token to cancel the asynchronous operation. The default value is <see cref="CancellationToken.None"/>.
/// </param>
/// <returns>A <see cref="Task{T}"/> representing a <see cref="PhysicalReplicationSlot"/> that represents the
/// newly-created replication slot.
/// </returns>
public Task <PhysicalReplicationSlot> CreateReplicationSlot(
string slotName, bool isTemporary = false, bool reserveWal = false, CancellationToken cancellationToken = default)
{
CheckDisposed();
using var _ = NoSynchronizationContextScope.Enter();
return(CreatePhysicalReplicationSlot(slotName, isTemporary, reserveWal, cancellationToken));
async Task <PhysicalReplicationSlot> CreatePhysicalReplicationSlot(string slotName, bool isTemporary, bool reserveWal, CancellationToken cancellationToken)
{
var builder = new StringBuilder("CREATE_REPLICATION_SLOT ").Append(slotName);
if (isTemporary)
{
builder.Append(" TEMPORARY");
}
builder.Append(" PHYSICAL");
if (reserveWal)
{
builder.Append(" RESERVE_WAL");
}
var command = builder.ToString();
LogMessages.CreatingReplicationSlot(Logger, slotName, command, Connector.Id);
var slotOptions = await CreateReplicationSlot(builder.ToString(), cancellationToken);
return(new PhysicalReplicationSlot(slotOptions.SlotName));
}
}
public DriverDaemon()
{
Log.Output += (sender, message) =>
{
LogMessages.Add(message);
Console.WriteLine(Log.GetStringFormat(message));
Message?.Invoke(sender, message);
};
Driver.TabletsChanged += (sender, e) => TabletsChanged?.Invoke(sender, e);
HidSharpDeviceRootHub.Current.DevicesChanged += async(sender, args) =>
{
if (args.Additions.Any())
{
await DetectTablets();
await SetSettings(Settings);
}
};
foreach (var driverInfo in DriverInfo.GetDriverInfos())
{
Log.Write("Detect", $"Another tablet driver found: {driverInfo.Name}", LogLevel.Warning);
if (driverInfo.IsBlockingDriver)
{
Log.Write("Detect", $"Detection for {driverInfo.Name} tablets might be impaired", LogLevel.Warning);
}
else if (driverInfo.IsSendingInput)
{
Log.Write("Detect", $"Detected input coming from {driverInfo.Name} driver", LogLevel.Error);
}
}
LoadUserSettings();
}
private async Task SendMessage()
{
CanSend = false;
// Capture the values locally before use
var msg = Message;
var proxy = _hubProxy;
if (proxy != null && !string.IsNullOrWhiteSpace(msg))
{
try
{
await proxy.Invoke("Send", msg);
Message = string.Empty;
}
catch (Exception ex)
{
LogMessages.Add(ex.ToString());
Messages.Add(new Message("Error sending message, see log for details"));
}
}
CanSend = true;
}
internal /* internal for test */ void ValidateResponseFromBroker(MsalTokenResponse msalTokenResponse)
{
_logger.Info(LogMessages.CheckMsalTokenResponseReturnedFromBroker);
if (!string.IsNullOrEmpty(msalTokenResponse.AccessToken))
{
_logger.Info(
"Success. Broker response contains an access token");
return;
}
if (msalTokenResponse.Error != null)
{
_logger.Info(
LogMessages.ErrorReturnedInBrokerResponse(msalTokenResponse.Error));
throw MsalServiceExceptionFactory.FromBrokerResponse(msalTokenResponse.Error,
MsalErrorMessage.BrokerResponseError + msalTokenResponse.ErrorDescription,
string.IsNullOrEmpty(msalTokenResponse.SubError)?
MsalError.UnknownBrokerError : msalTokenResponse.SubError,
msalTokenResponse.CorrelationId,
msalTokenResponse.HttpResponse);
}
_logger.Info(LogMessages.UnknownErrorReturnedInBrokerResponse);
throw new MsalServiceException(MsalError.BrokerResponseReturnedError, MsalErrorMessage.BrokerResponseReturnedError, null);
}
public async Task <IActionResult> Login([FromBody] UserLoginDTO userLoginDTO)
{
var location = GetControllerActionNames();
try
{
var username = userLoginDTO.Username;
var password = userLoginDTO.Password;
_logger.LogInfo(LogMessages.AttemptedToCreate(location));
var result = await _signInManager.PasswordSignInAsync(username, password, false, false);
if (result.Succeeded)
{
_logger.LogInfo(LogMessages.Success(location));
var user = await _userManager.FindByNameAsync(username);
var tokenString = await GenerateJSONWebToken(user);
return(Ok(new { token = tokenString }));
}
_logger.LogWarn(LogMessages.Unathorized(location));
return(Unauthorized(userLoginDTO));
}
catch (Exception e)
{
return(InternalError(LogMessages.InternalError(location, e.Message, e.InnerException)));
}
}
public void SendStatusMessage(LogMessages mgsStatus, string msg)
{
lock (syncObject)
{
switch (mgsStatus)
{
case LogMessages.Error:
{
_streamWriter.WriteLine($"{mgsStatus.ToString()}:{_stringCombiner.GetCombinedString(msg)}");
_streamWriter.Close();
Task.Delay(50);
_streamWriter = File.AppendText(_path);
break;
}
case LogMessages.Exceptions:
case LogMessages.Warning:
{
_streamWriter.WriteLine($"{mgsStatus.ToString()}:{_stringCombiner.GetCombinedString(msg)}");
break;
}
case LogMessages.Update:
{
_streamWriter.Close();
Task.Delay(50);
_streamWriter = File.AppendText(_path);
break;
}
}
}
}
public async Task <AuthenticationResult> ExecuteAsync(
AcquireTokenCommonParameters commonParameters,
AcquireTokenByRefreshTokenParameters refreshTokenParameters,
CancellationToken cancellationToken)
{
var requestContext = CreateRequestContextAndLogVersionInfo(commonParameters.CorrelationId, cancellationToken);
if (commonParameters.Scopes == null || !commonParameters.Scopes.Any())
{
commonParameters.Scopes = new SortedSet <string>
{
_clientApplicationBase.AppConfig.ClientId + "/.default"
};
requestContext.Logger.Info(LogMessages.NoScopesProvidedForRefreshTokenRequest);
}
var requestParameters = _clientApplicationBase.CreateRequestParameters(
commonParameters,
requestContext,
_clientApplicationBase.UserTokenCacheInternal);
requestContext.Logger.Info(LogMessages.UsingXScopesForRefreshTokenRequest(commonParameters.Scopes.Count()));
requestParameters.SendX5C = refreshTokenParameters.SendX5C;
var handler = new ByRefreshTokenRequest(ServiceBundle, requestParameters, refreshTokenParameters);
return(await handler.RunAsync(CancellationToken.None).ConfigureAwait(false));
}
protected override void DoUpdate(bool full)
{
if (full)
{
filterLogic.RebuildLeaves();
}
Execute.OnUIThread(() =>
{
var prevSelected = SelectedLogMessage;
CollectionViewSource.View?.Refresh();
if (CollectionViewSource.View != null && prevSelected != null)
{
if (filterLogic.IsFiltered(prevSelected))
{
var index = LogMessages.IndexOf(prevSelected);
if (index > 0)
{
foreach (var closestPrevMessage in LogMessages.Take(index).Reverse())
{
if (!filterLogic.IsFiltered(closestPrevMessage))
{
SelectedLogMessage = closestPrevMessage;
break;
}
}
}
}
}
NotifyOfPropertyChange(nameof(ShownLogMessages));
});
ScrollIntoSelected();
}
public ResponseData WriteToFile(string text)
{
if (fileName == null)
{
return(new ResponseData(StatusCode.ServerError, Messages.NoFile));
}
// Check permisions
if ((Code - 1) == _level || Code == _level)
{
try{
using (StreamWriter writer = new StreamWriter(Combine(Path, $"{fileName}"), true))
writer.WriteLine(text);
Logger.Log(LogMessages.Written(_user, fileName));
return(new ResponseData(StatusCode.Success, Messages.Written));
}
catch (Exception e) {
Logger.LogError(LogMessages.WriteError(_user, fileName, e));
return(new ResponseData(StatusCode.ServerError, Messages.WriteError));
}
}
else
{
return(PermissionError());
}
}
public ResponseData ReadFile()
{
var file = _db.FolderTrees.FirstOrDefault(file => file.Name == fileName)?.File;
if (file == null)
{
return(new ResponseData(StatusCode.ServerError, Messages.NoFile));
}
if ((file.Permission + 1) == _level || file.Permission == _level)
{
try {
Logger.Log(LogMessages.FileRead(_user, fileName));
return(new ResponseData(StatusCode.Success, Encoding.UTF8.GetString(file.Data)));
}
catch (Exception ex) {
Logger.LogError(LogMessages.ReadError(_user, fileName, ex));
return(new ResponseData(StatusCode.ServerError, Messages.ReadError));
}
}
else
{
return(PermissionError());
}
}
public ResponseData ReadFile()
{
if (fileName == null)
{
return(new ResponseData(StatusCode.ServerError, Messages.NoFile));
}
// Check permisions
if ((Code + 1) == _level || Code == _level)
{
try{
var texts = File.ReadAllText(Combine(Path, $"{fileName}"));
Logger.Log(LogMessages.FileRead(_user, fileName));
return(new ResponseData(StatusCode.Success, $"{texts}"));
}
catch (Exception e) {
Logger.LogError(LogMessages.ReadError(_user, fileName, e));
return(new ResponseData(StatusCode.ServerError, Messages.ReadError));
}
}
else
{
return(PermissionError());
}
}
private void DisplayBlacklistMethod()
{
// Get the list and provide feedback if it is null.
List <ulong> list = LogMessages.Blacklist();
if (list == null)
{
Console.WriteLine("Blacklist is empty or does not exist.");
return;
}
// Cycles through each channel and finds valid info to display.
string msg = "";
foreach (uint id in list)
{
IChannel currentChannel = Global.GetSocketChannelWithId(id);
if (currentChannel != null)
{
msg += $"{id} - {currentChannel.Name}\n";
}
}
if (msg.Equals(string.Empty))
{
msg = "The blacklist only has invalid entries.";
}
Console.WriteLine(msg);
}
public async Task <MessageResponse> SendMessageAsync(string message, string lastContext = "")
{
var storeCredentials = await StoreCredentialsCache.GetStoreAsync(uow, storeId);
if (storeCredentials == null)
{
var logRep = uow.GetRepository <LogRepository>();
await logRep.RecLog(
NopLogLevel.Error,
LogMessages.Fmt(LogMessages.STORE_CREDENTIALS_NOT_FOUND, storeId)
);
return(null);
}
var conversation = new ConversationService(
storeCredentials.Username,
storeCredentials.Password,
ConversationService.CONVERSATION_VERSION_DATE_2017_05_26
);
var response = conversation.Message(storeCredentials.WorkspaceId, new MessageRequest
{
Input = new { text = message },
Context = string.IsNullOrEmpty(lastContext) ? null : JsonConvert.DeserializeObject(lastContext)
});
response.Context = JsonConvert.SerializeObject(response.Context);
return(response);
}
public DriverDaemon()
{
Log.Output += (sender, message) =>
{
LogMessages.Add(message);
Console.WriteLine(Log.GetStringFormat(message));
Message?.Invoke(sender, message);
};
Driver.Reading += async(_, isReading) => TabletChanged?.Invoke(this, isReading ? await GetTablet() : null);
LoadUserSettings();
HidSharp.DeviceList.Local.Changed += async(sender, e) =>
{
var newDevices = from device in DeviceList.Local.GetHidDevices()
where !CurrentDevices.Any(d => d == device)
select device;
if (newDevices.Count() > 0)
{
if (await GetTablet() == null)
{
await DetectTablets();
}
}
CurrentDevices = DeviceList.Local.GetHidDevices();
};
}
public void PostStatusMessage(LogMessages logMessages, string msg)
{
foreach (var logger in this)
{
logger.Value.SendStatusMessage(logMessages, msg);
}
}
public DriverDaemon()
{
Log.Output += (sender, message) =>
{
LogMessages.Add(message);
Console.WriteLine(Log.GetStringFormat(message));
Message?.Invoke(sender, message);
};
Driver.TabletChanged += (sender, tablet) =>
{
TabletChanged?.Invoke(sender, tablet);
if (debugging)
{
if (Driver.TabletReader != null)
{
Driver.TabletReader.RawClone = true;
Driver.TabletReader.RawReport += DebugReportHandler;
}
if (Driver.AuxReader != null)
{
Driver.AuxReader.RawClone = true;
Driver.AuxReader.RawReport += DebugReportHandler;
}
}
};
Driver.DevicesChanged += async(sender, args) =>
{
if (await GetTablet() == null && args.Additions.Count() > 0)
{
await DetectTablets();
}
};
LoadUserSettings();
}
internal /* internal for test */ void ValidateResponseFromBroker(MsalTokenResponse msalTokenResponse)
{
_logger.Info(LogMessages.CheckMsalTokenResponseReturnedFromBroker);
if (msalTokenResponse.AccessToken != null)
{
_logger.Info("Success. Response contains an access token. ");
return;
}
if (msalTokenResponse.Error != null)
{
_logger.Info(
LogMessages.ErrorReturnedInBrokerResponse(msalTokenResponse.Error));
if (msalTokenResponse.Error == BrokerResponseConst.AndroidNoTokenFound ||
msalTokenResponse.Error == BrokerResponseConst.AndroidNoAccountFound ||
msalTokenResponse.Error == BrokerResponseConst.AndroidInvalidRefreshToken)
{
throw new MsalUiRequiredException(msalTokenResponse.Error, msalTokenResponse.ErrorDescription);
}
throw MsalServiceExceptionFactory.FromBrokerResponse(msalTokenResponse,
MsalErrorMessage.BrokerResponseError + msalTokenResponse.ErrorDescription);
}
_logger.Info(LogMessages.UnknownErrorReturnedInBrokerResponse);
throw new MsalServiceException(MsalError.BrokerResponseReturnedError, MsalErrorMessage.BrokerResponseReturnedError, null);
}
public ResponseData SingIn(string login, string password)
{
var user = _db.Users.Include(obj => obj.Passwords).FirstOrDefault(u => u.Name == login);
if (user == null)
{
// No user in data
Logger.LogAll(LogMessages.NotFound(login));
return(new ResponseData(StatusCode.BadData, Messages.NotFound(login)));
}
var currentPassword = user.Passwords.FirstOrDefault(p => !p.IsUsed);
if (currentPassword == null)
{
#region User's spent all passwords
switch (login)
{
case "Master":
Logger.LogAll(LogMessages.MasterBlocked);
return(new ResponseData(StatusCode.Blocked, Messages.MasterBlocked));
case "Senpai":
Logger.LogAll(LogMessages.SempaiBlocked);
return(new ResponseData(StatusCode.Blocked, Messages.SempaiBlocked));
case "Kouhai":
Logger.LogAll(LogMessages.KouhaiBlocked);
return(new ResponseData(StatusCode.Blocked, Messages.KouhaiBlocked));
default:
Logger.LogAll(LogMessages.Blocked(login));
return(new ResponseData(StatusCode.Blocked, Messages.Blocked));
}
#endregion
}
currentPassword.IsUsed = true;
_db.SaveChanges();
if (CheckPassword(password, currentPassword.Password))
{
return(new ResponseData());
}
else
{
if (user.Passwords.Count(p => !p.IsUsed) == 0)
{
// User's spent last password
Logger.LogAll(LogMessages.Blocked(login));
return(new ResponseData(StatusCode.Blocked, Messages.Blocked));
}
else
{
// User's written wrong password
Logger.LogAll(LogMessages.WrongPassword(login));
return(new ResponseData(StatusCode.BadData, Messages.TryAgain));
}
}
}
public ResponseData SingIn(string login, string password)
{
if (passwords.ContainsKey(login))
{
if (passwords[login]?.Count == 0)
{
#region User's spent all passwords
switch (login)
{
case "Master":
Logger.LogAll(LogMessages.MasterBlocked);
return(new ResponseData(StatusCode.Blocked, Messages.MasterBlocked));
case "Senpai":
Logger.LogAll(LogMessages.SempaiBlocked);
return(new ResponseData(StatusCode.Blocked, Messages.SempaiBlocked));
case "Kouhai":
Logger.LogAll(LogMessages.KouhaiBlocked);
return(new ResponseData(StatusCode.Blocked, Messages.KouhaiBlocked));
default:
Logger.LogAll(LogMessages.Blocked(login));
return(new ResponseData(StatusCode.Blocked, Messages.Blocked));
}
#endregion
}
else
{
if (passwords[login][0] == password)
{
passwords[login].RemoveAt(0);
return(new ResponseData());
}
else
{
passwords[login].RemoveAt(0);
if (passwords[login].Count == 1)
{
// User's spent last password
Logger.LogAll(LogMessages.Blocked(login));
return(new ResponseData(StatusCode.Blocked, Messages.Blocked));
}
else
{
// User's written wrong password
Logger.LogAll(LogMessages.WrongPassword(login));
return(new ResponseData(StatusCode.BadData, Messages.TryAgain));
}
}
}
}
else
{
// No user in data
Logger.LogAll(LogMessages.NotFound(login));
return(new ResponseData(StatusCode.BadData, Messages.NotFound(login)));
}
}
public void AddLog(LogMessage log)
{
LogMessages.Add(log);
var strSize = (int)_font.MeasureString(log.Message).X + 20;
Width = strSize > Width ? strSize : Width;
}
public async void log(Level level, string message)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
LogMessages.Add(message);
});
Debug.WriteLine(message);
}
public static int ProcessResponse(LogMessages logMessages, string servicesUrl, string dbuser, string dbschema, string dbpassword, string dbname, string dbserver, bool debug, string srid, string token)
{
if (debug) Console.WriteLine("Retrieved " + logMessages.logMessages.Count + " records");
SqlConnection myConnection;
if (dbuser != "OSA")
{
myConnection = new SqlConnection("Server=" + dbserver + "; Database=" + dbname + "; User ID=" + dbuser + "; Password="******"Server=" + dbserver + "; Database=" + dbname + ";Integrated Security=true");
}
try
{
myConnection.Open();
}
catch (Exception e)
{
if (debug) Console.WriteLine(e.ToString());
Environment.Exit(1);
}
int messageCount;
Dictionary<string,int> serviceWkids = new Dictionary<string, int>();
for(messageCount = 0; messageCount < logMessages.logMessages.Count; messageCount++)
{
LogMessage currentLogMessage = logMessages.logMessages[messageCount];
string scale = "NULL";
string size_x = "NULL";
string size_y = "NULL";
string minx = "NULL";
string miny = "NULL";
string maxx = "NULL";
string maxy = "NULL";
string Shape = "NULL";
DateTime dttime = UnixTimeStampToDateTime2(currentLogMessage.time);
if (currentLogMessage.message.Length > 4000) currentLogMessage.message = currentLogMessage.message.Substring(0, 4000);
if (currentLogMessage.methodName.Length > 50) currentLogMessage.methodName = currentLogMessage.methodName.Substring(0, 50);
currentLogMessage.message = currentLogMessage.message.Replace("'", "''");
if (currentLogMessage.message.Contains("Extent:"))
{
if (!serviceWkids.ContainsKey(currentLogMessage.source))
{
MapServer serviceInfo = GetServiceInfo(servicesUrl,
currentLogMessage.source, token);
int wkid = serviceInfo.fullExtent.spatialReference.wkid;
serviceWkids.Add(currentLogMessage.source, wkid);
}
string[] vals = currentLogMessage.message.Split(';');
string[] tmp_extent = vals[0].Split(':');
string[] tmp_size = vals[1].Split(':');
string[] tmp_scale = vals[2].Split(':');
string[] tmp_sizes = tmp_size[1].Split(',');
string[] tmp_extents = tmp_extent[1].Split(',');
scale = tmp_scale[1];
size_x = tmp_sizes[0];
size_y = tmp_sizes[1];
minx = tmp_extents[0];
miny = tmp_extents[1];
maxx = tmp_extents[2];
maxy = tmp_extents[3];
Shape = "'POLYGON((" + minx + " " + miny + "," + minx + " " + maxy + "," + maxx + " " + maxy + "," + maxx + " " + miny + "," + minx + " " + miny + "))'";
Shape = "geometry::STPolyFromText(" + Shape + ", " + serviceWkids[currentLogMessage.source] + ")";
}
string sql = "";
sql = sql + "INSERT INTO [" + dbname + "].["+ dbschema +"].[RawLogs]"; //TODO: handle the user schema for the table
sql = sql + "([type]";
sql = sql + ",[message]";
sql = sql + ",[time]";
sql = sql + ",[source]";
sql = sql + ",[machine]";
sql = sql + ",[user]";
sql = sql + ",[code]";
sql = sql + ",[elapsed]";
sql = sql + ",[process]";
sql = sql + ",[thread]";
sql = sql + ",[methodname]";
sql = sql + ",[mapsize_x]";
sql = sql + ",[mapsize_y]";
sql = sql + ",[mapscale]";
sql = sql + ",[mapextent_minx]";
sql = sql + ",[mapextent_miny]";
sql = sql + ",[mapextent_maxx]";
sql = sql + ",[mapextent_maxy]";
sql = sql + ",[Shape])";
sql = sql + "VALUES";
sql = sql + "(";
sql = sql + "'" + currentLogMessage.type + "',";
sql = sql + "'" + currentLogMessage.message + "',";
sql = sql + "'" + dttime.ToString("yyyy-MM-ddTHH:mm:ss.fff") + "',";
sql = sql + "'" + currentLogMessage.source + "',";
sql = sql + "'" + currentLogMessage.machine + "',";
sql = sql + "'" + currentLogMessage.user + "',";
sql = sql + currentLogMessage.code + ",";
sql = sql + "'" + currentLogMessage.elapsed + "',";
sql = sql + "'" + currentLogMessage.process + "',";
sql = sql + "'" + currentLogMessage.thread + "',";
sql = sql + "'" + currentLogMessage.methodName + "',";
sql = sql + "" + size_x + ",";
sql = sql + "" + size_y + ",";
sql = sql + "" + scale + ",";
sql = sql + "" + minx + ",";
sql = sql + "" + miny + ",";
sql = sql + "" + maxx + ",";
sql = sql + "" + maxy + ",";
sql = sql + Shape;
sql = sql + ")";
SqlCommand myUserCommand = new SqlCommand(sql, myConnection);
myUserCommand.ExecuteNonQuery();
if (debug == true) Console.WriteLine("Inserted record " + messageCount.ToString());
}
myConnection.Close();
return messageCount;
}