Пример #1
0
        public void CustomAttributesMatchingPatternMustSucceedTest()
        {
            EntityMetadata entity = new EntityMetadata()
            {
                SchemaName = "Account",
            };

            entity.SetSealedPropertyValue("IsManaged", true);
            entity.SetSealedPropertyValue("IsCustomEntity", false);

            var field1Metadata = new StringAttributeMetadata("foo_CustomField");

            field1Metadata.SetSealedPropertyValue("IsManaged", false);
            field1Metadata.SetSealedPropertyValue("IsCustomAttribute", true);

            var attributes = new List <AttributeMetadata> {
                field1Metadata
            };

            var isOwnedBySolution = false;

            var validSolutionEntity = new SolutionEntity(entity,
                                                         attributes,
                                                         isOwnedBySolution);

            var regexPattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$";
            var scope        = RuleScope.Attribute;

            var ruleToTest = new RegexRule(regexPattern, scope);

            var results = ruleToTest.Validate(validSolutionEntity);

            Assert.True(results.Passed);
        }
Пример #2
0
        public void CustomLookupOnCustomUnmanagedEntityConformingRuleResultStringIsCorrect()
        {
            var entity = new EntityMetadata()
            {
                SchemaName  = "foo_MyEntity",
                DisplayName = new Label()
                {
                    UserLocalizedLabel = new LocalizedLabel("My Entity", 1033)
                }
            };

            entity.SetSealedPropertyValue("IsManaged", false);
            entity.SetSealedPropertyValue("IsCustomEntity", true);

            var scope = RuleScope.Lookup;

            var lookupAttr = new LookupAttributeMetadata(LookupFormat.None)
            {
                SchemaName = "foo_MyCustomLookupId"
            };

            lookupAttr.SetSealedPropertyValue("IsCustomAttribute", true);
            lookupAttr.SetSealedPropertyValue("IsManaged", false);

            var attributes = new List <AttributeMetadata> {
                lookupAttr
            };
            var solutionEntity = new SolutionEntity(entity, attributes, true);

            var rule    = new RegexRule(_REGEX_PATTERN, scope);
            var results = rule.Validate(solutionEntity);

            Assert.Equal($"Rule: {rule.Description} Succeeded for entity \"My Entity\" (foo_MyEntity).",
                         results.FormatValidationResult());
        }
Пример #3
0
        public void CustomLookupOnCustomUnmanagedEntityNotConformingRuleValidationMessage()
        {
            var entity = new EntityMetadata()
            {
                SchemaName  = "foo_MyEntity",
                DisplayName = new Label()
                {
                    UserLocalizedLabel = new LocalizedLabel("My Entity", 1033)
                }
            };

            entity.SetSealedPropertyValue("IsManaged", false);
            entity.SetSealedPropertyValue("IsCustomEntity", true);

            var scope = RuleScope.Lookup;

            var lookupAttr = new LookupAttributeMetadata(LookupFormat.None)
            {
                SchemaName = "foo_MyCustomLookup"
            };

            lookupAttr.SetSealedPropertyValue("IsCustomAttribute", true);
            lookupAttr.SetSealedPropertyValue("IsManaged", false);

            var attributes = new List <AttributeMetadata> {
                lookupAttr
            };
            var solutionEntity = new SolutionEntity(entity, attributes, true);

            var rule    = new RegexRule(_REGEX_PATTERN, scope);
            var results = rule.Validate(solutionEntity);

            Assert.Equal($"Rule failed: {rule.Description} Following lookups do not match given pattern: foo_MyCustomLookup.",
                         results.FormatValidationResult());
        }
Пример #4
0
        public ActionResult Submit(Int32 id, FormCollection form)
        {
            ContestEntity contest = ViewData["Contest"] as ContestEntity;
            ProblemEntity problem = ContestProblemManager.GetProblem(contest.ContestID, id);

            SolutionEntity entity = new SolutionEntity()
            {
                ProblemID        = problem.ProblemID,
                ContestID        = contest.ContestID,
                ContestProblemID = id,
                SourceCode       = form["code"],
                LanguageType     = LanguageType.FromLanguageID(form["lang"])
            };

            Dictionary <String, Byte> supportLanguages = LanguageManager.GetSupportLanguages(contest.SupportLanguage);

            if (!supportLanguages.ContainsValue(entity.LanguageType.ID))
            {
                return(RedirectToErrorMessagePage("This contest does not support this programming language."));
            }

            String userip = this.GetCurrentUserIP();

            if (!SolutionManager.InsertSolution(entity, userip))
            {
                return(RedirectToErrorMessagePage("Failed to submit your solution!"));
            }

            return(RedirectToAction("List", "Status", new { area = "Contest", cid = contest.ContestID }));
        }
