Monday 29 July 2019

Refresh Look up Field

 public void CalculateRollupFieldRequest(EntityReference target, string fieldName)
        {
            if (this.organizationService != null)
            {
                CalculateRollupFieldRequest calculateRollUpFieldRequest = new CalculateRollupFieldRequest
                {
                    Target = target,
                    FieldName = fieldName
                };
                this.organizationService.Execute(calculateRollUpFieldRequest);
            }
        }

/ <summary>
        /// Gets or sets a Input Argument - Opportunity Entity Reference
        /// </summary>
        [RequiredArgument]
        [Input("OpportunityEntityReference")]
        [ReferenceTarget(Opportunity.EntityLogicalName)]
        public InArgument<EntityReference> OpportunityEntityReference { get; set; }
 
        /// <summary>
        /// Gets or sets a Input Argument - Field Name
        /// </summary>
        [RequiredArgument]
        [Input("OpportunityRollUpFieldName")]
        public InArgument<string> OpportunityRollUpFieldName { get; set; }

Monday 22 July 2019

Move New Stage in Buisness Process Flow Praogramitcally

pdateSalesProcessStage(IOrganizationService service)
        {
            Guid oppId = new Guid("2b685c81-4f1c-e511-80d3-3863bb347ba8");
            Entity opportunity = service.Retrieve("opportunity", oppId, new ColumnSet(true));
            //Entity entity = this.Opportunity;
            //var source = opportunity.GetAttributeValue<OptionSetValue>("lvo_source").Value;
            var source = 100000000;
            string fetch = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>
                              <entity name='opportunitysalesprocess'>
                                <attribute name='businessprocessflowinstanceid' />
                                <attribute name='name' />
                                <attribute name='createdon' />
                                <attribute name='opportunityid' />
                                <attribute name='activestageid' />
                                <attribute name='statecode' />
                                <attribute name='statuscode' />
                                <attribute name='processid' />
                                <order attribute='opportunityid' descending='false' />
                                <filter type='and'>
                                  <condition attribute='opportunityid' operator='eq' uiname='4' uitype='opportunity' value='{0}' />
                                </filter>
                              </entity>
                            </fetch>";
            fetch = string.Format(fetch, oppId);
            EntityCollection ec = service.RetrieveMultiple(new FetchExpression(fetch));
            QueryExpression qe = new QueryExpression("processstage");
            qe.ColumnSet = new ColumnSet(true);
            qe.Criteria.AddCondition(new ConditionExpression("processid", ConditionOperator.Equal, ec.Entities[0].GetAttributeValue<EntityReference>("processid").Id));
            EntityCollection pc = service.RetrieveMultiple(qe);
            Dictionary<string, Guid> dict = new Dictionary<string, Guid>();
            foreach (var p in pc.Entities)
            {
                dict.Add(p.GetAttributeValue<string>("stagename"), p.GetAttributeValue<Guid>("processstageid"));
            }
            Guid processStageId = RetrieveProcessStageId(dict, source);
            //if (dict.ContainsKey("Qualify"))
            //{
            //    dict.TryGetValue("Qualify",out processStageId);
            //}
            Entity pro = new Entity(ec.Entities[0].LogicalName);
            pro.Id = ec.Entities[0].Id;
            pro.Attributes["activestageid"] = new EntityReference("processstage", processStageId);
            service.Update(pro);
            Console.WriteLine("done");
        }
   
        private static Guid RetrieveProcessStageId(Dictionary<string, Guid> dict, int sourceValue)
        {
            Guid processId = Guid.Empty;
            if (sourceValue == 100000000)
                processId = dict.ContainsKey("Qualify") ? dict["Qualify"] : Guid.Empty;
            else if (sourceValue == 100000002)
                processId = dict.ContainsKey("Qualify") ? dict["Qualify"] : Guid.Empty;
            else if (sourceValue == 100000003)
                processId = dict.ContainsKey("Propose") ? dict["Propose"] : Guid.Empty;
            else if (sourceValue == 100000001)
                processId = dict.ContainsKey("Develop") ? dict["Develop"] : Guid.Empty;
            return processId;
        }
    }
}

