public ActionResult AcceptOrder(int orderId)
{
PartnerDto partnerDto = (PartnerDto)Session["session"];
productService.AcceptOrder(orderId);
return(RedirectToAction("OrdersList", new { userId = partnerDto.Id }));
}
static CustomerAcctDto mapToCustomerAcct(CustomerAcctRow pCustomerAcctRow, PartnerDto pPartner)
{
if (pCustomerAcctRow == null)
{
return(null);
}
var _customerAcct = new CustomerAcctDto
{
CustomerAcctId = pCustomerAcctRow.Customer_acct_id,
ServiceId = pCustomerAcctRow.Service_id,
RoutingPlanId = pCustomerAcctRow.Routing_plan_id,
AllowRerouting = pCustomerAcctRow.AllowRerouting,
DefaultBonusMinutesType = pCustomerAcctRow.DefaultBonusMinutesType,
DefaultStartBonusMinutes = pCustomerAcctRow.Default_start_bonus_minutes,
IsPrepaid = pCustomerAcctRow.IsPrepaid,
ConcurrentUse = pCustomerAcctRow.ConcurrentUse,
CurrentAmount = pCustomerAcctRow.Current_amount,
LimitAmount = pCustomerAcctRow.Limit_amount,
Name = pCustomerAcctRow.Name,
PrefixIn = pCustomerAcctRow.Prefix_in,
PrefixInTypeId = pCustomerAcctRow.Prefix_in_type_id,
PrefixOut = pCustomerAcctRow.Prefix_out,
Status = pCustomerAcctRow.AccountStatus,
WarningAmount = pCustomerAcctRow.Warning_amount,
MaxCallLength = pCustomerAcctRow.Max_call_length,
Partner = pPartner,
ServiceDto = null,
RoutingPlan = null
};
return(_customerAcct);
}
public ActionResult RemoveItemFromBag(int itemId)
{
PartnerDto currentPartner = (PartnerDto)Session["session"];
currentPartner.ItemsId.Remove(itemId);
return(RedirectToAction("ShowMyBag"));
}
public ActionResult AddItemInOrder(int itemId)
{
PartnerDto partner = (PartnerDto)Session["session"];
partner.ItemsId.Add(itemId);
return(RedirectToAction("ProductList"));
}
public ActionResult ShowMyBag()
{
PartnerDto currentPartner = (PartnerDto)Session["session"];
List <ProductDto> productsInBag = productService.GetProductsInBag(currentPartner.ItemsId);
return(View("ProductBag", productsInBag));
}
public object GetPartnerById(string id)
{
PartnerDto partnerDto = new PartnerDto();
try
{
Partner partner = new Partner();
partner.PartnerRepository = repository;
var item = partner.GetPartnerById(id);
if (item == null)
{
partnerDto.IsError = true;
partnerDto.Message = "Não retornou resultados na consultar parceiro por id!";
return(partnerDto);
}
partnerDto.Id = item.Id.ToString();
partnerDto.Address = item.Address;
partnerDto.CoverageArea = item.CoverageArea;
partnerDto.Document = item.Document;
partnerDto.OwnerName = item.OwnerName;
partnerDto.TradingName = item.TradingName;
}
catch (Exception ex)
{
partnerDto.IsError = true;
partnerDto.Message = $"Erro ao consultar parceiro por id: {ex.Message}!";
}
return(partnerDto);
}
static CarrierAcctDto mapToCarrierAcct(CarrierAcctRow pCarrierAcctRow, PartnerDto pPartner, CallingPlanDto pCallingPlan)
{
if (pCarrierAcctRow == null)
{
return(null);
}
if (pPartner == null)
{
return(null);
}
if (pCallingPlan == null)
{
return(null);
}
var _carrierAcct = new CarrierAcctDto
{
CarrierAcctId = pCarrierAcctRow.Carrier_acct_id,
IntlDialCode = pCarrierAcctRow.Intl_dial_code,
Name = pCarrierAcctRow.Name,
Strip1Plus = pCarrierAcctRow.Strip1plus,
PrefixOut = pCarrierAcctRow.Prefix_out,
Status = pCarrierAcctRow.AccountStatus,
RatingType = pCarrierAcctRow.RatingType,
MaxCallLength = pCarrierAcctRow.MaxCallLength,
Partner = pPartner,
CallingPlan = pCallingPlan
};
return(_carrierAcct);
}
static void sendNotification(PersonDto pPerson,
CustomerAcctPaymentDto pCustomerAcctPayment,
CustomerAcctRow_Base pCustomerAcctRow,
PartnerDto pPartner,
ContactInfoDto pContactInfo)
{
try {
var _subject = "Balance Adjustment, [Partner]> " + pPartner.Name + " [Acct]> " + pCustomerAcctRow.Name;
var _body = "Server Time> " + pCustomerAcctPayment.DateTime.ToString("yyyy-MM-dd HH:mm:ss");
_body += Environment.NewLine;
_body += "Adjust Amount> " + pCustomerAcctPayment.Amount.ToString("c");
_body += Environment.NewLine;
_body += "Previous Balance> " + pCustomerAcctPayment.PreviousAmount.ToString("c");
_body += Environment.NewLine;
_body += "Current Balance> " + decimal.Add(pCustomerAcctPayment.PreviousAmount, pCustomerAcctPayment.Amount).ToString("c");
_body += Environment.NewLine;
_body += "Comments> " + pCustomerAcctPayment.Comments;
Email.SetForSending(Path.Combine(Configuration.Instance.Folders.EmailFolder, Guid.NewGuid().ToString("N")),
Configuration.Instance.Email.ClientFrom,
Configuration.Instance.Email.ClientTo,
string.Empty,
pContactInfo.Email,
Configuration.Instance.Email.ClientEmailServer,
Configuration.Instance.Email.ClientEmailPassword,
_subject,
_body);
TimokLogger.Instance.LogRbr(LogSeverity.Status, "CustomerAcctController.sendNotification", string.Format("Adjusted by: {0}\r\n{1} {2}", pPerson.Name, _subject, _body));
}
catch (Exception _ex) {
TimokLogger.Instance.LogRbr(LogSeverity.Critical, "CustomerAcctController.sendNotification", string.Format("Exception sending notification\r\n{0}", _ex));
}
}
public ActionResult PrivatePage(string login)
{
PartnerDto partnerDto = userSerivice.LogIn(login);
Session["session"] = partnerDto;
return(View(partnerDto));
}
public PartnerDto LogIn(string login)
{
Partners partner = partnersDAO.GetByLogin(login);
PartnerDto partnerDto = userMapper.GetPartnerDto(partner);
return(partnerDto);
}
//NOTE: Use Save() when calling directly, it will generate correct salt.
//NOTE: Add and Update should be used only by Replication on the remote side, so that they don't regenerate salt again !!!
public static void Update(string pSalt, PartnerDto pPartner)
{
using (Rbr_Db _db = new Rbr_Db()) {
using (Transaction _tx = new Transaction(_db, pSalt, pPartner)) {
PartnerDto _originalPartner = PartnerManager.Get(_db, pPartner.PartnerId);
ContactInfoManager.Update(_db, pPartner.ContactInfo);
//TODO: NEW DAL - handle Person deletion...
if (pPartner.Employees != null)
{
foreach (PersonDto _employee in pPartner.Employees)
{
_employee.PartnerId = pPartner.PartnerId;
PersonManager.Save(_db, pSalt, _employee);
}
}
if (pPartner.BillingSchedule != null)
{
ScheduleManager.Save(_db, pPartner.BillingSchedule);
}
else if (_originalPartner.BillingSchedule != null)
{
ScheduleManager.Delete(_db, _originalPartner.BillingSchedule.ScheduleId);
}
PartnerManager.Update(_db, pPartner);
_tx.Commit();
}
}
}
public async Task <int> Create(PartnerDto partnerDto)
{
var partner = new Partner()
{
Name = partnerDto.Name,
Country = partnerDto.Country,
City = partnerDto.City,
Address = partnerDto.Address,
EIK = partnerDto.EIK,
IsVatRegistered = partnerDto.IsVatRegistered,
VatId = partnerDto.VatId,
Email = partnerDto.Email,
IsActive = partnerDto.IsActive,
MOL = partnerDto.MOL,
};
var employee = new Employee()
{
FullName = partnerDto.MOL,
IsActive = true,
};
partner.Employees.Add(employee);
await partnerRepository.AddAsync(partner);
await partnerRepository.SaveChangesAsync();
return(partner.Id);
}
internal static PartnerRow MapToPartnerRow(PartnerDto pPartner)
{
if (pPartner == null)
{
return(null);
}
var _partnerRow = new PartnerRow();
_partnerRow.Partner_id = pPartner.PartnerId;
_partnerRow.Name = pPartner.Name;
_partnerRow.AccountStatus = pPartner.Status;
_partnerRow.Virtual_switch_id = pPartner.VirtualSwitchId;
if (pPartner.ContactInfo != null)
{
_partnerRow.Contact_info_id = pPartner.ContactInfo.ContactInfoId;
}
if (pPartner.BillingSchedule != null)
{
_partnerRow.Billing_schedule_id = pPartner.BillingSchedule.ScheduleId;
}
return(_partnerRow);
}
public async Task <IHttpActionResult> CreateAsync(PartnerDto partner)
{
_partnerRepository.Add(partner.Map <Partner>());
await UnitOfWork.CompleteAsync();
return(Created(new Uri(Request.RequestUri + "/" + partner.Id), partner));
}
public ActionResult MakeOrder()
{
PartnerDto partnerDto = (PartnerDto)Session["session"];
productService.MakeOrder(partnerDto);
partnerDto.ItemsId.Clear();
Session["session"] = partnerDto;
return(RedirectToAction("ProductList"));
}
internal static void Update(Rbr_Db pDb, PartnerDto pPartner)
{
validatePartner(pDb, pPartner);
PartnerRow _partnerRow = MapToPartnerRow(pPartner);
if (!pDb.PartnerCollection.Update(_partnerRow))
{
throw new Exception("Failed to update Partner; name:" + _partnerRow.Name);
}
}
public async Task <IActionResult> Create(PartnerDto partnerDto)
{
if (ModelState.IsValid)
{
var companyId = await partnerService.Create(partnerDto);
var companyName = partnerDto.Name;
return(RedirectToAction("ConfirmCreate", new { companyId = companyId, companyName = companyName }));
}
return(View());
}
internal static void Add(Rbr_Db pDb, PartnerDto pPartner)
{
//TODO: NEW DAL - VirtualSwitch
pPartner.VirtualSwitchId = AppConstants.DefaultVirtualSwitchId;
validatePartner(pDb, pPartner);
PartnerRow _partnerRow = MapToPartnerRow(pPartner);
pDb.PartnerCollection.Insert(_partnerRow);
pPartner.PartnerId = _partnerRow.Partner_id;
}
public IActionResult Put(int id, [FromBody] PartnerDto partnerDto)
{
if (partnerDto == null)
{
return(BadRequest("Partner is not specified correctly"));
}
if (string.IsNullOrWhiteSpace(partnerDto.Country))
{
return(BadRequest("Country is not specified correctly"));
}
if (id == 0)
{
return(BadRequest("To add a new partner, use POST request"));
}
partnerDto.Id = id;
if (!_partnerRepository.GetAll().Any(x => x.Id == id))
{
return(NotFound());
}
var partner = ToPartner(partnerDto);
var availableDates = ToAvailableDates(partnerDto, partner);
var validationResult = Validate(partner).ToArray();
if (validationResult.Any())
{
return(BadRequest(string.Join(Environment.NewLine, validationResult)));
}
_transactionFactory.InTransaction(() =>
{
if (partner.Country.Id == 0)
{
_countryRepository.Save(partner.Country);
}
var dates = _availableDateRepository.GetAll().Where(d => d.Partner.Id == partnerDto.Id).ToArray();
if (dates.Any())
{
_availableDateRepository.DeleteMany(dates);
}
_partnerRepository.Update(partner);
_availableDateRepository.SaveMany(availableDates);
});
return(Ok(ToPartnerDto(partner, availableDates)));
}
/// <summary>
/// IMPORTANT: !!! SALT MUST BE THE SAME ON ALL SERVERS !!!
/// IMPORTANT: !!! SALT MUST BE SET ONLY ONCE !!!
/// that's why it's set outside of the transaction, so we can replicate it to other servers
/// </summary>
/// <param name="pPartner"></param>
public static void Save(PartnerDto pPartner)
{
//ControllerHelper.SetSalt(pPartner.Employees);
string _salt = SaltHashedPwd.CreateRandomSalt();
if (pPartner.PartnerId == 0)
{
Add(_salt, pPartner);
}
else
{
Update(_salt, pPartner);
}
}
public async Task <IActionResult> Edit(PartnerDto partnerDto, int companyId, string companyName)
{
if (ModelState.IsValid)
{
await partnerSettingService.Edit(partnerDto);
this.ViewBag.companyId = companyId;
this.ViewBag.companyName = companyName;
return(RedirectToAction("Index", new { companyId = partnerDto.Id }));
}
this.ViewBag.companyId = companyId;
this.ViewBag.companyName = companyName;
return(View(partnerDto));
}
private AvailableDate[] ToAvailableDates(PartnerDto dto, Partner partner)
{
if (dto.AvailableDates == null)
{
return(null);
}
return(dto.AvailableDates
.Distinct()
.Select(d => new AvailableDate {
Partner = partner, Date = d.Date
})
.ToArray());
}
private Partner ToPartner(PartnerDto dto)
{
var partner = new Partner
{
Id = dto.Id,
Name = dto.Name,
Email = dto.Email,
Country = _countryRepository.GetAll().SingleOrDefault(c => c.Name == dto.Country.ToUpperInvariant()) ?? new Country {
Name = dto.Country.ToUpperInvariant()
}
};
return(partner);
}
//NOTE: Use Save() when calling directly, it will generate correct salt.
//NOTE: Add and Update should be used only by Replication on the remote side, so that they don't regenerate salt again !!!
public static void Add(string pSalt, PartnerDto pPartner)
{
using (Rbr_Db _db = new Rbr_Db()) {
using (Transaction _tx = new Transaction(_db, pSalt, pPartner)) {
try {
if (pPartner.ContactInfo.ContactInfoId == 0)
{
ContactInfoManager.Add(_db, pPartner.ContactInfo);
}
if (pPartner.BillingSchedule != null)
{
ScheduleManager.Save(_db, pPartner.BillingSchedule);
}
PartnerManager.Add(_db, pPartner);
if (pPartner.Employees != null)
{
foreach (PersonDto _employee in pPartner.Employees)
{
_employee.PartnerId = pPartner.PartnerId;
PersonManager.Save(_db, pSalt, _employee);
}
}
}
catch (Exception _ex) {
TimokLogger.Instance.LogRbr(LogSeverity.Error, "PartnerController.add", string.Format("Exception:\r\n{0}", _ex));
if (pPartner.ContactInfo != null)
{
pPartner.ContactInfo.ContactInfoId = 0;
}
if (pPartner.Employees != null)
{
foreach (PersonDto _employee in pPartner.Employees)
{
_employee.PersonId = 0;
}
}
if (pPartner.BillingSchedule != null)
{
pPartner.BillingSchedule.ScheduleId = 0;
}
throw;
}
_tx.Commit();
}
}
}
public async Task <IHttpActionResult> UpdateAsync(int id, PartnerDto partner)
{
var partnerInDb = await _partnerRepository.GetAsync(id);
if (partnerInDb == null)
{
return(NotFound());
}
_partnerRepository.Add(partner.Map <Partner>());
await UnitOfWork.CompleteAsync();
return(Ok());
}
/// <summary>
/// From Partner dto To Partner pivot.
/// </summary>
/// <param name="partnerDto">partner dto to assemble.</param>
/// <returns>Partnerpivot result.</returns>
public static PartnerPivot ToPivot(this PartnerDto partnerDto)
{
if (partnerDto == null)
{
return(null);
}
return(new PartnerPivot()
{
PartnerId = partnerDto.PartnerId,
PartnerImage = partnerDto.PartnerImage,
PartnerName = partnerDto.PartnerName,
PartnerLink = partnerDto.PartnerLink,
PartnerPosition = partnerDto.PartnerPosition,
});
}
public async Task <DResult <OrganizationDto> > CorrelateOrganization([FromBody] PartnerDto partnerDto)
{
try
{
OrganizationDto organization = businessOrganization.CorrelateOrganization(partnerDto);
if (organization == null)
{
return(DResult.Error <OrganizationDto>("未找到该机构", 501));
}
return(DResult.Succ(organization));
}
catch (Exception ex) {
Logger.Error(ex.ToString());
return(DResult.Error <OrganizationDto>(ex.Message, 500));
}
}
public async Task <ActionResult> Post([FromBody] PartnerDto itemDto)
{
if (itemDto == null)
{
return(await Task.Run(() => BadRequest()));
}
itemDto.Created = DateTime.Now;
var item = _mapper.Map <Partner>(itemDto);
_context.Partners.Add(item);
_context.SaveChanges();
itemDto = _mapper.Map <PartnerDto>(item);
return(await Task.Run(() => new ObjectResult(itemDto)));
}
public static void Credit(PersonDto pPerson, CustomerAcctPaymentDto pCustomerAcctPayment)
{
using (var _db = new Rbr_Db()) {
using (var _tx = new Transaction(_db, pPerson, pCustomerAcctPayment)) {
pCustomerAcctPayment.DateTime = DateTime.Now;
//NOTE: make sure we got prev amnt
CustomerAcctRow _customerAcctRow = CustomerAcctManager.Get(_db, pCustomerAcctPayment.CustomerAcctId);
pCustomerAcctPayment.PreviousAmount = _customerAcctRow.Current_amount;
pCustomerAcctPayment.Person = pPerson;
CustomerAcctManager.Credit(_db, pCustomerAcctPayment);
_tx.Commit();
PartnerDto _partner = PartnerManager.Get(_db, _customerAcctRow.Partner_id);
ContactInfoDto _contactInfo = ContactInfoManager.Get(_db, _partner.ContactInfo.ContactInfoId);
sendNotification(pPerson, pCustomerAcctPayment, _customerAcctRow, _partner, _contactInfo);
}
}
}
public IActionResult Post([FromBody] PartnerDto partnerDto)
{
if (partnerDto == null)
{
return(BadRequest("Partner is not specified correctly"));
}
if (string.IsNullOrWhiteSpace(partnerDto.Country))
{
return(BadRequest("Country is not specified correctly"));
}
if (partnerDto.Id != 0)
{
return(BadRequest("To update an existing partner, use PUT request"));
}
var partner = ToPartner(partnerDto);
var validationResult = Validate(partner).ToArray();
if (validationResult.Any())
{
return(BadRequest(string.Join(Environment.NewLine, validationResult)));
}
var availableDates = ToAvailableDates(partnerDto, partner);
_transactionFactory.InTransaction(() => {
if (partner.Country.Id == 0)
{
_countryRepository.Save(partner.Country);
}
_partnerRepository.Save(partner);
if (availableDates != null && availableDates.Any())
{
_availableDateRepository.SaveMany(availableDates);
}
});
return(Ok(ToPartnerDto(partner, availableDates)));
}
