public async Task <PackageDto> UpdatePackage(int id, PackageDto packageDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (id != packageDto.PackageId)
{
return(null);
}
else
{
Package p = db.Packages.FirstOrDefault(c => c.PackageId == id);
if (p == null)
{
return(null);
}
else
{
p = packageDto.ToModel();
db.Entry(p).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
return(p.ToDto());
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public IHttpActionResult SendPackage(PackageDto package)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var customer = context.Customers.FirstOrDefault(c => c.User.UserName == User.Identity.Name);
if (customer == null)
{
return(BadRequest());
}
package.Status = PackageStatus.AtClientsLocation;
package.Cost = pricingStrategy.GetCost(package);
var newPackage = Mapper.Map <Package>(package);
context.Packages.Add(newPackage);
customer.Packages.Add(newPackage);
context.PackageEvents.Add(new PackageEvent
{
Package = newPackage,
EventType = PackageEventType.ReadyToPickFromSender
});
context.SaveChanges();
return(Ok());
}
public void RegisterPackage_AddsPackageToDatabase()
{
var mockSet = MockDbSetHelper.CreateMockSet(new Package[] { }.AsQueryable());
var mockContext = new Mock <InstantDeliveryContext>();
mockContext.Setup(m => m.Packages).Returns(mockSet.Object);
mockContext.Setup(m => m.PackageEvents).ReturnsDbSet(new List <PackageEvent>());
var pricingMock = new Mock <IPricingStrategy>();
var package = new Package
{
Width = 100,
Height = 200,
Length = 150,
Weight = 100
};
var controller = new PackagesController(mockContext.Object, pricingMock.Object);
var packageDto = new PackageDto();
Mapper.DynamicMap(package, packageDto, typeof(Package), typeof(PackageDto));
controller.RegisterPackage(packageDto);
mockSet.Verify(m => m.Add(It.IsAny <Package>()), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
public IHttpActionResult CreatePackage(PackageDto packageDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.ToString()));
}
var package = Mapper.Map <PackageDto, Package>(packageDto);
try
{
var json =
new WebClient().DownloadString("https://maps.googleapis.com/maps/api/geocode/json?address=" +
package.Destination +
"&key=AIzaSyBMVIteB6a_vtVSunhpk56yZWeTSGN2CkM");
var data = JObject.Parse(json);
package.Latitude =
(double)data["results"][0].SelectToken("geometry").SelectToken("location").SelectToken("lat");
package.Longitude =
(double)data["results"][0].SelectToken("geometry").SelectToken("location").SelectToken("lng");
_context.Packages.Add(package);
_context.SaveChanges();
}
catch (DbEntityValidationException e)
{
return(BadRequest(e.StackTrace + "\n Validation of content failed"));
}
catch (Exception e)
{
return(BadRequest(e.StackTrace + "\n Address does not exist"));
}
packageDto.Id = package.Id;
return(Created(new Uri(Request.RequestUri + "/" + package.Id), packageDto));
}
public async Task <IActionResult> Create([FromBody] PackageDto package)
{
if (package == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
//Automapper for mapping packageDto to Package Entity
var mappedPackage = Mapper.Map <Packages>(package);
//create the package
await _package.Create(package);
//save the package
if (!await _package.Save())
{
return(StatusCode(500, "Server Error, Unable to process request"));
}
//mapped packageEntity to PackageDto
var savedPackage = Mapper.Map <PackageDto>(mappedPackage);
//return Created Result
//ISSUE is with savedPackage.Id, am unable to get generated ID
return(CreatedAtRoute("GetPackage", new { id = savedPackage.Id }, savedPackage));
}
else
{
return(BadRequest(ModelState));
}
}
public void RegisterPackage_ForValidatedPackage_ShouldAddNewPackage()
{
var package = new Package
{
Id = 1,
Height = 100,
Weight = 100,
Width = 100,
Length = 100,
Status = PackageStatus.InWarehouse
};
var packages = new List <Package>().AsQueryable();
var packagesMockSet = MockDbSetHelper.CreateMockSet(packages);
var mockContext = new Mock <InstantDeliveryContext>();
mockContext.Setup(c => c.Packages).Returns(packagesMockSet.Object);
mockContext.Setup(m => m.PackageEvents).ReturnsDbSet(new List <PackageEvent>());
var pricingStrategy = new Mock <IPricingStrategy>().Object;
var controller = new PackagesController(mockContext.Object, pricingStrategy);
var packageDto = new PackageDto();
Mapper.DynamicMap(package, packageDto, typeof(Package), typeof(PackageDto));
controller.RegisterPackage(packageDto);
packagesMockSet.Verify(m => m.Add(It.IsAny <Package>()), Times.Once());
mockContext.Verify(m => m.SaveChanges(), Times.Once());
}
private bool CheckIfPackageBelongsToClient(PackageDto package, int lineId, string clientId)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
LineRepository lineRepository = new LineRepository();
LineDto line = lineRepository.GetLine(lineId);
if (line != null)
{
if (line.PackageId == package.PackageId)
{
if (line.ClientId == clientId)
{
return(true);
}
return(false);
}
return(false);
}
return(false);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(false);
}
}
public async Task <PackageDto> UpdatePackage(PackageDto package, int lineId, string clientId)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (package != null)
{
if (CheckIfPackageBelongsToClient(package, lineId, clientId))
{
PackageEntity entity = package.ToModel();
entity.PackageId = package.PackageId;
db.Packages.Attach(entity);
foreach (var propName in db.Entry(entity).CurrentValues.PropertyNames)
{
if (propName != "PackageId")
{
db.Entry(entity).Property(propName).IsModified = true;
}
}
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
private void PluginPackageManager_PackageUninstalling(object sender, PackageOperationEventArgs e)
{
PackageDto package = e.Package.MapTo <PackageDto>();
string packagePath = e.InstallPath;
this.PackageUnistalling.Raise(sender, new PackageEventArgs(packagePath, package));
}
public async Task <PackageDto> CreatePackage(PackageDto package, PackageIncludesDto packageIncludes)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (package != null)
{
PackageEntity entity = new PackageEntity()
{
PackageName = package.PackageName,
PackageTotalPrice = package.PackageTotalPrice,
};
db.PackageIncludes.Add(packageIncludes.ToModel());
await db.SaveChangesAsync();
return(entity.ToDto());
}
return(null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task <PackageDto> CreatePackage(PackageDto packageDto)
{
using (CellularCompanyContext db = new CellularCompanyContext())
{
try
{
if (packageDto == null)
{
return(null);
}
else
{
db.Packages.Add(packageDto.ToModel());
await db.SaveChangesAsync();
return(packageDto);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(null);
}
}
}
public async Task Create(PackageDto package)
{
await _context.Packages.AddAsync(new Packages
{
Name = package.Name,
Description = package.Description,
});
}
public void TestInitialize()
{
_mockMainView = Substitute.For <IViewMain>();
_controllerMockBundle = new PackageControllerMockBundle();
_handler = new PackageEditRouteHandler(_mockMainView, _controllerMockBundle.MockController);
_package = new PackageDto(Guid.NewGuid());
_route = new PackageEditRoute(_package);
}
/// <summary>
/// Metoda oblicza wielkość wymiarową.
/// </summary>
/// <param name="package"></param>
/// <returns></returns>
private decimal DimensionalWeight(PackageDto package)
{
if (package == null)
{
return(0);
}
return(((decimal)package.Length * (decimal)package.Width * (decimal)package.Height) /
dimensionalWeightFactor);
}
public void AddPackage(PackageDto packageDto)
{
var package = new Package(packageDto.Id);
package.EditInfo(packageDto.UserId, packageDto.Name, packageDto.Description, packageDto.RowVersion);
_eventStore.AddToEventQueue(new PackageEditedEvent(packageDto.Id));
_unitOfWork.Packages.Update(package);
_unitOfWork.Complete();
}
private void Save_Click(object sender, RoutedEventArgs e)
{
var pkg = new PackageDto(Guid.NewGuid());
pkg.Name = package.PackageName;
pkg.Description = package.PackageDescription;
_controller.AddPackage(pkg);
//_router.GoTo(new PackageIndexRoute());
}
public async Task <PackageDto> AddPackage(PackageDto package, PackageIncludesDto packageIncludes)
{
Task <PackageDto> packageDto;
lock (obj)
{
packageDto = packageManager.AddPackageDto(package, packageIncludes);
}
return(await packageDto);
}
private PackageDto CreatePackage(PackageDto partialPackage, string extension, Blob blob)
{
partialPackage.Kind = GetKind(extension);
partialPackage.Size = blob.Properties.ContentLength;
partialPackage.Url = blob.Url;
partialPackage.PublishedAt = DateTime.Parse(blob.Properties.LastModified);
partialPackage.Checksum = GetMd5Hex(blob);
return(partialPackage);
}
public async Task <PackageDto> UpdatePackage(int clientId, int lineId, PackageDto package)
{
Task <PackageDto> packageToUpdate;
lock (_obj)
{
packageToUpdate = _packageProvider.UpdatePackage(package.PackageId, package);
}
return(await packageToUpdate);
}
public async Task <PackageDto> UpdatePackage(PackageDto package, int packageId)
{
Task <PackageDto> packageDto;
lock (obj)
{
packageDto = packageManager.UpdatePackageDto(package, packageId);
}
return(await packageDto);
}
public void TestInitialize()
{
_mockMainView = Substitute.For <IViewMain>();
_mockController = new PackageControllerMockBundle().MockController;
_mockDispatcher = Substitute.For <IThreadDispatcher>();
_mockDispatcher.Dispatch(Arg.Invoke());
_handler = new PackageIndexRouteHandler(_mockDispatcher, _mockMainView, _mockController);
_package = new PackageDto(Guid.NewGuid());
_route = new PackageIndexRoute();
}
public static PackageModel ToModel(this PackageDto package)
{
return(new PackageModel()
{
PackageId = package.PackageId,
PackageName = package.PackageName,
PackageTotalPrice = package.PackageTotalPrice,
//Lines = package.Lines.Select(l => l.ToModel()).ToList(),
//PackageIncludes = package.PackageIncludes.Select(p => p.ToModel()).ToList()
});
}
public static Package Create(PackageDto dto)
{
var package = new Package
{
Name = dto.Name,
Abbreviation = dto.Abbreviation
};
Validate(package);
return(package);
}
/// <summary>
/// Zwraca koszt przesyłki.
/// </summary>
/// <param name="package"></param>
/// <returns></returns>
public async Task <decimal> CalculatePackageCost(PackageDto package)
{
NameValueCollection queryString = HttpUtility.ParseQueryString(string.Empty);
queryString[nameof(PackageDto.Height)] = package.Height.ToString(CultureInfo.InvariantCulture);
queryString[nameof(PackageDto.Width)] = package.Width.ToString(CultureInfo.InvariantCulture);
queryString[nameof(PackageDto.Length)] = package.Length.ToString(CultureInfo.InvariantCulture);
queryString[nameof(PackageDto.Weight)] = package.Weight.ToString(CultureInfo.InvariantCulture);
return(await Get <decimal>($"Cost?{queryString}"));
}
public void TestInitialize()
{
_controllerMockBundle = new PackageControllerMockBundle();
_package = new PackageDto(Guid.NewGuid());
_controller = new PackageController(
_controllerMockBundle.MockThreadDispatcher,
_controllerMockBundle.MockCommandDispatcher,
_controllerMockBundle.MockQueryDispatcher,
_controllerMockBundle.MockViews
);
}
public async Task <PackageDto> UpdatePackage(string clientId, int lineId, PackageDto package)
{
Task <PackageDto> packageDto;
lock (obj)
{
packageManager = GetContainer().Resolve <IPackageManager>();
packageDto = packageManager.UpdatePackageDto(package, lineId, clientId);
}
return(await packageDto);
}
private static void AssertCreateFails(PackageDto dto)
{
try
{
Package.Create(dto);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsNotInstanceOfType(e, typeof (AssertFailedException));
}
}
private static void AssertCreateFails(PackageDto dto)
{
try
{
Package.Create(dto);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsNotInstanceOfType(e, typeof(AssertFailedException));
}
}
public ActionResult SavePackage(PackageDto dto)
{
if (String.IsNullOrWhiteSpace(dto.Name))
{
return(this.Direct(new { success = false }));
}
if (dto.Id == Guid.Empty.ToString())
{
dto.Id = new Guid().ToString();
}
return(this.Direct(new { success = true, data = dto }));
}
public void Execute(IJobExecutionContext context)
{
IPagedResult <PluginDto> plugins = this.pluginService.GetInstalledPlugin(1, 1000);
foreach (PluginDto plugin in plugins.Result)
{
PackageDto package = this.packageInstaller.Get(plugin.PackageId, plugin.Version);
PluginDto p = package.MapPropertiesToInstance(plugin);
this.pluginService.UpdatePlugin(p);
}
}
public void TestInitialize()
{
_mockRepo = Substitute.For <IPackageRepository>();
_mockUow = Substitute.For <IUnitOfWork>();
_mockUow.Packages.Returns(_mockRepo);
_packageDto = new PackageDto();
_mockMapper = Substitute.For <IMyMapper>();
_mockMapper.Map <Package, PackageDto>(Arg.Any <Package>())
.Returns(_packageDto);
_query = new GetPackageQuery();
_handler = new GetPackageQueryHandler(_mockUow, _mockMapper);
}
public ActionResult SavePackage(PackageDto dto)
{
if (String.IsNullOrWhiteSpace(dto.Name))
return this.Direct(new { success = false });
if (dto.Id == Guid.Empty.ToString()) dto.Id = new Guid().ToString();
return this.Direct(new { success = true, data = dto });
}
