public override void Run(string[] _params)
{
try {
if (_params.Length != 1)
{
m_Console.SendResult("Utilisation: unban <steamidDuJoueur>");
return;
}
long tempLong;
if (_params [0].Length != 17 || !long.TryParse(_params [0], out tempLong))
{
m_Console.SendResult("Not a valid Steam ID.");
return;
}
AdminTools at = CommonMappingFunctions.GetGameManager().adminTools;
if (!at.IsBanned(_params [0]))
{
m_Console.SendResult("Steam ID is not banned.");
return;
}
at.RemoveBan(_params [0]);
m_Console.SendResult("Joueur deban " + _params [0]);
} catch (Exception e) {
Log.Out("Error in Unban.Run: " + e);
}
}
public static int Core_StartSqlOnly([MarshalAs(UnmanagedType.BStr)] String serverConnectionString, ref bool startResult)
{
int result = 0;
try
{
try
{
startResult = core.StartSqlOnly(serverConnectionString);
}
catch (Exception ex1)
{
AdminTools adminTools = new AdminTools(serverConnectionString);
adminTools.MigrateDb();
adminTools.DbSettingsReloadRemote();
core.StartSqlOnly(serverConnectionString);
}
}
catch (Exception ex)
{
LastError.Value = ex.Message;
result = 1;
}
return(result);
}
public async Task Setup()
{
ConnectionString = @"Server = localhost; port = 3306; Database = eformsdk-tests; user = root; Convert Zero Datetime = true;";
dbContext = GetContext(ConnectionString);
dbContext.Database.SetCommandTimeout(300);
try
{
await ClearDb().ConfigureAwait(false);
}
catch
{
}
try
{
AdminTools adminTools = new AdminTools(ConnectionString);
await adminTools.DbSetup("abc1234567890abc1234567890abcdef").ConfigureAwait(false);
} catch
{
}
await DoSetup().ConfigureAwait(false);
}
private void closeAssistent()
{
if (selectedComputer != null)
{
AdminTools.killProcess(selectedComputer, "msra.exe");
}
}
public void DoHandle(Client client, Packet packet)
{
var clientMap = packet.Carriage.Deserialize();
if (clientMap.Count != 2)
{
return;
}
string email = clientMap[0];
string password = clientMap[1];
if (string.IsNullOrEmpty(email) ||
string.IsNullOrEmpty(password))
{
Packets.LoginFail("Invalid Email or Password").Write(client);
return;
}
var user = User.GetUser(email);
if (!user.Exists)
{
Packets.LoginFail("Account does not exist").Write(client);
return;
}
if (user.Password == password)
{
Packets.LoginSuccess(user.Id, user.Nickname).Write(client);
AdminTools.DisconnectSessions(user.Id, "Logged In Elsewhere");
Packets.Message("{0} joined the chat", user.Nickname).WriteAll();
lock (Handle.OnlineUsers)
{
if (Handle.OnlineUsers.ContainsKey(client))
{
Handle.OnlineUsers[client] = user;
}
else
{
Handle.OnlineUsers.Add(client, user);
}
}
Console.WriteLine("[Info] User {0} ({1}) now online, role: {2}",
user.Nickname,
user.Email,
user.Role.ToString());
Packets.Message("Server", Program.Motd).Write(client);
Packets.UserList().WriteAll();
return;
}
Packets.LoginFail("Invalid Password").Write(client);
}
public OperationDataResult <TemplateListModel> Index(TemplateRequestModel templateRequestModel)
{
try
{
try
{
var core = _coreHelper.GetCore();
var templatesDto = core.TemplateItemReadAll(false,
"",
templateRequestModel.NameFilter,
templateRequestModel.IsSortDsc,
templateRequestModel.Sort,
templateRequestModel.TagIds);
var model = new TemplateListModel
{
NumOfElements = 40,
PageNum = templateRequestModel.PageIndex,
Templates = templatesDto
};
return(new OperationDataResult <TemplateListModel>(true, model));
}
catch (Exception ex)
{
if (ex.Message.Contains("PrimeDb"))
{
var lines = File.ReadAllLines(
System.Web.Hosting.HostingEnvironment.MapPath("~/bin/Input.txt"));
var connectionStr = lines.First();
var adminTool = new AdminTools(connectionStr);
adminTool.DbSettingsReloadRemote();
return(new OperationDataResult <TemplateListModel>(false, LocaleHelper.GetString("CheckConnectionString")));
}
else
{
if (ex.InnerException.Message.Contains("Cannot open database"))
{
try
{
var core = _coreHelper.GetCore();
}
catch (Exception)
{
return(new OperationDataResult <TemplateListModel>(false, LocaleHelper.GetString("CoreIsNotStarted")));
}
return(new OperationDataResult <TemplateListModel>(false, LocaleHelper.GetString("CheckSettingsBeforeProceed")));
}
}
return(new OperationDataResult <TemplateListModel>(false, LocaleHelper.GetString("CheckSettingsBeforeProceed")));
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
}
public void DoHandle(Client client, Packet packet)
{
var user = Handle.OnlineUsers[client];
if (string.IsNullOrEmpty(packet.Carriage))
{
return;
}
var map = packet.Carriage.Deserialize();
if (map.Count != 2)
{
return;
}
int userId = Convert.ToInt32(map[0]);
string newRole = map[1];
if (user.Role != User.UserRole.Admin)
{
return;
}
try
{
User tuser = User.GetUser(userId);
if (!tuser.Exists)
{
return;
}
if (newRole == "banned")
{
AdminTools.BanUser(user);
Console.WriteLine("[Info] {0} banned user {1}", user.Email, tuser.Email);
return;
}
if (newRole == "unbanned")
{
AdminTools.UnbanUser(tuser);
Console.WriteLine("[Info] {0} unbanned user {1}", user.Email, tuser.Email);
return;
}
var role = (User.UserRole)(Enum.Parse(typeof(User.UserRole), newRole, true));
User tuser2 = User.GetUser(userId);
if (!tuser2.Exists)
{
return;
}
AdminTools.ChangeRank(tuser, role);
Console.WriteLine("[Info] {0} changed {1}'s rank to {2}", user.Email, tuser.Email, newRole.ToString());
}
catch
{
}
}
public void DoHandle(Client client, Packet packet)
{
var user = Handle.OnlineUsers[client];
if (string.IsNullOrEmpty(packet.Carriage))
{
return;
}
AdminTools.ChangeNickname(user, packet.Carriage.Trim());
Console.WriteLine("[Info] {0} changed their nickname to {1}", user.Email, packet.Carriage.Trim());
}
//protected override void OnException(ExceptionContext filterContext)
//{
// this.Session["ErrorException"] = filterContext.Exception;
// filterContext.ExceptionHandled = true;
// if (filterContext.Exception.Message.Contains("Could not find file") && filterContext.Exception.Message.Contains("Input.txt"))
// {
// filterContext.Result = this.RedirectToAction("ConnectionMissing", "Settings");
// }
// else
// {
// if (filterContext.Exception.Message.Contains("Core is not running"))
// {
// filterContext.Result = this.RedirectToAction("Index", "Settings");
// }
// }
// base.OnException(filterContext);
//}
#endregion
public Core GetCore()
{
string[] lines;
try
{
lines =
System.IO.File.ReadAllLines(System.Web.Hosting.HostingEnvironment.MapPath("~/bin/Input.txt"));
if (lines[0].IsEmpty())
{
throw new Exception();
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
string connectionStr = lines.First();
this._core = new Core();
bool running = false;
_core.HandleCaseCreated += EventCaseCreated;
_core.HandleCaseRetrived += EventCaseRetrived;
_core.HandleCaseCompleted += EventCaseCompleted;
_core.HandleCaseDeleted += EventCaseDeleted;
_core.HandleFileDownloaded += EventFileDownloaded;
_core.HandleSiteActivated += EventSiteActivated;
//_core.HandleEventLog += EventLog;
//_core.HandleEventMessage += EventMessage;
//_core.HandleEventWarning += EventWarning;
_core.HandleEventException += EventException;
try
{
running = _core.StartSqlOnly(connectionStr);
} catch (Exception ex) {
AdminTools adminTools = new AdminTools(connectionStr);
adminTools.MigrateDb();
adminTools.DbSettingsReloadRemote();
running = _core.StartSqlOnly(connectionStr);
}
if (running)
{
return(_core);
}
Logger.Error("Core is not running");
throw new Exception("Core is not running");
//return null;
}
public void DoHandle(Client client, Packet packet)
{
var currentUser = Handle.OnlineUsers[client];
if (currentUser.Role != User.UserRole.Admin)
{
return;
}
int uid = Convert.ToInt32(packet.Carriage);
AdminTools.DisconnectSessions(uid, "Connection discontinued by an administrator.");
}
public void DoHandle(Client client, Packet packet)
{
var user = Handle.OnlineUsers[client];
if (string.IsNullOrEmpty(packet.Carriage))
{
return;
}
user.Password = packet.Carriage;
user.UpdatePassword();
AdminTools.DisconnectSessions(user, "Password changed. Relogin for security reasons");
Console.WriteLine("[Info] {0} changed their nickname to {1}", user.Email, packet.Carriage.Trim());
}
private void killProcces_button_Click(object sender, EventArgs e)
{
try {
AdminTools.killProcess(
this.computerName,
(process_dataGridView.SelectedRows[0].DataBoundItem as TableProces).PID
);
int index = process_dataGridView.SelectedRows[0].Index;
this.tableProcess.RemoveAt(process_dataGridView.SelectedRows[0].Index);
this.refreshProcessTable();
this.process_dataGridView.CurrentCell = process_dataGridView.Rows[index].Cells[0];
} catch (Exception ex) {
MessageBox.Show(ex.Message);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try {
AdminTools admTools = GameManager.Instance.adminTools;
bool onlineOnly = false;
bool notBannedOnly = false;
string nameFilter = string.Empty;
if (_params.Count == 1)
{
if (_params [0].ToLower().Equals("-online"))
{
onlineOnly = true;
}
else if (_params [0].ToLower().Equals("-notbanned"))
{
notBannedOnly = true;
}
else
{
nameFilter = _params [0].ToLower();
}
}
int num = 0;
foreach (string sid in PersistentContainer.Instance.Players.SteamIDs)
{
Player p = PersistentContainer.Instance.Players [sid, false];
if (
(!onlineOnly || p.IsOnline) &&
(!notBannedOnly || !admTools.IsBanned(sid)) &&
(nameFilter.Length == 0 || p.Name.ToLower().Contains(nameFilter))
)
{
SdtdConsole.Instance.Output(String.Format("{0}. {1}, id={2}, steamid={3}, online={4}, ip={5}, playtime={6} m, seen={7}",
++num, p.Name, p.EntityID, sid, p.IsOnline, p.IP,
p.TotalPlayTime / 60,
p.LastOnline.ToString("yyyy-MM-dd HH:mm"))
);
}
}
SdtdConsole.Instance.Output("Total of " + PersistentContainer.Instance.Players.Count + " known");
} catch (Exception e) {
Log.Out("Error in ListKnownPlayers.Run: " + e);
}
}
public static int AdminTools_Create([MarshalAs(UnmanagedType.BStr)] String serverConnectionString)
{
int result = 0;
try
{
program = new AdminTools(serverConnectionString);
}
catch (Exception ex)
{
LastError.Value = ex.Message;
result = 1;
}
return(result);
}
public void Test_Reset(string connectionString)
{
sqlController = new SqlController(connectionString);
Log log = sqlController.StartLog(this);
outlookController = new OutlookController(sqlController, log);
AdminTools at = new AdminTools(sqlController.SettingRead(Settings.microtingDb));
try
{
if (!coreRunning && !coreStatChanging)
{
coreStatChanging = true;
log.LogStandard("Not Specified", "Reset!");
List <Appointment> lstAppointments;
DateTime now = DateTime.Now;
DateTime rollBackTo__ = now.AddDays(+2);
DateTime rollBackFrom = now.AddDays(-3);
lstAppointments = outlookController.UnitTest_CalendarItemGetAllNonRecurring(rollBackFrom, rollBackTo__);
foreach (var item in lstAppointments)
{
outlookController.CalendarItemUpdate(item, WorkflowState.Planned, true);
}
sqlController.SettingUpdate(Settings.checkLast_At, now.ToString());
at.RetractEforms();
sqlController.UnitTest_TruncateTable_Outlook("appointment_versions");
sqlController.UnitTest_TruncateTable_Outlook("appointments");
sqlController.UnitTest_TruncateTable_Microting("a_interaction_case_lists");
sqlController.UnitTest_TruncateTable_Microting("a_interaction_cases");
sqlController.UnitTest_TruncateTable_Microting("notifications");
sqlController.UnitTest_TruncateTable_Microting("cases");
coreStatChanging = false;
}
}
catch (Exception ex)
{
FatalExpection(t.GetMethodName() + "failed. Core failed to restart", ex);
}
Close();
}
public async Task <OperationDataResult <Template_Dto> > Get(int id)
{
try
{
var core = await _coreHelper.GetCore();
var locale = await _userService.GetCurrentUserLocale();
Language language = core.DbContextHelper.GetDbContext().Languages.Single(x => x.LanguageCode.ToLower() == locale.ToLower());
var templateDto = await core.TemplateItemRead(id, language);
return(new OperationDataResult <Template_Dto>(true, templateDto));
}
catch (Exception ex)
{
if (ex.Message.Contains("PrimeDb"))
{
var sdkConnectionString = _connectionStringsSdk.Value.SdkConnection;
var adminTool = new AdminTools(sdkConnectionString);
await adminTool.DbSettingsReloadRemote();
return(new OperationDataResult <Template_Dto>(false,
_localizationService.GetString("CheckConnectionString")));
}
if (ex.InnerException.Message.Contains("Cannot open database"))
{
try
{
var core = await _coreHelper.GetCore();
}
catch (Exception)
{
return(new OperationDataResult <Template_Dto>(false,
_localizationService.GetString("CoreIsNotStarted")));
}
return(new OperationDataResult <Template_Dto>(false,
_localizationService.GetString("CheckSettingsBeforeProceed")));
}
return(new OperationDataResult <Template_Dto>(false,
_localizationService.GetString("CheckSettingsBeforeProceed")));
}
}
public OperationDataResult <Template_Dto> Get(int id)
{
try
{
try
{
var core = _coreHelper.GetCore();
var templateDto = core.TemplateItemRead(id);
return(new OperationDataResult <Template_Dto>(true, templateDto));
}
catch (Exception ex)
{
if (ex.Message.Contains("PrimeDb"))
{
var lines = File.ReadAllLines(System.Web.Hosting.HostingEnvironment.MapPath("~/bin/Input.txt"));
var connectionStr = lines.First();
var adminTool = new AdminTools(connectionStr);
adminTool.DbSettingsReloadRemote();
return(new OperationDataResult <Template_Dto>(false, LocaleHelper.GetString("CheckConnectionString")));
}
else
{
if (ex.InnerException.Message.Contains("Cannot open database"))
{
try
{
var core = _coreHelper.GetCore();
}
catch (Exception)
{
return(new OperationDataResult <Template_Dto>(false, LocaleHelper.GetString("CoreIsNotStarted")));
}
return(new OperationDataResult <Template_Dto>(false, LocaleHelper.GetString("CheckSettingsBeforeProceed")));
}
}
return(new OperationDataResult <Template_Dto>(false, LocaleHelper.GetString("CheckSettingsBeforeProceed")));
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
}
static void Main(string[] args)
{
Console.WriteLine("");
Console.WriteLine("Enter SDK's database connection string:");
string sdkCon = Console.ReadLine();
Console.WriteLine("Processing...");
AdminTools at = new AdminTools(sdkCon);
Console.WriteLine("Completed...");
Console.WriteLine("");
Console.WriteLine("Enter token:");
string token = Console.ReadLine();
Console.WriteLine("Processing...");
at.DbSetup(token);
Console.WriteLine("Completed...");
Console.WriteLine("");
Console.WriteLine("Enter Outlook's database connection string:");
string outlookCon = Console.ReadLine();
Console.WriteLine("Processing...");
SqlController outlook = new SqlController(outlookCon);
outlook.SettingUpdate(Settings.microtingDb, sdkCon);
Console.WriteLine("Completed...");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
Console.WriteLine("!!! Please check, and change where needed, the setting tables in the SDK and Outlook databases !!!");
Console.WriteLine("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("(press any key to close)");
Console.ReadLine();
Console.WriteLine("");
Console.WriteLine("Closing app in a sec");
Thread.Sleep(1000);
}
private void OnAddUser(object parameter)
{
NewUser.Username = NewUser.Username.Trim();
if (User.List.FindAll(u => u.Username.ToLower() == NewUser.Username.ToLower()).Count != 0)
{
UIMessager.ShowMessage("Пользователь с тамим именем уже существует в системе. Выберите другое имя пользователя");
return;
}
var response = AdminTools.AddUser(NewUser);
UIMessager.ShowMessage(response.Message);
if (response.IsDone)
{
this.OnRequestClose();
}
}
private async void ping_button_Click(object sender, EventArgs e)
{
int time = 5;
string selectedComputerName = this.selectedComputer;
bool pingResalt = AdminTools.pingResalt(selectedComputer);
while (time > 0 && selectedComputerName == selectedComputer)
{
if (pingResalt)
{
ping_button.Text = $" ПИНГУЕТСЯ ({time--})";
}
else
{
ping_button.Text = $"НЕ ПИНГУЕТСЯ ({time--})";
}
await Task.Delay(TimeSpan.FromSeconds(1));
}
ping_button.Text = " PING";
}
/// <summary>
/// Загружает нужное представление
/// </summary>
/// <param name="typeView"></param>
public void LoadView(ViewType typeView)
{
switch (typeView)
{
case ViewType.PRODUCTS:
//загружаем вьюшку, ее вьюмодель
Products viewP = new Products();
ProductsViewModel vmP = new ProductsViewModel(this);
//связываем их м/собой
viewP.DataContext = vmP;
//отображаем
this.OutputView.Content = viewP;
break;
case ViewType.ADMIN_TOOLS:
AdminTools viewAT = new AdminTools();
AdminToolsViewModel vmAT = new AdminToolsViewModel(this);
viewAT.DataContext = vmAT;
this.OutputView.Content = viewAT;
break;
}
}
private async void UserName_comboBox_SelectedIndexChanged(object sender, EventArgs e)
{
if (this.userName_comboBox.SelectedItem == null)
{
//this.userName_comboBox.SelectedItem = 0;
this.userName_comboBox.SelectedItem = this.userName_comboBox.Items[0];
}
this.selectedComboboxItem = this.userName_comboBox.GetItemText(this.userName_comboBox.SelectedItem).ToString();
parsedEntities = LogFileParser.ParceUsersComputers(selectedComboboxItem);
sortComputers(ref parsedEntities);
this.parsedEntitiesNames_listBox.DataSource = LogFileParser.getNames(parsedEntities);
foreach (var el in parsedEntities)
{
if (Convert.ToDateTime(el.lastLog.Substring(0, 8)).AddMonths(4) >= DateTime.Now)
{
string computerName = String.Empty;
string userName = String.Empty;
switch (selectedSearchType)
{
case SearchFor.users:
computerName = selectedComboboxItem;
userName = el.name;
break;
case SearchFor.computers:
computerName = el.name;
userName = selectedComboboxItem;
break;
}
if (await Task.Run(() => AdminTools.checkUserLogedIn(computerName, userName)))
{
el.loginStatus = true;
this.parsedEntitiesNames_listBox.Refresh();
}
}
}
}
private void refreshProcessTable()
{
this.tableProcess = new List <TableProces>();
this.process = AdminTools.getComputerProcess(this.computerName);
ITerminalServer server = process[0].Server;
foreach (ITerminalServicesProcess proc in process)
{
ITerminalServicesSession session = server.GetSession(proc.SessionId);
if (showAllProcess | session.UserAccount != null)
{
TableProces tmpProc = new TableProces(
proc.ProcessId,
proc.ProcessName,
session.UserName
);
tableProcess.Add(tmpProc);
}
}
tableProcess.Sort((x, y) => x.processName.CompareTo(y.processName));
//process_dataGridView.Refresh();
process_dataGridView.DataSource = this.tableProcess;
}
public static async Task <Core> GetCoreInstance(string connectionString, ILogger <EFormCoreService> logger)
{
if (_coreInstance != null && connectionString.Equals(_connectionString))
{
return(_coreInstance);
}
await Task.Run(() => { });
lock (LockObj)
{
bool isCoreRunning;
_coreInstance = new Core();
try
{
isCoreRunning = _coreInstance.StartSqlOnly(connectionString).Result;
}
catch (Exception exception)
{
Log.LogException($"CoreSingleton.GetCoreInstance: Got exception {exception.Message}");
var adminTools = new AdminTools(connectionString);
var result = adminTools.DbSettingsReloadRemote().Result;
isCoreRunning = _coreInstance.StartSqlOnly(connectionString).Result;
}
if (isCoreRunning)
{
_connectionString = connectionString;
return(_coreInstance);
}
logger.LogError("Core is not running");
throw new Exception("Core is not running");
}
}
static void Main(string[] args)
{
try
{
#region pick database
//string serverConnectionString = "Persist Security Info=True;server=localhost;database=microtingMySQL;uid=root;password=1234";
string serverConnectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=v166;User Id=sa;Password=aiT1sueh;";
Console.WriteLine("Enter database to use:");
Console.WriteLine("> If left blank, it will use 'Microting'");
Console.WriteLine(" Enter name of database to be used");
string databaseName = Console.ReadLine();
//if (databaseName.ToUpper() != "")
// serverConnectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=" + databaseName + ";Integrated Security=True";
//if (databaseName.ToUpper() == "T")
// serverConnectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=" + "MicrotingTest" + ";Integrated Security=True";
//if (databaseName.ToUpper() == "O")
// serverConnectionString = @"Data Source=.\SQLEXPRESS;Initial Catalog=" + "MicrotingOdense" + ";Integrated Security=True";
Console.WriteLine(serverConnectionString);
#endregion
#region Console.WriteLine(...text...)
Console.WriteLine("");
Console.WriteLine("Enter one of the following keys to start:");
Console.WriteLine(" 'A', for Admin tools");
Console.WriteLine("> 'S', for sample programs");
Console.WriteLine(" 'I', for purely run core");
Console.WriteLine("");
Console.WriteLine("Any other will close Console");
string input = Console.ReadLine().ToUpper();
#endregion
var bus = Configure.With(new BuiltinHandlerActivator())
.Logging(l => l.ColoredConsole())
.Transport(t => t.UseSqlServerAsOneWayClient(connectionStringOrConnectionStringName: serverConnectionString, tableName: "Rebus"))
.Options(o =>
{
})
.Routing(r => r.TypeBased().Map <EformRetrieved>("eformsdk-input"))
.Start();
if (input == "A")
{
var program = new AdminTools(serverConnectionString);
program.RunConsole();
}
if (input == "S")
{
var program = new Samples(serverConnectionString);
program.Run();
}
if (input == "I")
{
var core = new Core();
core.Start(serverConnectionString);
#region keep core running
while (true)
{
Console.WriteLine("");
Console.WriteLine("Press any key to exit program,");
Console.ReadLine();
break;
}
#endregion
}
if (input == "E")
{
var core = new Core();
core.Start(serverConnectionString);
Console.WriteLine("Sending EformRetrieved message");
bus.Send(new EformRetrieved("123", "123")).Wait();
Console.WriteLine("Hit a key to exit");
Console.ReadLine();
}
Console.WriteLine("");
Console.WriteLine("Console will close in 1s");
Thread.Sleep(1000);
Environment.Exit(0);
}
#region ...catch all...
catch (Exception ex)
{
Tools t = new Tools();
try
{
File.AppendAllText("FatalException_" + DateTime.Now.ToString("MM.dd_HH.mm.ss") + ".txt", t.PrintException("Fatal Exception", ex));
}
catch { }
Console.WriteLine("");
Console.WriteLine(t.PrintException("Fatal Exception", ex));
Console.WriteLine("");
Console.WriteLine("Fatal Exception found and logged. Fil can be found at log/");
Console.WriteLine("Console will close in 6s");
Thread.Sleep(6000);
Environment.Exit(0);
}
#endregion
}
public async Task <OperationDataResult <TemplateListModel> > Index(TemplateRequestModel templateRequestModel)
{
var timeZoneInfo = await _userService.GetCurrentUserTimeZoneInfo();
Log.LogEvent("TemplateService.Index: called");
try
{
var core = await _coreHelper.GetCore();
await using var sdkDbContext = core.DbContextHelper.GetDbContext();
Log.LogEvent("TemplateService.Index: try section");
var language = await _userService.GetCurrentUserLanguage();
if (language == null)
{
language = await sdkDbContext.Languages.SingleOrDefaultAsync(x => x.Name == "Danish");
if (language != null)
{
language.LanguageCode = "da";
await language.Update(sdkDbContext);
}
}
var query = sdkDbContext.CheckListTranslations
.Include(x => x.CheckList)
.ThenInclude(x => x.Taggings)
.ThenInclude(x => x.Tag)
.Include(x => x.CheckList.CheckListSites)
.ThenInclude(x => x.Site)
.Include(x => x.CheckList.Cases)
.Where(x => x.CheckList.ParentId == null)
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => x.CheckList.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => x.LanguageId == language.Id);
query = QueryHelper.AddFilterAndSortToQuery(query, templateRequestModel, new List <string> {
"Text"
},
new List <string> {
"Id", "CreatedAt"
});
if (templateRequestModel.Sort is "Id" or "CreatedAt")
{
if (templateRequestModel.IsSortDsc)
{
query = query
.CustomOrderByDescending(templateRequestModel.Sort);
}
else
{
query = query
.CustomOrderBy(templateRequestModel.Sort);
}
}
if (templateRequestModel.TagIds.Any())
{
query = query.Where(x => x.CheckList.Taggings
.Where(y => y.Tag.WorkflowState != Constants.WorkflowStates.Removed)
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.Any(y => templateRequestModel.TagIds.Contains((int)y.TagId)));
}
var templatesDto = await query.Select(x => new TemplateDto
{
Id = x.CheckListId,
CreatedAt =
TimeZoneInfo.ConvertTimeFromUtc((DateTime)x.CheckList.CreatedAt, timeZoneInfo),
DeployedSites = x.CheckList.CheckListSites
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.Select(y => new SiteNameDto
{
SiteUId = (int)y.Site.MicrotingUid,
SiteName = y.Site.Name,
CreatedAt = y.Site.CreatedAt,
UpdatedAt = y.Site.UpdatedAt
})
.ToList(),
Description = x.Description,
Label = x.Text,
Repeated = (int)x.CheckList.Repeated,
FolderName = x.CheckList.FolderName,
WorkflowState = x.CheckList.WorkflowState,
HasCases = x.CheckList.Cases
.Any(y => y.WorkflowState != Constants.WorkflowStates.Removed),
DisplayIndex = x.CheckList.DisplayIndex,
Tags = x.CheckList.Taggings
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.Where(y => y.Tag.WorkflowState != Constants.WorkflowStates.Removed)
.Select(y => new KeyValuePair <int, string>(y.Tag.Id, y.Tag.Name))
.ToList(),
FolderId = x.CheckList.CheckListSites
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.Select(y => y.FolderId)
.FirstOrDefault(),
IsLocked = x.CheckList.IsLocked,
IsEditable = x.CheckList.IsEditable,
DocxExportEnabled = x.CheckList.DocxExportEnabled,
JasperExportEnabled = x.CheckList.JasperExportEnabled,
ExcelExportEnabled = x.CheckList.ExcelExportEnabled,
IsAchievable = x.CheckList.IsAchievable,
IsDoneAtEditable = x.CheckList.IsDoneAtEditable
}).ToListAsync();
//var templatesDto = await core.TemplateItemReadAll(false,
// "",
// templateRequestModel.NameFilter,
// templateRequestModel.IsSortDsc,
// templateRequestModel.Sort,
// templateRequestModel.TagIds,
// timeZoneInfo, language);
var model = new TemplateListModel
{
NumOfElements = await query.Where(y => y.CheckList.WorkflowState != Constants.WorkflowStates.Removed).Select(x => x.CheckListId).CountAsync(),
//PageNum = templateRequestModel.PageIndex,
Templates = new List <TemplateDto>()
};
var pluginIds = await _dbContext.EformPlugins
.Select(x => x.PluginId)
.ToListAsync();
if (!_userService.IsAdmin())
{
var isEformsInGroups = await _dbContext.SecurityGroupUsers
.Where(x => x.EformUserId == _userService.UserId)
.Where(x => x.SecurityGroup.EformsInGroup.Any())
.AnyAsync();
if (isEformsInGroups)
{
var eformIds = _dbContext.EformInGroups
.Where(x =>
x.SecurityGroup.SecurityGroupUsers.Any(y => y.EformUserId == _userService.UserId))
.Select(x => x.TemplateId)
.ToList();
foreach (var templateDto in templatesDto.Where(templateDto => eformIds.Contains(templateDto.Id)))
{
await templateDto.CheckForLock(_dbContext);
model.Templates.Add(templateDto);
}
}
else
{
foreach (var templateDto in templatesDto)
{
await templateDto.CheckForLock(_dbContext, pluginIds);
model.Templates.Add(templateDto);
}
}
}
else
{
foreach (var templateDto in templatesDto)
{
await templateDto.CheckForLock(_dbContext, pluginIds);
model.Templates.Add(templateDto);
}
}
//foreach (var template in model.Templates)
//{
// var tagsForRemove = new List<KeyValuePair<int, string>>();
// foreach (var tag in template.Tags)
// {
// if (await sdkDbContext.Tags
// .Where(y => y.WorkflowState == Constants.WorkflowStates.Removed)
// .AnyAsync(x => x.Id == tag.Key))
// {
// tagsForRemove.Add(tag);
// }
// }
// foreach (var tag in tagsForRemove)
// {
// template.Tags.Remove(tag);
// }
//}
return(new OperationDataResult <TemplateListModel>(true, model));
}
catch (Exception ex)
{
Log.LogEvent("TemplateService.Index: catch section");
Log.LogException($"TemplatesService.Index: Got exception {ex.Message}");
Log.LogException($"TemplatesService.Index: Got stacktrace {ex.StackTrace}");
if (ex.Message.Contains("PrimeDb"))
{
var sdkConnectionString = _connectionStringsSdk.Value.SdkConnection;
var adminTool = new AdminTools(sdkConnectionString);
await adminTool.DbSettingsReloadRemote();
return(new OperationDataResult <TemplateListModel>(false,
_localizationService.GetString("CheckConnectionString")));
}
if (ex.InnerException != null && ex.InnerException.Message.Contains("Cannot open database"))
{
try
{
var _ = await _coreHelper.GetCore();
}
catch (Exception ex2)
{
return(new OperationDataResult <TemplateListModel>(false,
_localizationService.GetString("CoreIsNotStarted") + " " + ex2.Message));
}
return(new OperationDataResult <TemplateListModel>(false,
_localizationService.GetString("CheckSettingsBeforeProceed")));
}
return(new OperationDataResult <TemplateListModel>(false,
_localizationService.GetString("CheckSettingsBeforeProceed")));
}
}
static void Main(string[] args)
{
// set true for MS SQL Server Database
// set false for MySQL Datbase
// bool IsMSSQL = true;
//MicrotingDbMs DbContext;
//string mySQLConnStringFormat = "Server = localhost; port = 3306; Database = {0}; user = eform; password = eform; Convert Zero Datetime = true;";
//string msSQLConnStringFormat = @"data source=localhost;Initial catalog={0};Integrated Security=True";
//DbContextOptionsBuilder dbContextOptionsBuilder = new DbContextOptionsBuilder();
//dbContextOptionsBuilder.UseSqlServer(ConnectionString);
//DbContext = new MicrotingDbMs(dbContextOptionsBuilder.Options);
try
{
#region pick database
string serverConnectionString = "";
Console.WriteLine("Enter database to use:");
Console.WriteLine("> If left blank, it will use 'Microting'");
Console.WriteLine(" Enter name of database to be used");
string databaseName = Console.ReadLine();
if (databaseName.ToUpper() != "")
{
serverConnectionString = string.Format(DbConfig.ConnectionString, databaseName);
}
// serverConnectionString = @"Data Source=localhost;Initial Catalog=" + databaseName + ";Integrated Security=True";
if (databaseName.ToUpper() == "T")
{
serverConnectionString = string.Format(DbConfig.ConnectionString, "MicrotingTest");
}
//serverConnectionString = @"Data Source=locahost;Initial Catalog=" + "MicrotingTest" + ";Integrated Security=True";
if (databaseName.ToUpper() == "O")
{
serverConnectionString = string.Format(DbConfig.ConnectionString, "MicrotingOdense");
}
// serverConnectionString = @"Data Source=localhost;Initial Catalog=" + "MicrotingOdense" + ";Integrated Security=True";
if (serverConnectionString == "")
{
serverConnectionString = string.Format(DbConfig.ConnectionString, "MicrotingSourceCode");
}
// serverConnectionString = @"Data Source=localhost;Initial Catalog=" + "MicrotingSourceCode" + ";Integrated Security=True";
Console.WriteLine(serverConnectionString);
#endregion
#region Console.WriteLine(...text...)
Console.WriteLine("");
Console.WriteLine("Enter one of the following keys to start:");
Console.WriteLine(" 'A', for Admin tools");
Console.WriteLine("> 'S', for sample programs");
Console.WriteLine(" 'I', for purely run core");
Console.WriteLine("");
Console.WriteLine("Any other will close Console");
string input = Console.ReadLine().ToUpper();
#endregion
if (input == "A")
{
var program = new AdminTools(serverConnectionString);
program.RunConsole();
}
if (input == "S")
{
var program = new Samples(serverConnectionString);
program.Run();
}
if (input == "I")
{
var core = new Core();
core.Start(serverConnectionString);
#region keep core running
while (true)
{
Console.WriteLine("");
Console.WriteLine("Press any key to exit program,");
Console.ReadLine();
break;
}
#endregion
}
Console.WriteLine("");
Console.WriteLine("Console will close in 1s");
Thread.Sleep(1000);
Environment.Exit(0);
}
#region ...catch all...
catch (Exception ex)
{
Tools t = new Tools();
try
{
File.AppendAllText("FatalException_" + DateTime.Now.ToString("MM.dd_HH.mm.ss") + ".txt", t.PrintException("Fatal Exception", ex));
}
catch { }
Console.WriteLine("");
Console.WriteLine(t.PrintException("Fatal Exception", ex));
Console.WriteLine("");
Console.WriteLine("Fatal Exception found and logged. Fil can be found at log/");
Console.WriteLine("Console will close in 6s");
Thread.Sleep(6000);
Environment.Exit(0);
}
#endregion
}
private static async Task InitializeSettings(IWebHost webHost, string[] args)
{
using var scope = webHost.Services.GetService <IServiceScopeFactory>().CreateScope();
var settingsService = scope.ServiceProvider.GetRequiredService <ISettingsService>();
var existsResult = settingsService.ConnectionStringExist();
if (!existsResult.Success)// do need to initialize database
{
// Find file
var filePath = Path.Combine(Directory.GetCurrentDirectory(), "init.json");
if (File.Exists(filePath))
{
Log.LogEvent($"Try initialize from {filePath}");
// Get content
var startupContent = await File.ReadAllTextAsync(filePath);
var startup = JsonConvert.DeserializeObject <StartupInitializeModel>(startupContent);
// Apply settings
var updateConnectionResult =
await settingsService.UpdateConnectionString(startup.InitialSettings);
if (!updateConnectionResult.Success)
{
throw new Exception("Init error: " + updateConnectionResult.Message);
}
var adminSettingsUpdateModel = new AdminSettingsModel
{
S3SettingsModel = startup.S3SettingsModel,
SMTPSettingsModel = startup.SMTPSettingsModel,
SdkSettingsModel = startup.SdkSettingsModel,
SendGridSettingsModel = startup.SendGridSettingsModel,
SwiftSettingsModel = startup.SwiftSettingsModel,
};
var updateAdminSettingsResult =
await settingsService.UpdateAdminSettings(adminSettingsUpdateModel);
if (!updateAdminSettingsResult.Success)
{
throw new Exception("Init error: " + updateAdminSettingsResult.Message);
}
EnabledPlugins = PluginHelper.GetPlugins(_defaultConnectionString);
DisabledPlugins = PluginHelper.GetDisablePlugins(_defaultConnectionString);
// Enable plugins
foreach (var pluginId in startup.PluginsList)
{
var pluginObject = DisabledPlugins.FirstOrDefault(x => x.PluginId == pluginId);
if (pluginObject != null)
{
var contextFactory = new BaseDbContextFactory();
await using var dbContext =
contextFactory.CreateDbContext(new[] { _defaultConnectionString });
var eformPlugin = await dbContext.EformPlugins
.Where(x => x.Status == (int)PluginStatus.Disabled)
.FirstOrDefaultAsync(x => x.PluginId == pluginObject.PluginId);
if (eformPlugin != null)
{
eformPlugin.Status = (int)PluginStatus.Enabled;
dbContext.EformPlugins.Update(eformPlugin);
await dbContext.SaveChangesAsync();
var pluginMenu = pluginObject.GetNavigationMenu(scope.ServiceProvider);
// Load to database all navigation menu from plugin by id
var pluginMenuItemsLoader = new PluginMenuItemsLoader(dbContext, pluginId);
pluginMenuItemsLoader.Load(pluginMenu);
}
}
}
// not need because settingsService.UpdateAdminSettings call restart
// Restart(); // restart IF some plugins has been enabled
}
else if (args.Any())
{
Log.LogEvent("Try initialize from args");
var defaultConfig = new ConfigurationBuilder()
.AddCommandLine(args)
.AddEnvironmentVariables(prefix: "ASPNETCORE_")
.Build();
var firstName = defaultConfig.GetValue("FirstName", "");
var lastName = defaultConfig.GetValue("LastName", "");
var email = defaultConfig.GetValue("Email", "");
var password = defaultConfig.GetValue("Password", "");
var token = defaultConfig.GetValue("Token", "");
if (!string.IsNullOrEmpty(token) && !string.IsNullOrEmpty(firstName) &&
!string.IsNullOrEmpty(lastName) && !string.IsNullOrEmpty(email) &&
!string.IsNullOrEmpty(password))
{
var sdkConnectionString = _defaultConnectionString.Replace("_Angular", "_SDK");
// get customer number
const RegexOptions options = RegexOptions.Multiline | RegexOptions.CultureInvariant;
const string pattern = @"[D|d]atabase=(\D*)(\d*)_Angular";
if (int.TryParse(Regex.Match(_defaultConnectionString, pattern, options).Groups[^ 1].Value,
out var customerNumber))
{
var adminTools = new AdminTools(sdkConnectionString);
// Setup SDK DB
await adminTools.DbSetup(token);
var core = new Core();
await core.StartSqlOnly(sdkConnectionString);
await core.SetSdkSetting(Settings.customerNo, customerNumber.ToString());
// setup admin
var adminSetupModel = new AdminSetupModel()
{
DarkTheme = false,
FirstName = firstName,
LastName = lastName,
Email = email,
Password = password,
};
var contextFactory = new BaseDbContextFactory();
await using var dbContext =
contextFactory.CreateDbContext(new[] { _defaultConnectionString });
var connectionStringsSdk =
scope.ServiceProvider.GetRequiredService <IDbOptions <ConnectionStringsSdk> >();
await connectionStringsSdk.UpdateDb(
options => { options.SdkConnection = sdkConnectionString; }, dbContext);
await SeedAdminHelper.SeedAdmin(adminSetupModel,
"", dbContext);
Restart();
}
}
}
}
}
public OperationResult UpdateConnectionString(InitialSettingsModel initialSettingsModel)
{
if (!ModelState.IsValid)
{
return(new OperationResult(false, "Required fields are not filled"));
}
var inputPath = System.Web.Hosting.HostingEnvironment.MapPath("~/bin/Input.txt");
AdminTools adminTools;
var sdkConnectionString = "Data Source="
+ initialSettingsModel.ConnectionStringSdk.Source + ";Initial Catalog="
+ initialSettingsModel.ConnectionStringSdk.Catalogue + ";"
+ initialSettingsModel.ConnectionStringSdk.Auth;
var mainConnectionString = "Data Source="
+ initialSettingsModel.ConnectionStringMain.Source + ";Initial Catalog="
+ initialSettingsModel.ConnectionStringMain.Catalogue + ";"
+ initialSettingsModel.ConnectionStringMain.Auth;
try
{
if (File.Exists(inputPath))
{
//File.Delete(inputPath);
//var fileStream = File.Create(inputPath);
//fileStream.Dispose();
return(new OperationResult(false, "Connection string already exist"));
}
var fileStream = File.Create(inputPath);
fileStream.Dispose();
File.WriteAllText(inputPath, sdkConnectionString);
}
catch (Exception exception)
{
Logger.Error(exception.Message);
return(new OperationResult(false, "Could not write connection string in /bin/Input.txt"));
}
try
{
adminTools = new AdminTools(sdkConnectionString);
}
catch (Exception exception)
{
Logger.Error(exception.Message);
return(new OperationResult(false, "SDK connection string is invalid"));
}
var configuration = WebConfigurationManager.OpenWebConfiguration("~");
var section = (ConnectionStringsSection)configuration.GetSection("connectionStrings");
section.ConnectionStrings["eFormMainConnection"].ConnectionString = mainConnectionString;
try
{
configuration.Save();
ConfigurationManager.RefreshSection("connectionStrings");
var migrationConfiguration = new EformMigrationsConfiguration(mainConnectionString)
{
TargetDatabase = new DbConnectionInfo(mainConnectionString, "System.Data.SqlClient")
};
var migrator = new DbMigrator(migrationConfiguration);
migrator.Update();
var settingsHelper = new SettingsHelper(mainConnectionString);
settingsHelper.CreateAdminUser(initialSettingsModel.AdminSetupModel);
}
catch (Exception exception)
{
Logger.Error(exception.Message);
return(new OperationResult(false, "Main connection string is invalid"));
}
adminTools.DbSetup(initialSettingsModel.ConnectionStringSdk.Token);
return(new OperationResult(true));
}
private void ip_button_Click(object sender, EventArgs e)
{
AdminTools.getIpByHostname(selectedComputer);
}
