/// <summary>
/// Updates information for an existing reader
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='reader'>
/// information for the new Reader. The ID should not be set.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> PutAsync(this IReaders operations, ReaderModel reader, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.PutWithHttpMessagesAsync(reader, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async Task ReaderController_Update_ThrowsExceptionIfModelIsIncorrect()
{
// Name is empty
var reader = new ReaderModel {
Id = 1, Name = "", Email = "*****@*****.**",
Phone = "165479823", Address = "Modena, Maranello"
};
await CheckExceptionWhileUpdateModel(reader);
// Email is empty
reader.Name = "Enzo Ferrari";
reader.Email = "";
await CheckExceptionWhileUpdateModel(reader);
// Phone is empty
reader.Email = "*****@*****.**";
reader.Phone = "";
await CheckExceptionWhileUpdateModel(reader);
// Name is empty
reader.Phone = "165479823";
reader.Address = "";
await CheckExceptionWhileUpdateModel(reader);
}
public IActionResult Post(string name, string age)
{
int parseAge = 0;
try
{
parseAge = int.Parse(age);
}
catch (Exception exception)
{
return(BadRequest(exception.Message));
}
var record = Context.Readers.SingleOrDefault(x => x.Name == name && x.Age == parseAge);
if (record != null)
{
return(StatusCode(409));
}
var readerModel = new ReaderModel()
{
Name = name,
Age = parseAge
};
Context.Readers.Add(readerModel);
Context.SaveChanges();
return(CreatedAtAction("Get", readerModel.ID));
}
private async Task CheckExceptionWhileUpdateModel(ReaderModel reader)
{
var content = new StringContent(JsonConvert.SerializeObject(reader), Encoding.UTF8, "application/json");
var httpResponse = await _client.PutAsync(requestUri, content);
Assert.That(httpResponse.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
}
public async Task ReaderService_AddAsync_AddModel()
{
//arrange
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.Setup(m => m.ReaderRepository.AddAsync(It.IsAny <Reader>()));
var readerService = new ReaderService(mockUnitOfWork.Object, UnitTestHelper.CreateMapperProfile());
var newReader = new ReaderModel()
{
Id = 10,
Name = "Test_Adding",
Email = "*****@*****.**",
Phone = "123789456",
Address = "Kyiv, 10"
};
//act
await readerService.AddAsync(newReader);
//assert
mockUnitOfWork.Verify(x => x.ReaderRepository.AddAsync(
It.Is <Reader>(r => r.Id == newReader.Id && r.Name == newReader.Name &&
r.Email == newReader.Email && r.ReaderProfile.Phone == newReader.Phone &&
r.ReaderProfile.Address == newReader.Address)), Times.Once);
mockUnitOfWork.Verify(x => x.SaveAsync(), Times.Once);
}
public async Task ReaderController_Add_ThrowsExceptionIfModelIsIncorrect()
{
// Name is empty
var reader = new ReaderModel {
Name = "", Email = "*****@*****.**",
Phone = "999999999", Address = "Glasgow"
};
await CheckExceptionWhileAddNewModel(reader);
// Email is empty
reader.Name = "Scrooge McDuck";
reader.Email = "";
await CheckExceptionWhileAddNewModel(reader);
// Phone is empty
reader.Email = "*****@*****.**";
reader.Phone = "";
await CheckExceptionWhileAddNewModel(reader);
// Address is empty
reader.Phone = "999999999";
reader.Address = "";
await CheckExceptionWhileAddNewModel(reader);
}
public void ReaderService_UpdateAsync_ThrowsExceptionIfModelIsIncorrect()
{
//arrange
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.Setup(m => m.ReaderRepository.Update(It.IsAny <Reader>()));
var readerService = new ReaderService(mockUnitOfWork.Object, UnitTestHelper.CreateMapperProfile());
// Name is empty
var reader = new ReaderModel {
Id = 1, Name = "", Email = "*****@*****.**",
Phone = "999999999", Address = "Glasgow"
};
Assert.ThrowsAsync <LibraryException>(async() => await readerService.UpdateAsync(reader));
// Email is empty
reader.Name = "Scrooge McDuck";
reader.Email = "";
Assert.ThrowsAsync <LibraryException>(async() => await readerService.UpdateAsync(reader));
// Phone is empty
reader.Email = "*****@*****.**";
reader.Phone = "";
Assert.ThrowsAsync <LibraryException>(async() => await readerService.UpdateAsync(reader));
// Address is empty
reader.Phone = "999999999";
reader.Address = "";
Assert.ThrowsAsync <LibraryException>(async() => await readerService.UpdateAsync(reader));
}
public async Task UpdateAsync(ReaderModel model)
{
ReaderValidation.CheckReader(model);
var reader = _mapper.Map <Reader>(model);
_unit.ReaderRepository.Update(reader);
await _unit.SaveAsync();
}
/// <summary>
/// Converte o model em entidade e chama o repository para alterar
/// </summary>
/// <param name="reader">Leitor que será alterado</param>
/// <returns>Leitor Alterado</returns>
public ReaderModel Update(ReaderModel reader)
{
ReaderEntity readerEntity = _mapper.Map <ReaderEntity>(reader);
readerEntity.Id = _repository.FindByKeyId(readerEntity.KeyId).Id;
readerEntity = _repository.Update(readerEntity);
return(_mapper.Map <ReaderModel>(readerEntity));
}
/// <summary>
/// Converte o model na entidade e chama o repository para inserir
/// </summary>
/// <param name="reader">Leitor que será inserido</param>
/// <returns>Leitor inserido</returns>
public ReaderModel Insert(ReaderModel reader)
{
ReaderEntity readerEntity = _mapper.Map <ReaderEntity>(reader);
readerEntity.KeyId = Guid.NewGuid( );
readerEntity = _repository.Insert(readerEntity);
return(_mapper.Map <ReaderModel>(readerEntity));
}
public void AddReader(string connectionString, ReaderModel model)
{
string sql = "INSERT INTO dbo.Czytelnicy(Tytuł,Imię,Nazwisko,Adres,Miasto,Telefon,Email,Opłata,Wartość,Profil,Active) " +
"values(@Tytuł,@Imię,@Nazwisko,@Adres,@Miasto,@Telefon,@Email,@Opłata,@Wartość,@Profil,1)";
using (IDbConnection cnn = new SqlConnection(connectionString))
{
cnn.Execute(sql, model);
}
}
public async void RegisterUser([FromBody] ReaderModel model)
{
CititorDTO cititor = new CititorDTO();
cititor.adresa = model.adress;
cititor.nume = model.firstName;
cititor.prenume = model.lastName;
cititor.email = model.email;
await readerService.RegisterReaderAsync(cititor);
}
public Reader Map(ReaderModel from) =>
new Reader()
{
Id = from.Id,
Name = from.Name,
Surname = from.Surname,
Parentname = from.Parentname,
TicketNumber = from.TicketNumber,
Passport = from.Passport,
Phone = from.Phone
};
public async Task AddAsync(ReaderModel model)
{
ReaderValidation.CheckReader(model);
var reader = _mapper.Map <Reader>(model);
await _unit.ReaderRepository.AddAsync(reader);
await _unit.SaveAsync();
model.Id = reader.Id;
}
public async Task <ActionResult> Put([FromBody] ReaderModel value)
{
try
{
await _readerService.UpdateAsync(value);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(NoContent());
}
public async void delUser(string connectionString, ReaderModel reader)
{
var p = new
{
Nr_czytelnika = reader.Nr_czytelnika,
};
using (IDbConnection cnn = new SqlConnection(connectionString))
{
cnn.Execute("[dbo].[SpDelUser]", p, commandType: CommandType.StoredProcedure);
}
}
public async Task <StatusCodeResult> UserExists([FromBody] ReaderModel model)
{
CititorDTO cititor = await readerService.GetReaderByEmailAsync(model.email);
if (cititor == null)
{
return(StatusCode(204));
}
else
{
return(StatusCode(200));
}
}
public void Map(ReaderModel from, Reader to)
{
if (to.Id != from.Id)
{
throw new ArgumentException("Cannot map. Object are not related");
}
to.Name = from.Name;
to.Surname = from.Surname;
to.Parentname = from.Parentname;
to.TicketNumber = from.TicketNumber;
to.Passport = from.Passport;
to.Phone = from.Phone;
}
public async Task <ActionResult> Post([FromBody] ReaderModel value)
{
try
{
await _readerService.AddAsync(value);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(CreatedAtAction(nameof(Get), new { id = value.Id }, value));
}
private void Button_Click(object sender, RoutedEventArgs e)
{
ReaderModel model = new ReaderModel();
try
{
model.Imię = string.IsNullOrEmpty(oplata.Text) ? null : imię.Text;
model.Nazwisko = string.IsNullOrEmpty(oplata.Text) ? null : nazwisko.Text;
if (string.IsNullOrWhiteSpace(tytuł.SelectedItem?.ToString()))
{
model.Tytuł = " ";
throw new Exception();
}
else
{
model.Tytuł = tytuł.SelectedItem.ToString();
}
model.Telefon = telefon.Text;
model.Adres = adres.Text;
model.Email = email.Text;
model.Miasto = miasto.Text;
model.Opłata = string.IsNullOrEmpty(oplata.Text) ? 0 : Convert.ToInt32(oplata.Text);
model.Profil = profil.SelectedItem?.ToString();
switch (model.Profil)
{
case "Student":
model.Wartość = 15f;
break;
case "Dziecko":
model.Wartość = 10f;
break;
case "Dorosły":
model.Wartość = 20f;
break;
default:
model.Wartość = 0;
break;
}
data.AddReader(_module.SqlProfile.connectionString.ToString(), model);
buttOn.Background = Brushes.LightGray;
}
catch (Exception ex)
{
buttOn.Background = Brushes.DarkRed;
}
RefereschData();
SetNull();
}
public void NewRental(string connectionString, AvailableBooks book, ReaderModel reader, DateTime time)
{
var p = new
{
isbn = book.ISBN,
Nr_Czytelnika = reader.Nr_czytelnika,
spodziewanaDataZwrotu = time
};
using (IDbConnection cnn = new SqlConnection(connectionString))
{
cnn.Execute("[dbo].[SpNewRental]", p, commandType: CommandType.StoredProcedure);
}
}
private void dodaj_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(dataOddania.ToString()))
{
dataOddania.BorderBrush = Brushes.Red;
return;
}
if (users.SelectedItem == null)
{
users.BorderBrush = Brushes.Red;
return;
}
if (books.SelectedItem == null)
{
books.BorderBrush = Brushes.Red;
return;
}
try
{
ReaderModel reader = (ReaderModel)users.SelectedItem;
AvailableBooks book = (AvailableBooks)books.SelectedItem;
DateTime time = (DateTime)dataOddania.SelectedDate;
_data.NewRental(_module.SqlProfile.connectionString.ToString(), book, reader, time);
books.BorderBrush = Brushes.Transparent;
users.BorderBrush = Brushes.Transparent;
dataOddania.BorderBrush = Brushes.Transparent;
fUser.Text = null;
fBook.Text = null;
users.SelectedItem = null;
books.SelectedItem = null;
dataOddania.SelectedDate = null;
BooksList();
UsersList();
}
catch (System.Data.SqlClient.SqlException)
{
dataOddania.BorderBrush = Brushes.Red;
}
catch
{
books.BorderBrush = Brushes.Red;
users.BorderBrush = Brushes.Red;
dataOddania.BorderBrush = Brushes.Red;
}
}
public void GetReaderByID(int readerID)
{
HttpResponseMessage response = client.GetAsync($"api/readers/{readerID}").Result;
if (response.IsSuccessStatusCode)
{
ReaderModel reader = response.Content.ReadAsAsync <ReaderModel>().Result;
ShowReader(reader);
}
else
{
// error
DisplayApiError(response);
}
}
private void DelUser(object sender, RoutedEventArgs e)
{
Button button = sender as Button;
ReaderModel model = button.DataContext as ReaderModel;
try
{
data.delUser(_module.SqlProfile.connectionString.ToString(), model);
}
catch
{
gridd.BorderBrush = Brushes.Red;
}
RefereschData();
}
public virtual ActionResult Index()
{
var model = new ReaderModel();
var membership = new WebLogic.CmsMembership(_userBusiness);
var MUser = membership.GetCurrentUser();
model.UserTitle = membership.GetCurrentUserTitle();
ViewBag.Title = "صفحه شخصی " + model.UserTitle;
model.Tags = _tagBusiness.GetList()
.Where(x => x.Users.Any(c => c.Id == MUser.Id)).Select(t => new TagViewModel()
{
Id = t.Id,
Title = t.Title,
EnValue = t.EnValue
}).ToList();
model.Categories = _categoryBusiness.GetList().Where(x => x.Users.Any(c => c.Id == MUser.Id)).
Select(c => new CategoryViewModel
{
Id = c.Id,
Title = c.Title,
Code = c.Code,
ParentId = c.ParentId
})
.ToList();
model.Categories.ForEach(x => x.ParentId = x.ParentId > 0 && model.Categories.Any(y => y.Id == x.ParentId) ? x.ParentId : 0);
model.Sites = _siteBusiness.GetList().Where(x => x.Users.Any(c => c.Id == MUser.Id))
.Select(x => new SiteOnlyTitle {
Id = x.Id, SiteUrl = x.SiteUrl, SiteTitle = x.SiteTitle
}).ToList();
model.RecomendTags = _recomendBiz.Tags(10, model.Tags.Select(t => t.Id).ToList()).Select(t => new TagViewModel()
{
Id = t.Id,
Title = t.Title,
EnValue = t.EnValue
}).ToList();
model.RecomendCats = _recomendBiz.Cats(5).Select(c => new CategoryViewModel()
{
Id = c.Id,
Title = c.Title,
Code = c.Code
}).ToList();
model.RecomendSites = _recomendBiz.Sites(10, model.Sites.Select(s => s.Id).ToList());
return(View("Index." + CmsConfig.ThemeName, model));
}
/// <summary>
/// 添加数据模型
/// </summary>
public void AddModel(ReaderModel readHoleModel)
{
if ("HEX".Equals(readHoleModel.ValueType))
{
if (hexDataDict.ContainsKey(readHoleModel.Count))
{
hexDataDict[readHoleModel.Count].Add(readHoleModel);
}
}
else if ("FAM".Equals(readHoleModel.ValueType))
{
if (famDataDict.ContainsKey(readHoleModel.Count))
{
famDataDict[readHoleModel.Count].Add(readHoleModel);
}
}
}
public void InsertReader( )
{
ReaderModel readerModel = new ReaderModel( );
ReaderEntity readerEntity = new ReaderEntity( );
Mock <IRepository <ReaderEntity> > mockRepository = new Mock <IRepository <ReaderEntity> >( );
mockRepository
.Setup((a) => a.Insert(It.IsAny <ReaderEntity>( )))
.Returns(readerEntity);
ReaderBusiness readerBusiness = new ReaderBusiness(mockRepository.Object, AutoMapperConfigTest.GetInstance( ));
var result = readerBusiness.Insert(readerModel);
result.Should( ).BeOfType <ReaderModel>( );
}
/// <summary>
/// Akcja Update, aktualizująca obiekt. Dostępna pod API: <strong>/api/readers/1</strong>.
/// </summary>
/// <param name="input">Obiekt czytelnika.</param>
/// <returns>
/// Kod 400 jeśli walidacja danych nie powiodła się, kod 404 jeśli nie można odnaleźć zasobu o podanym identyfikatorze.
/// Kod 200 jeśli aktualizacja przebiegła pomyślnie.
/// </returns>
public IHttpActionResult Put(int id, ReaderModel input)
{
if (string.IsNullOrWhiteSpace(input.Name) || input.Age < 10)
{
return(StatusCode(HttpStatusCode.BadRequest));
}
var record = Context.Readers.SingleOrDefault(x => x.ID == id);
if (record == null)
{
return(NotFound());
}
record.Name = input.Name;
record.Age = input.Age;
Context.SaveChanges();
return(Ok());
}
public ActionResult PrevPage(long?id)
{
var model = new ReaderModel();
if (id != null)
{
var ticket = FormsAuthentication.Decrypt(Request.Cookies[FormsAuthentication.FormsCookieName].Value);
var user = JsonSerializer.DeserializeFromString <User>(ticket.UserData);
model.Page = ReaderService.Instance.GetPrevPage(user.Id, (long)id);
}
if (Request.Headers["X-PJAX"] == "true")
{
Response.Headers["X-PJAX-URL"] = "/Reader/Book/" + id;
return(PartialView("Book", model));
}
return(View("Book", model));
}
public void Update(ReaderModel entity)
{
if (entity.Id == null)
{
throw new ArgumentNullException(nameof(entity.Id));
}
var reader = _readerRepository.GetById(entity.Id);
if (reader is null)
{
throw new Exception("Reader not found");
}
reader.Name = entity.Name;
_readerRepository.Update(reader);
}
