public async Task <Guid> CreateNewExpense(ExpenseRequestDTO requestDTO)
{
var bankAccount = await _repository.GetByIdAsync <Domain.Model.Account.BankAccount>(requestDTO.BankAccountId);
var institution = await _repository.GetByIdAsync <Domain.Model.Institution.Institution>(requestDTO.InstitutionId);
var sector = await _repository.GetByIdAsync <Domain.Model.Sector.Sector>(requestDTO.SectorId);
if (bankAccount == null || institution == null || sector == null)
{
return(Guid.Empty);
}
var newInstance = new Domain.Model.Income.Expenses
{
Amount = requestDTO.Amount,
CurrencyType = requestDTO.CurrencyType,
Description = requestDTO.Description,
DocumentNumber = requestDTO.DocumentNumber,
Expiry = requestDTO.Expiry,
ExpiryDate = requestDTO.ExpiryDate,
Type = requestDTO.ExpenseType,
BankAccount = bankAccount,
Institution = institution,
Sector = sector
};
_repository.Add(newInstance);
await _repository.CommitAsync();
return(newInstance.Id);
}
public async Task HandleAsync(CreateBusiness message, IRequestInfo requestInfo)
{
IBusinessDocument businessDocument;
try
{
var code = await CheckCode(_numberGenerator.GenerateNumber(6));
businessDocument = _businessesFactory.CreateBusiness(message.Name, message.TradingName, message.WebAddress,
message.HeadContactFirstName, message.HeadContactSecondName,
message.HeadContactContactNumber, message.HeadContactEmail, message.HeadOfficePostCode, message.HeadOfficeAddressLine1, message.HeadOfficeAddressLine2, code);
await _repository.Add(businessDocument);
}
catch (VmsException e)
{
_logger.LogInformation("Create business rejected: " + e.Code);
_publisher.PublishEvent(new CreateBusinessRejected(e.Code, e.Message), requestInfo);
return;
}
_logger.LogInformation("Create business succeeded.");
_publisher.PublishEvent(new BusinessCreated(businessDocument.Id, businessDocument.Code), requestInfo);
}
public void Add(IBusiness business, ILocation location, IUserBusiness userBusiness, IGroup group)
{
try
{
Lock();
_businessRepository.Add(business);
_locationRepository.Add(location);
_groupRepository.Add(group);
foreach (var email in business.Members)
{
var userGroup = new UserGroup
{
Id = group.Id,
Name = group.Name,
Role = GroupRoles.Admin
};
_userRepository.AddBusinessWithEmail(userBusiness, email);
_userRepository.AddGroupWithEmail(userGroup, email);
}
}
catch (Exception)
{
//TODO: Rollback logic
throw new Exception("Failed to perform atomic action - " + Desc);
}
finally
{
Unlock();
}
}
public Business Save(Business business)
{
var bu = _businessRepository.Add(business);
SaveCommit();
return(bu);
}
public IActionResult Create(BusinessViewModel model)
{
var listing = model.Listing;
var categories = ListingHelper.GetCategories(listing);
listing.Categories.AddRange(categories);
businessRepo.Add(listing);
return(RedirectToAction("CreateLocation", new { id = model.Listing.Id.ToString() }));
}
public static void SeedBusinesses(IBusinessRepository _businessRepo)
{
var businesses = GetSeedBusinessListings();
// TODO: Finish this with find and replace functionality
foreach (var business in businesses)
{
_businessRepo.Add(business);
}
}
public async Task <Guid> CreateAsync(InstitutionRequestDTO requestDTO)
{
var institution = new Domain.Model.Institution.Institution
{
Name = requestDTO.Name,
PhoneNumber = requestDTO.PhoneNumber,
EmailAddress = requestDTO.EmailAddress,
Code = requestDTO.Code
};
_repository.Add(institution);
await _repository.CommitAsync();
return(institution.Id);
}
public bool Add(Business business)
{
if (!business.IsValid())
{
return(false);
}
_businessRepository.Add(business);
if (business.Id != 0)
{
return(true);
}
else
{
return(false);
}
}
public async Task <IActionResult> Add(AddCompanyDTO company)
{
var user = await _repo.GetUser(company.UserName);
var companyToAdd = new Company();
companyToAdd.Name = company.Name;
companyToAdd.Description = company.Description;
companyToAdd.Tags = company.Tags;
companyToAdd.CreatedOn = DateTime.Now;
companyToAdd.UpdatedOn = DateTime.Now;
companyToAdd.UserId = user.Id;
_repo.Add <Company>(companyToAdd);
await _repo.SaveAll();
return(Ok(company));
}
public ActionResult <AuthData> Post([FromBody] RegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _mapper.Map <User>(model);
var business = _mapper.Map <Business>(model);
var emailUnique = _userRepository.IsEmailUnique(model.Email);
if (emailUnique)
{
business.BusinessOwner = new BusinessOwner()
{
User = user
};
business.BusinessCategory = new BusinessCategory()
{
};
_userRepository.Add(user);
_userRepository.Commit();
_businessRepository.Add(business);
_businessRepository.Commit();
}
else
{
business = _businessRepository.GetSingle(x => x.BusinessOwner.User.Auth0UserId == model.Auth0UserId, x => x.BusinessOwner, x => x.BusinessOwner.User);
user = business.BusinessOwner.User;
}
return(new AuthData()
{
BusinessId = business.Id,
UserId = user.Id
});
}
public async Task <Guid> CreateNewBankAccountAsync(BankAccountRequestDTO requestDTO)
{
Domain.Model.Institution.Institution currentInstitution;
if (string.IsNullOrEmpty(CurrentInstitutionId))
{//admin user so , ins id will come from request payload.
currentInstitution = await _repository.GetByIdAsync <Domain.Model.Institution.Institution>(requestDTO.InstitutionId.Value);
}
else
{//casual user.
currentInstitution = await _repository.GetByIdAsync <Domain.Model.Institution.Institution>(Guid.Parse(CurrentInstitutionId));
}
if (currentInstitution == null)
{
return(Guid.Empty);
}
var newInstance = new Domain.Model.Account.BankAccount
{
BankAccountName = requestDTO.BankAccountName,
Institution = currentInstitution,
AccountIBAN = requestDTO.AccountIBAN,
AccountNo = requestDTO.AccountNo,
AccountType = requestDTO.AccountType,
BankAccountDescription = requestDTO.BankAccountDescription,
BankType = requestDTO.BankType,
BlockedBalance = requestDTO.BlockedBalance,
CurrencyType = requestDTO.CurrencyType,
TotalBalance = requestDTO.TotalBalance,
UsableBalance = requestDTO.UsableBalance
};
_repository.Add(newInstance);
await _repository.CommitAsync();
return(newInstance.Id);
}
public IActionResult Registe([FromServices] AppData appData,
string name,
string pwd,
string code,
string invitationCode,
string email,
string address,
string phone,
string mark,
string license)
{
var result = new JsonData();
if (service.Exists(a => (a.Name == name)))
{
result.Msg = "该商户已注册";
result.Success = false;
return(Json(result));
}
else if (service.Exists(a => (a.Code == code)))
{
result.Msg = "该用户名已注册";
result.Success = false;
return(Json(result));
}
else
{
var userInfo = new Business
{
Name = name,
Password = UtilHelper.MD5Encrypt(pwd),
Code = code,
Email = email,
InvitationCode = invitationCode,
Address = address,
Mobile = phone,
BusinessLicense = license,
RegisterDate = DateTime.Now,
Description = mark,
Freight = 4,
BusinessStartTime = "06:00",
BusinessEndTime = "21:00",
Category = BusinessCategory.Store,
StoreId = service.GetNextStoreNumber(),
ObjectId = Guid.NewGuid().ToString().ToLower(),
Score = 5,
Delivery = 5,
IsEnjoymentActivity = false,
DiscountQuantity = 1,
WeChatAppId = appData.WeChatAppId,
WeChatSecret = appData.WeChatSecret,
RefundTemplateId = appData.Msg_Refund,
NewOrderTemplateId = appData.EventMessageTemplateId,
PayServerAppId = appData.ServerAppId,
PayServerKey = appData.ServerKey,
PayServerMchId = appData.ServerMchId,
CertFile = appData.CertFile
};
userInfo.FeyinMemberCode = appData.FeyinMemberCode;
userInfo.FeyinApiKey = appData.FeyinApiKey;
service.Add(userInfo);
result.Msg = "注册成功";
result.Success = true;
return(Json(result));
}
}
public IActionResult Create(BusinessListingViewModel model)
{
businessRepo.Add(model.Listing);
return(RedirectToAction("Details", new { id = model.Listing.Id.ToString() }));
}
