/// <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);
}
