コード例 #1
0
        public static void CheckException(Exception ex, MaterialProgressBar dataLoadProgressBar)
        {
            Tuple <Type, string> type = ExceptionData.ExceptionList.Find(e => e.Item1.IsInstanceOfType(ex));

            ExceptionMessageBox exceptionMessage = new ExceptionMessageBox(type.Item2);

            exceptionMessage.ShowDialog();
            dataLoadProgressBar.Value = 0;
        }
コード例 #2
0
        private void LoadConEmuDll(string asLibrary)
        {
            try
            {
                if (m_ConEmuHandle != IntPtr.Zero)
                {
                    return;
                }

                m_ConEmuHandle = LoadLibrary(asLibrary);
                if (m_ConEmuHandle == IntPtr.Zero)
                {
                    int error = Marshal.GetLastWin32Error();
                    ExceptionMessageBox box = new ExceptionMessageBox();
                    box.SetException("Unable to load the conemu library",
                                     "Failure while load the conemu library" + Environment.NewLine +
                                     "Library path: " + asLibrary + Environment.NewLine +
                                     "Last error code: " + error);
                    box.ShowDialog();
                    return;
                }

                const string fnNameOld      = "ConsoleMain3";
                IntPtr       ptrConsoleMain = GetProcAddress(m_ConEmuHandle, fnNameOld);

                const string fnNameNew   = "GuiMacro";
                IntPtr       ptrGuiMacro = GetProcAddress(m_ConEmuHandle, fnNameNew);

                if (ptrConsoleMain == IntPtr.Zero && ptrGuiMacro == IntPtr.Zero)
                {
                    int error = Marshal.GetLastWin32Error();
                    ExceptionMessageBox box = new ExceptionMessageBox();
                    box.SetException("Unable to load the conemu library",
                                     "Failure while getting the addresses of the methods in the conemu library" +
                                     Environment.NewLine +
                                     "Library path: " + asLibrary + Environment.NewLine +
                                     "Methods: ConsoleMain3, GuiMacro" + Environment.NewLine +
                                     "Last error code: " + error);
                    box.ShowDialog();

                    UnloadConEmuDll();
                    return;
                }

                m_fnGuiMacro     = (FGuiMacro)Marshal.GetDelegateForFunctionPointer(ptrGuiMacro, typeof(FGuiMacro));
                m_fnConsoleMain3 = (FConsoleMain3)Marshal.GetDelegateForFunctionPointer(ptrConsoleMain, typeof(FConsoleMain3));
            }
            catch (Exception error)
            {
                UnloadConEmuDll();

                ExceptionMessageBox box = new ExceptionMessageBox();
                box.SetException(error);
                box.ShowDialog();
            }
        }
        public static async Task <bool> UpdateSelectionAsync(int IdSel, List <string> TagToRemove)
        {
            try
            {
                string serverIP   = Properties.Settings.Default.ServerIp;
                int    serverPort = Properties.Settings.Default.ServerPort;

                string urlServer = "http://" + serverIP + ":" + serverPort;
                var    client    = new RestClient(urlServer);
                client.Authenticator = new HttpBasicAuthenticator(publicApiLogin, publicApiMdp);
                var request = new RestRequest("selections/" + IdSel, Method.GET);
                client.Timeout           = timeout;
                client.ReadWriteTimeout  = timeout;
                request.Timeout          = timeout;
                request.ReadWriteTimeout = timeout;
                var response = await client.ExecuteTaskAsync(request);

                if (response.IsSuccessful)
                {
                    var Selection = JsonSelectionList.DeserializedJsonAlone(response.Content);
                    if (Selection != null)
                    {
                        if (Selection.state == "closed")
                        {
                            return(false);
                        }

                        var request2 = new RestRequest("/selections/" + IdSel, Method.PUT);

                        foreach (string uid in TagToRemove)
                        {
                            request2.AddParameter("listOfTagPulled", uid);
                        }

                        var client2 = new RestClient(urlServer);
                        client2.Authenticator = new HttpBasicAuthenticator(privateApiLogin, privateApiMdp);
                        LogToFile.LogMessageToFile("------- Start Update selection --------");
                        var response2 = await client2.ExecuteTaskAsync(request2);

                        LogToFile.LogMessageToFile(response2.Content);
                        LogToFile.LogMessageToFile("------- End Updateselection --------");
                        return(response2.IsSuccessful);
                    }
                    return(false);
                }
                return(false);
            }
            catch (Exception error)
            {
                ExceptionMessageBox exp = new ExceptionMessageBox(error, "Error update selection");
                exp.ShowDialog();
                return(false);
            }
        }
        public static async Task <bool> UpdateUserAsync(string login)
        {
            try
            {
                string serverIP   = Properties.Settings.Default.ServerIp;
                int    serverPort = Properties.Settings.Default.ServerPort;
                string urlServer  = "http://" + serverIP + ":" + serverPort;
                var    client     = new RestClient(urlServer);
                client.Authenticator = new HttpBasicAuthenticator(publicApiLogin, publicApiMdp);
                var request  = new RestRequest("users/" + login, Method.GET);
                var response = await client.ExecuteTaskAsync(request);

                if (response.IsSuccessful)
                {
                    var User = JsonUserList.DeserializedJsonAlone(response.Content);
                    if (User != null)
                    {
                        var request2 = new RestRequest("users/" + login, Method.PUT);
                        var ctx      = await RemoteDatabase.GetDbContextAsync();

                        var dbUser = ctx.GrantedUsers.GetByServerId(User.user_id);
                        if (dbUser != null)
                        {
                            request2.AddParameter("login", dbUser.Login);
                            request2.AddParameter("password", dbUser.Password);
                            request2.AddParameter("lname", dbUser.LastName);
                            request2.AddParameter("fname", dbUser.FirstName);
                            request2.AddParameter("badge_num", dbUser.BadgeNumber);
                            var dbFingers = ctx.Fingerprints.Where(fp => fp.GrantedUserId == dbUser.GrantedUserId).ToList();

                            if (dbFingers != null)
                            {
                                foreach (SmartDrawerDatabase.DAL.Fingerprint fp in dbFingers)
                                {
                                    request2.AddParameter("finger_index", fp.Index.ToString());
                                    request2.AddParameter("ftemplate", fp.Template);
                                }
                            }
                            var response2 = await client.ExecuteTaskAsync(request2);

                            return(response2.IsSuccessful);
                        }
                    }
                    return(false);
                }
            }
            catch (Exception error)
            {
                ExceptionMessageBox exp = new ExceptionMessageBox(error, "Error update user");
                exp.ShowDialog();
            }
            return(false);
        }
