using AttributeRouting.Web.

Http;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Mail;
using System.Security.Claims;
using System.Web;
using System.Web.Helpers;
using System.Web.Http;
using iNpress.MembershipReboot;
using iNpress.Business.Managers;
using iNpress.Business.DTO;
using BigGame.Web.MembershipReboot;

using System.Web.Http.Description;
using System.Drawing;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;
using iNpress.ViewModels;

namespace iNpress.Controllers.API
{
public class BrandApiController : ApiControllerBase
{
[HttpGet]
[GET("api/Brand/All")]

public HttpResponseMessage GetAll(HttpRequestMessage request)

{
return GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;

BrandManager brandManager = new BrandManager();

bool hasClaim =
ClaimsPrincipal.Current.HasClaim(CustomClaimTypes.Role, "Reseller");
if (hasClaim)
{
iNpress.MembershipReboot.UserRepository userRepo = new
iNpress.MembershipReboot.UserRepository();

User signedUser = userRepo.GetByUserName(User.Identity.Name);

int userId = signedUser.Key;

BrandAddressDTO[] brands = brandManager.GetAllBrands(userId);

response =
request.CreateResponse<BrandAddressDTO[]>(HttpStatusCode.OK, brands);

return response;
}
else
 {
BrandAddressDTO[] brands = brandManager.GetAllBrands(0);

response =
request.CreateResponse<BrandAddressDTO[]>(HttpStatusCode.OK, brands);

return response;
}

});
}

[HttpGet]
[GET("api/Brand/All/{Increment}")]

public HttpResponseMessage GetAll(HttpRequestMessage request, int

Increment)
{
return GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;

BrandManager brandManager = new BrandManager();

bool hasClaim =
ClaimsPrincipal.Current.HasClaim(CustomClaimTypes.Role, "Reseller");
if (hasClaim)
{
iNpress.MembershipReboot.UserRepository userRepo = new
iNpress.MembershipReboot.UserRepository();
User signedUser = userRepo.GetByUserName(User.Identity.Name);
int userId = signedUser.Key;
BrandAddressDTO[] brands = brandManager.GetAllBrands(Increment,
userId);
response =
request.CreateResponse<BrandAddressDTO[]>(HttpStatusCode.OK, brands);

return response;
}
else
{
BrandAddressDTO[] brands =
brandManager.GetAllBrandsShowMore(Increment);
response =
request.CreateResponse<BrandAddressDTO[]>(HttpStatusCode.OK, brands);
return response;
}

});
}

[HttpPost]
[POST("api/Brand/CityCountry")]

public HttpResponseMessage GetByCityCountry(HttpRequestMessage request,

[FromBody] SearchByCityCountryVM searchByCityCountryModelVM)
 {
return GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
UserRepository userRepository = new UserRepository();
BrandManager brandManager = new BrandManager();

bool hasClaim =
ClaimsPrincipal.Current.HasClaim(CustomClaimTypes.Role, "Reseller");
if (hasClaim)
{
iNpress.MembershipReboot.UserRepository userRepo = new
iNpress.MembershipReboot.UserRepository();
User signedUser =
userRepository.GetByUserName(User.Identity.Name);
int ResellerId = signedUser.Key;

BrandAddressDTO[] brands =
brandManager.GetResellerBrandsByCityCountry(searchByCityCountryModelVM.City,
searchByCityCountryModelVM.CountryName, searchByCityCountryModelVM.increment,
ResellerId);

response =
request.CreateResponse<BrandAddressDTO[]>(HttpStatusCode.OK, brands);

return response;
}
else
{

BrandAddressDTO[] brands =
brandManager.GetBrandsByCityCountry(searchByCityCountryModelVM.City,
searchByCityCountryModelVM.CountryName, searchByCityCountryModelVM.increment);

response =
request.CreateResponse<BrandAddressDTO[]>(HttpStatusCode.OK, brands);

return response;
}
});
}

[HttpGet]
[GET("api/BrandOnly/All")]

public HttpResponseMessage GetAllBrandsOnly(HttpRequestMessage request)

{
return GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;

BrandManager brandManager = new BrandManager();

bool hasClaim =
ClaimsPrincipal.Current.HasClaim(CustomClaimTypes.Role, "Reseller");
if (hasClaim)
{
UserRepository userRepository = new UserRepository();
User signedUser =
userRepository.GetByUserName(User.Identity.Name);
int userId = signedUser.Key;
BrandAddressDTO[] brands =
brandManager.GetAllBrandsOnly(userId);

response =
request.CreateResponse<BrandAddressDTO[]>(HttpStatusCode.OK, brands);

return response;
}
else
{
BrandAddressDTO[] brands = brandManager.GetAllBrandsOnly(0);

response =
request.CreateResponse<BrandAddressDTO[]>(HttpStatusCode.OK, brands);

return response;
}

});
}

