TEST - DEL Later


namespace MSCRMConnectorUI
{
    using System;
    using System.Collections.Generic;
    using System.Data;
    using System.IO;
    using System.Linq;
    using System.Net;
    using System.Web.Services.Protocols;
    using Microsoft.Crm.Sdk.Messages;
    using Microsoft.Crm.Sdk.Samples;
    using Microsoft.Xrm.Client;
    using Microsoft.Xrm.Client.Services;
    using Microsoft.Xrm.Sdk;
    using Microsoft.Xrm.Sdk.Client;
    using Microsoft.Xrm.Sdk.Query;   

    /// <summary>
    /// TODO: Update summary.
    /// </summary>
    public static class Helper
    {
        #region Public Properties
        public static string DiscoveryServiceAddress { get; set; }
        public static string OrganizationUniqueName { get; set; }
        public static string UserName { get; set; }
        public static string Password { get; set; }
        public static string DomainName { get; set; }
        public static OrganizationServiceProxy OrganizationProxy { get; set; }
        public static IOrganizationService CrmService { get; set; }
        public static OrganizationServiceContext ServiceContext { get; set; }
        #endregion Public Properties

        public static bool InitService()
        {
            try
            {
                DiscoveryServiceAddress = System.Configuration.ConfigurationManager.AppSettings["DiscoveryServiceAddress"];
                OrganizationUniqueName = System.Configuration.ConfigurationManager.AppSettings["OrganizationUniqueName"];
                UserName = System.Configuration.ConfigurationManager.AppSettings["UserName"];
                Password = System.Configuration.ConfigurationManager.AppSettings["Password"];
                DomainName = System.Configuration.ConfigurationManager.AppSettings["DomainName"];

                // Connector ObjConnect = new Connector(GetDiscoveryServiceURL(AuthenticationProviderType.OnlineFederation), UserName, Password, DomainName, OrganizationUniqueName);
                Connector ObjConnect = new Connector(DiscoveryServiceAddress, UserName, Password, DomainName, OrganizationUniqueName);
                OrganizationProxy = ObjConnect.Connect();
                CrmService = (IOrganizationService)OrganizationProxy;
                ServiceContext = new OrganizationServiceContext(CrmService);

                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="strConnectionString"></param>
        /// <param name="blnInitGlobalMembers">Init Global Properties for MS CRM Connections</param>
        /// <returns></returns>
        public static IOrganizationService InitService(string strConnectionString = "CRM", bool blnInitGlobalMembers = false)
        {
            IOrganizationService CrmServiceLocal = null;
            try
            {
                string strCrmConnection = System.Configuration.ConfigurationManager.ConnectionStrings[strConnectionString].ToString();
                CrmConnection crmConnection = CrmConnection.Parse(strCrmConnection);

                OrganizationService organizationService = new OrganizationService(crmConnection);
                CrmServiceLocal = (IOrganizationService)organizationService;
               
                if (blnInitGlobalMembers)
                {
                    CrmService = CrmServiceLocal;
                    ServiceContext = new OrganizationServiceContext(organizationService);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return CrmServiceLocal;
        }

        public static EntityReference GetServiceOwner()
        {
            // Get the current user to set as record owner.
            WhoAmIRequest systemUserRequest = new WhoAmIRequest();
            WhoAmIResponse systemUserResponse =
                (WhoAmIResponse)Helper.CrmService.Execute(systemUserRequest);

            return new EntityReference("systemuser", systemUserResponse.UserId);
        }

        public static bool IsEntityTypeOfActivity(EntityReference ObjEntityRecord)
        {
            if (ObjEntityRecord != null)
            {
                if (ObjEntityRecord.LogicalName != null)
                {
                    if (ObjEntityRecord.LogicalName.ToLower() == "appointment" || ObjEntityRecord.LogicalName.ToLower() == "email" ||
                        ObjEntityRecord.LogicalName.ToLower() == "fax" || ObjEntityRecord.LogicalName.ToLower() == "letter" ||
                        ObjEntityRecord.LogicalName.ToLower() == "phonecall" || ObjEntityRecord.LogicalName.ToLower() == "task")
                        return true;
                }
            }
            return false;
        }

        public static bool UploadFile(string strDestinationWebUrl, string strFileName, string strSourceFilePath, CredentialCache MyCredentialCache)
        {
            WebClient myWebClient = new WebClient();
            myWebClient.Credentials = MyCredentialCache;

            Uri strUploadPath = new Uri(strDestinationWebUrl).Append(@"/" + strFileName);
            byte[] responseArray = myWebClient.UploadFile(strUploadPath, "PUT", strSourceFilePath);

            return true;
        }

        public static byte[] ReadFileAndConvertIntoByteArray(Stream input)
        {
            byte[] buffer = new byte[16 * 1024];
            using (MemoryStream ms = new MemoryStream())
            {
                int read;
                while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
                {
                    ms.Write(buffer, 0, read);
                }
                return ms.ToArray();
            }
        }

        public static byte[] ConvertFileToByteArray(string FilePath, CredentialCache MyCredentialCache)
        {
            byte[] buffer = null;
            try
            {
                WebRequest request = WebRequest.Create(new Uri(FilePath, UriKind.Absolute));
                request.Credentials = MyCredentialCache;
                WebResponse response = request.GetResponse();
                Stream fs = response.GetResponseStream() as Stream;
                buffer = ReadFileAndConvertIntoByteArray(fs);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return buffer;
        }

        public static string GetMimeType(string extension)
        {
            if (extension == null)
            {
                throw new ArgumentNullException("extension");
            }

            if (!extension.StartsWith("."))
            {
                extension = "." + extension;
            }

            string mime;

            return _mappings.TryGetValue(extension, out mime) ? mime : "application/octet-stream";
        }


        /// <summary>
        /// Copy DataTable Columns by Name
        /// </summary>
        /// <param name="dtSource">Source DataTable</param>
        /// <param name="dtDestination">Destination [Copy the Columns] DataTable</param>
        /// <param name="arrColumns">Columns to be copied by NAME</param>
        public static void CopyDataTableColumns(DataTable dtSource, DataTable dtDestination, params string[] arrColumns)
        {
            foreach (DataRow drSourceRow in dtSource.Rows)
            {
                DataRow drDestinationRow = dtDestination.NewRow();

                foreach (string strColumnName in arrColumns)
                {
                    drDestinationRow[strColumnName] = drSourceRow[strColumnName];
                }

                dtDestination.Rows.Add(drDestinationRow);
            }
        }

        /// <summary>
        /// Copy DataTable Columns by Name
        /// </summary>
        /// <param name="dtSource">Source DataTable</param>
        /// <param name="dtDestination">Destination [Copy the Columns] DataTable</param>
        /// <param name="arrColumns">Columns to be copied by Column Position / Index</param>
        public static void CopyDataTableColumns(DataTable dtSource, DataTable dtDestination, params int[] arrColumns)
        {
            foreach (DataRow drSourceRow in dtSource.Rows)
            {
                DataRow drDestinationRow = dtDestination.NewRow();
                foreach (int iColumnNumber in arrColumns)
                {
                    drDestinationRow[iColumnNumber] = drSourceRow[iColumnNumber];
                }

                dtDestination.Rows.Add(drDestinationRow);
            }
        }


        /// <summary>
        /// Copy Source DataTable Column Value [all rows] in a Destination DataTable column
        /// # of Rows in Source & Destination should same. Both Column index should be available.
        /// </summary>
        /// <param name="dtSource"></param>
        /// <param name="dtDestination"></param>
        /// <param name="arrColumns"></param>
        public static void MegeDataTableColumns(DataTable dtSource, DataTable dtDestination, params int[] arrColumns)
        {
            for (int i = 0; i < dtSource.Rows.Count; i++)
            {
                foreach (int iColumnNumber in arrColumns)
                {
                    dtDestination.Rows[i][iColumnNumber] = dtSource.Rows[i][iColumnNumber];
                }
            }
        }
    }

    public static class UriExtensions
    {
        public static Uri Append(this Uri uri, params string[] paths)
        {
            return new Uri(paths.Aggregate(uri.AbsoluteUri, (current, path) => string.Format("{0}/{1}", current.TrimEnd('/'), path.TrimStart('/'))));
        }
    }

    public class FileHandlingHelper
    {
        public static void MoveSubFolders(string strSourcePath, string strTargetPath, bool blnKeepFirstLevelFolders = true)
        {
            DirectoryInfo sourceDirectory = new DirectoryInfo(strSourcePath);
            DirectoryInfo targetDirectory = new DirectoryInfo(strTargetPath);

            // Move Directory
            foreach (DirectoryInfo currentDirectory in sourceDirectory.GetDirectories())
            {
                Directory.Move(currentDirectory.FullName, targetDirectory.FullName + @"\" + currentDirectory.Name);
                if (blnKeepFirstLevelFolders)
                    Directory.CreateDirectory(currentDirectory.FullName);
            }
            // Move Files
            foreach (FileInfo currentFile in sourceDirectory.GetFiles())
                currentFile.MoveTo(Path.Combine(targetDirectory.FullName, currentFile.Name));
        }

        /// <summary>
        /// Download Attachments at Download Path
        /// </summary>
        /// <param name="Service">Crm Service</param>
        /// <param name="EntityRecordId">Entity record Guid</param>
        /// <param name="strDownloadPath">Download Files Path</param>
        public static int DownloadAttachments(IOrganizationService Service, Guid EntityRecordId, string strDownloadPath)
        {
            int iFileCount = 0;
            #region Retrieve Records
            string strFetchQuery = @"<fetch mapping='logical'>
                                           <entity name='annotation'>
                                                 <attribute name='documentbody' />
                                                 <attribute name='filename' />
                                                 <filter>
                                                        <condition attribute='objectid' operator='eq' value='{0}' />
                                                           <condition attribute='isdocument' operator='eq' value='1' />
                                                        <condition attribute='documentbody' operator='not-null'/>
                                                        <condition attribute='filename' operator='not-null' />
                                                 </filter>
                                           </entity>
                                    </fetch>";

            string strFetchQueryTemp = string.Format(strFetchQuery, EntityRecordId);

            EntityCollection EntityAttachmentRecords = Service.RetrieveMultiple(new FetchExpression(strFetchQueryTemp));
            iFileCount = EntityAttachmentRecords.Entities.Count;
            #endregion

            #region Donwload Attachments
            foreach (Entity retrievedAnnotation in EntityAttachmentRecords.Entities)
            {
                string Body = retrievedAnnotation.Attributes["documentbody"].ToString();
                string FileName = retrievedAnnotation.Attributes["filename"].ToString();               

                // Download the attachment in the current execution folder.
                using (FileStream fileStream = new FileStream(string.Format(@"{0}\{1}", strDownloadPath, FileName), FileMode.OpenOrCreate))
                {
                    byte[] fileContent = Convert.FromBase64String(Body);
                    fileStream.Write(fileContent, 0, fileContent.Length);
                }
            }
            #endregion

            return iFileCount;
        }

        /// <summary>
        /// Download Attachments at Download Path
        /// </summary>
        /// <param name="Service">Crm Service</param>
        /// <param name="EmailId">Email record Guid</param>
        /// <param name="strDownloadPath">Download Files Path</param>
        public static int DownloadEmailAttachments(IOrganizationService Service, Guid EmailId, string strDownloadPath)
        {
            int iFileCount = 0;
            #region Retrieve Records
            string strFetchQuery = @"<fetch mapping='logical'>
                                           <entity name='activitymimeattachment'>
                                                 <all-attributes />
                                                 <filter>
                                                        <condition attribute='objectid' operator='eq' value='{0}' />
                                                        <condition attribute='body' operator='not-null'/>
                                                        <condition attribute='filename' operator='not-null' />
                                                 </filter>
                                           </entity>
                                    </fetch>";

            string strFetchQueryTemp = string.Format(strFetchQuery, EmailId);

            EntityCollection EmailAttachmentRecords = Service.RetrieveMultiple(new FetchExpression(strFetchQueryTemp));
            iFileCount = EmailAttachmentRecords.Entities.Count;
            #endregion

            #region Donwload Attachments
            foreach (Entity retrievedAnnotation in EmailAttachmentRecords.Entities)
            {
                string FileName = retrievedAnnotation.Attributes["filename"].ToString();
                string Body = retrievedAnnotation.Attributes["body"].ToString();

                // Download the attachment in the current execution folder.
                using (FileStream fileStream = new FileStream(string.Format(@"{0}\{1}", strDownloadPath, FileName), FileMode.OpenOrCreate))
                {
                    byte[] fileContent = Convert.FromBase64String(Body);
                    fileStream.Write(fileContent, 0, fileContent.Length);
                }
            }
            #endregion

            return iFileCount;
        }
    }
   
    public class GroupColumnValue
    {
        public string GroupColumn { get; set; }
        public decimal ComputeValue { get; set; }
    }

    public class ChartData
    {
        #region Properties
        public string[] Labels { get; set; }
        public decimal[] Values { get; set; }
        #endregion

        public ChartData(IOrganizationService Service, string strFetchQuery, string strGroupByAttributeName, string strAttributeDataType, bool blnSortASC = true, int iRecordCount = 0)
        {
            #region Execute
            QueryExpression qeMain = CRMHelper.GetQueryExpressionFromFetchXml(Helper.CrmService, strFetchQuery);
            EntityCollection ecRecords = CRMHelper.RetrieveMultipleInBatch(Helper.CrmService, qeMain, -1, 2000);
            #endregion

            #region Get Result
            List<string> listGroupData = new List<string>();

            if (ecRecords != null)
            {
                foreach (Entity item in ecRecords.Entities)
                {
                    if (item.Attributes.Contains(strGroupByAttributeName.ToLower()))
                    {
                        switch (strAttributeDataType.ToLower())
                        {
                            case "lookup":
                                EntityReference erValue = (EntityReference)item.Attributes[strGroupByAttributeName.ToLower()];
                                listGroupData.Add(erValue.Name);
                                break;

                            case "optionset":
                                OptionSetValue osValue = (OptionSetValue)item.Attributes[strGroupByAttributeName.ToLower()];
                                listGroupData.Add(osValue.Value.ToString());
                                break;

                            default:
                                string strValue = item.Attributes[strGroupByAttributeName.ToLower()].ToString();
                                listGroupData.Add(strValue);
                                break;
                        }

                    }
                }
            }
            #endregion

            #region Sort Data
            List<KeyValuePair<string, decimal>> listChartData = StringHelper.CountUniquePrefix(listGroupData);

            if (blnSortASC)
                listChartData.Sort(CompareValue);
            else
                listChartData.Sort(CompareValueDesc);
            #endregion

            #region Slice Array / Assign Output Values
            string[] LabelsTemp = listChartData.Select(pairs => pairs.Key).ToArray();
            decimal[] ValuesTemp = listChartData.Select(pairs => pairs.Value).ToArray();

            if (iRecordCount > 0 && LabelsTemp.Length >= iRecordCount)
            {
                this.Labels = new string[iRecordCount];
                this.Values = new decimal[iRecordCount];

                Array.Copy(LabelsTemp, this.Labels, iRecordCount);
                Array.Copy(ValuesTemp, this.Values, iRecordCount);
            }
            else
            {
                this.Labels = LabelsTemp;
                this.Values = ValuesTemp;
            }
            #endregion
        }

        #region Sorting
        static int CompareKey(KeyValuePair<string, decimal> a, KeyValuePair<string, decimal> b)
        {
            return a.Key.CompareTo(b.Key);
        }

        static int CompareValue(KeyValuePair<string, decimal> a, KeyValuePair<string, decimal> b)
        {
            return a.Value.CompareTo(b.Value);
        }

        static int CompareValueDesc(KeyValuePair<string, decimal> a, KeyValuePair<string, decimal> b)
        {
            return b.Value.CompareTo(a.Value);
        }
        /*
        public static T[] SubArray<T>(this T[] data, int index, int length)
        {
            T[] result = new T[length];
            Array.Copy(data, index, result, 0, length);
            return result;
        }
        */

        #endregion
    }
}

Posted by Dynamics 365 Solution Architect | Azure / ALM/DevOps | Power Platform at 7:20 AM

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)