/// <summary> /// Melts a specific amount of tokens /// </summary> /// <param name="index">Index of item within a nonfungible item</param> /// <param name="identityID">Identity ID of user</param> /// <param name="tokenID">CryptoItem ID</param> /// <param name="amount">Numbner of cryptoItemss to melt</param> /// <returns>Melt request data from API</returns> public Request MeltItem(int identityID, string itemID, string index, int amount, System.Action <RequestEvent> callback) { if (index != "") { _query = @"mutation meltToken{request:CreateEnjinRequest(type:MELT,identity_id:$identityid^,melt_token_data:{token_id:""$itemid^"",token_index:""$index^"",value:$amount^}){id,encoded_data,state}}"; GraphQuery.variable["index"] = index.ToString(); } else { _query = @"mutation meltToken{request:CreateEnjinRequest(type:MELT,identity_id:$identityid^,melt_token_data:{token_id:""$itemid^"",value:$amount^}){id,encoded_data,state}}"; } GraphQuery.variable["identityid"] = identityID.ToString(); GraphQuery.variable["itemid"] = itemID.ToString(); GraphQuery.variable["amount"] = amount.ToString(); GraphQuery.POST(_query); if (Enjin.ServerResponse == ResponseCodes.SUCCESS) { Request request = JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2)); Enjin.RequestCallbacks.Add(request.id, callback); return(request); } return(null); }
/// <summary> /// Sends a Token on the Trusted Platform and blockchain using full CryptoItem. /// Allows for fungible and nonfungible token requests /// </summary> /// <param name="identityID">Identity ID of requestor</param> /// <param name="item">CryptoItem to be sent</param> /// <param name="recipientID">Identity ID of reciving wallet</param> /// <param name="value">Number of tokens to be sent</param> /// /// <param name="value">Callback function to execute when request is fulfilled</param> /// <returns>Create request data from API</returns> public Request SendItem(int identityID, CryptoItem item, int recipientID, int value, System.Action <string> handler, bool async = false) { _query = @"mutation sendItem{CreateEnjinRequest(appId:$appId^,type:SEND,identityId:$identityId^,send_token_data:{recipient_identity_id:$recipient_id^, token_id: ""$token_id^"", "; if (item.nonFungible) { _query += @"token_index: ""$item_index^"", "; } _query += "value:$value^}){id,encodedData,state}}"; GraphQuery.variable["appId"] = Enjin.AppID.ToString(); GraphQuery.variable["identityId"] = identityID.ToString(); GraphQuery.variable["token_id"] = item.id; if (item.nonFungible) { GraphQuery.variable["item_index"] = item.index; } GraphQuery.variable["recipient_id"] = recipientID.ToString(); GraphQuery.variable["value"] = value.ToString(); GraphQuery.POST(_query, "", async, (queryReturn) => { handler?.Invoke(queryReturn); }); if (GraphQuery.queryStatus == GraphQuery.Status.Complete) { return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); } return(null); }
/// <summary> /// Creates a new CryptoItem for current selected application /// </summary> /// <param name="newItem">CryptoItem to create</param> /// <param name="identityID">CryptoItem creator user identity ID</param> /// <returns>Request data</returns> public Request CreateCryptoItem(CryptoItem newItem, int identityID) { string query = string.Empty; if (newItem.icon != null) { query = "mutation createCryptoItem{request:CreateEnjinRequest(type:CREATE,identity_id:$identity^,create_token_data:{name:\"$name^\",totalSupply:$totalSupply^,initialReserve:$reserve^,supplyModel:$model^,meltValue:\"$meltValue^\",meltFeeRatio:$meltFee^,transferable:$transferable^,transferFeeSettings:{type:$fType^, token_id:\"$fToken^\",value:\"$fValue^\"},nonFungible:$nonFungible^,icon:\"$icon^\"}){id,encoded_data,state}}"; GraphQuery.variable["icon"] = newItem.icon; } else { query = "mutation createCryptoItem{request:CreateEnjinRequest(type:CREATE,identity_id:$identity^,create_token_data:{name:\"$name^\",totalSupply:$totalSupply^,initialReserve:$reserve^,supplyModel:$model^,meltValue:\"$meltValue^\",meltFeeRatio:$meltFee^,transferable:$transferable^,transferFeeSettings:{type:$fType^, token_id:\"$fToken^\",value:\"$fValue^\"},nonFungible:$nonFungible^}){id,encoded_data,state}}"; } GraphQuery.variable["name"] = newItem.name; GraphQuery.variable["identity"] = identityID.ToString(); GraphQuery.variable["totalSupply"] = newItem.totalSupply; GraphQuery.variable["reserve"] = newItem.reserve; GraphQuery.variable["model"] = newItem.supplyModel.ToString(); GraphQuery.variable["meltValue"] = newItem.meltValue; GraphQuery.variable["meltFee"] = newItem.meltFeeRatio.ToString(); GraphQuery.variable["transferable"] = newItem.transferable.ToString(); GraphQuery.variable["fType"] = newItem.transferFeeSettings.type.ToString(); GraphQuery.variable["fToken"] = newItem.transferFeeSettings.token_id; GraphQuery.variable["fValue"] = newItem.transferFeeSettings.value.ToString(); GraphQuery.variable["nonFungible"] = newItem.nonFungible.ToString().ToLower(); GraphQuery.POST(query); return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); }
/// <summary> /// Searches the CryptoItems globally for matching term /// </summary> /// <param name="term">term is what user is searching for</param> /// <returns>Array of CryptoItems found in search</returns> public CryptoItem[] SearchCryptoItems(string term) { string query = string.Empty; query = @"query searchCryptoItem{result:EnjinSearch(term:""$term^""){__typename... on EnjinToken {index,token_id,name,creator,totalSupply,reserve,circulatingSupply,supplyModel,meltValue,meltFeeRatio,meltFeeMaxRatio,transferable,transferFeeSettings{type,token_id,value},nonFungible,icon,balance,isCreator}}}"; GraphQuery.variable["term"] = term; GraphQuery.POST(query); List <CryptoItem> searchResults = new List <CryptoItem>(); //var results = JsonUtility.FromJson<JSONArrayHelper<CryptoItem>>(EnjinHelpers.GetJSONString(Regex.Replace(GraphQuery.queryReturn, @"(""[^""\\]*(?:\\.[^""\\]*)*"")|\s+", "$1"), 1)).result; var results = JSON.Parse(GraphQuery.queryReturn); string temp = EnjinHelpers.GetJSONString(Regex.Replace(GraphQuery.queryReturn, @"(""[^""\\]*(?:\\.[^""\\]*)*"")|\s+", "$1"), 1); var temp2 = JsonUtility.FromJson <JSONArrayHelper <CryptoItem> >(temp); for (int i = 0; i < temp2.result.Length; i++) { if (temp2.result[i].token_id != null) { temp2.result[i].supplyModel = (SupplyModel)Enum.Parse(typeof(SupplyModel), results["data"]["result"][i]["supplyModel"].Value); temp2.result[i].transferable = (Transferable)Enum.Parse(typeof(Transferable), results["data"]["result"][i]["transferable"].Value); temp2.result[i].transferFeeSettings.type = (TransferType)Enum.Parse(typeof(TransferType), results["data"]["result"][i]["transferFeeSettings"]["type"].Value); searchResults.Add(temp2.result[i]); } } //foreach (CryptoItem item in results) //{ // if (item.token_id != null) // searchResults.Add(item); //} return(searchResults.ToArray()); }
public Request SendItems(CryptoItemBatch sendItems, int userId) { _query = @"mutation advancedSend{CreateEnjinRequest(appId:$appId^,identityId:" + userId + ",type:ADVANCED_SEND,advanced_send_token_data:{transfers:["; for (int i = 0; i < sendItems.Items.Count; i++) { _query += "{" + sendItems.Items[i] + "}"; if (i < sendItems.Items.Count - 1) { _query += ","; } } _query += "]}){id,encodedData}}"; GraphQuery.variable["appId"] = Enjin.AppID.ToString(); GraphQuery.POST(_query); Debug.Log("<color=white>[DEBUG INFO]</color> " + _query); if (Enjin.ServerResponse == ResponseCodes.SUCCESS) { return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); } return(null); }
/// <summary> /// Sends a Token on the Trusted Platform and blockchain using full CryptoItem. /// Allows for fungible and nonfungible token requests /// </summary> /// <param name="identityID">Identity ID of requestor</param> /// <param name="item">CryptoItem to be sent</param> /// <param name="recipientID">Identity ID of reciving wallet</param> /// <param name="value">Number of tokens to be sent</param> /// /// <param name="value">Callback function to execute when request is fulfilled</param> /// <returns>Create request data from API</returns> public Request SendItem(int identityID, CryptoItem item, int recipientID, int value, System.Action <RequestEvent> callback) { _query = @"mutation sendItem{CreateEnjinRequest(type:SEND,identity_id:$identity_id^,send_token_data:{recipient_identity_id:$recipient_id^, token_id: ""$token_id^"", "; if (item.nonFungible) { _query += @"token_index: ""$item_index^"", "; } _query += "value:$value^}){id,encoded_data,state}}"; GraphQuery.variable["identity_id"] = identityID.ToString(); GraphQuery.variable["token_id"] = item.token_id.ToString(); if (item.nonFungible) { GraphQuery.variable["item_index"] = item.index.ToString(); } GraphQuery.variable["recipient_id"] = recipientID.ToString(); GraphQuery.variable["value"] = value.ToString(); GraphQuery.POST(_query); if (Enjin.ServerResponse == ResponseCodes.SUCCESS) { return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); } return(null); }
/// <summary> /// Gets all items in a pagination format /// </summary> /// <param name="page">Page to get</param> /// <param name="limit">Total items per page</param> /// <param name="identityID">Identity ID of user</param> /// <returns></returns> public PaginationHelper <CryptoItem> GetItems(int page, int limit, int identityID) { string query = string.Empty; if (limit == 0) { query = @"query getAllItems{result:EnjinIdentities(id:$id^){tokens(pagination:{page:$page^},include_creator_tokens:true){items{index,token_id,name,creator,totalSupply,reserve,circulatingSupply,supplyModel,meltValue,meltFeeRatio,meltFeeMaxRatio,transferable,transferFeeSettings{type,token_id,value},nonFungible,icon,balance,isCreator,markedForDelete}cursor{total,hasPages,perPage,currentPage}}}}"; } else { query = @"query getAllItems{result:EnjinIdentities(id:$id^){tokens(pagination:{limit:$limit^,page:$page^},include_creator_tokens:true){items{index,token_id,name,creator,totalSupply,reserve,circulatingSupply,supplyModel,meltValue,meltFeeRatio,meltFeeMaxRatio,transferable,transferFeeSettings{type,token_id,value},nonFungible,icon,balance,isCreator,markedForDelete}cursor{total,hasPages,perPage,currentPage}}}}"; GraphQuery.variable["limit"] = limit.ToString(); } GraphQuery.variable["id"] = identityID.ToString(); GraphQuery.variable["page"] = page.ToString(); GraphQuery.POST(query); var results = JSON.Parse(GraphQuery.queryReturn); string temp = EnjinHelpers.GetJSONString(Regex.Replace(GraphQuery.queryReturn, @"(""[^""\\]*(?:\\.[^""\\]*)*"")|\s+", "$1"), 3); var temp2 = JsonUtility.FromJson <PaginationHelper <CryptoItem> >(temp); for (int i = 0; i < temp2.items.Length; i++) { temp2.items[i].supplyModel = (SupplyModel)Enum.Parse(typeof(SupplyModel), results["data"]["result"][0]["tokens"]["items"][i]["supplyModel"].Value); temp2.items[i].transferable = (Transferable)Enum.Parse(typeof(Transferable), results["data"]["result"][0]["tokens"]["items"][i]["transferable"].Value); temp2.items[i].transferFeeSettings.type = (TransferType)Enum.Parse(typeof(TransferType), results["data"]["result"][0]["tokens"]["items"][i]["transferFeeSettings"]["type"].Value); } return(temp2); }
public Request CreateTradeRequest(int senderIdentityID, CryptoItem[] itemsFromSender, int[] amountsFromSender, string secondPartyAddress, int?secondPartyIdentityID, CryptoItem[] itemsFromSecondParty, int[] amountsFromSecondParty) { if (EnjinHelpers.IsNullOrEmpty(itemsFromSender) || EnjinHelpers.IsNullOrEmpty(amountsFromSender) || itemsFromSender.Length != amountsFromSender.Length) { return(null); } if (EnjinHelpers.IsNullOrEmpty(itemsFromSecondParty) || EnjinHelpers.IsNullOrEmpty(amountsFromSecondParty) || itemsFromSecondParty.Length != amountsFromSecondParty.Length) { return(null); } TokenValueInputData[] fromSender = new TokenValueInputData[itemsFromSender.Length]; TokenValueInputData[] fromSecondParty = new TokenValueInputData[itemsFromSecondParty.Length]; for (int i = 0; i < itemsFromSender.Length; i++) { CryptoItem item = itemsFromSender[i]; int amount = amountsFromSender[i]; fromSender[i] = new TokenValueInputData(item.token_id, item.index, amount); } for (int i = 0; i < itemsFromSecondParty.Length; i++) { CryptoItem item = itemsFromSecondParty[i]; int amount = amountsFromSecondParty[i]; fromSecondParty[i] = new TokenValueInputData(item.token_id, item.index, amount); } return(CreateTradeRequest(senderIdentityID, fromSender, secondPartyAddress, secondPartyIdentityID, fromSecondParty)); }
/// <summary> /// Melts a specific amount of tokens /// </summary> /// <param name="identityID">Identity ID of user</param> /// <param name="itemID">CryptoItem ID</param> /// <param name="index">Index of item within a nonfungible item</param> /// <param name="amount">Numbner of cryptoItemss to melt</param> /// <returns>Melt request data from API</returns> public Request MeltItem(int identityID, string itemID, string index, int amount, System.Action <string> handler, bool async = false) { if (index != "") { _query = @"mutation meltToken{request:CreateEnjinRequest(appId:$appId^,type:MELT,identityId:$identityid^,melt_token_data:{token_id:""$itemid^"",token_index:""$index^"",value:$amount^}){id,encodedData,state}}"; GraphQuery.variable["index"] = index; } else { _query = @"mutation meltToken{request:CreateEnjinRequest(appId:$appId^,type:MELT,identityId:$identityid^,melt_token_data:{token_id:""$itemid^"",value:$amount^}){id,encodedData,state}}"; } GraphQuery.variable["appId"] = Enjin.AppID.ToString(); GraphQuery.variable["identityid"] = identityID.ToString(); GraphQuery.variable["itemid"] = itemID; GraphQuery.variable["amount"] = amount.ToString(); GraphQuery.POST(_query, "", async, (queryReturn) => { handler?.Invoke(queryReturn); }); if (GraphQuery.queryStatus == GraphQuery.Status.Complete) { return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); } return(null); }
private string _query; // Query string to be sent to API /// <summary> /// Gets a specific request by ID /// </summary> /// <param name="id">Request ID</param> /// <returns>Request of specified ID</returns> public Request Get(int id) { _query = "query getRequest{request:EnjinTransactions(id:$id^){id,transaction_id,app_id,type,icon,title,value,state,accepted,updated_at,created_at}}"; GraphQuery.variable["id"] = id.ToString(); GraphQuery.POST(_query); return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(_query, 1))); }
/// <summary> /// Gets the platform information for intiializing platform /// </summary> /// <returns>PlatformInfo object containing platform info</returns> private PlatformInfo GetPlatformInfo() { GraphQuery.POST(Enjin.PlatformTemplate.GetQuery["GetPlatformInfo"], Enjin.AccessToken); Debug.Log(">>> fetched string " + EnjinHelpers.GetJSONString(GraphQuery.queryReturn)); return(JsonUtility.FromJson <PlatformInfo>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn))); }
/// <summary> /// Gets all requests made on the platform /// </summary> /// <returns>All requests on the platform</returns> public Request[] GetAll() { _query = "query getAllRequests{request:EnjinTransactions{id,transaction_id,app_id,type,icon,title,value,state,accepted,updated_at,created_at}}"; GraphQuery.POST(_query); var tData = JsonUtility.FromJson <JSONArrayHelper <Request> >(EnjinHelpers.GetJSONString(_query, 1)); return(tData.result); }
/// <summary> /// Gets all roles and permission for current application /// </summary> /// <returns>Array of Roles</returns> public Roles[] GetRoles() { GraphQuery.POST(Enjin.IdentityTemplate.GetQuery["GetRoles"]); if (Enjin.ServerResponse != ResponseCodes.SUCCESS) { return(null); } return(JsonUtility.FromJson <JSONArrayHelper <Roles> >(EnjinHelpers.GetJSONString(Regex.Replace(GraphQuery.queryReturn, @"(""[^""\\]*(?:\\.[^""\\]*)*"")|\s+", "$1"), 1)).result); }
/// <summary> /// Links an identity to a wallet or eth address /// </summary> /// <param name="identity">Identity to link</param> /// <returns>Updated identity </returns> public Identity Link(Identity identity) { GraphQuery.POST(string.Format(Enjin.IdentityTemplate.GetQuery["LinkIdentity"], identity.id.ToString(), identity.ethereum_address)); if (Enjin.ServerResponse != ResponseCodes.SUCCESS) { return(null); } return(JsonUtility.FromJson <Identity>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 1))); }
/// <summary> /// Creates a new identity for the requester's app under a given email address /// </summary> /// <param name="email">The email address to attempt creation with</param> /// <returns>Created Identity</returns> public Identity CreateByEmail(string email) { GraphQuery.POST(string.Format(Enjin.IdentityTemplate.GetQuery["CreateIdentityWithEmail"], email)); if (Enjin.ServerResponse != ResponseCodes.SUCCESS) { return(null); } return(JsonUtility.FromJson <Identity>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 1))); }
/// <summary> /// Creates a new identity /// </summary> /// <param name="newIdentity">New Identity to create</param> /// <returns>Created Identity</returns> public Identity Create(Identity newIdentity) { GraphQuery.POST(string.Format(Enjin.IdentityTemplate.GetQuery["CreateIdentity"], newIdentity.user.id.ToString(), newIdentity.ethereum_address, EnjinHelpers.GetFieldsString(newIdentity.fields))); if (Enjin.ServerResponse != ResponseCodes.SUCCESS) { return(null); } return(JsonUtility.FromJson <Identity>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 1))); }
/// <summary> /// Updates an identities fields property /// </summary> /// <param name="id">ID of idenitiy to update</param> /// <param name="fields">Updated fields object</param> /// <returns>Updated Identity</returns> public Identity UpdateFields(int id, Fields[] fields) { GraphQuery.POST(string.Format(Enjin.IdentityTemplate.GetQuery["UpdateFields"], id.ToString(), EnjinHelpers.GetFieldsString(fields)), Enjin.AccessToken); if (Enjin.ServerResponse != ResponseCodes.SUCCESS) { return(null); } return(JsonUtility.FromJson <Identity>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 1))); }
/// <summary> /// Gets a specific identity /// </summary> /// <param name="id">ID of identity to get</param> /// <returns>Identity associated with passed id</returns> public Identity Get(int id) { GraphQuery.POST(string.Format(Enjin.IdentityTemplate.GetQuery["GetIdentity"], id.ToString())); if (Enjin.ServerResponse != ResponseCodes.SUCCESS) { return(null); } return(JsonUtility.FromJson <JSONArrayHelper <Identity> >(EnjinHelpers.GetJSONString(Regex.Replace(GraphQuery.queryReturn, @"(""[^""\\]*(?:\\.[^""\\]*)*"")|\s+", "$1"), 1)).result[0]); }
/// <summary> /// Creates a new User /// </summary> /// <param name="name">User's username</param> /// <returns>Created user object</returns> public User Create(string name) { GraphQuery.POST(string.Format(Enjin.UserTemplate.GetQuery["CreateUser"], name)); if (Enjin.ServerResponse == ResponseCodes.SUCCESS) { return(JsonUtility.FromJson <User>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); } return(null); }
public Request MintNonFungibleItem(int senderID, string[] addresses, string itemID) { _query = @"mutation mintNFToken{request:CreateEnjinRequest(identity_id:$senderID^,type:MINT,mint_token_data:{token_id:""$itemID^"",recipient_address_array:$addresses^}){id,encoded_data,state}}"; GraphQuery.variable["senderID"] = senderID.ToString(); GraphQuery.variable["addresses"] = EnjinHelpers <string> .ConvertToJSONArrayString(addresses); GraphQuery.variable["itemID"] = itemID; GraphQuery.POST(_query); return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); }
/// <summary> /// Removes a role from the currenct application /// </summary> /// <param name="role">Name of role to remove</param> /// <returns>(True / False) if deleting a role was successful</returns> public Request DeleteRole(Roles role) { GraphQuery.POST(string.Format(Enjin.PlatformTemplate.GetQuery["DeleteRole"], role.name)); if (Enjin.ServerResponse == ResponseCodes.SUCCESS) { return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); } return(null); }
/// <summary> /// Updates App information /// </summary> /// <param name="app">App to update information for</param> /// <returns>Updated App</returns> public App UpdateApp(App app) { string query; query = @"mutation updateApp{App:UpdateEnjinApp(name:""$appName^"",description:""$appDescription^"",image:""$appImageURL^""){id,name,description,image}}"; GraphQuery.variable["appName"] = app.name; GraphQuery.variable["appDescription"] = app.description; GraphQuery.variable["appImageURL"] = app.image; GraphQuery.POST(query); return(JsonUtility.FromJson <App>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 1))); }
public Request MintFungibleItem(int senderID, string[] addresses, string itemID, int value) { _query = @"mutation mintFToken{request:CreateEnjinRequest(identity_id:$senderID^,type:MINT,mint_token_data:{token_id:""$itemID^"",recipient_address_array:$addresses^,value:$value^}){id,encoded_data,state}}"; GraphQuery.variable["senderID"] = senderID.ToString(); GraphQuery.variable["addresses"] = EnjinHelpers <string> .ConvertToJSONArrayString(addresses); GraphQuery.variable["itemID"] = itemID; GraphQuery.variable["value"] = value.ToString(); // EnjinHelpers<int>.ConvertToJSONArrayString(value); <- Use this for sending multiple mint values when using multiple addresses GraphQuery.POST(_query); return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); }
/// <summary> /// Updates user data /// </summary> /// <param name="id">ID of user to update</param> /// <param name="username">Updated username</param> /// <param name="email">Updated email</param> /// <returns>Updated user</returns> public User Update(int id, string username, string email, string roles) { string updRoles = string.Empty; if (roles != "[]") { updRoles = ",roles:" + roles; } GraphQuery.POST(string.Format(Enjin.UserTemplate.GetQuery["UpdateUser"], id.ToString(), username, email, updRoles)); return(JsonUtility.FromJson <User>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); }
/// <summary> /// Creates a new User /// </summary> /// <param name="username">User's username</param> /// <param name="email">User's email address</param> /// <param name="password">User's password</param> /// <param name="role">User's role</param> /// <returns>Created user object</returns> public User Create(string username, string email, string password, string role) { role = "\"" + role + "\""; GraphQuery.POST(string.Format(Enjin.UserTemplate.GetQuery["CreateUser"], username, password, email, role)); if (Enjin.ServerResponse == ResponseCodes.SUCCESS) { return(JsonUtility.FromJson <User>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); } return(null); }
/// <summary> /// Gets a specified user no matter what applicaiton it's associated to /// </summary> /// <param name="userID">ID of user to get</param> /// <param name="raw">Flag to turn on/off getting user from application only</param> /// <returns>Specified user</returns> public User GetRaw(int userID, bool raw = true) { if (!raw) { GraphQuery.POST(string.Format(Enjin.UserTemplate.GetQuery["GetUser"], userID.ToString())); } else { GraphQuery.POST(string.Format(Enjin.UserTemplate.GetQuery["GetUser"], userID.ToString()), Enjin.AccessToken); } var tData = JsonUtility.FromJson <JSONArrayHelper <User> >(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 1)); return(tData.result[0]); }
/// <summary> /// Cancels a request made by ID /// </summary> /// <param name="id">Request ID to cancel</param> /// <returns>Success of canceled request</returns> public bool Cancel(int id) { _query = "mutation cancelRequest{request:UpdateEnjinRequest(id:$id^,state:CANCELED_USER){id,state,transaction_id}}"; GraphQuery.variable["id"] = id.ToString(); GraphQuery.POST(_query); Request temp = JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 1)); if (temp.state == "CANCELED_USER") { return(true); } return(false); }
public static string ToGraphQL(TokenValueInputData data) { string val = @"{"; if (EnjinHelpers.IsNullOrEmpty(data.index)) { val += string.Format(@"id:""{0}"",value:{1}", data.id, data.value); } else { val += string.Format(@"id:""{0}"",index:{1},value:{2}", data.id, data.index, data.value); } val += @"}"; return(val); }
/// <summary> /// Creates a new Token on the Trusted Platform and blockchain /// </summary> /// <param name="identityID">Identity ID of creator</param> /// <param name="tokenID">Token ID to create</param> /// <param name="recipientID">Identity ID of reciving wallet</param> /// <param name="value">Number of tokens to be created</param> /// <returns>Create request data from API</returns> public Request SendItem(int identityID, string tokenID, int recipientID, int value) { _query = @"mutation sendItem{CreateEnjinRequest(type:SEND,identity_id:$identity_id^,send_token_data:{recipient_identity_id:$recipient_id^, token_id: ""$token_id^"", value:$value^}){id,encoded_data,state}}"; GraphQuery.variable["identity_id"] = identityID.ToString(); GraphQuery.variable["token_id"] = tokenID.ToString(); GraphQuery.variable["recipient_id"] = recipientID.ToString(); GraphQuery.variable["value"] = value.ToString(); GraphQuery.POST(_query); if (Enjin.ServerResponse == ResponseCodes.SUCCESS) { return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); } return(null); }
public Request CreateTradeRequest(int senderIdentityID, TokenValueInputData[] itemsFromSender, string secondPartyAddress, int?secondPartyIdentityID, TokenValueInputData[] itemsFromSecondParty) { if (EnjinHelpers.IsNullOrEmpty(itemsFromSender) || EnjinHelpers.IsNullOrEmpty(itemsFromSecondParty)) { return(null); } if (secondPartyAddress == null && !secondPartyIdentityID.HasValue) { return(null); } string askingStr = TokenValueInputData.ToGraphQL(itemsFromSecondParty); string offeringStr = TokenValueInputData.ToGraphQL(itemsFromSender); _query = @"mutation sendTrade{result:CreateEnjinRequest(appId:$appId^,identityId:$senderIdentityID^,type:CREATE_TRADE,create_trade_data:{asking_tokens:$askingTokens^,offering_tokens:$offeringTokens^"; if (secondPartyAddress != null) { _query += @",second_party_address:""$secondPartyAddress^"""; GraphQuery.variable["secondPartyAddress"] = secondPartyAddress; } else { _query += @",second_party_identity_id:$secondPartyIdentityID^"; GraphQuery.variable["secondPartyIdentityID"] = secondPartyIdentityID.ToString(); } _query += @"}){id,encodedData,state}}"; GraphQuery.variable["appId"] = Enjin.AppID.ToString(); GraphQuery.variable["senderIdentityID"] = senderIdentityID.ToString(); GraphQuery.variable["askingTokens"] = askingStr; GraphQuery.variable["offeringTokens"] = offeringStr; GraphQuery.POST(_query); if (Enjin.ServerResponse == ResponseCodes.SUCCESS) { return(JsonUtility.FromJson <Request>(EnjinHelpers.GetJSONString(GraphQuery.queryReturn, 2))); } return(null); }