Tuesday 2 July 2019

Read Files from Web Reources , Add to Excel

  WebResourceList = GetAllWebResourceFilesfromSolution(ConfigurationManager.AppSettings["SolutionName"].ToString());
            Dictionary<string, string> keyValueText = null;
            if (WebResourceList != null)
            {
                foreach (string file in WebResourceList.Values)
                {
                    keyValueText = ReadWebResourceContent(file);

                    AddToExcelFile(keyValueText, file);

                }
                ReadFromExcelandTranslate();
                Console.WriteLine("Translation Completed!! Press Any key to exit..!");
                Console.ReadKey();
                Environment.Exit(0);
            }

 public static void AddToExcelFile(Dictionary<string, string> resourcedictionary, string filename)
        {
            try
            {
                bool sheet_avail = false;
                string newfilePath = Environment.CurrentDirectory + @"\Transalation.xlsx";
                Excel.Application xlApp = new Excel.Application();
                Excel.Workbook xlWorkBook = xlApp.Workbooks.Open(newfilePath);
                int sheetCount = xlWorkBook.Worksheets.Count;
                Excel.Sheets sheets = xlWorkBook.Worksheets;
                // Excel.Worksheet xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets;
                Excel.Range xlRange;
                Excel.Worksheet excelWorkSheet;
                int index1 = filename.IndexOf('_') + 1;
                int index2 = filename.IndexOf('.');
                string languagecode = filename.Substring(index2 + 1, 4);

                for (int k = 1; k <= sheetCount; k++)
                {

                    Excel.Worksheet worksheet = (Excel.Worksheet)sheets.get_Item(k);
                    string name = worksheet.Name;

                    if (filename.Contains(name))
                    {
                        sheet_avail = true;
                        excelWorkSheet = (Excel.Worksheet)sheets.Item[k];
                        xlRange = excelWorkSheet.UsedRange;
                        int totalColumns = xlRange.Columns.Count;
                        string[] colnames = new string[totalColumns + 1];
                        for (int q = 1; q <= totalColumns; q++)
                            colnames[q] = xlRange.Cells[1, q].Value.ToString();
                        int i = 2, j = 1;
                        if (languagecode == "1033")
                        {
                            foreach (KeyValuePair<string, string> entry in resourcedictionary)
                            {
                                excelWorkSheet.Cells[i, j] = entry.Key;
                                excelWorkSheet.Cells[i, j + 1] = entry.Value;
                                i++;
                            }
                        }
                        else
                        {
                            bool col_avail = false;
                            for (int m = 1; m < colnames.Length; m++)
                            {
                                if (colnames[m] == languagecode)
                                {
                                    col_avail = true;
                                    foreach (KeyValuePair<string, string> entry in resourcedictionary)
                                    {
                                        if (excelWorkSheet.Cells[i, j].Value.ToString() == entry.Key)
                                            excelWorkSheet.Cells[i, m] = entry.Value;
                                        i++;
                                    }
                                    break;
                                }
                            }
                            if (col_avail == false)
                            {
                                excelWorkSheet.Cells[1, totalColumns + 1] = languagecode;
                                foreach (KeyValuePair<string, string> entry in resourcedictionary)
                                {
                                    if (excelWorkSheet.Cells[i, j].Value.ToString() == entry.Key)
                                        excelWorkSheet.Cells[i, totalColumns + 1] = entry.Value;
                                    i++;
                                }
                            }

                        }
                        break;
                    }
                }

                if (sheet_avail == false)
                {
                    var xlNewSheet = (Excel.Worksheet)sheets.Add(Type.Missing, sheets[1], Type.Missing, Type.Missing);
                    //wSheet.Move(Missing.Value, workbook.Sheets[workbook.Sheets.Count]);
                    //var xlNewSheet=xlWorkBook.Worksheets.Add();
                    //xlWorkBook.Sheets.Move(After: xlWorkBook.Sheets.Count);
                    filename.Substring(index1, index2 - index1);
                    xlNewSheet.Name = filename.Substring(index1, index2 - index1);

                    int NewCount = xlWorkBook.Worksheets.Count;
                    excelWorkSheet = (Excel.Worksheet)sheets.Item[NewCount];
                    excelWorkSheet.Cells[1, 1] = "Key";
                    excelWorkSheet.Cells[1, 2] = "1033";
                    int i = 2, j = 1;
                    foreach (KeyValuePair<string, string> entry in resourcedictionary)
                    {
                        excelWorkSheet.Cells[i, j] = entry.Key;
                        excelWorkSheet.Cells[i, j + 1] = entry.Value;
                        i++;
                    }
                }

                xlApp.Visible = false;
                xlApp.UserControl = false;
                xlWorkBook.Save();
                xlWorkBook.Close();
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.Read();
            }
        }

 public static void ReadFromExcelandTranslate()
        {
            try
            {
                string excelPath = Environment.CurrentDirectory + @"\Transalation.xlsx";
                Excel.Application xlApp = new Excel.Application();
                Excel.Workbook xlWorkBook = xlApp.Workbooks.Open(excelPath);
                int totalSheets = xlWorkBook.Worksheets.Count;
                for (int sheet = 1; sheet <= totalSheets; sheet++)
                {
                    Excel.Worksheet xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(sheet);
                    Excel.Range xlRange = xlWorkSheet.UsedRange;
                    int totalRows = xlRange.Rows.Count;
                    int totalColumns = xlRange.Columns.Count;
                    string[] languageTobeConverted = null;
                    string combinedLanguages = ConfigurationManager.AppSettings["languagesTranslation"];
                    languageTobeConverted = combinedLanguages.Split(',');
                    List<int> integerList = new List<int>();
                    string[] languageLables = null;
                    languageLables = new string[languageTobeConverted.Count()];
                    //foreach (var langCode in languageTobeConverted)
                    for (int u = 0; u < languageTobeConverted.Count(); u++)
                    {
                        integerList.Add(int.Parse(languageTobeConverted[u]));
                        languageLables[u] = languageTobeConverted[u];
                    }

                    totalColumns = 2 + integerList.Count;

                    for (int colCount = 3; colCount <= totalColumns; colCount++)
                    {
                        int languageID = 0;
                        string colNullValue = (xlRange.Cells[1, colCount] as Excel.Range).Text;

                        if (string.IsNullOrEmpty(colNullValue))
                        {
                            for (int d = 0; d < integerList.Count; d++)
                            {
                                xlWorkSheet.Cells[1, colCount + d] = integerList[d];
                            }
                            languageID = Convert.ToInt32((xlRange.Cells[1, colCount] as Excel.Range).Text);
                        }

                        if (!string.IsNullOrEmpty(colNullValue) && languageID == 0)
                        {
                            languageID = Convert.ToInt32((xlRange.Cells[1, colCount] as Excel.Range).Text);
                        }

                        for (int rowCount = 2; rowCount <= totalRows; rowCount++)
                        {
                            originalText = Convert.ToString((xlRange.Cells[rowCount, 2] as Excel.Range).Text);
                            translatedText = Convert.ToString((xlRange.Cells[rowCount, colCount] as Excel.Range).Text);
                            if (translatedText == null || translatedText == "")
                            {
                                List<TranslationHelper> translatedTextList = Translation.TranslateText(originalText, LanguageCodes.languageID[languageID]);
                                xlWorkSheet.Cells[rowCount, colCount] = translatedTextList.Where(x => x.to == LanguageCodes.languageID[languageID]).Select(x => x.text).ToList().FirstOrDefault();
                            }
                        }
                        integerList.Remove(languageID);
                    }
                }
                xlApp.DisplayAlerts = false;
                xlWorkBook.Save();
                xlWorkBook.Close();
                xlApp.Quit();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.Read();
            }
        }

        static void ReadFromExcelToImport()
        {
            try
            {
                string excelPath = Environment.CurrentDirectory + @"\Transalation.xlsx";
                //XmlDocument doc = new XmlDocument();           
                //doc.Load(@"..\..\sampleResource.resx");
                //string xmlcontents = doc.InnerXml;
                //XDocument xmlDocument = XDocument.Parse(xmlcontents);           
                Excel.Application xlApp = new Excel.Application();
                Excel.Workbook xlWorkBook = xlApp.Workbooks.Open(excelPath);

             
                int sheetcount = xlWorkBook.Worksheets.Count;
                for (int k = 1; k <= sheetcount; k++)
                {
                    Excel.Worksheet xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(k);
                    Excel.Range xlRange = xlWorkSheet.UsedRange;
                    int totalRows = xlRange.Rows.Count;
                    int totalColumns = xlRange.Columns.Count;
                    for (int c = 1; c < totalColumns; c++)
                    {
                        var xmlDocument = new XDocument();
                        var declartion = new XDeclaration("1.0", "UTF-8", null);
                        xmlDocument.Declaration = declartion;
                        var rootElement = new XElement("root");
                        xmlDocument.Add(rootElement);

                        for (int row = 1; row < totalRows; row++)
                        {
                            var data = new XElement("data");
                            data.SetAttributeValue("name", "test");
                            data.SetAttributeValue(XNamespace.Xml + "space", "preserve");
                            var value = new XElement("value", "test");
                            data.Add(value);
                            rootElement.Add(data);
                        }
                            int i = 2, j = 1;
                        var dataelements = xmlDocument.Descendants("data").ToList();
                        //for (int n = 1; n < totalRows - 8; n++)
                        //{
                        //    dataelements.Add(new XElement("data", new XAttribute("name", "test"), new XAttribute(XNamespace.Xml + "space", "preserve"), new XElement("value", "test")));
                        //}
                   
                        foreach (var dataelement in dataelements)
                        {
                            if (xlRange.Cells[i, j] != null)
                                dataelement.Attribute("name").Value = xlRange.Cells[i, j].Value.ToString();
                            if (xlRange.Cells[i, j + c] != null)
                                dataelement.Element("value").Value = xlRange.Cells[i, j + c].Value.ToString();
                            i++;
                        }
                     
                        //dataelements=xmlDocument.Descendants("data").ToList();
                        string ws_name = xlWorkSheet.Name;
                        string c_name = xlRange.Cells[1, j + c].Value.ToString();
                        string filename = ws_name + "." + c_name;
                        CreateResourcefile(xmlDocument, filename);

                    }
                }


                xlApp.DisplayAlerts = false;
                xlWorkBook.Close();
                xlApp.Quit();

            }
            catch (FileNotFoundException ex)
            {
                Console.WriteLine("File not Found");
                Console.Read();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.Read();

            }

        }

    }
}

