private async Task <(LibraryBookApiModel libraryBook, LibraryUserApiModel libraryuser)> GetBookAndUser(string libraryBookCode, string libraryUserCode)
{
LibraryBookApiModel libraryBook = null;
LibraryUserApiModel libraryuser = null;
var(libraryBookResponse, libraryUserResponse) = await TaskEx.WhenAllTwo(_libraryBookClient.GetLibraryBookByLibraryBookCode(libraryBookCode), _libraryUserClient.GetLibraryUserByLibraryUserCode(libraryUserCode));
if (libraryBookResponse.StatusIsSuccessful)
{
libraryBook = libraryBookResponse.Data;
}
else
{
AddResponseErrorsToModelState(libraryBookResponse);
}
if (libraryUserResponse.StatusIsSuccessful)
{
libraryuser = libraryUserResponse.Data;
}
else
{
AddResponseErrorsToModelState(libraryUserResponse);
}
return(libraryBook : libraryBook, libraryuser : libraryuser);
}
public IActionResult Insert([FromBody] LibraryBookStatusApiModel model)
{
int result = 0;
var libraryBookStatusCode = "";
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model != null)
{
int?retVal = _libraryBookStatusWebApiManager.GetCountOfBookCurrentLent(model?.LibraryUser.LibraryUserCode);
if (retVal != null && retVal.Value > 4)
{
ModelState.AddModelError(string.Empty, "Maximum number of books exceeded");
return(BadRequest(ModelState));
}
LibraryBookApiModel libraryBookApiModel = _libraryBookWebApiManager.GetLibraryBookByLibraryBookCode(model.LibraryBook?.LibraryBookCode);
if (libraryBookApiModel == null)
{
ModelState.AddModelError(string.Empty, "Library book not found");
return(BadRequest(ModelState));
}
if (_libraryBookStatusWebApiManager.HasMoreThanOneBookWithSameISBN(libraryBookApiModel.ISBN, model?.LibraryUser.LibraryUserCode))
{
ModelState.AddModelError(string.Empty, "Library User already has that book");
return(BadRequest(ModelState));
}
model.CreatedBy = GetCurrentUser();
model.DateCreated = DateTime.Now;
model.ModifiedBy = GetCurrentUser();
model.DateModified = DateTime.Now;
result = _libraryBookStatusWebApiManager.InsertLibraryBookStatus(model, out libraryBookStatusCode);
}
switch (result)
{
case 1:
return(new ContentResult
{
Content = libraryBookStatusCode,
ContentType = "text/plain",
StatusCode = 200
});
default:
ModelState.AddModelError(string.Empty, "Failed to insert record");
break;
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "insertlibrarybook")] HttpRequest req, ILogger log)
{
try
{
var result = _tokenProvider.ValidateToken(req);
if (result.Status == AccessTokenStatus.Valid)
{
log.LogInformation($"Request received for {result.Principal.Identity.Name}.");
}
else
{
return(new UnauthorizedResult());
}
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
LibraryBookApiModel model = JsonConvert.DeserializeObject <LibraryBookApiModel>(requestBody);
if (model == null)
{
return(new BadRequestObjectResult("Please pass LibraryBookApiModel in the request body"));
}
int retVal = 0;
string libraryBookCode = string.Empty;
if (model != null)
{
model.CreatedBy = _tokenProvider.User;
model.DateCreated = DateTime.Now;
model.ModifiedBy = _tokenProvider.User;
model.DateModified = DateTime.Now;
retVal = _libraryBookWebApiManager.InsertLibraryBook(model, out libraryBookCode);
}
if (retVal < 1)
{
return(new BadRequestObjectResult("Failed to insert record"));
}
return((ActionResult) new OkObjectResult(new ContentResult
{
Content = libraryBookCode,
ContentType = "text/plain",
StatusCode = 200
}));
}
catch (Exception ex)
{
log.LogError($"Caught exception: {ex.Message}");
return(new BadRequestObjectResult(ex.Message));
}
}
/// <summary>
/// Updare LibraryBook
/// </summary>
/// <param name="LibraryBook"></param>
/// <returns>The<see cref="int"/> </returns>
public int UpdateLibraryBook(LibraryBookApiModel LibraryBook, TransactionParam transactionParam = null)
{
var parameters = new DynamicParameters();
parameters.Add(name: "LibraryBookCode", value: LibraryBook.LibraryBookCode);
parameters.Add(name: "isbn", value: LibraryBook.ISBN);
parameters.Add(name: "title", value: LibraryBook.Title);
parameters.Add(name: "author", value: LibraryBook.Author);
parameters.Add(name: "isStolen", value: LibraryBook.IsStolen);
parameters.Add(name: "isLost", value: LibraryBook.IsLost);
parameters.Add(name: "copyNumber", value: LibraryBook.CopyNumber);
parameters.Add(name: "modifiedBy", value: LibraryBook.ModifiedBy);
parameters.Add(name: "modifiedDate", value: DateTime.Now.ToString("yyyy-MM-dd H:mm:ss"));
const string sql = @"UPDATE LibraryBook
SET
Title = @title
,ISBN = @isbn
,Title = @title
,Author = @author
,IsStolen = @isStolen
,IsLost = @isLost
,CopyNumber = @copyNumber
,ModifiedBy = @modifiedBy
,DateModified = @modifiedDate
WHERE LibraryBookCode = @LibraryBookCode" ;
LibraryBook.DateModified = DateTime.Now;
int rowaffected = 0;
if (transactionParam != null)
{
rowaffected = transactionParam.Connection.Execute(
sql,
param: parameters,
commandType: CommandType.Text,
transaction: transactionParam.Transaction);
}
else
{
using (var connection = this.OpenConnection())
{
rowaffected = connection.Execute(
sql,
param: parameters,
commandType: CommandType.Text);
}
}
return(rowaffected);
}
/// <summary>
/// Get a LibraryBook by it's id
/// </summary>
/// <param name="LibraryBookCode"></param>
/// <returns>The <see cref="LibraryBookApiModel"/> </returns>
public LibraryBookApiModel GetLibraryBookByLibraryBookCode(string LibraryBookCode)
{
LibraryBookApiModel LibraryBookApiModel = null;
using (var connection = this.OpenConnection())
{
LibraryBookApiModel = connection.Query <LibraryBookApiModel>(@"SELECT C.LibraryBookCode, C.ISBN, C.Title, C.Author, C.IsStolen, C.IsLost, C.CopyNumber,
C.DateCreated, C.CreatedBy, C.DateModified, C.ModifiedBy
FROM LibraryBook C
WHERE C.LibraryBookCode = @LibraryBookCode" , new { LibraryBookCode }).SingleOrDefault();
}
return(LibraryBookApiModel);
}
public LibraryBookStatusApiModel GetApiModel(LibraryBookApiModel libraryBook, LibraryUserApiModel libraryuser)
{
return(new LibraryBookStatusApiModel()
{
LibraryBookStatusCode = this.LibraryBookStatusCode,
DateCheckedOut = Extension.ConvertToDateTime(this.DateCheckedOut),
DateReturned = Extension.ConvertToDateTime(this.DateReturned),
CreatedBy = this.CreatedBy,
DateCreated = this.DateCreated,
ModifiedBy = this.ModifiedBy,
DateModified = this.DateModified,
LibraryBook = libraryBook,
LibraryUser = libraryuser
});
}
public IActionResult Post([FromBody] LibraryBookApiModel model)
{
ClaimsIdentity claimsIdentity = User.Identity as ClaimsIdentity;
var claims = claimsIdentity.Claims.Select(x => new { type = x.Type, value = x.Value });
//var rolesClaim = this.HttpContext.User.Claims;
if (model != null)
{
return(Ok("Model OK"));
}
else
{
return(Ok("Model Null"));
}
}
/// <summary>
/// Insert LibraryBook
/// </summary>
/// <param name="LibraryBook"></param>
/// <param name="LibraryBookCode"></param>
/// <returns>The<see cref="int"/> </returns>
public virtual int InsertLibraryBook(LibraryBookApiModel LibraryBook, out string LibraryBookCode, TransactionParam transactionParam = null)
{
LibraryBookCode = _randomKeyGenerator.GetUniqueKey(9);
LibraryBook.LibraryBookCode = LibraryBookCode;
var parameters = new DynamicParameters();
parameters.Add(name: "LibraryBookCode", value: LibraryBookCode);
parameters.Add(name: "isbn", value: LibraryBook.ISBN);
parameters.Add(name: "title", value: LibraryBook.Title);
parameters.Add(name: "author", value: LibraryBook.Author);
parameters.Add(name: "isStolen", value: LibraryBook.IsStolen);
parameters.Add(name: "isLost", value: LibraryBook.IsLost);
parameters.Add(name: "copyNumber", value: LibraryBook.CopyNumber);
parameters.Add(name: "createdBy", value: LibraryBook.CreatedBy);
//parameters.Add(name: "dateCreated", value: LibraryBook.DateCreated.ToString("yyyy-MM-dd H:mm:ss"));
parameters.Add(name: "modifiedBy", value: LibraryBook.ModifiedBy);
//parameters.Add(name: "dateModified", value: LibraryBook.DateModified.ToString("yyyy-MM-dd H:mm:ss"));
int rowaffected = 0;
string sql = @"INSERT INTO LibraryBook (
LibraryBookCode, ISBN, Title, Author, IsStolen, IsLost, CopyNumber, CreatedBy, ModifiedBy)
VALUES (@libraryBookCode, @isbn, @title, @author, @isStolen, @isLost, @copyNumber,
@createdBy, @modifiedBy)" ;
if (transactionParam != null)
{
rowaffected = transactionParam.Connection.Execute(
sql,
param: parameters,
commandType: CommandType.Text,
transaction: transactionParam.Transaction);
}
else
{
using (var connection = this.OpenConnection())
{
rowaffected = connection.Execute(
sql,
param: parameters,
commandType: CommandType.Text);
}
}
return(rowaffected);
}
public static LibraryBookViewModel CreateLibraryBookViewModel(LibraryBookApiModel apiModel)
{
return(new LibraryBookViewModel()
{
LibraryBookCode = apiModel.LibraryBookCode,
ISBN = apiModel.ISBN,
Title = apiModel.Title,
Author = apiModel.Author,
IsStolen = apiModel.IsStolen,
IsLost = apiModel.IsLost,
CopyNumber = apiModel.CopyNumber,
CreatedBy = apiModel.CreatedBy,
DateCreated = apiModel.DateCreated,
ModifiedBy = apiModel.ModifiedBy,
DateModified = apiModel.DateModified
});
}
public IActionResult Update([FromBody] LibraryBookApiModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
model.ModifiedBy = GetCurrentUser();
var result = _libraryBookWebApiManager.UpdateLibraryBook(model);
switch (result)
{
case 1:
return(Ok());
default:
ModelState.AddModelError(string.Empty, "Unable to Update user");
break;
}
return(BadRequest(ModelState));
}
public IActionResult Insert([FromBody] LibraryBookApiModel model)
{
int result = 0;
var libraryBookCode = "";
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model != null)
{
model.CreatedBy = GetCurrentUser();
model.DateCreated = DateTime.Now;
model.ModifiedBy = GetCurrentUser();
model.DateModified = DateTime.Now;
result = _libraryBookWebApiManager.InsertLibraryBook(model, out libraryBookCode);
}
switch (result)
{
case 1:
return(new ContentResult
{
Content = libraryBookCode,
ContentType = "text/plain",
StatusCode = 200
});
default:
ModelState.AddModelError(string.Empty, "Failed to insert record");
break;
}
return(BadRequest(ModelState));
}
public async Task <BoolResponse> Update(LibraryBookApiModel apiModel)
{
var createBranchResponse = await PutEncodedContentWithSimpleBoolResponse <BoolResponse, LibraryBookApiModel>(_apiUrl /*+ APIConstants.Update*/, apiModel);
return(createBranchResponse);
}
public async Task <IntResponse> Insert(LibraryBookApiModel apiModel)
{
var createBranchResponse = await PostEncodedContentWithSimpleResponse <IntResponse, LibraryBookApiModel>(_apiUrl /*+ APIConstants.Insert*/, apiModel);
return(createBranchResponse);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "insertlibrarybookstatus")] HttpRequest req, ILogger log)
{
try
{
var result = _tokenProvider.ValidateToken(req);
if (result.Status == AccessTokenStatus.Valid)
{
log.LogInformation($"Request received for {result.Principal.Identity.Name}.");
}
else
{
return(new UnauthorizedResult());
}
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
LibraryBookStatusApiModel model = JsonConvert.DeserializeObject <LibraryBookStatusApiModel>(requestBody);
if (model == null)
{
return(new BadRequestObjectResult("Please pass LibraryBookApiModel in the request body"));
}
int retVal = 0;
string libraryBookCode = string.Empty;
if (model != null)
{
int?returnVal = _libraryBookStatusWebApiManager.GetCountOfBookCurrentLent(model?.LibraryUser.LibraryUserCode);
if (returnVal != null && returnVal.Value > 4)
{
return(new BadRequestObjectResult("Maximum number of books exceeded"));
}
LibraryBookApiModel libraryBookApiModel = _libraryBookWebApiManager.GetLibraryBookByLibraryBookCode(model.LibraryBook?.LibraryBookCode);
if (libraryBookApiModel == null)
{
return(new BadRequestObjectResult("Library book not found"));
}
if (_libraryBookStatusWebApiManager.HasMoreThanOneBookWithSameISBN(libraryBookApiModel.ISBN, model?.LibraryUser.LibraryUserCode))
{
return(new BadRequestObjectResult("Library User already has that book"));
}
model.CreatedBy = _tokenProvider.User;
model.DateCreated = DateTime.Now;
model.ModifiedBy = _tokenProvider.User;
model.DateModified = DateTime.Now;
retVal = _libraryBookStatusWebApiManager.InsertLibraryBookStatus(model, out libraryBookCode);
}
if (retVal < 1)
{
return(new BadRequestObjectResult("Failed to insert record"));
}
return((ActionResult) new OkObjectResult(new ContentResult
{
Content = libraryBookCode,
ContentType = "text/plain",
StatusCode = 200
}));
}
catch (Exception ex)
{
log.LogError($"Caught exception: {ex.Message}");
return(new BadRequestObjectResult(ex.Message));
}
}
/// <summary>
/// Updare LibraryBook
/// </summary>
/// <param name="libraryBook"></param>
/// <returns>The<see cref="int"/> </returns>
public int UpdateLibraryBook(LibraryBookApiModel libraryBook, TransactionParam transactionParam = null)
{
return(this._libraryBookRepository.UpdateLibraryBook(libraryBook, transactionParam));
}
/// <summary>
/// Insert LibraryBook
/// </summary>
/// <param name="libraryBook"></param>
/// <param name="libraryBookCode"></param>
/// <returns>The<see cref="int"/> </returns>
public int InsertLibraryBook(LibraryBookApiModel libraryBook, out string libraryBookCode, TransactionParam transactionParam = null)
{
return(this._libraryBookRepository.InsertLibraryBook(libraryBook, out libraryBookCode, transactionParam));
}