public async Task <IActionResult> OrderStatusReport()
{
var model = new OrderStatusModel();
model.AvailableVendor.Add(new SelectListItem {
Text = "All", Value = "0"
});
foreach (var item in (await _financialDataService.GetVendorUsage((int)_workContext.CurrentCustomer.ClientId)))
{
model.AvailableVendor.Add(new SelectListItem {
Text = item.HVendorName, Value = item.HVendorName
});
}
model.AvailableCostCenter.Add(new SelectListItem {
Text = "All", Value = "0"
});
foreach (var item in (await _financialDataService.GetCostCenterList((int)_workContext.CurrentCustomer.ClientId)))
{
model.AvailableCostCenter.Add(new SelectListItem {
Text = item.SName, Value = item.ShipID
});
}
return(View(model));
}
public void when_handling_item_added()
{
var orderStatusBuilder = new OrderStatusModelHandler();
var model = new OrderStatusModel() { Created = new DateTime(2013, 06, 21), LastChange = new DateTime(2013, 06, 21) , Status = Status.New};
var eventContext = new EventContext()
{
Event = new ItemAddedToOrder() { OrderId = OrderId, ProductId = Guid.NewGuid() },
EventNumber = 2,
Headers =
new Dictionary<string, object>()
{
{
"_Timestamp",
new DateTime(2013, 06, 24,
13, 37, 42,
18)
}
}
};
var lastEvent = orderStatusBuilder.HandleAll(ref model, new[] { eventContext });
model.ShouldNotBeNull();
model.LastChange.ShouldEqual(new DateTime(2013, 06, 24, 13, 37, 42, 18));
lastEvent.ShouldEqual(2);
}
public List <OrderStatusModel> GetOrderStatus(string urlApi, int idOrder)
{
urlApi += $"Estados/ConsultarEstadosOrden?idOrden={idOrder}";
string response = RequestGet(urlApi);
var json = JsonConvert.DeserializeObject <Response <List <EstadoOrdenEntity> > >(response);
List <OrderStatusModel> lista = new List <OrderStatusModel>();
if (json.Data != null)
{
json.Data.ForEach(est =>
{
OrderStatusModel registro = new OrderStatusModel
{
Comments = est.Comentario,
StatusProperty = new StatusModel
{
StatusId = est.IdEstado.ToString(),
Description = est.Comentario
},
Update = est.FechaActualizacion
};
lista.Add(registro);
});
}
return(lista);
}
public IActionResult OrderTrack(TrackOrderModel modelIn)
{
var orderServices = new OrderServices(); //methods
var orderDateServices = new OrderDataServices(); //database
bool emailValidation = orderServices.IsEmailValid(modelIn.EmailAddress);
if (emailValidation == false)
{
ModelState.AddModelError(string.Empty, "Invalid Email");
}
bool orderNumberValidation = orderServices.IsOrderNumberValid(modelIn.OrderNumber);
if (orderNumberValidation == false)
{
ModelState.AddModelError(string.Empty, "Invalid Order Number");
}
if (emailValidation == false || orderNumberValidation == false)
{
return(View(modelIn));
}
string orderStatus = orderServices.GetOrderDetails(modelIn.EmailAddress, modelIn.OrderNumber, orderDateServices);
OrderStatusModel orderStatusModel = new OrderStatusModel();
orderStatusModel.OrderStatus = orderStatus;
return(View("OrderStatus", orderStatusModel));
}
public async Task <IActionResult> PutOrderStatus(int id, OrderStatusModel orderStatus)
{
if (id != orderStatus.OrderStatusId)
{
return(BadRequest());
}
try
{
await orderStatusService.PutOrderStatus(id, orderStatus);
}
catch (DbUpdateConcurrencyException)
{
if (!orderStatusService.OrderStatusExists(id).Result)
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task PostOrderStatus(OrderStatusModel orderStatus)
{
context.OrderStatus.Add(new OrderStatus
{
OrderStatusId = orderStatus.OrderStatusId,
Name = orderStatus.Name
});
await context.SaveChangesAsync();
}
public async Task PutOrderStatus(int id, OrderStatusModel orderStatus)
{
context.Entry(new OrderStatus
{
OrderStatusId = orderStatus.OrderStatusId,
Name = orderStatus.Name
}).State = EntityState.Modified;
await context.SaveChangesAsync();
}
public IActionResult UpdateOrdersStatus(OrderStatusModel orderStatus)
{
using (var scope = new TransactionScope())
{
_orderRepository.UpdateOrder(orderStatus.Id, orderStatus.StatusCode);
scope.Complete();
return(Ok());
}
}
public static OrderStatus ToDomain(this OrderStatusModel model, OrderStatus domain)
{
if (model != null)
{
domain.Id = model.Id;
domain.Status = model.Status;
}
return(domain);
}
public IActionResult AddOrderStatus(OrderStatusModel orderStatus)
{
if (dbAccessor.AddOrderStatus(orderStatus) == 1)
{
return(Ok());
}
else
{
return(BadRequest());
}
}
public IHttpActionResult Post(Guid orderId, string orderStatus)
{
var orderStatusModel = new OrderStatusModel
{
OrderId = orderId,
OrderStatus = orderStatus
};
UpdateOrder(orderStatusModel);
return(Ok("Sipariş statüsü alındı... OrderId : " + orderId + " OrderStatus : " + orderStatus));
}
public IActionResult UpdateOrderStatus(int orderStatusID, OrderStatusModel orderStatus)
{
if (dbAccessor.UpdateOrderStatus(orderStatusID, orderStatus) == 1)
{
return(Ok());
}
else
{
return(BadRequest());
}
}
public Task PrepareModelAsync(OrderStatusModel model, Order order)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
model = _mapper.Map(order, model);
return(Task.CompletedTask);
}
private static OrderStatusModel getStatusModelObjectFromDataRow(DataRow dtRow)
{
OrderStatusModel os = new OrderStatusModel()
{
Id = dtRow.ToInt("Id"),
Name = System.Convert.ToString(dtRow["Name"]),
AppName = System.Convert.ToString(dtRow["AppName"]),
Description = System.Convert.ToString(dtRow["Description"])
};
return(os);
}
public static OrderStatusModel ToModel(this OrderStatus domain)
{
var model = new OrderStatusModel();
if (domain != null)
{
model.Id = domain.Id;
model.Status = domain.Status;
}
return(model);
}
public static OrderStatus ToDomain(this OrderStatusModel model)
{
var domain = new OrderStatus();
if (model != null)
{
domain.Id = model.Id;
domain.Status = model.Status;
}
return(domain);
}
public async Task <IHttpActionResult> Update([FromBody] OrderStatusModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var entity = await OrderService.FindOneAsync(model.Id);
entity.OrderStatusId = model.OrderStatusId;
await OrderService.UpdateAsync(entity);
return(Ok(entity.ToModel()));
}
// GET: api/OrderStatus
public IEnumerable <OrderStatusModel> GetOrderStatuses()
{
List <OrderStatusModel> statusList = new List <OrderStatusModel>();
var config = new MapperConfiguration(cfg => cfg.CreateMap <OrderStatus, OrderStatusModel>());
var mapper = config.CreateMapper();
foreach (var status in db.OrderStatuses)
{
OrderStatusModel model = mapper.Map <OrderStatusModel>(status);
statusList.Add(model);
}
return(statusList);
}
public virtual ActionResult Modify(OrderStatusModel model)
{
if (model == null)
{
return(null);
}
var entity = model.CreateEntity(SaveType.Modify);
var result = new Dictionary <string, object>();
var rev = this.SaveEntity(entity);
var mess = rev ? "" : entity.Errors?.FirstOrDefault()?.Message;
result.Add("Status", rev);
result.Add("Message", mess);
return(this.Jsonp(result));
}
public virtual ActionResult Get(long id)
{
var entity = this.GetEntity <OrderStatusEntity>(id);
if (entity == null)
{
return(null);
}
var model = new OrderStatusModel
{
Id = entity.Id.ToString(),
Name = entity.Name
};
return(this.Jsonp(model));
}
public async Task <IActionResult> Update(OrderStatusModel model)
{
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
var status = await _orderStatusService.GetById(model.Id);
status = model.ToEntity(status);
await _orderStatusService.Update(status);
return(new JsonResult(""));
}
public async Task <IList <OrderStatus> > GetOrderStatus(OrderStatusModel model)
{
SqlParameter[] pr = new SqlParameter[]
{
new SqlParameter("@DateStart", model.DateStart),
new SqlParameter("@DateEnd", model.DateEnd),
new SqlParameter("@intClientID", (int)_workContext.CurrentCustomer.ClientId),
new SqlParameter("@intSelect", model.intSelect),
new SqlParameter("@txtShipID", model.txtShipID),
new SqlParameter("@strVendor", model.strVendor)
};
var result = await _dbContext.Set <OrderStatus>().FromSqlRaw("exec OrderStatus @DateStart,@DateEnd,@intClientID,@intSelect,@txtShipID,@strVendor", pr).ToListAsync();
return(result);
}
public async Task <IActionResult> Add(OrderStatusModel model)
{
if (!ModelState.IsValid)
{
return(Json(new DataSourceResult {
Errors = ModelState.SerializeErrors()
}));
}
var status = new OrderStatus();
status = model.ToEntity(status);
status.StatusId = (await _orderStatusService.GetAll()).Max(x => x.StatusId) + 10;
await _orderStatusService.Insert(status);
return(new JsonResult(""));
}
public async Task <IActionResult> OrderStatusReport(OrderStatusModel model)
{
if (ModelState.IsValid)
{
var status = await _transactionReports.GetOrderStatus(model);
foreach (var item in status)
{
model.OrderStatusList.Add(new OrderStatus
{
HclientId = item.HclientId,
Day = item.Day,
Month = item.Month,
Year = item.Year,
HshipId = item.HshipId,
HshipName = item.HshipName,
Hpo = item.Hpo,
Hoitem = item.Hoitem,
Huom = item.Huom,
Hqty = item.Hqty,
Hdescription = item.Hdescription,
TotalOrderPrice = item.TotalOrderPrice,
Hgl = item.Hgl,
HvendorName = item.HvendorName,
Hstatus = item.Hstatus,
HistoryId = item.HistoryId
});
}
}
model.AvailableVendor.Add(new SelectListItem {
Text = "All", Value = "0"
});
foreach (var item in (await _transactionReports.GetVendorClients((int)_workContext.CurrentCustomer.ClientId)))
{
model.AvailableVendor.Add(new Microsoft.AspNetCore.Mvc.Rendering.SelectListItem
{
Text = item.VName,
Value = item.VName
});
}
return(View(model));
}
public virtual async Task <IHttpActionResult> Post(OrderStatusModel orderStatusModel)
{
try
{
var createUser = await _orderStatusServices.createOrderAsync(orderStatusModel);
return(Ok(ResponseUtil.GetResponse(true, createUser, null)));
}
catch (Exception ex)
{
var response = new FailureResponse()
{
Message = Messages.FAILURE_MESSAGE_CREATESALESUSER,
StatusCode = 400
};
return(Content(HttpStatusCode.BadRequest, ResponseUtil.GetResponse(false, null, response)));
}
}
public bool GetOrderIsComplete(string orderNumber)
{
string url = "https://api.bittrex.com/api/v1.1/account/getorder?uuid=" + orderNumber + "&apikey=" + _key + "&nonce=" + GetNonce();
HttpResponseModel result = CallSignedApi(url);
if (result.Successfull)
{
try
{
OrderStatusModel objectResponse = JsonConvert.DeserializeObject <OrderStatusModel>(result.ResponseString);
return(objectResponse.result[0].Closed != null);
}
catch
{
OrderStatusModel2 objectResponse = JsonConvert.DeserializeObject <OrderStatusModel2>(result.ResponseString);
return(objectResponse.result.Closed != null);
}
}
return(false);
}
public (ResultCode, QueryModel) Query(OrderStatusQueryRequest filter)
{
QueryModel queryResult = new QueryModel();
List <OrderStatusQueryDTO> orderStatusDTOs = _procedureHelper.GetData <OrderStatusQueryDTO>(
"order_status_table_query", filter);
if (0 != orderStatusDTOs.Count)
{
queryResult.TotalRows = orderStatusDTOs[0].TotalRows;
}
List <OrderStatusModel> orderStatuses = new List <OrderStatusModel>();
foreach (var item in orderStatusDTOs)
{
OrderStatusModel orderStatus = new OrderStatusModel(item);
orderStatuses.Add(orderStatus);
}
queryResult.Items = orderStatuses;
return(ResultCode.SUCCESS, queryResult);
}
public async Task <IActionResult> GetOrderStatusNewCard([FromQuery] string orderId)
{
int id = Int32.Parse(User.Claims.First(c => c.Type == "UserId").Value);
try
{
OrderStatusModel orderStatus = await PaymentManager.GetOrderStatus(orderId);
Uri domain = new Uri(Request.GetDisplayUrl());
Uri uri = new Uri(domain.Scheme + "://" + domain.Host + (domain.IsDefaultPort ? "" : ":" + domain.Port));
host = uri.ToString();
orderStatus.Date = DateTime.Now.ToString();
CardManager.AddCard(orderStatus.BindingInfo.BindingId);
return(Ok());
}
catch
{
return(BadRequest());
}
}
public void SendOrderStatusChangedMail(int orderId, int oldStatusId, int newStatusId)
{
if (oldStatusId == newStatusId)
{
return;
}
HostingEnvironmentPolyfills.QueueBackgroundWorkItemPf(async ct =>
{
OrdersProvider ordersProvider = new OrdersProvider();
Task <OrderStatusModel> getNewStatusTask = ordersProvider.GetStatus(newStatusId);
Task <OrderStatusModel> getOldStatusTask = ordersProvider.GetStatus(oldStatusId);
OrderStatusChangedEmailModel emailModel = new OrderStatusChangedEmailModel();
emailModel.OrderNumber = orderId;
SimpleOrderModel orderModel = await ordersProvider.GetOrder(orderId);
string toEmailAddress;
using (ApplicationDbContext appContext = new ApplicationDbContext())
{
string userId = orderModel.UserId.ToString();
Address userAddress = await appContext.AddressInfos.FirstOrDefaultAsync(a => a.UserId == userId);
emailModel.FullName = string.Format("{0} {1} {2}", userAddress.FirstName, userAddress.MiddleName, userAddress.LastName);
toEmailAddress = userAddress.Email;
}
emailModel.BaseUrl = ConfigurationManager.AppSettings["Site.BaseUrl"];
OrderStatusModel newOrderStatus = await getNewStatusTask;
OrderStatusModel oldOrderStatus = await getOldStatusTask;
emailModel.NewOrderStatus = newOrderStatus.Name;
emailModel.OldOrderStatus = oldOrderStatus.Name;
string emailContent = templateEngine.RenderTemplate("OrderStatusChanged", emailModel);
await this.mailSender.SendEmail(toEmailAddress, string.Format("{0}: Статусът на поръчка #{1} беше променен", emailModel.BaseUrl, orderId), emailContent);
});
}
private IEnumerable <OrderModel> GetUserModelsByItems(
IEnumerable <OrderEntity> orders,
IEnumerable <MarketplaceItemEntity> items,
IEnumerable <UserEntity> users)
{
var orderModels = orders.Select(order =>
{
var orderStatus = OrderStatusModel.ToDomainModel(
_orderStatusRepository.Value.GetStatusById((int)order.StatusId));
var itemModel = MarketplaceItemModel.ToDomainModel(
items.First(item => item.Id == order.ItemId));
var recipients = users.FirstOrDefault(user => user.Id == order.BuyerId);
var recipientsModel = recipients == null ? null : UserModel.ToDomainModel(recipients);
return(new OrderModel(order.Id, orderStatus, order.OrderTime, itemModel, recipientsModel));
});
return(orderModels);
}
public static void AddActivity(OrderStatusModel orderStatus, int id)
{
Activity activity = new Activity
{
ServiceName = "Payment",
Amount = Convert.ToDouble(orderStatus.Amount) / 100,
Fee = 0,
Rrn = orderStatus.AuthRefNum,
Date = Convert.ToDateTime(orderStatus.Date),
CardNumber = orderStatus.CardAuthInfo.Pan,
OrderId = orderStatus.OrderNumber,
Customer = orderStatus.CardAuthInfo.CardHolderName,
Description = "Payment",
};
User user = UserManager.GetUserById(id);
using (MySqlConnection conn = new MySqlConnection(ConnectionString.Build()))
{
conn.Open();
using (MySqlCommand cmd = new MySqlCommand())
{
cmd.Connection = conn;
cmd.CommandText = @"INSERT INTO activities (service_name,amount,order_id,fee,total,rrn,customer_id,customer,address,description,card_number,date)
VALUES(@service_name,@amount,@order_id,@fee,@total,@rrn,@customer_id,@customer,@address,@description,@card_number,@date)";
cmd.Parameters.AddWithValue("@service_name", activity.ServiceName);
cmd.Parameters.AddWithValue("@amount", activity.Amount);
cmd.Parameters.AddWithValue("order_id", activity.OrderId);
cmd.Parameters.AddWithValue("@fee", activity.Fee);
cmd.Parameters.AddWithValue("@total", activity.Total);
cmd.Parameters.AddWithValue("@rrn", activity.Rrn);
cmd.Parameters.AddWithValue("@card_number", activity.CardNumber);
cmd.Parameters.AddWithValue("@customer_id", user.Id);
cmd.Parameters.AddWithValue("@customer", activity.Customer);
cmd.Parameters.AddWithValue("@address", user.Address.Id);
cmd.Parameters.AddWithValue("@description", activity.Description);
cmd.Parameters.AddWithValue("@date", activity.Date);
cmd.ExecuteNonQuery();
}
}
}