Import data using Excel MSCRM programitacally

   public static void ImportToCRMPluginErrorCodes()
        {
            //string filePath = Environment.CurrentDirectory + @"\Active sheetname.xlsx";
            Entity import = new Entity("import");
            import["modecode"] = new OptionSetValue(1);
            import["name"] = "Active sheet Name";
            import["sendnotification"] = false;
            Guid importId = organizationService.Create(import);

            OrganizationServiceContext servicecontext = new OrganizationServiceContext(organizationService);

            var importMap = (from a in servicecontext.CreateQuery("importmap") where a.GetAttributeValue<string>("name") == "DataFinal" select new { a.Id }).FirstOrDefault();

            Entity impmap = new Entity("importmap");
            Guid importMapId = importMap.Id;
            var importEntityMap = (from cl in servicecontext.CreateQuery("columnmapping")
                                   where (Guid)cl["importmapid"] == importMap.Id && cl["sourceentityname"] != null
                                   select cl).FirstOrDefault();

            // Create the ImportFile class
            Entity importFile = new Entity("importfile");
            importFile["content"] = getEncodedFileContents(filePath);
            importFile["name"] = "File Name";
            importFile["filetypecode"] = new OptionSetValue(3);
            importFile["isfirstrowheader"] = true;
            importFile["source"] = "lenovo.xlsx";
            importFile["sourceentityname"] = (string)importEntityMap["sourceentityname"];
            // Schema name of the Target entity
            importFile["targetentityname"] = "lvo_languageresource";
            importFile["importmapid"] = new EntityReference(impmap.LogicalName, importMapId);
            importFile["importid"] = new EntityReference(import.LogicalName, importId);
            //importFile["Size"] = importFile.Content.Length.ToString();
            importFile["size"] = importFile.FormattedValues.Count.ToString();
            importFile["processcode"] = new OptionSetValue(1);
            importFile["datadelimitercode"] = new OptionSetValue(1);
            importFile["fielddelimitercode"] = new OptionSetValue(2);
            importFile["usesystemmap"] = false;
            importFile["enableduplicatedetection"] = true;
            organizationService.Create(importFile);

            ParseImportRequest parseRequest = new ParseImportRequest();
            parseRequest.ImportId = importId;
            organizationService.Execute(parseRequest);

            TransformImportRequest transRequest = new TransformImportRequest();
            transRequest.ImportId = importId;
            TransformImportResponse transResponse = (TransformImportResponse)organizationService.Execute(transRequest);

            ImportRecordsImportRequest request = new ImportRecordsImportRequest();
            request.ImportId = importId;

            ImportRecordsImportResponse response = (ImportRecordsImportResponse)organizationService.Execute(request);
        }

        static public string getEncodedFileContents(String pathToFile)
        {
            FileStream fs = new FileStream(pathToFile, FileMode.Open, FileAccess.Read);
            byte[] binaryData = new byte[fs.Length];
            long bytesRead = fs.Read(binaryData, 0, (int)fs.Length);
            fs.Close();
            return System.Convert.ToBase64String(binaryData, 0, binaryData.Length);
        }

