public void CreateCampaign(CreateCampaignRequest request)
{
if (!_context.Client.Any(c => c.IdClient == request.IdClient))
{
throw new KeyNotFoundException($"Couldn't find client [{request.IdClient}]");
}
var fromBuildingStreet = _context.Building
.Single(b => b.IdBuilding == request.FromIdBuilding)
.Street;
var toBuildingStreet = _context.Building
.Single(b => b.IdBuilding == request.ToIdBuilding)
.Street;
if (!fromBuildingStreet.Equals(toBuildingStreet))
{
throw new ArgumentException(
$"Buildings [{request.FromIdBuilding}] and [{request.ToIdBuilding}] are not on the same street"
);
}
// todo obliczanie kosztu reklamy
// todo szukanie dobrego rozmiaru banerow
// todo dodawanie danych do DB
// todo zwracanie stworzonej kampanii 201
throw new System.NotImplementedException();
}
public IActionResult CreateCampaign([FromBody] CreateCampaignRequest request)
{
if (request.NumberOfCodes >= 1 && request.NumberOfCodes <= 3000)
{
var sql = new SQL(connectionString: _config.GetConnectionString("Storage"));
var codeReader = new CodeReader(fileUrl: _config.GetSection("FileUrls")["SeedBlobUrl"]);
var campaign = new Campaign()
{
Name = request.Name,
Size = request.NumberOfCodes
};
// Get the last offset position
var prevAndNextOffset = sql.UpdateOffset(campaign.Size);
// Read from the file
var codes = codeReader.GenerateCodesFromFile(prevAndNextOffset);
// Create the campaign and insert the codes
sql.CreateCampaign(campaign, codes);
return(Ok(campaign));
}
return(BadRequest());
}
public void CreateCampaign_Correct()
{
//Arrange
var dbLayer = new Mock <IClientServiceDb>();
var req = new CreateCampaignRequest
{
IdClient = 2,
StartDate = new DateTime(2020, 1, 1),
EndDate = new DateTime(2020, 3, 1),
FromIdBuilding = 4,
ToIdBuilding = 6,
PricePerSquareMeter = 35
};
dbLayer.Setup(d => d.CreateCampaign(req))
.Returns(new CreateCampaignResponse
{
IdCampaign = 2,
TotalPrice = 1130,
Banners = new List <int>
{
4, 5, 6
}
});
var cont = new ClientController(dbLayer.Object);
//Act
var res = cont.CreateCampaign(req);
//Assert
Assert.NotNull(res);
var r = (OkObjectResult)res;
Assert.True(r.StatusCode == 200);
}
public async Task CreateCampaign(CreateCampaignRequest request)
{
Campaign campaign = new Campaign(request);
campaign.SetStore(_transactionStore);
await campaign.Save();
}
public async Task <CreateCampaignResponse> CreateCampaign(CreateCampaignRequest createCampaignRequest)
{
var resource = "/v1/campaigns";
var request = new HttpRequestMessage(HttpMethod.Post, resource);
return(await Execute <CreateCampaignResponse, CreateCampaignRequest>(request, createCampaignRequest));
}
public async Task <BaseResponseDto <bool> > Handle(CreateCampaignRequest request, CancellationToken cancellationToken)
{
BaseResponseDto <bool> response = new BaseResponseDto <bool>();
try
{
var campaign = new Campaigning
{
Duration = request.Duration,
CreatedAt = DateTime.Now,
Limit = request.Limit,
CampaignName = request.CampaignName,
ProductCode = request.ProductCode,
TargetSalesCount = request.TargetSalesCount
};
await _repository.CreateAsync(campaign);
response.Data = true;
await _mediator.Publish(new CampaignCreatedEvent(campaignName : campaign.CampaignName));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
response.Errors.Add("An error occurred while creating the campaign.");
}
return(response);
}
public async Task <IActionResult> CreateCampaign([FromBody] CreateCampaignRequest request)
{
var campaign = await CampaignService.CreateCampaign(request);
await EventService.Publish(new CampaignCreatedEvent(campaign.ToCampaignQueueItem(request.SelectedUserCodes)));
return(CreatedAtAction(nameof(GetCampaignById), new { campaignId = campaign.Id }, campaign));
}
public async Task CreateAsync(CreateCampaignRequest request)
{
var entity = new CampaignEntity
{
Name = request.Name
};
await(await _container).CreateItemAsync(await _entityMutator.CreateMetadataAsync(entity, request.SharedWith));
}
public async Task <Guid> CreateACampaign(CreateCampaignRequest request)
{
var json = JsonConvert.SerializeObject(request);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(new Uri("/campaign", UriKind.Relative), content);
var body = JsonConvert.DeserializeObject <dynamic>(await response.Content.ReadAsStringAsync());
Guid id = body.id;
return(id);
}
public async Task CreateCampaign(CreateCampaignRequest createCampaignRequest)
{
string json = JsonConvert.SerializeObject(createCampaignRequest);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "api/transactions/campaigns")
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
HttpResponseMessage responseMessage = await _httpClient.SendAsync(request);
await EnsureSuccessOrThrowAsync(responseMessage);
}
public override Task <Campaign> CreateCampaign(CreateCampaignRequest request, ServerCallContext context)
{
return(Task.FromResult(
new Campaign()
{
BeneficiaryId = request.BeneficiaryId,
Id = Guid.NewGuid().ToString(),
InitiatorId = request.InitiatorId,
OperatorId = request.OperatorId,
State = CampaignState.Draft
}));
}
public async Task <ActionResult <string> > CreateOrderAsync([FromBody] CreateCampaignRequest createCampaignRequest)
{
BaseResponseDto <bool> createResponse = await _mediator.Send(createCampaignRequest);
if (createResponse.Data)
{
return(Created("...", null));
}
else
{
return(BadRequest(createResponse.Errors));
}
}
public IActionResult CreateCampaign(CreateCampaignRequest request)
{
CreateCampaignResponse res;
try
{
res = _clientServiceDb.CreateCampaign(request);
}catch (Exception e) when(e is ClientDoesNotExsitsException ||
e is WrongDateException || e is BuildingsAreNotOnTheSameStreetException)
{
return(BadRequest(e.Message));
}
return(Ok(res));
}
public Campaign(CreateCampaignRequest createCampaignRequest)
{
Id = Utils.CreateId();
Name = createCampaignRequest.Name;
Username = createCampaignRequest.NgoUsername;
NgoName = createCampaignRequest.NgoName;
Type = createCampaignRequest.Type;
Category = createCampaignRequest.Category;
Status = "Active";
CompletedCount = 0;
TimeCreated = Utils.UnixTimeSeconds();
TimeCompleted = 0;
Description = createCampaignRequest.Description;
}
/// <summary>
/// Creates a new campaign.
/// </summary>
/// <param name="campaign">The request model used to create a new campaign.</param>
public async Task <CampaignResult> Create(CreateCampaignRequest campaign)
{
var validator = ServiceProvider.GetRequiredService <CreateCampaignRequestValidator>();
var validationResult = validator.Validate(campaign);
if (!validationResult.IsValid)
{
var errorMessages = validationResult.Errors.Select(x => x.ErrorMessage).ToArray();
return(CampaignResult.Fail(errorMessages));
}
var createdCampaign = await CampaignService.CreateCampaign(campaign);
campaign.Id = createdCampaign.Id;
return(CampaignResult.Success());
}
/// <summary>
/// 创建短信推送活动
/// </summary>
/// <param name="req"><see cref="CreateCampaignRequest"/></param>
/// <returns><see cref="CreateCampaignResponse"/></returns>
public CreateCampaignResponse CreateCampaignSync(CreateCampaignRequest req)
{
JsonResponseModel <CreateCampaignResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "CreateCampaign");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateCampaignResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public async Task GetCampaignDetailsAfterCreateCampaign_WithRandomValidRequest_ShouldReturnCorrectResponse()
{
// Arrange
var createCampaignTypeRequest = new CreateCampaignTypeRequest
{
Name = _faker.Random.Utf16String(1, 50, true),
Description = _faker.Random.Utf16String(0, 200, true)
};
var createCampaignTypeResponse = await _campaignsService.CreateCampaignType(
createCampaignTypeRequest, Mock.Of <ServerCallContext>());
var createCampaignRequest = new CreateCampaignRequest
{
InitiatorId = Guid.NewGuid().ToString(),
OperatorId = Guid.NewGuid().ToString(),
BeneficiaryId = Guid.NewGuid().ToString(),
Title = _faker.Random.Utf16String(1, 200, true),
CampaignTypeId = createCampaignTypeResponse.Id
};
// Act
var createCampaignResponse = await _campaignsService.CreateCampaign(
createCampaignRequest, Mock.Of <ServerCallContext>());
var campaignDetails = await _campaignsService.GetCampaignDetails(
new GetCampaignDetailsRequest { Id = createCampaignResponse.Id }, Mock.Of <ServerCallContext>());
// Assert
campaignDetails.Should().NotBeNull();
campaignDetails.Title.Should().Be(createCampaignRequest.Title);
campaignDetails.InitiatorId.Should().Be(createCampaignRequest.InitiatorId);
campaignDetails.OperatorId.Should().Be(createCampaignRequest.OperatorId);
campaignDetails.BeneficiaryId.Should().Be(createCampaignRequest.BeneficiaryId);
campaignDetails.State.Should().Be(CampaignState.Draft);
campaignDetails.CampaignType.Should().NotBeNull();
campaignDetails.CampaignType.Name.Should().Be(createCampaignTypeRequest.Name);
campaignDetails.CampaignSubtype.Should().BeNull();
campaignDetails.ShortDescription.Should().BeEmpty();
campaignDetails.FullDescription.Should().BeEmpty();
}
public string CreateCampaign(CreateCampaignRequest createCampaignRequest)
{
var client = new RestClient(_baseUrl);
var request = new RestRequest("api/campaign", Method.POST);
request.AddHeader("Accept", "application/json");
string jsonObject = JsonConvert.SerializeObject(createCampaignRequest, Formatting.Indented, jsonSerializerSettings);
request.AddParameter("application/json", jsonObject, ParameterType.RequestBody);
var response = client.Execute(request);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(response.Content);
}
return($"Campaign created; name {createCampaignRequest.Name}, product {createCampaignRequest.ProductCode}, " +
$"duration {createCampaignRequest.Duration}, limit {createCampaignRequest.PriceManipulationLimit}, target sales count {createCampaignRequest.TargetSalesCount}");
}
public async Task CreateCampaign_WithRandomValidRequest_ShouldPersistCorrectly()
{
// Arrange
var createCampaignTypeRequest = new CreateCampaignTypeRequest
{
Name = _faker.Random.Utf16String(1, 50, true),
Description = _faker.Random.Utf16String(0, 200, true)
};
var createCampaignTypeResponse = await _campaignsService.CreateCampaignType(
createCampaignTypeRequest, Mock.Of <ServerCallContext>());
var createCampaignRequest = new CreateCampaignRequest
{
InitiatorId = Guid.NewGuid().ToString(),
OperatorId = Guid.NewGuid().ToString(),
BeneficiaryId = Guid.NewGuid().ToString(),
Title = _faker.Random.Utf16String(1, 200, true),
CampaignTypeId = createCampaignTypeResponse.Id
};
var expectedCreationDate = DateTime.UtcNow;
// Act
var createCampaignResponse = await _campaignsService.CreateCampaign(
createCampaignRequest, Mock.Of <ServerCallContext>());
// Assert
createCampaignTypeResponse.Should().NotBeNull();
var campaignFromDb = await _appDbContext.Campaigns.FindAsync(Guid.Parse(createCampaignResponse.Id));
campaignFromDb.Title.Should().Be(createCampaignRequest.Title);
campaignFromDb.InitiatorId.Should().Be(createCampaignRequest.InitiatorId);
campaignFromDb.OperatorId.Should().Be(createCampaignRequest.OperatorId);
campaignFromDb.BeneficiaryId.Should().Be(createCampaignRequest.BeneficiaryId);
campaignFromDb.State.Should().Be(CampaignState.Draft);
campaignFromDb.CampaignType.Should().NotBeNull();
campaignFromDb.CampaignType.Name.Should().Be(createCampaignTypeRequest.Name);
campaignFromDb.CreationDate.Should().BeCloseTo(expectedCreationDate, 200);
}
public async Task <Campaign> CreateCampaign(CreateCampaignRequest request)
{
var dbCampaign = request.ToDbCampaign();
DbContext.Campaigns.Add(dbCampaign);
if (!request.IsGlobal && request.SelectedUserCodes?.Count > 0)
{
var campaignUsers = request.SelectedUserCodes.Select(userId => new DbCampaignUser {
Id = Guid.NewGuid(),
UserCode = userId,
CampaignId = dbCampaign.Id
});
DbContext.CampaignUsers.AddRange(campaignUsers);
}
await DbContext.SaveChangesAsync();
var campaign = dbCampaign.ToCampaign();
return(campaign);
}
public IActionResult CreateCampaign(CreateCampaignRequest request)
{
try
{
var response = _advertService.CreateCampaign(request);
return(CreatedAtAction("CreateCampaign", response));
}
catch (CannotFindSuchBuilding ex)
{
return(NotFound(ex.Message));
}
catch (DifferentStreets ex1)
{
return(BadRequest(ex1.Message));
}
catch (BuildingsInDifferentCities ex2)
{
return(BadRequest(ex2.Message));
}
}
public IActionResult CreateCampaign([FromBody] CreateCampaignRequest request)
{
if (request.campaignSize >= 1 && request.campaignSize <= 30000)
{
var campaign = new Campaign()
{
CampaignName = request.campaignName,
CampaignSize = request.campaignSize
};
var cloudPath = new CloudPath(_config.GetSection("SeedBlobUrl")["BlobUrl"]);
var sql = new SQL(_config.GetConnectionString("SQLConnnection"));
var offsetUpdate = sql.UpdateOffset(campaign.CampaignSize);
var listOfCodes = cloudPath.GenerateCodesFromCloudFile(offsetUpdate);
sql.CreateCampaign(listOfCodes, campaign);
return(Ok(campaign));
}
return(BadRequest());
}
public async Task <IActionResult> Post(CreateCampaignRequest createCampaignRequest)
{
Building buildingFrom;
Building buildingTo;
try
{
buildingFrom = await _advertCampaignContext.Building.FindAsync(createCampaignRequest.FromIdBuilding);
buildingTo = await _advertCampaignContext.Building.FindAsync(createCampaignRequest.ToIdBuilding);
if (!buildingFrom.Street.Equals(buildingTo.Street))
{
return(BadRequest());
}
} catch (Exception exception)
{
Console.WriteLine(exception);
return(NotFound());
}
return(Ok());
}
public IActionResult CreateBatch([FromBody] CreateCampaignRequest request)
{
if (request.CodesNumber >= 1 && request.CodesNumber <= 3000)
{
var sql = new SQL(connectionString: _config.GetConnectionString("Storage"));
var file = new CloudReader(filePath: _config.GetSection("File")["SeedBlobUrl"]);
var promotion = new Promotion()
{
Name = request.Name,
BatchSize = request.CodesNumber
};
var firstAndLastOffset = sql.UpdateOffset(promotion.BatchSize);
var codes = file.GenerateCodes(firstAndLastOffset);
sql.CreateBatch(promotion, codes);
return(Ok(promotion));
}
return(BadRequest());
}
public CreateCampaignResponse CreateCampaign(CreateCampaignRequest request)
{
var fromBuilding = _context.Building.FirstOrDefault(p => p.IdBuilding == request.FromIdBuilding);
var toBuilding = _context.Building.FirstOrDefault(p => p.IdBuilding == request.ToIdBuilding);
if (fromBuilding == null || toBuilding == null)
{
throw new CannotFindSuchBuilding();
}
if (!fromBuilding.Street.Equals(toBuilding.Street))
{
throw new DifferentStreets();
}
if (!fromBuilding.City.Equals(toBuilding.City))
{
throw new BuildingsInDifferentCities();
}
var buildings = _context.Building
.Where(p => p.StreetNumber >= fromBuilding.StreetNumber && p.StreetNumber <= toBuilding.StreetNumber)
.OrderByDescending(p => p.Height)
.ToList();
var highest_1 = buildings.First();
var highest_2 = buildings.ElementAt(1);
var highest_1_Count = buildings.Count(p => p.Height == highest_1.Height);
var areas = _service.CalculateMinimalArea(highest_1, highest_2, buildings, fromBuilding, toBuilding);
var bannerPrice_1 = areas.Item1 * request.PricePerSquareMeter;
var bannerPrice_2 = areas.Item2 * request.PricePerSquareMeter;
var totalPrice = bannerPrice_1 + bannerPrice_2;
var roundPrice1 = Math.Round(bannerPrice_1, 2);
var roundPrice2 = Math.Round(bannerPrice_2, 2);
var roundTotal = Math.Round(totalPrice, 2);
var campaign = new Campaign()
{
IdClient = request.IdClient,
StartDate = request.StartDate,
EndDate = request.EndDate,
PricePerSquareMeter = request.PricePerSquareMeter,
FromIdBuilding = request.FromIdBuilding,
ToIdBuilding = request.ToIdBuilding
};
_context.Campaign.Add(campaign);
_context.SaveChanges();
var banner1 = new Banner()
{
Name = request.BannerName1,
Price = roundPrice1,
IdCampaignNavigation = campaign,
Area = areas.Item1
};
var banner2 = new Banner()
{
Name = request.BannerName2,
Price = roundPrice2,
IdCampaignNavigation = campaign,
Area = areas.Item2
};
List <Banner> banners = new List <Banner>();
banners.Add(banner1);
banners.Add(banner2);
_context.Banner.Add(banner1);
_context.Banner.Add(banner2);
_context.SaveChanges();
return(new CreateCampaignResponse()
{
IdClient = request.IdClient,
StartDate = request.StartDate,
EndDate = request.EndDate,
PricePerSquareMeter = request.PricePerSquareMeter,
FromIdBuilding = request.FromIdBuilding,
ToIdBuilding = request.ToIdBuilding,
Banners = banners,
TotalPrice = roundTotal
});
}
public override Task <CreateCampaignResponse> CreateCampaign(CreateCampaignRequest request, ServerCallContext context)
{
return(_mediator.Send(new CreateCampaignCommand(request)));
}
public CreateCampaignResponse CreateCampaign(CreateCampaignRequest request)
{
// def date Format 2020-01-01T00:00:00
var exists = _campaignDbContext.Clients.Any(c => c.IdClient == request.IdClient);
if (!exists)
{
throw new ClientDoesNotExsitsException($"client {request.IdClient} does not exists");
}
if (request.EndDate < request.StartDate)
{
throw new WrongDateException("campaign should last at least 1 second");
}
var heights = new List <decimal>();
var numOfBuild = 0;
var firstB = _campaignDbContext.Buildings
.Where(b => b.IdBuilding == request.FromIdBuilding)
.FirstOrDefault();
heights.Add(firstB.Height);
for (int i = request.FromIdBuilding + 1; i <= request.ToIdBuilding; i++)
{
var nextB = _campaignDbContext.Buildings
.Where(b => b.IdBuilding == i)
.FirstOrDefault();
if (firstB == null || nextB == null)
{
throw new BuildingsAreNotOnTheSameStreetException();
}
if (firstB.Street != nextB.Street || firstB.City != nextB.City)
{
throw new BuildingsAreNotOnTheSameStreetException();
}
heights.Add(nextB.Height);
numOfBuild++;
}
// looking for the height of our banners
var sorted = heights.OrderByDescending(v => v).ToArray();
var firstBannerHeight = sorted[0];
var secondBannerHeight = sorted[1] * numOfBuild;
var price = (firstBannerHeight + secondBannerHeight) * request.PricePerSquareMeter;
var campaign = new Campaign()
{
IdClient = request.IdClient,
StartDate = request.StartDate,
EndDate = request.EndDate,
PricePerSquareMeter = request.PricePerSquareMeter,
FromIdBuilding = request.FromIdBuilding,
ToIdBuilding = request.ToIdBuilding
};
_campaignDbContext.Add(campaign);
_campaignDbContext.SaveChanges();
var banners = new List <int>();
var banner1 = new Banner()
{
IdCampaign = campaign.IdCampaign,
Area = firstBannerHeight,
Name = "for campaign: " + campaign.IdCampaign,
Price = price / 2
};
_campaignDbContext.Add(banner1);
_campaignDbContext.SaveChanges();
banners.Add(banner1.IdAdvertisement);
var banner2 = new Banner()
{
IdCampaign = campaign.IdCampaign,
Area = secondBannerHeight,
Name = "for campaign: " + campaign.IdCampaign,
Price = price / 2
};
_campaignDbContext.Add(banner2);
_campaignDbContext.SaveChanges();
banners.Add(banner2.IdAdvertisement);
return(new CreateCampaignResponse
{
IdCampaign = campaign.IdCampaign,
TotalPrice = price,
Banners = banners
});
}
public async Task <IActionResult> CreateCampaign([FromBody] CreateCampaignRequest request)
{
await _transactionService.CreateCampaign(request);
return(Ok());
}
public IActionResult CreateCampaign(CreateCampaignRequest request)
{
// todo 8 Tworzenie nowej kampanii
return(Ok());
}
public async Task CreateAsync(CreateCampaignRequest request) => await _service.CreateAsync(request);
