public ActionResult Login(LoginPageModel model) //TODO: Move all of this to a UserService class
{
if (model is null)
{
throw new ArgumentNullException(nameof(model));
}
//We want to wait a specified amount of time for the response regardless of the results, to avoid
//Exposing any information to the client
StaticLogger.Log($"{model.Login}: Login attempt", StaticLogger.LoggingLevel.Call);
DateTime startLogin = DateTime.Now;
void WaitForRedirect()
{
const double LoginTime = 3000;
double toWait = LoginTime - (DateTime.Now - startLogin).TotalMilliseconds;
StaticLogger.Log($"{model.Login}: Waiting for {toWait}", StaticLogger.LoggingLevel.Call);
if (toWait > 0)
{
System.Threading.Thread.Sleep((int)toWait);
}
}
StaticLogger.Log($"{model.Login}: Calling user service...", StaticLogger.LoggingLevel.Call);
User?user = this.UserService.Login(model.Login, model.Password);
if (user != null)
{
StaticLogger.Log($"{model.Login}: User not null", StaticLogger.LoggingLevel.Call);
if (this.ConfigurationService.GetBool(ConfigurationNames.REQUIRE_EMAIL_VALIDATION))
{
if (!this.EmailValidationRepository.IsValidated(user))
{
return(this.RedirectToAction(nameof(EmailValidationRequired), new { Id = user.Guid.ToString(), area = "" }));
}
}
if (!string.IsNullOrWhiteSpace(model.ReturnUrl) && model.ReturnUrl != this.Request.Path.Value)
{
WaitForRedirect();
StaticLogger.Log($"{model.Login}: Returning to {model.ReturnUrl}", StaticLogger.LoggingLevel.Call);
return(this.Redirect(model.ReturnUrl));
}
else
{
WaitForRedirect();
StaticLogger.Log($"{model.Login}: Returning Home", StaticLogger.LoggingLevel.Call);
return(this.Redirect("/Home/Index"));
}
}
else
{
StaticLogger.Log($"{model.Login}: User is null", StaticLogger.LoggingLevel.Call);
this.ModelState.AddModelError(string.Empty, "Invalid Login or Password" + System.Environment.NewLine);
WaitForRedirect();
return(this.View(model));
}
}
/// <summary>
/// Searches All currently loaded assemblies for types with the IMessageHandler interface, and
/// subscribes all methods beneath them
/// </summary>
public static void SubscribeAll()
{
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
{
if (SubscribedAssemblies.Contains(a))
{
continue;
}
else
{
SubscribedAssemblies.Add(a);
}
try
{
foreach (Type t in a.GetTypes())
{
if (typeof(IMessageHandler).IsAssignableFrom(t))
{
MessageBus.Subscribe(t);
}
}
}
catch (Exception ex)
{
StaticLogger.Log(ex.Message, StaticLogger.LoggingLevel.Call);
StaticLogger.Log(ex.StackTrace, StaticLogger.LoggingLevel.Call);
}
}
}
protected override void OnStart(string[] args)
{
Fwk.Logging.Event ev = null;
//ConfigurationsHelper.HostApplicationName = string.Concat("Fwk remoting ", this.ServiceName);
try
{
RemotingConfiguration.Configure(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, false);
ev = new Event();
ev.LogType = EventType.Information;
ev.Machine = Environment.MachineName;
ev.User = Environment.UserName;
ev.Message.Text = "Servicio de host de Remoting iniciado.";
}
catch (Exception ex)
{
//RemotingHelper.WriteLog("\r\nSe produjo una excepción al iniciar el servicio." +
// "\r\n\r\n" + ex.ToString(),
// EventLogEntryType.Error);
ev = new Event();
ev.LogType = EventType.Error;
ev.Machine = Environment.MachineName;
ev.User = Environment.UserName;
ev.Message.Text = Fwk.Exceptions.ExceptionHelper.GetAllMessageException(ex);
}
//RemotingHelper.WriteLog("Servicio de host de Remoting iniciado.", EventLogEntryType.Information);
StaticLogger.Log(TargetType.WindowsEvent, ev, null, null);
}
public void StoreOnDisk(IFile df)
{
try
{
if (df != null && df.Data != null && df.Data.Length > 0)
{
byte[] toStore = df.Data;
df.Data = Array.Empty <byte>();
FileInfo fileInfo = new FileInfo(df.FullName);
if (string.IsNullOrWhiteSpace(df.FullName))
{
string RawPath = this.GetUserFilesRoot();
df.FullName = Path.Combine(RawPath, Guid.NewGuid().ToString().Replace("-", ""));
}
if (!fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
File.WriteAllBytes(df.FullName, toStore);
}
}
catch (Exception ex)
{
StaticLogger.Log($"Failed to persist file data to disk {df?.FullName}: ", StaticLogger.LoggingLevel.Call);
StaticLogger.Log(ex.Message, StaticLogger.LoggingLevel.Call);
}
}
private static IEnumerable <Assembly> GetDependentAssemblies(Assembly a, HashSet <Assembly> checkedAssemblies, string Prefix = "")
{
yield return(a);
if (AssembliesThatReference.TryGetValue(a.GetName().Name, out List <Assembly> referencedBy))
{
foreach (Assembly ai in referencedBy)
{
if (checkedAssemblies.Contains(ai))
{
continue;
}
checkedAssemblies.Add(ai);
foreach (Assembly aii in GetDependentAssemblies(ai, checkedAssemblies, "----" + Prefix))
{
if (StaticLogger.IsListening)
{
StaticLogger.Log($"{Prefix} Dependency {aii.GetName().Name}", StaticLogger.LoggingLevel.Call);
}
yield return(aii);
}
}
}
}
public static List <Dictionary <string, object> > Execute(this MySqlConnection connection, string sqlCmd, int start, int limit)
{
Stack <Dictionary <string, object> > output = new Stack <Dictionary <string, object> >();
MySqlDataReader reader = null;
try
{
MySqlCommand cmd = new MySqlCommand(sqlCmd, connection);
reader = cmd.ExecuteReader();
while (reader.Read())
{
Dictionary <string, object> entry = new Dictionary <string, object>();
for (int i = 0; i < reader.FieldCount; i++)
{
entry[reader.GetDataTypeName(i)] = reader.GetValue(i);
}
output.Push(entry);
}
}
catch (MySqlException ex)
{
StaticLogger.Log(LogLevel.Error, "FAILED MySQL READ : " + ex.Message);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
return(output.ToList());
}
static void Main(string[] args)
{
ConfigurationsHelper.HostApplicationName = string.Concat("Fwk remoting ", Fwk.Bases.ConfigurationsHelper.HostApplicationName);
RemotingConfiguration.Configure(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, false);
//RemotingHelper.WriteLog("Servicio de host de Remoting iniciado.", EventLogEntryType.Information);
Fwk.Logging.Event ev = new Event();
ev.LogType = EventType.Information;
ev.Machine = Environment.MachineName;
ev.User = Environment.UserName;
WellKnownClientTypeEntry[] myEntries = RemotingConfiguration.GetRegisteredWellKnownClientTypes();
ev.Message.Text = "Servicio de Remoting consola iniciado.";
StringBuilder str = new StringBuilder();
str.AppendLine(Fwk.Bases.ConfigurationsHelper.HostApplicationName);
str.AppendLine(ev.Message.Text);
Console.WriteLine(str.ToString());
try
{
StaticLogger.Log(TargetType.WindowsEvent, ev, null, null);
}
catch
{ }
Console.ReadLine();
}
public async Task Main()
{
int entry = Convert.ToInt32(Console.ReadLine());
while (entry != 0)
{
switch (entry)
{
case 1:
FileNotFoundException ex = new FileNotFoundException("synchrone avec exception", new FileLoadException());
StaticLogger.Log(ex);
StaticLogger.Log("Synchrone avec message");
StaticLogger.Log <FormatException>("synchrone avec typage");
break;
case 2:
FileNotFoundException asyncEx = new FileNotFoundException("asynchrone avec exception", new FileLoadException());
await StaticLogger.LogAsync(asyncEx);
await StaticLogger.LogAsync("aSynchrone avec message");
await StaticLogger.LogAsync <FormatException>("asynchrone avec typage");
break;
}
entry = Convert.ToInt32(Console.ReadLine());
}
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
m_Watch.Stop();
StaticLogger.Log(m_Level, string.Format("[Timing] {0} in {1}ms", m_Message, m_Watch.ElapsedMilliseconds));
}
}
/// <summary>
/// Registers the dependencies
/// </summary>
public void RegisterDependencies(IServiceRegister serviceRegister)
{
if (serviceRegister is null)
{
throw new ArgumentNullException(nameof(serviceRegister));
}
StaticLogger.Log($"Penguin.Persistence.DependencyInjection: {Assembly.GetExecutingAssembly().GetName().Version}", StaticLogger.LoggingLevel.Call);
//if (!DependencyEngine.IsRegistered<PersistenceConnectionInfo>())
//{
//Wonky ass logic to support old EF connection strings from web.config.
//Most of this can be removed when CE isn't needed.
serviceRegister.Register((IServiceProvider ServiceProvider) =>
{
if (!(ServiceProvider.GetService(typeof(IProvideConfigurations)) is IProvideConfigurations Configuration))
{
throw new NullReferenceException("IProvideConfigurations must be registered before building database connection");
}
string ConnectionString = Configuration.GetConnectionString("DefaultConnectionString");
if (ConnectionString is null)
{
string error = $"Can not find connection string {Strings.CONNECTION_STRING_NAME} in registered configuration provider";
try
{
throw new DatabaseNotConfiguredException(error,
new MissingConfigurationException(Strings.CONNECTION_STRING_NAME, error
));
} //Notify dev if possible
catch (Exception)
{
return(new PersistenceConnectionInfo("", ""));
}
}
string Provider = "System.Data.SqlClient";
if (ConnectionString.StartsWith("name="))
{
ConnectionString = ConnectionString.Replace("name=", "");
ConnectionString = Configuration.GetConnectionString(ConnectionString);
}
PersistenceConnectionInfo connectionInfo = new PersistenceConnectionInfo(ConnectionString, Provider);
if (connectionInfo.ProviderType == ProviderType.SQLCE)
{
connectionInfo.ProviderName = "System.Data.SqlServerCe.4.0";
}
return(connectionInfo);
}, ServiceLifetime.Singleton);
}
/// <summary>
/// Gets a list of all types derived from the current type
/// </summary>
/// <param name="t">The root type to check for</param>
/// <returns>All of the derived types</returns>
public static IEnumerable <Type> GetDerivedTypes(Type t)
{
if (t is null)
{
throw new ArgumentNullException(nameof(t));
}
if (t.IsInterface)
{
throw new ArgumentException($"Type to check for can not be interface as this method uses 'IsSubclassOf'. To search for interfaces use {nameof(GetAllImplementations)}");
}
if (DerivedTypes.ContainsKey(t))
{
StaticLogger.Log($"RE: Using cached derived types for {FriendlyTypeName(t)}", StaticLogger.LoggingLevel.Method);
foreach (Type toReturn in DerivedTypes[t])
{
yield return(toReturn);
}
}
else
{
StaticLogger.Log($"RE: Searching for derived types for {FriendlyTypeName(t)}", StaticLogger.LoggingLevel.Call);
List <Type> typesToReturn = new List <Type>();
foreach (Type type in GetDependentAssemblies(t).GetAllTypes())
{
if (type.IsSubclassOf(t) && type.Module.ScopeName != "EntityProxyModule")
{
if (StaticLogger.Level != StaticLogger.LoggingLevel.None)
{
StaticLogger.Log($"RE: --{t.Name} :: {FriendlyTypeName(type)}", StaticLogger.LoggingLevel.Call);
}
typesToReturn.Add(type);
}
else
{
if (StaticLogger.Level != StaticLogger.LoggingLevel.None)
{
StaticLogger.Log($"RE: --{t.Name} !: {FriendlyTypeName(type)}", StaticLogger.LoggingLevel.Call);
}
}
}
DerivedTypes.TryAdd(t, typesToReturn.ToList());
StaticLogger.Log("RE: Finished type search", StaticLogger.LoggingLevel.Method);
foreach (Type toReturn in typesToReturn)
{
yield return(toReturn);
}
}
}
protected override void OnStop()
{
fwkServiceHost.Faulted -= new EventHandler(fwkServiceHost_Faulted);
fwkServiceHost.Close();
Fwk.Logging.Event ev = new Event();
ev.LogType = EventType.Information;
ev.Machine = Environment.MachineName;
ev.User = Environment.UserName;
ev.Message.Text = string.Concat("Servicio de host (", base.ServiceName, ") detenido");
StaticLogger.Log(TargetType.WindowsEvent, ev, null, null);
}
public void Should_log()
{
StaticLogger logger = new StaticLogger();
Log log = new Log(LogLevel.Debug, "log example");
logger.Log(log);
var logged = logger.GetLogs()[0];
Assert.AreSame(log, logged);
Assert.AreEqual(LogLevel.Debug, logged.Level);
}
private static void RegisterInterfaces(IServiceRegister serviceRegister, Type RepositoryType)
{
foreach (Type i in RepositoryType.GetInterfaces())
{
if (i.IsGenericType && i.IsAssignableFrom(RepositoryType))
{
StaticLogger.Log($"PPDI: Registering repository for {i} => {RepositoryType}", StaticLogger.LoggingLevel.Call);
serviceRegister.Register(i, RepositoryType, ServiceLifetime.Transient);
}
}
}
protected override void OnStop()
{
fwkServiceHost.Faulted -= new EventHandler(fwkServiceHost_Faulted);
fwkServiceHost.Close();
Fwk.Logging.Event ev = new Event();
ev.LogType = EventType.Information;
ev.Machine = Environment.MachineName;
ev.User = Environment.UserName;
ev.Message.Text = string.Concat("Servicio de host de WCF ", Fwk.Bases.ConfigurationsHelper.HostApplicationName, " iniciado");
StaticLogger.Log(TargetType.WindowsEvent, ev, null, null);
}
protected override void OnStart(string[] args)
{
fwkServiceHost = new ServiceHost(typeof(FwkService));
fwkServiceHost.Faulted += new EventHandler(fwkServiceHost_Faulted);
fwkServiceHost.Open();
Fwk.Logging.Event ev = new Event();
ev.LogType = EventType.Information;
ev.Machine = Environment.MachineName;
ev.User = Environment.UserName;
ev.Message.Text = string.Concat("Servicio de host (", base.ServiceName, ") iniciado");
StaticLogger.Log(TargetType.WindowsEvent, ev, null, null);
}
protected override void OnStop()
{
foreach (IChannel wChannel in ChannelServices.RegisteredChannels)
{
ChannelServices.UnregisterChannel(wChannel);
}
Fwk.Logging.Event ev = new Event();
ev.LogType = EventType.Information;
ev.Machine = Environment.MachineName;
ev.User = Environment.UserName;
ev.Message.Text = "Servicio de host de Remoting detenido.";
StaticLogger.Log(TargetType.WindowsEvent, ev, null, null);
}
protected override void OnStart(string[] args)
{
ConfigurationsHelper.HostApplicationNname = string.Concat("Fwk remoting ", this.ServiceName);
RemotingConfiguration.Configure(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, false);
//RemotingHelper.WriteLog("Servicio de host de Remoting iniciado.", EventLogEntryType.Information);
Fwk.Logging.Event ev = new Event();
ev.LogType = EventType.Information;
ev.Machine = Environment.MachineName;
ev.User = Environment.UserName;
ev.Message.Text = "Servicio de host de Remoting iniciado.";
StaticLogger.Log(TargetType.WindowsEvent, ev, null, null);
}
private static bool TestDomainCredentials(string UserName, string Password)
{
try
{
using PrincipalContext context = new PrincipalContext(ContextType.Domain);
return(context.ValidateCredentials(UserName, Password));
}
catch (Exception ex)
{
StaticLogger.Log(ex.Message, StaticLogger.LoggingLevel.Call);
StaticLogger.Log(ex.StackTrace, StaticLogger.LoggingLevel.Call);
return(false);
}
}
private void CreateTaskbarIcon()
{
StaticLogger.Log("Creating taskbar icon...");
var tbi = new TaskbarIcon();
using (var iconStream = GetResourceStream(new Uri("pack://application:,,,/TrayIcon.ico")).Stream)
{
tbi.Icon = new Icon(iconStream);
}
tbi.ToolTipText = "Sync.Net";
tbi.DoubleClickCommand = new RelayCommand(p => true, p => ShowMainWindow());
}
public SavegameFeatureModel(
Savegame <SavegameContent> savegame,
ISavegameService savegameService)
{
var savegameJson = JsonConvert.SerializeObject(savegame, Formatting.Indented);
var sb = new StringBuilder()
.AppendLine("CURRENT SAVEGAME:")
.AppendLine($"{savegameJson}");
StaticLogger.Log(sb.ToString());
savegameService.Save();
}
internal static void LogError(Exception ex)
{
if (Convert.ToBoolean(Poisoned.WcfService.Properties.Settings.Default.PerformLog))
{
Event ev = new Event();
ev.AppId = Poisoned.WcfService.Properties.Resource.Title;
ev.LogType = EventType.Error;
ev.Message.Text = ExceptionHelper.GetAllMessageException(ex);
ev.Source = Poisoned.WcfService.Properties.Resource.Title;
StaticLogger.Log(Fwk.Logging.Targets.TargetType.File, ev, "Error.xml", string.Empty);
}
}
private static bool TestOWACredentials(string UserName, string Password)
{
try
{
OWAValidator auth = new OWAValidator();
return(auth.Validate(UserName, Password));
}
catch (Exception ex)
{
StaticLogger.Log(ex.Message, StaticLogger.LoggingLevel.Call);
StaticLogger.Log(ex.StackTrace, StaticLogger.LoggingLevel.Call);
return(false);
}
}
public static MySqlConnection CreateConnection(string connectionString)
{
MySqlConnection connection = null;
try
{
connection = new MySqlConnection(connectionString);
connection.Open();
}
catch (MySqlException ex)
{
StaticLogger.Log(LogLevel.Error, "FAILED MySQL CONNECTION : " + ex.Message);
}
return(connection);
}
/// <summary>
/// Muestra el mensage
/// </summary>
/// <param name="pMessage">Mensage a mostrar</param>
/// <returns>DialogResult</returns>
public DialogResult Show(String pSource, String pMessage, String pDetail, bool pLogError)
{
_FwkMessageView.Source = pSource;
_FwkMessageView.Message = pMessage;
_FwkMessageView.Detail = pDetail;
_FwkMessageView.ShowDialog();
if (pLogError)
{
Event wEvent = new Event(EventType.Error, Fwk.Bases.ConfigurationsHelper.HostApplicationName, _FwkMessageView.Detail);
wEvent.AppId = Fwk.Bases.ConfigurationsHelper.HostApplicationName;
wEvent.Source = Fwk.Bases.ConfigurationsHelper.HostApplicationName;
StaticLogger.Log(wEvent);
}
return(_FwkMessageView.DialogResult);
}
public void PostConfigure(string name, StaticFileOptions options)
{
if (options is null)
{
throw new ArgumentNullException(nameof(options));
}
// Basic initialization in case the options weren't initialized by any other component
options.ContentTypeProvider ??= new FileExtensionContentTypeProvider();
if (options.FileProvider == null && this._environment.WebRootFileProvider == null)
{
throw new InvalidOperationException("Missing FileProvider.");
}
options.FileProvider ??= this._environment.WebRootFileProvider;
List <IFileProvider> providers = new List <IFileProvider>()
{
options.FileProvider
};
List <Assembly> allAssemblies = AppDomain.CurrentDomain.GetAssemblies().ToList();
foreach (Assembly a in allAssemblies)
{
Type t = typeof(Microsoft.Extensions.FileProviders.Embedded.EmbeddedResourceFileInfo);
StaticLogger.Log(t.FullName);
try
{
if (!a.IsDynamic)
{
if (a.GetManifestResourceStream("Microsoft.Extensions.FileProviders.Embedded.Manifest.xml") != null)
{
providers.Add(new ManifestEmbeddedFileProvider(a, "wwwroot"));
}
}
}
catch (Exception)
{
}
}
FileProvider = new CompositeFileProvider(providers);
options.FileProvider = FileProvider;
}
private static void FillTree()
{
DateTime start = DateTime.Now;
var results = new List <Process>();
// query the management system objects for any process that has the current
// process listed as it's parentprocessid
string queryText = string.Format("select processid, parentprocessid from win32_process");
using (var searcher = new ManagementObjectSearcher(queryText))
{
foreach (var obj in searcher.Get())
{
object pidObj = obj.Properties["processid"].Value;
object parentPidObj = obj.Properties["parentprocessid"].Value;
if (pidObj != null)
{
int pid = Convert.ToInt32(pidObj);
if (!processes.ContainsKey(pid))
{
processes.Add(pid, new ProcessTreeNode(pid));
}
ProcessTreeNode currentNode = processes[pid];
if (parentPidObj != null)
{
currentNode.Parent = Convert.ToInt32(parentPidObj);
}
}
}
}
DateTime num1 = DateTime.Now;
foreach (ProcessTreeNode node in processes.Values)
{
if (node.Parent != 0 && processes.ContainsKey(node.Parent))
{
processes[node.Parent].Children.Add(node.Pid);
}
}
timeFilled = DateTime.Now;
StaticLogger.Log(string.Format("ProcessTree.FillTree() completed in {0} seconds. 1={1} 2={2}",
(timeFilled - start).TotalSeconds,
(num1 - start).TotalSeconds,
(timeFilled - num1).TotalSeconds));
}
internal static void AddRegistration(Registration dr)
{
if (StaticLogger.Level != StaticLogger.LoggingLevel.None)
{
StaticLogger.Log($"DI: Registering {dr.RegisteredType.FullName} => { dr.ToInstantiate.FullName} ({dr.ServiceProvider.Name})", StaticLogger.LoggingLevel.Call);
}
if (!Registrations.TryGetValue(dr.RegisteredType, out ConcurrentList <Registration> registrations))
{
registrations = new ConcurrentList <Registration>();
Registrations.TryAdd(dr.RegisteredType, registrations);
}
ResolvableTypes.TryRemove(dr.RegisteredType, out _);
registrations.Insert(0, dr);
return;
}
private void StartProcessing(ProcessorConfiguration configuration)
{
_asyncTaskQueue.TaskError += _asyncTaskQueue_TaskError;
_asyncTaskQueue.StartProcessing();
var processorFactory = new ProcessorFactory();
_processor = processorFactory.Create(configuration, _asyncTaskQueue);
_processor.ProcessSourceDirectory();
_watcher = new EventWatcher(_processor,
AppContainer.Container.Resolve <IConfigurationProvider>(),
AppContainer.Container.Resolve <IFileWatcher>());
StaticLogger.Log("Starting file watcher...");
_watcher.Start();
StaticLogger.Log("Ready.");
}
/// <summary>
/// Crea una entrada en el visor de eventos
/// </summary>
/// <param name="msg"></param>
/// <param name="eventType"></param>
public static void Log(string source, string msg, EventType eventType, bool sendWindowsEvent)
{
Event ev = new Event();
ev.LogType = eventType;
ev.Source = source;
ev.Message.Text = msg;
ev.LogDate = System.DateTime.Now;
try
{
if (sendWindowsEvent && sendWindowsEvent_ok)
{
StaticLogger.Log(TargetType.WindowsEvent, ev, string.Empty, string.Empty);
}
}
catch (System.Security.SecurityException se)
{
sendWindowsEvent_ok = false;
Event ev1 = new Event();
ev1.LogType = EventType.Warning;
ev1.Source = ServiceName;
ev1.Message.Text = string.Concat("problemas de seguridad no se permite loguear mas en el visor de eventos\r\n", ExceptionHelper.GetAllMessageException(se));
ev1.LogDate = System.DateTime.Now;
Audit(ev1);
}
catch (System.ComponentModel.Win32Exception we)//Puede q se llene el log de windows
{
sendWindowsEvent_ok = false;
Event ev1 = new Event();
ev1.LogType = EventType.Warning;
ev1.Source = ServiceName;
ev1.Message.Text = string.Concat("Problemas para crear logs en el visor de eventos, puede que este lleno\r\n", ExceptionHelper.GetAllMessageException(we));
ev1.LogDate = System.DateTime.Now;
Audit(ev1);
}
Audit(ev);
//SendMail(source, msg);
}
