Esempio n. 1
0
        /// ------------------------------------------------------------------------------------------------
        ///
        /// ------------------------------------------------------------------------------------------------
        /// Name		GetContentType
        ///
        /// <summary>	Gets the content type header value based on the ContentType enum.
        /// </summary>
        /// <param name="contentType">		The ContentType enum.</param>
        ///
        /// <remarks>
        /// </remarks>
        /// ------------------------------------------------------------------------------------------------
        ///
        public string GetContentType(ContentType contentType)
        {
            try
            {
                switch (contentType)
                {
                case ContentType.BinaryData:
                    return("application/octet-stream");

                case ContentType.Json:
                    return("application/json");

                case ContentType.Xml:
                    return("application/xml");

                default:
                    return("text/plain");
                }
            }
            catch (Exception ex)
            {
                LogTracking.LogTrace(ex.ToString());
                return(null);
            }
        }
Esempio n. 2
0
        /// ------------------------------------------------------------------------------------------------
        /// Name		GetDocumentType
        ///
        /// <summary>	Gets the document type mime for the particular file extension.
        /// </summary>
        /// <param name="fileExtension">	The file extension.</param>
        ///
        /// <returns>	string.
        /// </returns>
        /// <remarks>
        /// </remarks>
        /// ------------------------------------------------------------------------------------------------
        ///
        public static string GetDocumentType(this string fileExtension)
        {
            try
            {
                string source;
                //
                switch (fileExtension)
                {
                case ".txt":
                case ".csv":
                    source = "txt.png";
                    break;

                case ".doc":
                case ".docx":
                    source = "doc.png";
                    break;

                case ".gif":
                case ".jpeg":
                case ".jpg":
                case ".png":
                case ".tiff":
                case ".tif":
                case ".bmp":
                    source = "png.png";
                    break;

                case ".pdf":
                    source = "pdf.png";
                    break;

                case ".mp3":
                case ".wav":
                    source = "mp3.png";
                    break;

                case ".mp4":
                    source = "mp4.png";
                    break;

                case ".xls":
                case ".xlsx":
                    source = "xls.png";
                    break;

                default:
                    source = "others.png";
                    break;
                }
                return(source);
            }
            catch (Exception ex)
            {
                LogTracking.LogTrace(ex.ToString());
                return(null);
            }
        }
 ///
 /// ------------------------------------------------------------------------------------------------
 /// Name		RequestResponseEventArgs
 ///
 /// <summary>	Creates a new instance of the RequestResponseEventArgs class.
 /// </summary>
 /// <param name="data">					The valid response data.</param>
 ///
 /// <remarks>
 /// </remarks>
 /// ------------------------------------------------------------------------------------------------
 ///
 public RequestResponseEventArgs(byte[] data)
 {
     try
     {
         Data = data;
     }
     catch (Exception ex)
     {
         LogTracking.LogTrace(ex.ToString());
     }
 }
 /// ------------------------------------------------------------------------------------------------
 #region Public Constructors
 /// ------------------------------------------------------------------------------------------------
 ///
 /// ------------------------------------------------------------------------------------------------
 /// Name		RequestResponseEventArgs
 ///
 /// <summary>	Creates a new instance of the RequestResponseEventArgs class.
 /// </summary>
 /// <param name="responseString"> The valid response string.</param>
 ///
 /// <remarks>
 /// </remarks>
 /// ------------------------------------------------------------------------------------------------
 ///
 public RequestResponseEventArgs(string responseString)
 {
     try
     {
         Text = responseString;
     }
     catch (Exception ex)
     {
         LogTracking.LogTrace(ex.ToString());
     }
 }
Esempio n. 5
0
 ///
 /// ------------------------------------------------------------------------------------------------
 /// Name		AddAuthHeader
 ///
 /// <summary>	Adds an authorisation header
 /// </summary>
 /// <param name="token">		The authorisation token.</param>
 ///
 /// <remarks>
 /// </remarks>
 /// ------------------------------------------------------------------------------------------------
 ///
 public void AddAuthHeader(string token)
 {
     try
     {
         AddHeader("Authorization", string.Format("Bearer {0}", token));
     }
     catch (Exception ex)
     {
         LogTracking.LogTrace(ex.ToString());
     }
 }
