コード例 #1
0
        public ActionResult ExportToExcel(string Spec, string Alloy, string Temper, string Plant)
        {
            DataGridoption ExportDataFilter = new DataGridoption();

            string SearchBy = "";

            if (!string.IsNullOrEmpty(Spec))
            {
                SearchBy = SearchBy + ";" + "Spec:" + Spec;
            }
            if (!string.IsNullOrEmpty(Alloy))
            {
                SearchBy = SearchBy + ";" + "Alloy:" + Alloy;
            }
            if (!string.IsNullOrEmpty(Temper))
            {
                SearchBy = SearchBy + ";" + "Temper:" + Temper;
            }
            if (!string.IsNullOrEmpty(Plant))
            {
                SearchBy = SearchBy + ";" + "Plant:" + Plant;
            }

            ExportDataFilter.Screen    = "ExceptionList";
            ExportDataFilter.filterBy  = "all";
            ExportDataFilter.pageIndex = 0;
            ExportDataFilter.pageSize  = 10000;
            ExportDataFilter.searchBy  = SearchBy;

            List <ProdExceptions>       lstException = new List <ProdExceptions>();
            DataSearch <ProdExceptions> ds           = null;

            try
            {
                ds = new ExceptionsData().GetList(ExportDataFilter);

                if (ds != null && ds.items != null && ds.items.Count > 0)
                {
                    lstException = ds.items;
                    string fileName = "ExceptionList" + "_" + DateTime.Now.ToString().Replace(" ", "").Replace("-", "").Replace(":", "");
                    GetExcelFile <ProdExceptions>(lstException, fileName);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(RedirectToAction("ExceptionList"));
        }
コード例 #2
0
        public ActionResult GetExceptionList(DataGridoption dataoptions)
        {
            DataSearch <ProdExceptions> ds = new DataSearch <ProdExceptions>();

            try
            {
                ds = new ExceptionsData().GetList(dataoptions);
            }
            catch (Exception ex)
            {
                ds.Message = ex.Message.ToString();
                ds.total   = 0;
            }

            return(Json(new { items = ds.items, total = ds.total }, JsonRequestBehavior.AllowGet));
        }
コード例 #3
0
        public DeveloperLogEvent Clone()
        {
            var clone = (DeveloperLogEvent)MemberwiseClone();

            clone.GrpcErrorDetails               = GrpcErrorDetails?.Clone();
            clone.ExternalToolError              = ExternalToolError?.Clone();
            clone.CommandData                    = CommandData?.Clone();
            clone.GameletData                    = GameletData?.Clone();
            clone.GrpcCallDetails                = GrpcCallDetails?.Select(x => x.Clone()).ToList();
            clone.LoadSymbolData                 = LoadSymbolData?.Clone();
            clone.DebugPreflightCheckData        = DebugPreflightCheckData?.Clone();
            clone.DebugSessionEndData            = DebugSessionEndData?.Clone();
            clone.DebugEventBatch                = DebugEventBatch?.Clone();
            clone.DebugParameters                = DebugParameters?.Clone();
            clone.CopyExecutable                 = CopyExecutable?.Clone();
            clone.CopyLldbServer                 = CopyLldbServer?.Clone();
            clone.CustomCommand                  = CustomCommand?.Clone();
            clone.ExceptionsData                 = ExceptionsData?.Select(x => x.Clone()).ToList();
            clone.BoundBreakpointsData           = BoundBreakpointsData?.Clone();
            clone.GameLaunchData                 = GameLaunchData?.Clone();
            clone.DebugExpressionEvaluationBatch = DebugExpressionEvaluationBatch?.Clone();
            return(clone);
        }
コード例 #4
0
        public void MergeFrom(DeveloperLogEvent other)
        {
            if (other == null)
            {
                return;
            }

            if (other.ApiEndpoint.HasValue)
            {
                ApiEndpoint = other.ApiEndpoint;
            }

            if (other.BinaryType.HasValue)
            {
                BinaryType = other.BinaryType;
            }

            if (other.OrganizationId != null)
            {
                OrganizationId = other.OrganizationId;
            }

            if (other.ProjectId != null)
            {
                ProjectId = other.ProjectId;
            }

            if (other.VisualStudioVersion != null)
            {
                VisualStudioVersion = other.VisualStudioVersion;
            }

            if (other.SdkVersion != null)
            {
                SdkVersion = other.SdkVersion;
            }

            if (other.VsExtensionVersion != null)
            {
                VsExtensionVersion = other.VsExtensionVersion;
            }

            if (other.VsSessionIdStr != null)
            {
                VsSessionIdStr = other.VsSessionIdStr;
            }

            if (other.DebugSessionIdStr != null)
            {
                DebugSessionIdStr = other.DebugSessionIdStr;
            }

            if (other.StatusCode.HasValue)
            {
                StatusCode = other.StatusCode;
            }

            if (other.GrpcErrorDetails != null)
            {
                if (GrpcErrorDetails == null)
                {
                    GrpcErrorDetails = new GrpcServiceCallDetails();
                }

                GrpcErrorDetails.MergeFrom(other.GrpcErrorDetails);
            }

            if (other.ExternalToolError != null)
            {
                if (ExternalToolError == null)
                {
                    ExternalToolError = new Types.ExternalToolError();
                }

                ExternalToolError.MergeFrom(other.ExternalToolError);
            }

            if (other.LatencyMilliseconds.HasValue)
            {
                LatencyMilliseconds = other.LatencyMilliseconds;
            }

            if (other.LatencyType.HasValue)
            {
                LatencyType = other.LatencyType;
            }

            if (other.CommandData != null)
            {
                if (CommandData == null)
                {
                    CommandData = new Types.CommandData();
                }

                CommandData.MergeFrom(other.CommandData);
            }

            if (other.GameletData != null)
            {
                if (GameletData == null)
                {
                    GameletData = new Types.GameletData();
                }

                GameletData.MergeFrom(other.GameletData);
            }

            if (other.GrpcCallDetails != null)
            {
                if (GrpcCallDetails == null)
                {
                    GrpcCallDetails = new List <GrpcServiceCallDetails>();
                }

                GrpcCallDetails.AddRange(other.GrpcCallDetails);
            }

            if (other.LoadSymbolData != null)
            {
                if (LoadSymbolData == null)
                {
                    LoadSymbolData = new Types.LoadSymbolData();
                }

                LoadSymbolData.MergeFrom(other.LoadSymbolData);
            }

            if (other.DebugPreflightCheckData != null)
            {
                if (DebugPreflightCheckData == null)
                {
                    DebugPreflightCheckData = new DebugPreflightCheckData();
                }

                DebugPreflightCheckData.MergeFrom(other.DebugPreflightCheckData);
            }

            if (other.DebugSessionEndData != null)
            {
                if (DebugSessionEndData == null)
                {
                    DebugSessionEndData = new DebugSessionEndData();
                }

                DebugSessionEndData.MergeFrom(other.DebugSessionEndData);
            }

            if (other.DebugEventBatch != null)
            {
                if (DebugEventBatch == null)
                {
                    DebugEventBatch = new VSIDebugEventBatch();
                }

                DebugEventBatch.MergeFrom(other.DebugEventBatch);
            }

            if (other.DebugParameters != null)
            {
                if (DebugParameters == null)
                {
                    DebugParameters = new VSIDebugParameters();
                }

                DebugParameters.MergeFrom(other.DebugParameters);
            }

            if (other.CopyExecutable != null)
            {
                if (CopyExecutable == null)
                {
                    CopyExecutable = new CopyBinaryData();
                }

                CopyExecutable.MergeFrom(other.CopyExecutable);
            }

            if (other.CopyLldbServer != null)
            {
                if (CopyLldbServer == null)
                {
                    CopyLldbServer = new CopyBinaryData();
                }

                CopyLldbServer.MergeFrom(other.CopyLldbServer);
            }

            if (other.CustomCommand != null)
            {
                if (CustomCommand == null)
                {
                    CustomCommand = new CustomCommandData();
                }

                CustomCommand.MergeFrom(other.CustomCommand);
            }

            if (other.ExceptionsData != null)
            {
                if (ExceptionsData == null)
                {
                    ExceptionsData = new List <VSIExceptionData>();
                }

                ExceptionsData.AddRange(other.ExceptionsData);
            }

            if (other.BoundBreakpointsData != null)
            {
                if (BoundBreakpointsData == null)
                {
                    BoundBreakpointsData = new VSIBoundBreakpointsData();
                }

                BoundBreakpointsData.MergeFrom(other.BoundBreakpointsData);
            }

            if (other.GameLaunchData != null)
            {
                if (GameLaunchData == null)
                {
                    GameLaunchData = new GameLaunchData();
                }

                GameLaunchData.MergeFrom(other.GameLaunchData);
            }

            if (other.DebugExpressionEvaluationBatch != null)
            {
                if (DebugExpressionEvaluationBatch == null)
                {
                    DebugExpressionEvaluationBatch = new VSIDebugExpressionEvaluationBatch();
                }

                DebugExpressionEvaluationBatch.MergeFrom(other.DebugExpressionEvaluationBatch);
            }
        }