private VATRP.Core.Model.VATRPCredential GetAuthentication()
        {
            AuthenticationView _authForm = new AuthenticationView();

            _authForm.ShowDialog();
            if (!_authForm.Proceed)
            {
                return(null);
            }
            VATRPCredential tempCred = new VATRPCredential();

            tempCred.username = _authForm.Username;
            tempCred.password = _authForm.Password;
            return(tempCred);
        }
        public void SendXMLToServer(string xmlContents)
        {
            VATRPCredential credentials = GetAuthentication();

            Task.Run(async() =>
            {
                try
                {
                    await PostLocationToServer(xmlContents, credentials, GeolocationPostURI);
                }
                catch (Exception ex)
                {
                }
                finally
                {
                    await Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = null));
                }
            });
        }
 private async Task PostLocationToServer(string location, VATRPCredential credentials, string uri)
 {
     if (string.IsNullOrEmpty(uri))
     {
         string           msg     = "No geolocation uri is set";
         string           caption = "Load failed";
         MessageBoxButton button  = MessageBoxButton.OK;
         System.Windows.MessageBox.Show(msg, caption, button, MessageBoxImage.Error);
     }
     try
     {
         await Utilities.JsonWebRequest.MakeXmlWebPostAuthenticatedAsync(uri, credentials, location);
     }
     catch (Utilities.JsonException ex)
     {
         string           msg     = String.Format("Failed to post location file to the web server: {0}.", uri);
         string           caption = "Load failed";
         MessageBoxButton button  = MessageBoxButton.OK;
         System.Windows.MessageBox.Show(msg, caption, button, MessageBoxImage.Error);
     }
 }
        /// <summary>
        /// Async authenticated XML POST request.
        /// </summary>
        /// <param name="webRequestUrl">string</param>
        /// <param name="cred">VATRPCredential</param>
        /// <param name="xml">string</param>
        /// <returns>void</returns>
        public static async Task MakeXmlWebPostAuthenticatedAsync(string webRequestUrl, VATRPCredential cred, string xml)
        {
            WebResponse response = null;

            try
            {
                // Specify TLS 1.2
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
                ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(AcceptAllCertifications);

                // Build basic authentication header
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(webRequestUrl);
                request.Credentials = new NetworkCredential(cred.username, cred.password);
                request.Headers["Authorization"] = "Basic " + Convert.ToBase64String(Encoding.Default.GetBytes(cred.username + ":" + cred.password));

                // Specify the rerquest properties
                request.KeepAlive   = false;
                request.Method      = "POST";
                request.Timeout     = 30000;
                request.ContentType = "application/xml";

                StreamWriter sw = new StreamWriter(request.GetRequestStream());
                sw.WriteLine(xml);
                sw.Close();

                response = await request.GetResponseAsync();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Async authenticated XML GET request.
        /// </summary>
        /// <typeparam name="T">T</typeparam>
        /// <param name="webRequestUrl">string</param>
        /// <param name="cred">VATRPCredential</param>
        /// <returns>Task<T></returns>
        public static async Task <T> MakeXmlWebRequestAuthenticatedAsync <T>(string webRequestUrl, VATRPCredential cred)
        {
            WebResponse response = null;

            try
            {
                // Specify TLS 1.2
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
                ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(AcceptAllCertifications);

                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(webRequestUrl);
                request.Credentials     = new NetworkCredential(cred.username, cred.password);
                request.PreAuthenticate = true;
                request.KeepAlive       = false;
                request.ContentLength   = 0;
                request.Method          = "GET";
                request.Timeout         = 30000;

                response = await request.GetResponseAsync();

                string        xmlResults = string.Empty;
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                using (StreamReader sr = new StreamReader(response.GetResponseStream()))
                {
                    try
                    {
                        T item = (T)serializer.Deserialize(sr);
                        return(item);
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                    finally
                    {
                        sr.Close();
                        if (response != null)
                        {
                            response.Close();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Exemple #6
0
        /// <summary>
        /// Method to export contacts to remote uri. Generates the
        /// xml format for the contacts and provides that to the
        /// method used to generate the POST request.
        /// </summary>
        /// <param name="uri">string</param>
        /// <param name="cred">VATRPCredential</param>
        /// <returns>void</returns>
        private async Task ExecuteRemoteExport(string uri, VATRPCredential cred)
        {
            var cardWriter = new vCardWriter();

            this.MyContacts        = new ContactList();
            this.MyContacts.VCards = new List <vCard>();

            foreach (var contactVM in this.Contacts)
            {
                var card = new vCard()
                {
                    GivenName     = contactVM.Contact.Fullname,
                    FormattedName = contactVM.Contact.Fullname,
                    Title         = contactVM.Contact.RegistrationName
                };

                card.Telephone.Uri = contactVM.Contact.RegistrationName;

                this.MyContacts.VCards.Add(card);
            }

            // Add the namespaces
            XmlSerializerNamespaces ns = new XmlSerializerNamespaces();

            ns.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
            ns.Add("xsd", "http://www.w3.org/2001/XMLSchema");
            this.MyContacts.Namespaces = ns;

            // Serialize contacts into xml string
            if (this.MyContacts.VCards != null)
            {
                XmlAttributes atts = new XmlAttributes();
                atts.Xmlns = true;

                XmlAttributeOverrides xover = new XmlAttributeOverrides();
                xover.Add(typeof(List <vCard>), "Namespaces", atts);

                XmlSerializer xsSubmit = new XmlSerializer(typeof(List <vCard>), xover);

                var xml = "";

                //XmlWriterSettings settings = new XmlWriterSettings();
                //settings.OmitXmlDeclaration = true; // is this necessary?

                using (var sww = new StringWriter())
                {
                    using (XmlWriter writer = XmlWriter.Create(sww))
                    {
                        xsSubmit.Serialize(writer, this.MyContacts.VCards);
                        xml = sww.ToString();                        // the final xml output
                        xml = xml.Replace("ArrayOfVcard", "vcards"); // replace incorrect tag with correct one
                        xml = xml.Replace("utf-16", "utf-8");        // TODO - fix this with formatting
                    }
                }

                try
                {
                    await JsonWebRequest.MakeXmlWebPostAuthenticatedAsync(uri, cred, xml);
                }
                catch (JsonException ex)
                {
                    Debug.WriteLine($"ERROR -- Failed to POST contacts to {uri}.");
                }
            }
        }
Exemple #7
0
        /// <summary>
        /// Method called when the export button clicked. Prompts
        /// the user if they want to export the contacts to a
        /// remote location or local one and then calls the
        /// relevant methods to complete the request.
        /// </summary>
        /// <param name="obj">object</param>
        /// <returns>void</returns>
        private void ExecuteExportCommand(object obj)
        {
            //**************************************************************************************************************
            // Exporting Vcard contact from contact list.
            //**************************************************************************************************************
            if (ServiceManager.Instance.LinphoneService.VCardSupported && !ExportInProgress)
            {
                ExportInProgress = true;
                string           msg        = "To export your contacts to the Provider, please select Yes. Select No to export to local file system.";
                string           caption    = "Export Contacts";
                MessageBoxButton button     = MessageBoxButton.YesNoCancel;
                MessageBoxResult result     = MessageBox.Show(msg, caption, button, MessageBoxImage.Question);
                Dispatcher       Dispatcher = Dispatcher.CurrentDispatcher;

                switch (result)
                {
                // Remote Export
                case MessageBoxResult.Yes:
                    string uri = App.CurrentAccount.ContactsURI;
                    if (uri == string.Empty)
                    {
                        msg     = "Valid URI required to export contacts. Please go to the Settings, Account menu to input a valid URI.";
                        caption = "Import Contacts";
                        button  = MessageBoxButton.OK;
                        MessageBox.Show(msg, caption, button, MessageBoxImage.Error);
                        ExportInProgress = false;
                        break;
                    }
                    VATRPCredential contactsCredential = App.CurrentAccount.configuration.FindCredential("contacts", null) ?? GetAuthentication();
                    if (contactsCredential == null)
                    {
                        ExportInProgress = false; return;
                    }
                    exportTask = Task.Run(async() =>
                    {
                        try
                        {
                            await Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = Cursors.AppStarting));
                            await ExecuteRemoteExport(uri, contactsCredential);
                            await Dispatcher.BeginInvoke((Action) delegate()
                            {
                                msg     = "Upload Successful.";
                                caption = "Export Status";
                                button  = MessageBoxButton.OK;
                                MessageBox.Show(msg, caption, button, MessageBoxImage.Information);
                            });
                        }
                        catch (Exception ex)
                        {
                            await Dispatcher.BeginInvoke((Action) delegate()
                            {
                                msg     = "Upload failed.";
                                caption = "Export Error";
                                button  = MessageBoxButton.OK;
                                MessageBox.Show(msg, caption, button, MessageBoxImage.Error);
                            });
                        }
                        finally
                        {
                            await Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = null));
                            ExportInProgress = false;
                        }
                    });
                    break;

                // Local Export
                case MessageBoxResult.No:
                    exportTask = Task.Run((Action) delegate()
                    {
                        try
                        {
                            Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = Cursors.AppStarting));
                            ExecuteLocalExport();
                        }
                        catch (Exception ex)
                        {
                            Dispatcher.BeginInvoke((Action) delegate()
                            {
                                msg     = "Contacts export failed.";
                                caption = "Export Error";
                                button  = MessageBoxButton.OK;
                                MessageBox.Show(msg, caption, button, MessageBoxImage.Error);
                            });
                        }
                        finally
                        {
                            Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = null));
                            ExportInProgress = false;
                        }
                    });
                    break;

                case MessageBoxResult.Cancel:
                    ExportInProgress = false;
                    break;
                }
            }
        }