Esempio n. 6
0
        /// ------------------------------------------------------------------------------------------------
        #region Public Constructor
        /// ------------------------------------------------------------------------------------------------
        ///

        /// ------------------------------------------------------------------------------------------------
        /// Name		ServieClient
        ///
        /// <summary>	Creates a new instance of the ServiceClient class.
        /// </summary>
        /// <remarks>
        /// </remarks>
        /// ------------------------------------------------------------------------------------------------
        ///
        public ServiceClient()
        {
            try
            {
                m_oHeaders = new Dictionary <string, string>();
            }
            catch (Exception ex)
            {
                LogTracking.LogTrace(ex.ToString());
            }
        }
Esempio n. 7
0
 /// ------------------------------------------------------------------------------------------------
 #region Static Constructor
 /// ------------------------------------------------------------------------------------------------
 ///
 /// <summary>  It is used to check the network status and update it.
 /// </summary>
 /// ------------------------------------------------------------------------------------------------
 ///
 static Reachability()
 {
     try
     {
         HostName = "www.google.com";
     }
     catch (Exception ex)
     {
         LogTracking.LogTrace(ex.ToString());
     }
 }
Esempio n. 8
0
 public static float?RevertMt(string miles, string decMiles)
 {
     try
     {
         float?value = Convert.ToInt32(miles) + Convert.ToSingle(decMiles);
         return(value == 0 ? null : value);
     }
     catch (Exception ex)
     {
         LogTracking.LogTrace(ex.ToString());
         return(null);
     }
 }
 ///
 /// ------------------------------------------------------------------------------------------------
 /// Name		RequestResponseEventArgs
 ///
 /// <summary>	Creates a new instance of the RequestResponseEventArgs class.
 /// </summary>
 /// <param name="ex">					The error exception.</param>
 /// <param name="url">					The Url that caused the error.</param>
 ///
 /// <remarks>
 /// </remarks>
 /// ------------------------------------------------------------------------------------------------
 ///
 public RequestResponseEventArgs(Exception ex, string url)
 {
     try
     {
         AuthenticationError = false;
         Error       = ex;
         Url         = url;
         Body        = "";
         RequestType = "GET";
     }
     catch (Exception e)
     {
         LogTracking.LogTrace(e.ToString());
     }
 }
Esempio n. 10
0
 ///
 /// ------------------------------------------------------------------------------------------------
 /// Name		IsHostReachable
 ///
 /// <summary>	Is the host reachable with the current network configuration.
 /// </summary>
 /// <param name="host">			The host.</param>
 ///
 /// <returns>	If it's reachable.
 /// </returns>
 /// ------------------------------------------------------------------------------------------------
 ///
 public static async Task <bool> IsHostReachable(string host)
 {
     try
     {
         if (string.IsNullOrEmpty(host))
         {
             return(false);
         }
         return(await CrossConnectivity.Current.IsReachable(host));
     }
     catch (Exception ex)
     {
         LogTracking.LogTrace(ex.ToString());
         return(false);
     }
 }
Esempio n. 11
0
        /// ------------------------------------------------------------------------------------------------
        #region Public Functions, Properties and Methods
        /// ------------------------------------------------------------------------------------------------
        ///

        /// ------------------------------------------------------------------------------------------------
        /// Name		AddHeader
        ///
        /// <summary>	Adds a header value to the ServiceClient class to be used on future requests.
        /// </summary>
        /// <param name="name">			The name of the header.</param>
        /// <param name="value">		The value for the header.</param>
        ///
        /// <remarks>
        /// </remarks>
        /// ------------------------------------------------------------------------------------------------
        ///
        public void AddHeader(string name, string value)
        {
            try
            {
                if (m_oHeaders.ContainsKey(name))
                {
                    m_oHeaders[name] = value;
                }
                else
                {
                    m_oHeaders.Add(name, value);
                }
            }
            catch (Exception ex)
            {
                LogTracking.LogTrace(ex.ToString());
            }
        }
Esempio n. 12
0
        public static Tuple <string, string> ToConvertHt(this float?value)
        {
            try
            {
                Tuple <string, string> htValue;

                var splitValue = String.Format("{0:.00}", value).Split('.');
                var htHours    = (!string.IsNullOrWhiteSpace(splitValue[0]) ? splitValue[0] + "h" : null);
                var htMin      = splitValue.Length > 1 ? GetMinutesFromValue(splitValue) + "m" : null;

                htValue = new Tuple <string, string>(htHours, htMin);

                return(htValue);
            }
            catch (Exception ex)
            {
                LogTracking.LogTrace(ex.ToString());
                return(null);
            }
        }
