services.cs

微软的行业应用解决方案示例

                {
                    parameters = new Parameters();

                    foreach (OrderDetail currentDetail in order.OrderDetails)
                    {
                        _currentOrderDetail = currentDetail; // setup for trigger

                        if (currentDetail.ObjectState != ObjectState.Unchanged)
                        {
                            parameters.Clear();
                            parameters.Add("@OrderId", order.OrderId);
                            parameters.Add("@OrderDetailId", currentDetail.OrderDetailId);
                            switch (currentDetail.ObjectState)
                            {
                                case ObjectState.Delete:
                                    _dataStore.Save(StoredProcs.DeleteOrderDetail, parameters);
                                    break;
                                case ObjectState.Modify:
                                    parameters["@InventoryId"] = currentDetail.InventoryId;
                                    parameters["@Quantity"] = currentDetail.Quantity;
                                    _dataStore.Save(StoredProcs.UpdateOrderDetail, parameters);
                                    break;
                                case ObjectState.New:
                                    parameters["@InventoryId"] = currentDetail.InventoryId;
                                    parameters["@Quantity"] = currentDetail.Quantity;
                                    _dataStore.Save(StoredProcs.CreateOrderDetail, parameters);
                                    break;
                            }
                            currentDetail.ObjectState = ObjectState.Unchanged;
                        }
                    }
                }
                _dataStore.Commit();
            }
            catch
            {
                _dataStore.Rollback();
                throw;
            }
            finally
            {
                _currentOrder = null; // teardown for trigger
                _currentOrderDetail = null; // teardown for trigger
            }
        }


        /// <summary>
        /// Send a notification to the email assigned to a role.
        /// </summary>
        /// <param name="roleName">Role to send the email</param>
        public static void SendNotification(string roleName)
        {
            int count;
            List<Role> listRoles;

            Utility.IsStringNullOrEmpty(roleName, 
                                        "RoleName cannot be null or empty.", 
                                        true);

            //find the email address for the role
            string emailAddress = string.Empty;
            var roleQuery = from currentRole in GetRoles()
                            where currentRole.RoleName.Trim() == roleName
                            select currentRole;

            listRoles = roleQuery.ToList();
            count = listRoles.Count;
            if (count == 0)
            {
                throw new ApplicationException("Could not find role for RoleName, " +
                                               roleName + ".");
            }
            else
            {
                if (count > 1)
                {
                    throw new ApplicationException("RoleName, " +
                                                   roleName + ", not unique.");
                }
            }
            emailAddress = listRoles.ElementAt(0).EmailAddress;

            Utility.IsStringNullOrEmpty(emailAddress,
                                        "Could not find role email addressin in database.",
                                        true);

            NotificationAgent.Instance.SendMessage(emailAddress, "SYNC", null);
        }




        /// <summary>
        /// Save the signature Gif file to a database Image column
        /// </summary>
        /// <param name="signaturePath"></param>
        /// <param name="orderId"></param>
        public static void SaveGifToDatabase(string signaturePath, Guid orderId)
        {
            FileStream fs = null;
            byte[] imageData;
            Parameters parameters;

            //Open Gif file
            fs = File.Open(signaturePath, FileMode.Open);

            try
            {
                //Create byte array equal to the size of the Gif file
                imageData = new byte[fs.Length];

                //Write Gif image data to the byte array
                fs.Read(imageData, 0, imageData.Length);
                // capture signature and put in order
                parameters = new Parameters();
                parameters.Add("@Signature", imageData);
                parameters.Add("@OrderId", orderId);
                _dataStore.Save(StoredProcs.UpdateSignature, parameters);
            }
            finally
            {
                fs.Close();
                fs.Dispose();
            }
        }


        /// <summary>
        /// Writes settings to the xml config file
        /// </summary>
        /// <param name="settingName"></param>
        /// <param name="settingValue"></param>
        private static void SetAppSetting(string appSettingName, string appSettingValue)
        {
            XElement appSetting = GetAppSettingNode(appSettingName);
            appSetting.Attribute("value").Value = appSettingValue;
            _configFile.Save(GlobalCache.Instance.ConfigFile);
        }


        /// <summary>
        /// Synchronize with server data source
        /// </summary>
        public static void SyncWithDataSource()
        {
            //commit changes so that they can be picked up by the sync framework
            _dataStore.Close();

            //create agent if we already don't have one 
            ClientSyncAgent.Instance.Synchronize();
        }


        /// <summary>
        /// <see cref="HardwareDistributor.Business.OrderState"/>, needs to be 
        /// translated from the enum to the string in the language selected.
        /// </summary>
        /// <param name="state">OrderState of an order</param>
        /// <returns>State as a string</returns>
        public static string TranslateOrderState(Nullable<OrderState> state)
        {
            string result = string.Empty;

            if (state != null)
            {
                switch (state)
                {
                    case OrderState.Cancelled:
                        result = Resources.OrderStateCancelled;
                        break;
                    case OrderState.Delivered:
                        result = Resources.OrderStateDelivered;
                        break;
                    case OrderState.Loaded:
                        result = Resources.OrderStateLoaded;
                        break;
                    case OrderState.OutForDelivery:
                        result = Resources.OrderStateOutForDelivery;
                        break;
                    case OrderState.Picked:
                        result = Resources.OrderStatePicked;
                        break;
                    case OrderState.Placed:
                        result = Resources.OrderStatePlaced;
                        break;
                }
            }

            return result;
        }


        /// <summary>
        /// Update the amount of Inventory items in stock
        /// </summary>
        /// <param name="inventoryId"></param>
        /// <param name="inStock"></param>
        public static void UpdateInStockAmount(int inventoryId, int inStock)
        {
            Parameters parameters;

            // update inventory level
            parameters = new Parameters();
            parameters.Add("@InStock", inStock);
            parameters.Add("@InventoryId", inventoryId);
            _dataStore.Save(StoredProcs.UpdateStock, parameters);
        }


        /// <summary>
        /// Verify a user's login credentials to either grant or deny access 
        /// to the system
        /// </summary>
        /// <param name="userName">username</param>
        /// <param name="password">password for username</param>
        /// <returns></returns>
        public static bool VerifyCredentials(string userName, string password)
        {
            bool result;

            Parameters parameters = new Parameters();
            parameters.Add("@userName", userName);
            parameters.Add("@password", password);

            result = (((int)_dataStore.GetValue(StoredProcs.VerifyCredentials, parameters)) == 1);

            return result;
        }


        /// <summary>
        /// WebCheck sends a GET request to a valid URL like a web page, web 
        /// service, or replication ISAPI dll
        /// </summary>
        /// <param name="url">URL to check</param>
        /// <param name="cred">User credentials</param>
        /// <returns>true if URL is valid\available</returns>
        private static bool WebCheck(string url, NetworkCredential cred)
        {
            HttpWebRequest _req = null;
            HttpWebResponse _res = null;
            Uri _uri = null;

            try
            {
                //Create a Uri object
                _uri = new Uri(url);
                //Create an HttpWebRequest object
                _req = (HttpWebRequest)WebRequest.Create(_uri);
                //Set the HttpWebRequest's properties
                _req.Timeout = 20000;
                _req.KeepAlive = false;
                _req.Credentials = cred;

                //Return an HttpWebResponse object
                _res = (HttpWebResponse)_req.GetResponse();
                //Check for null
                if (_res != null)
                {
                    //If Uri was reached sucessfully return true
                    if (_res.StatusCode == HttpStatusCode.OK)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            catch (Exception e)
            {
                return false;
            }
            finally
            {
                //Ensure HttpWebResponse is closed
                if (_res != null)
                {
                    _res.Close();
                    _res = null;
                }
                //Ensure HttpWebRequest is closed
                if (_req != null)
                {
                    _req.Abort();
                    _req = null;
                }
            }
        }
        #endregion
    }
}