public async Task UpdateAsync(Settings settings, string userId)
{
var item = (await _repository.GetAsync(SETTINGS, null, false, null, 1)).FirstOrDefault();
if (item == null)
{
await _repository.AddAsync(SETTINGS, JObject.FromObject(settings), userId);
}
else
{
await _repository.UpdateAsync(item.Id, JObject.FromObject(settings), userId);
}
}
public async Task <bool> CreatePedestrianCrossingLog(PedestrianCrossingRequest request)
{
var copier = new ClassValueCopier();
PedestrianCrossingLog newChildPart = copier.ConvertAndCopy <PedestrianCrossingLog, PedestrianCrossingRequest>(request);
return(await _pedestrianRepository.AddAsync(newChildPart));
}
public async Task <IActionResult> AddNewEnquiryAsync([FromForm] CustomerEnquiryDto customerEnquiry)
{
string attachmentUrl = string.Empty;
string fileTempPath = string.Empty;
if (customerEnquiry.Attachment != null)
{
var fileName = $"{Guid.NewGuid()}-{customerEnquiry.Attachment.FileName}";
fileTempPath = @$ "{Path.GetTempPath()}{fileName}";
using var stream = new FileStream(fileTempPath, FileMode.Create, FileAccess.ReadWrite);
await customerEnquiry.Attachment.CopyToAsync(stream);
attachmentUrl = await _blobStorageService.UploadBlobAsync(stream, fileName);
}
var enquiry = new Enquiry
{
Id = Guid.NewGuid().ToString(),
Title = customerEnquiry.Title,
Content = customerEnquiry.Content,
CustomerContactEmail = customerEnquiry.CustomerContactEmail,
AttachmentUrl = attachmentUrl
};
var createdEnquiry = await _enquiryRepository.AddAsync(enquiry);
if (!string.IsNullOrEmpty(fileTempPath))
{
System.IO.File.Delete(fileTempPath);
}
return(Ok(createdEnquiry));
}
public async Task <bool> CreateTrafficDensityLog(TrafficDensityRequest request)
{
var copier = new ClassValueCopier();
TrafficDensityLog newChildPart = copier.ConvertAndCopy <TrafficDensityLog, TrafficDensityRequest>(request);
return(await _trafficDensityRepository.AddAsync(newChildPart));
}
public async Task <bool> Handle(AddCarCommand request, CancellationToken cancellationToken)
{
Validate(request);
var vehicleType = await _vehicleTypeRepository.GetByNameAsync(request.VehicleType);
if (vehicleType == null)
{
throw new Exception("Vehicle type not found.");
}
var bodyType = await _bodyTypeRepository.GetByNameAsync(request.BodyType);
if (bodyType == null)
{
throw new Exception("Body type not found.");
}
var resource = await _carRepository.AddAsync(new Data.Models.Car()
{
Make = request.Make,
Model = request.Model,
Price = request.Price,
Engine = request.Engine,
Doors = request.Doors,
BodyTypeId = bodyType.Id,
VehicleTypeId = vehicleType.Id,
Created = DateTime.Now
});
//EmailHelper.SendEmail("", "*****@*****.**", "Car details added successfully", "Body Of the email");
return(true);
}
public ApiMutation(IDataRepository dataRepo)
{
Field <CustomerType>()
.Name("addCustomer")
.Argument <CustomerInputType>("customer", "the customer to add")
.Resolve(ctx =>
{
var customer = ctx.GetArgument <Customer>("customer");
return(dataRepo.AddAsync(customer));
});
Field <CustomerType>()
.Name("updateCustomer")
.Argument <CustomerInputType>("customer", "the customer to update")
.Resolve(ctx =>
{
var customer = ctx.GetArgument <Customer>("customer");
return(dataRepo.UpdateAsync(customer));
});
Field <CustomerType>()
.Name("deleteCustomer")
.Argument <IdGraphType>("id", "the id to delete")
.Resolve(ctx =>
{
var id = ctx.GetArgument <Guid>("id");
return(dataRepo.DeleteAsync <Customer>(id));
});
}
public async Task <ActionResult <TemperatureSensor> > Post([FromBody] TemperatureSensor temperatureSensor)
{
if (temperatureSensor == null)
{
return(BadRequest("temperatureSensor is null."));
}
await _dataRepository.AddAsync(temperatureSensor);
return(Ok(temperatureSensor));
}
/// <summary>
/// This method is used to add new project
/// </summary>
/// <param name="newProject">project that need to be added</param>
/// <param name="createdBy">passed id of user who has create this project</param>
/// <returns>project id of newly created project</returns>
public async Task <int> AddProjectAsync(ProjectAc newProject, string createdBy)
{
var project = _mapperContext.Map <ProjectAc, Project>(newProject);
project.CreatedDateTime = DateTime.UtcNow;
project.CreatedBy = createdBy;
project.ApplicationUsers = null;
_projectDataRepository.AddAsync(project);
await _projectDataRepository.SaveChangesAsync();
return(project.Id);
}
public async Task AddAsync(string templateName, string templateText, string userId, DateTimeOffset createAt)
{
var data = new Entities.Template
{
Name = templateName,
Text = templateText,
LastModifiedBy = userId,
LastModifiedAt = createAt
};
var json = JsonConvert.SerializeObject(data);
await _data.AddAsync(COLLECTION_NAME, json, userId, DateTimeOffset.Now);
}
public async Task <ActionResult <Pet> > CreatePet(Pet pet)
{
try
{
await _petRepository.AddAsync(pet);
return(Ok(pet));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task <string> AddAsync(string collectionName, JToken data)
{
var userId = _resolver.GetUserId();
if (userId == null)
{
throw new UnauthorizedAccessException();
}
var item = await _repository.AddAsync(collectionName, data.ToString(), userId, DateTimeOffset.UtcNow);
return(item.Id);
}
public async Task CommitChangesAsync()
{
await _repository.AddAsync(new Description
{
Template = nameof(CommitChangesAsync)
});
await _sut.CommitAsync();
var entity = await _repository.GetAllAsync(x => x.Template == nameof(CommitChangesAsync));
entity.Should().BeAssignableTo <Description>()
.And.NotBeNull();
}
//post all restaurants
public async Task <AllDetails> AddAllRestaurants(AllDetails details)
{
City city = new City();
_mapper.Map(details.City, city);
await _dataRepository.AddAsync <City>(city);
Country country = new Country();
_mapper.Map(details.Country, country);
await _dataRepository.AddAsync <Country>(country);
Location location = new Location();
_mapper.Map(details, location);
await _dataRepository.AddAsync <Location>(location);
Restaurant restaurant = new Restaurant();
_mapper.Map(details, restaurant);
await _dataRepository.AddAsync <Restaurant>(restaurant);
ICollection <Location> Locations = new List <Location>();
Locations.Add(location);
ICollection <Dishes> Dishes = new List <Dishes>();
restaurant.Location = Locations;
restaurant.Dishes = Dishes;
await _dataRepository.AddAsync <Location>(location);
await _dataRepository.SaveChangesAsync();
return(details);
}
public async Task <SaveDataResponse> SaveAsync(Data data)
{
try
{
await _dataRepository.AddAsync(data);
await _unitOfWork.CompleteAsync();
return(new SaveDataResponse(data));
}
catch (Exception ex)
{
return(new SaveDataResponse($"An error occurred when saving the category: {ex.Message}"));
}
}
/// <summary>
/// Amount deposit transaction
/// </summary>
/// <param name="transaction">transaction entity</param>
/// <returns>transaction object with id</returns>
public async Task <Models.Transaction> Create(Models.Transaction transaction)
{
try
{
transaction = await _transactionDataRepository.AddAsync(transaction);
await _transactionDataRepository.SaveChangesAsync();
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
_logger.LogTrace(ex.StackTrace);
throw ex;
}
return(transaction);
}
/// <summary>
/// Create new bank account
/// </summary>
/// <param name="bankAccount">bank account entity</param>
/// <returns>identity result</returns>
public async Task Create(Models.BankAccount bankAccount)
{
try
{
var account = await _bankAccountDataRepository.FirstOrDefaultAsync(x => x.UserName == bankAccount.UserName);
if (account == null)
{
var result = await _bankAccountDataRepository.AddAsync(bankAccount);
await _bankAccountDataRepository.SaveChangesAsync();
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
_logger.LogTrace(ex.StackTrace);
throw ex;
}
}
public async Task <IActionResult> UploadBlob([FromForm] BikeDto bikeDetails)
{
try
{
string attachmentUrl = string.Empty;
Bike bike = null;
if (!string.IsNullOrEmpty(bikeDetails.image.FileName))
{
string fileName = $"{Guid.NewGuid()}-{bikeDetails.image.FileName}";
string fileTempPath = @$ "{Path.GetTempPath()}{fileName}";
using var stream = new FileStream(fileTempPath, FileMode.Create, FileAccess.ReadWrite);
await bikeDetails.image.CopyToAsync(stream);
attachmentUrl = await _blobStorageService.UploadBlobAsync(stream, fileName);
}
if (!string.IsNullOrEmpty(attachmentUrl))
{
bike = new Bike()
{
Id = Guid.NewGuid().ToString(),
ImageUrl = attachmentUrl,
Brand = bikeDetails.Brand,
Location = bikeDetails.Location,
Model = bikeDetails.Model,
PricePerDay = bikeDetails.PricePerDay
};
}
var createdQuery = await _dataRepository.AddAsync(bike);
return(Ok(createdQuery));
}
catch (Exception e)
{
return(Ok("Transaction Failed"));
}
}
public async Task <string> AddAsync(Collection collection, string userId, DateTimeOffset datetime)
{
var item = await _data.AddAsync(COLLECTION_NAME__COLECTIONS, JsonConvert.SerializeObject(collection), userId, datetime);
return(item.Id);
}
/// <summary>
///This method to add user id and project id in userproject table
/// </summary>
/// <param name="newProjectUser">projectuser object</param>
public async Task AddUserProjectAsync(ProjectUser newProjectUser)
{
_projectUserDataRepository.AddAsync(newProjectUser);
await _projectUserDataRepository.SaveChangesAsync();
}