Esempio n. 13
0
        public static Tuple <string, string> ToConvertMt(this float?value)
        {
            try
            {
                Tuple <string, string> mtValue;

                var splitValue = String.Format("{0:.00}", value).Split('.');
                var mtMiles    = (!string.IsNullOrWhiteSpace(splitValue[0]) ? splitValue[0] : null);
                var mtDec      = splitValue.Length > 1 ? "." + splitValue[1] : null;

                mtValue = new Tuple <string, string>(mtMiles, mtDec);

                return(mtValue);
            }
            catch (Exception ex)
            {
                LogTracking.LogTrace(ex.ToString());
                return(null);
            }
        }
 ///
 /// ------------------------------------------------------------------------------------------------
 /// Name		RequestResponseEventArgs
 ///
 /// <summary>	Creates a new instance of the RequestResponseEventArgs class.
 /// </summary>
 /// <param name="ex">				The web error exception.</param>
 /// <param name="url">				The Url that caused the error.</param>
 ///
 /// <remarks>
 /// </remarks>
 /// ------------------------------------------------------------------------------------------------
 ///
 public RequestResponseEventArgs(HttpRequestException ex, string url)
 {
     try
     {
         AuthenticationError = false;
         Error = ex;
         if (ex.Message != null)
         {
             if (ServiceClient.StatCode == HttpStatusCode.Unauthorized)
             {
                 AuthenticationError = true;
             }
             Text = ex.Message;
         }
         Url         = url;
         Body        = "";
         RequestType = "GET";
     }
     catch (Exception e)
     {
         LogTracking.LogTrace(e.ToString());
     }
 }
Esempio n. 15
0
 /// ------------------------------------------------------------------------------------------------
 /// Name		OnNetworkChanged
 ///
 /// <summary>	Executes when the network type is changed.
 /// </summary>
 /// <remarks>
 /// </remarks>
 /// ------------------------------------------------------------------------------------------------
 ///
 public static void OnNetworkChanged(object sender, Plugin.Connectivity.Abstractions.ConnectivityChangedEventArgs e)
 {
     try
     {
         LoginPage login = new LoginPage();
         SplitView.Instace().UpdateStatus();
         login.MakeReady();
         if ((Application.Current.MainPage.ToString() == "ServiceRequest.Pages.SplitView") && (InternetConnectionStatus() == ReachabilityNetworkStatus.NotReachable))
         {
             DocumentListView.StopProcess?.Invoke();
             //PropertySummary.ShowMatchAddress.Invoke(false);
         }
         else
         {
             //PropertySummary.ShowMatchAddress.Invoke(true);
         }
         FullMapView.NewCaseAddView?.LoadButton();
     }
     catch (Exception ex)
     {
         LogTracking.LogTrace(ex.ToString());
     }
 }
