public void LeadListTest(string digest, string auth) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("/lead/list?digest={digest}", Method.GET); request .AddUrlSegment("digest", digest) .AddHeader("Authorization", auth); var response = client.Execute <LeadListModel.RootObject>(request); EnsureOkResponseStatusCode(response, client, request); List <string> allErrorMessages = new List <string>(); ValidationResultModel <LeadListModel.RootObject> leadListMainResults; var isLeadListDataValid = GlobalLogic.IsModelValid(response.Data, out leadListMainResults); if (!isLeadListDataValid) { var message = $"LeadList with success: {leadListMainResults.Model.Success} and results: {leadListMainResults.Model.Results}." .RequestInfo(client, request) .WithValidationErrors(leadListMainResults.Results); allErrorMessages.Add(message); } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } }
public DataTable executeSelectNoParameter(String _query) { SqlCommand myCommand = new SqlCommand(); DataTable dataTable = new DataTable(); try { myCommand.CommandTimeout = 120; //myCommand.CommandType = CommandType.StoredProcedure; myCommand.Connection = openConnection(); myCommand.CommandText = _query; myAdapter.SelectCommand = myCommand; myAdapter.Fill(dataTable); myAdapter.Dispose(); } catch (SqlException e) { Console.Write("Error - Connection.executeSelectQuery - Query: " + _query + " \nException: " + e.StackTrace.ToString()); GlobalLogic.ExceptionHandle(e, _query + "--------------------------executeSelectNoParameter"); return(null); } finally { myCommand.Connection = closeConnection(); } return(dataTable); }
public bool executeUpdateQuerySP(String _query, SqlParameter[] sqlParameter) { SqlCommand myCommand = new SqlCommand(); try { myCommand.CommandTimeout = 120; myCommand.CommandType = CommandType.StoredProcedure; myCommand.Connection = openConnection(); myCommand.CommandText = _query; myCommand.Parameters.AddRange(sqlParameter); myAdapter.UpdateCommand = myCommand; myCommand.ExecuteNonQuery(); } catch (SqlException e) { Console.Write("Error - Connection.executeUpdateQuerySP - Query: " + _query + " \nMessage: " + e.Message + _query + " \nException: " + e.StackTrace.ToString()); string paramsVal = ""; foreach (SqlParameter p in sqlParameter) { paramsVal += p.ParameterName + " --- " + p.Value + " ------- "; } GlobalLogic.ExceptionHandle(e, _query + "------------------" + paramsVal + "executeUpdateQuerySP"); return(false); } finally { myCommand.Dispose(); myCommand.Connection = closeConnection(); } return(true); }
public void CheckOtpTest(string digest, string phone, int otp, string auth) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("/user/otp_check", Method.GET); request .AddParameter("digest", digest) .AddParameter("phone", phone) .AddParameter("otp", otp) .AddHeader("Authorization", auth); var response = client.Execute <CheckOtpModel>(request); GlobalLogic.EnsureOkResponseStatusCode(response, client, request); List <string> allErrorMessages = new List <string>(); ValidationResultModel <CheckOtpModel> checkotpResults; var isCheckOtpDataValid = GlobalLogic.IsModelValid(response.Data, out checkotpResults); if (!isCheckOtpDataValid) { var message = $"CheckOtp with success: {checkotpResults.Model.Success} and username: {checkotpResults.Model.Username}." .RequestInfo(client, request) .WithValidationErrors(checkotpResults.Results); allErrorMessages.Add(message); } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } }
public void UpdateAccountProfile(AccountProfileViewModel model) { using (new SecurityDisabler()) { var editAccount = Master.GetItem(model.Id.ToString()); editAccount.Editing.BeginEdit(); try { editAccount.Fields["NameField"].Value = model.NameUVM; editAccount.Fields["SurnameField"].Value = model.SurnameUVM; editAccount.Fields["PhoneField"].Value = model.PhoneUVM; editAccount.Editing.EndEdit(); GlobalLogic.PublishItem(editAccount); } catch (Exception ex) { Sitecore.Diagnostics.Log.Error( "Could not update item " + editAccount.Paths.FullPath + ": " + ex.Message, this); editAccount.Editing.CancelEdit(); } } }
void OnTriggerEnter(Collider other) { if (!detecting) { return; } int otherLayer = 1 << other.gameObject.layer; if ((otherLayer & mask.value) > 0) //Is in the masks accepted layers { Vector3 otherCenter = other.bounds.center; Ray ray = new Ray(this.transform.position, (otherCenter - this.transform.position).normalized); RaycastHit hitInfo; if (Physics.Raycast(ray, out hitInfo, Mathf.Infinity)) { if (hitInfo.collider == other) { Debug.Log("Collider " + other.transform.name + " hit by the camera on enter."); } GlobalLogic temp = other.gameObject.GetComponentInChildren <GlobalLogic>(); if (temp != null) { temp.playerDetected(); } } } }
public void CheckGuidTest(string digest, string emailguid, string auth) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("/user/pass_reset/{emailguid}", Method.GET); request .AddUrlSegment("emailguid", emailguid) .AddParameter("digest", digest) .AddHeader("Authorization", auth); var response = client.Execute <RegisterRequestModel>(request); EnsureOkResponseStatusCode(response, client, request); List <string> allErrorMessages = new List <string>(); ValidationResultModel <RegisterRequestModel> checkguidResults; var isCheckOtpDataValid = GlobalLogic.IsModelValid(response.Data, out checkguidResults); if (!isCheckOtpDataValid) { var message = $"CheckGuid with success: {checkguidResults.Model.Success}." .RequestInfo(client, request) .WithValidationErrors(checkguidResults.Results); allErrorMessages.Add(message); } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } }
private void OnMessageReceived(object sender, MessageEventArgs e) { if (State == 0) { KeyMessage keyMessage = (KeyMessage)e.Message; System.Buffer.BlockCopy(keyMessage.Key, 0, Session.ClientKey1, 0, 128); Client.SendMessage(new KeyMessage { Key = Session.ServerKey1 }); State++; return; } if (State == 1) { KeyMessage keyMessage = (KeyMessage)e.Message; System.Buffer.BlockCopy(keyMessage.Key, 0, Session.ClientKey2, 0, 128); Client.SendMessage(new KeyMessage { Key = Session.ServerKey2 }); Session.Init(); Client.WireProtocol = new GameProtocol(Session); State++; return; } GameMessage message = (GameMessage)e.Message; Buffer = message.Data; if (OpCodes.Recv.ContainsKey(message.OpCode)) { string opCodeLittleEndianHex = BitConverter.GetBytes(message.OpCode).ToHex(); Logger.WriteLine(LogState.Debug, "C->S opCode: 0x{0}{1} [{2}]", opCodeLittleEndianHex.Substring(2), opCodeLittleEndianHex.Substring(0, 2), Buffer.Length); Logger.WriteLine(LogState.Debug, "Data:\n{0}", Buffer.FormatHex()); GlobalLogic.PacketReceived(GameAccount, OpCodes.Recv[message.OpCode], Buffer); ((ARecvPacket)Activator.CreateInstance(OpCodes.Recv[message.OpCode])).Process(this); } else { string opCodeLittleEndianHex = BitConverter.GetBytes(message.OpCode).ToHex(); Logger.WriteLine(LogState.Debug, "C->S Unknown opCode: 0x{0}{1} [{2}]", opCodeLittleEndianHex.Substring(2), opCodeLittleEndianHex.Substring(0, 2), Buffer.Length); Logger.WriteLine(LogState.Debug, "Data:\n{0}", Buffer.FormatHex()); GlobalLogic.PacketReceived(GameAccount, null, Buffer); } }
// Update is called once per frame void Update() { if (transform.parent == null && GlobalLogic.Overlaps(gameObject, "Water")) { Destroy(gameObject); Instantiate(potteryInWater, transform.position, Quaternion.identity); } }
private void ProcessAttack(Creature creature, UseSkillArgs args, int time) { try { Creature target = creature.Target; if (target == null || creature.LifeStats.IsDead()) { return; } if (!target.LifeStats.IsDead()) { creature.Attack = new Attack(creature, args, () => GlobalLogic.AttackStageEnd(creature), () => GlobalLogic.AttackFinished(creature)); int damage = SeUtils.CalculateDefaultAttackDamage(creature, target, creature.GameStats.Attack); Player player = creature as Player; if (player != null) { VisibleService.Send(player, new SpAttack(player, player.Attack)); } Npc npc = creature as Npc; if (npc != null) { VisibleService.Send(npc, new SpNpcAttack(npc, npc.Attack)); } target.LifeStats.MinusHp(damage); AiLogic.OnAttack(creature, target); AiLogic.OnAttacked(target, creature, damage); if (target is Player) { (target as Player).LifeStats.PlusSp(damage); } new DelayedAction(creature .Attack .NextStage, time); return; } new DelayedAction(creature .Attack .Finish, time); } catch (Exception ex) { Log.ErrorException("ProcessAttack:", ex); } }
void Start() { GameObject tmp = GameObject.Find("Global"); if (tmp) { global = tmp.GetComponent <GlobalLogic>(); } }
IEnumerator DoJump() { yield return(new WaitForSeconds(jumpDuration)); foreach (GameObject jumpedOn in GlobalLogic.GetOverlapped(gameObject, "Droppable")) { jumpedOn.SendMessage("OnJumpedOn"); } }
void Update() { if (transform.parent == null && GlobalLogic.Overlaps(gameObject, "Water")) { GetComponent <SpriteRenderer>().sprite = droppedSprite; } else { GetComponent <SpriteRenderer>().sprite = filledSprite; } }
private void Start() { t = 2.0f; died = false; GameObject tmp = GameObject.Find("Global"); if (tmp) { global = tmp.GetComponent <GlobalLogic>(); } }
public ResultInfo <GlobalNotificationMarks> NotificationMarks(RequestParam <GlobalNotificationMarksRequest> reqst) { var ri = new ResultInfo <GlobalNotificationMarks>("99999"); using (GlobalLogic global = new GlobalLogic()) { ri.body = global.GetGlobalNotificationMarks(reqst.body); } ri.code = "1"; ri.message = Settings.Instance.GetErrorMsg(ri.code); return(ri); }
/// <constructor> /// Initialise Connection /// </constructor> public dbConnection() { try { myAdapter = new SqlDataAdapter(); conn = new SqlConnection(@"Server=dbserver;Database=FworkSQLEcm;User Id=etssys; Password=c4ndy4u"); } catch (Exception e) { Console.WriteLine(e.Message); GlobalLogic.ExceptionHandle(e, "dbConnection"); } }
void Start() { GameObject tmp = GameObject.Find("Global"); if (tmp) { global = tmp.GetComponent <GlobalLogic>(); } trackedObj = GetComponent <SteamVR_Behaviour_Pose>(); //trackedobject = this.getcomponent<steamvr_trackedobject>(); //print((int)(trackedobject.index)); swordWipe = GetComponent <AudioSource>(); }
public void ClassifiedDataTest(string guid, string digest, string auth) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("/objects/{guid}", Method.GET); request .AddUrlSegment("guid", guid) .AddParameter("digest", digest) .AddHeader("Authorization", auth); var response = client.Execute <ReadClassifiedModel.RootObject>(request); if (response.StatusCode != HttpStatusCode.OK || response.Data == null || response.Data.Success == false) { throw new Exception(AssertMessages.StatusCodeErrorMessage(client.BuildUri(request), response.StatusCode, response.Content)); } List <string> allErrorMessages = new List <string>(); ValidationResultModel <ReadClassifiedModel.RootObject> classifiedDataMainResults; var isClassifiedDataValid = GlobalLogic.IsModelValid(response.Data, out classifiedDataMainResults); ValidationResultModel <ReadClassifiedModel.Items> classifiedDataItemsResults; var areClassifiedDataItemsValid = GlobalLogic.IsModelValid(response.Data.Items, out classifiedDataItemsResults); if (!isClassifiedDataValid) { var message = $"Classified with success: {classifiedDataMainResults.Model.Success} and results: {classifiedDataMainResults.Model.Results}." .RequestInfo(client, request) .WithValidationErrors(classifiedDataMainResults.Results); allErrorMessages.Add(message); } if (!areClassifiedDataItemsValid) { var message = $"Classified items with guid: {classifiedDataItemsResults.Model.guid}" .RequestInfo(client, request) .WithValidationErrors(classifiedDataItemsResults.Results); allErrorMessages.Add(message); } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } }
public void RecommendsTest(string digest, string guid, int user_id, string auth) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("/recommends", Method.GET); request .AddParameter("digest", digest) .AddParameter("guid", guid) .AddParameter("user_id", user_id) .AddHeader("Authorization", auth); var response = client.Execute <RecommendsModel.RootObject>(request); EnsureOkResponseStatusCode(response, client, request); List <string> allErrorMessages = new List <string>(); ValidationResultModel <RecommendsModel.RootObject> recommendsMainResults; var isRecommendsDataValid = GlobalLogic.IsModelValid(response.Data, out recommendsMainResults); IList <ValidationResultModel <RecommendsModel.Item> > recommendsAndRecentlyAddedResults; var areRecommendsAndRecentlyAddedItemsValid = GlobalLogic.IsModelArrayValid(response.Data.RecentlyAdded.Concat(response.Data.Recommendations), out recommendsAndRecentlyAddedResults); if (!isRecommendsDataValid) { var message = $"Recommends with success: {recommendsMainResults.Model.Success}." .RequestInfo(client, request) .WithValidationErrors(recommendsMainResults.Results); allErrorMessages.Add(message); } if (!areRecommendsAndRecentlyAddedItemsValid) { foreach (var recommendsAndRecentlyAddedResult in recommendsAndRecentlyAddedResults.Where(x => x.Results.Any())) { var message = $"RecentlyAdded item with Guid: {recommendsAndRecentlyAddedResult.Model.Guid}" .RequestInfo(client, request) .WithValidationErrors(recommendsAndRecentlyAddedResult.Results); allErrorMessages.Add(message); } } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } }
public void AddContactRev(string ContactName, string ContactSurname, string ContactPhone, string ContactCompany, string ContactMessage) { var emailName = User.Current.Name; using (new SecurityDisabler()) { var itemName = emailName.Split('\\')[1]; itemName = itemName.Replace("@", "__"); itemName = itemName.Replace('.', '_'); Item parent = Master.GetItem(ID.Parse("{9B751520-3D50-4A08-A437-B1576A3549BF}")); // id folder TemplateItem temp = Master.GetItem(ID.Parse("{693EFA96-9C09-4764-A5FD-E90F3EE9394D}")); // conatct // Add the item to the site tree var newItem = parent.Add(itemName, temp); // Set the new item in editing mode // Fields can only be updated when in editing mode // (It's like the begin tarnsaction on a database) newItem.Editing.BeginEdit(); try { // Assign values to the fields of the new item newItem.Fields["Name"].Value = ContactName; newItem.Fields["Surname"].Value = ContactSurname; newItem.Fields["Email"].Value = emailName; newItem.Fields["Phone"].Value = ContactPhone; newItem.Fields["Company"].Value = ContactCompany; newItem.Fields["Message"].Value = ContactMessage; // End editing will write the new values back to the Sitecore // database (It's like commit transaction of a database) newItem.Editing.EndEdit(); GlobalLogic.PublishItem(newItem); } catch (Exception ex) { // The update failed, write a message to the log Sitecore.Diagnostics.Log.Error( "Could not update item " + newItem.Paths.FullPath + ": " + ex.Message, this); //TODO $"" и вынести в константу // Cancel the edit (not really needed, as Sitecore automatically aborts // the transaction on exceptions, but it wont hurt your code) newItem.Editing.CancelEdit(); } } }
public void UploadImageTest(string digest, string auth, string guid) { foreach (string fileType in Data.Filetypes) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("/file?digest={digest}", Method.POST); request.RequestFormat = DataFormat.Json; request .AddHeader("Authorization", auth) .AddUrlSegment("digest", digest) .AddJsonBody( new { username = Data.DealerName, guid = guid, file = new { type = fileType, name = Data.ImageName, content = Data.FileContent } }); var response = client.Execute <UploadImageModel>(request); EnsureOkResponseStatusCode(response, client, request); List <string> allErrorMessages = new List <string>(); ValidationResultModel <UploadImageModel> UploadImageResults; var isUploadImageValid = GlobalLogic.IsModelValid(response.Data, out UploadImageResults); if (!isUploadImageValid) { var message = $"\r\nUploaded photo with success: '{UploadImageResults.Model.Success}' and Url: '{UploadImageResults.Model.Url}'\r\n" .RequestInfo(client, request) .WithValidationErrors(UploadImageResults.Results); allErrorMessages.Add(message); } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } } }
public void DealerLeadsTest(string digest, string auth) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("lead/list?digest={digest}", Method.GET); request .AddUrlSegment("digest", digest) .AddHeader("Authorization", auth); var response = client.Execute <DealerLeadsModel.RootObject>(request); EnsureOkResponseStatusCode(response, client, request); List <string> allErrorMessages = new List <string>(); ValidationResultModel <DealerLeadsModel.RootObject> dealerLeadsMainResults; var isDealerLeadsDataValid = GlobalLogic.IsModelValid(response.Data, out dealerLeadsMainResults); IList <ValidationResultModel <DealerLeadsModel.Item> > DealerLeadsItemResults; var areDealerLeadsDataItemsValid = GlobalLogic.IsModelArrayValid(response.Data.Items, out DealerLeadsItemResults); if (!isDealerLeadsDataValid) { var message = $"Dealer leads with success: {dealerLeadsMainResults.Model.Success} and results: {dealerLeadsMainResults.Model.Results}." .RequestInfo(client, request) .WithValidationErrors(dealerLeadsMainResults.Results); allErrorMessages.Add(message); } if (!areDealerLeadsDataItemsValid) { foreach (var DealerLeadsItemResult in DealerLeadsItemResults.Where(x => x.Results.Any())) { var message = $"Dealer lead item with Classified_id: {DealerLeadsItemResult.Model.Classified_id}" .RequestInfo(client, request) .WithValidationErrors(DealerLeadsItemResult.Results); allErrorMessages.Add(message); } } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } }
void Awake() { if (!currentInstance) { currentInstance = this; } else { Destroy(this.gameObject); } DontDestroyOnLoad(this.gameObject); startTime = -1; finalBossKilled = false; }
public void Jump() { if (GlobalLogic.Overlaps(gameObject, "Hero")) { Vector2 rockTarget = Random.insideUnitCircle * 4; while (Vector2.Distance(rockTarget, transform.position) < 2f) { rockTarget = Random.insideUnitCircle * 4; } GameObject rockInstance = Instantiate(rock, rockTarget + new Vector2(0, 15f), Quaternion.identity); rockInstance.GetComponent <DraggableItem>().Drop(rockTarget, true); } }
public void AddBikeAsOrder(string bikeId, string bikeName, string bikePrice) { var emailName = User.Current.Name; using (new SecurityDisabler()) { var itemName = emailName.Split('\\')[1]; itemName = itemName.Replace("@", "__"); itemName = itemName.Replace('.', '_'); Item parent = Master.GetItem(ID.Parse("{08D7057C-369D-4900-9FA0-4BCD976216D8}")); // id folder TemplateItem temp = Master.GetItem(ID.Parse("{510E2C3A-FAE7-4285-8737-537CFC4CDEA7}")); // bikeOrder // Add the item to the site tree var newItem = parent.Add(itemName, temp); // Set the new item in editing mode // Fields can only be updated when in editing mode // (It's like the begin tarnsaction on a database) newItem.Editing.BeginEdit(); try { // Assign values to the fields of the new item newItem.Fields["EmailName"].Value = emailName; newItem.Fields["BikeId"].Value = bikeId; newItem.Fields["BikeName"].Value = bikeName; newItem.Fields["Price"].Value = bikePrice; //newItem.Fields["Phone"].Value = // End editing will write the new values back to the Sitecore // database (It's like commit transaction of a database) newItem.Editing.EndEdit(); GlobalLogic.PublishItem(newItem); } catch (Exception ex) { // The update failed, write a message to the log Sitecore.Diagnostics.Log.Error( "Could not update item " + newItem.Paths.FullPath + ": " + ex.Message, this); //TODO $"" и вынести в константу // Cancel the edit (not really needed, as Sitecore automatically aborts // the transaction on exceptions, but it wont hurt your code) newItem.Editing.CancelEdit(); } } }
public void RegSourceTest(string digest, string auth) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("/user/reg_request_source?digest={digest}", Method.GET); request .AddUrlSegment("digest", digest) .AddHeader("Authorization", auth); var response = client.Execute <RegSourceModel.RootObject>(request); EnsureOkResponseStatusCode(response, client, request); List <string> allErrorMessages = new List <string>(); ValidationResultModel <RegSourceModel.RootObject> regSourceMainResults; var isRegSourceDataValid = GlobalLogic.IsModelValid(response.Data, out regSourceMainResults); IList <ValidationResultModel <RegSourceModel.Item> > RegSourceItemResults; var areRegSourceDataItemsValid = GlobalLogic.IsModelArrayValid(response.Data.Items, out RegSourceItemResults); if (!isRegSourceDataValid) { var message = $"Registration source with success: {regSourceMainResults.Model.Success} and results: {regSourceMainResults.Model.Results}." .RequestInfo(client, request) .WithValidationErrors(regSourceMainResults.Results); allErrorMessages.Add(message); } if (!areRegSourceDataItemsValid) { foreach (var RegSourceItemResult in RegSourceItemResults.Where(x => x.Results.Any())) { var message = $"Source item with Name: {RegSourceItemResult.Model.Name}" .RequestInfo(client, request) .WithValidationErrors(RegSourceItemResult.Results); allErrorMessages.Add(message); } } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } }
public void CertifiersTest(string digest, string auth) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("/certifiers?digest={digest}", Method.GET); request .AddUrlSegment("digest", digest) .AddHeader("Authorization", auth); var response = client.Execute <CertifiersModel.RootObject>(request); EnsureOkResponseStatusCode(response, client, request); List <string> allErrorMessages = new List <string>(); ValidationResultModel <CertifiersModel.RootObject> certifiersMainResults; var isCertifiersDataValid = GlobalLogic.IsModelValid(response.Data, out certifiersMainResults); IList <ValidationResultModel <CertifiersModel.Item> > CertifiersItemResults; var areCertifiersDataItemsValid = GlobalLogic.IsModelArrayValid(response.Data.Items, out CertifiersItemResults); if (!isCertifiersDataValid) { var message = $"Certifiers with success: {certifiersMainResults.Model.Success} and results: {certifiersMainResults.Model.Results}." .RequestInfo(client, request) .WithValidationErrors(certifiersMainResults.Results); allErrorMessages.Add(message); } if (!areCertifiersDataItemsValid) { foreach (var CertifiersItemResult in CertifiersItemResults.Where(x => x.Results.Any())) { var message = $"Certifier item with Name: {CertifiersItemResult.Model.Name}" .RequestInfo(client, request) .WithValidationErrors(CertifiersItemResult.Results); allErrorMessages.Add(message); } } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } }
public void DealerDataTest(string dealer, string digest, string auth) { var client = new RestClient(TestConfiguration.API.Location); var request = new RestRequest("/users/{dealer_name}", Method.GET); request .AddUrlSegment("dealer_name", dealer) .AddParameter("digest", digest) .AddHeader("Authorization", auth); var response = client.Execute <DealerDataModel.RootObject>(request); EnsureOkResponseStatusCode(response, client, request); List <string> allErrorMessages = new List <string>(); ValidationResultModel <DealerDataModel.RootObject> dealerDataMainResults; var isDealerDataValid = GlobalLogic.IsModelValid(response.Data, out dealerDataMainResults); ValidationResultModel <DealerDataModel.Items> dealerDataItemResults; var areDealerDataItemsValid = GlobalLogic.IsModelValid(response.Data.Items, out dealerDataItemResults); if (!isDealerDataValid) { var message = $"Dealer with success: {dealerDataMainResults.Model.Success} and results: {dealerDataMainResults.Model.Results}." .RequestInfo(client, request) .WithValidationErrors(dealerDataMainResults.Results); allErrorMessages.Add(message); } if (!areDealerDataItemsValid) { var message = $"Dealer items with user name: {dealerDataMainResults.Model.Items.User_name}" .RequestInfo(client, request) .WithValidationErrors(dealerDataMainResults.Results); allErrorMessages.Add(message); } if (allErrorMessages.Any()) { var allMessages = string.Join("\r\n\r\n", allErrorMessages); throw new Exception(allMessages); } }
public void GenerarGridPokemon(bool amigo) { if (amigo == true) { GlobalGrid.imageFriendImage.Source = new UriImageSource { Uri = new Uri(GlobalLogic.obtenerImagen(GlobalVar.pokAmigo, amigo)) }; } else { GlobalGrid.imageEnemyImage.Source = new UriImageSource { Uri = new Uri(GlobalLogic.obtenerImagen(GlobalVar.pokEnemigo, amigo)) }; } }
private void ProcessSkill(Creature creature, List <UseSkillArgs> argsList, Skill skill) { creature.Attack = new Attack(creature, argsList[0], () => GlobalLogic.AttackStageEnd(creature), () => GlobalLogic.AttackFinished(creature)); VisibleService.Send(creature, new SpAttack(creature, creature.Attack)); VisibleService.Send(creature, new SpAttackDestination(creature, creature.Attack)); ProcessStages(creature, skill); ProcessMove(creature, skill); AiLogic.OnUseSkill(creature, skill); ProcessTargets(creature, skill); }