public void DeploymentImportXmlMaskEmailsTest()
        {
            PrepareTests();
            var workFolder = ClearFilesAndData();

            DeleteAll(Entities.account);

            var entity = CreateAccount();

            Assert.IsFalse(entity.GetStringField(Fields.account_.emailaddress1).Contains("_AT_"));

            var accountsExport = new ExportRecordType()
            {
                Type       = ExportType.AllRecords,
                RecordType = new RecordType(Entities.account, Entities.account)
            };

            var exportRequest = new ExportXmlRequest
            {
                Folder = new Folder(workFolder),
                RecordTypesToExport = new[] { accountsExport }
            };
            var exportService   = new ExportXmlService(XrmRecordService);
            var ecxportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller));

            Assert.IsFalse(ecxportResponse.HasError);

            var importRequest = new ImportXmlRequest
            {
                Folder     = new Folder(workFolder),
                MaskEmails = true
            };
            var application     = CreateAndLoadTestApplication <ImportXmlModule>();
            var immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);

            Assert.IsFalse(immportResponse.HasError);

            entity = XrmService.GetFirst(Entities.account);
            Assert.IsTrue(entity.GetStringField(Fields.account_.emailaddress1).Contains("_AT_"));

            importRequest = new ImportXmlRequest
            {
                Folder     = new Folder(workFolder),
                MaskEmails = false
            };
            application     = CreateAndLoadTestApplication <ImportXmlModule>();
            immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
            Assert.IsFalse(immportResponse.HasError);

            entity = XrmService.GetFirst(Entities.account);
            Assert.IsFalse(entity.GetStringField(Fields.account_.emailaddress1).Contains("_AT_"));
        }
        public void DeploymentImportXmlKnowledgeArticleTest()
        {
            PrepareTests();

            var type = "knowledgearticle";

            if (XrmRecordService.RecordTypeExists(type))
            {
                DeleteAll(type);

                var workFolder = ClearFilesAndData();

                //create or get a knowledge article
                var knowledgeArticle = XrmService.GetFirst(type, "articlepublicnumber", PopulateStringValue);
                if (knowledgeArticle == null)
                {
                    knowledgeArticle = CreateRecordAllFieldsPopulated("knowledgearticle");
                }

                //export to xml
                var export = new ExportRecordType()
                {
                    Type       = ExportType.AllRecords,
                    RecordType = new RecordType(type, type)
                };

                var exportRequest = new ExportXmlRequest
                {
                    Folder = new Folder(workFolder),
                    RecordTypesToExport = new[] { export }
                };
                var exportService   = new ExportXmlService(XrmRecordService);
                var ecxportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller));
                Assert.IsFalse(ecxportResponse.HasError);

                //okay we will delete then create one with the same article number
                XrmService.Delete(knowledgeArticle);
                knowledgeArticle = CreateRecordAllFieldsPopulated("knowledgearticle");

                var kaCount = XrmService.RetrieveAllEntityType(type).Count();

                //import should match them
                var importRequest = new ImportXmlRequest
                {
                    Folder     = new Folder(workFolder),
                    MaskEmails = true
                };
                var application     = CreateAndLoadTestApplication <ImportXmlModule>();
                var immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
                Assert.IsFalse(immportResponse.HasError);
                Assert.AreEqual(kaCount, XrmService.RetrieveAllEntityType(type).Count());

                //now lets just verify for create (delete it prioor to import)
                XrmService.Delete(knowledgeArticle);
                importRequest = new ImportXmlRequest
                {
                    Folder     = new Folder(workFolder),
                    MaskEmails = true
                };
                application     = CreateAndLoadTestApplication <ImportXmlModule>();
                immportResponse = application.NavigateAndProcessDialog <ImportXmlModule, ImportXmlDialog, ImportXmlResponse>(importRequest);
                Assert.IsFalse(immportResponse.HasError);
                Assert.AreEqual(kaCount, XrmService.RetrieveAllEntityType(type).Count());
            }
        }
        public void DeploymentImportXmlTypesTest()
        {
            var query = new QueryExpression();

            PrepareTests();
            var types      = new[] { Entities.jmcg_testentitytwo, Entities.jmcg_testentitythree, Entities.jmcg_testentity };
            var workFolder = ClearFilesAndData(types);

            var importService = new ImportXmlService(XrmRecordService);

            var t1_1 = CreateTestRecord(Entities.jmcg_testentity, importService);
            var t1_2 = CreateTestRecord(Entities.jmcg_testentity, importService);
            var t1_3 = CreateTestRecord(Entities.jmcg_testentity, importService);

            var t2_1 = CreateTestRecord(Entities.jmcg_testentitytwo, importService);
            var t2_2 = CreateTestRecord(Entities.jmcg_testentitytwo, importService);
            var t2_3 = CreateTestRecord(Entities.jmcg_testentitytwo, importService);

            var t3_1 = CreateTestRecord(Entities.jmcg_testentitythree, importService);
            var t3_2 = CreateTestRecord(Entities.jmcg_testentitythree, importService);
            var t3_3 = CreateTestRecord(Entities.jmcg_testentitythree, importService);

            var t1RequestAll = new ExportRecordType()
            {
                Type       = ExportType.AllRecords,
                RecordType = new RecordType(Entities.jmcg_testentity, Entities.jmcg_testentity)
            };
            var t2RequestFetch = new ExportRecordType()
            {
                Type       = ExportType.FetchXml,
                RecordType = new RecordType(Entities.jmcg_testentitytwo, Entities.jmcg_testentitytwo),
                FetchXml   = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false' count='2' >
                      <entity name='" + Entities.jmcg_testentitytwo + @"'>
                      </entity>
                    </fetch>"
            };
            var t3RequestSpecific = new ExportRecordType()
            {
                Type       = ExportType.SpecificRecords,
                RecordType = new RecordType(Entities.jmcg_testentitythree, Entities.jmcg_testentitythree),
                SpecificRecordsToExport = new[]
                {
                    new LookupSetting()
                    {
                        Record = new Lookup(Entities.jmcg_testentitythree, t3_1.Id.ToString(), "t3_1")
                    },
                    new LookupSetting()
                    {
                        Record = new Lookup(Entities.jmcg_testentitythree, t3_2.Id.ToString(), "t3_2")
                    },
                }
            };

            var exportRequest = new ExportXmlRequest
            {
                Folder = new Folder(workFolder),
                RecordTypesToExport = new[] { t1RequestAll, t2RequestFetch, t3RequestSpecific }
            };
            var exportService  = new ExportXmlService(XrmRecordService);
            var exportResponse = exportService.Execute(exportRequest, new ServiceRequestController(Controller));

            Assert.IsFalse(exportResponse.HasError);

            var entities = importService.LoadEntitiesFromXmlFiles(workFolder);

            Assert.AreEqual(7, entities.Count());

            var importRequest = new ImportXmlRequest
            {
                Folder = new Folder(workFolder)
            };
            var importResponse = importService.Execute(importRequest, new ServiceRequestController(Controller));

            Assert.IsFalse(importResponse.HasError);
        }