Export using Code Programitically MSCRM

 var exportToExcelRequest = new OrganizationRequest("ExportToExcel");
                exportToExcelRequest.Parameters = new ParameterCollection();
                //Has to be a savedquery aka "System View" or userquery aka "Saved View"
                //The view has to exist, otherwise will error out
                //Guid of the view has to be passed
                exportToExcelRequest.Parameters.Add(new KeyValuePair<string, object>("View",
                    new EntityReference("savedquery", new Guid(ConfigurationManager.AppSettings["SavedViewId"]))));
                exportToExcelRequest.Parameters.Add(new KeyValuePair<string, object>("FetchXml", @"
                    <fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>
                          <entity name='entity name'>
                   ' descending='false' />
                            <filter type='and'>
                              <condition attribute='statecode' operator='eq' value='0' />
                            </filter>
                        </entity>
                    </fetch>"));
                exportToExcelRequest.Parameters.Add(new KeyValuePair<string, object>("LayoutXml", @"
                    <grid name='resultset' object='2' jump='lvo_name' select='1' icon='1' preview='1'>
                        <row name='result' id='primary key'>
                        </row>
                    </grid>"));
                //need these params to keep org service happy
                exportToExcelRequest.Parameters.Add(new KeyValuePair<string, object>("QueryApi", ""));
                exportToExcelRequest.Parameters.Add(new KeyValuePair<string, object>("QueryParameters",
                    new InputArgumentCollection()));
                var exportToExcelResponse = organizationService.Execute(exportToExcelRequest);
                if (exportToExcelResponse.Results.Any())
                {
                    File.WriteAllBytes(filePath, exportToExcelResponse.Results["ExcelFile"] as byte[]);
                }