コード例 #5
0
ファイル: frmCodeEditor.cs プロジェクト: daxnet/guluwin
 /// <summary>
 /// Occurs when the script is going to be run.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void EventHandler_Run(object sender, System.EventArgs e)
 {
     try
     {
         compiler__.ClearCodes();
         compiler__.AddCode(syntaxDocument1.Text);
         int ret = compiler__.Compile();
         Output.Clear();
         ErrorList.Clear();
         if (ret > 0)
         {
             foreach (CompilerError error in compiler__.Errors)
             {
                 ErrorLevel level = error.IsWarning ? ErrorLevel.elWarning : ErrorLevel.elError;
                 ErrorList.Add(level, error.ErrorNumber, error.ErrorText, error.Line);
             }
             Output.Add(SunnyChen.Gulu.Win.Properties.Resources.TEXT_ERR_COMPILE);
             ErrorList.Show();
         }
         else if (ret == 0)
         {
             Output.Add(SunnyChen.Gulu.Win.Properties.Resources.TEXT_COMPILE_OK);
             Output.Show();
             try
             {
                 compiler__.Run("Program", "Main");
             }
             catch (Exception ex)
             {
                 //ExceptionMessageBox.ShowDialog(ex);
                 Exception param = ex.InnerException == null ? ex : ex.InnerException;
                 ExceptionMessageBox.ShowDialog(param, true);
             }
         }
         else if (ret == -1)
         {
             Output.Add(SunnyChen.Gulu.Win.Properties.Resources.TEXT_ERR_NO_CODE);
             Output.Show();
         }
         else
         {
             Output.Add(SunnyChen.Gulu.Win.Properties.Resources.TEXT_ERR_COMPILE_GENERAL);
             Output.Show();
         }
     }
     catch
     {
         throw;
     }
 }
        public static async Task <List <Device> > GetCabinets()
        {
            try
            {
                string serverIP   = Properties.Settings.Default.ServerIp;
                int    serverPort = Properties.Settings.Default.ServerPort;

                string urlServer = "http://" + serverIP + ":" + serverPort;
                var    client    = new RestClient(urlServer);
                client.Authenticator = new HttpBasicAuthenticator(publicApiLogin, publicApiMdp);
                var request = new RestRequest("cabinets", Method.GET);
                client.Timeout           = timeout;
                client.ReadWriteTimeout  = timeout;
                request.Timeout          = timeout;
                request.ReadWriteTimeout = timeout;
                var response = await client.ExecuteTaskAsync(request);

                if (response.IsSuccessful)
                {
                    List <Device> lstDevice = new List <Device>();
                    var           devices   = JsonDevice.DeserializedJsonList(response.Content);
                    if ((devices != null) && (devices.Count() > 0))
                    {
                        foreach (JsonDevice jd in devices)
                        {
                            Device newDev = new Device
                            {
                                DeviceName     = jd.name,
                                DeviceSerial   = jd.serial_num,
                                DeviceLocation = jd.Location,
                                IpAddress      = jd.IP_addr,
                            };
                            lstDevice.Add(newDev);
                        }
                    }
                    return(lstDevice);
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception error)
            {
                ExceptionMessageBox exp = new ExceptionMessageBox(error, "Get Cabinet ");
                exp.ShowDialog();
                return(null);
            }
        }
コード例 #7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnOK_Click(object sender, System.EventArgs e)
        {
            using (new LengthyOperation(this))
            {
                try
                {
                    System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
                    // Sets preference settings
                    PreferenceConfigHandler preferenceHandler = (PreferenceConfigHandler)config.GetSection("PreferenceConfig");
                    preferenceHandler.SearchRecursivly   = chkSearchRecursivly.Checked;
                    preferenceHandler.FileTreeShowFiles  = chkShowFiles.Checked;
                    preferenceHandler.FileTreeShowHidden = chkShowHidden.Checked;
                    preferenceHandler.FileTreeShowSystem = chkShowSystem.Checked;

                    // Sets backup settings
                    BackupConfigHandler backupHandler = (BackupConfigHandler)config.GetSection("BackupConfig");
                    backupHandler.BackupDirectory = txtBackupDirectory.Text;
                    backupHandler.EnableBackup    = chkEnableBackup.Checked;

                    // Sets editor and compiler settings
                    EditorCompilerConfigHandler editorCompilerConfigHandler = (EditorCompilerConfigHandler)config.GetSection("EditorCompilerConfig");
                    editorCompilerConfigHandler.CompilerTypeName = txtCodeDomCompilerType.Text;
                    if (cbSimpleTemplate.SelectedItem.ToString().Equals(Resources.TEXT_NOT_SPECIFIED) ||
                        cbGTemplate.SelectedItem.ToString().Equals(Resources.TEXT_NOT_SPECIFIED) ||
                        cbSyntaxFile.SelectedItem.ToString().Equals(Resources.TEXT_NOT_SPECIFIED))
                    {
                        MessageBox.Show(Resources.TEXT_SCRIPT_MUST_SPECIFY,
                                        Resources.TEXT_ERROR,
                                        MessageBoxButtons.OK,
                                        MessageBoxIcon.Error);

                        // forbid closing
                        DialogResult = DialogResult.None;
                        return;
                    }
                    editorCompilerConfigHandler.SimpleTemplate = cbSimpleTemplate.SelectedItem.ToString();
                    editorCompilerConfigHandler.GTemplate      = cbGTemplate.SelectedItem.ToString();
                    editorCompilerConfigHandler.SyntaxFileName = cbSyntaxFile.SelectedItem.ToString();

                    config.Save(ConfigurationSaveMode.Full);
                    DialogResult = DialogResult.OK;
                }
                catch (Exception ex)
                {
                    ExceptionMessageBox.ShowDialog(ex, true);
                }
            }
        }
コード例 #8
0
        public bool CheckConEmuAndDisplay()
        {
            bool result = CheckConEmu();

            if (result == false)
            {
                var conemu = GetConEmuExecutable();
                ExceptionMessageBox box = new ExceptionMessageBox();
                box.SetException("Unable to find the ConEmu installation",
                                 "Please set the paths of your ConEmu installation in the Visual Studio options pane" +
                                 Environment.NewLine + Environment.NewLine +
                                 "ConEmu Path: " + conemu + Environment.NewLine);
                box.ShowDialog();
            }
            return(result);
        }
コード例 #9
0
ファイル: App.xaml.cs プロジェクト: Pretorer/Drachenhorn
        private void Application_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
        {
            e.Handled = true;

            try
            {
                var logger = SimpleIoc.Default.GetInstance <ILogService>().GetLogger <App>();
                logger.Fatal("Some crash occurred.", e.Exception);
            }
            catch (InvalidOperationException)
            {
            }

            var window = new ExceptionMessageBox(e.Exception, "Im Programm ist ein Fehler aufgetreten.", true);

            window.ShowDialog();
        }
        public static async Task <Device> GetCabinet(string serial)
        {
            try
            {
                Properties.Settings.Default.Reload();
                string serverIP   = Properties.Settings.Default.ServerIp;
                int    serverPort = Properties.Settings.Default.ServerPort;

                string urlServer = "http://" + serverIP + ":" + serverPort;
                var    client    = new RestClient(urlServer);
                client.Authenticator = new HttpBasicAuthenticator(publicApiLogin, publicApiMdp);
                var request = new RestRequest("cabinets/" + serial, Method.GET);
                client.Timeout           = timeout;
                client.ReadWriteTimeout  = timeout;
                request.Timeout          = timeout;
                request.ReadWriteTimeout = timeout;
                var response = await client.ExecuteTaskAsync(request);

                if (response.IsSuccessful)
                {
                    var device = JsonDevice.DeserializedJsonAlone(response.Content);
                    if (device != null)
                    {
                        Device newDev = new Device
                        {
                            DeviceName     = device.name,
                            DeviceSerial   = device.serial_num,
                            DeviceLocation = device.Location,
                            IpAddress      = device.IP_addr,
                        };
                        return(newDev);
                    }
                    return(null);
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception error)
            {
                ExceptionMessageBox exp = new ExceptionMessageBox(error, "Error in Get Cabinet");
                exp.ShowDialog();
                return(null);
            }
        }
コード例 #11
0
        protected override void OnStartup(StartupEventArgs args)
        {
            Dispatcher.UnhandledException += (sender, e) =>
            {
                //new Window1().Show();
                //var errorMessage = string.Format("An exception occurred: {0}",
                //    e.Exception.Message + Environment.NewLine + e.Exception.StackTrace);
                //MessageBox.Show(errorMessage, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                e.Handled = true;
                var window = new ExceptionMessageBox(e.Exception, "AN UNHANDLED EXCEPTION HAS OCCURED.");
                window.ShowDialog();
            };

            BackgroundRunner.Init();
            BackgroundRunner.Run(Repository.Instance.Refresh);
            BackgroundRunner.Run(Repository.Instance.LoadQueryHierarchy);

            base.OnStartup(args);
        }
コード例 #12
0
        private void MenuItemCallback(object sender, EventArgs e)
        {
            try
            {
                var window = (FastFileAccessWindow)this.package.FindToolWindow(typeof(FastFileAccessWindow), 0, true);
                if ((null == window) || (null == window.Frame))
                {
                    throw new NotSupportedException("Cannot create tool window");
                }

                IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
                Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
            }
            catch (Exception error)
            {
                ExceptionMessageBox box = new ExceptionMessageBox();
                box.SetException(error);
                box.ShowDialog();
            }
        }
コード例 #13
0
        private async void PopulateDeviceGranted()
        {
            try
            {
                DataDeviceAvailable.Clear();
                DataDeviceGranted.Clear();
                if (SelectedGrantedUser != null)
                {
                    var ctx = await RemoteDatabase.GetDbContextAsync();

                    var user = ctx.GrantedUsers.Find(SelectedGrantedUser.Id);
                    if (user != null)
                    {
                        var lstDev = ctx.GrantedAccesses.GetByUser(user);
                        foreach (var dv in lstDev)
                        {
                            DataDeviceGranted.Add(dv.Device);
                        }

                        foreach (var dv in DataDevice)
                        {
                            if (DataDeviceGranted.Where(d => d.DeviceId == dv.DeviceId).FirstOrDefault() == null)
                            {
                                DataDeviceAvailable.Add(dv);
                            }
                        }
                    }

                    ctx.Database.Connection.Close();
                    ctx.Dispose();
                }
            }
            catch (Exception error)
            {
                await mainview0.Dispatcher.BeginInvoke(new System.Action(() =>
                {
                    ExceptionMessageBox exp = new ExceptionMessageBox(error, "Error in Populate Device");
                    exp.ShowDialog();
                }));
            }
        }
        public static async Task <bool> CreateCabinet(Device dev)
        {
            try
            {
                string serverIP   = Properties.Settings.Default.ServerIp;
                int    serverPort = Properties.Settings.Default.ServerPort;

                string urlServer = "http://" + serverIP + ":" + serverPort;
                var    client    = new RestClient(urlServer);
                client.Authenticator = new HttpBasicAuthenticator(publicApiLogin, publicApiMdp);
                var request = new RestRequest("cabinets/", Method.POST);
                client.Timeout           = timeout;
                client.ReadWriteTimeout  = timeout;
                request.Timeout          = timeout;
                request.ReadWriteTimeout = timeout;
                request.AddParameter("serial_num", dev.DeviceSerial);
                request.AddParameter("name", dev.DeviceName);
                request.AddParameter("location", dev.DeviceLocation);

                // If default parameter is nul get found IP
                if (string.IsNullOrEmpty(Properties.Settings.Default.NotificationIp))
                {
                    request.AddParameter("IP_addr", dev.IpAddress);
                }
                else
                {
                    request.AddParameter("IP_addr", Properties.Settings.Default.NotificationIp);
                }
                request.AddParameter("port", Properties.Settings.Default.NotificationPort);

                var response = await client.ExecuteTaskAsync(request);

                return(response.IsSuccessful);
            }
            catch (Exception error)
            {
                ExceptionMessageBox exp = new ExceptionMessageBox(error, "Error Delete Selection");
                exp.ShowDialog();
                return(false);
            }
        }
        public static async Task <JsonSku> GetSkuInfo(string skuQueried)
        {
            try
            {
                Properties.Settings.Default.Reload();
                string serverIP   = Properties.Settings.Default.ServerIp;
                int    serverPort = Properties.Settings.Default.ServerPort;

                string urlServer = "http://" + serverIP + ":" + serverPort;
                var    client    = new RestClient(urlServer);
                client.Authenticator = new HttpBasicAuthenticator(privateApiLogin, privateApiMdp);
                var request = new RestRequest("sku", Method.GET);
                client.Timeout           = timeout;
                client.ReadWriteTimeout  = timeout;
                request.Timeout          = timeout;
                request.ReadWriteTimeout = timeout;
                request.AddParameter("refNumber", skuQueried);
                var response = await client.ExecuteTaskAsync(request);

                if (response.IsSuccessful)
                {
                    var skuInfo = JsonSku.DeserializedJsonAlone(response.Content);
                    if (skuInfo != null)
                    {
                        return(skuInfo);
                    }
                    return(null);
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception error)
            {
                ExceptionMessageBox exp = new ExceptionMessageBox(error, "Error in Get sku");
                exp.ShowDialog();
                return(null);
            }
        }
コード例 #16
0
        public void Execute(string asWhere, string asMacro)
        {
            try
            {
                if (m_ConEmuHandle == IntPtr.Zero)
                {
                    return;
                }

                new Thread(() =>
                {
                    Thread.CurrentThread.IsBackground = true;
                    ExecuteHelper(asWhere, asMacro);
                }).Start();
            }
            catch (Exception error)
            {
                ExceptionMessageBox box = new ExceptionMessageBox();
                box.SetException(error);
                box.ShowDialog();
            }
        }
コード例 #17
0
        /// <summary>
        /// Crea el mensaje de error y lo muestra
        /// </summary>
        /// <param name="ex"></param>
        /// <param name="handlingInstanceId"></param>
        /// <returns></returns>
        private DialogResult ShowThreadExceptionDialog(Exception exception, Guid handlingInstanceId)
        {
            //Capturar las excepciones para las cuales no se quiere mostrar el dialogo de exception, sino un mensaje estandar
            if (exception is PPPNegocioException)
            {
                MessageHelper.MostrarMensajeAlerta(exception.Message);
                return DialogResult.OK;
            }

            //Capturar las excepciones para las cuales se muestra la innerException
            if (exception.InnerException != null)
            {
                if (exception.InnerException is SqlException)
                {
                    exception = exception.InnerException;
                }
            }

            var form = new ExceptionMessageBox(exception.Message);

            return form.ShowDialog();
        }
コード例 #18
0
        public void OpenConEmuToolWindow()
        {
            if (this.Package == null || this.Package.Zombied)
            {
                return;
            }

            try
            {
                if (CheckConEmuAndDisplay() == false)
                {
                    return;
                }

                var window = this.Package.FindToolWindow(typeof(ConEmuWindow), 0, true) as ConEmuWindow;
                if (window?.Frame == null)
                {
                    throw new NotSupportedException("Cannot create tool window");
                }

                ThreadHelper.ThrowIfNotOnUIThread();

                IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
                ErrorHandler.ThrowOnFailure(windowFrame.Show());

                if (IsConEmuToolWindowVisible(windowFrame) == false)
                {
                    window.RunConEmu();
                }
            }
            catch (Exception error)
            {
                ExceptionMessageBox box = new ExceptionMessageBox();
                box.SetException(error);
                box.ShowDialog();
            }
        }
コード例 #19
0
        public bool RunConEmu()
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            try
            {
                if (ProductEnvironment.Instance.ConEmu == null || m_HasExited)
                {
                    RunConEmuSession();
                }
                else
                {
                    DisableMaxMinCloseButtons();
                }
                return(true);
            }
            catch (Exception error)
            {
                ExceptionMessageBox box = new ExceptionMessageBox();
                box.SetException(error);
                box.ShowDialog();
            }
            return(false);
        }
コード例 #20
0
        private async void PopulateUser()
        {
            try
            {
                var ctx = await RemoteDatabase.GetDbContextAsync();

                var lstDev = ctx.GrantedUsers
                             .Where(u => u.UserRankId > 1).ToList();

                EditedUser = new UsersViewModel();
                DataUser.Clear();
                foreach (var dv in lstDev)
                {
                    UsersViewModel uvm = new UsersViewModel()
                    {
                        Id           = dv.GrantedUserId,
                        Login        = dv.Login,
                        FirstName    = dv.FirstName,
                        LastName     = dv.LastName,
                        BadgeId      = dv.BadgeNumber,
                        Fingerprints = dv.Fingerprints.Count
                    };
                    DataUser.Add(uvm);
                }
                ctx.Database.Connection.Close();
                ctx.Dispose();
            }
            catch (Exception error)
            {
                await mainview0.Dispatcher.BeginInvoke(new System.Action(() =>
                {
                    ExceptionMessageBox exp = new ExceptionMessageBox(error, "Error in Populate Device");
                    exp.ShowDialog();
                }));
            }
        }
コード例 #21
0
        private async void myDatagrid_Loaded(object sender, RoutedEventArgs e)
        {
            try
            {
                var ctx = await RemoteDatabase.GetDbContextAsync();

                if (ctx.Columns != null && ctx.Columns.Count() > 0)
                {
                    foreach (Column col in ctx.Columns)
                    {
                        myDatagrid.Columns[col.ColumnIndex].IsHidden   = false;
                        myDatagrid.Columns[col.ColumnIndex].HeaderText = col.ColumnName;
                    }
                }
                myDatagrid.Columns["Drawer"].IsHidden = false;
                ctx.Database.Connection.Close();
                ctx.Dispose();
            }
            catch (Exception err)
            {
                ExceptionMessageBox exp = new ExceptionMessageBox(err, "Error Datagrid loaded");
                exp.ShowDialog();
            }
        }
コード例 #22
0
        private void ExecuteHelper(string asWhere, string asMacro)
        {
            try
            {
                if (m_fnGuiMacro != null)
                {
                    IntPtr bstrPtr = IntPtr.Zero;
                    int    result  = m_fnGuiMacro.Invoke(asWhere, asMacro, out bstrPtr);
                    if (result != 133 /*CERR_GUIMACRO_SUCCEEDED*/ || result != 134 /*CERR_GUIMACRO_FAILED*/)
                    {
                        return; // Sucess
                    }

                    ExceptionMessageBox box = new ExceptionMessageBox();
                    box.SetException("Invoke GuiMacro method failed",
                                     "Failure while invoke the GuiMacro of the conemu library" + Environment.NewLine +
                                     "Result code: " + result);
                    box.ShowDialog();

                    if (bstrPtr != IntPtr.Zero)
                    {
                        Marshal.FreeBSTR(bstrPtr);
                    }
                }
                else
                {
                    ExecuteLegacy(asWhere, asMacro);
                }
            }
            catch (Exception error)
            {
                ExceptionMessageBox box = new ExceptionMessageBox();
                box.SetException(error);
                box.ShowDialog();
            }
        }
コード例 #23
0
        public void OnProjectChanged(string path, string[] filter)
        {
            this.treeViewExplorer.BeginUpdate();

            this._model = new TreeModel();

            BaseNode rootNode = new BaseNode("UDK");

            this._model.Nodes.Add(rootNode);

            try
            {
                PopulateTree(path, rootNode, filter);
            }
            catch (Exception e)
            {
                ExceptionMessageBox msgBox = new ExceptionMessageBox(e);
                msgBox.ShowDialog();
            }

            this.treeViewExplorer.Model = _model;
            this.treeViewExplorer.EndUpdate();

            foreach (TreeNodeAdv node in this.treeViewExplorer.Root.Children)
            {
                node.Expand();
            }
        }
コード例 #24
0
ファイル: frmGScriptManager.cs プロジェクト: daxnet/guluwin
 public void EventHandler_Run(object sender, System.EventArgs e)
 {
     try
     {
         TreeNode node = gscriptTreeView.SelectedNode;
         if (node != null)
         {
             ScriptTreeNodeProperty prop = (ScriptTreeNodeProperty)node.Tag;
             if (prop != null)
             {
                 if (prop.Type == ScriptTreeNodeType.G ||
                     prop.Type == ScriptTreeNodeType.Simple)
                 {
                     ScriptType type;
                     type = prop.Type == ScriptTreeNodeType.G ? ScriptType.G : ScriptType.Simple;
                     string code = scriptRepository__.GetContent(prop.Name, type);
                     compiler__.ClearCodes();
                     compiler__.AddCode(code);
                     int ret = compiler__.Compile();
                     Output.Clear();
                     ErrorList.Clear();
                     if (ret > 0)
                     {
                         foreach (CompilerError error in compiler__.Errors)
                         {
                             ErrorLevel level = error.IsWarning ? ErrorLevel.elWarning : ErrorLevel.elError;
                             ErrorList.Add(level, error.ErrorNumber, error.ErrorText, error.Line);
                         }
                         Output.Add(Resources.TEXT_ERR_COMPILE);
                         ErrorList.Show();
                     }
                     else if (ret == 0)
                     {
                         Output.Add(Resources.TEXT_COMPILE_OK);
                         Output.Show();
                         try
                         {
                             compiler__.Run("Program", "Main");
                         }
                         catch (Exception ex)
                         {
                             //ExceptionMessageBox.ShowDialog(ex);
                             Exception param = ex.InnerException == null ? ex : ex.InnerException;
                             ExceptionMessageBox.ShowDialog(param, true);
                         }
                     }
                     else if (ret == -1)
                     {
                         Output.Add(Resources.TEXT_ERR_NO_CODE);
                         Output.Show();
                     }
                     else
                     {
                         Output.Add(Resources.TEXT_ERR_COMPILE_GENERAL);
                         Output.Show();
                     }
                 }
             }
         }
     }
     catch
     {
         throw;
     }
 }
        public static async Task <bool> GetAndStoreSelectionAsync()
        {
            try
            {
                string serverIP   = Properties.Settings.Default.ServerIp;
                int    serverPort = Properties.Settings.Default.ServerPort;

                string urlServer = "http://" + serverIP + ":" + serverPort;
                var    client    = new RestClient(urlServer);
                client.Authenticator = new HttpBasicAuthenticator(publicApiLogin, publicApiMdp);
                var request = new RestRequest("selections", Method.GET);
                client.Timeout           = timeout;
                client.ReadWriteTimeout  = timeout;
                request.Timeout          = timeout;
                request.ReadWriteTimeout = timeout;
                var response = await client.ExecuteTaskAsync(request);

                if (response.IsSuccessful)
                {
                    var ctx = await RemoteDatabase.GetDbContextAsync();

                    ctx.PullItems.Clear();
                    await ctx.SaveChangesAsync();

                    lock (somePublicStaticObject)
                    {
                        var lstSelection = JsonSelectionList.DeserializedJsonList(response.Content);
                        if ((lstSelection != null) && (lstSelection.Length > 0))
                        {
                            foreach (var sel in lstSelection)
                            {
                                if (sel == null)
                                {
                                    LogToFile.LogMessageToFile("------- Start Error in selection --------");
                                    LogToFile.LogMessageToFile(response.Content);
                                    LogToFile.LogMessageToFile("------- End Error in selection --------");
                                    break;
                                }
                            }
                            lastSelection = lstSelection;
                        }
                        else
                        {
                            lastSelection = null;
                        }
                        ctx.Database.Connection.Close();
                        ctx.Dispose();
                        return(true);
                    }
                }
                return(false);
            }
            catch (DbEntityValidationException e)
            {
                foreach (var eve in e.EntityValidationErrors)
                {
                    Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                                      eve.Entry.Entity.GetType().Name, eve.Entry.State);
                    foreach (var ve in eve.ValidationErrors)
                    {
                        Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                                          ve.PropertyName, ve.ErrorMessage);
                    }
                }
                return(false);
            }
            catch (Exception error)
            {
                ExceptionMessageBox exp = new ExceptionMessageBox(error, "Error getting selection");
                exp.ShowDialog();
                return(false);
            }
        }