[HttpGet]
[GET("api/Brand/{id}")]
public HttpResponseMessage GetBrandById(HttpRequestMessage request, int id)
{
return GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;

BrandManager brandManager = new BrandManager();

BrandAddressDTO brand = brandManager.GetBrandById(id);

response =
request.CreateResponse<BrandAddressDTO>(HttpStatusCode.OK, brand);

return response;
});
}

[HttpPost]
[POST("api/Brand/CheckTitle")]
public HttpResponseMessage CheckTitle(HttpRequestMessage request,
[FromBody] BrandAddressDTO brandsDTO)
{
return GetHttpResponse(request, () =>
{
HttpResponseMessage response = null;
bool checking = false;
BrandManager brandManager = new BrandManager();

checking = brandManager.CheckTitle(brandsDTO.BrandTitle);

response = request.CreateResponse<bool>(HttpStatusCode.OK,
checking);
 return response;
});
}

[HttpPost]
[POST("api/Brand/Save")]
public HttpResponseMessage Save(HttpRequestMessage request, [FromBody]
BrandAddressDTO brandsDTO) {
return GetHttpResponse(request, () =>
{

HttpResponseMessage response = null;

string path = "https://maps.googleapis.com/maps/api/staticmap?

center=" + brandsDTO.Latitude + "," + brandsDTO.Longitude +
"&zoom=11&size=300x200";

BrandManager brandManager = new BrandManager();

iNpress.MembershipReboot.UserRepository userRepository = new
iNpress.MembershipReboot.UserRepository();

iNpress.MembershipReboot.User loggedInUser =
userRepository.GetByUserName(User.Identity.Name);
brandsDTO.IsBlockedForMap = false;
if (brandsDTO.BrandID > 0)
{
brandsDTO.UpdatedDate = DateTime.Now;
brandsDTO.UpdatedUserID = loggedInUser.Key;
}
else
{
brandsDTO.UpdatedDate = DateTime.Now;
brandsDTO.UpdatedUserID = loggedInUser.Key;
brandsDTO.CreatedDate = DateTime.Now;
brandsDTO.CreatedUserID = loggedInUser.Key;
}
if (string.IsNullOrEmpty(brandsDTO.ImageBinaryStringAdd) &&
string.IsNullOrEmpty(brandsDTO.ImageBinaryStringEdit) &&
string.IsNullOrEmpty(brandsDTO.LogoPath))
{

response = request.CreateResponse<string>(HttpStatusCode.OK,
"Brand Logo is required && Kindly Upload image files");

return response;
}
if (brandsDTO.ImageBinaryStringEdit != "" && brandsDTO.LogoPath !=
null && brandsDTO.BrandID > 0)
{
brandsDTO.LogoPath =
brandManager.GetBrandById(brandsDTO.BrandID).LogoPath;
try
{
string mapImg = brandsDTO.LogoPath.Substring(0,
brandsDTO.LogoPath.Length - 4); ;
mapImg = mapImg + "_map.jpg";

File.Delete(System.Web.HttpContext.Current.Server.MapPath("~" + mapImg));
File.Delete(System.Web.HttpContext.Current.Server.MapPath("~" +
brandsDTO.LogoPath));

}
catch (Exception e)
{

Guid fileNumber = Guid.NewGuid();

byte[] imageBytes =
Convert.FromBase64String(brandsDTO.ImageBinaryStringEdit);
MemoryStream ms = new MemoryStream(imageBytes, 0,
imageBytes.Length);

// Convert byte[] to Image

ms.Write(imageBytes, 0, imageBytes.Length);
Image image = Image.FromStream(ms, true);

//For Making Thumbnail and save it

int width = image.Width;

int height = image.Height;

if (height > 700)

height = 700;

if (width > 500)

{
UserCatalogManager userCatalogManager = new
UserCatalogManager();
//Image thumbnailImage =
userCatalogManager.getThumbnail(image, 500, height);
Image thumbnailImage = userCatalogManager.FixedSize(image,
300, 200, true);

thumbnailImage.Save(System.Web.HttpContext.Current.Server.MapPath("~/Logos/Brands/"
+ fileNumber + ".jpg"), System.Drawing.Imaging.ImageFormat.Jpeg);
}
else
{

image.Save(System.Web.HttpContext.Current.Server.MapPath("~/Logos/Brands/" +
fileNumber + ".jpg"), System.Drawing.Imaging.ImageFormat.Jpeg);
}

//while
(File.Exists(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/Advertisement
s/Images/img" + fileNumber + ".jpg")))

//MAp Image Generation

using (WebClient Client = new WebClient())
{

//Client.Headers.Add("user-agent", "Mozilla/5.0 (Windows NT

6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36");
 Client.DownloadFile(path,
System.Web.HttpContext.Current.Server.MapPath("~/Logos/Brands/" + fileNumber +
"_map.jpg"));
}
//MAp Image Generation

brandsDTO.LogoPath = string.Empty;

brandsDTO.LogoPath = "/Logos/Brands/" + fileNumber + ".jpg";

// brandsDTO.LogoPath = "/Logos/Brands/" + fileNumber + ".jpg";

}
if (brandsDTO.ImageBinaryStringAdd != "" && brandsDTO.BrandID == 0)
{
Guid fileNumber = Guid.NewGuid();

byte[] imageBytes =
Convert.FromBase64String(brandsDTO.ImageBinaryStringAdd);
MemoryStream ms = new MemoryStream(imageBytes, 0,
imageBytes.Length);

// Convert byte[] to Image

ms.Write(imageBytes, 0, imageBytes.Length);
Image image = Image.FromStream(ms, true);

//For Making Thumbnail and save it

int width = image.Width;
int height = image.Height;
if (width > 500)
{
UserCatalogManager userCatalogManager = new
UserCatalogManager();
//Image thumbnailImage =
userCatalogManager.getThumbnail(image, 500, height);
Image thumbnailImage = userCatalogManager.FixedSize(image,
300, 200, true);

thumbnailImage.Save(System.Web.HttpContext.Current.Server.MapPath("~/Logos/Brands/"
+ fileNumber + ".jpg"), System.Drawing.Imaging.ImageFormat.Jpeg);
}
else
{

image.Save(System.Web.HttpContext.Current.Server.MapPath("~/Logos/Brands/" +
fileNumber + ".jpg"), System.Drawing.Imaging.ImageFormat.Jpeg);
}

brandsDTO.LogoPath = "/Logos/Brands/" + fileNumber + ".jpg";

//MAp Image Generation
using (WebClient Client = new WebClient())
{
Client.DownloadFile(path,
System.Web.HttpContext.Current.Server.MapPath("~/Logos/Brands/" + fileNumber +
"_map.jpg"));
}
 // brandsDTO.LogoPath = "/Logos/Brands/" + fileNumber + ".jpg";
}

if (brandsDTO.ImageBinaryStringAdd == "" &&

brandsDTO.ImageBinaryStringEdit == "")
{
using (WebClient Client = new WebClient())
{
string filesavepath = brandsDTO.LogoPath;
string imgFilePath = filesavepath.Substring(0,
filesavepath.Length - 4);
imgFilePath = imgFilePath + "_map.jpg";
Client.DownloadFile(path,
System.Web.HttpContext.Current.Server.MapPath(imgFilePath));
}
}

bool hasClaim =
ClaimsPrincipal.Current.HasClaim(CustomClaimTypes.Role, "Reseller");
if (hasClaim)
{
iNpress.MembershipReboot.UserRepository userRepo = new
iNpress.MembershipReboot.UserRepository();
User signedUser =
userRepository.GetByUserName(User.Identity.Name);
int userId = signedUser.Key;

brandManager.SaveBrand(brandsDTO, userId);

response = request.CreateResponse<string>(HttpStatusCode.OK,
"OK");

return response;

}
else
{
brandManager.SaveBrandForSuperAdmin(brandsDTO, 0);

response = request.CreateResponse<string>(HttpStatusCode.OK,
"OK");

return response;
}
});
}

[HttpDelete]
[DELETE("api/brand/Delete/{id}")]
public HttpResponseMessage Delete(HttpRequestMessage request, int id)
{
return GetHttpResponse(request, () =>
{

HttpResponseMessage response = null;

BrandManager brandManager = new BrandManager();

BrandAddressDTO brand = brandManager.GetBrandById(id);
 try
{
string mapImg = brand.LogoPath.Substring(0,
brand.LogoPath.Length - 4);;
mapImg = mapImg + "_map.jpg";
File.Delete(System.Web.HttpContext.Current.Server.MapPath("~" +
mapImg));
File.Delete(System.Web.HttpContext.Current.Server.MapPath("~" +
brand.LogoPath));

}
catch (Exception e)
{

}
brandManager.DeleteBrand(id);
response = request.CreateResponse<string>(HttpStatusCode.OK, "OK");

return response;
});
}

[HttpPost]
[POST("api/brand/DeleteSelected")]
public HttpResponseMessage DeleteSelected(HttpRequestMessage request,
[FromBody] DeleteSelectedVM deleteSelectedVM)
{
return GetHttpResponse(request, () =>
{

HttpResponseMessage response = null;

BrandManager brandManager = new BrandManager();

for (int i = 0; i < deleteSelectedVM.DeleteIDs.Length; i++)

{
brandManager.DeleteBrand(deleteSelectedVM.DeleteIDs[i]);
}
response = request.CreateResponse<string>(HttpStatusCode.OK, "OK");

return response;
});
}

}
}