Пример #5
0
        public void EnsureEntityFirstLetterIsCapitalLetterFailsTest()
        {
            EntityMetadata entity = new EntityMetadata()
            {
                SchemaName = "foobar_myMagnificientEntity",
            };

            entity.SetSealedPropertyValue("IsManaged", false);
            entity.SetSealedPropertyValue("IsCustomEntity", true);

            List <AttributeMetadata> attributes = null;

            var isOwnedBySolution = true;

            var validSolutionEntity = new SolutionEntity(entity,
                                                         attributes,
                                                         isOwnedBySolution);

            var regexPattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$";
            var scope        = RuleScope.Entity;

            var ruleToTest = new RegexRule(regexPattern, scope);

            var results = ruleToTest.Validate(validSolutionEntity);

            Assert.False(results.Passed);
        }
Пример #6
0
        public void ExcludeEntityFromCheck()
        {
            EntityMetadata entity = new EntityMetadata()
            {
                SchemaName = "foobar_myNotSoMagnificientEntity",
            };

            entity.SetSealedPropertyValue("IsManaged", false);
            entity.SetSealedPropertyValue("IsCustomEntity", true);

            List <AttributeMetadata> attributes = null;

            var isOwnedBySolution = true;

            var validSolutionEntity = new SolutionEntity(entity,
                                                         attributes,
                                                         isOwnedBySolution);

            var regexPattern     = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$";
            var scope            = RuleScope.Entity;
            var excludedEntities = new List <string> {
                "foobar_123",
                "foobar_myNotSoMagnificientEntity",
                "foobar_mySecondNotSoGreatAgainEntity"
            };

            var ruleToTest = new RegexRule(regexPattern, scope,
                                           excludedEntities);

            var results = ruleToTest.Validate(validSolutionEntity);

            Assert.True(results.Passed);
        }
Пример #7
0
        public void CustomLookupOnCustomUnmanagedEntityConformingRule()
        {
            var entity = new EntityMetadata()
            {
                SchemaName = "foo_MyEntity",
            };

            entity.SetSealedPropertyValue("IsManaged", false);
            entity.SetSealedPropertyValue("IsCustomEntity", true);

            var scope = RuleScope.Lookup;

            var lookupAttr = new LookupAttributeMetadata(LookupFormat.None)
            {
                SchemaName = "foo_MyCustomLookupId"
            };

            lookupAttr.SetSealedPropertyValue("IsCustomAttribute", true);
            lookupAttr.SetSealedPropertyValue("IsManaged", false);

            var attributes = new List <AttributeMetadata> {
                lookupAttr
            };
            var solutionEntity = new SolutionEntity(entity, attributes, true);

            var rule    = new RegexRule(_REGEX_PATTERN, scope);
            var results = rule.Validate(solutionEntity);

            Assert.True(results.Passed);
        }
Пример #8
0
        public ActionResult Submit(Int32 id, FormCollection form)
        {
            SolutionEntity entity = new SolutionEntity()
            {
                ProblemID    = id,
                SourceCode   = form["code"],
                LanguageType = LanguageType.FromLanguageID(form["lang"])
            };

            Dictionary <String, Byte> supportLanguages = LanguageManager.MainSubmitSupportLanguages;

            if (!supportLanguages.ContainsValue(entity.LanguageType.ID))
            {
                return(RedirectToErrorMessagePage("This problem does not support this programming language."));
            }

            String userip = this.GetCurrentUserIP();

            if (!SolutionManager.InsertSolution(entity, userip))
            {
                return(RedirectToErrorMessagePage("Failed to submit your solution!"));
            }

            return(RedirectToAction("List", "Status"));
        }
Пример #9
0
        /// <summary>
        /// 根据ID得到一个提交实体
        /// </summary>
        /// <param name="id">提交ID</param>
        /// <returns>提交实体</returns>
        public static SolutionEntity GetSourceCode(Int32 id)
        {
            if (id <= 0)
            {
                throw new InvalidRequstException(RequestType.Solution);
            }

            SolutionEntity solu = SolutionRepository.Instance.GetEntity(id);

            if (solu == null)
            {
                throw new NullResponseException(RequestType.Solution);
            }
            else
            {
                solu.SourceCode = HtmlEncoder.HtmlEncode(solu.SourceCode);
            }

            if (!SolutionManager.CanViewSource(solu.UserName))
            {
                throw new NoPermissionException("You have no privilege to view the code!");
            }

            return(solu);
        }
