public void Dto_Test()
{
var dto = DtoFactory.Dto <IMyObj>();
dto.A = 1;
dto.A.Should().Be(1);
}
[ProducesResponseType(typeof(DtoError), 500)] //Define the extra HttpStatusCode for Swagger
public IQueryable <DtoCustomer> GetAll()
{
var rtn = new List <DtoCustomer>();
try
{
//throw new Exception("Test");
using (var custService = new CustomerService(DbContextFactory.Create()))
{
var custDaos = custService.GetAll().ToList();
foreach (var custDao in custDaos)
{
rtn.Add(DtoFactory.Create <Angular2.Mvc.DAL.Models.DAO.Customer, Angular2.Mvc.Core.Models.DTO.DtoCustomer>(custDao));
}
}
return(rtn.AsQueryable());
}
catch (Exception ex)
{
var err = new DtoError
{
StatusCode = 500,
ServerError = ex.Message,
ClientMsg = "Please try again..."
};
var errJson = JsonConvert.SerializeObject(err);
byte[] data = System.Text.Encoding.UTF8.GetBytes(errJson);
Response.ContentType = "application/json";
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
Response.Body.WriteAsync(data, 0, data.Length);
throw;
}
}
private List <SellDto> DoGetDrinkSells(BeerControlEntities context, int idMarket, int idDrink, DateTimeOffset startTs, DateTimeOffset endTs)
{
var list = new List <SellDto>();
var dbSells = context.Sell.Where(s => s.idMarket == idMarket && s.idDrink == idDrink && s.Ts >= startTs && s.Ts <= endTs).OrderBy(s => s.Ts).ToArray();
var priceIds = dbSells.Select(s => s.idPrice).Distinct();
var dbPrices = context.Price.Where(p => priceIds.Contains(p.id)).Select(p => new { p.id, p.Val });
var priceDic = new Dictionary <int, int>();
foreach (var dbPrice in dbPrices)
{
priceDic.Add(dbPrice.id, dbPrice.Val);
}
foreach (var dbSell in dbSells)
{
int price;
if (dbSell.idPrice == 0 || !priceDic.ContainsKey(dbSell.idPrice))
{
price = 0;
}
else
{
price = priceDic[dbSell.idPrice];
}
list.Add(DtoFactory.Create(dbSell, price));
}
return(list);
}
public object GetSrcAdapter(object src)
{
if (SrcType == src.GetType())
{
return(src);
}
return(DtoFactory.DtoAdapter(src, SrcType));
}
public void CreateDtoGeneric_CreatesINotifyPropertyChanged()
{
IDtoFactory factory = new DtoFactory();
IDataTransferObject dto = factory.CreateDto <TestPersonDto> ();
Assert.IsInstanceOfType(dto, typeof(INotifyPropertyChanged));
}
public void CreateDto_CreatesINotifyPropertyChanged()
{
IDtoFactory factory = new DtoFactory ();
IDataTransferObject dto = factory.CreateDto ( typeof ( TestPersonDto ) ) as IDataTransferObject;
Assert.IsInstanceOfType ( dto, typeof ( INotifyPropertyChanged ) );
}
public object GetDtoDst()
{
if (DstType.IsInterface)
{
return(DtoFactory.Dto(DstType));
}
return(Activator.CreateInstance(DstType));
}
public void Dto_ForChildInterface()
{
var dto = DtoFactory.Dto <IMyChildObj>();
dto.A = 1;
dto.B = 2;
dto.A.Should().Be(1);
dto.B.Should().Be(2);
}
public object GetDstAdapter <TDst>(TDst dst)
{
if (DstType.IsInterface)
{
return(DtoFactory.DtoAdapter(dst, DstType));
}
else
{
return(dst);
}
}
private DrinkDto LoadDrink(BeerControlEntities context, int?idDrink)
{
if (!idDrink.HasValue)
{
return(null);
}
var dbDrink = context.Drink.Find(idDrink);
return(DtoFactory.Create(dbDrink));
}
public UserDTO AddUser(NewUserDTO newUserDTO)
{
var user = DtoFactory.NewUserDtoToUserModel(newUserDTO);
db.Users.AddEntity(user);
db.Save();
var id = user.Id;
var newUserModel = db.Users.GetUserById(id);
return(DtoFactory.UserModelToUserDTO(newUserModel));
}
public IEnumerable <UserDTO> Search(string key)
{
var users = db.Users.Search(key);
var dtos = new List <UserDTO>();
foreach (var user in users)
{
dtos.Add(DtoFactory.UserModelToUserDTO(user));
}
return(dtos);
}
public void ToDtoTest()
{
var contact = new Contact()
{
Firstname = "Jesper", Lastname = "Aaberg", Email = "*****@*****.**"
};
var contactDto = contact.ToDto();
Assert.AreEqual(contact.Firstname, contactDto.Firstname);
Assert.AreEqual(contact.Lastname, contactDto.Lastname);
Assert.AreEqual(contact.Email, contactDto.Email);
Assert.IsNull(DtoFactory.ToDto(null));
}
// POST api/status
public void Post([FromBody] StatusDTO value)
{
string logText = "i: " + value.i + ", a: " + value.a + ", o: " + value.o + ", l: " + value.l + ", s: " +
value.s + ", b: " + value.b + ", g: " + value.g + ", t: " +
value.t?.ToString("yyyy-MM-dd'T'HH:mm:ss") + ", k: " + value.k;
if (SecurityHelper.CheckAccessKey(value))
{
var dtoFactory = new DtoFactory();
dtoFactory.InsertOrUpdateDatabase(value);
}
else
{
Logger.Warn("Pozice odmÃtnuta: " + logText);
}
}
public DtoCustomer Get(int id)
{
Angular2.Mvc.Core.Models.DTO.DtoCustomer rtn = null;
using (var custService = new CustomerService(DbContextFactory.Create()))
{
var cust = custService.Get(x => x.Id.Equals(id)).FirstOrDefault();
if (cust != null)
{
return(DtoFactory.Create <Angular2.Mvc.DAL.Models.DAO.Customer, Angular2.Mvc.Core.Models.DTO.DtoCustomer>(cust));
}
else
{
throw new Exception($"The customers with Id:{id.ToString()} is not exist!");
}
}
}
public IEnumerable <UserDTO> GetStudentsNotInCurrentGroup(int groupId)
{
var studentsNotInCurrentGroup = db.Users.GetStudentsNotInGroup(groupId);
if (studentsNotInCurrentGroup == null)
{
return(null);
}
var studentsDtos = new List <UserDTO>();
foreach (var student in studentsNotInCurrentGroup)
{
studentsDtos.Add(DtoFactory.UserModelToUserDTO(student));
}
return(studentsDtos);
}
public IEnumerable <UserDTO> GetMentors()
{
var mentorModels = db.Users.GetMentors();
if (mentorModels == null)
{
return(null);
}
var mentorsDtos = new List <UserDTO>();
foreach (var item in mentorModels)
{
mentorsDtos.Add(DtoFactory.UserModelToUserDTO(item));
}
return(mentorsDtos);
}
public IEnumerable <UserDTO> GetAllStudents()
{
var studentModels = db.Users.GetStudents();
if (studentModels == null)
{
return(null);
}
var studentsDtos = new List <UserDTO>();
foreach (var item in studentModels)
{
studentsDtos.Add(DtoFactory.UserModelToUserDTO(item));
}
return(studentsDtos);
}
public IEnumerable <UserDTO> GetMentorsNotInGroup(int[] usedMentors)
{
var unUSedMentors = db.Users.GetMentorsNotInGroup(usedMentors);
if (unUSedMentors == null)
{
return(null);
}
var mentorDtos = new List <UserDTO>();
foreach (var item in unUSedMentors)
{
mentorDtos.Add(DtoFactory.UserModelToUserDTO(item));
}
return(mentorDtos);
}
public IEnumerable <UserDTO> GetAllUsers()
{
var users = db.Users.GetAllUsers();
if (users == null)
{
return(null);
}
var dtos = new List <UserDTO>();
foreach (var user in users)
{
dtos.Add(DtoFactory.UserModelToUserDTO(user));
}
return(dtos);
}
public IEnumerable <UserDTO> GetUsersFromGroup(int groupId)
{
var userModelsInGroup = db.Users.GetStudentsByGroupId(groupId);
if (userModelsInGroup == null)
{
return(null);
}
var usersInGroup = new List <UserDTO>();
foreach (var item in userModelsInGroup)
{
usersInGroup.Add(DtoFactory.UserModelToUserDTO(item));
}
return(usersInGroup);
}
public void TestCustomerMapping()
{
var cust = new Angular2.Mvc.DAL.Models.DAO.Customer()
{
Id = 10,
Age = 35,
Description = "Hello!!",
Name = "JB",
Phone = "0933XXXXXXX"
};
var actual = DtoFactory.Create <Angular2.Mvc.DAL.Models.DAO.Customer, Angular2.Mvc.Core.Models.DTO.DtoCustomer>(cust);
Assert.True(cust.Id.Equals(actual.Id), $"Expected:{cust.Id}, Actual:{actual.Id}");
Assert.True(cust.Name.Equals(actual.Name), $"Expected:{cust.Name}, Actual:{actual.Name}");
Assert.True(cust.Phone.Equals(actual.Phone), $"Expected:{cust.Phone}, Actual:{actual.Phone}");
Assert.True(cust.Age.Equals(actual.Age), $"Expected:{cust.Age}, Actual:{actual.Age}");
Assert.True(cust.Description.Equals(actual.Description), $"Expected:{cust.Description}, Actual:{actual.Description}");
}
public IEnumerable <GroupDTO> GetAllGroups()
{
var groups = db.Groups.GetAllGroups();
if (groups == null)
{
return(null);
}
var dtos = new List <GroupDTO>();
foreach (var group in groups)
{
dtos.Add(DtoFactory.GroupModelToGroupDTO(group));
}
return(dtos);
}
public IEnumerable <GroupDTO> GetGroupsByUserId(int userId)
{
var groupModels = db.Groups.GetGroupsByUserId(userId);
if (groupModels == null)
{
return(null);
}
var groupDtos = new List <GroupDTO>();
foreach (var model in groupModels)
{
groupDtos.Add(DtoFactory.GroupModelToGroupDTO(model));
}
return(groupDtos);
}
public void SampleDtoFromDataRow()
{
var gameId = Guid.NewGuid();
var gameYear = 2010;
var gameMonth = 7;
var gameDay = 3;
var sampleTable = GenerateSampleDataTable();
sampleTable.Rows.Add(gameId, gameYear, gameMonth, gameDay);
var sut = new DtoFactory();
var result = sut.Create<GetGameCountByDateDto>(sampleTable.Rows[0]);
Assert.IsNotNull(result);
Assert.AreEqual(gameId, result.GameId);
Assert.AreEqual(gameYear, result.GameYear);
Assert.AreEqual(gameMonth, result.GameMonth);
Assert.AreEqual(gameDay, result.GameDay);
}
public void SampleDtoFromDataRow()
{
var gameId = Guid.NewGuid();
var gameYear = 2010;
var gameMonth = 7;
var gameDay = 3;
var sampleTable = GenerateSampleDataTable();
sampleTable.Rows.Add(gameId, gameYear, gameMonth, gameDay);
var sut = new DtoFactory();
var result = sut.Create <GetGameCountByDateDto>(sampleTable.Rows[0]);
Assert.IsNotNull(result);
Assert.AreEqual(gameId, result.GameId);
Assert.AreEqual(gameYear, result.GameYear);
Assert.AreEqual(gameMonth, result.GameMonth);
Assert.AreEqual(gameDay, result.GameDay);
}
public HttpResponseMessage Get()
{
try
{
var clusters = DataService.Clusters.ToList();
return(Request.CreateResponse(HttpStatusCode.OK, new
{
Result = clusters.Select(c => DtoFactory.Create(c)),
Succeeded = true
}));
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, new
{
Succeeded = true,
Error = "There was an error when retrieving clusters."
}));
}
}
public List <MarketConfigDto> GetMarketsConfig(UserPass user)
{
if (!_security.Check(user))
{
throw new AuthenticationException();
}
var idUser = _security.GetUserId(user);
var list = new List <MarketConfigDto>();
using (var context = new BeerControlEntities())
{
var dbMarket = context.Market.Where(m => m.idUser == idUser);
foreach (Market mr in dbMarket)
{
list.Add(DtoFactory.CreateEx(mr));
}
}
return(list);
}
public List <DrinkDto> GetDrinks(UserPass user)
{
if (!_security.Check(user))
{
throw new AuthenticationException();
}
var idUser = _security.GetUserId(user);
var list = new List <DrinkDto>();
using (var context = new BeerControlEntities())
{
var dbDrinks = context.Drink.Where(d => d.idUser == idUser);
foreach (var dbDrink in dbDrinks)
{
list.Add(DtoFactory.Create(dbDrink));
}
}
return(list);
}
public Dictionary <MarketDto, SellSummaryDto> GetSellSummary(UserPass user, DateTimeOffset startTs, DateTimeOffset endTs)
{
if (!_security.Check(user))
{
throw new AuthenticationException();
}
var idUser = _security.GetUserId(user);
var items = new Dictionary <MarketDto, SellSummaryDto>();
using (var context = new BeerControlEntities())
{
var dbMarkets = context.Market.Where(m => m.idUser == idUser).ToArray();
foreach (var dbMarket in dbMarkets)
{
items.Add(DtoFactory.Create(dbMarket), DoGetMarketSellSummary(context, dbMarket.id, startTs, endTs));
}
}
return(items);
}
public Dictionary <DrinkDto, List <SellDto> > GetMarketSells(UserPass user, int idMarket, DateTimeOffset startTs, DateTimeOffset endTs)
{
if (!_security.Check(user))
{
throw new AuthenticationException();
}
var items = new Dictionary <DrinkDto, List <SellDto> >();
using (var context = new BeerControlEntities())
{
var drinkIds = context.MarketDrink.Where(m => m.idMarket == idMarket).Select(d => d.idDrink).ToArray();
var dbDrinks = context.Drink.Where(d => drinkIds.Contains(d.id));
foreach (var dbDrink in dbDrinks)
{
items.Add(DtoFactory.Create(dbDrink), DoGetDrinkSells(context, idMarket, dbDrink.id, startTs, endTs));
}
}
return(items);
}
public List <ProducerDto> GetProducers(UserPass user)
{
if (!_security.Check(user))
{
throw new AuthenticationException();
}
var idUser = _security.GetUserId(user);
var list = new List <ProducerDto>();
using (var context = new BeerControlEntities())
{
var dbProducers = context.Producer.Where(p => p.idUser == idUser);
foreach (var pr in dbProducers)
{
list.Add(DtoFactory.Create(pr));
}
}
return(list);
}
public void DataTransferObject_PublicPropertySetterCallsOnPropertyChanged_Succeeds()
{
List<string> ignoredDtoProperties = new List<string> () { "Notifications" };
IDtoFactory dtoFactory = new DtoFactory ();
foreach ( AssemblyPart assemblyPart in Deployment.Current.Parts )
{
StreamResourceInfo sri =
Application.GetResourceStream (
new Uri ( assemblyPart.Source, UriKind.Relative ) );
Assembly dtoAssembly = new AssemblyPart ().Load ( sri.Stream );
var allDtos = dtoAssembly.GetTypes ()
.Where ( t => typeof ( EditableDataTransferObject ).IsAssignableFrom ( t ) && !t.IsAbstract )
.Select
( t => new
{
Dto = dtoFactory.CreateDto ( t ),
PropSet = t.GetProperties ()
.Select
( p => new
{
PropertyName = p.Name,
PropertySetter = p.GetSetMethod ()
}
)
.Where ( p => p.PropertySetter != null
&& !ignoredDtoProperties.Contains ( p.PropertyName ) )
}
);
foreach ( var d in allDtos )
{
INotifyPropertyChanged inpc = d.Dto;
foreach ( var p in d.PropSet )
{
// Setup event handler for the property being examined
string changedPropertyName = String.Empty;
// use named variable (as opposed to anonymous delegate) so we can unsubscribe
PropertyChangedEventHandler inpcOnPropertyChanged =
( obj, e ) => changedPropertyName = e.PropertyName;
inpc.PropertyChanged += inpcOnPropertyChanged;
// Simulate property change by invoking setter directly
p.PropertySetter.Invoke ( d.Dto, new object[] { null } );
Assert.AreEqual (
p.PropertyName,
changedPropertyName,
String.Format (
"Offending DTO type::property {0}::{1}",
d.Dto.GetType (),
p.PropertyName ) );
// Reset event handler
inpc.PropertyChanged -= inpcOnPropertyChanged;
}
}
}
}
public void NullDataRow()
{
var sut = new DtoFactory();
sut.Create<GetGameCountByDateDto>(null);
}
