public static Result <(int X, int Y)> TryGetPosition(this WorldObject obj) { Result <(int X, int Y)> result = Result <(int, int)> .CreateResult(false, (0, 0), "Obj has no [X,Y] Position"); if (obj.Tags != null && obj.Tags.Count > 1) { if (obj.Tags[0] is int x && obj.Tags[1] is int y) { result = Result <(int, int)> .CreateResult(true, (x, y)); } } return(result); }
public ResponseMessage <object> TeacherTestTrans_D() { dynamic result; var teacher = new T_Teacher() { F_TeacherName = $"Test_{ (DateTime.Now.Ticks - 621356256000000000) / 10000}" }; var bl = _SqlDB.ExecuteWithTransaction((conn, trans) => { var r = conn.Execute($"INSERT INTO T_Teacher (F_TeacherName) VALUES(@F_TeacherName);", teacher, trans, null, null); r += conn.Execute("delete from T_Teacher where f_id=@id", new { id = 1 }, trans, null, null); return(r); }); if (bl) { result = CreateResult.For(); } else { result = CreateResult.For("00001", "新增出现错误"); } return(result); }
public async Task <CreateResult> CreateProjectAsync(string name, string description, bool isPrivate) { var user = await _storage.GetUserAsync(); if (user == null) { throw new UnauthorizedAccessException(Strings.NotLoginYet); } var result = new CreateResult(); try { var repo = await user.Session.CreateRepoAsync(name, description, isPrivate); result.Project = new Project() { Repo = repo }; return(result); } catch (WebException ex) { OutputWindowHelper.ExceptionWriteLine($"LoginAsync:{ex.Message}", ex); var res = (HttpWebResponse)ex.Response; var statusCode = (int)res.StatusCode; throw new Exception($"错误代码: {statusCode}"); } }
public async void CreateAsyncTest() { CreateResult result = null; var identifier = System.Guid.NewGuid().ToString(); try { var creation_group_result = await ApiReference.Instance.LargePersonGroup.CreateAsync(identifier, identifier, identifier); if (creation_group_result) { result = await ApiReference.Instance.LargePersonGroupPerson.CreateAsync(identifier, identifier, identifier); } } catch { throw; } finally { var deletion_person_result = await ApiReference.Instance.LargePersonGroupPerson.DeleteAsync(identifier, result.personId); var deletion_group_result = await ApiReference.Instance.LargePersonGroup.DeleteAsync(identifier); } Assert.True(result != null); }
public ResponseMessage <IEnumerable <UserInfo> > Get(int pageIndex, int pageSize) { int total = 0; var result = _us.FindList(e => true, o => o.Id, out total, true, pageIndex, pageSize); return(CreateResult.For(result, total)); }
/// <summary> /// Iterates over the populated Dictionary object and pushes each attachment to the respective user story /// </summary> /// <param name="attachmentsDictionary"></param> /// <param name="attachmentContent"></param> /// <param name="attachmentContainer"></param> /// <param name="createUserStory"></param> private void PushAttachments(Dictionary <string, string> attachmentsDictionary, DynamicJsonObject attachmentContent, DynamicJsonObject attachmentContainer, CreateResult createUserStory) { foreach (KeyValuePair <string, string> attachmentPair in attachmentsDictionary) { try { //create attachment content attachmentContent[RallyConstant.Content] = attachmentPair.Key; _attachmentContentCreateResult = _rallyApi.Create(RallyConstant.AttachmentContent, attachmentContent); _userStoryReference = _attachmentContentCreateResult.Reference; //create attachment contianer attachmentContainer[RallyConstant.Artifact] = createUserStory.Reference; attachmentContainer[RallyConstant.Content] = _userStoryReference; attachmentContainer[RallyConstant.Name] = attachmentPair.Value; attachmentContainer[RallyConstant.Description] = RallyConstant.EmailAttachment; attachmentContainer[RallyConstant.ContentType] = SyncConstant.FileType; //Create & associate the attachment to the respecitve user story _attachmentContainerCreateResult = _rallyApi.Create(RallyConstant.Attachment, attachmentContainer); } catch (WebException e) { Console.WriteLine("Attachment Failed: " + e.Message); } } }
static void Main(string[] args) { RallyRestApi restApi; restApi = new RallyRestApi("*****@*****.**", "secret", "https://rally1.rallydev.com", "v2.0"); String projectRef = "/project/123456"; //use valid OID of your project Request userRequest = new Request("User"); userRequest.Query = new Query("UserName", Query.Operator.Equals, "*****@*****.**"); QueryResult userResults = restApi.Query(userRequest); String userRef = userResults.Results.First()._ref; Console.WriteLine(userRef); DynamicJsonObject myStory = new DynamicJsonObject(); myStory["Name"] = "a new story"; myStory["Project"] = projectRef; myStory["Owner"] = userRef; CreateResult createResult = restApi.Create("HierarchicalRequirement", myStory); myStory = restApi.GetByReference(createResult.Reference, "FormattedID", "Owner", "Project"); Console.WriteLine(myStory["FormattedID"] + " " + myStory["Owner"]._refObjectName + " " + myStory["Project"]._refObjectName); }
/// <summary> /// Creates the userstory with a feature or iteration /// Both feature and iteration are read only fields /// </summary> /// <param name="workspace"></param> /// <param name="project"></param> /// <param name="userstory"></param> /// <param name="userstoryDescription"></param> /// <param name="userstoryOwner"></param> public void CreateUserStory(string workspace, string project, string userstory, string userstoryDescription, string userstoryOwner) { //authenticate this.EnsureRallyIsAuthenticated(); //DynamicJsonObject DynamicJsonObject toCreate = new DynamicJsonObject(); toCreate[RALLY.WorkSpace] = workspace; toCreate[RALLY.Project] = project; toCreate[RALLY.Name] = userstory; toCreate[RALLY.Description] = userstoryDescription; toCreate[RALLY.Owner] = userstoryOwner; toCreate[RALLY.PlanEstimate] = "1"; toCreate[RALLY.PortfolioItem] = RALLYQUERY.FeatureShareProject; //toCreate[RALLY.Iteration] = usIteration; try { CreateResult createUserStory = _rallyRestApi.Create(RALLY.HierarchicalRequirement, toCreate); Console.WriteLine("Created Userstory: " + createUserStory.Reference); } catch (WebException e) { Console.WriteLine(e.Message); } }
public ResponseMessage <List <Guid> > Get(int pageIndex, int pageSize) { int total = 0; var result = _adminService.LoadEntities(e => true, o => o.Id, "asc", pageIndex, pageSize, out total).Select(e => e.Id).ToList(); return(CreateResult.For(result, total)); }
public void Start_should_check_that_beacon_has_started() { var zkClient = Substitute.For <IZooKeeperClient>(); zkClient.CreateAsync(Arg.Any <CreateRequest>()).Returns(Task.FromResult(CreateResult.Unsuccessful(ZooKeeperStatus.AuthFailed, "", null))); application = new PortRequiresApplication(); host = new VostokHost( new TestHostSettings( application, s => { SetupEnvironment(s); s.SetupZooKeeperClient(zkSetup => zkSetup.UseInstance(zkClient)); s.SetupServiceBeacon( beaconSetup => beaconSetup.SetupReplicaInfo( replicaInfoSetup => { replicaInfoSetup.SetApplication("auth-test"); })); }) { BeaconRegistrationWaitEnabled = true, BeaconRegistrationTimeout = 2.Seconds() }); Action checkStart = () => host.Start(); checkStart.Should().Throw <Exception>().Where(e => e.Message.Contains("beacon hasn't registered")); host.ApplicationState.Should().Be(VostokApplicationState.CrashedDuringInitialization); }
public ICOContractTests() { this.mContractLogger = new Mock <IContractLogger>(); this.mContractState = new Mock <ISmartContractState>(); this.mTransactionExecutor = new Mock <IInternalTransactionExecutor>(); this.persistentState = new InMemoryState(); this.network = new Mock <Network>(); this.mBlock = new Mock <IBlock>(); this.mContractState.Setup(s => s.Block).Returns(this.mBlock.Object); this.mContractState.Setup(s => s.PersistentState).Returns(this.persistentState); this.mContractState.Setup(s => s.ContractLogger).Returns(this.mContractLogger.Object); this.mContractState.Setup(s => s.InternalTransactionExecutor).Returns(this.mTransactionExecutor.Object); this.serializer = new Serializer(new ContractPrimitiveSerializer(this.network.Object)); this.mContractState.Setup(s => s.Serializer).Returns(this.serializer); this.sender = "0x0000000000000000000000000000000000000001".HexToAddress(); this.owner = "0x0000000000000000000000000000000000000002".HexToAddress(); this.investor = "0x0000000000000000000000000000000000000003".HexToAddress(); this.identity = "0x0000000000000000000000000000000000000004".HexToAddress(); this.contract = "0x0000000000000000000000000000000000000005".HexToAddress(); this.tokenContract = "0x0000000000000000000000000000000000000006".HexToAddress(); this.kycContract = "0x0000000000000000000000000000000000000007".HexToAddress(); this.mapperContract = "0x0000000000000000000000000000000000000008".HexToAddress(); this.createSuccess = CreateResult.Succeeded(this.tokenContract); this.name = "Test Token"; this.symbol = "TST"; this.totalSupply = 100 * Satoshis; this.persistentState.IsContractResult = true; }
private static string TextSerialize(CreateResult model, IEnumerable <Error> errors) { string content = null; if (model != null) { content = model.ShortUrl; } else if (errors != null) { StringBuilder errorBuilder = new StringBuilder(); foreach (Error error in errors) { foreach (string message in error.Messages) { errorBuilder.AppendLine("{0}: {1}".FormatWith(error.Parameter, message)); } } content = errorBuilder.ToString(); } if (string.IsNullOrWhiteSpace(content)) { content = TextMessages.SomethingUnholyGoingOn; } return(content); }
public void RemoveFromCollection2x() { RallyRestApi restApi = GetRallyRestApi2x(); DynamicJsonObject newStory = new DynamicJsonObject(); newStory["Name"] = "Test Story"; var itemRef = restApi.Create("hierarchicalrequirement", newStory).Reference; DynamicJsonObject newDefect = new DynamicJsonObject(); newDefect["Name"] = "New Defect Added via collection"; newDefect["Requirement"] = itemRef; CreateResult newTaskResult = restApi.Create("defect", newDefect); DynamicJsonObject story = restApi.GetByReference(itemRef, "Defects"); Assert.AreEqual(1, story["Defects"]["Count"]); DynamicJsonObject taskToRemove = new DynamicJsonObject(); taskToRemove["_ref"] = newTaskResult.Reference; OperationResult result = restApi.RemoveFromCollection(itemRef, "Defects", new List <DynamicJsonObject>() { taskToRemove }, new NameValueCollection()); Assert.IsTrue(result.Success); Assert.AreEqual(0, result.Results.Count); story = restApi.GetByReference(itemRef, "Defects"); Assert.AreEqual(0, story["Defects"]["Count"]); // Now delete the defect and story TestHelperDeleteItem(restApi, newTaskResult.Reference); TestHelperDeleteItem(restApi, itemRef); }
/// <summary> /// <para>新規ユーザーを登録します.</para> /// </summary> /// <param name="model"></param> /// <returns></returns> public UserCreateResultModel CreateUser(CreateUserModel model) { CreateResult result = CreateResult.Success; ValidationErrors validErrors = ValidationErrors.Create(); string errorMessage = string.Empty; try { var user = model.CreateUser(); var identityResult = UserMng.Create(user, model.Password); if (!identityResult.Succeeded) { result = CreateResult.Failed; errorMessage = CreateErrorMessage(identityResult.Errors); } } catch (TemplateValidationException e) { result = CreateResult.ValidError; validErrors = e.ValidErrors; } catch { result = CreateResult.Failed; } return(UserCreateResultModel.Create(model, result, validErrors, errorMessage)); }
public void CreateAsyncTest() { TimeoutHelper.ThrowExceptionInTimeout(() => { CreateResult result = null; var identifier = System.Guid.NewGuid().ToString(); try { var creation_group_result = APIReference.Instance.LargePersonGroupInstance.CreateAsync(identifier, identifier, identifier).Result; System.Diagnostics.Trace.Write($"Creation Result: {creation_group_result}"); if (creation_group_result) { result = APIReference.Instance.LargePersonGroupPersonInstance.CreateAsync(identifier, identifier, identifier).Result; } } catch { throw; } finally { var deletion_person_result = APIReference.Instance.LargePersonGroupPersonInstance.DeleteAsync(identifier, result.personId).Result; System.Diagnostics.Trace.Write($"Deletion Result: {deletion_person_result}"); var deletion_group_result = APIReference.Instance.LargePersonGroupInstance.DeleteAsync(identifier).Result; System.Diagnostics.Trace.Write($"Deletion Result: {deletion_group_result}"); } Assert.True(result != null); }); }
static void Main(string[] args) { RallyRestApi restApi = new RallyRestApi(webServiceVersion: "v2.0"); String apiKey = "_abc777"; restApi.Authenticate(apiKey, "https://rally1.rallydev.com", allowSSO: false); String workspaceRef = "/workspace/123"; String projectRef = "/project/134"; DynamicJsonObject badDefect = new DynamicJsonObject(); badDefect["Name"] = "bad defect 2" + DateTime.Now; badDefect["Project"] = projectRef; CreateResult createRequest = restApi.Create(workspaceRef, "Defect", badDefect); badDefect = restApi.GetByReference(createRequest.Reference, "FormattedID", "Project", "State"); Console.WriteLine(badDefect["FormattedID"] + " " + badDefect["Project"]._refObjectName + " " + badDefect["State"]); badDefect["State"] = "Open"; OperationResult updateRequest = restApi.Update(badDefect["_ref"], badDefect); Console.WriteLine("Success? " + updateRequest.Success); Console.WriteLine("updated State: " + badDefect["State"]); }
public async Task <CreateResult> CreateAsync(CreateInput input) { var requestTemplate = @" <methodCall> <methodName>domain.create</methodName> <params> <param> <value><string>§model.ApiKey§</string></value></param> <param> <value><string>§model.Data.Domain§</string></value></param> <param> <struct> <member><name>admin</name><value><string>§model.Data.DomainCreate.Admin§</string></value></member> <member><name>bill</name><value><string>§model.Data.DomainCreate.Bill§</string></value></member> <member><name>owner</name><value><string>§model.Data.DomainCreate.Owner§</string></value></member> <member><name>tech</name><value><string>§model.Data.DomainCreate.Tech§</string></value></member> <member><name>duration</name><value><int>§model.Data.DomainCreate.Duration§</int></value></member> </struct></param> </params> </methodCall>"; var methodResponse = await MethodResponse(requestTemplate, input); var result = new CreateResult(); return(result); }
private async Task <CreateResult> CreateWithParents(CreateRequest request) { while (true) { var parentPath = ZooKeeperPath.GetParentPath(request.Path); if (parentPath == null) { return(CreateResult.Unsuccessful( ZooKeeperStatus.BadArguments, request.Path, new ArgumentException($"Can't get parent path for `{request.Path}`"))); } var result = await CreateAsync(new CreateRequest(parentPath, CreateMode.Persistent)).ConfigureAwait(false); if (!result.IsSuccessful && result.Status != ZooKeeperStatus.NodeAlreadyExists) { return(CreateResult.Unsuccessful(result.Status, request.Path, result.Exception)); } result = await ExecuteOperation(new CreateOperation(request)).ConfigureAwait(false); if (result.Status != ZooKeeperStatus.NodeNotFound) { return(result); } // Note(kungurtsev): someone has deleted our parent since we checked, create it again. } }
public void CreateStakingMarket_Success() { const uint transactionFee = 3; var marketOwner = Owner; var createParams = new object[] { transactionFee, StakingToken }; SetupCreate <OpdexStakingMarket>(CreateResult.Succeeded(StakingMarket), 0, createParams); var createRouterParams = new object[] { StakingMarket, transactionFee, false, false }; SetupCreate <OpdexRouter>(CreateResult.Succeeded(Router), 0, createRouterParams); var deployer = CreateNewOpdexMarketDeployer(); SetupMessage(Deployer, marketOwner); State.SetContract(StakingToken, true); var market = deployer.CreateStakingMarket(StakingToken); market.Should().Be(StakingMarket); VerifyLog(new CreateMarketLog { Market = StakingMarket, Owner = marketOwner, Router = Router, TransactionFee = transactionFee, StakingToken = StakingToken, MarketFeeEnabled = true }, Times.Once); }
public void CreateStandardPool_Success(bool authProviders, bool authTraders, uint fee) { const bool authPoolCreators = false; var market = CreateNewOpdexStandardMarket(authPoolCreators, authProviders, authTraders, fee); State.SetContract(Token, true); var parameters = new object[] { Token, market.TransactionFee, market.AuthProviders, market.AuthTraders, false }; SetupCreate <OpdexStandardPool>(CreateResult.Succeeded(Pool), parameters: parameters); var pool = market.CreatePool(Token); market.GetPool(Token).Should().Be(pool).And.Be(Pool); market.AuthProviders.Should().Be(authProviders); market.AuthTraders.Should().Be(authTraders); market.TransactionFee.Should().Be(fee); market.Owner.Should().Be(Owner); var expectedPoolCreatedLog = new CreateLiquidityPoolLog { Token = Token, Pool = Pool }; VerifyLog(expectedPoolCreatedLog, Times.Once); }
public void CreateStandardMarket_Success(bool authPoolCreators, bool authProviders, bool authTraders, uint fee) { var marketOwner = Trader0; var createParams = new object[] { marketOwner, authPoolCreators, authProviders, authTraders, fee }; SetupCreate <OpdexStandardMarket>(CreateResult.Succeeded(StandardMarket), 0, createParams); var deployer = CreateNewOpdexMarketDeployer(); SetupMessage(Deployer, Owner); var market = deployer.CreateStandardMarket(marketOwner, authPoolCreators, authProviders, authTraders, fee); market.Should().Be(StandardMarket); VerifyLog(new CreateMarketLog { Market = StandardMarket, Owner = marketOwner, AuthPoolCreators = authPoolCreators, AuthProviders = authProviders, AuthTraders = authTraders, Fee = fee }, Times.Once); }
public async Task Create_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken) { var args = new CreateArgs(); await args.ReadAsync(iprot, cancellationToken); await iprot.ReadMessageEndAsync(cancellationToken); var result = new CreateResult(); try { result.Success = await _iAsync.CreateAsync(args.Person, cancellationToken); await oprot.WriteMessageBeginAsync(new TMessage("Create", TMessageType.Reply, seqid), cancellationToken); await result.WriteAsync(oprot, cancellationToken); } catch (TTransportException) { throw; } catch (Exception ex) { Console.Error.WriteLine("Error occurred in processor:"); Console.Error.WriteLine(ex.ToString()); var x = new TApplicationException(TApplicationException.ExceptionType.InternalError, " Internal error."); await oprot.WriteMessageBeginAsync(new TMessage("Create", TMessageType.Exception, seqid), cancellationToken); await x.WriteAsync(oprot, cancellationToken); } await oprot.WriteMessageEndAsync(cancellationToken); await oprot.Transport.FlushAsync(cancellationToken); }
static void Main(string[] args) { RallyRestApi restApi = new RallyRestApi(webServiceVersion: "v2.0"); String apiKey = "_abc123"; restApi.Authenticate(apiKey, "https://rally1.rallydev.com", allowSSO: false); String workspaceRef = "/workspace/123"; String projectRef = "/project/456"; Request request = new Request("PortfolioItem/Feature"); request.Fetch = new List <string>() { "Name", "FormattedID" }; request.Query = new Query("FormattedID", Query.Operator.Equals, "F2356"); QueryResult result = restApi.Query(request); String featureRef = result.Results.First()._ref; Console.WriteLine("found" + featureRef); //create stories try { for (int i = 1; i <= 25; i++) { DynamicJsonObject story = new DynamicJsonObject(); story["Name"] = "story " + i; story["PlanEstimate"] = new Random().Next(2, 10); story["PortfolioItem"] = featureRef; story["Project"] = projectRef; CreateResult createResult = restApi.Create(workspaceRef, "HierarchicalRequirement", story); story = restApi.GetByReference(createResult.Reference, "FormattedID"); Console.WriteLine("creating..." + story["FormattedID"]); } //read stories DynamicJsonObject feature = restApi.GetByReference(featureRef, "UserStories"); Request storiesRequest = new Request(feature["UserStories"]); storiesRequest.Fetch = new List <string>() { "FormattedID", "PlanEstimate" }; storiesRequest.Limit = 1000; QueryResult storiesResult = restApi.Query(storiesRequest); int storyCount = 0; foreach (var userStory in storiesResult.Results) { Console.WriteLine(userStory["FormattedID"] + " " + userStory["PlanEstimate"]); storyCount++; } Console.WriteLine(storyCount); } catch (Exception e) { Console.WriteLine(e); } }
public void StartGame_Success() { // Set up create for player vs opponent. this.mockInternalExecutor.Setup(s => s.Create <Player>( It.IsAny <ISmartContractState>(), It.IsAny <ulong>(), It.Is <object[]>(o => (Address)o[0] == PlayerAddress && (Address)o[1] == OpponentAddress), It.IsAny <ulong>())) .Returns(CreateResult.Succeeded(PlayerContractAddress)); // Set up create for opponent vs player. this.mockInternalExecutor.Setup(s => s.Create <Player>( It.IsAny <ISmartContractState>(), It.IsAny <ulong>(), It.Is <object[]>(o => (Address)o[0] == OpponentAddress && (Address)o[1] == PlayerAddress), It.IsAny <ulong>())) .Returns(CreateResult.Succeeded(OpponentContractAddress)); var starter = new Starter(this.mockContractState.Object); starter.StartGame(PlayerAddress, OpponentAddress, "Test"); this.mockInternalExecutor.Verify( s => s.Create <Player>( this.mockContractState.Object, 0, It.Is <object[]>(o => (Address)o[0] == PlayerAddress && (Address)o[1] == OpponentAddress && (string)o[2] == "Test"), 0), Times.Once); this.mockInternalExecutor.Verify( s => s.Create <Player>( this.mockContractState.Object, 0, It.Is <object[]>(o => (Address)o[0] == OpponentAddress && (Address)o[1] == PlayerAddress && (string)o[2] == "Test"), 0), Times.Once); this.mockContractLogger.Verify( l => l.Log( It.IsAny <ISmartContractState>(), new Starter.GameCreated { Player1Contract = PlayerContractAddress, Player2Contract = OpponentContractAddress, GameName = "Test" }), Times.Once); }
public ResponseMessage <List <AEmployee> > Get() { var list = _employeeService.LoadEntities(e => true).Select(e => new AEmployee { Id = e.Id, Name = e.Name }).ToList(); return(CreateResult.For(list)); }
public ResponseMessage <IEnumerable <Dictionary <string, string> > > Get() { var list = from c in User.Claims select new Dictionary <string, string> { { c.Type, c.Value } }; return(CreateResult.For(list)); }
public ResponseMessage <List <T_Teacher> > GetTeachersList_D() { dynamic result; var list = _SqlDB.Query <T_Teacher>("SELECT * FROM T_Teacher"); result = CreateResult.For(list, list.Count); return(result); }
public static TodoItemCreateResultModel Create(CreateTodoItemModel model, CreateResult result, ValidationErrors validErrors = null) { return(new TodoItemCreateResultModel { Name = model.Name, Result = result, ValidErrors = validErrors ?? ValidationErrors.Create(), }); }
public ResponseMessage <List <TTeacher> > GetTeachersList() { dynamic result; var list = _dbContext.TTeacher.ToList(); result = CreateResult.For(list, list.Count); return(result); }
protected IOpdexMarketDeployer CreateNewOpdexMarketDeployer() { SetupBalance(0); SetupBlock(10); SetupMessage(Deployer, Owner); SetupCreate <OpdexStakingMarket>(CreateResult.Succeeded(StakingMarket), 0ul, new object[] { StakingToken, (uint)3 }); return(new OpdexMarketDeployer(_mockContractState.Object, StakingToken)); }