Пример #10
0
        public void ManagedCustomEntityMustBeSkippedTest()
        {
            EntityMetadata entity = new EntityMetadata()
            {
                SchemaName = "new_notconforming",
            };

            entity.SetSealedPropertyValue("IsManaged", true);
            entity.SetSealedPropertyValue("IsCustomEntity", true);

            List <AttributeMetadata> attributes = null;

            var isOwnedBySolution = true;

            var validSolutionEntity = new SolutionEntity(entity,
                                                         attributes,
                                                         isOwnedBySolution);

            var regexPattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$";
            var scope        = RuleScope.Entity;

            var ruleToTest = new RegexRule(regexPattern, scope);

            var results = ruleToTest.Validate(validSolutionEntity);

            Assert.True(results.Passed);
        }
        public static async Task ThenSolutionsHaveTheFollowingDetails(Table table)
        {
            var expectedSolutionDetails = table.CreateSet <SolutionTable>().Select(m => new
            {
                m.SolutionId,
                AboutUrl             = string.IsNullOrWhiteSpace(m.AboutUrl) ? null : m.AboutUrl,
                Features             = string.IsNullOrWhiteSpace(m.Features) ? null : m.Features,
                Summary              = string.IsNullOrWhiteSpace(m.SummaryDescription) ? null : m.SummaryDescription,
                FullDescription      = string.IsNullOrWhiteSpace(m.FullDescription) ? null : m.FullDescription,
                RoadMap              = string.IsNullOrWhiteSpace(m.RoadMap) ? null : m.RoadMap,
                IntegrationsUrl      = string.IsNullOrWhiteSpace(m.IntegrationsUrl) ? null : m.IntegrationsUrl,
                ImplementationDetail = string.IsNullOrWhiteSpace(m.ImplementationDetail) ? null : m.ImplementationDetail,
                ClientApplication    = string.IsNullOrWhiteSpace(m.ClientApplication) ? null : JToken.Parse(m.ClientApplication).ToString(),
                Hosting              = string.IsNullOrWhiteSpace(m.Hosting) ? null : JToken.Parse(m.Hosting).ToString(),
            });

            var solutionDetails = await SolutionEntity.FetchAllAsync();

            solutionDetails.Select(m => new
            {
                m.SolutionId,
                m.AboutUrl,
                m.Features,
                m.Summary,
                m.FullDescription,
                m.RoadMap,
                m.IntegrationsUrl,
                m.ImplementationDetail,
                ClientApplication = string.IsNullOrWhiteSpace(m.ClientApplication) ? null : JToken.Parse(m.ClientApplication).ToString(),
                Hosting           = string.IsNullOrWhiteSpace(m.Hosting) ? null : JToken.Parse(m.Hosting).ToString(),
            }).Should().BeEquivalentTo(expectedSolutionDetails);
        }
Пример #12
0
        /// <summary>
        /// 更新一条提交(更新所有评测信息)
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <param name="error">编译错误信息</param>
        /// <returns>是否成功更新</returns>
        public static Boolean JudgeUpdateSolutionAllResult(SolutionEntity entity, String error)
        {
            if (entity == null)
            {
                return(false);
            }

            lock (_updateLock)
            {
                entity.JudgeTime = DateTime.Now;

                if (SolutionRepository.Instance.UpdateEntity(entity, error) > 0)
                {
                    if (entity.Result == ResultType.Accepted)
                    {
                        UserCache.RemoveUserTop10Cache();
                    }

                    SolutionCache.RemoveAcceptedCodesCache(entity.UserName);
                    SolutionCache.RemoveProblemIDListCache(entity.UserName, false);
                    SolutionCache.RemoveProblemIDListCache(entity.UserName, true);

                    return(true);
                }
                else
                {
                    return(false);
                }
            }
        }