Esempio n. 16
0
        ///
        /// ------------------------------------------------------------------------------------------------
        /// Name		UploadStringAsync
        ///
        /// <summary>	Asynchronously uploads string content to the url.
        /// </summary>
        /// <param name="url">		The url for the request.</param>
        /// <param name="isPut">	Where the method is PUT or POST.</param>
        /// <param name="content">	The string content of the request.</param>
        /// <param name="contentType"></param>
        /// <param name="firstTry">	Indicates that this is the first try at the request.</param>
        ///
        /// <remarks>
        /// </remarks>
        /// ------------------------------------------------------------------------------------------------
        public async Task <RequestResponseEventArgs> UploadStringAsync(string url,
                                                                       bool isPut,
                                                                       string content,
                                                                       ContentType contentType,
                                                                       bool firstTry = true)
        {
            HttpClient client;
            RequestResponseEventArgs args;
            string response;

            //HttpResponseMessage result;
            //string response;
            //
            try
            {
                client   = new HttpClient(new NativeMessageHandler());
                StatCode = HttpStatusCode.InternalServerError;
                foreach (string name in m_oHeaders.Keys)
                {
                    client.DefaultRequestHeaders.Add(name, m_oHeaders[name]);
                }
                //
                StringContent       stringContent = new StringContent(content, Encoding.UTF8, GetContentType(contentType));
                HttpResponseMessage result        = isPut ? await client.PutAsync(url, stringContent) : await client.PostAsync(url, stringContent);

                if (result.IsSuccessStatusCode)
                {
                    response = await result.Content.ReadAsStringAsync();

                    args = new RequestResponseEventArgs(response);
                }
                else
                {
                    StatCode = result.StatusCode;
                    if (result.StatusCode == HttpStatusCode.Unauthorized)
                    {
                        throw new HttpRequestException();
                    }
                    else
                    {
                        if (result.Content != null)
                        {
                            response = await result.Content.ReadAsStringAsync();
                        }
                        else
                        {
                            response = result.ReasonPhrase;
                        }
                        //
                        throw new Exception(response);
                    }
                }
            }
            catch (HttpRequestException ex)
            {
                if (firstTry && ex.Message.Contains("(ReadDone2)"))
                {
                    await Task.Delay(500);

                    return(await UploadStringAsync(url, isPut, content, contentType, false));
                }
                args = new RequestResponseEventArgs(ex, url);
                LogTracking.LogTrace(ex.ToString());
            }
            catch (Exception ex)
            {
                args = new RequestResponseEventArgs(ex, url);
                LogTracking.LogTrace(ex.ToString());
            }
            //
            if (args.Error != null)
            {
                args.Body        = content;
                args.RequestType = isPut ? "PUT" : "POST";
            }
            //
            return(args);
        }
Esempio n. 17
0
        ///
        /// ------------------------------------------------------------------------------------------------
        /// Name		UploadDataAsync
        ///
        /// <summary>	Asynchronously uploads data to the url.
        /// </summary>
        /// <param name="url">		The url for the request.</param>
        /// <param name="isPut">	Whether the method is PUT or POST.</param>
        /// <param name="data">		The data content for the request.</param>
        /// <param name="contentType"></param>
        /// <param name="firstTry">	Indicates that this is the first try at the request.</param>
        ///
        /// <remarks>
        /// </remarks>
        /// ------------------------------------------------------------------------------------------------
        public async Task <RequestResponseEventArgs> UploadDataAsync(string url,
                                                                     bool isPut,
                                                                     byte[] data,
                                                                     ContentType contentType,
                                                                     bool firstTry = true)
        {
            HttpClient client;
            RequestResponseEventArgs args;
            HttpResponseMessage      result;

            byte[] response;
            string stringException;

            try
            {
                client   = new HttpClient(new NativeMessageHandler());
                StatCode = HttpStatusCode.InternalServerError;

                foreach (string name in m_oHeaders.Keys)
                {
                    client.DefaultRequestHeaders.Add(name, m_oHeaders[name]);
                }
                ByteArrayContent byteContent = new ByteArrayContent(data);
                byteContent.Headers.Add("Content-Type", GetContentType(contentType));
                result = isPut ? await client.PutAsync(url, byteContent) : await client.PostAsync(url, byteContent);

                if (result.IsSuccessStatusCode)
                {
                    response = await result.Content.ReadAsByteArrayAsync();

                    args = new RequestResponseEventArgs(response);
                }
                else
                {
                    StatCode = result.StatusCode;
                    if (result.StatusCode == HttpStatusCode.Unauthorized)
                    {
                        throw new HttpRequestException();
                    }
                    else
                    {
                        if (result.Content != null)
                        {
                            stringException = await result.Content.ReadAsStringAsync();
                        }
                        else
                        {
                            stringException = result.ReasonPhrase;
                        }

                        throw new Exception(stringException);
                    }
                }

                args = new RequestResponseEventArgs(response);
            }
            catch (HttpRequestException ex)
            {
                if (firstTry && ex.Message.Contains("(ReadDone2)"))
                {
                    await Task.Delay(500);

                    return(await UploadDataAsync(url, isPut, data, contentType, false));
                }
                args             = new RequestResponseEventArgs(ex, url);
                args.Body        = string.Format("Data content of length [{0}].", data.Length);
                args.RequestType = isPut ? "PUT" : "POST";
                LogTracking.LogTrace(ex.ToString());
            }
            catch (Exception ex)
            {
                args = new RequestResponseEventArgs(ex, url);
                LogTracking.LogTrace(ex.ToString());
            }

            return(args);
        }