コード例 #26
0
        internal void ParseScript(string file)
        {
            this.treeViewOutline.BeginUpdate();

            this._model = new TreeModel();
            this._outline = ScriptOutline.CreateFromScript(file);

            if (this._outline != null)
            {
                BookmarkNode rootNode = new BookmarkNode(this._outline.Class, BookmarkNode.Categories.Class, null);

                this._model.Nodes.Add(rootNode);

                try
                {
                    BookmarkNode replicationNode = new BookmarkNode("Replication", BookmarkNode.Categories.Replication, this._outline.Replication);
                    rootNode.Nodes.Add(replicationNode);

                    BookmarkNode defaultPropertiesNode = new BookmarkNode("Default Properties", BookmarkNode.Categories.DefaultProperties, this._outline.DefaultProperties);
                    rootNode.Nodes.Add(defaultPropertiesNode);

                    BookmarkNode varsNode = new BookmarkNode("Variables", BookmarkNode.Categories.Group, null);
                    rootNode.Nodes.Add(varsNode);

                    foreach (ScriptOutline.VarDesc scriptVar in this._outline.Variables)
                    {
                        BookmarkNode varNode = new BookmarkNode(scriptVar.Identifier, BookmarkNode.Categories.Variable, scriptVar);
                        varsNode.Nodes.Add(varNode);
                    }

                    BookmarkNode stateNode = null;
                    Dictionary<string, BookmarkNode> states = new Dictionary<string, BookmarkNode>();
                    BookmarkNode functionsNode = new BookmarkNode("Functions", BookmarkNode.Categories.Group, null);
                    rootNode.Nodes.Add(functionsNode);

                    states.Clear();
                    stateNode = new BookmarkNode("\tGlobal", BookmarkNode.Categories.State, null);
                    states["\tGlobal"] = stateNode;
                    functionsNode.Nodes.Add(stateNode);

                    foreach (ScriptOutline.StateDesc scriptState in this._outline.States)
                    {
                        stateNode = new BookmarkNode(scriptState.Identifier, BookmarkNode.Categories.State, scriptState);
                        states[scriptState.Identifier] = stateNode;
                        functionsNode.Nodes.Add(stateNode);
                    }

                    foreach (ScriptOutline.FunctionDesc scriptFunction in this._outline.Functions)
                    {
                        BookmarkNode functionNode = new BookmarkNode(scriptFunction.Identifier, BookmarkNode.Categories.Function, scriptFunction);

                        if (states.TryGetValue(scriptFunction.State, out stateNode))
                        {
                            stateNode.Nodes.Add(functionNode);
                        }
                    }

                    BookmarkNode eventsNode = new BookmarkNode("Events", BookmarkNode.Categories.Group, null);
                    rootNode.Nodes.Add(eventsNode);

                    states.Clear();
                    stateNode = new BookmarkNode("\tGlobal", BookmarkNode.Categories.State, null);
                    states["\tGlobal"] = stateNode;
                    eventsNode.Nodes.Add(stateNode);

                    foreach (ScriptOutline.StateDesc scriptState in this._outline.States)
                    {
                        stateNode = new BookmarkNode(scriptState.Identifier, BookmarkNode.Categories.State, scriptState);
                        states[scriptState.Identifier] = stateNode;
                        eventsNode.Nodes.Add(stateNode);
                    }

                    foreach (ScriptOutline.EventDesc scriptEvent in this._outline.Events)
                    {
                        BookmarkNode eventNode = new BookmarkNode(scriptEvent.Identifier, BookmarkNode.Categories.Event, scriptEvent);

                        if (states.TryGetValue(scriptEvent.State, out stateNode))
                        {
                            stateNode.Nodes.Add(eventNode);
                        }
                    }
                }
                catch (Exception e)
                {
                    ExceptionMessageBox msgBox = new ExceptionMessageBox(e);
                    msgBox.ShowDialog();
                }
            }

            this.treeViewOutline.Model = _model;
            this.treeViewOutline.EndUpdate();

            foreach (TreeNodeAdv node in this.treeViewOutline.Root.Children)
            {
                node.Expand();
            }
        }
        public static async Task <bool> GetAndStoreUserAsync()
        {
            try
            {
                string serverIP   = Properties.Settings.Default.ServerIp;
                int    serverPort = Properties.Settings.Default.ServerPort;

                //serverIP = "157.230.97.196";
                //serverPort = 3000;

                string urlServer = "http://" + serverIP + ":" + serverPort;
                var    client    = new RestClient(urlServer);
                client.Authenticator = new HttpBasicAuthenticator(publicApiLogin, publicApiMdp);
                var request = new RestRequest("/users", Method.GET);
                client.Timeout           = timeout;
                client.ReadWriteTimeout  = timeout;
                request.Timeout          = timeout;
                request.ReadWriteTimeout = timeout;

                var response = await client.ExecuteTaskAsync(request);

                if (response.IsSuccessful)
                {
                    // remove  granted standard users
                    var ctx = await RemoteDatabase.GetDbContextAsync();

                    /* ctx.GrantedAccesses.Clear();
                    *  await ctx.SaveChangesAsync();*/

                    //get device
                    Device mydev = ctx.Devices.GetBySerialNumber(Properties.Settings.Default.WallSerial);

                    if (mydev == null)
                    {
                        return(false);
                    }

                    var lstUser = JsonUserList.DeserializedJsonList(response.Content);
                    if ((lstUser != null) && (lstUser.Length > 0))
                    {
                        foreach (JsonUserList jsl in lstUser)
                        {
                            var original  = ctx.GrantedUsers.GetByServerId(jsl.user_id);
                            var original2 = ctx.GrantedUsers.GetByLogin(jsl.login);
                            if ((original != null) && (original.Login != "Admin"))
                            {
                                TimeSpan ts = jsl.updated_at - original.UpdateAt;
                                if (Math.Abs(ts.TotalSeconds) > 1)  // Not the latest but avoid ms
                                {
                                    original.ServerGrantedUserId = jsl.user_id;
                                    original.Login            = jsl.login;
                                    original.Password         = jsl.password;
                                    original.FirstName        = jsl.fname;
                                    original.LastName         = jsl.lname;
                                    original.BadgeNumber      = string.IsNullOrEmpty(jsl.badge_num) ? "000000" : jsl.badge_num;
                                    original.UserRankId       = 3;
                                    original.UpdateAt         = jsl.updated_at;
                                    ctx.Entry(original).State = EntityState.Modified;
                                    await ctx.SaveChangesAsync();

                                    //deletefingerprint for this user if exists

                                    var fpUser = ctx.Fingerprints.Where(gu => gu.GrantedUserId == original.GrantedUserId).ToList();
                                    if ((fpUser != null) && (fpUser.Count > 0))
                                    {
                                        foreach (SmartDrawerDatabase.DAL.Fingerprint fp in fpUser)
                                        {
                                            ctx.Fingerprints.Remove(fp);
                                        }
                                        await ctx.SaveChangesAsync();
                                    }

                                    if ((jsl.ftemplate != null) & (jsl.ftemplate.Count > 0))
                                    {
                                        for (int loop = 0; loop < jsl.ftemplate.Count; loop++)
                                        {
                                            if (!string.IsNullOrEmpty(jsl.ftemplate[loop]) && !string.IsNullOrEmpty(jsl.finger_index[loop]))
                                            {
                                                ctx.Fingerprints.Add(new SmartDrawerDatabase.DAL.Fingerprint
                                                {
                                                    GrantedUserId = original.GrantedUserId,
                                                    Index         = Convert.ToInt32(jsl.finger_index[loop]),
                                                    Template      = jsl.ftemplate[loop],
                                                });
                                            }
                                        }
                                        await ctx.SaveChangesAsync();
                                    }
                                    ctx.GrantedAccesses.AddOrUpdateAccess(original, mydev, ctx.GrantTypes.All());
                                    await ctx.SaveChangesAsync();
                                }
                            }
                            else if (original2 != null)
                            {
                                TimeSpan ts = jsl.updated_at - original2.UpdateAt;
                                if (Math.Abs(ts.TotalSeconds) > 1)  // Not the latest but avoid ms
                                {
                                    original2.ServerGrantedUserId = jsl.user_id;
                                    original2.Login            = jsl.login;
                                    original2.Password         = jsl.password;
                                    original2.FirstName        = jsl.fname;
                                    original2.LastName         = jsl.lname;
                                    original2.BadgeNumber      = string.IsNullOrEmpty(jsl.badge_num) ? "000000" : jsl.badge_num;
                                    original2.UserRankId       = 3;
                                    original2.UpdateAt         = jsl.updated_at;
                                    ctx.Entry(original2).State = EntityState.Modified;
                                    await ctx.SaveChangesAsync();

                                    //deletefingerprint for this user if exists

                                    var fpUser = ctx.Fingerprints.Where(gu => gu.GrantedUserId == original2.GrantedUserId).ToList();
                                    if ((fpUser != null) && (fpUser.Count > 0))
                                    {
                                        foreach (SmartDrawerDatabase.DAL.Fingerprint fp in fpUser)
                                        {
                                            ctx.Fingerprints.Remove(fp);
                                        }
                                        await ctx.SaveChangesAsync();
                                    }

                                    if ((jsl.ftemplate != null) & (jsl.ftemplate.Count > 0))
                                    {
                                        for (int loop = 0; loop < jsl.ftemplate.Count; loop++)
                                        {
                                            if (!string.IsNullOrEmpty(jsl.ftemplate[loop]) && !string.IsNullOrEmpty(jsl.finger_index[loop]))
                                            {
                                                ctx.Fingerprints.Add(new SmartDrawerDatabase.DAL.Fingerprint
                                                {
                                                    GrantedUserId = original2.GrantedUserId,
                                                    Index         = Convert.ToInt32(jsl.finger_index[loop]),
                                                    Template      = jsl.ftemplate[loop],
                                                });
                                            }
                                        }
                                        await ctx.SaveChangesAsync();
                                    }
                                    ctx.GrantedAccesses.AddOrUpdateAccess(original2, mydev, ctx.GrantTypes.All());
                                    await ctx.SaveChangesAsync();
                                }
                            }
                            else if ((original == null) && (original2 == null))
                            {
                                GrantedUser newUser = new GrantedUser()
                                {
                                    ServerGrantedUserId = jsl.user_id,
                                    Login       = jsl.login,
                                    Password    = jsl.password,
                                    FirstName   = jsl.fname,
                                    LastName    = jsl.lname,
                                    BadgeNumber = string.IsNullOrEmpty(jsl.badge_num) ? "000000" : jsl.badge_num,
                                    UpdateAt    = jsl.updated_at,
                                    UserRankId  = 3,
                                };
                                ctx.GrantedUsers.Add(newUser);
                                await ctx.SaveChangesAsync();

                                if ((jsl.ftemplate != null) & (jsl.ftemplate.Count > 0))
                                {
                                    for (int loop = 0; loop < jsl.ftemplate.Count; loop++)
                                    {
                                        if (!string.IsNullOrEmpty(jsl.ftemplate[loop]) && !string.IsNullOrEmpty(jsl.finger_index[loop]))
                                        {
                                            ctx.Fingerprints.Add(new SmartDrawerDatabase.DAL.Fingerprint
                                            {
                                                GrantedUserId = newUser.GrantedUserId,
                                                Index         = Convert.ToInt32(jsl.finger_index[loop]),
                                                Template      = jsl.ftemplate[loop],
                                            });
                                        }
                                    }
                                    await ctx.SaveChangesAsync();
                                }
                                ctx.GrantedAccesses.AddOrUpdateAccess(newUser, mydev, ctx.GrantTypes.All());
                                await ctx.SaveChangesAsync();
                            }
                        }
                        ctx.Database.Connection.Close();
                        ctx.Dispose();
                        return(true);
                    }
                    return(true);
                }
                return(false);
            }
            catch (DbEntityValidationException e)
            {
                foreach (var eve in e.EntityValidationErrors)
                {
                    Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                                      eve.Entry.Entity.GetType().Name, eve.Entry.State);
                    foreach (var ve in eve.ValidationErrors)
                    {
                        Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                                          ve.PropertyName, ve.ErrorMessage);
                    }
                }
                throw;
            }
            catch (Exception error)
            {
                ExceptionMessageBox exp = new ExceptionMessageBox(error, "Error getting user");
                exp.ShowDialog();
                return(false);
            }
        }
