// 비동기 방식 보낸 쪽지 리스트 조회
public void getSendMessageAsync()
{
BackendAsyncClass.BackendAsync(Backend.Social.Message.GetSentMessageList, (callback) =>
{
if (callback.IsSuccess())
{
JsonData jsonData = callback.GetReturnValuetoJSON()["rows"];
for (int i = 0; i < jsonData.Count; i++)
{
JsonData Data = jsonData[i];
string nickname = Data["receiverNickname"][0].ToString();
string inDate = Data["inDate"][0].ToString();
for (int j = 0; j < messageSendList.childCount; j++)
{
if (!messageReceivedList.GetChild(j).gameObject.activeSelf)
{
messageSendList.GetChild(j).GetChild(1).GetComponent <Text>().text = nickname + "\n님께 보냄";
messageSendList.GetChild(j).GetChild(2).GetComponent <Text>().text = inDate;
messageSendList.GetChild(j).gameObject.SetActive(true);
break;
}
}
}
}
});
}
// 비동기 방식 친구 리스트 조회
public void getFriendListAsync()
{
BackendAsyncClass.BackendAsync(Backend.Social.Friend.GetFriendList, (callback) =>
{
if (callback.IsSuccess())
{
JsonData jsonData = callback.GetReturnValuetoJSON()["rows"];
for (int i = 0; i < jsonData.Count; i++)
{
JsonData Data = jsonData[i];
string nickname = Data["nickname"][0].ToString();
string indate = Data["inDate"][0].ToString();
for (int j = 0; j < FriendList.childCount; j++)
{
if (!FriendList.GetChild(j).gameObject.activeSelf)
{
FriendList.GetChild(j).GetChild(1).GetComponent <Text>().text = nickname;
FriendList.GetChild(j).GetChild(2).GetComponent <Text>().text = indate;
FriendList.GetChild(j).gameObject.SetActive(true);
break;
}
}
}
print("비동기 방식 친구 리스트 조회 성공");
}
});
}
public IEnumerator ReceiveAdminPostAll()
{
BackendAsyncClass.BackendAsyncEnqueue(Backend.Social.Post.GetPostListV2, callback =>
{
bro = callback;
isPostSetting = true;
});
yield return(new WaitUntil(() => isPostSetting));
//bro = Backend.Social.Post.GetPostListV2();
for (int i = 0; i < listContent.childCount; i++)
{
try
{
var json = bro.GetReturnValuetoJSON()["fromAdmin"][i];
var title = json["title"][0].ToString();
var itemName = json["item"][0]["name"][0].ToString();
var itemCount = json["itemCount"][0].ToString();
var expirationDate = json["expirationDate"][0].ToString();
var inDate = json["inDate"][0].ToString();
// UI 세팅하면서
//(이미지, 제목, 날짜, 버튼 Listener)
// 아이콘 설정
var child = listContent.GetChild(i);
child.GetChild(0).GetChild(0).GetComponent <Image>().sprite = IconSetting(itemName);
child.GetChild(0).GetChild(0).GetComponent <Image>().SetNativeSize();
child.GetChild(0).GetChild(1).GetComponent <Text>().text = itemCount;
// 제목 설정
if (title.Length > POSTTITLELENGTH)
{
title = title.Substring(0, POSTTITLELENGTH);
child.GetChild(1).GetComponent <Text>().text = string.Format("{0} ...", title);
}
else
{
child.GetChild(1).GetComponent <Text>().text = string.Format(title);
}
// 만기 날짜 설정
var str = expirationDate.Split('T');
child.GetChild(2).GetComponent <Text>().text = string.Format("삭제 예정일 : <color=#67D3BB>{0}</color>", str[0]);
child.gameObject.SetActive(true);
// 딕셔너리에 넣기
itemNameList.Add(itemName);
itemCountList.Add(itemCount);
indateList.Add(inDate);
}
catch (System.Exception e)
{
Debug.Log(e);
break;
}
}
ChkPostCount();
}
public void LoadChart(System.Action loadAction)
{
BackendAsyncClass.BackendAsync(Backend.Chart.GetChartContents, field, (backendCallback) => {
JsonData jsonData = backendCallback.GetReturnValuetoJSON()["rows"];
gachaBoxChartInfos = new GachaBoxChartInfo[jsonData.Count];
for (int i = 0; i < jsonData.Count; i++)
{
gachaBoxChartInfos[i] = new GachaBoxChartInfo();
JsonData rowData = jsonData[i];
if (rowData["ItemId"]["S"].ToString() != "null")
{
gachaBoxChartInfos[i].ItemId = int.Parse(rowData["ItemId"]["S"].ToString());
}
if (rowData["GachaCount"]["S"].ToString() != "null")
{
gachaBoxChartInfos[i].GachaCount = int.Parse(rowData["GachaCount"]["S"].ToString());
}
}
if (loadAction != null)
{
loadAction();
}
});
}
// 비동기 방식 정보 읽기
public void readDataAsync()
{
BackendAsyncClass.BackendAsync(Backend.GameInfo.GetPrivateContents, "character", (callback) =>
{
if (callback.IsSuccess())
{
JsonData jsonData = callback.GetReturnValuetoJSON()["rows"][0];
string level = jsonData["level"][0].ToString();
string exp = jsonData["exp"][0].ToString();
string gunLevel = jsonData["weapon"][0]["gun"][0].ToString();
string knifeLevel = jsonData["weapon"][0]["knife"][0].ToString();
string punchLevel = jsonData["weapon"][0]["punch"][0].ToString();
dataIndate = jsonData["inDate"][0].ToString();
print($"Level : {level} Exp : {exp}");
print($"Gun : LV.{gunLevel} Knife : LV.{knifeLevel} Punch : LV.{punchLevel}");
print("비동기 방식 정보 읽기 완료");
}
else
{
Error(callback.GetErrorCode(), "gameData");
}
});
}
public void LoadChart(System.Action loadAction)
{
BackendAsyncClass.BackendAsync(Backend.Chart.GetChartContents, field, (backendCallback) => {
JsonData jsonData = backendCallback.GetReturnValuetoJSON()["rows"];
textChartInfos = new TextChartInfo[jsonData.Count];
for (int i = 0; i < jsonData.Count; i++)
{
textChartInfos[i] = new TextChartInfo();
JsonData rowData = jsonData[i];
if (rowData["TextId"]["S"].ToString() != "null")
{
textChartInfos[i].TextId = rowData["TextId"]["S"].ToString();
}
if (rowData["Ko"]["S"].ToString() != "null")
{
textChartInfos[i].Ko = rowData["Ko"]["S"].ToString();
}
if (rowData["En"]["S"].ToString() != "null")
{
textChartInfos[i].En = rowData["En"]["S"].ToString();
}
}
if (loadAction != null)
{
loadAction();
}
});
}
private void LoadMusicScoreData()
{
if (!Backend.IsInitialized || ID.Equals("") || ID == null)
{
return;
}
BackendAsyncClass.BackendAsync(Backend.GameInfo.GetPrivateContents, "ScoreTable", UserDataBro =>
{
if (UserDataBro.IsSuccess())
{
int cnt = UserDataBro.GetReturnValuetoJSON()["rows"].Count;
for (int i = 0; i < cnt; i++)
{
string DBmusic = UserDataBro.GetReturnValuetoJSON()["rows"][i]["Music"]["S"].ToString();
string DBscore = UserDataBro.GetReturnValuetoJSON()["rows"][i]["Score"]["S"].ToString();
string t_Indate = UserDataBro.GetReturnValuetoJSON()["rows"][i]["inDate"]["S"].ToString();
MusicScoredata.Add(Tuple.Create(DBmusic, DBscore, t_Indate));
}
}
else
{
Debug.Log(UserDataBro.GetMessage());
}
});
}
public void LoadMaxScoreData()
{
if (!Backend.IsInitialized)
{
return;
}
BackendAsyncClass.BackendAsync(Backend.GameInfo.GetPublicContents, "MaxScore", UserDataBro =>
{
if (UserDataBro.IsSuccess())
{
int cnt = UserDataBro.GetReturnValuetoJSON()["rows"].Count;
Debug.Log("DBcnt: " + cnt);
for (int i = 0; i < cnt; i++)
{
string DBID = UserDataBro.GetReturnValuetoJSON()["rows"][i]["ID"]["S"].ToString();
string DBMaxscore = UserDataBro.GetReturnValuetoJSON()["rows"][i]["MaxScore"]["N"].ToString();
string DBIndate = UserDataBro.GetReturnValuetoJSON()["rows"][i]["inDate"]["S"].ToString();
if (DBID == ID)
{
maxScore = int.Parse(DBMaxscore);
maxScoreIndate = DBIndate;
}
MaxScoredata.Add(Tuple.Create(DBID, DBMaxscore, DBIndate));
}
}
else
{
Debug.Log(UserDataBro.GetMessage());
}
});
}
public void SaveScore()
{
//백그라운드 비동기통신 (프라이베잇으로 테이블네임을 가져오는데 그걸 유저데이터에 저장)
BackendAsyncClass.BackendAsync(Backend.GameInfo.GetPrivateContents, "Score", UserDataBro =>
{
if (UserDataBro.IsSuccess()) //성공시
{
Param data = new Param(); //키값처리
data.Add("Scores", score);
if (UserDataBro.GetReturnValuetoJSON()["rows"].Count > 0) //가져온 데이터의 개수를 세서 0보다 많다 = 이미 데이터가 들어가있다
{
string t_Indate = UserDataBro.GetReturnValuetoJSON()["rows"][0]["inDate"]["S"].ToString(); //수정할 식별값 가져오기
BackendAsyncClass.BackendAsync(Backend.GameInfo.Update, "Score", t_Indate, data, (t_callback) => //데이터로 수정해서 콜백으로 받아옴
{
});
}
else //데이터 없으니 새로 만듬
{
BackendAsyncClass.BackendAsync(Backend.GameInfo.Insert, "Score", data, (t_callback) =>
{
});
}
}
});
}
public void LoadChart(System.Action loadAction)
{
BackendAsyncClass.BackendAsync(Backend.Chart.GetChartContents, field, (backendCallback) => {
JsonData jsonData = backendCallback.GetReturnValuetoJSON()["rows"];
foodChartInfos = new FoodChartInfo[jsonData.Count];
for (int i = 0; i < jsonData.Count; i++)
{
foodChartInfos[i] = new FoodChartInfo();
JsonData rowData = jsonData[i];
if (rowData["FoodId"]["S"].ToString() != "null")
{
foodChartInfos[i].FoodId = int.Parse(rowData["FoodId"]["S"].ToString());
}
if (rowData["Image"]["S"].ToString() != "null")
{
foodChartInfos[i].Image = foodSpriteAtlas.GetSprite(rowData["Image"]["S"].ToString());
}
}
if (loadAction != null)
{
loadAction();
}
});
}
public void GetRankingListToday(System.Action callback)
{
rankingUserInfos.Clear();
BackendReturnObject bro = Backend.Utils.GetServerTime();
string time = bro.GetReturnValuetoJSON()["utcTime"].ToString();
DateTime dateTime = DateTime.Parse(time);
TimeSpan timeSpan = new TimeSpan(dateTime.Ticks);
long totalDays = (long)timeSpan.TotalDays;
int row = (int)(totalDays % 8);
string todayUuid = uuid[row];
BackendAsyncClass.BackendAsync(Backend.RTRank.GetRTRankByUuid, todayUuid, 100, (rankingByUuidCallback) => {
switch (rankingByUuidCallback.GetStatusCode())
{
case "404":
Debug.Log("랭킹 Uuid가 틀린 경우");
break;
}
JsonData jsonData = rankingByUuidCallback.GetReturnValuetoJSON()["rows"];
for (int i = 0; i < jsonData.Count; i++)
{
string nickname = jsonData[i]["nickname"].ToString();
float score = float.Parse(jsonData[i]["score"]["N"].ToString());
int rank = int.Parse(jsonData[i]["rank"]["N"].ToString());
rankingUserInfos.Add(new RankingUserInfo(nickname, score, rank));
}
if (callback != null)
{
callback();
}
});
}
public void LoadChart(System.Action loadAction)
{
BackendAsyncClass.BackendAsync(Backend.Chart.GetChartContents, field, (backendCallback) => {
JsonData jsonData = backendCallback.GetReturnValuetoJSON()["rows"];
combinationChartInfos = new CombinationChartInfo[jsonData.Count];
for (int i = 0; i < jsonData.Count; i++)
{
combinationChartInfos[i] = new CombinationChartInfo();
JsonData rowData = jsonData[i];
if (rowData["CombinationId"]["S"].ToString() != "null")
{
combinationChartInfos[i].CombinationId = int.Parse(rowData["CombinationId"]["S"].ToString());
}
if (rowData["BeforeId"]["S"].ToString() != "null")
{
combinationChartInfos[i].BeforeId = int.Parse(rowData["BeforeId"]["S"].ToString());
}
if (rowData["Count"]["S"].ToString() != "null")
{
combinationChartInfos[i].Count = int.Parse(rowData["Count"]["S"].ToString());
}
if (rowData["AfterID"]["S"].ToString() != "null")
{
combinationChartInfos[i].AfterID = int.Parse(rowData["AfterID"]["S"].ToString());
}
}
if (loadAction != null)
{
loadAction();
}
});
}
public void GetPublicContents(string table, string key, System.Action sucess = null)
{
serverDataList.Clear();
BackendAsyncClass.BackendAsync(Backend.GameInfo.GetPublicContents, table, (callback) => {
switch (callback.GetStatusCode())
{
case "200": // 성공
break;
case "404": // 존재하지 않는 tableName인 경우
Debug.Log("존재하지 않는 tableName인 경우 ");
break;
case "400": // private table 아닌 tableName을 입력한 경우 또는 limit이 100이상인 경우
Debug.Log("public table 아닌 tableName 을 입력한 경우 또는 limit이 100이상인 경우");
break;
case "412": // 비활성화 된 tableName인 경우
Debug.Log("비활성화 된 tableName인 경우 ");
break;
default:
break;
}
if (callback.GetReturnValuetoJSON()[0].Count == 0) // 테이블에 해당 유저의 정보가 아무것도 없는 경우
{
if (sucess != null)
{
sucess();
}
}
else
{
for (int i = 0; i < callback.GetReturnValuetoJSON()[0].Count; i++)
{
JsonData jsonData = callback.GetReturnValuetoJSON()[0][i];
if (jsonData.Keys.Contains(key))
{
if (jsonData[key].Keys.Contains("L")) // 리스트형 데이터인지 아닌지
{
JsonData keyData = jsonData[key][0];
for (int j = 0; j < keyData.Count; j++)
{
serverDataList.Add(keyData[j][0].ToString());
}
}
else
{
serverDataList.Add(jsonData[key][0].ToString());
}
}
}
if (sucess != null)
{
sucess();
}
}
});
}
// 비동기 방식 회원가입
public void RegisterAsync()
{
BackendAsyncClass.BackendAsync(Backend.BMember.CustomSignUpAsync, ID.text, PW.text, (callback) =>
{
bro = callback;
isSuccess = true;
});
}
// 비동기 방식 로그인
public void LoginAsync()
{
BackendAsyncClass.BackendAsync(Backend.BMember.CustomLoginAsync, ID.text, PW.text, (callback) =>
{
bro = callback;
isSuccess = true;
});
}
public void SetScore(float score, System.Action scoreCallback = null)
{
//년-월-일-닉네임-점수
BackendReturnObject servertime = Backend.Utils.GetServerTime();
string time = servertime.GetReturnValuetoJSON()["utcTime"].ToString();
DateTime currentTime = DateTime.Parse(time);
TimeSpan timeSpan = new TimeSpan(currentTime.Ticks);
int year = currentTime.Year;
int month = currentTime.Month;
int day = currentTime.Day;
long totalDays = (long)timeSpan.TotalDays;
int row = (int)(totalDays % 8);
string key = "Score" + row;
Param param = new Param();
param.Add(key, score);
BackendGameInfo.instance.GetPrivateContents("Ranking", "inDate", () => {
string inDate = BackendGameInfo.instance.serverDataList[0];
BackendAsyncClass.BackendAsync(Backend.GameInfo.UpdateRTRankTable, "Ranking", key, inDate, (int)score, (updateRTRankTableCallback) => {
switch (updateRTRankTableCallback.GetErrorCode())
{
case "ForbiddenException":
Debug.Log("콘솔에서 실시간 랭킹을 활성화 하지 않고 갱신 요청을 한 경우");
return;
case "BadRankData":
Debug.Log("콘솔에서 실시간 랭킹을 생성하지 않고 갱신 요청을 한 경우");
Debug.Log("콘솔에서 Public 테이블로 실시간 랭킹을 생성한 경우");
Debug.Log("테이블 명 혹은 colum명이 존재하지 않는 경우");
return;
case "PreConditionError":
Debug.Log("한국시간(UTC+9) 4시 ~ 5시 사이에 실시간 랭킹 갱신 요청을 한 경우");
return;
case "ForbiddenError":
Debug.Log("퍼블릭테이블의 타인정보를 수정하고자 하였을 경우");
return;
case "NotFoundException":
Debug.Log("존재하지 않는 tableName인 경우");
return;
case "PreconditionFailed":
Debug.Log("비활성화 된 tableName인 경우");
return;
}
scoreCallback();
});
});
}
public void LoadChart(System.Action loadAction)
{
BackendAsyncClass.BackendAsync(Backend.Chart.GetChartContents, field, (backendCallback) => {
JsonData jsonData = backendCallback.GetReturnValuetoJSON()["rows"];
shopChartInfos = new ShopChartInfo[jsonData.Count];
for (int i = 0; i < jsonData.Count; i++)
{
shopChartInfos[i] = new ShopChartInfo();
JsonData rowData = jsonData[i];
if (rowData["ShopId"]["S"].ToString() != "null")
{
shopChartInfos[i].ShopId = int.Parse(rowData["ShopId"]["S"].ToString());
}
if (rowData["Type"]["S"].ToString() != "null")
{
shopChartInfos[i].Type = (ShopType)int.Parse(rowData["Type"]["S"].ToString());
}
if (rowData["Image"]["S"].ToString() != "null")
{
shopChartInfos[i].Image = shopSpriteAtlas.GetSprite(rowData["Image"]["S"].ToString());
}
if (rowData["Text"]["S"].ToString() != "null")
{
shopChartInfos[i].Text = rowData["Text"]["S"].ToString();
}
if (rowData["BuyType"]["S"].ToString() != "null")
{
shopChartInfos[i].BuyType = (BuyType)int.Parse(rowData["BuyType"]["S"].ToString());
}
if (rowData["BuyCount"]["S"].ToString() != "null")
{
shopChartInfos[i].BuyCount = int.Parse(rowData["BuyCount"]["S"].ToString());
}
if (rowData["BuyText"]["S"].ToString() != "null")
{
shopChartInfos[i].BuyText = rowData["BuyText"]["S"].ToString();
}
if (rowData["RewardType"]["S"].ToString() != "null")
{
shopChartInfos[i].RewardType = (RewardType)int.Parse(rowData["RewardType"]["S"].ToString());
}
if (rowData["RewardId"]["S"].ToString() != "null")
{
shopChartInfos[i].RewardId = int.Parse(rowData["RewardId"]["S"].ToString());
}
if (rowData["RewardCount"]["S"].ToString() != "null")
{
shopChartInfos[i].RewardCount = int.Parse(rowData["RewardCount"]["S"].ToString());
}
}
if (loadAction != null)
{
loadAction();
}
});
}
// 비동기 방식 이메일 등록
public void UpdateEmailAsync()
{
BackendAsyncClass.BackendAsync(Backend.BMember.UpdateCustomEmail, email.text, callback =>
{
if (callback.IsSuccess())
{
print("비동기 방식 이메일 등록 완료");
}
});
}
//public static string NumberNotation(double value)
//{
// return CurrencyNotationManager.ToCurrencyString(value);
// //return string.Format("{0:#,##0.####}", value);
//}
//public static string NumberNotation(decimal value)
//{
// return CurrencyNotationManager.ToCurrencyString(value);
// //return string.Format("{0:#,##0.####}", value);
//}
public static void SaveLogToServer(string param_Key, string param_Value, string type)
{
Param param = new Param();
param.Add(param_Key, param_Value);
BackendAsyncClass.BackendAsync(Backend.GameInfo.InsertLog, type, param,
(callback) =>
{ //Debug.Log(string.Format("'{0}'로그 저장", type));
});
}
// 비동기 방식 로그아웃
public void LogOutAsync()
{
BackendAsyncClass.BackendAsync(Backend.BMember.Logout, (callback) =>
{
if (callback.IsSuccess())
{
ID.text = PW.text = "";
loginState.text = "로그인 상태 : 비로그인";
print("비동기 방식 로그아웃 성공");
}
});
}
// 비동기 방식 유저 정보 가져오기
public void getUserInfoAsync()
{
BackendAsyncClass.BackendAsync(Backend.BMember.GetUserInfo, (callback) =>
{
JsonData returnJson = callback.GetReturnValuetoJSON()["row"];
userInfo.text = "nickName : " + returnJson["nickname"] +
"\ninDate : " + returnJson["inDate"].ToString() +
"\nsubscriptionType : " + returnJson["subscriptionType"].ToString() +
"\nemailForFindPassword : "******"emailForFindPassword"];
});
}
public void OnClickGetReward(int index)
{
//아이템 UP
ItemUp(itemNameList[index], long.Parse(itemCountList[index]));
//수령할 때 여기서 쏴주기(관리자 보상 수령)
BackendAsyncClass.BackendAsyncEnqueue(Backend.Social.Post.ReceiveAdminPostItemV2, indateList[index], callback => { Debug.Log(callback); });
//Backend.Social.Post.ReceiveAdminPostItemV2(indateList[index]);
//해당 오브젝트 false
listContent.GetChild(index).gameObject.SetActive(false);
ChkPostCount();
}
// 비동기 방식 보낸 쪽지 삭제
public void deleteSendMessageAsync()
{
string inDate = EventSystem.current.currentSelectedGameObject.transform.parent.GetChild(2).GetComponent <Text>().text;
BackendAsyncClass.BackendAsync(Backend.Social.Message.DeleteSentMessage, inDate, (callback) =>
{
if (callback.IsSuccess())
{
EventSystem.current.currentSelectedGameObject.transform.parent.gameObject.SetActive(false);
print("비동기 방식 보낸 쪽지 삭제 완료");
}
});
}
// 비동기 방식 친구 거절
public void RejectFriendAsync()
{
string inDate = EventSystem.current.currentSelectedGameObject.transform.parent.GetChild(2).GetComponent <Text>().text;
BackendAsyncClass.BackendAsync(Backend.Social.Friend.RejectFriend, inDate, (callback) =>
{
if (callback.IsSuccess())
{
EventSystem.current.currentSelectedGameObject.transform.parent.gameObject.SetActive(false);
print("비동기 방식 친구 거절 완료");
}
});
}
// 비동기 방식 회원탈퇴
public void SignOutAsync()
{
// BackendAsyncClass.BackendAsync(Backend.BMember.SignOut, "reason", ( callback )
// 비동기 방식도 이유를 작성할 수 있습니다.
BackendAsyncClass.BackendAsync(Backend.BMember.SignOut, (callback) =>
{
if (callback.IsSuccess())
{
ID.text = PW.text = "";
print("비동기 방식 회원탈퇴 성공");
}
});
}
// 비동기 방식 유저 찾기
public void getGammerIndateAsync()
{
BackendAsyncClass.BackendAsync(Backend.Social.GetGamerIndateByNickname, GamerNickname.text, (callback) =>
{
if (callback.IsSuccess())
{
JsonData GamerIndate = callback.GetReturnValuetoJSON()["rows"][0];
string indate = GamerIndate["inDate"][0].ToString();
print($"[비동기] {GamerNickname.text} 님의 inDate : {indate}");
}
});
}
// 비동기 방식 정보 삭제
public void deleteDataAsync()
{
BackendAsyncClass.BackendAsync(Backend.GameInfo.Delete, "character", dataIndate, (callback) =>
{
if (callback.IsSuccess())
{
print("비동기 방식 정보 삭제 성공");
}
else
{
Error(callback.GetErrorCode(), "gameData");
}
});
}
// 비동기 방식 쿠폰 사용
public void useCouponAsync()
{
BackendAsyncClass.BackendAsync(Backend.Coupon.UseCoupon, coupon.text, (callback) =>
{
if (callback.IsSuccess())
{
print("쿠폰 사용 성공");
}
else
{
Error(callback.GetErrorCode(), "Coupon");
}
});
}
// 비동기 방식 비밀번호 변경
public void UpdatePWAsync()
{
BackendAsyncClass.BackendAsync(Backend.BMember.UpdatePassword, PW.text, newPW.text, (callback) =>
{
if (callback.IsSuccess())
{
print("비동기 방식 비밀번호 변경 완료");
}
else
{
Error(callback.GetErrorCode(), "UserPW");
}
});
}
// 비동기 방식 비밀번호 초기화
public void ResetPWAsync()
{
BackendAsyncClass.BackendAsync(Backend.BMember.ResetPassword, ID.text, email.text, (callback) =>
{
if (callback.IsSuccess())
{
print("비동기 방식 초기화된 비밀번호 발송 완료");
}
else
{
Error(callback.GetErrorCode(), "UserPW");
}
});
}