Пример #13
0
        public async Task ShouldUpdateSupplierStatus()
        {
            await SolutionEntityBuilder.Create()
            .WithName("Solution1")
            .WithId(_solution1Id)
            .WithOnLastUpdated(_lastUpdated)
            .WithOrganisationId(_org1Id)
            .WithSupplierId(_supplierId)
            .WithSupplierStatusId(1)
            .Build()
            .InsertAsync()
            .ConfigureAwait(false);

            var mockUpdateSolutionSupplierStatusRequest = new Mock <IUpdateSolutionSupplierStatusRequest>();

            mockUpdateSolutionSupplierStatusRequest.Setup(m => m.Id).Returns(_solution1Id);
            mockUpdateSolutionSupplierStatusRequest.Setup(m => m.SupplierStatusId).Returns(2);

            _solutionRepository.CheckExists(_solution1Id, new CancellationToken()).Result.Should().BeTrue();

            await _solutionRepository.UpdateSupplierStatusAsync(mockUpdateSolutionSupplierStatusRequest.Object, new CancellationToken()).ConfigureAwait(false);

            var solution = await SolutionEntity.GetByIdAsync(_solution1Id)
                           .ConfigureAwait(false);

            solution.Id.Should().Be(_solution1Id);

            (await solution.LastUpdated.SecondsFromNow().ConfigureAwait(false)).Should().BeLessOrEqualTo(5);

            solution.SupplierStatusId.Should().Be(2);
        }
Пример #14
0
        public async Task ShouldUpdateSupplierStatus()
        {
            await CatalogueItemEntityBuilder
            .Create()
            .WithCatalogueItemId(_solution1Id)
            .WithName(_solution1Id)
            .WithPublishedStatusId((int)PublishedStatus.Published)
            .WithSupplierId(_supplierId)
            .Build()
            .InsertAsync();

            await SolutionEntityBuilder.Create()
            .WithId(_solution1Id)
            .WithOnLastUpdated(_lastUpdated)
            .Build()
            .InsertAsync();

            var mockUpdateSolutionSupplierStatusRequest = new Mock <IUpdateSolutionSupplierStatusRequest>();

            mockUpdateSolutionSupplierStatusRequest.Setup(m => m.Id).Returns(_solution1Id);
            mockUpdateSolutionSupplierStatusRequest.Setup(m => m.SupplierStatusId).Returns(2);

            _solutionRepository.CheckExists(_solution1Id, new CancellationToken()).Result.Should().BeTrue();

            await _solutionRepository.UpdateSupplierStatusAsync(mockUpdateSolutionSupplierStatusRequest.Object, new CancellationToken());

            var solution = await SolutionEntity.GetByIdAsync(_solution1Id);

            solution.Id.Should().Be(_solution1Id);

            (await solution.LastUpdated.SecondsFromNow()).Should().BeLessOrEqualTo(5);
        }
Пример #15
0
        private RegexValidationResult ValidateAttributes(
            SolutionEntity solutionEntity,
            IEnumerable <AttributeMetadata> attributesToCheck)
        {
            var failingAttributes = new List <AttributeMetadata>();

            foreach (var attribute in attributesToCheck)
            {
                var attrFullname = $"{solutionEntity.Entity.SchemaName}.{attribute.SchemaName}";
                if (_excludedSchemaNames.Contains(attrFullname))
                {
                    continue;
                }

                var pass = Pattern.IsMatch(attribute.SchemaName);

                if (!pass)
                {
                    failingAttributes.Add(attribute);
                }
            }

            return(new RegexValidationResult(solutionEntity.Entity,
                                             failingAttributes,
                                             this));
        }
Пример #16
0
        /// <summary>
        /// See <see cref="CustomizationRuleBase.ValidateRule(SolutionEntity)"/>.
        /// </summary>
        protected override ValidationResult ValidateRule(
            SolutionEntity solutionEntity)
        {
            RegexValidationResult validationResult = null;

            switch (Scope)
            {
            case RuleScope.Entity:
                validationResult = ValidateEntityScope(solutionEntity);
                break;

            case RuleScope.Attribute:
                validationResult = ValidateAttributeScope(solutionEntity);
                break;

            case RuleScope.Lookup:
                validationResult = ValidateLookupScope(solutionEntity);
                break;

            default:
                throw new NotImplementedException(
                          $"Implementation is missing for scope {Scope}.");
            }

            return(validationResult as ValidationResult);
        }