コード例 #28
0
ファイル: ExceptionDialog.cs プロジェクト: rlefever68/Broobu
        public static bool Execute(ExceptionInfo info)
        {
            var f = new ExceptionMessageBox(info.TheException, info.TheException.Message);

            return(f.ShowDialog() == true);
        }
コード例 #29
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void frmConfiguration_Load(object sender, System.EventArgs e)
        {
            try
            {
                cbSimpleTemplate.Items.Clear();
                cbGTemplate.Items.Clear();
                cbSyntaxFile.Items.Clear();

                // Populates values
                DirectoryInfo directoryInfo = new DirectoryInfo(Directories.ScriptsPath);

                FileInfo[] simpleTemplates = directoryInfo.GetFiles("*.simpletemplate");
                foreach (FileInfo simpleTemplate in simpleTemplates)
                {
                    cbSimpleTemplate.Items.Add(simpleTemplate.Name);
                }
                cbSimpleTemplate.Items.Add(Resources.TEXT_NOT_SPECIFIED);

                FileInfo[] gTemplates = directoryInfo.GetFiles("*.gtemplate");
                foreach (FileInfo gTemplate in gTemplates)
                {
                    cbGTemplate.Items.Add(gTemplate.Name);
                }
                cbGTemplate.Items.Add(Resources.TEXT_NOT_SPECIFIED);

                DirectoryInfo rootDirectoryInfo = new DirectoryInfo(Directories.ApplicationPath);
                FileInfo[]    syntaxFiles       = rootDirectoryInfo.GetFiles("*.syn");
                foreach (FileInfo syntaxFile in syntaxFiles)
                {
                    cbSyntaxFile.Items.Add(syntaxFile.Name);
                }
                cbSyntaxFile.Items.Add(Resources.TEXT_NOT_SPECIFIED);

                cbSimpleTemplate.SelectedIndex = 0;
                cbGTemplate.SelectedIndex      = 0;
                cbSyntaxFile.SelectedIndex     = 0;

                // Loads configurations
                System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
                // Gets preference settings
                PreferenceConfigHandler preferenceConfigHandler = (PreferenceConfigHandler)config.GetSection("PreferenceConfig");
                chkSearchRecursivly.Checked = preferenceConfigHandler.SearchRecursivly;
                chkShowFiles.Checked        = preferenceConfigHandler.FileTreeShowFiles;
                chkShowHidden.Checked       = preferenceConfigHandler.FileTreeShowHidden;
                chkShowSystem.Checked       = preferenceConfigHandler.FileTreeShowSystem;

                // Gets backup settings
                BackupConfigHandler backupConfigHandler = (BackupConfigHandler)config.GetSection("BackupConfig");
                chkEnableBackup.Checked = backupConfigHandler.EnableBackup;
                txtBackupDirectory.Text = backupConfigHandler.BackupDirectory;

                // Gets editor and compiler settings
                EditorCompilerConfigHandler editorCompilerConfigHandler = (EditorCompilerConfigHandler)config.GetSection("EditorCompilerConfig");
                txtCodeDomCompilerType.Text = editorCompilerConfigHandler.CompilerTypeName;
                if (!cbSimpleTemplate.Items.Contains(editorCompilerConfigHandler.SimpleTemplate))
                {
                    cbSimpleTemplate.SelectedItem = Resources.TEXT_NOT_SPECIFIED;
                }
                else
                {
                    cbSimpleTemplate.SelectedItem = editorCompilerConfigHandler.SimpleTemplate;
                }
                if (!cbGTemplate.Items.Contains(editorCompilerConfigHandler.GTemplate))
                {
                    cbGTemplate.SelectedItem = Resources.TEXT_NOT_SPECIFIED;
                }
                else
                {
                    cbGTemplate.SelectedItem = editorCompilerConfigHandler.GTemplate;
                }
                if (!cbSyntaxFile.Items.Contains(editorCompilerConfigHandler.SyntaxFileName))
                {
                    cbSyntaxFile.SelectedItem = Resources.TEXT_NOT_SPECIFIED;
                }
                else
                {
                    cbSyntaxFile.SelectedItem = editorCompilerConfigHandler.SyntaxFileName;
                }
            }
            catch (Exception ex)
            {
                ExceptionMessageBox.ShowDialog(ex, true);
            }
        }