public ServerResponse<string, string, string> validateRegister(UserAccount userAccount, HttpRequestBase request)
{
ServerResponse<string, string, string> response =
new ServerResponse<string, string, string>(ErrorMessages.SuccessString, "", "");
var userAccounts = baseRepo.getDb().UserAccount.Where(x => x.Username == userAccount.Username);
if (userAccounts != null && userAccounts.Count() > 0)
{
response.status = ErrorMessages.ErrorString;
response.message = "A user account with that name already exists. Please choose a different Username.";
}
else
{
try
{
baseRepo.Add<UserAccount>(userAccount);
createOwinIdentity(userAccount, request);
}
catch (Exception e)
{
response.status = ErrorMessages.ErrorString;
response.message = "There was an error with your account creation. Please try again.";
}
}
return response;
}
public ChatClient()
{
m_client = new TcpClient();
m_lock = new object();
m_receiveThread = new Thread(Receive) { IsBackground = true };
OnFatalError += FatalError;
}
public void Read()
{
var tmpCxStringsFile = Path.GetTempFileName();
var tmpCxStringsDoc = XDocument.Parse("<aaa></aaa>");
tmpCxStringsDoc.Save(tmpCxStringsFile);
var tmpWebConfigFile = Path.GetTempFileName();
var tmpWebConfigDoc = XDocument.Parse((string) this.TestContext.DataRow["fileSystem"]);
var csElement = tmpWebConfigDoc.XPathSelectElement("/configuration/connectionStrings");
var attr = csElement.Attribute("configSource");
if (attr != null)
{
attr.Value = tmpCxStringsFile;
}
tmpWebConfigDoc.Save(tmpWebConfigFile);
var mockCxSettings = new Mock<ISitecoreConnectionSettings>();
mockCxSettings.SetupGet(cxSettings => cxSettings.WebRootPath).Returns(Path.GetDirectoryName(tmpWebConfigFile));
var driverSettings = new SitecoreDriverSettings() {CxSettings = mockCxSettings.Object};
var mockManager = new Mock<ISitecoreConnectionManager>();
var response = new ServerResponse<XElement>();
response.Data = XElement.Parse((string)this.TestContext.DataRow["server"]);
mockManager.Setup(m => m.GetSitecoreConfig()).Returns(response);
var reader = new Sitecore8AppConfigReader();
var doc = reader.Read(mockManager.Object, driverSettings, tmpWebConfigFile, false);
//
//Test by re-running the transformers. No changes should be reported.
var transformers = reader.GetTransformers(driverSettings);
foreach (var transformer in transformers)
{
Assert.IsFalse(transformer.Transform(doc));
}
}
public ServerResponse Do(string file, string op, string args)
{
ServerResponse response = new ServerResponse();
var f = fileProvider.GetFile(file);
if (f != null)
{
try
{
switch (op.ToLower())
{
case "delete":
response.Status = ResponseStatus.Success;
response.Message = LocaleHelper.Localizer.Get("DeleteSuccessfully");
break;
case "rename":
break;
}
}
catch (Exception ex)
{
response.Status = ResponseStatus.Exception;
response.Message = ex.Message;
}
}
return response;
}
public ServerResponse<string, string, string> validateLogin(UserAccount userAccount, HttpRequestBase request)
{
UserAccount existingAccount = null;
ServerResponse<string, string, string> response =
new ServerResponse<string, string, string>(ErrorMessages.SuccessString, "", "");
var userAccounts = baseRepo.getDb().UserAccount.Where(x => x.Username == userAccount.Username);
if (userAccounts != null && userAccounts.Count() > 0)
{
existingAccount = userAccounts.First();
if (existingAccount.UserPassword != userAccount.UserPassword)
{
response.status = ErrorMessages.ErrorString;
response.message = "Incorrect Password. Please confirm you spelled your Password correctly";
} else
{
createOwinIdentity(userAccount, request);
}
}
else
{
response.status = ErrorMessages.ErrorString;
response.message = "Username does not exist.";
}
return response;
}
public bool login(string number, string password)
{
_logedUser = "";
_logedPassword = "";
Connection conn = Connection.getInstance();
MessageFactory messageFactory = MessageFactory.getInstance();
string message = messageFactory.loginMessage(number, password);
string response = conn.sendMessage(message);
ServerResponse serverResponse = new ServerResponse(response);
if (serverResponse.getType() == "login")
{
if (serverResponse.getParams()["result"] == "success")
{
_logedUser = number;
_logedPassword = password;
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
public ChatClient()
{
m_client = new TcpClient();
m_recivedQueue = new Queue<MessageReceived>();
m_sendQueue = new Queue<byte[]>();
m_clientThread = new Thread(HandleClient) { IsBackground = true };
m_parseThread = new Thread(OnCommand) { IsBackground = true };
OnFatalError += FatalError;
}
private void handlerWS(ServerRequest request, ServerResponse response)
{
if (oldGateways.Count > 0) {
var inj = ( siteIndex++ ) % oldIndex.Count;
response.End(oldGateways[inj]);
return;
}
response.End();
}
public NetClient()
{
m_messageQueue = new Queue<string>();
m_lock = new object();
m_receiveThread = new Thread(Receive);
m_receiveThread.IsBackground = true;
m_parserThread = new Thread(Parse);
m_parserThread.IsBackground = true;
OnFatalError += new ServerResponse(FatalError);
}
private void handler(ServerRequest request, ServerResponse response)
{
var dict = new JsDictionary<string, string>();
dict["Content-Type"] = "text/html";
dict["Access-Control-Allow-Origin"] = "*";
if (oldIndex.Count > 0) {
response.WriteHead(200, dict);
var inj = ( siteIndex++ ) % oldIndex.Count;
response.End(oldIndex[inj]);
} else {
response.WriteHead(200, dict);
response.End();
}
}
void httpCallback(ServerResponse.ResponseData data, object userdata)
{
ServerResponse.Resopnse_1001 res = (ServerResponse.Resopnse_1001)data.Resonse;
string ret = "Page " + res.PageCount;
for(int i = 0; i <res.items.Count; i++)
{
ServerResponse.Item item = res.items[i];
ret +=item.UserName;
ret += ",";
ret += item.Score;
ret += ":";
}
Debug.Log("value" + ret);
}
public string createAccount(string number, string password, string name, string surname, string email)
{
Connection conn = Connection.getInstance();
MessageFactory messageFactory = MessageFactory.getInstance();
string message = messageFactory.createAccountMessage(number, password, name, surname, email);
string response = conn.sendMessage(message);
ServerResponse serverResponse = new ServerResponse(response);
if (serverResponse.getType() == "createAccount")
{
return serverResponse.getParams()["result"];
}
else
{
return "fail";
}
}
public ServerResponse SaveActivity(string client, string userId, string eventType, string eventName, DateTime actionTime,
string userType, string userName, string title, string desp,
string imgUrl, string detailUrl, string linkUrl, string userUrl, string siteName, string siteUrl,
string keywords)
{
var obj = new TimelineItem()
{
ClientId = client,
UserId = userId,
EventType = eventType,
EventName = eventName,
UserType = userType,
UserName = userName,
Title = title,
Decription = desp,
ImageUrl = imgUrl,
DetailUrl = detailUrl,
LinkUrl = linkUrl,
UserUrl = userUrl,
SiteName = siteName,
SiteUrl = siteUrl,
ActionTime = actionTime,
Keywords = keywords
};
ServerResponse result = new ServerResponse();
try
{
if (provider.SaveActivity(obj))
{
result.Status = ResponseStatus.Success;
}
else
{
result.Status = ResponseStatus.Failed;
}
}
catch (Exception ex)
{
result.Status = ResponseStatus.Exception;
result.Message = ex.Message;
}
return result;
}
public virtual ServerResponse<XElement> GetSitecoreConfig()
{
var response = new ServerResponse<XElement>();
try
{
if (this.DoLogin())
{
var document = XDocument.Parse(this.Client.DownloadString(this.GetConfigUrl));
this.DoLogout();
response.Data = document.Root;
}
}
catch (Exception ex)
{
response.AddException(ex);
}
return response;
}
public bool Authenticate(string username, string passwordHash)
{
string packet = "";
packet += RequestType.Authenticate.ToString() + "|";
packet += "username="******"|";
packet += "passhash=" + passwordHash + "|";
ServerResponse response = new ServerResponse(sendMessage(packet));
if (response.responseType == RequestType.Authenticate)
{
if (response.elements.ContainsKey("success"))
{
return bool.Parse(response.elements["success"]);
}
else return false;
}
else return false;
}
public ServerResponse Delete(string siteId, bool deleteRelated, [FromBody]string[] deleteIds)
{
ServerResponse response = new ServerResponse();
try
{
foreach (var k in deleteIds)
{
provider.Delete(siteId, k, deleteRelated);
}
response.Status = ResponseStatus.Success;
response.Message = LocaleHelper.Localizer.Get("DeleteSuccessfully");
}
catch (Exception ex)
{
response.Status = ResponseStatus.Exception;
response.Message = ex.Message;
}
return response;
}
public ServerResponse Create(string client, string group, string report)
{
ServerResponse result = new ServerResponse();
try
{
var path = ReportHelper.GetPath(client, group, report);
var dir = new DirectoryInfo(path);
if (!dir.Exists)
dir.Create();
result.Status = ResponseStatus.Success;
result.Message = "成功创建报表";
}
catch (Exception ex)
{
result.Status = ResponseStatus.Exception;
result.Message = ex.Message;
}
return result;
}
public string GetUserName(int ID, int Quantity)
{
ServerResponse resp = new ServerResponse();
NameValueCollection data = new NameValueCollection();
var dt = new DataTable("fooddata");
dt.Columns.Add("Id", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Rows.Add(1, "Hello");
dt.Rows.Add(2, "World");
dt.Rows.Add(1, "Foo"); // dupe key
var dt1 = new DataTable("citydata");
dt1.Columns.Add("Id", typeof(int));
dt1.Columns.Add("Name", typeof(string));
dt1.Rows.Add(1, "hcm");
dt1.Rows.Add(2, "hn");
dt1.Rows.Add(1, "cantho"); // dupe key
DataSet ds = new DataSet();
ds.Tables.Add(dt);
ds.Tables.Add(dt1);
var nvc = new NameValueCollection();
foreach (DataRow row in dt.Rows)
{
string key = row[0].ToString();
// tidy up key here
nvc.Add(key, row[1].ToString());
}
resp.setResponseData(nvc);
//resp.setResponseDataset(ds);
JavaScriptSerializer js = new JavaScriptSerializer();
string temp = js.Serialize(resp);
return temp;
//return UserBiz.GetUserName();
//string str =// "{Success:true,ErrorInfo:null,Data:{total:10,data:[{id:1,name:happy day site},{id:1,name:happy day site}]}}";
//return str;
}
public ServerResponse DeleteGroup(string client, string group)
{
ServerResponse result = new ServerResponse();
try
{
var path = ReportHelper.GetPath(client, group);
var dir = new DirectoryInfo(path);
if (dir.Exists)
{
dir.Delete(true);
}
result.Status = ResponseStatus.Success;
result.Message = "成功删除报表分组";
}
catch (Exception ex)
{
result.Status = ResponseStatus.Exception;
result.Message = ex.Message;
}
return result;
}
public IServerResponse ChangePassword(ChangePasswordInfo changePasswordInfo)
{
var client = GetClient(changePasswordInfo.ClientId);
var encryptor = GetClientEncryptor(client);
var hpwd = pwdEncryptor.Encrypt(changePasswordInfo.OldPassword);
var obj = repoUser.Query(o => o.UserId == changePasswordInfo.UserId && o.Password == hpwd).FirstOrDefault();
ServerResponse<Session> response = new ServerResponse<Session>();
if (obj == null)
{
response.Status = ResponseStatus.Failed;
response.Message = DAF.SSO.Resources.Locale(o => o.AccountNotFound);
}
else
{
if (changePasswordInfo.NewPassword != changePasswordInfo.ConfirmPassword)
{
response.Status = ResponseStatus.Failed;
response.Message = DAF.SSO.Resources.Locale(o => o.ConfirmPasswordIsNotSameToPassword);
}
else
{
obj.Password = pwdEncryptor.Encrypt(changePasswordInfo.NewPassword);
if (repoUser.Update(obj))
{
response.Status = ResponseStatus.Success;
response.Message = DAF.SSO.Resources.Locale(o => o.ChangePasswordSuccessfully);
}
else
{
response.Status = ResponseStatus.Failed;
response.Message = DAF.Core.Resources.Locale(o => o.SaveFailure);
}
}
}
return response;
}
public Task Invoke(IDictionary<string, object> env)
{
var serverRequest = new ServerRequest(env);
var serverResponse = new ServerResponse(env);
var hostContext = new HostContext(serverRequest, serverResponse);
var origins = serverRequest.RequestHeaders.GetHeaders("Origin");
if (origins != null && origins.Any(origin => !String.IsNullOrEmpty(origin)))
{
serverResponse.ResponseHeaders["Access-Control-Allow-Origin"] = origins;
serverResponse.ResponseHeaders["Access-Control-Allow-Credentials"] = AllowCredentialsTrue;
}
hostContext.Items[HostConstants.SupportsWebSockets] = env.ContainsKey(OwinConstants.WebSocketSupport);
serverRequest.DisableRequestBuffering();
serverResponse.DisableResponseBuffering();
_connection.Initialize(_resolver, hostContext);
return _connection.ProcessRequestAsync(hostContext);
}
public ServerResponse DeleteBookRemark(string remarkId)
{
ServerResponse result = new ServerResponse();
try
{
if (bookProvider.RemoveRemark(remarkId))
{
result.Status = ResponseStatus.Success;
result.Message = DAF.Core.Resources.Locale(o => o.DeleteSuccessfully);
}
else
{
result.Status = ResponseStatus.Failed;
result.Message = DAF.Core.Resources.Locale(o => o.DeleteFailure);
}
}
catch (Exception ex)
{
result.Status = ResponseStatus.Exception;
result.Message = ex.Message;
}
return result;
}
public ServerResponse AddPage(string client, string group, string report, string page)
{
ServerResponse result = new ServerResponse();
try
{
var path = Path.Combine(ReportHelper.GetPath(client, group, report), string.Format("{0}.cshtml", page));
FileInfo fi = new FileInfo(path);
if (!fi.Exists)
{
var fs = fi.Create();
fs.Close();
fs.Dispose();
fs = null;
}
result.Status = ResponseStatus.Success;
result.Message = "成功添加报表页面";
}
catch (Exception ex)
{
result.Status = ResponseStatus.Exception;
result.Message = ex.Message;
}
return result;
}
public RoleModel GetByRoleName(string name)
{
return(ServerResponse.Invoke <RoleModel>("api/role/getByName?name=" + name, "", "POST"));
}
public List <SalesWeeklyData> GetWeeklySales(int?id)
{
return(ServerResponse.Invoke <List <SalesWeeklyData> >("api/salesOrderItems/getWeeklyReportByProduct?id=" + id, "", "GET"));
}
public AsyncSocketMessage(ServerResponse response)
{
this.m_package = response.ToString() + DEFAULT_SEPARATOR + "1" + DEFAULT_SEPARATOR + "0";
}
public static EntityTemplate Player(EntityId entityId, string workerId, byte[] args)
{
var client = EntityTemplate.GetWorkerAccessAttribute(workerId);
var(spawnPosition, spawnYaw, spawnPitch) = SpawnPoints.GetRandomSpawnPoint();
var serverResponse = new ServerResponse
{
Position = spawnPosition.ToVector3Int()
};
var rotationUpdate = new RotationUpdate
{
Yaw = spawnYaw.ToInt1k(),
Pitch = spawnPitch.ToInt1k()
};
var pos = new Position.Snapshot {
Coords = Coordinates.FromUnityVector(spawnPosition)
};
var serverMovement = new ServerMovement.Snapshot {
Latest = serverResponse
};
var clientMovement = new ClientMovement.Snapshot {
Latest = new ClientRequest()
};
var clientRotation = new ClientRotation.Snapshot {
Latest = rotationUpdate
};
var shootingComponent = new ShootingComponent.Snapshot();
var gunComponent = new GunComponent.Snapshot {
GunId = PlayerGunSettings.DefaultGunIndex
};
var gunStateComponent = new GunStateComponent.Snapshot {
IsAiming = false
};
var healthComponent = new HealthComponent.Snapshot
{
Health = PlayerHealthSettings.MaxHealth,
MaxHealth = PlayerHealthSettings.MaxHealth,
};
var healthRegenComponent = new HealthRegenComponent.Snapshot
{
CooldownSyncInterval = PlayerHealthSettings.SpatialCooldownSyncInterval,
DamagedRecently = false,
RegenAmount = PlayerHealthSettings.RegenAmount,
RegenCooldownTimer = PlayerHealthSettings.RegenAfterDamageCooldown,
RegenInterval = PlayerHealthSettings.RegenInterval,
RegenPauseTime = 0,
};
var template = new EntityTemplate();
template.AddComponent(pos, WorkerUtils.UnityGameLogic);
template.AddComponent(new Metadata.Snapshot {
EntityType = "Player"
}, WorkerUtils.UnityGameLogic);
template.AddComponent(serverMovement, WorkerUtils.UnityGameLogic);
template.AddComponent(clientMovement, client);
template.AddComponent(clientRotation, client);
template.AddComponent(shootingComponent, client);
template.AddComponent(gunComponent, WorkerUtils.UnityGameLogic);
template.AddComponent(gunStateComponent, client);
template.AddComponent(healthComponent, WorkerUtils.UnityGameLogic);
template.AddComponent(healthRegenComponent, WorkerUtils.UnityGameLogic);
PlayerLifecycleHelper.AddPlayerLifecycleComponents(template, workerId, WorkerUtils.UnityGameLogic);
const int serverRadius = 150;
var clientRadius = workerId.Contains(WorkerUtils.MobileClient) ? 60 : 150;
// Position, Metadata, OwningWorker and ServerMovement are included in all queries, since these
// components are required by the GameObject creator.
// HealthComponent is needed by the LookAtRagdoll script for respawn behaviour.
// GunComponent is needed by the GunManager script.
var clientSelfInterest = InterestQuery.Query(Constraint.EntityId(entityId)).FilterResults(new[]
{
Position.ComponentId, Metadata.ComponentId, OwningWorker.ComponentId,
ServerMovement.ComponentId, HealthComponent.ComponentId, GunComponent.ComponentId
});
// ClientRotation is used for rendering other players.
// GunComponent is required by the GunManager script.
// GunStateComponent and ShootingComponent are needed for rendering other players' shots.
var clientRangeInterest = InterestQuery.Query(Constraint.RelativeCylinder(clientRadius)).FilterResults(new[]
{
Position.ComponentId, Metadata.ComponentId, OwningWorker.ComponentId,
ServerMovement.ComponentId, ClientRotation.ComponentId, HealthComponent.ComponentId,
GunComponent.ComponentId, GunStateComponent.ComponentId, ShootingComponent.ComponentId
});
// ClientMovement is used by the ServerMovementDriver script.
// ShootingComponent is used by the ServerShootingSystem.
var serverSelfInterest = InterestQuery.Query(Constraint.EntityId(entityId)).FilterResults(new[]
{
ClientMovement.ComponentId, ShootingComponent.ComponentId
});
// ClientRotation is used for driving player proxies.
// HealthComponent is required by the VisiblityAndCollision script.
// ShootingComponent is used by the ServerShootingSystem.
var serverRangeInterest = InterestQuery.Query(Constraint.RelativeCylinder(serverRadius)).FilterResults(new[]
{
Position.ComponentId, Metadata.ComponentId, OwningWorker.ComponentId,
ServerMovement.ComponentId, ClientRotation.ComponentId, HealthComponent.ComponentId,
ShootingComponent.ComponentId
});
var interest = InterestTemplate.Create()
.AddQueries <ClientMovement.Component>(clientSelfInterest, clientRangeInterest)
.AddQueries <ServerMovement.Component>(serverSelfInterest, serverRangeInterest);
template.AddComponent(interest.ToSnapshot());
template.SetReadAccess(WorkerUtils.UnityClient, WorkerUtils.UnityGameLogic, WorkerUtils.MobileClient);
return(template);
}
private async Task <bool> UploadResults(int index, Action OnFinish)
{
ShowLoading();
AppDataUpload upload = viewSource.Rows[index];
DatabaseManager dbManager = await Storage.GetDatabaseManager();
// Upload relevent files
bool success = await Storage.UploadFiles(
JsonConvert.DeserializeObject <List <FileUpload> >(upload.FilesJson),
index,
(percentage) =>
{
Console.WriteLine("Upload percentage: " + percentage);
loadPop.loadingLabel.Text = string.Format("Uploading: {0}%", percentage);
},
(listPos, jsonData) =>
{
viewSource.Rows[listPos].FilesJson = jsonData;
dbManager.UpdateUpload(viewSource.Rows[listPos]);
viewSource.UpdateData(dbManager.GetUploadQueue().ToList());
upload = viewSource.Rows[index];
},
(upload.UploadType == UploadType.NewActivity ||
upload.UploadType == UploadType.UpdatedActivity)?Storage.GetCacheFolder() : Storage.GetUploadsFolder()
);
if (!success)
{
HideLoading();
AppUtils.ShowSimpleDialog(this, "Unable to Upload", "Something went wrong, please try again later.", "Got it");
return(false);
}
ServerResponse <string> resp = new ServerResponse <string>();
if (upload.UploadType == UploadType.NewActivity ||
upload.UploadType == UploadType.UpdatedActivity)
{
resp = await ServerUtils.UploadActivity(upload, upload.UploadType == UploadType.UpdatedActivity);
}
else
{
// Uploading activity results
List <FileUpload> files = JsonConvert.DeserializeObject <List <FileUpload> >(upload.FilesJson);
AppTask[] results = JsonConvert.DeserializeObject <AppTask[]>(upload.JsonData) ?? new AppTask[0];
resp = await ServerUtils.UpdateAndPostResults(results, files, upload.UploadRoute);
}
HideLoading();
if (resp == null)
{
// do this but for iOS, fool
var suppress = AppUtils.SignOut(this);
return(false);
}
if (!resp.Success)
{
AppUtils.ShowSimpleDialog(this, "Unable to Upload", "Something went wrong, please try again later.", "Got it");
return(false);
}
dbManager.DeleteUpload(upload);
var newList = dbManager.GetUploadQueue().ToList();
viewSource.UpdateData(newList);
TableView.ReloadData();
await(ParentViewController as MainTabBarController).UpdateUploadsBadge(newList.Count);
ManageNavItems();
OnFinish?.Invoke();
return(true);
}
public bool Create(PendingItemReceiptModel model)
{
bool create = ServerResponse.Invoke <bool>("api/pendingReceipt/create", JsonConvert.SerializeObject(model), "POST");
return(create);
}
public TemplateModel Create(TemplateModel model)
{
TemplateModel result = ServerResponse.Invoke <TemplateModel>("api/template/create", JsonConvert.SerializeObject(model), "POST");
return(result);
}
// handles the complete battle
// first: player attacks chosen enemy
// then: enemy attacks random team member
// lastly: reset all battle states
private void HandleRound()
{
// check if player has won
if (m_Enemies.Count <= 0)
{
ResetBattlePhase();
UIControllerBattle.get.m_AttackButton.gameObject.SetActive(false);
UIControllerBattle.get.m_HelperMenuButton.gameObject.SetActive(false);
// Activate the ending screen
UIControllerBattle.get.m_EndingScreen.gameObject.SetActive(true);
string tmp = CheckForCharacterUnlock();
UIControllerBattle.get.m_EndingText.text = "You won!\n" + tmp;
if (PlayerData.LastSelectedLevel < 5)
{
ServerResponse sr = UserRequestLibrary.UnlockLevelForUser(PlayerData.LastSelectedLevel + 1);
}
return;
}
// if player lost
if (m_Team.Count <= 0)
{
ResetBattlePhase();
UIControllerBattle.get.m_AttackButton.gameObject.SetActive(false);
UIControllerBattle.get.m_HelperMenuButton.gameObject.SetActive(false);
// Activate the ending screen
UIControllerBattle.get.m_EndingScreen.gameObject.SetActive(true);
UIControllerBattle.get.m_EndingText.text = "You lost.. try again with a better team!";
return;
}
// round start
if (!m_roundInitialized)
{
// get gameobject of current team member
m_teamMember = m_LastSelectedTeamMember.gameObject;
// save last position of team member
m_teamMemberLastPos = m_teamMember.transform.position;
// get animator
m_teamMemberAnimator = m_teamMember.GetComponent <Animator>();
// attacker should overlap attacked
// save original sorting layer
m_teamMemberSpriteLayer = m_teamMember.GetComponent <SpriteRenderer>().sortingOrder;
m_teamMember.GetComponent <SpriteRenderer>().sortingOrder = 15;
// get gameobject of current enemy
m_enemyTarget = m_LastSelectedEnemy.gameObject;
// get animator
m_enemyTargetAnimator = m_enemyTarget.GetComponent <Animator>();
// let enemy sprite be under player sprite
// save original sorting layer
m_enemyTargetSpriteLayer = m_enemyTarget.GetComponent <SpriteRenderer>().sortingOrder;
m_enemyTarget.GetComponent <SpriteRenderer>().sortingOrder = 14;
// direction where team member is headed
m_direction = m_enemyTarget.transform.position - m_teamMember.transform.position;
m_direction.Normalize();
// round start done
m_roundInitialized = true;
// run animation
m_teamMemberAnimator.SetBool("IsRunning", true);
}
// player attack turn
else if (!m_PlayerAttacked)
{
// if is not playing animation
if (m_teamMemberAnimator != null && !m_teamMemberAnimator.GetBool("IsAttacking"))
{
// if enemy was reached, attack
if (m_teamMember.transform.position.x >= m_enemyTarget.transform.position.x - 1.5f)
{
m_teamMemberAnimator.SetBool("IsAttacking", true);
m_enemyTargetAnimator.SetTrigger("IsHurt");
}
// if enemy was not reached yet, return, so position can be updated
else
{
// move towards enemy
m_teamMember.transform.position += m_direction * m_MoveSpeed * Time.deltaTime;
return;
}
}
// if already is playing animation | wait for animation event to be called
else
{
return;
}
}
// player moves back to original position
else if (!m_playerMoveBack)
{
// if player has returned to his original position
if (m_teamMember.transform.position.x <= m_teamMemberLastPos.x)
{
m_teamMember.GetComponent <Animator>().SetBool("IsRunning", false);
// Reset Sprite Layers
m_teamMember.GetComponent <SpriteRenderer>().sortingOrder = m_teamMemberSpriteLayer;
m_enemyTarget.GetComponent <SpriteRenderer>().sortingOrder = m_enemyTargetSpriteLayer;
m_playerMoveBack = true;
}
// if not move backwards
else
{
m_teamMember.transform.position -= m_direction * m_MoveSpeed * Time.deltaTime;
return;
}
}
// check if enemy dead
else if (m_LastSelectedEnemy.m_Health <= 0)
{
if (m_enemyTargetAnimator != null && !m_enemyTargetAnimator.GetBool("IsDead"))
{
m_enemyTargetAnimator.SetBool("IsDead", true);
}
return;
}
// enemy chooses a target to attack
else if (!m_enemyTargetChoosen)
{
// choose a random target from the remaining team members
// Remember: Random.Next(inclusive, exclusive)
System.Random rand = new System.Random();
m_enemy_ChosenTeamPlayerTarget = m_Team[rand.Next(0, m_Team.Count)];
System.Random random = new System.Random();
m_enemyAttackerCharacter = m_Enemies[random.Next(0, m_Enemies.Count)];
// save spritelayer order for chosen target
m_enemy_ChosenTeamPlayerTargetSpriteLayer = m_enemy_ChosenTeamPlayerTarget.GetComponent <SpriteRenderer>().sortingOrder;
m_enemy_ChosenTeamPlayerTarget.GetComponent <SpriteRenderer>().sortingOrder = 14;
m_enemy_ChosenTeamPlayerTargetAnimator = m_enemy_ChosenTeamPlayerTarget.GetComponent <Animator>();
// get gameobject of current enemy
m_enemyAttacker = m_enemyAttackerCharacter.gameObject;
// save last position of current enemy
m_enemyAttackerLastPos = m_enemyAttacker.transform.position;
// get animator
m_enemyAttackerAnimator = m_enemyAttacker.GetComponent <Animator>();
// let enemy sprite be over player sprite
// save original sorting layer
m_enemyAttackerSpriteLayer = m_enemyAttacker.GetComponent <SpriteRenderer>().sortingOrder;
m_enemyAttacker.GetComponent <SpriteRenderer>().sortingOrder = 15;
// direction where enemy attacker is headed
m_direction = m_enemy_ChosenTeamPlayerTarget.transform.position - m_enemyAttacker.transform.position;
m_direction.Normalize();
m_enemyAttacker.GetComponent <Animator>().SetBool("IsRunning", true);
m_enemyTargetChoosen = true;
}
// enemy is attacking
else if (!m_EnemyAttacked)
{
// if is not playing animation
if (m_enemyAttackerAnimator != null && !m_enemyAttackerAnimator.GetBool("IsAttacking"))
{
// if player was reached, attack
if (m_enemyAttacker.transform.position.x <= m_enemy_ChosenTeamPlayerTarget.transform.position.x + 1.5f)
{
m_enemyAttackerAnimator.SetBool("IsAttacking", true);
m_enemy_ChosenTeamPlayerTargetAnimator.SetTrigger("IsHurt");
}
// if enemy was not reached yet, return, so position can be updated
else
{
// move towards enemy
m_enemyAttacker.transform.position += m_direction * m_MoveSpeed * Time.deltaTime;
return;
}
}
// if already is playing animation | wait for animation event to be called
else
{
return;
}
}
// enemy moves back to original position
else if (!m_enemyMoveBack)
{
// if player has returned to his original position
if (m_enemyAttacker.transform.position.x >= m_enemyAttackerLastPos.x)
{
m_enemyAttacker.GetComponent <Animator>().SetBool("IsRunning", false);
// Reset Sprite Layers
m_enemy_ChosenTeamPlayerTarget.GetComponent <SpriteRenderer>().sortingOrder = m_enemy_ChosenTeamPlayerTargetSpriteLayer;
m_enemyAttacker.GetComponent <SpriteRenderer>().sortingOrder = m_enemyAttackerSpriteLayer;
m_enemyMoveBack = true;
}
// if not move backwards
else
{
m_enemyAttacker.transform.position -= m_direction * m_MoveSpeed * Time.deltaTime;
return;
}
}
// team member targeted by enemy dead
else if (m_enemy_ChosenTeamPlayerTarget.m_Health <= 0)
{
if (m_enemy_ChosenTeamPlayerTargetAnimator != null && !m_enemy_ChosenTeamPlayerTargetAnimator.GetBool("IsDead"))
{
m_enemy_ChosenTeamPlayerTargetAnimator.SetBool("IsDead", true);
}
return;
}
// round finished
else
{
ResetBattlePhase();
}
}
public bool Create(ProductCat1Model model)
{
return(ServerResponse.Invoke <bool>("api/productCat1/create", JsonConvert.SerializeObject(model), "POST"));
}
public ProductCat1Model GetById(int?id)
{
return(ServerResponse.Invoke <ProductCat1Model>("api/ProductCat1/getDetail?id=" + id, "", "GET"));
}
public List <ProductCat1Model> GetAll()
{
return(ServerResponse.Invoke <List <ProductCat1Model> >("api/ProductCat1/getDetails", "", "Get"));
}
public async Task <string> DownloadPackageAsync(string connectionID, RequestDownloadInfo requestInfo)
{
// cast
RequestDownloadNpmInfo info = (RequestDownloadNpmInfo)requestInfo;
// server response
ServerResponse response = new ServerResponse()
{
payload = new Dictionary <string, string>()
};
string _outputDirectory = $"{_environment.ContentRootPath}/wwwroot/{_configuration.GetValue<string>("DownloadPath")}";
// check if output directory exists
if (!Directory.Exists(_outputDirectory))
{
Directory.CreateDirectory(_outputDirectory);
}
string connectionSubName = $"npm-{connectionID}-{DateTime.Now:yyyymmddHHmmss}";
string connectionDirectory = $"{_outputDirectory}/{connectionSubName}";
Directory.CreateDirectory(connectionDirectory);
// send message
response.payload.Clear();
response.payload.Add("Resource", $"{connectionSubName} created.");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
// set all parent packages
for (int i = 0; i < info.packageList.Count(); i++)
{
string packageId = info.packageList.ElementAt(i).packageId;
string packageVersionValue = info.packageList.ElementAt(i).packageVersion;
string setValue = $"{packageId}-{packageVersionValue}";
PackageInfo packageInfo = await GetPackageInfoByStringAsync(packageId, packageVersionValue,
info.preReleased, info.repository);
if (packageInfo != null)
{
packageInfo.depth = 0;
_downloadQueue.Enqueue(packageInfo);
_cacheForPackageVersion.Add(setValue);
}
}
// download counter
int download_counter = 0;
while (_downloadQueue.Count > 0)
{
PackageInfo package = _downloadQueue.Dequeue();
string validFileName = FileUtil.GetValidFileName(package.packageId);
string packageFilePath = $"{connectionDirectory}/{validFileName}-{package.packageVersion}.tgz";
if (_cacheDownloadedFileName.Contains($"{package.packageId}-{package.packageVersion}"))
{
continue;
}
else
{
_cacheDownloadedFileName.Add($"{package.packageId}-{package.packageVersion}");
}
// Get specific package and version
PackageVersion packageVerion = await GetPackageVersionAsync(info.repository, package.packageId, package.packageVersion);
// Downlaod package
if (packageVerion != null && packageVerion.dist != null && packageVerion.dist.tarball != null)
{
using var packageStream = new FileStream(packageFilePath, FileMode.Create);
using var httpStream = await new HttpClient().GetStreamAsync(packageVerion.dist.tarball);
await httpStream.CopyToAsync(packageStream);
}
else
{
Console.WriteLine($"Error: tarball url is null, {package.packageId}");
continue;
}
download_counter++;
// starting
if (download_counter == 1)
{
// send message
response.payload.Clear();
response.payload.Add("DownloadCounter", $"starting...");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
}
// check if send message is needed
if (download_counter % MessageFrequency == 0)
{
Console.WriteLine($"DownloadCounter: {download_counter}, download queue: {_downloadQueue.Count}," +
$" file: {_cacheDownloadedFileName.Count}, parse: {_cacheForPackageVersion.Count}," +
$" versions: {_cacheForVersions.Count}, percent: {((float)download_counter / (float)(download_counter + _downloadQueue.Count)) * 100.0f} %");
// send message
response.payload.Clear();
response.payload.Add("DownloadCounter", $"{download_counter}, {((float)download_counter / (float)(download_counter + _downloadQueue.Count)) * 100.0f}%");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
}
Console.WriteLine($"Downloaded package {package.packageId} {package.packageVersion}");
//Console.WriteLine($"Author: {packageVerion.author}");
Console.WriteLine($"Description: {packageVerion.description}");
if (info.withDependency == false)
{
Console.WriteLine("\nDependencies download is not need.");
continue;
}
Console.WriteLine("\nStart download dependencies:");
if (packageVerion.dependencies != null && (info.dependencyDepth == -1 || package.depth < info.dependencyDepth))
{
foreach (var dependencyGroup in packageVerion.dependencies)
{
string packageId = dependencyGroup.Key;
string packageVersionValue = dependencyGroup.Value;
string setValue = $"{packageId}-{packageVersionValue}";
if (_cacheForPackageVersion.Contains(setValue) == true)
{
Console.WriteLine($"Already parsed: {setValue}");
continue;
}
PackageInfo packageInfo = await GetPackageInfoByStringAsync(packageId, packageVersionValue,
info.preReleased, info.repository);
if (packageInfo != null)
{
packageInfo.depth = package.depth + 1;
if (info.dependencyDepth == -1 || packageInfo.depth <= info.dependencyDepth)
{
_downloadQueue.Enqueue(packageInfo);
_cacheForPackageVersion.Add(setValue);
}
}
}
}
if (info.withDevDependency == false)
{
Console.WriteLine("\nDev dependencies download is not need.");
continue;
}
Console.WriteLine("\nStart download dev dependencies:");
if (packageVerion.devDependencies != null && (info.dependencyDepth == -1 || package.depth < info.dependencyDepth))
{
foreach (var dependencyGroup in packageVerion.devDependencies)
{
string packageId = dependencyGroup.Key;
string packageVersionValue = dependencyGroup.Value;
string setValue = $"{packageId}-{packageVersionValue}";
if (_cacheForPackageVersion.Contains(setValue) == true)
{
Console.WriteLine($"Already parsed: {setValue}");
continue;
}
PackageInfo packageInfo = await GetPackageInfoByStringAsync(packageId, packageVersionValue,
info.preReleased, info.repository);
if (packageInfo != null)
{
packageInfo.depth = package.depth + 1;
if (info.dependencyDepth == -1 || packageInfo.depth <= info.dependencyDepth)
{
_downloadQueue.Enqueue(packageInfo);
_cacheForPackageVersion.Add(setValue);
}
}
}
}
}
Console.WriteLine($"DownloadCounter: {download_counter}, download queue: {_downloadQueue.Count}," +
$" file: {_cacheDownloadedFileName.Count}, parse: {_cacheForPackageVersion.Count}," +
$" versions: {_cacheForVersions.Count}, percent: {((float)download_counter / (float)(download_counter + _downloadQueue.Count)) * 100.0f} %");
// send message
response.payload.Clear();
response.payload.Add("DownloadCounter", $"{download_counter}, {((float)download_counter / (float)(download_counter + _downloadQueue.Count)) * 100.0f}%");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
string zipFileName = $"{_outputDirectory}/{connectionSubName}.zip";
bool result = _compressService.CompressDirectory(connectionDirectory, zipFileName);
if (result == true)
{
string readableSize = FileUtil.getFileHumanReadableSize(zipFileName);
// send message
response.payload.Clear();
response.payload.Add("CompressStatus", $"compressed ok, file sieze: {readableSize}.");
await _downloadHubContext.Clients.Client(connectionID).Response(response);;
}
else
{
// send message
response.payload.Clear();
response.payload.Add("CompressStatus", $"compressed failed.");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
}
// delete directory
Directory.Delete(connectionDirectory, true);
return(connectionSubName);
}
private async void PollEncodeProgress()
{
ServerResponse response = null;
try
{
if (this.retryCount > 5)
{
this.EncodeCompleted?.Invoke(sender: this, e: new EncodeCompletedEventArgs(4));
this.encodePollTimer?.Stop();
if (this.workerProcess != null && !this.workerProcess.HasExited)
{
this.workerProcess?.Kill();
}
return;
}
response = await this.MakeHttpGetRequest("PollEncodeProgress");
}
catch (Exception e)
{
retryCount = this.retryCount + 1;
}
if (response == null || !response.WasSuccessful)
{
retryCount = this.retryCount + 1;
return;
}
this.retryCount = 0; // Reset
string statusJson = response.JsonResponse;
JsonState state = JsonConvert.DeserializeObject <JsonState>(statusJson);
TaskState taskState = state != null?TaskState.FromRepositoryValue(state.State) : null;
if (taskState != null && (taskState == TaskState.Working || taskState == TaskState.Searching))
{
if (this.EncodeProgress != null)
{
var progressEventArgs = new EncodeProgressEventArgs(
fractionComplete: state.Working.Progress,
currentFrameRate: state.Working.Rate,
averageFrameRate: state.Working.RateAvg,
estimatedTimeLeft: TimeSpan.FromSeconds(state.Working.ETASeconds),
passId: state.Working.PassID,
pass: state.Working.Pass,
passCount: state.Working.PassCount,
stateCode: taskState.Code);
this.EncodeProgress(this, progressEventArgs);
}
}
else if (taskState != null && taskState == TaskState.WorkDone)
{
this.encodePollTimer.Stop();
if (this.workerProcess != null && !this.workerProcess.HasExited)
{
try
{
this.workerProcess?.Kill();
}
catch (Win32Exception e)
{
Debug.WriteLine(e);
}
}
this.EncodeCompleted?.Invoke(sender: this, e: new EncodeCompletedEventArgs(state.WorkDone.Error));
this.portService.FreePort(this.port);
}
}
private void GatherFile(string ReqFile, string ReqParam, HttpListenerRequest SourceReq)
{
HttpWebRequest ServerRequest = WebRequest.Create(new Uri("https://gc2018.gczero.com/" + ReqFile + "?" + ReqParam)) as HttpWebRequest;
ServerRequest.ServerCertificateValidationCallback = delegate { return(true); };
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
for (int i = 0; i < SourceReq.Headers.Count; i++)
{
string HeaderName_Orig = SourceReq.Headers.Keys[i];
string HeaderValue_Orig = SourceReq.Headers.GetValues(i)[0];
switch (HeaderName_Orig)
{
case "Accept":
ServerRequest.Accept = HeaderValue_Orig;
//ServerRequest.Connection = HeaderValue_Orig;
break;
case "User-Agent":
ServerRequest.UserAgent = HeaderValue_Orig;
break;
case "Accept-Encoding":
//ServerRequest.TransferEncoding = HeaderValue_Orig;
break;
case "Accept-Language":
//ServerRequest.a
break;
case "Host":
ServerRequest.Host = HeaderValue_Orig;
break;
}
}
var Input = default(byte[]);
bool HasContent = false;
if (SourceReq.HttpMethod == "POST")
{
HasContent = true;
using (var memstream = new MemoryStream())
{
SourceReq.InputStream.CopyTo(memstream);
Input = memstream.ToArray();
}
}
if (HasContent)
{
ServerRequest.Method = "POST";
ServerRequest.GetRequestStream().Write(Input, 0, Input.Length);
}
Console.WriteLine("Getting response from game server:" + ReqFile);
HttpWebResponse ServerResponse;
try
{
ServerResponse = ServerRequest.GetResponse() as HttpWebResponse;
}
catch (Exception e)
{
throw e;
}
var ServerOutput = default(byte[]);
using (var memstream = new MemoryStream())
{
ServerResponse.GetResponseStream().CopyTo(memstream);
ServerOutput = memstream.ToArray();
}
if (ReqFile.Split('/').Length > 0)
{
string DirectoryData = "";
foreach (string DirName in ReqFile.Split('/'))
{
if (!DirName.Contains("."))
{
if (nonWindows)
{
DirectoryData += DirName + "/";
}
else
{
DirectoryData += DirName + "\\";
}
}
if (!Directory.Exists(DirectoryData))
{
Console.WriteLine("Creating directory:" + DirectoryData);
Directory.CreateDirectory(CacheFolder + DirectoryData);
}
}
}
File.WriteAllBytes(CacheFolder + ReqFile, ServerOutput);
SpecialTreatment(ReqFile);
return;
//Console.ReadLine();
}
public TemplateModel Delete(TemplateModel model)
{
TemplateModel result = ServerResponse.Invoke <TemplateModel>("api/template/delete?id=" + model.Id, "", "POST");
return(result);
}
public TemplateModel Edit(TemplateModel model)
{
TemplateModel result = ServerResponse.Invoke <TemplateModel>("api/template/edit?id=" + model.Id, JsonConvert.SerializeObject(model), "POST");
return(result);
}
public async Task <string> DownloadPackageAsync(string connectionID, RequestDownloadInfo requestInfo)
{
// cast
RequestDownloadContainerInfo info = (RequestDownloadContainerInfo)requestInfo;
// server response
ServerResponse response = new ServerResponse()
{
payload = new Dictionary <string, string>()
};
string _outputDirectory = $"{_environment.ContentRootPath}/wwwroot/{_configuration.GetValue<string>("DownloadPath")}";
// check if output directory exists
if (!Directory.Exists(_outputDirectory))
{
Directory.CreateDirectory(_outputDirectory);
}
string fileName = info.image.Replace("/", "-").Replace(":", "-");
string connectionSubName = $"container-{fileName}-{connectionID}-{DateTime.Now:yyyymmddHHmmss}";
// send message
response.payload.Clear();
response.payload.Add("Resource", $"{connectionSubName} created.");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
// docker pull
Process compiler = new Process();
compiler.StartInfo.FileName = "docker";
compiler.StartInfo.Arguments = $"pull {info.image}";
compiler.StartInfo.UseShellExecute = false;
compiler.StartInfo.RedirectStandardOutput = true;
compiler.OutputDataReceived += async(sender, args) => await sendMessageAsync(connectionID, args.Data);
compiler.Start();
compiler.BeginOutputReadLine();
compiler.WaitForExit();
// send message
response.payload.Clear();
response.payload.Add("DownloadCounter", $"download finished.");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
// docker save
Process compiler2 = new Process();
compiler2.StartInfo.FileName = "docker";
compiler2.StartInfo.Arguments = $"save -o {_outputDirectory}/{connectionSubName}.zip {info.image}";
compiler2.StartInfo.UseShellExecute = false;
compiler2.StartInfo.RedirectStandardOutput = true;
compiler2.OutputDataReceived += (sender, args) => Console.WriteLine("received output: {0}", args.Data);
compiler2.Start();
compiler2.BeginOutputReadLine();
compiler2.WaitForExit();
string readableSize = FileUtil.getFileHumanReadableSize($"{_outputDirectory}/{connectionSubName}.zip");
// send message
response.payload.Clear();
response.payload.Add("CompressStatus", $"compressed ok, file sieze: {readableSize}.");
await _downloadHubContext.Clients.Client(connectionID).Response(response);
// delete image
Process compiler3 = new Process();
compiler3.StartInfo.FileName = "docker";
compiler3.StartInfo.Arguments = $"rmi {info.image}";
compiler3.StartInfo.UseShellExecute = false;
compiler3.Start();
compiler3.WaitForExit();
return(connectionSubName);
}
/// <summary>
/// Reads data from the SortedTreeEngine with the provided read options and server side filters.
/// </summary>
/// <param name="readerOptions">read options supplied to the reader. Can be null.</param>
/// <param name="keySeekFilter">a seek based filter to follow. Can be null.</param>
/// <param name="keyMatchFilter">a match based filer to follow. Can be null.</param>
/// <returns>A stream that will read the specified data.</returns>
public override TreeStream <TKey, TValue> Read(SortedTreeEngineReaderOptions readerOptions, SeekFilterBase <TKey> keySeekFilter, MatchFilterBase <TKey, TValue> keyMatchFilter)
{
if (m_reader != null)
{
throw new Exception("Sockets do not support concurrent readers. Dispose of old reader.");
}
m_stream.Write((byte)ServerCommand.Read);
if (keySeekFilter is null)
{
m_stream.Write(false);
}
else
{
m_stream.Write(true);
m_stream.Write(keySeekFilter.FilterType);
keySeekFilter.Save(m_stream);
}
if (keyMatchFilter is null)
{
m_stream.Write(false);
}
else
{
m_stream.Write(true);
m_stream.Write(keyMatchFilter.FilterType);
keyMatchFilter.Save(m_stream);
}
if (readerOptions is null)
{
m_stream.Write(false);
}
else
{
m_stream.Write(true);
readerOptions.Save(m_stream);
}
m_stream.Flush();
ServerResponse command = (ServerResponse)m_stream.ReadUInt8();
switch (command)
{
case ServerResponse.UnhandledException:
string exception = m_stream.ReadString();
throw new Exception("Server UnhandledExcetion: \n" + exception);
case ServerResponse.UnknownOrCorruptSeekFilter:
throw new Exception("Server does not recgonize the seek filter");
case ServerResponse.UnknownOrCorruptMatchFilter:
throw new Exception("Server does not recgonize the match filter");
case ServerResponse.UnknownOrCorruptReaderOptions:
throw new Exception("Server does not recgonize the reader options");
case ServerResponse.SerializingPoints:
break;
case ServerResponse.ErrorWhileReading:
exception = m_stream.ReadString();
throw new Exception("Server Error While Reading: \n" + exception);
default:
throw new Exception("Unknown server response: " + command.ToString());
}
m_reader = new PointReader(m_encodingMode, m_stream, () => m_reader = null);
return(m_reader);
}
/// <summary>
/// Parses the response body to get the response code.
/// </summary>
///
/// <returns>The error code in the given response body.</returns>
///
/// <param name="serverResponse">The server response from which to get the error code. This
/// must describe an successful response from the server which contains an error in the
/// response body.</param>
private static Error GetErrorCode(ServerResponse serverResponse)
{
const string JsonKeyErrorCode = "Code";
ReleaseAssert.IsNotNull(serverResponse, "A server response must be supplied.");
ReleaseAssert.IsTrue(serverResponse.Result == HttpResult.Success, "The result must describe a successful server response.");
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode != SuccessHttpResponseCode && serverResponse.HttpResponseCode != UnexpectedErrorHttpResponseCode,
"Must not be a successful or unexpected HTTP response code.");
object errorCodeObject = serverResponse.Body[JsonKeyErrorCode];
ReleaseAssert.IsTrue(errorCodeObject is long, "'Code' must be a long.");
long errorCode = (long)errorCodeObject;
switch (errorCode)
{
case 1007:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 422, @"Invalid HTTP response code for error code.");
return(Error.InvalidRequest);
case 10002:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 429, @"Invalid HTTP response code for error code.");
return(Error.RateLimitReached);
case 1008:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 503, @"Invalid HTTP response code for error code.");
return(Error.TemporaryServiceError);
case 1003:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 401, @"Invalid HTTP response code for error code.");
return(Error.ExpiredConnectAccessToken);
case 1004:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 401, @"Invalid HTTP response code for error code.");
return(Error.InvalidConnectAccessToken);
case 1011:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 403, @"Invalid HTTP response code for error code.");
return(Error.MethodDisabled);
case 1009:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 401, @"Invalid HTTP response code for error code.");
return(Error.PlayerNotFound);
case 10203:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 401, @"Invalid HTTP response code for error code.");
return(Error.CurrencyItemNotFound);
case 10504:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 401, @"Invalid HTTP response code for error code.");
return(Error.PurchaseCostsNotMet);
case 6002:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 401, @"Invalid HTTP response code for error code.");
return(Error.PlayerContextNotSet);
case 10105:
ReleaseAssert.IsTrue(serverResponse.HttpResponseCode == 401, @"Invalid HTTP response code for error code.");
return(Error.CatalogNotPublished);
default:
return(Error.UnexpectedError);
}
}
public bool Delete(int?id)
{
return(ServerResponse.Invoke <bool>("api/ProductCat1/delete?id=" + id, "", "POST"));
}
public static void UpdateExperience(int _expToAdd)
{
int currentCharID = PlayerData.currentSelectedCharacter;
string characterName = "";
switch (currentCharID)
{
case 0:
characterName = "Adventurer";
break;
case 1:
characterName = "Bandit";
break;
case 2:
characterName = "Golem";
break;
case 3:
characterName = "Mandrake";
break;
case 4:
characterName = "Rat";
break;
case 5:
characterName = "Red Ogre";
break;
case 6:
characterName = "Satyr";
break;
case 7:
characterName = "Shade";
break;
case 8:
characterName = "Wasp";
break;
case 9:
characterName = "Werewolf";
break;
case 10:
characterName = "Yeti";
break;
default:
break;
}
// get current stats from database
ServerResponse sr = UserRequestLibrary.GetCharacterStatsRequest(characterName);
// copy stats
BA_Praxis_Library.Character charTMP = sr.Characters[0];
//set name
charTMP.Name = characterName;
// add experience
charTMP.Experience += _expToAdd;
// update experience
UserRequestLibrary.UpdateExperience(charTMP);
}
public ServerResponse RenameReport(string client, string group, string report, string newName)
{
ServerResponse result = new ServerResponse();
try
{
var path = ReportHelper.GetPath(client, group, report);
var dir = new DirectoryInfo(path);
if (dir.Exists)
{
dir.MoveTo(ReportHelper.GetPath(client, group, newName));
}
result.Status = ResponseStatus.Success;
result.Message = "成功重命名报表";
}
catch (Exception ex)
{
result.Status = ResponseStatus.Exception;
result.Message = ex.Message;
}
return result;
}
public ServerResponse DeletePage(string path)
{
ServerResponse result = new ServerResponse();
try
{
var fi = new FileInfo(path);
if (fi.Exists)
{
fi.Delete();
}
result.Status = ResponseStatus.Success;
result.Message = "成功删除页面";
}
catch (Exception ex)
{
result.Status = ResponseStatus.Exception;
result.Message = ex.Message;
}
return result;
}
public ServerResponse SavePage([FromBody]ReportPageContent page)
{
ServerResponse result = new ServerResponse();
try
{
StringBuilder sb = new StringBuilder();
if (!string.IsNullOrEmpty(page.Css))
{
sb.AppendLine("<style type=\"text/css\">");
sb.AppendLine(page.Css);
sb.AppendLine("</style>");
}
sb.AppendLine("<!-- start html content -->");
sb.AppendLine(page.Html);
sb.AppendLine("<!-- end html content -->");
if (!string.IsNullOrEmpty(page.Js))
{
sb.AppendLine("<script type=\"text/javascript\">");
sb.AppendLine(page.Js);
sb.AppendLine("</script>");
}
File.WriteAllText(page.File, sb.ToString(), System.Text.Encoding.UTF8);
result.Status = ResponseStatus.Success;
result.Message = "成功保存页面";
}
catch (Exception ex)
{
result.Status = ResponseStatus.Exception;
result.Message = ex.Message;
}
return result;
}
/// <summary>
/// Raises the <see cref="ReceivedServerResponse"/> event.
/// </summary>
/// <param name="responseCode">Response received from the server.</param>
/// <param name="commandCode">Command that the server responded to.</param>
protected void OnReceivedServerResponse(ServerResponse responseCode, ServerCommand commandCode)
{
try
{
if ((object)ReceivedServerResponse != null)
ReceivedServerResponse(this, new EventArgs<ServerResponse, ServerCommand>(responseCode, commandCode));
}
catch (Exception ex)
{
// We protect our code from consumer thrown exceptions
OnProcessException(new InvalidOperationException($"Exception in consumer handler for ReceivedServerResponse event: {ex.Message}", ex));
}
}
public async Task <IActionResult> CreateMessage([FromBody] ServerResponse ServerResponse)
{
// declare a complex type as input parameter
HttpResponseMessage rs;
string response;
if (ServerResponse.text == null)
{
ServerResponse.text = "";
}
// loop through the server's text value to determine the next cause of action
if (ServerResponse.text.Equals("", StringComparison.Ordinal))
{
// always include a 'CON' in your first statements
response = "CON Welcome to Crext";
response += "Enter organisation Id";
var team = await _teamMember.GetTeamMemberByPhone(ServerResponse.phoneNumber);
if (team == null)
{
response = "END You were not Identified, Please continue with the phone number that was registered by the organisation";
}
//validate Organisation Id
var orgId = Convert.ToInt32(ServerResponse.text);
var hasOrg = await _organisation.Find(orgId);
if (hasOrg)
{
response += "Enter Customer Phone Number";
var findcus = await _customer.GetPhone(ServerResponse.text);
if (findcus != null)
{
response += "Enter Option \n 1 Add Payment \n 2 Report";
var opt = ServerResponse.text;
if (opt.Equals("1", StringComparison.Ordinal))
{
response += "Enter Amount";
var amount = ServerResponse.text;
//Update feed back with comment "Customer Paid Amount on Date"
var reviewCreateMapped = new CreateReviewDto
{
Comment = "Customer Paid " + amount + " on " + DateTime.UtcNow,
CustomerId = findcus.Id.ToString(),
TeamMemberId = team.Id,
Status = Helpers.ReviewStatus.UNREAD.ToString()
};
var reviewNotificationCreateMapped = new CreateReviewNotificationsDto
{
ReviewActionId = 4,
ReviewKindId = 1,
StartDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow,
DateAdded = DateTime.UtcNow
};
var targetReview = Mapper.Map <Reviews>(reviewCreateMapped);
await _review.Create(targetReview);
//
if (!await _review.Save())
{
return(StatusCode(500, "END Server Error, Something went wrong with our server"));
}
var createdReview = Mapper.Map <Reviews>(targetReview);
//notificationMapped.ReviewId = createdReview.Id;
reviewNotificationCreateMapped.ReviewId = createdReview.Id;
// var targetNotification = Mapper.Map<ReviewNotifications>(notificationMapped);
var targetNotification = Mapper.Map <ReviewNotifications>(reviewNotificationCreateMapped);
await _reviewNotification.Create(targetNotification);
if (!await _review.Save())
{
return(StatusCode(500, "END Server Error, Something went wrong with our server"));
}
var createdNotification = Mapper.Map <ReviewNotifications>(targetNotification);
response = "End Update Successful";
return(CreatedAtRoute("GetReview", new { id = createdNotification.Id }, response));
}
else if (opt.Equals("2", StringComparison.Ordinal))
{
}
}
else
{
//Wrong Phone Number
}
}
else
{
//Wroung Organisation Phone number
}
}
else if (ServerResponse.text.Equals("1", StringComparison.Ordinal))
{
response = "END Your phone number is " + ServerResponse.phoneNumber;
//the last response starts with an 'END' so that the server understands that it's the final response
}
else
{
response = "END invalid option";
}
// rs = Request.CreateResponse(HttpStatusCode.Created, response);
var re = CreatedAtRoute("Get", response);
// append your response to the HttpResponseMessage and set content type to text/plain, exactly what the server expects
// rs.Content = new StringContent(response, Encoding.UTF8, "text/plain");
// finally return your response to the server
return(re);
}
protected void OnServerResponse(string responseMessage)
{
ServerResponse?.Invoke(responseMessage);
}
public DuelServerClient()
{
m_lock = new object();
m_receiveThread = new Thread(Receive) { IsBackground = true };
OnFatalError += FatalError;
}
public TemplateModel GetById(int?id)
{
var data = ServerResponse.Invoke <TemplateModel>("api/template/getDetail?id=" + id, "", "GET");
return(data);
}
public bool CheckTemplate(TemplateModel check)
{
return(ServerResponse.Invoke <bool>("api/template/checkTemplate", JsonConvert.SerializeObject(check), "Post"));
}
public TemplateModel GetTemplateId(string sku)
{
var getTemplateId = ServerResponse.Invoke <TemplateModel>("api/template/getTemplateId?sku=" + sku, "", "POST");
return(getTemplateId);
}
public AsyncSocketMessage(ServerResponse response, Object obj)
{
String message = JsonConvert.SerializeObject(obj);
this.m_package = response.ToString() + DEFAULT_SEPARATOR + message.Length + DEFAULT_SEPARATOR + message;
Console.WriteLine("将要发送的数据MESSAGE :{0}", this.m_package);
}
public int PageCount()
{
var count = ServerResponse.Invoke <int>("api/template/count", "", "GET");
return(count);
}
public ServerResponse <String> logout()
{
HttpContext.Session.Remove("CurrentUser");
return(ServerResponse <string> .createBySuccessMessage("退出成功"));
}
public List <SalesOrderItemModel> GetByProduct(int?id)
{
return(ServerResponse.Invoke <List <SalesOrderItemModel> >("api/salesOrderItems/getByProduct?id=" + id, "", "GET"));
}
public bool Edit(ProductCat1Model model)
{
return(ServerResponse.Invoke <bool>("api/ProductCat1/edit?id=" + model.Id, JsonConvert.SerializeObject(model), "POST"));
}
public List <LengthMeasureModel> LengthMeasure()
{
var list = ServerResponse.Invoke <List <LengthMeasureModel> >("api/template/lengthmeasure", "", "GET");
return(list);
}