Пример #17
0
        public void EntityFirstLetterIsCapitalLetterFailureDescriptionIsCorrectTest()
        {
            EntityMetadata entity = new EntityMetadata()
            {
                SchemaName  = "foobar_myMagnificientEntity",
                DisplayName = new Label()
                {
                    UserLocalizedLabel = new LocalizedLabel("Suurenmoinen entiteetti",
                                                            1035)
                }
            };

            entity.SetSealedPropertyValue("IsManaged", false);
            entity.SetSealedPropertyValue("IsCustomEntity", true);

            List <AttributeMetadata> attributes = null;

            var isOwnedBySolution = true;

            var validSolutionEntity = new SolutionEntity(entity,
                                                         attributes,
                                                         isOwnedBySolution);

            var regexPattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$";
            var scope        = RuleScope.Entity;

            var ruleToTest = new RegexRule(regexPattern, scope);

            var results = ruleToTest.Validate(validSolutionEntity);

            Assert.Equal($"Rule failed: {ruleToTest.Description} Entity schema name {entity.SchemaName} doesn't match given pattern \"{regexPattern}\".",
                         results.FormatValidationResult());
        }
        public static async Task ThenFieldSolutionSupplierStatusIdShouldCorrespondTo(string solutionId, string supplierStatusName)
        {
            var status = await SolutionSupplierStatusEntity.GetByNameAsync(supplierStatusName).ConfigureAwait(false);

            var solution = await SolutionEntity.GetByIdAsync(solutionId).ConfigureAwait(false);

            solution.SupplierStatusId.Should().Be(status.Id);
        }
Пример #19
0
        /// <summary>
        /// 更新评测状态
        /// </summary>
        /// <param name="sid">提交ID</param>
        /// <param name="pid">题目ID</param>
        /// <param name="username">用户名</param>
        /// <param name="result">评测结果</param>
        /// <param name="detail">出错信息</param>
        /// <param name="tcost">花费时间</param>
        /// <param name="mcost">花费内存</param>
        /// <param name="error">错误信息</param>
        /// <returns>是否更新成功</returns>
        public static Boolean TryUpdateSolutionStatus(String sid, String pid, String username, String result, String detail, String tcost, String mcost, out String error)
        {
            try
            {
                error = JudgeStatusManager.GetJudgeServerLoginStatus();

                if (!String.IsNullOrEmpty(error))
                {
                    return(false);
                }

                SolutionEntity entity = new SolutionEntity()
                {
                    SolutionID = Int32.Parse(sid),
                    ProblemID  = pid.ToInt32(0),
                    UserName   = username,
                    Result     = (ResultType)result.ToByte(0),
                    TimeCost   = tcost.ToInt32(0),
                    MemoryCost = mcost.ToInt32(0)
                };

                if (entity.Result > ResultType.Accepted)//评测失败
                {
                    Boolean hasProblemData = !String.IsNullOrEmpty(ProblemDataManager.GetProblemDataRealPath(entity.ProblemID));

                    //没有题目的不重新评测
                    Boolean canAutoRejudge = hasProblemData;

                    Int32 triedTimes = 0;
                    if (!_rejudgeTimesMap.TryGetValue(entity.SolutionID, out triedTimes))
                    {
                        triedTimes = 0;
                    }

                    if (triedTimes > AUTO_REJUDGE_MAX_TIMES)
                    {
                        _rejudgeTimesMap.Remove(entity.SolutionID);
                        canAutoRejudge = false;
                    }
                    else
                    {
                        _rejudgeTimesMap[entity.SolutionID] = triedTimes + 1;
                    }

                    entity.Result = canAutoRejudge ? ResultType.RejudgePending : ResultType.JudgeFailed;
                }

                SolutionManager.JudgeUpdateSolutionAllResult(entity, detail);

                return(true);
            }
            catch (System.Exception ex)
            {
                error = ex.Message;
                return(false);
            }
        }
Пример #20
0
        private RegexValidationResult ValidateAttributeScope(
            SolutionEntity solutionEntity)
        {
            var attributesToCheck = solutionEntity.Attributes
                                    .Where(a => a.IsManaged != true &&
                                           a.IsCustomAttribute == true);

            return(ValidateAttributes(solutionEntity, attributesToCheck));
        }
Пример #21
0
        public void RemoveSolution(SolutionEntity solution)
        {
            if (solution.Type == "Farm Solution")
            {
                var apps = _utility.GetAllWebApplications();

                (solution.InternalObject as SPSolution).RetractLocal(apps);
            }
        }
        public static async Task ThenSolutionsExist(Table table)
        {
            var expectedSolutions = table.CreateSet <SolutionUpdatedTable>();
            var solutions         = await SolutionEntity.FetchAllAsync();

            solutions.Select(s => new
            {
                SolutionId   = s.SolutionId,
                SolutionName = s.Name,
            }).Should().BeEquivalentTo(expectedSolutions);
        }