Esempio n. 18
0
        ///
        /// ------------------------------------------------------------------------------------------------
        /// Name		DownloadDataAsync
        ///
        /// <summary>	Asynchronously downloads binary data from a url.
        /// </summary>
        /// <param name="url">		The Url for the request.</param>
        /// <param name="firstTry">	Indicates that this is the first try at the request.</param>
        ///
        /// <remarks>
        /// </remarks>
        /// ------------------------------------------------------------------------------------------------
        ///
        public async Task <RequestResponseEventArgs> DownloadDataAsync(string url, bool firstTry = true)
        {
            HttpClient client;
            RequestResponseEventArgs args;

            byte[] response;
            string stringException;

            //
            try
            {
                client   = new HttpClient(new NativeMessageHandler());
                StatCode = HttpStatusCode.InternalServerError;
                foreach (string name in m_oHeaders.Keys)
                {
                    client.DefaultRequestHeaders.Add(name, m_oHeaders[name]);
                }
                var result = await client.GetAsync(url);

                if (result.IsSuccessStatusCode)
                {
                    response = await result.Content.ReadAsByteArrayAsync();

                    args = new RequestResponseEventArgs(response);
                }
                else
                {
                    StatCode = result.StatusCode;
                    if (result.StatusCode == HttpStatusCode.Unauthorized)
                    {
                        throw new HttpRequestException();
                    }
                    else
                    {
                        if (result.Content != null)
                        {
                            stringException = await result.Content.ReadAsStringAsync();
                        }
                        else
                        {
                            stringException = result.ReasonPhrase;
                        }

                        throw new Exception(stringException);
                    }
                }
            }
            catch (HttpRequestException ex)
            {
                if (firstTry && ex.Message.Contains("(ReadDone2)"))
                {
                    await Task.Delay(500);

                    return(await DownloadDataAsync(url, false));
                }

                args = new RequestResponseEventArgs(ex, url);
                LogTracking.LogTrace(ex.ToString());
            }
            catch (Exception ex)
            {
                args = new RequestResponseEventArgs(ex, url);
                LogTracking.LogTrace(ex.ToString());
            }
            //
            return(args);
        }
Esempio n. 19
0
        /// ------------------------------------------------------------------------------------------------
        /// Name		GetContentType
        ///
        /// <summary>	Gets the content type mime for the particular file extension.
        /// </summary>
        /// <param name="fileExtension">	The file extension.</param>
        ///
        /// <returns>	string.
        /// </returns>
        /// <remarks>
        /// </remarks>
        /// ------------------------------------------------------------------------------------------------
        ///
        public static string GetContentType(this string fileExtension)
        {
            try
            {
                string sContentType;
                //
                switch (fileExtension)
                {
                case "bmp":
                    sContentType = "image/bmp";
                    break;

                case "csv":
                    sContentType = "text/plain";
                    break;

                case "doc":
                case "docx":
                    sContentType = "application/msword";
                    break;

                case "dxf":
                    sContentType = "application/dxf";
                    break;

                case "dwg":
                    sContentType = "application/dwg";
                    break;

                case "dwf":
                    sContentType = "application/dwf";
                    break;

                case "eps":
                    sContentType = "image/eps";
                    break;

                case "gif":
                    sContentType = "image/gif";
                    break;

                case "jpeg":
                case "jpg":
                    sContentType = "image/jpeg";
                    break;

                case "pdf":
                    sContentType = "application/pdf";
                    break;

                case "png":
                    sContentType = "image/png";
                    break;

                case "rtf":
                    sContentType = "application/rtf";
                    break;

                case "tif":
                case "tiff":
                    sContentType = "image/tiff";
                    break;

                case "mp3":
                case "wav":
                    sContentType = "audio/mp3";
                    break;

                case "mp4":
                    sContentType = "video/mp4";
                    break;

                case "txt":
                    sContentType = "text/plain";
                    break;

                case "xls":
                case "xlsx":
                    sContentType = "application/msexcel";
                    break;

                default:
                    sContentType = "text/plain";
                    break;
                }
                return(sContentType);
            }
            catch (Exception ex)
            {
                LogTracking.LogTrace(ex.ToString());
                return(null);
            }
        }