Exemplo n.º 1
0
        private void ReportRequest(string ticketNumber)
        {
            var requests = UOLAddInUtilities.UIThreadSafeAsync(
                () => uolClient.GetValidationRequestsAsync(projectNumber, ticketNumber)).Result;

            if (requests != null && requests.FirstOrDefault() != null && !string.IsNullOrEmpty(requests.FirstOrDefault().UserFriendlyResultBlobId))
            {
                var content = UOLAddInUtilities.UIThreadSafeAsync(
                    () => uolClient.GetValidationBlobAsStringAsync(requests.FirstOrDefault().UserFriendlyResultBlobId)).Result;

                if (!string.IsNullOrEmpty(content))
                {
                    var webBrowser = new WebBrowser($"Ticket {ticketNumber}", content);
                    webBrowser.ShowDialog();
                }
                else
                {
                    MessageBox.Show(string.Format(Resources.MessageBoxValidationReportNotAvailable_Text, ticketNumber), Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
            else
            {
                MessageBox.Show(string.Format(Resources.MessageBoxValidationReportNotAvailable_Text, ticketNumber), Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            /// monitoredExecutionContext is used for logging purposes.
            var monitoredExecutionContext = ApplicationGlobals.ApplicationContext.GetService <IMonitoredExecutionContext>();

            using (var executionBlock = monitoredExecutionContext
                                        .MonitorMethod <ExternalApplication>(nameof(Execute))
                                        .WithTiming())
            {
                /// ExternalCommandData is stored in a static variable for later use.
                ApplicationGlobals.ExternalCommandData = commandData;

                /// RequestValidationForm is initialized and shown.
                using (var requestValidationForm = new RequestValidationForm())
                {
                    var dialogResult = requestValidationForm.ShowDialog(ApplicationGlobals.HostWindow);

                    if (dialogResult == DialogResult.No)
                    {
                        do
                        {
                            requestValidationForm.FamilyInstances = new ElementHelper().SelectElements(ApplicationGlobals.ExternalCommandData.Application.ActiveUIDocument, typeof(FamilyInstance), Resources.MessageSelectFamilyInstancesToValidate, requestValidationForm.FamilyInstances).Where(e => ((FamilyInstance)e).Symbol.GetOrderedParameters().FirstOrDefault(p => p.Definition != null && p.Definition.Name.StartsWith("MC_")) != null || e.GetOrderedParameters().FirstOrDefault(p => p.Definition != null && p.Definition.Name.StartsWith("MC_")) != null).ToList();

                            dialogResult = requestValidationForm.ShowDialog(ApplicationGlobals.HostWindow);
                        }while (dialogResult == DialogResult.No);
                    }

                    if (dialogResult == DialogResult.OK && requestValidationForm.CADValidationRequest != null && requestValidationForm.CADValidationRequest.CADProducts.Count() > 0)
                    {
                        try
                        {
                            var ticket = UOLAddInUtilities.UIThreadSafeAsync(
                                () =>
                            {
                                var uolClient   = ApplicationGlobals.ApplicationContext.GetService <IUOLClient>();
                                var returnValue = uolClient.AddValidationRequestAsync(requestValidationForm.CADValidationRequest);
                                return(returnValue);
                            }).Result;

                            var started = UOLAddInUtilities.UIThreadSafeAsync(
                                () =>
                            {
                                var uolClient   = ApplicationGlobals.ApplicationContext.GetService <IUOLClient>();
                                var returnValue = "gestart";
                                uolClient.StartValidationAsync(requestValidationForm.CADValidationRequest.ProjectId, $"{requestValidationForm.CADValidationRequest.TicketNumber}");
                                return(returnValue);
                            });
                        }
                        catch (UOLClientException)
                        {
                            MessageBox.Show(Resources.MessageBoxAddValidationRequestError_Text, Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                }

                return(Result.Succeeded);
            }
        }
Exemplo n.º 3
0
        private void FillValidations()
        {
            var uolClient = ApplicationGlobals.ApplicationContext.GetService <IUOLClient>();

            uolClient.Initialize();
            var authorize = (IAuthorizationService)ApplicationGlobals.ApplicationContext.GetService(typeof(IAuthorizationService));

            authorize.GetAccessToken();

            var projectId = parameterHelper.GetParameterValue(ApplicationGlobals.ExternalCommandData.Application.ActiveUIDocument.Document.ProjectInformation, Autodesk.Revit.DB.BuiltInParameter.PROJECT_NUMBER);

            if (projectId == null || string.IsNullOrEmpty(projectId.ToString()))
            {
                MessageBox.Show(Resources.MessageBoxProcessValidationNoProjectId_Text, Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            projectNumber = projectId.ToString();

            try
            {
                var assembly        = GetType().Assembly;
                var resourceManager = new ResourceManager(typeof(Resources));

                var validations = UOLAddInUtilities.UIThreadSafeAsync(
                    () => uolClient.GetValidationRequestsAsync(projectId.ToString())).Result;

                foreach (var validation in validations)
                {
                    tableLayoutPanelValidations.RowCount += 1;
                    tableLayoutPanelValidations.RowStyles.Add(new RowStyle
                    {
                        Height   = 35,
                        SizeType = SizeType.Absolute
                    });

                    tableLayoutPanelValidations.Controls.Add(CreateLabelControl("labelTicketNumber", validation.TicketNumber, Color.FromArgb(255, 96, 0)), 0, tableLayoutPanelValidations.RowCount - 1);
                    tableLayoutPanelValidations.Controls.Add(CreateLabelControl("labelRequestDate", validation.RequestDate.ToString("dd-MM-yyyy"), Color.FromArgb(100, 99, 99)), 1, tableLayoutPanelValidations.RowCount - 1);
                    tableLayoutPanelValidations.Controls.Add(CreateLabelControl("labelRequestStatus", resourceManager.GetString($"ValidationStatus_{(int)validation.Status}"), Color.FromArgb(100, 99, 99)), 2, tableLayoutPanelValidations.RowCount - 1);
                    tableLayoutPanelValidations.Controls.Add(CreateLabelControl("labelValidationResult", validation.ValidationResult.ToString("0.0"), Color.FromArgb(100, 99, 99)), 3, tableLayoutPanelValidations.RowCount - 1);
                    tableLayoutPanelValidations.Controls.Add(CreateButtonControl("buttonRestart", "icon1"), 4, tableLayoutPanelValidations.RowCount - 1);
                    tableLayoutPanelValidations.Controls.Add(CreateButtonControl("buttonReport", "icon2"), 5, tableLayoutPanelValidations.RowCount - 1);
                    tableLayoutPanelValidations.Controls.Add(CreateButtonControl("buttonDelete", "icon4"), 6, tableLayoutPanelValidations.RowCount - 1);
                    toolTipForm.SetToolTip(tableLayoutPanelValidations.Controls[$"buttonRestart_{tableLayoutPanelValidations.RowCount - 1}"], Resources.ProcessValidation_TooltipRestart);
                    toolTipForm.SetToolTip(tableLayoutPanelValidations.Controls[$"buttonReport_{tableLayoutPanelValidations.RowCount - 1}"], Resources.ProcessValidation_TooltipReport);
                    toolTipForm.SetToolTip(tableLayoutPanelValidations.Controls[$"buttonDelete_{tableLayoutPanelValidations.RowCount - 1}"], Resources.ProcessValidation_TooltipDelete);
                }
            }
            catch (UOLClientException)
            {
                MessageBox.Show(Resources.MessageBoxGetValidationsError_Text, Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Exemplo n.º 4
0
        private void DeleteRequest(string ticketNumber)
        {
            var reallyDelete = MessageBox.Show(string.Format(Resources.MessageBoxValidationDelete_Text, ticketNumber), Resources.ApplicationTitle, MessageBoxButtons.YesNo, MessageBoxIcon.Information);

            if (reallyDelete == DialogResult.Yes)
            {
                var content = UOLAddInUtilities.UIThreadSafeAsync(
                    () => uolClient.DeleteValidationRequestAsync(projectNumber, ticketNumber)).Result;

                MessageBox.Show(string.Format(Resources.MessageBoxValidationDeleted_Text, ticketNumber), Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Information);
                SetTableHeaders();
                FillValidations();
            }
            else
            {
                MessageBox.Show(string.Format(Resources.MessageBoxValidationNotDeleted_Text, ticketNumber), Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            /// monitoredExecutionContext is used for logging purposes.
            var monitoredExecutionContext = ApplicationGlobals.ApplicationContext.GetService <IMonitoredExecutionContext>();

            using (var executionBlock = monitoredExecutionContext
                                        .MonitorMethod <ExternalApplication>(nameof(Execute))
                                        .WithTiming())
            {
                /// ExternalCommandData is stored in a static variable for later use.
                ApplicationGlobals.ExternalCommandData = commandData;
                var uolClientControls = ApplicationGlobals.ApplicationContext.GetService <IUOLClientControls>();
                var revitHost         = ApplicationGlobals.ApplicationContext.GetService <ICADHost>();

                /// Save the current security protocol settings for web requests.
                var currentSecurityProtocol = ServicePointManager.SecurityProtocol;
                try
                {
                    /// Set the security protocol to TLS12.
                    ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
                    var dialogResult = uolClientControls.ShowEtimClassPickerDialog(ApplicationGlobals.HostWindow, Properties.Resources.ApplicationTitle);

                    if (dialogResult.Cancelled || dialogResult.CADFilterResult.CADProducts.Count() == 0)
                    {
                        return(Result.Cancelled);
                    }

                    foreach (var cadProduct in dialogResult.CADFilterResult.CADProducts)
                    {
                        try
                        {
                            /// Get the metadata of the cadproduct
                            var cadMetadataList = UOLAddInUtilities.UIThreadSafeAsync(
                                () =>
                            {
                                var uolClient = ApplicationGlobals.ApplicationContext.GetService <IUOLClient>();
                                return(uolClient.GetMetadataAsync(new List <CADMetadataCriteria> {
                                    UOLAddInUtilities.GetCADMetadataCriteria(cadProduct)
                                }));
                            }).Result;

                            /// Do a thread safe call for downloading CAD Content.
                            var cadContent = UOLAddInUtilities.UIThreadSafeAsync(
                                () =>
                            {
                                var uolClient = ApplicationGlobals.ApplicationContext.GetService <IUOLClient>();
                                return(uolClient.DownloadCadContentAsync(
                                           new CADApplication
                                {
                                    Name = "Revit",
                                    Version = ApplicationGlobals.GetRevitVersion()
                                },
                                           new ETIM
                                {
                                    ClassCode = cadProduct.EtimClassCode,
                                    ClassCodeVersion = cadProduct.EtimClassCodeVersion,
                                    ModelCode = cadProduct.ModellingClassCode,
                                    ModelCodeVersion = cadProduct.ModellingClassCodeVersion
                                },
                                           cadMetadataList.FirstOrDefault() != null ? cadMetadataList.FirstOrDefault().Type : "Template"));
                            }).Result;

                            if (cadContent.Exists)
                            {
                                var rfaPath  = CreateRfaFile(cadContent);
                                var typeName = $"{cadProduct.EtimClassCode}_{cadProduct.ModellingClassCode}_{DateTime.Now.Ticks}";

                                if (string.IsNullOrEmpty(typeName))
                                {
                                    return(Result.Cancelled);
                                }

                                dialogResult.CADFilterResult.CADProducts.FirstOrDefault().Name = typeName;

                                // Load rfa into Revit project
                                var result = revitHost.InsertCadContent(rfaPath, dialogResult.CADFilterResult.CADProducts.FirstOrDefault().Name, dialogResult.CADFilterResult.CADProducts.FirstOrDefault().Properties, dialogResult.CADFilterResult.CADProducts.Count() == 1, cadMetadataList.FirstOrDefault());
                                if (result.State == CADHostResultState.Succeeded)
                                {
                                    result = revitHost.WriteAdditionalData(result.CADObject, JsonConvert.SerializeObject(dialogResult.CADFilterResult));
                                }

                                return(result.State == CADHostResultState.Succeeded ? Result.Succeeded : Result.Failed);
                            }
                            else
                            {
                                MessageBox.Show(Properties.Resources.MessageBoxCadContentNotFound_Text, Properties.Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                            }
                        }
                        catch (UOLClientException)
                        {
                            MessageBox.Show(Properties.Resources.MessageBoxCadacContentDownloadError_Text, Properties.Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                }
                catch (UOLClientDataException)
                {
                    MessageBox.Show(Properties.Resources.MessageBoxCadContentIncomplete_Text, Properties.Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                catch (UOLClientException)
                {
                    MessageBox.Show(Properties.Resources.MessageBoxCadacContentDownloadError_Text, Properties.Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                finally
                {
                    ServicePointManager.SecurityProtocol = currentSecurityProtocol;
                }

                return(Result.Failed);
            }
        }
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            /// monitoredExecutionContext is used for logging purposes.
            var monitoredExecutionContext = ApplicationGlobals.ApplicationContext.GetService <IMonitoredExecutionContext>();

            using (var executionBlock = monitoredExecutionContext
                                        .MonitorMethod <ExternalApplication>(nameof(Execute))
                                        .WithTiming())
            {
                /// ExternalCommandData is stored in a static variable for later use.
                ApplicationGlobals.ExternalCommandData = commandData;

                var uolClientControls = ApplicationGlobals.ApplicationContext.GetService <IUOLClientControls>();
                var revitHost         = ApplicationGlobals.ApplicationContext.GetService <ICADHost>();

                /// Select families you want to edit.
                var familyInstanceList = new ElementHelper().SelectElements(commandData.Application.ActiveUIDocument, typeof(FamilyInstance), "Select the familyinstances to edit", false);

                if (familyInstanceList != null && familyInstanceList.Count > 0)
                {
                    /// Filter out the unique family symbols to send online.
                    var uniqueFamilySymbols = new List <FamilySymbol>();
                    foreach (FamilyInstance familyInstance in familyInstanceList)
                    {
                        var foundFamilySymbol = uniqueFamilySymbols.FirstOrDefault(familySymbol => familySymbol.Id.Equals(familyInstance.Symbol.Id));
                        if (foundFamilySymbol == null)
                        {
                            uniqueFamilySymbols.Add(familyInstance.Symbol);
                        }
                    }

                    /// This function only works when there is only one unique family symbol!
                    if (uniqueFamilySymbols.Count == 1)
                    {
                        try
                        {
                            var path            = commandData.Application.ActiveUIDocument.Document.PathName;
                            var cadFilterResult = new CADFilterResult();

                            if (!string.IsNullOrEmpty(path))
                            {
                                /// Read the metadata for the family from file.
                                var filterresult = File.ReadAllText(path.Replace(".rvt", $"_{uniqueFamilySymbols.FirstOrDefault().Id.IntegerValue.ToString()}.met"));
                                cadFilterResult = JsonConvert.DeserializeObject <CADFilterResult>(filterresult);
                            }

                            /// Show the edit dialog.
                            var dialogResult = uolClientControls.ShowUOLEditDialog(new List <CADFilterResult>()
                            {
                                cadFilterResult
                            }, ApplicationGlobals.HostWindow, Properties.Resources.ApplicationTitle);

                            if (dialogResult.Cancelled || dialogResult.CADFilterResult.CADProducts.Count() == 0)
                            {
                                return(Result.Cancelled);
                            }

                            var cadfilterResultCADProduct = cadFilterResult.CADProducts.FirstOrDefault();
                            var dialogResultCADProduct    = dialogResult.CADFilterResult.CADProducts.FirstOrDefault();

                            if (cadfilterResultCADProduct.EtimClassCode.Equals(dialogResultCADProduct.EtimClassCode) && cadfilterResultCADProduct.ModellingClassCode.Equals(dialogResultCADProduct.ModellingClassCode))
                            {
                                if (HasChangedProperties(cadfilterResultCADProduct, dialogResultCADProduct))
                                {
                                    var typeName = $"{dialogResultCADProduct.EtimClassCode}_{dialogResultCADProduct.ModellingClassCode}_{DateTime.Now.Ticks}";

                                    dialogResultCADProduct.Name = typeName;

                                    var cadMetadataList = UOLAddInUtilities.UIThreadSafeAsync(
                                        () =>
                                    {
                                        var uolClient = ApplicationGlobals.ApplicationContext.GetService <IUOLClient>();
                                        return(uolClient.GetMetadataAsync(new List <CADMetadataCriteria> {
                                            UOLAddInUtilities.GetCADMetadataCriteria(dialogResultCADProduct)
                                        }));
                                    }).Result;

                                    var result = revitHost.InsertCadContent(uniqueFamilySymbols.FirstOrDefault().FamilyName, dialogResultCADProduct.Name, dialogResultCADProduct.Properties, false, cadMetadataList.FirstOrDefault());
                                    if (result.State == CADHostResultState.Succeeded)
                                    {
                                        result = revitHost.WriteAdditionalData(result.CADObject, JsonConvert.SerializeObject(dialogResult.CADFilterResult));

                                        if (result.State == CADHostResultState.Succeeded && result.CADObject is FamilySymbol familySymbolNew)
                                        {
                                            using (var transaction = new Transaction(ApplicationGlobals.ExternalCommandData.Application.ActiveUIDocument.Document, "Edit Family Instances"))
                                            {
                                                transaction.Start();
                                                foreach (FamilyInstance item in familyInstanceList)
                                                {
                                                    item.Symbol = familySymbolNew;
                                                }

                                                transaction.Commit();
                                            }
                                        }
                                    }

                                    return(result.State == CADHostResultState.Succeeded ? Result.Succeeded : Result.Failed);
                                }
                                else
                                {
                                    var result = revitHost.WriteAdditionalData(uniqueFamilySymbols.FirstOrDefault(), JsonConvert.SerializeObject(dialogResult.CADFilterResult));
                                    return(result.State == CADHostResultState.Succeeded ? Result.Succeeded : Result.Failed);
                                }
                            }
                            else
                            {
                                MessageBox.Show(Properties.Resources.MessageBoxECcodeMCcodeChangeNotAllowed_Text, Properties.Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                            }

                            return(Result.Succeeded);
                        }
                        catch (UOLClientDataException)
                        {
                            MessageBox.Show(Properties.Resources.MessageBoxCadContentIncomplete_Text, Properties.Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                        catch (UOLClientException)
                        {
                            MessageBox.Show(Properties.Resources.MessageBoxCadacContentDownloadError_Text, Properties.Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                    else
                    {
                        MessageBox.Show(Properties.Resources.MessageBoxMultipleTypesInSelectionNotAllowed_Text, Properties.Resources.ApplicationTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                    }
                }

                return(Result.Failed);
            }
        }