public async Task <RESTResult> AddOrUpdateItemAsync(UserDto currentUser, ItemDto item, bool isNew)
{
RESTResult result = new RESTResult
{
Code = Common.RESTStatus.Failed,
Message = "Set Item Failed"
};
if (!isNew)
{
if (item.Id.Equals(Guid.Empty))
{
throw new ArgumentException("Please input correct item data");
}
var itemEntity = await _itemRepository.GetAsync(item.Id);
if (itemEntity != null)
{
itemEntity.Name = item.Name;
itemEntity.Price = item.Price;
itemEntity.PromotionPrice = item.PromotionPrice;
itemEntity.Status = item.Status;
itemEntity.Unit = item.Unit;
await _itemRepository.UpdateAsync(itemEntity);
result.Code = RESTStatus.Success;
result.Message = "Set Item successfully";
}
}
else
{
var itemEntity = Mapper.Map <ItemDto, Item>(item);
itemEntity.Id = Guid.NewGuid();
await _itemRepository.InsertAsync(itemEntity);
result.Code = RESTStatus.Success;
result.Message = "Set Item successfully";
}
return(result);
}
public async Task <RESTResult> AddOrUpdateDepartmentAsync(DepartmentDto departmentInfo, Guid userId, bool IsDeleted)
{
RESTResult result = new RESTResult {
Code = RESTStatus.Failed
};
if (Guid.Empty.Equals(departmentInfo.Id) || departmentInfo.Id == null)
{
//TODO:Add a new department
var deparmentEntity = Mapper.Map <DepartmentDto, Department>(departmentInfo);
deparmentEntity.CreateTime = DateTime.Now;
deparmentEntity.CreateByUserId = userId;
await _departmentReposiotry.InsertAsync(deparmentEntity);
result.Code = RESTStatus.Success;
result.Message = "Add the department successful";
}
else
{
//TODO:Update department
var departmentEntity = await _departmentReposiotry.GetAsync(departmentInfo.Id.Value);
if (departmentEntity.IsDeleted)
{
result.Message = "The department have been removed";
return(result);
}
if (departmentEntity != null)
{
departmentEntity.Name = string.IsNullOrEmpty(departmentInfo.Name) ? departmentEntity.Name : departmentInfo.Name;
departmentEntity.ModifyByUserId = userId;
departmentEntity.ModifyTime = DateTime.Now;
departmentEntity.IsDeleted = IsDeleted;
await _departmentReposiotry.UpdateAsync(departmentEntity);
result.Code = RESTStatus.Success;
result.Message = "update the department successful";
}
}
return(result);
}
public async Task <RESTResult> AddOrUpdatePermissionAsync(PermissionDto permissionInfo, Guid currentUserId, bool IsDeleted)
{
RESTResult result = new RESTResult {
Code = RESTStatus.Success
};
if (Guid.Empty.Equals(permissionInfo.Id) || permissionInfo.Id == null)
{
//TODO:Add a new department
var permissionEntity = Mapper.Map <PermissionDto, Permission>(permissionInfo);
if (permissionInfo.PermissionData != null)
{
permissionInfo.PermissionData.Id = Guid.NewGuid();
permissionInfo.PermissionData.ParentId = permissionInfo.PermissionData.ParentId != null ? permissionInfo.PermissionData.ParentId : Guid.Empty;
permissionEntity.DataXml = _serializer.Serialize(permissionInfo.PermissionData);
}
permissionEntity.CreateTime = DateTime.Now;
permissionEntity.CreateByUserId = currentUserId;
result.Data = await _permissionRepository.InsertAsync(permissionEntity);
}
else
{
//TODO:Update department
var permissionEntity = await _permissionRepository.GetAsync(permissionInfo.Id.Value);
permissionEntity.Name = permissionInfo.Name;
permissionEntity.ModifyByUserId = currentUserId;
permissionEntity.ModifyTime = DateTime.Now;
permissionEntity.IsDeleted = IsDeleted;
permissionEntity.DataXml = permissionInfo.PermissionData != null?_serializer.Serialize(permissionInfo.PermissionData) : permissionEntity.DataXml;
result.Data = await _permissionRepository.UpdateAsync(permissionEntity);
}
if (result.Data != null)
{
return(result);
}
result.Code = RESTStatus.Failed;
return(result);
}
public async Task <RESTResult> GetItemsByPageAsync(UserDto currentUser, int pageIndex, int pageSize)
{
RESTResult result = new RESTResult
{
Code = Common.RESTStatus.Success
};
IList <ItemDto> itemDtos = null;
//TODO: get items from paging
var itemModels = (await _itemRepository.GetAllListAsync(c => c.IsDeleted = false)).Take(pageIndex * pageSize).Skip(pageSize * (pageIndex - 1));
if (itemModels.Count() > 0)
{
itemDtos = new List <ItemDto>();
foreach (var item in itemModels)
{
itemDtos.Add(Mapper.Map <Item, ItemDto>(item));
}
result.Data = itemDtos;
}
return(result);
}
public async Task <RESTResult> GetItemDetailedByIdAsync(UserDto currentUser, Guid itemId)
{
RESTResult result = new RESTResult
{
Code = Common.RESTStatus.Success,
Message = "Get item detailed data successfully"
};
var itemEntity = await _itemRepository.GetAsync(itemId);
var itemDto = Mapper.Map <Item, ItemDto>(itemEntity);
//TODO: get pictures
var pictureEntity = await _pictureRepository.GetAllListAsync(item => item.ItemId.Equals(itemId));
pictureEntity.ForEach(pictureItem =>
{
itemDto.PictureLink.Add($"{_baseOptions.Value.Host}/{pictureItem.Id}");
});
result.Data = itemDto;
return(result);
}
public async Task <RESTResult> AddOrUpdateUserInfo(UserInfoDto userInfo, Guid userId)
{
RESTResult result = new RESTResult {
Code = RESTStatus.Failed
};
var userInfos = await _userInfoRepository.GetAllListAsync(item => item.UserId.Equals(userId));
if (userInfos.Count <= 0)
{
//TODO:Add user info
var userInfoModle = Mapper.Map <UserInfoDto, UserInfo>(userInfo);
userInfoModle.UserId = userId;
await _userInfoRepository.InsertAsync(userInfoModle);
result.Code = RESTStatus.Success;
result.Message = "Create User info successful";
return(result);
}
else
{
//TODO:Update user info
var userinfoEntity = userInfos.First();
userinfoEntity.FirstName = userInfo.FirstName;
userinfoEntity.LastName = userInfo.LastName;
userinfoEntity.NickName = userInfo.NickName;
userinfoEntity.CardType = userInfo.CardType;
userinfoEntity.CardNo = userInfo.CardNo;
userinfoEntity.Phone = userInfo.Phone;
userinfoEntity.Tel = userInfo.Tel;
userinfoEntity.Address = userInfo.Address;
userinfoEntity.BirthDate = userInfo.BirthDate;
userinfoEntity.ExtendInfo = userInfo.ExtendInfo;
await _userInfoRepository.UpdateAsync(userinfoEntity);
result.Code = RESTStatus.Success;
result.Data = userInfo;
}
return(result);
}
public async Task <RESTResult> SetDeaprtmentAndRoleAsync(Guid userRoleId, Guid curretnUserId, Guid userId, Guid roleId, Guid departmentId)
{
RESTResult result = new RESTResult
{
Code = RESTStatus.Success
};
UserRole userRoleEntity;
if (Guid.Empty.Equals(userRoleId))
{
//TODO:Add new user role
userRoleEntity = new UserRole
{
RoleId = roleId,
UserId = userId,
CreateByUserId = curretnUserId,
CreateTime = DateTime.Now
};
await _userRoleRepository.InsertAsync(userRoleEntity);
}
else
{
userRoleEntity = await _userRoleRepository.GetAsync(userRoleId);
userRoleEntity.RoleId = roleId;
userRoleEntity.ModifyByUserId = curretnUserId;
userRoleEntity.ModifyTime = DateTime.Now;
await _userRoleRepository.UpdateAsync(userRoleEntity);
}
if (userRoleEntity != null)
{
result.Message = "Set departmnet and role successful";
return(result);
}
result.Code = RESTStatus.Failed;
result.Message = "Set departmnet and role failed";
return(result);
}
public async Task <RESTResult> GetMenusToCurrentUser(Guid userId)
{
RESTResult result = new RESTResult {
Code = RESTStatus.Success
};
var permissions = await GetCurrentUserPermissions(userId);
List <PageMenu> pages = new List <PageMenu>();
foreach (var item in permissions)
{
if (!string.IsNullOrEmpty(item.DataXml))
{
pages.Add(_serializer.Deserialize <PageMenu>(item.DataXml));
}
}
List <PageDto> pageDTOs = new List <PageDto>();
RecursivePage(pages.OrderBy(c => c.ParentId).ToList(), pageDTOs, true);
result.Data = pageDTOs;
return(result);
}
static async Task MatchIdScraperAsync(string[] args)
{
List <string> regions = new List <string>();
regions.Add("na");
regions.Add("euw");
regions.Add("kr");
regions.Add("tr");
regions.Add("lan");
regions.Add("eune");
regions.Add("oce");
regions.Add("las");
regions.Add("br");
regions.Add("ru");
foreach (string region in regions)
{
for (long i = StartEpochTime; i < CurrentEpochTime; i += Interval)
{
string fileName = JSONCacheDirectory + region + @"\" + i.ToString() + ".json";
if (!File.Exists(fileName))
{
RESTResult <List <long> > gameListResult =
await
RESTHelpers.RESTRequest <List <long> >(
string.Format("{0}{1}/v4.1/game/ids", BaseUrl.Replace("/na.", "/" + region + "."), region), "",
DevKey, "beginDate=" + i.ToString(), 4);
if (gameListResult.Success)
{
JavaScriptSerializer jss = new JavaScriptSerializer();
File.WriteAllText(fileName, jss.Serialize(gameListResult.ReturnObject));
Console.WriteLine(string.Format("Region {0}, File {1}", region, fileName));
}
}
}
}
}
public async Task <RESTResult> RemoveItemAsync(Guid itemId)
{
RESTResult result = new RESTResult
{
Code = RESTStatus.Failed,
Message = "Remove ITem Filaed"
};
var itemEntity = await _itemRepository.GetAsync(itemId);
if (itemEntity == null)
{
result.Message = "Can not find the item, please input the correct id";
return(result);
}
//TODO:Remove the item, set the IsDeleted as true;
itemEntity.IsDeleted = true;
await _itemRepository.UpdateAsync(itemEntity);
result.Code = RESTStatus.Success;
result.Message = "Successed";
return(result);
}
public RESTResult <TResponse, TError> Put <TResponse, TError>(string url, object model = null)
{
using (WebClient client = new WebClient())
{
var result = new RESTResult <TResponse, TError>();
try
{
client.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
var str = toUrlFormData(model);
var response = client.UploadString(url, "PUT", toUrlFormData(model));
result.model = JsonConvert.DeserializeObject <TResponse>(response);
}
catch (WebException ex)
{
var resp = (HttpWebResponse)ex.Response;
var errorStr = new StreamReader(resp.GetResponseStream()).ReadToEnd();
result.error = JsonConvert.DeserializeObject <TError>(errorStr);
}
return(result);
}
}
public ActionResult GetOneThread(int ThreadID)
{
JsonResult retData = new JsonResult();
try
{
RESTResult Result = (new REST(Global.WebAPIBaseURL, "api/Training/RecDB/V1/App/Thread/GetOneThread?ThreadID=" + ThreadID, REST.Method.GET)).Result;
if (Result.Success)
{
retData = Json(new
{
Status = "Success",
Message = "Get Thread Success!",
Data = Result.Deserialize <ThreadModel>()
});
}
else
{
retData = Json(new
{
Status = "Failed",
Message = "Failed When Getting Data.."
});
}
}
catch (Exception ex)
{
retData = Json(new
{
Status = "Failed",
Message = ex.Message
});
}
return(retData);
}
public ActionResult Edit(BookModel model)
{
JsonResult retData = new JsonResult();
try
{
RESTResult Result = (new REST(Global.WebAPIBaseURL,
"/api/Training/BookDB/V1/App/Book/GetOneBook?BookID=" + model.BookID,
REST.Method.GET,
REST.NeedOAuth.False)).Result;
if (Result.Success)
{
retData = Json(new {
Status = "Success",
Data = Result.Deserialize <BookModel>()
});
}
else
{
retData = Json(new
{
Status = "Failed",
Message = "Failed when getting data.."
});
}
}
catch (Exception ex)
{
retData = Json(new
{
Status = "Failed",
Message = ex.Message
});
}
return(retData);
}
public RESTResult <TResponse, TError> Get <TResponse, TError>(string url)
{
using (WebClient client = new WebClient())
{
var result = new RESTResult <TResponse, TError>();
try
{
var response = client.DownloadString(url);
result.model = JsonConvert.DeserializeObject <TResponse>(response);
if (result.model == null)
{
result.error = JsonConvert.DeserializeObject <TError>(response);
}
}
catch (WebException ex)
{
var resp = (HttpWebResponse)ex.Response;
var errorStr = new StreamReader(resp.GetResponseStream()).ReadToEnd();
result.error = JsonConvert.DeserializeObject <TError>(errorStr);
}
return(result);
}
}
public ActionResult Index()
{
JsonResult RetData = new JsonResult();
try
{
HomeViewModel hvm = new HomeViewModel();
RESTResult Result = (new REST(Global.WebAPIBaseURL, "/api/Training/BookDB/V1/App/Book/GetAllBooks", REST.Method.GET, REST.NeedOAuth.False)).Result;
if (Result.Success)
{
hvm.Books = Result.Deserialize <List <BookModel> >();
}
else
{
hvm.Books = new List <BookModel>();
}
return(View("index", hvm));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <RESTResult> GetUsers(UserDto currentUser, int pageIndex, int pageSize)
{
RESTResult result = new RESTResult {
Code = RESTStatus.Success
};
List <UserDto> userDTOs = new List <UserDto>();
//TODO: Super admin
if (currentUser.Roles.Where(item => item.Level.Equals(RoleLevelStatus.SupperAdmin)).Count() > 0)
{
var allUserCount = await _userRepository.CountAsync();
var allUser = (await _userRepository.GetAllListAsync()).Take(pageIndex * pageSize).Skip(pageSize * (pageIndex - 1));
allUser.ToList().ForEach(item => userDTOs.Add(Mapper.Map <User, UserDto>(item)));
result.Data = new { users = userDTOs, Count = allUserCount };
return(result);
}
if (currentUser.Department == null || currentUser.Permissions == null)
{
result.Code = RESTStatus.NotData;
return(result);
}
var allUserIds = await _userDepartmentReposiotry.GetAllListAsync(item => item.DepartmentId.Equals(currentUser.Department.Id));
var userModels = _userRepository.GetAllList(item => allUserIds.Select(c => c.UserId).Contains(item.Id) && item.IsDeleted.Equals(false)).Take(pageIndex * pageSize).Skip(pageSize * (pageIndex - 1));
//TODO:Mapping, DOT NOT USE THE .ToList()
foreach (var item in userModels)
{
userDTOs.Add(Mapper.Map <User, UserDto>(item));
}
var userCount = await _userRepository.CountAsync(item => item.IsDeleted.Equals(false));
result.Data = new { users = userDTOs, Count = userCount };
return(result);
}
public ActionResult Delete(AssignmentModel Model)
{
JsonResult retData = new JsonResult();
try
{
RESTResult Result = (new REST(Global.WebAPIBaseURL, "/api/Training/RecDB/V1/App/Assignment/DeleteAssignment", REST.Method.POST, Model)).Result;
if (Result.Success)
{
retData = Json(new
{
Status = "Success",
Message = "Delete Assignment Success!",
URL = Global.BaseURL + "/Assignment"
});
}
else
{
retData = Json(new
{
Status = "Failed",
Message = "Failed When Deleting Data.."
});
}
}
catch (Exception ex)
{
retData = Json(new
{
Status = "Failed",
Message = ex.Message
});
}
return(retData);
}
static async Task MatchDetailScraperAsync(String[] args)
{
/*
* For the sake of "Compartimentilization" (or however you spell it...)
* I am assigning these local variables from the global ones, so when
* this function moves you can easily change what the values are.
*/
int HttpResponse_RateLimitExceeded = 429;
String jsonCacheDirectory = JSONCacheDirectory;
String matchInfoDirectory = MatchDetailDirectory;
String baseUrl = BaseUrl;
String fileSearchPattern = "*.json";
int millisecondsPerRequest = 250;
//Stopwatch sw = new Stopwatch();
//====--------------------------------
List <string> regions = new List <string>();
regions.Add("na");
regions.Add("euw");
regions.Add("kr");
regions.Add("tr");
regions.Add("lan");
regions.Add("eune");
regions.Add("oce");
regions.Add("las");
regions.Add("br");
regions.Add("ru");
try
{
foreach (string region in regions)
{
String inputDirectory = Path.Combine(jsonCacheDirectory, region);
String outputDirectory = Path.Combine(inputDirectory, matchInfoDirectory);
if (!Directory.Exists(outputDirectory))
{
Directory.CreateDirectory(outputDirectory);
}
foreach (var file in Directory.GetFiles(inputDirectory, fileSearchPattern))
{
using (StreamReader reader = new StreamReader(new FileStream(file, FileMode.Open)))
{
//Way to drunk to use any sort of JSON craziness
String[] matchIds = reader.ReadToEnd()
.Replace("[", "")
.Replace("]", "")
.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < matchIds.Length; i++)
{
string outputFileName = Path.Combine(outputDirectory, matchIds[i] + ".json");
if (!File.Exists(outputFileName))
{
String apiEndpoint = string.Format(
"{0}{1}/v2.2/match/{2}",
baseUrl.Replace("/na.", "/" + region + "."),
region,
matchIds[i]);
//sw.Start();
RESTResult <MatchDetail> gameListResult = await RESTHelpers.RESTRequest <MatchDetail>(apiEndpoint, "", DevKey, "includeTimeline=true", 5);
//sw.Stop();
if (gameListResult.Success)
{
//int remainingDelay = millisecondsPerRequest - (int)sw.ElapsedMilliseconds;
//if (remainingDelay > 0)
//{
// Thread.Sleep(remainingDelay);
//}
JavaScriptSerializer jss = new JavaScriptSerializer();
File.WriteAllText(outputFileName, jss.Serialize(gameListResult.ReturnObject));
Console.WriteLine(string.Format("Region {0}, File {1}", region, outputFileName));
}
else if ((int)gameListResult.StatusCode == HttpResponse_RateLimitExceeded)
{
Console.WriteLine("Rate Exceeded, waiting {0}ms before trying again.", millisecondsPerRequest);
//decrement the iterator and try this file again momentarily
i--;
Thread.Sleep(millisecondsPerRequest);
}
else
{
Console.WriteLine("Fail, Http Resonse: {0}", (int)gameListResult.StatusCode);
}
}
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Exception thrown: " + e);
}
}
private RESTResult Execute(IServerProcess process, string statement, DataParam[] paramsValue)
{
IServerScript script = process.PrepareScript(statement);
try
{
if (script.Batches.Count != 1)
{
throw new ArgumentException("Execution statement must contain one, and only one, batch.");
}
IServerBatch batch = script.Batches[0];
DataParams dataParams = RESTMarshal.ParamsArrayToDataParams(process, paramsValue);
RESTResult result = new RESTResult();
result.Params = paramsValue;
if (batch.IsExpression())
{
IServerExpressionPlan expressionPlan = batch.PrepareExpression(dataParams);
try
{
if (expressionPlan.DataType is TableType)
{
IServerCursor cursor = expressionPlan.Open(dataParams);
try
{
result.Value = RESTMarshal.ServerCursorToValue(process, cursor);
}
finally
{
expressionPlan.Close(cursor);
}
}
else
{
using (IDataValue tempValue = expressionPlan.Evaluate(dataParams))
{
result.Value = RESTMarshal.DataValueToValue(process, tempValue);
}
}
}
finally
{
batch.UnprepareExpression(expressionPlan);
}
}
else
{
IServerStatementPlan statementPlan = batch.PrepareStatement(dataParams);
try
{
statementPlan.Execute(dataParams);
}
finally
{
batch.UnprepareStatement(statementPlan);
}
}
//NativeMarshal.SetNativeOutputParams(process, result.Params, dataParams);
return(result);
}
finally
{
process.UnprepareScript(script);
}
}
public async Task <RESTResult> AddOrUpdateUserAsync(Guid currentUserId, Guid id, bool isAdd, RegisterUserDto input)
{
RESTResult result = new RESTResult {
Code = RESTStatus.Failed
};
if (!RegUtility.IsValidationForEmail(input.AccountEmail))
{
throw new ArgumentException("Wrong Email format!");
}
if (!string.IsNullOrEmpty(input.AccountPhone) && !RegUtility.IsValidationForPhone(input.AccountPhone))
{
throw new ArgumentException("Wrong Phone format!");
}
if (isAdd)
{
//Check the user whteher exist in User
var userEntities = await _userRepository.GetAllListAsync(item => item.AccountEmail.Equals(input.AccountEmail) || item.AccountCode.Equals(input.AccountCode) || item.AccountPhone.Equals(input.AccountPhone));
if (userEntities.Count > 0)
{
throw new ArgumentException($"The user {input.AccountEmail} {input.AccountCode} {input.AccountEmail} have been exist");
}
var userEntity = new User();
userEntity.Id = Guid.NewGuid();
userEntity.AccountEmail = input.AccountEmail;
userEntity.AccountPhone = input.AccountPhone;
userEntity.AccountCode = input.AccountCode;
//It need to be optimized.
userEntity.LastLoginIP = "127.0.0.1";
userEntity.CreateTime = DateTime.Now;
userEntity.LastLoginTime = DateTime.Now;
userEntity.Password = HashUtility.CreateHash(string.IsNullOrEmpty(input.Password) ? GeneralPassword(input.AccountEmail) : input.Password);
await _userRepository.InsertAsync(userEntity);
if (input.UserInfo != null)
{
var userInfoEntity = Mapper.Map <UserInfoDto, UserInfo>(input.UserInfo);
await _userInfoRepository.InsertAsync(userInfoEntity);
}
await SetUserAndDepartmentMapAsync(currentUserId, userEntity.Id, input.DepartmentId);
await SetUserAndRoleMapAsync(currentUserId, userEntity.Id, input.RoleIds);
result.Code = RESTStatus.Success;
result.Message = "Add user successful";
}
else
{
if (id == null || Guid.Empty.Equals(id))
{
throw new ArgumentException("The user id can not be null");
}
//TODO:Update the User
var userEntity = await _userRepository.GetAsync(id);
if (userEntity == null)
{
result.Message = $"The user(id is {id}) doesn't exist";
return(result);
}
userEntity.AccountEmail = input.AccountEmail;
userEntity.AccountPhone = input.AccountPhone;
userEntity.ModifyByUserId = currentUserId;
userEntity.ModifyTime = DateTime.Now;
await _userRepository.UpdateAsync(userEntity);
//TODO:Update the user info;
var userInfoEntity = (await _userInfoRepository.GetAllListAsync(item => item.UserId.Equals(id))).FirstOrDefault();
if (userInfoEntity != null)
{
var userInfoModel = Mapper.Map <UserInfoDto, UserInfo>(input.UserInfo);
userInfoModel.Id = userInfoEntity.Id;
userInfoModel.UserId = id;
await _userInfoRepository.UpdateAsync(userInfoModel);
}
else
{
//TODO:Add new Informations
var userinfoModel = Mapper.Map <UserInfoDto, UserInfo>(input.UserInfo);
userinfoModel.UserId = userEntity.Id;
await _userInfoRepository.InsertAsync(userinfoModel);
}
//
//TODO:Update the department;
await SetUserAndDepartmentMapAsync(currentUserId, userEntity.Id, input.DepartmentId);
//TODO:Remove before user role;
await RemoveBeforeUserRole(userEntity.Id);
//TODO:update the role;
await SetUserAndRoleMapAsync(currentUserId, userEntity.Id, input.RoleIds);
result.Code = RESTStatus.Success;
result.Message = "update user successful";
}
return(result);
}
public ActionResult InsertBook(BookModel model)
{
JsonResult RetData = new JsonResult();
try
{
if (model.BookID != 0)
{
RESTResult Result = (new REST(Global.WebAPIBaseURL, "/api/Training/BookDB/V1/App/Book/UpdateBook", REST.Method.POST, REST.NeedOAuth.False, model)).Result;
if (Result.Success)
{
RetData = Json(new
{
Status = "Success",
URL = Global.BaseURL + "/Book"
});
}
else
{
RetData = Json(new
{
Status = "Failed",
Message = "Failed when updating data.."
});
}
}
else
{
RESTResult Result = (new REST(
BaseURL: Global.WebAPIBaseURL,
URL: "api/Training/BookDB/V1/App/Book/InsertBookWithModel",
Method: REST.Method.POST,
NeedOAuth: REST.NeedOAuth.False,
Data: model)).Result;
if (Result.Success)
{
RetData = Json(new {
Status = "Success",
URL = Global.BaseURL + "/Book"
});
}
else
{
RetData = Json(new {
Status = "Failed",
Message = "Failed When Inserting Data.."
});
}
}
}
catch (Exception ex)
{
RetData = Json(new {
Status = "Failed",
Message = ex.Message
});
}
return(RetData);
}
