public async Task <ActionResult <CryptoItem> > PostCryptoItem(CryptoItem item)
{
_context.CryptoItems.Add(item);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetCryptoItem), new { id = item.Id }, item));
}
// This method tests Enjin's non-runtime API methods mostly used in the editor window.
private void TestStaticEndpoints()
{
// Helper methods.
TestMethod(() => { Enjin.StoreUserData(new User(), "test"); }, "user data storage");
TestMethod <Boolean>(() => { return(Enjin.ValidateAddress("0xf629cbd94d3791c9250152bd8dfbdf380e2a3b9c")); }, true, "address validation");
TestMethod(() => { Enjin.URLGetData("https://enjincoin.io/", new System.Collections.Generic.Dictionary <string, string>()); }, "fetching URL data");
TestMethod <String>(() => { return(Enjin.URLGetData("bad URL", new System.Collections.Generic.Dictionary <string, string>())); }, string.Empty, "expected result from bad URL data");
TestMethod(() => { Enjin.ResetErrorReport(); }, "error report reset");
// CryptoItems methods.
TestMethod(() => { Enjin.GetCryptoItemBalance(testingIdentityID, TESTING_ITEM_ID); }, "balance by identity");
TestMethod(() => { Enjin.GetMintableItems(TESTING_ITEM_ID); }, "mintable item retrieval");
TestMethod(() => {
CryptoItem item = Enjin.GetCryptoItem(TESTING_ITEM_ID);
Enjin.GetCryptoItemIDByName(item.name);
}, "item identity by name");
TestMethod(() => { Enjin.GetCryptoItemBalances(testingIdentityID); }, "all balances by identity");
TestMethod(() => { Enjin.UpdateCryptoItem(new CryptoItem()); }, "item updating");
TestMethod(() => { Enjin.GetAllCryptoItems(); }, "searching all items");
TestMethod(() => {
CryptoItem item = Enjin.GetCryptoItem(TESTING_ITEM_ID);
Enjin.GetCryptoItemIDByName(item.name);
}, "searching for item name");
TestMethod(() => { Enjin.GetAllItems(0, 0, DEVELOPER_IDENTITY_ID); }, "getting all items by page");
TestMethod(() => { Enjin.GetAllItems(DEVELOPER_IDENTITY_ID); }, "getting all items");
// Enjin Platform API methods.
TestMethod(() => { Enjin.GetTotalActiveTokens(DEVELOPER_IDENTITY_ID); }, "getting all active tokens");
TestMethod(() => { Enjin.GetAppsByUserID(loginUser.id); }, "getting apps for user");
TestMethod(() => { Enjin.GetAppByID(APP_ID); }, "getting app by id");
// Identity methods.
TestMethod(() => { Enjin.UpdateBalances(new Identity()); }, "identity balance updates");
TestMethod(() => { Enjin.GetIdentity(testingIdentityID); }, "identity retrieval");
TestMethod(() => { Enjin.GetAllIdentities(); }, "bulk identity retrieval");
TestMethod(() => { Enjin.SearchIdentities("enjin"); }, "identity search");
Identity sampleIdentity = new Identity
{
user = new Identity.User
{
name = loginUser.name,
id = loginUser.id
},
id = testingIdentityID,
fields = new Fields[] { new Fields("test", "enjin", 0, 0, 0) }
};
TestMethod(() => { Enjin.UpdateIdentity(sampleIdentity); }, "identity update");
Enjin.AccessToken = TESTER_TOKEN;
TestMethod(() => { Enjin.UpdateIdentityFields(testingIdentityID, new Fields[] { new Fields("test", "enjin!", 0, 0, 0) }); }, "identity field update");
TestMethod(() => { Enjin.LinkIdentity(sampleIdentity); }, "identity link");
TestMethod(() => { Enjin.UnLinkIdentity(testingIdentityID); }, "identity unlinking");
TestMethod(() => { Enjin.DeleteIdentity(testingIdentityID + ""); }, "identity deletion");
TestMethod(() => { Enjin.CreateIdentity(sampleIdentity); }, "identity creation");
TestMethod(() => { Enjin.GetRoles(); }, "fetching identity roles");
TestMethod(() => { Enjin.GetIdentities(0, 0); }, "fetching identity pages");
}
public IActionResult Encrypt(string data)
{
string secretKey = "dR7s?ufreWa=r*G_ZEphA*Ra";
var symmetricEncryptDecrypt = new SymmetricTripleDesCipher();
CryptoItem response = symmetricEncryptDecrypt.Encrypt(data, secretKey);
return(Ok(new { Value = response.EncryptedData, IV = response.IV }));
}
public async Task <IActionResult> PutCryptoItem(long id, CryptoItem item)
{
if (id != item.Id)
{
return(BadRequest());
}
_context.Entry(item).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(NoContent());
}
/// <summary>
///
/// </summary>
/// <param name="cryptoItem"></param>
/// <param name="meltValue"></param>
/// <returns></returns>
private CryptoItem SetMeltValue(CryptoItem cryptoItem, float meltValue)
{
string minValue = GraphQLClient.GraphQuery.GetEndPointData(Enjin.MeltValueURL + cryptoItem.reserve);
decimal actual = (decimal)(meltValue * Mathf.Pow(10, 18));
if (actual < System.Convert.ToInt64(minValue))
{
cryptoItem.meltValue = minValue;
}
else
{
cryptoItem.meltValue = actual.ToString("0");
}
return(cryptoItem);
}
/// <summary>
/// Local UI reset function for working CI object
/// </summary>
public void Reset()
{
//CurrentCryptoItem = new CryptoItem();
NewCryptoItem = new CryptoItem();
MetaDataURI = "";
Whitelist.Clear();
MeltValue = 0;
MeltFee = 0;
NumToMint = 1;
NumToMelt = 0;
TotalItems = 0;
InitialItems = 1;
EnjValue = 0;
State = CryptoItemState.MAIN;
IsEditingWhitelist = false;
ScrollIndex = Vector2.zero;
Address = "";
UpdateEnjPerItem();
}
public CryptoItemsController()
{
_resultQueue = new Dictionary <string, Result>();
ModelType = SupplyModel2.FIXED;
ItemType = CryptoItemType.FUNGIBLE;
CurrentPage = 1;
FirstPage = 1;
PageNumber = "01";
Pagination = Enjin.GetAllItems(CurrentPage, EnjinEditor.ItemsPerPage, EnjinEditor.CurrentUserIdentity.id);
SelectedIndex = 0;
SearchOptionIndex = 0;
InitialItems = 1;
FilterSelection = 1;
LastFilterSelected = 1;
ListItems = new string[9];
SelectedIndex = 0;
EnjValue = 0;
ScrollPos = Vector2.zero;
LastFilterSelected = 1;
CurrentCryptoItem = new CryptoItem();
HasListRefreshed = true;
IsSearchMode = false;
Whitelist = new List <string>();
NumToMelt = 0;
EnjReturned = 0;
EnjPerItem = 0;
MinWei = System.Convert.ToInt64(GraphQLClient.GraphQuery.GetEndPointData(Enjin.MeltValueURL + 1));
if (Pagination != null)
{
TotalPages = (int)Mathf.Ceil((float)Pagination.cursor.total / (float)Pagination.cursor.perPage);
CryptoItemList = new List <CryptoItem>(Pagination.items);
}
Reset();
Properties = new Dictionary <string, object>();
}
private void Update()
{
// Sequence lock to wait for a successful callback on linking a wallet.
if (sequenceOne)
{
sequenceOne = false;
Debug.Log("(5/8) Sending an item from the developer account to the testing account ... ");
Enjin.AccessToken = DEVELOPER_TOKEN;
// Mint a new token directly from the developer wallet.
CryptoItem item = Enjin.GetCryptoItem(TESTING_ITEM_ID);
string reserveCount = item.reserve;
int developerBalance = Enjin.GetCryptoItemBalance(DEVELOPER_IDENTITY_ID, TESTING_ITEM_ID);
if (!reserveCount.Equals("0"))
{
Enjin.MintFungibleItem(DEVELOPER_IDENTITY_ID, new string[] { USER_ADDRESS }, TESTING_ITEM_ID, 1,
(requestEvent) =>
{
if (requestEvent.event_type.Equals("tx_executed"))
{
Debug.Log(" ... PASSED: MINTED.");
sequenceTwo = true;
}
});
}
// If the developer wallet is unable to mint reward tokens from the reserve, try to send it from the developer wallet.
else if (developerBalance > 0)
{
Enjin.SendCryptoItemRequest(DEVELOPER_IDENTITY_ID, TESTING_ITEM_ID, testingIdentityID, 1, sendData =>
{
if (sendData.event_type.Equals("tx_executed"))
{
Debug.Log(" ... PASSED: SENT.");
sequenceTwo = true;
}
});
}
// Otherwise there really is nothing of this token left for the developer to give out.
else
{
Debug.Log(" ... FAILED: NO RESERVE TO MINT OR BALANCE TO SEND.");
}
}
// Sequence lock to wait for a successful callback on sending an item.
if (sequenceTwo)
{
sequenceTwo = false;
Debug.Log("(6/8) Trading an item from the testing account to the developer account ... ");
Enjin.AccessToken = TESTER_TOKEN;
CryptoItem tradeToItem = new CryptoItem
{
token_id = TESTING_ITEM_ID,
nonFungible = false
};
CryptoItem tradeFromItem = new CryptoItem
{
token_id = TESTING_ITEM_ID,
nonFungible = false
};
testingIdentity = Enjin.GetIdentity(testingIdentityID);
Identity developerIdentity = Enjin.GetIdentity(DEVELOPER_IDENTITY_ID);
Enjin.CreateTradeRequest(testingIdentityID, new CryptoItem[] { tradeToItem }, new int[] { 1 },
DEVELOPER_IDENTITY_ID, new CryptoItem[] { tradeFromItem }, new int[] { 1 }, tradeData =>
{
tradeId = tradeData.request_id;
Debug.Log(" ... PASSED.");
sequenceThree = true;
});
}
// Sequence lock to wait for successful trade creation before completion.
if (sequenceThree)
{
sequenceThree = false;
Debug.Log("(7/8) Completing trade from the testing account to the developer account ... ");
Enjin.AccessToken = DEVELOPER_TOKEN;
Enjin.CompleteTradeRequest(DEVELOPER_IDENTITY_ID, "" + tradeId, tradeData =>
{
Debug.Log(" ... PASSED.");
sequenceFour = true;
});
}
// Sequence lock to wait for successful trade of item before melting.
if (sequenceFour)
{
sequenceFour = false;
Debug.Log("(8/8) Melting an item on the testing account ... ");
Enjin.AccessToken = TESTER_TOKEN;
Enjin.MeltTokens(testingIdentityID, TESTING_ITEM_ID, 1, meltData =>
{
Debug.Log(" ... PASSED.");
sequenceFive = true;
});
}
// Sequence lock to wait for successful completion of all tests before running static suite.
if (sequenceFive)
{
sequenceFive = false;
// Execute additional tests for non-runtime SDK calls.
TestStaticEndpoints();
Debug.Log("=== All tests executed successfully. ===");
}
}
// Initialize the game state on start.
private void Start()
{
pendingActions = new List <System.Action>();
score = 0;
linkingCode = "";
identityId = -1;
userAddress = "";
user = null;
count = 0;
pending = 0;
tokenName = "";
// Initialize references to scene objects.
status = GameObject.Find("Status").GetComponent <Text>();
tutorial = GameObject.Find("Tutorial").GetComponent <Text>();
authenticationPanel = GameObject.Find("Authentication Panel");
registrationPanel = GameObject.Find("Registration Panel");
registrationEmail = registrationPanel.transform.Find("Email").GetComponent <InputField>();
proceedToLoginPanel = GameObject.Find("Proceed to Login Panel");
loginPanel = GameObject.Find("Login Panel");
loginEmail = loginPanel.transform.Find("Email").GetComponent <InputField>();
loginPassword = loginPanel.transform.Find("Password").GetComponent <InputField>();
gamePanel = GameObject.Find("Game Panel");
inventory = gamePanel.transform.Find("Inventory").GetComponent <Text>();
rewardTokenImage = gamePanel.transform.Find("Reward Image").GetComponent <Image>();
rewardMask = gamePanel.transform.Find("Reward Mask").gameObject;
rewardMaskImage = rewardMask.GetComponent <Image>();
panelList = new List <GameObject>
{
authenticationPanel,
registrationPanel,
proceedToLoginPanel,
loginPanel,
gamePanel
};
// Prepare the first scene.
ShowPanel(authenticationPanel);
tutorial.text = Resources.Load <TextAsset>("auth-method-tutorial").text;
// Start the Enjin SDK.
Enjin.StartPlatform(PLATFORM_URL, DEVELOPER_USERNAME, DEVELOPER_PASSWORD, APP_ID);
Debug.Log("<color=aqua>[Simple Game]</color> Using app with ID " + Enjin.AppID);
// Retrieve the specified reward token's metadata.
CryptoItem rewardToken = Enjin.GetCryptoItem(REWARD_TOKEN_ID);
StartCoroutine(rewardToken.GetMetadata((metadataInfo) =>
{
// Handle any potential errors in metadata retrieval.
MetadataInfo.MetadataRequestState requestState = metadataInfo.state;
switch (requestState)
{
case MetadataInfo.MetadataRequestState.PARSE_FAILED:
SetStatus("Unable to parse the reward item's metadata.");
break;
case MetadataInfo.MetadataRequestState.RETRIEVAL_FAILED:
SetStatus("Unable to retrieve the reward item's metadata.");
break;
case MetadataInfo.MetadataRequestState.SUCCESS:
{
tokenName = metadataInfo.metadata.name;
StartCoroutine(rewardToken.GetImage((imageInfo) =>
{
// Handle any potential errors with retrieving the item image.
ImageInfo.ImageRequestState imageRequestState = imageInfo.state;
switch (imageRequestState)
{
case ImageInfo.ImageRequestState.BAD_METADATA:
SetStatus("Unable to handle item metadata for the image.");
break;
case ImageInfo.ImageRequestState.RETRIEVAL_FAILED:
SetStatus("Unable to retrieve the reward item's image.");
break;
case ImageInfo.ImageRequestState.SUCCESS:
rewardTokenImage.sprite = imageInfo.image;
break;
}
}));
break;
}
}
}));
}
// On each update, check the current game state and handle logic appropriately.
void Update()
{
// Handle any events posted here from an asynchronous Enjin task.
for (int i = 0; i < pendingActions.Count; i++)
{
System.Action action = pendingActions[i];
action();
}
pendingActions.Clear();
// Reward the users with a token every time they get 15 clicks.
if (score >= SCORE_THRESHOLD)
{
score = 0;
SetStatus("Linked successfully.\nYour score is: " + score, false);
rewardMask.transform.localScale = new Vector3(1, 1, 1);
// Mint a new token directly from the developer wallet.
CryptoItem item = Enjin.GetCryptoItem(REWARD_TOKEN_ID);
string reserveCount = item.reserve;
int developerBalance = Enjin.GetCryptoItemBalance(DEVELOPER_IDENTITY_ID, REWARD_TOKEN_ID);
if (!reserveCount.Equals("0"))
{
pending += 1;
Enjin.MintFungibleItem(DEVELOPER_IDENTITY_ID, new string[] { userAddress }, REWARD_TOKEN_ID, 1,
(requestEvent) =>
{
if (requestEvent.event_type.Equals("tx_executed"))
{
pending -= 1;
count += 1;
pendingActions.Add(() =>
{
inventory.text = (tokenName + "\nYou have: " + count + "\nCurrently pending: " + pending);
});
}
});
inventory.text = (tokenName + "\nYou have: " + count + "\nCurrently pending: " + pending);
}
// If the developer wallet is unable to mint reward tokens from the reserve, try to send it from the developer wallet.
else if (developerBalance > 0)
{
pending += 1;
Enjin.SendCryptoItemRequest(DEVELOPER_IDENTITY_ID, REWARD_TOKEN_ID, identityId, 1,
(requestEvent) =>
{
if (requestEvent.event_type.Equals("tx_executed"))
{
pending -= 1;
count += 1;
pendingActions.Add(() =>
{
inventory.text = (tokenName + "\nYou have: " + count + "\nCurrently pending: " + pending);
});
}
});
inventory.text = (tokenName + "\nYou have: " + count + "\nCurrently pending: " + pending);
}
// Otherwise there really is nothing of this token left for the developer to give out.
else
{
SetStatus("Uh oh! The game developer is out of reward items!", true);
}
}
}
public CompoundQuery(ProcessTasks task, CryptoItem cryptoItem, Dictionary <string, object> properties)
{
this.Task = task;
this.CryptoItem = cryptoItem;
this.Properties = properties;
}
/// <summary>
///
/// </summary>
/// <param name="cryptoItem"></param>
/// <param name="action"></param>
/// <returns></returns>
private Request SendCreateRequest(CryptoItem cryptoItem, Action <RequestEvent> action)
{
Request request = Enjin.CreateCryptoItem(cryptoItem, EnjinEditor.CurrentUserIdentity.id, action);
return(request);
}
public void HandleChainedRequestAction(Request request, RequestEvent requestEvent, ProcessTasks task, CryptoItem cryptoItem, Dictionary <string, object> properties)
{
Debug.Log("<color=violet>[Handler Request]</color> " + JsonUtility.ToJson(request));
Result result = new Result
{
Type = Result.Types.CRYPTOITEMS,
Request = request,
Refresh = true,
Message = JsonUtility.ToJson(request),
Status = (EnjinEditor.IsRequestSuccessfull(request.state)) ? Status.SUCCESS : Status.FAILURE
};
CompoundQuery query = new CompoundQuery(task, requestEvent.data.token, properties);
result.compoundQueries.Add(query);
EnjinEditor.NotificationMonitor.ResultsQueue.Add(System.Guid.NewGuid().ToString(), result);
//_resultQueue.Add(System.Guid.NewGuid().ToString(), result);
}
internal Request ProcessCryptoItem(ProcessTasks task, CryptoItem cryptoItem, Dictionary <string, object> properties)
{
Request request = new Request();
string editMetaDataURI = "";
switch (task)
{
case ProcessTasks.CREATE:
string minValue = GraphQLClient.GraphQuery.GetEndPointData(Enjin.MeltValueURL + cryptoItem.reserve);
if (properties.ContainsKey("MeltValue"))
{
decimal actual = (decimal)((float)properties["MeltValue"] * Mathf.Pow(10, 18));
if (actual < System.Convert.ToInt64(minValue))
{
cryptoItem.meltValue = minValue;
}
else
{
cryptoItem.meltValue = actual.ToString("0");
}
}
else
{
cryptoItem.meltValue = minValue;
}
if (properties.ContainsKey("MetaDataURI"))
{
request = Enjin.CreateCryptoItem(cryptoItem, EnjinEditor.CurrentUserIdentity.id, ItemCreated => { HandleChainedRequestAction(request, ItemCreated, ProcessTasks.SETURI, cryptoItem, properties); });
}
else
{
request = Enjin.CreateCryptoItem(cryptoItem, EnjinEditor.CurrentUserIdentity.id, ItemCreated => { HandleRequestAction(request); });
}
return(request);
case ProcessTasks.DELETE:
break;
case ProcessTasks.EDIT:
if (cryptoItem.isCreator)
{
// handle name changes
if (properties.ContainsKey("ItemName"))
{
string editItemName = (string)properties["ItemName"];
if (editItemName != cryptoItem.name)
{
Debug.Log("running name change");
string temp = cryptoItem.name;
cryptoItem.name = editItemName;
request = Enjin.UpdateCryptoItem(EnjinEditor.CurrentUserIdentity.id, cryptoItem, CryptoItemFieldType.NAME, ItemUpdated => { HandleRequestAction(request); });
cryptoItem.name = temp;
}
}
// handle metadata URI changes
if (properties.ContainsKey("MetaDataURI"))
{
editMetaDataURI = (string)properties["MetaDataURI"];
if (editMetaDataURI != cryptoItem.itemURI)
{
Debug.Log("running meta data URI update");
request = Enjin.SetCryptoItemURI(EnjinEditor.CurrentUserIdentity.id, cryptoItem, editMetaDataURI, URISet => { HandleRequestAction(request); });
}
}
return(request);
}
return(null);
case ProcessTasks.MELT:
int numToMelt = 1;
if (properties.ContainsKey("NumToMelt"))
{
numToMelt = (int)properties["NumToMelt"];
}
if (cryptoItem.nonFungible)
{
Debug.Log("running melt request for non-fungible CI");
request = Enjin.MeltTokens(EnjinEditor.CurrentUserIdentity.id, cryptoItem.token_id, cryptoItem.index, numToMelt, MeltItem => { HandleRequestAction(request); });
}
else
{
Debug.Log("running melt request for fungible CI");
request = Enjin.MeltTokens(EnjinEditor.CurrentUserIdentity.id, cryptoItem.token_id, numToMelt, MeltItem => { HandleRequestAction(request); });
}
return(request);
case ProcessTasks.MINT:
string[] addresses = new string[] { };
if (properties.ContainsKey("RecieverAddress"))
{
addresses = (string[])properties["RecieverAddress"];
}
if (!cryptoItem.nonFungible)
{
int numToMint = 0;
if (properties.ContainsKey("NumToMint"))
{
numToMint = (int)properties["NumToMint"];
}
// Request should be pushed to event system to register the request by id, then the action callback should push to a method that fires off the seturi method once executed.
request = Enjin.MintFungibleItem(EnjinEditor.CurrentUserIdentity.id, addresses, cryptoItem.token_id, numToMint, ItemMinted => { HandleRequestAction(request); });
}
else
{
// Request should be pushed to event system to register the request by id, then the action callback should push to a method that fires off the seturi method once executed.
request = Enjin.MintNonFungibleItem(EnjinEditor.CurrentUserIdentity.id, addresses, cryptoItem.token_id, ItemMinted => { HandleRequestAction(request); });
}
return(request);
case ProcessTasks.SETURI:
// handle metadata URI changes
if (properties.ContainsKey("MetaDataURI"))
{
editMetaDataURI = (string)properties["MetaDataURI"];
if (editMetaDataURI != cryptoItem.itemURI)
{
Debug.Log("running meta data URI update");
request = Enjin.SetCryptoItemURI(EnjinEditor.CurrentUserIdentity.id, cryptoItem, editMetaDataURI, URISet => { HandleRequestAction(request); });
}
}
return(request);
default:
break;
}
return(null);
}
