public virtual ActionResult SetShippingCharges(ShippingChargeCollectionViewModel model)
{
model.Save(DbFactory, Time.GetAppNowTime(), AccessManager.UserId);
return(JsonGet(new MessagesResult()
{
IsSuccess = true,
Messages = new List <MessageString>()
{
MessageString.Success("Succefully updated")
}
}));
}
public virtual ActionResult Create(OrderNewViewModel model)
{
LogI("Submit, model=" + model);
//model.PrepareData();
//Save
if (ModelState.IsValid)
{
IList <MessageString> messages;
if (model.IsValid(Db, out messages))
{
model.Create(LogService,
Time,
QuantityManager,
DbFactory,
WeightService,
ShippingService,
AutoCreateListingService,
Settings,
EmailService,
ActionService,
HtmlScraper,
OrderHistoryService,
PriceService,
AccessManager.Company,
Time.GetAppNowTime(),
AccessManager.UserId);
return(Json(model));
}
else
{
messages.ForEach(m => ModelState.AddModelError("model", m.Message));
}
//var rand = new Random();
//model.OrderNumber = (20000 + rand.Next(1, 100)).ToString();
model.Messages.Add(MessageString.Success("Order has been successfully created. Order #: " + model.OrderNumber));
return(Json(model));
}
return(PartialView(PopupContentView, model));
}
public CallMessagesResultVoid CheckConnection()
{
try
{
FtpClient client = new FtpClient(FtpSite);
if (!String.IsNullOrEmpty(UserName))
{
client.Credentials = new NetworkCredential(UserName, Password);
}
client.Connect();
return(new CallMessagesResultVoid()
{
Status = CallStatus.Success,
Messages = new List <MessageString>()
{
MessageString.Success("Successfully connected")
}
});
}
catch (Exception ex)
{
return(CallMessagesResultVoid.Fail(ex.Message, null));
}
}
public void Create(ILogService log,
ITime time,
IQuantityManager quantityManager,
IDbFactory dbFactory,
IWeightService weightService,
IShippingService shippingService,
IAutoCreateListingService createListingService,
ISettingsService settingService,
IEmailService emailService,
ISystemActionService actionService,
IHtmlScraperService htmlScraper,
IOrderHistoryService orderHistory,
IPriceService priceService,
CompanyDTO company,
DateTime when,
long?by)
{
var syncInfo = new EmptySyncInformer(log, SyncType.Orders);
var market = (int)MarketType.OfflineOrders;
var marketplaceId = MarketplaceKeeper.ManuallyCreated;
var orderItems = new List <ListingOrderDTO>();
using (var db = dbFactory.GetRWDb())
{
var index = 1;
foreach (var item in Items)
{
var dbItem = db.Items.GetAll().FirstOrDefault(i => i.Market == market &&
i.MarketplaceId == marketplaceId &&
i.StyleItemId == item.StyleItemId);
if (dbItem == null)
{
var itemPrice = item.ItemPrice; // db.Items.GetAllViewActual()
//.FirstOrDefault(i => i.Market == (int)MarketType.Amazon
// && i.MarketplaceId == MarketplaceKeeper.AmazonComMarketplaceId)?.CurrentPrice;
log.Info("Request create listing, market=" + market
+ ", marketplaceId=" + marketplaceId);
IList <MessageString> messages = new List <MessageString>();
//Create New
var model = createListingService.CreateFromStyle(db,
item.StyleId.Value,
(MarketType)market,
marketplaceId,
out messages);
model.Variations.ForEach(v => v.CurrentPrice = itemPrice);
createListingService.Save(model,
"",
db,
when,
by);
dbItem = db.Items.GetAll().FirstOrDefault(i => i.Market == market &&
i.MarketplaceId == marketplaceId &&
i.StyleItemId == item.StyleItemId);
}
var dbListing = db.Listings.GetAll().FirstOrDefault(l => l.Market == market &&
l.MarketplaceId == marketplaceId &&
l.ItemId == dbItem.Id);
orderItems.Add(new ListingOrderDTO()
{
ASIN = dbItem.ASIN,
SKU = dbListing.SKU,
ItemPaid = item.ItemPrice,
ItemPrice = item.ItemPrice,
ItemGrandPrice = item.ItemPrice,
StyleId = dbItem.StyleId,
StyleID = dbItem.StyleString,
StyleItemId = dbItem.StyleItemId,
Market = dbItem.Market,
MarketplaceId = dbItem.MarketplaceId,
QuantityOrdered = item.Quantity,
ItemOrderId = index.ToString(),
SourceListingId = dbListing.Id,
});
index++;
}
OrderNumber = db.Orders.GetAll()
.Where(o => o.Market == (int)market &&
o.MarketplaceId == marketplaceId)
.OrderByDescending(o => o.Id).FirstOrDefault()?.AmazonIdentifier;
if (String.IsNullOrEmpty(OrderNumber))
{
OrderNumber = "1000";
}
else
{
OrderNumber = ((StringHelper.TryGetInt(OrderNumber) ?? 1000) + 1).ToString();
}
}
var dtoOrder = new DTOOrder()
{
Market = market,
MarketplaceId = marketplaceId,
OrderDate = OrderDate,
OrderStatus = "Unshipped",
SourceOrderStatus = "Unshipped",
OrderId = OrderNumber,
CustomerOrderId = OrderNumber,
MarketOrderId = OrderNumber,
AmazonEmail = ToAddress.Email,
BuyerEmail = ToAddress.Email,
PersonName = ToAddress.FullName,
BuyerName = ToAddress.FullName,
ShippingAddress1 = ToAddress.Address1,
ShippingAddress2 = ToAddress.Address2,
ShippingCity = ToAddress.City,
ShippingCountry = ToAddress.Country,
ShippingZip = ToAddress.Zip,
ShippingZipAddon = ToAddress.ZipAddon,
ShippingPhone = ToAddress.Phone,
ShippingState = StringHelper.GetFirstNotEmpty(ToAddress.USAState, ToAddress.NonUSAState),
ShippingPaid = 0,
ShippingPrice = 0,
TotalPaid = Items.Sum(i => i.ItemPrice),
TotalPrice = Items.Sum(i => i.ItemPrice),
Quantity = Items.Sum(i => i.Quantity),
InitialServiceType = ShippingService,
ShippingService = ShippingService,
SourceShippingService = ShippingService,
Items = orderItems,
};
var userOrderApi = new UserOrderApi(new List <DTOOrder>()
{
dtoOrder
});
var serviceFactory = new ServiceFactory();
var addressCheckServices = serviceFactory.GetAddressCheckServices(log,
time,
dbFactory,
company.AddressProviderInfoList);
var companyAddress = new CompanyAddressService(company);
var addressService = new AddressService(addressCheckServices, companyAddress.GetReturnAddress(MarketIdentifier.Empty()), companyAddress.GetPickupAddress(MarketIdentifier.Empty()));
var rateProviders = serviceFactory.GetShipmentProviders(log,
time,
dbFactory,
weightService,
company.ShipmentProviderInfoList,
null,
null,
null,
null);
var stampsRateProvider = rateProviders.FirstOrDefault(r => r.Type == ShipmentProviderType.Stamps);
var validatorService = new OrderValidatorService(log, dbFactory, emailService, settingService, orderHistory, actionService,
priceService, htmlScraper, addressService, companyAddress.GetReturnAddress(MarketIdentifier.Empty()), stampsRateProvider, time, company);
var orderHistoryService = new OrderHistoryService(log, time, dbFactory);
var cacheService = new CacheService(log, time, actionService, quantityManager);
using (var db = dbFactory.GetRWDb())
{
try
{
var orderSyncFactory = new OrderSyncFactory();
var synchronizer = orderSyncFactory.GetForMarket(userOrderApi,
log,
company,
settingService,
syncInfo,
rateProviders,
quantityManager,
emailService,
validatorService,
orderHistoryService,
cacheService,
actionService,
companyAddress,
time,
weightService,
null);
if (!String.IsNullOrEmpty(OrderNumber))
{
synchronizer.ProcessSpecifiedOrder(db, OrderNumber);
Messages.Add(MessageString.Success("The order has been successfully created, order #: " + OrderNumber));
}
}
catch (Exception ex)
{
Messages.Add(MessageString.Error(ex.Message));
}
}
}
public MessagesResult Success(string message)
{
Messages.Add(MessageString.Success(message));
return(this);
}
public static IList <MessageString> CancelCurrentOrderLabels(
ILogService log,
IUnitOfWork db,
ILabelService labelService,
ITime time,
long orderId,
bool sampleMode)
{
var cancelTrackings = GetOrdersToCancel(db, orderId);
var results = new List <MessageString>();
foreach (var tracking in cancelTrackings)
{
MailLabelInfo mailInfo = null;
OrderShippingInfo shippingInfo = null;
if (tracking.LabelFromType == (int)LabelFromType.Mail)
{
mailInfo = db.MailLabelInfos.Get(tracking.Id);
if (mailInfo != null)
{
mailInfo.CancelLabelRequested = true;
}
}
else
{
shippingInfo = db.OrderShippingInfos.Get(tracking.Id);
if (shippingInfo != null)
{
shippingInfo.CancelLabelRequested = true;
}
}
try
{
string shipmentIdentifier = tracking.StampsTxId;
if (tracking.ShipmentProviderType == (int)ShipmentProviderType.Stamps ||
tracking.ShipmentProviderType == (int)ShipmentProviderType.StampsPriority)
{
shipmentIdentifier = tracking.TrackingNumber;
}
var result = labelService.CancelLabel((ShipmentProviderType)tracking.ShipmentProviderType,
shipmentIdentifier,
sampleMode);
if (result.IsSuccess)
{
results.Add(MessageString.Success(tracking.TrackingNumber + " (cancelled)" + ", OrderId=" + orderId));
if (tracking.LabelFromType == (int)LabelFromType.Mail)
{
if (mailInfo != null)
{
mailInfo.LabelCanceled = true;
mailInfo.LabelCanceledDate = time.GetAppNowTime();
}
}
else
{
if (shippingInfo != null)
{
shippingInfo.LabelCanceled = true;
shippingInfo.LabelCanceledDate = time.GetAppNowTime();
}
}
}
else
{
results.Add(MessageString.Error(tracking.TrackingNumber + " (cancellation was failed with error: " + result.Message + ")"));
}
}
catch (Exception ex)
{
results.Add(MessageString.Error(tracking.TrackingNumber + " (cancellation was failed with error: " + ExceptionHelper.GetMostDeeperException(ex) + ")"));
}
}
db.Commit();
if (!cancelTrackings.Any())
{
results.Add(MessageString.Success("No tracking numbers to cancel"));
}
return(results);
}
public IList <MessageString> Generate(ILogService log,
ITime time,
ILabelService labelService,
IQuantityManager quantityManager,
IUnitOfWork db,
IWeightService weightService,
IShippingService shippingService,
bool sampleMode,
DateTime when,
long?by)
{
var results = new List <MessageString>();
//Cancel privious
if (CancelCurrentOrderLabel)
{
var cancelResults = CancelCurrentOrderLabels(log,
db,
labelService,
time,
OrderEntityId.Value,
sampleMode);
results.AddRange(cancelResults);
}
//Print new
var printResult = GenerateLabel(db,
labelService,
weightService,
shippingService,
this,
time.GetAppNowTime(),
by);
if (printResult.Success)
{
//Remove from batch if unshipped
var wasRemoved = RemoveFromBatchIfUnshipped(log,
db,
OrderEntityId.Value);
if (wasRemoved)
{
results.Add(MessageString.Success("Order was removed from batch"));
}
}
//Processing print result
Messages.AddRange(printResult.Messages.Select(m => MessageString.Error(m.Text)).ToList());
IsPrinted = printResult.Success;
PrintedLabelPath = printResult.Url;
PrintedLabelUrl = UrlHelper.GetPrintLabelPathById(printResult.PrintPackId);
PrintedTrackingNumber = printResult.TrackingNumber;
if (ReduceInventory)
{
AddQuantityOperation(log,
db,
quantityManager,
OrderID,
Items.Select(i => i.GetItemDto()).ToList(),
time,
by);
results.Add(MessageString.Success("Inventory quantity was adjusted"));
}
//Add to track table
if (ReasonCode == (int)MailLabelReasonCodes.ReturnLabelReasonCode)
{
AddToOrderTracking(log,
db,
OrderID,
printResult.TrackingNumber,
printResult.Carrier,
when,
by);
results.Add(MessageString.Success("Tracking number was added to Track Orders list"));
}
if (OrderEntityId.HasValue &&
!String.IsNullOrEmpty(OrderComment))
{
db.OrderComments.Add(new OrderComment()
{
OrderId = OrderEntityId.Value,
Message = OrderComment, // "[System] Returned",
Type = (int)CommentType.ReturnExchange,
CreateDate = when,
CreatedBy = by
});
db.Commit();
results.Add(MessageString.Success("Comment was added"));
}
if (printResult.Success && !string.IsNullOrEmpty(printResult.Url))
{
log.Info(string.Format("LabelPath for {0} order: {1}",
string.IsNullOrEmpty(OrderID) ? "Ebay" : OrderID, printResult.Url));
}
if (printResult.Success && UpdateAmazon)
{
results.Add(MessageString.Success("Send the order update to the market was scheduled"));
}
return(results);
}