Пример #23
0
        public void UnmanagedAttributesOnOobEntityWithIncorrectNamesFailureDescriptionIsCorrectTest()
        {
            EntityMetadata entity = new EntityMetadata()
            {
                SchemaName  = "Account",
                DisplayName = new Label()
                {
                    UserLocalizedLabel = new LocalizedLabel("Asiakas", 1035)
                }
            };

            entity.SetSealedPropertyValue("IsManaged", true);
            entity.SetSealedPropertyValue("IsCustomEntity", false);

            var field1Metadata = new StringAttributeMetadata("foo_customField");

            field1Metadata.SetSealedPropertyValue("IsManaged", false);
            field1Metadata.SetSealedPropertyValue("IsCustomAttribute", true);

            var field2Metadata = new StringAttributeMetadata("foo_c");

            field2Metadata.SetSealedPropertyValue("IsManaged", false);
            field2Metadata.SetSealedPropertyValue("IsCustomAttribute", true);

            var field3Metadata = new StringAttributeMetadata("foo_CustomField");

            field3Metadata.SetSealedPropertyValue("IsManaged", false);
            field3Metadata.SetSealedPropertyValue("IsCustomAttribute", true);

            var attributes = new List <AttributeMetadata> {
                field1Metadata,
                field2Metadata,
                field3Metadata
            };

            var isOwnedBySolution = false;

            var validSolutionEntity = new SolutionEntity(entity,
                                                         attributes,
                                                         isOwnedBySolution);

            var regexPattern = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$";
            var scope        = RuleScope.Attribute;

            var ruleToTest = new RegexRule(regexPattern, scope);

            var results = ruleToTest.Validate(validSolutionEntity);

            Assert.Equal($"Rule failed: {ruleToTest.Description} " +
                         "Following attributes do not match given pattern: " +
                         "foo_customField, foo_c.",
                         results.FormatValidationResult());
        }
Пример #24
0
        /// <summary>
        /// 增加一条提交
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <param name="userip">用户IP</param>
        /// <returns>是否成功增加</returns>
        public static Boolean InsertSolution(SolutionEntity entity, String userip)
        {
            if (!UserManager.IsUserLogined)
            {
                throw new UserUnLoginException();
            }

            if (String.IsNullOrEmpty(entity.SourceCode) || entity.SourceCode.Length < SolutionRepository.SOURCECODE_MINLEN)
            {
                throw new InvalidInputException("Code is too short!");
            }

            if (entity.SourceCode.Length > SolutionRepository.SOURCECODE_MAXLEN)
            {
                throw new InvalidInputException("Code is too long!");
            }

            if (LanguageType.IsNull(entity.LanguageType))
            {
                throw new InvalidInputException("Language Type is INVALID!");
            }

            if (!UserSubmitStatus.CheckLastSubmitSolutionTime(UserManager.CurrentUserName))
            {
                throw new InvalidInputException(String.Format("You can not submit code more than twice in {0} seconds!", ConfigurationManager.SubmitInterval.ToString()));
            }

            ProblemEntity problem = ProblemManager.InternalGetProblemModel(entity.ProblemID);

            if (problem == null)//判断题目是否存在
            {
                throw new NullResponseException(RequestType.Problem);
            }

            if (entity.ContestID <= 0 && problem.IsHide && !AdminManager.HasPermission(PermissionType.ProblemManage))//非竞赛下判断是否有权访问题目
            {
                throw new NoPermissionException("You have no privilege to submit the problem!");
            }

            entity.UserName   = UserManager.CurrentUserName;
            entity.SubmitTime = DateTime.Now;
            entity.SubmitIP   = userip;

            Boolean success = SolutionRepository.Instance.InsertEntity(entity) > 0;

            if (success)
            {
                ProblemCache.UpdateProblemCacheSubmitCount(entity.ProblemID, -1);//更新缓存
                SolutionCache.RemoveProblemIDListCache(entity.UserName, true);
            }

            return(success);
        }
Пример #25
0
        public SolutionEntityBuilder()
        {
            const string id = "SolutionId";

            solutionEntity = new SolutionEntity
            {
                SolutionId            = id,
                Version               = "1.0.0",
                ServiceLevelAgreement = null,
                WorkOfPlan            = null
            };
        }
