public async Task <string> DeleteItem(string Itemid)
{
try
{
using (var client = new HttpClient())
{
HttpResponseMessage response = await client.DeleteAsync(Keys.Url_Main + "item/delete/" + Itemid);
using (HttpContent spawn = response.Content)
{
string content = await spawn.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
return("true");
}
return(callback.Mess);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
return(Strings.HttpFailed);
}
}
public async Task <bool> DeleteNotify(string email)
{
try
{
using (var client = new HttpClient())
{
HttpResponseMessage response = await client.DeleteAsync(Keys.Url_Main + "notifaction/delete/" + email);
using (HttpContent spawn = response.Content)
{
string content = await spawn.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
return(true);
}
DialogService.ShowError(callback.Mess);
return(false);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
DialogService.ShowErrorToast(Strings.HttpFailed);
return(false);
}
}
public async Task <string> ValidateToken(string Token)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(Keys.Url_Main + "auth/reset/" + Token);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == Strings.True)
{
return(Strings.True);
}
return(callback.Mess);
}
catch (Exception ex)
{
DialogService.ShowErrorToast(Strings.HttpFailed);
Debug.WriteLine(Keys.TAG + ex);
return(Strings.HttpFailed);
}
}
public async Task UpdateStatus(mAccount account)
{
try
{
var Usercreds = Newtonsoft.Json.JsonConvert.SerializeObject(account);
HttpContent UserContent = new StringContent(Usercreds, Encoding.UTF8, "application/json");
using (var client = new HttpClient())
{
HttpResponseMessage response = await client.PutAsync(Keys.Url_Main + "user/update-status", UserContent);
using (HttpContent spawn = response.Content)
{
string content = await spawn.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
return;
}
else
{
DialogService.ShowErrorToast(callback.Mess);
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
DialogService.ShowError(Strings.HttpFailed);
}
}
public async Task <string> PostQuestion(mQuestion question)//server error
{
try
{
var Questioncreds = Newtonsoft.Json.JsonConvert.SerializeObject(question);
HttpContent ItemContent = new StringContent(Questioncreds, Encoding.UTF8, "application/json");
using (var client = new HttpClient())
{
HttpResponseMessage response = await client.PostAsync(Keys.Url_Main + "item-question/post", ItemContent);
using (HttpContent spawn = response.Content)
{
string content = await spawn.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
return("true");
}
DialogService.ShowError(callback.Mess);
return(null);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
return(Strings.HttpFailed);
}
}
public async Task <mAccount> FetchUser(string Email)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(Keys.Url_Main + "user/get-profile/" + Email);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
mAccount User = Newtonsoft.Json.JsonConvert.DeserializeObject <mAccount>(callback.Data.ToString());
return(User);
}
DialogService.ShowError(callback.Mess);
return(null);
}
catch (Exception ex)
{
DialogService.ShowErrorToast(Strings.HttpFailed);
Debug.WriteLine(Keys.TAG + ex);
return(null);
}
}
public async Task <string> RateProduct(mRate rate)
{
try
{
var Itemcreds = Newtonsoft.Json.JsonConvert.SerializeObject(rate);
HttpContent ItemContent = new StringContent(Itemcreds, Encoding.UTF8, "application/json");
using (var client = new HttpClient())
{
HttpResponseMessage response = await client.PutAsync(Keys.Url_Main + "product/rate/post", ItemContent);
using (HttpContent spawn = response.Content)
{
string content = await spawn.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
return("true");
}
DialogService.ShowError(Strings.ServerFailed);
return(callback.Mess);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
return(Strings.ServerFailed);
}
}
public async Task <string> Additem(mUserItem item)
{
try
{
var Itemcreds = Newtonsoft.Json.JsonConvert.SerializeObject(item);
HttpContent ItemContent = new StringContent(Itemcreds, Encoding.UTF8, "application/json");
using (var client = new HttpClient())
{
HttpResponseMessage response = await client.PostAsync(Keys.Url_Main + "item/add", ItemContent);
using (HttpContent spawn = response.Content)
{
string content = await spawn.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
return("true");
}
return(callback.Mess);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
return(Strings.HttpFailed);
}
}
public async Task <ObservableCollection <mQuestion> > FetchQuestions(string link, int len, int amount, string txt = null)
{
try
{
if (txt == null)
{
link += "?len=" + len + "&amount=" + amount;
}
else
{
link += "?Search=" + txt + "&len=" + len + "&amount=" + amount;
}
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(link);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
ObservableCollection <mQuestion> newitems = new ObservableCollection <mQuestion>();
newitems = Newtonsoft.Json.JsonConvert.DeserializeObject <ObservableCollection <mQuestion> >(callback.Data.ToString());
if (newitems.Count < 1)
{
return(null);
}
for (var i = 0; i < newitems.Count; i++)
{
if (newitems[i].Answer == null)
{
newitems[i].Answer = "*No Answer Yet*";
}
}
return(newitems);
}
else
{
DialogService.ShowError(callback.Mess);
return(null);
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
DialogService.ShowErrorToast(Strings.HttpFailed);
return(null);
}
}
public async Task <ObservableCollection <Product> > FetchDeals(int amount, string category, string by, int len)
{
var link = Keys.Url_Main + "product/deals?amount=" + amount.ToString() + "&len=" + len.ToString();
if (!String.IsNullOrEmpty(category))
{
link += "&category=" + category;
}
if (!String.IsNullOrEmpty(by))
{
link += "&by=" + by;
}
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(link);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
ObservableCollection <Product> newitems = new ObservableCollection <Product>();
newitems = Newtonsoft.Json.JsonConvert.DeserializeObject <ObservableCollection <Product> >(callback.Data.ToString());
if (newitems.Count < 1)
{
return(null);
}
newitems = CalculatePercentages(newitems);
return(newitems);
}
DialogService.ShowError(callback.Mess);
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
DialogService.ShowError(Strings.HttpFailed);
return(null);
}
}
public async Task <ObservableCollection <mUserItem> > FetchUsersItems(string userEmail, int amount, int len, string searchTxt = null)
{
var link = Keys.Url_Main + "item/user-items/" + userEmail + "?amount=" + amount.ToString() + "&len=" + len.ToString();
if (searchTxt != null)
{
link += "&Search=" + searchTxt;
}
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(link);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
ObservableCollection <mUserItem> newitems = new ObservableCollection <mUserItem>();
newitems = Newtonsoft.Json.JsonConvert.DeserializeObject <ObservableCollection <mUserItem> >(callback.Data.ToString());
if (newitems.Count < 1)
{
return(null);
}
return(newitems);
}
else
{
DialogService.ShowError(Strings.ServerFailed);
return(null);
}
}
catch (Exception ex)
{
DialogService.ShowErrorToast(Strings.HttpFailed);
Debug.WriteLine(Keys.TAG + ex);
return(null);
}
}
public async Task <CartType> FetchUserCart(string email)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(Keys.Url_Main + "cart/get/" + email);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
ObservableCollection <Product> newitems = new ObservableCollection <Product>();
ObservableCollection <string> quantity = new ObservableCollection <string>();
newitems = Newtonsoft.Json.JsonConvert.DeserializeObject <ObservableCollection <Product> >(callback.Data.ToString());
quantity = Newtonsoft.Json.JsonConvert.DeserializeObject <ObservableCollection <string> >(callback.Data2.ToString());
if (newitems.Count < 1)
{
return(null);
}
return(new CartType()
{
Prop1 = newitems, Prop2 = quantity
});
}
else
{
DialogService.ShowError(Strings.ServerFailed);
return(null);
}
}
catch (Exception ex)
{
DialogService.ShowErrorToast(Strings.HttpFailed);
Debug.WriteLine(Keys.TAG + ex);
return(null);
}
}
public async Task <mQuestion> FetchQuestion(string id)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(Keys.Url_Main + "item-question/question/" + id);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
mQuestion newitems = new mQuestion();
newitems = Newtonsoft.Json.JsonConvert.DeserializeObject <mQuestion>(callback.Data.ToString());
if (newitems == null)
{
return(null);
}
if (newitems.Answer == null)
{
newitems.Answer = "*No Answer Yet*";
}
return(newitems);
}
else
{
DialogService.ShowError(callback.Mess);
return(null);
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
DialogService.ShowErrorToast(Strings.HttpFailed);
return(null);
}
}
public async Task <ObservableCollection <mOrderAddress> > FetchAddresses(string email, int amount, int len)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(Keys.Url_Main + "address/get/" + email + "?amount=" + amount + "&len=" + len);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
ObservableCollection <mOrderAddress> newitems = new ObservableCollection <mOrderAddress>();
newitems = Newtonsoft.Json.JsonConvert.DeserializeObject <ObservableCollection <mOrderAddress> >(callback.Data.ToString());
if (newitems.Count < 1)
{
return(null);
}
return(newitems);
}
else
{
DialogService.ShowError(Strings.ServerFailed);
return(null);
}
}
catch (Exception ex)
{
DialogService.ShowErrorToast(Strings.HttpFailed);
Debug.WriteLine(Keys.TAG + ex);
return(null);
}
}
public async Task <ObservableCollection <Product> > FetchUserInterets(string UserEmail)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(Keys.Url_Main + "product/interests/" + UserEmail);//product/interests/
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
ObservableCollection <Product> newitems = new ObservableCollection <Product>();
newitems = Newtonsoft.Json.JsonConvert.DeserializeObject <ObservableCollection <Product> >(callback.Data.ToString());
if (newitems.Count < 1)
{
return(null);
}
newitems = CalculatePercentages(newitems);
return(newitems);
}
else
{
DialogService.ShowError(Strings.ServerFailed);
return(null);
}
}
catch (Exception ex)
{
DialogService.ShowErrorToast(Strings.HttpFailed);
Debug.WriteLine(Keys.TAG + ex);
return(null);
}
}
public async Task <Product> FetchProduct(string Id)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(Keys.Url_Main + "product/get/" + Id);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
Product newitem = new Product();
newitem = Newtonsoft.Json.JsonConvert.DeserializeObject <Product>(callback.Data.ToString());
if (newitem == null)
{
return(null);
}
newitem = CalculatePercentage(newitem);
return(newitem);
}
else
{
DialogService.ShowError(Strings.ServerFailed);
return(null);
}
}
catch (Exception ex)
{
DialogService.ShowError(Strings.HttpFailed);
Debug.WriteLine(Keys.TAG + ex);
return(null);
}
}
public async Task UpdateToken(string token) //When someone logout and login into another account the token wont update until they restart the app
{
if (!hasToken)
{
return;
}
Current_Account.nToken = token;
try
{
var Usercreds = Newtonsoft.Json.JsonConvert.SerializeObject(Current_Account);
HttpContent UserContent = new StringContent(Usercreds, Encoding.UTF8, "application/json");
using (var client = new HttpClient())
{
HttpResponseMessage response = await client.PutAsync(Keys.Url_Main + "user/update-token", UserContent);
using (HttpContent spawn = response.Content)
{
string content = await spawn.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
hasToken = false;
Debug.WriteLine(Keys.TAG + callback.Mess);
}
else
{
Debug.WriteLine(Keys.TAG + "Fail To Update Token");
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
DialogService.ShowError(Strings.HttpFailed);
}
}
public async Task <string> Login(mAccount account)
{
try
{
var Usercreds = Newtonsoft.Json.JsonConvert.SerializeObject(account);
HttpContent UserContent = new StringContent(Usercreds, Encoding.UTF8, "application/json");
using (var client = new HttpClient())
{
HttpResponseMessage response = await client.PostAsync(Keys.Url_Main + "auth/login", UserContent);
using (HttpContent spawn = response.Content)
{
string content = await spawn.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
Instance.Current_Account = Newtonsoft.Json.JsonConvert.DeserializeObject <mAccount>(callback.Data.ToString());
Current_Account = Newtonsoft.Json.JsonConvert.DeserializeObject <mAccount>(callback.Data.ToString());
CrossSettings.Current.AddOrUpdateValue <string>("Current_User", callback.Data.ToString());
await UpdateToken(CrossSettings.Current.GetValueOrDefault <string>("Token"));
return("true");
}
return(callback.Mess);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
return(Strings.HttpFailed);
}
}
public async Task <mUserItem> FetchItem(string Itemid)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(Keys.Url_Main + "item/" + Itemid);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
mUserItem newitem = new mUserItem();
newitem = Newtonsoft.Json.JsonConvert.DeserializeObject <mUserItem>(callback.Data.ToString());
if (newitem == null)
{
return(null);
}
return(newitem);
}
else
{
DialogService.ShowError(Strings.ServerFailed);
return(null);
}
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
DialogService.ShowErrorToast(Strings.HttpFailed);
return(null);
}
}
public async Task <string> ShippingCost(string email)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(Keys.Url_Main + "cart/check/shipping/" + email);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
var cost = callback.Data.ToString();
if (cost == "0" || cost == null)
{
cost = "0";
}
return(cost);
}
else
{
DialogService.ShowError(Strings.ServerFailed);
return(null);
}
}
catch (Exception ex)
{
DialogService.ShowErrorToast(Strings.HttpFailed);
Debug.WriteLine(Keys.TAG + ex);
return(null);
}
}
public async Task <ObservableCollection <mUserItem> > FetchSearch(string link)
{
try
{
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(link);
response.EnsureSuccessStatusCode();
string content = await response.Content.ReadAsStringAsync();
mServerCallback callback = Newtonsoft.Json.JsonConvert.DeserializeObject <mServerCallback>(content);
if (callback.Status == "true")
{
ObservableCollection <mUserItem> newitems = new ObservableCollection <mUserItem>();
newitems = Newtonsoft.Json.JsonConvert.DeserializeObject <ObservableCollection <mUserItem> >(callback.Data.ToString());
if (newitems.Count < 1)
{
return(null);
}
return(newitems);
}
DialogService.ShowError(callback.Mess);
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(Keys.TAG + ex);
DialogService.ShowErrorToast(Strings.HttpFailed);
return(null);
}
}