Exemple #8
0
        /// <summary>
        /// Method called when the import button clicked. Prompts
        /// the user if they want to import the contacts from a
        /// remote location or local one and then calls the
        /// relevant methods to complete the request.
        /// </summary>
        /// <param name="obj">object</param>
        /// <returns>void</returns>
        private void ExecuteImportCommand(object obj)
        {
            if (ServiceManager.Instance.LinphoneService.VCardSupported && !ImportInProgress)
            {
                ImportInProgress = true;
                string           msg        = "To download your contacts from the Provider, please select Yes. Select No to import from local file system.";
                string           caption    = "Import Contacts";
                MessageBoxButton button     = MessageBoxButton.YesNoCancel;
                MessageBoxResult result     = MessageBox.Show(msg, caption, button, MessageBoxImage.Question);
                Dispatcher       Dispatcher = Dispatcher.CurrentDispatcher;

                switch (result)
                {
                case MessageBoxResult.Yes:
                    string uri = App.CurrentAccount.ContactsURI;
                    if (uri == string.Empty)
                    {
                        msg     = "Valid URI required to import contacts. Please go to the Settings, Account menu to input a valid URI.";
                        caption = "Import Contacts";
                        button  = MessageBoxButton.OK;
                        MessageBox.Show(msg, caption, button, MessageBoxImage.Error);
                        ImportInProgress = false;
                        break;
                    }

                    importTask = Task.Run(async() =>
                    {
                        try
                        {
                            await Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = Cursors.AppStarting));
                            XmlDocument xDoc    = new XmlDocument();
                            xDoc                = await JsonWebRequest.MakeXmlWebRequestAsync <XmlDocument>(uri);
                            var recordsImported = ServiceManager.Instance.ContactService.ImportVcardFromXdoc(xDoc);
                        }
                        catch (Exception ex)
                        {
                            try
                            {
                                System.Net.HttpWebResponse response = ((ex as System.Net.WebException).Response) as System.Net.HttpWebResponse;
                                if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
                                {
                                    await Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = Cursors.AppStarting));
                                    VATRPCredential creds = App.CurrentAccount.configuration.FindCredential("contacts", null);
                                    if (creds == null)
                                    {
                                        await Dispatcher.BeginInvoke((Action) delegate()
                                        {
                                            creds = GetAuthentication();
                                        });
                                    }
                                    XmlDocument xDoc    = new XmlDocument();
                                    xDoc                = await JsonWebRequest.MakeXmlWebRequestAuthenticatedAsync <XmlDocument>(uri, creds);
                                    var recordsImported = ServiceManager.Instance.ContactService.ImportVcardFromXdoc(xDoc);
                                }
                                else
                                {
                                    throw;
                                }
                            }
                            catch
                            {
                                await Dispatcher.BeginInvoke((Action) delegate()
                                {
                                    msg     = ex.Message;
                                    caption = "Download failed";
                                    button  = MessageBoxButton.OK;
                                    MessageBox.Show(msg, caption, button, MessageBoxImage.Error);
                                });
                            }
                        }
                        finally
                        {
                            await Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = null));
                            ImportInProgress = false;
                        }
                    });
                    break;

                case MessageBoxResult.No:
                    importTask = Task.Run((Action) delegate()
                    {
                        try
                        {
                            Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = Cursors.AppStarting));
                            ExecuteLocalImport();
                        }
                        catch (Exception ex)
                        {
                            Dispatcher.BeginInvoke((Action) delegate()
                            {
                                msg     = "Contacts failed to load.";
                                caption = "Import Error";
                                button  = MessageBoxButton.OK;
                                MessageBox.Show(msg, caption, button, MessageBoxImage.Error);
                            });
                        }
                        finally
                        {
                            Dispatcher.BeginInvoke((Action)(() => Mouse.OverrideCursor = null));
                            ImportInProgress = false;
                        }
                    });
                    break;

                case MessageBoxResult.Cancel:
                    ImportInProgress = false;
                    break;
                }
            }
        }
        /// <summary>
        /// New login which handles remote configuration parsing.
        /// </summary>
        /// <param name="authId"></param>
        /// <param name="outboundProxy"></param>
        /// <param name="username"></param>
        /// <param name="addAccount"></param>
        private void Login_New(string authId, string outboundProxy, string username, bool addAccount)
        {
            //*********************************************************************************************************************************
            // Login in the VATRP application
            //*********************************************************************************************************************************
            VATRPCredential sipCredential = App.CurrentAccount.configuration.FindCredential("sip", username);

            if (sipCredential == null)
            {
                UserNameBox.Text = string.Empty;
                string           msg     = string.Format("VRS Account information is not present for {0}", Address);
                string           caption = "Error finding your account";
                MessageBoxButton button  = MessageBoxButton.OK;
                MessageBox.Show(msg, caption, button, MessageBoxImage.Stop);
                return;
            }

            App.CurrentAccount.AuthID               = sipCredential.username;
            App.CurrentAccount.OutboundProxy        = outboundProxy;
            App.CurrentAccount.Username             = sipCredential.username;
            App.CurrentAccount.RegistrationUser     = sipCredential.username;
            App.CurrentAccount.Password             = sipCredential.password;
            App.CurrentAccount.RegistrationPassword = sipCredential.password;
            App.CurrentAccount.ProxyHostname        = Address;
            App.CurrentAccount.HostPort             = HostPort;
            App.CurrentAccount.RememberPassword     = RememberPasswordBox.IsChecked ?? false;

            bool autoLogin = AutoLoginBox.IsChecked ?? false;

            ServiceManager.Instance.ConfigurationService.Set(Configuration.ConfSection.GENERAL,
                                                             Configuration.ConfEntry.AUTO_LOGIN, autoLogin);
            if (autoLogin)
            {
                App.CurrentAccount.StorePassword(ServiceManager.Instance.GetPWFile());
            }

            var transportText = TransportComboBox.SelectedItem as TextBlock;

            if (transportText != null)
            {
                App.CurrentAccount.Transport = transportText.Text;
            }

            if (LoginWithOld)
            {
                App.CurrentAccount.LoginMethod = "Old";
            }
            else
            {
                App.CurrentAccount.LoginMethod = "New";
            }

            ServiceManager.Instance.ConfigurationService.Set(Configuration.ConfSection.GENERAL,
                                                             Configuration.ConfEntry.ACCOUNT_IN_USE, App.CurrentAccount.AccountID);
            // cjm-aug17
            if (addAccount)
            {
                ServiceManager.Instance.AccountService.AddAccount(App.CurrentAccount);
            }

            ServiceManager.Instance.AccountService.Save();
            ServiceManager.Instance.RegisterNewAccount(App.CurrentAccount.AccountID);
        }