Пример #26
0
        public void ExcludeUnmanagedAttributesWithIncorrectNamesFromValidationTest()
        {
            EntityMetadata entity = new EntityMetadata()
            {
                SchemaName = "Account",
            };

            entity.SetSealedPropertyValue("IsManaged", true);
            entity.SetSealedPropertyValue("IsCustomEntity", false);

            var field1Metadata = new StringAttributeMetadata("foo_customField");

            field1Metadata.SetSealedPropertyValue("IsManaged", false);
            field1Metadata.SetSealedPropertyValue("IsCustomAttribute", true);

            var field2Metadata = new StringAttributeMetadata("foo_c");

            field2Metadata.SetSealedPropertyValue("IsManaged", false);
            field2Metadata.SetSealedPropertyValue("IsCustomAttribute", true);

            var field3Metadata = new StringAttributeMetadata("foo_CustomField");

            field3Metadata.SetSealedPropertyValue("IsManaged", false);
            field3Metadata.SetSealedPropertyValue("IsCustomAttribute", true);

            var attributes = new List <AttributeMetadata> {
                field1Metadata,
                field2Metadata,
                field3Metadata
            };

            var isOwnedBySolution = false;

            var validSolutionEntity = new SolutionEntity(entity,
                                                         attributes,
                                                         isOwnedBySolution);

            var regexPattern       = @"^[A-Za-z]+_[A-Z]{1}[a-z]{1}[A-Za-z]*$";
            var scope              = RuleScope.Attribute;
            var excludedAttributes = new List <string> {
                "Account.foo_customField",
                "Account.foo_c"
            };

            var ruleToTest = new RegexRule(regexPattern, scope,
                                           excludedAttributes);

            var results = ruleToTest.Validate(validSolutionEntity);

            Assert.True(results.Passed);
        }
Пример #27
0
        /// <summary>
        /// See <see cref="CustomizationRuleBase.ValidateRule(SolutionEntity)"/>.
        /// </summary>
        protected override ValidationResult ValidateRule(
            SolutionEntity solutionEntity)
        {
            var customAttributes = solutionEntity.Attributes
                                   .Where(a => a.IsManaged == false &&
                                          a.IsCustomAttribute == true);

            var attributeFailures = customAttributes.Where(a => !a.SchemaName
                                                           .StartsWith(_schemaPrefix + "_"));

            return(new AttributeValidationResult(solutionEntity.Entity,
                                                 attributeFailures,
                                                 this));
        }
Пример #28
0
        /// <summary>
        /// See <see cref="CustomizationRuleBase.ValidateRule(SolutionEntity)"/>.
        /// </summary>
        protected override ValidationResult ValidateRule(SolutionEntity solutionEntity)
        {
            var result = true;

            if (!_allowSolutionToOwnManagedEntities &&
                solutionEntity.IsOwnedBySolution &&
                solutionEntity.Entity.IsManaged == true)
            {
                result = false;
            }

            return(new ValidationResult(solutionEntity.Entity,
                                        result,
                                        this));
        }
Пример #29
0
        private void GetFarmSolutions(string url, IList <SolutionEntity> result)
        {
            foreach (SPSolution s in SPFarm.Local.Solutions)
            {
                SolutionEntity entity = new SolutionEntity();
                entity.Name           = s.Name;
                entity.Type           = "Farm Solution";
                entity.SolutionGuid   = s.Id;
                entity.Status         = s.Status.ToString();
                entity.InternalObject = s;
                entity.Site           = "(none)";

                result.Add(entity);
            }
        }
        public static async Task GivenSolutionsAreLinkedToCapabilities(Table table)
        {
            var solutions = await SolutionEntity.FetchAllAsync().ConfigureAwait(false);

            var capabilities = await CapabilityEntity.FetchAllAsync().ConfigureAwait(false);

            foreach (var solutionCapabilityTable in table.CreateSet <SolutionCapabilityTable>())
            {
                await SolutionCapabilityEntityBuilder.Create()
                .WithSolutionId(solutions.First(s => s.Name == solutionCapabilityTable.Solution).Id)
                .WithCapabilityId(capabilities.First(s => s.Name == solutionCapabilityTable.Capability).Id)
                .Build()
                .InsertAsync()
                .ConfigureAwait(false);
            }
        }