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