public ActionResult ConfirmBooking()
{
var bookedEventIds = Session["cart"] as List <int>;
if (bookedEventIds != null)
{
foreach (var id in bookedEventIds)
{
var booking = new Booking {
EventId = id,
UserId = User.Identity.GetUserId(),
BookingStatus = EventStatus.Create.ToString(),
BookingDate = DateTime.Now
};
db.Bookings.Add(booking);
db.SaveChanges();
//Keep EquipmentId into Booking table, we will not allow booking equipment without Event booked first.
//The record of Event booking should be with EquipmentId = null,
// then every equipment booking should have new record with EventId been set.
var eventTrack = new EventTracking
{
BookingId = booking.Id,
EventId = id,
CustomerId = User.Identity.GetUserId(),
EventStatus = (byte)EventStatus.Create,
Date = DateTime.Now
};
db.EventTrackings.Add(eventTrack);
}
}
db.SaveChanges();
return(View());
}
public async Task <TrackingResult> TrackEventAsync(EventTracking eventTracking)
{
SetRequired(eventTracking);
var parameters = GetParametersDictionary(eventTracking);
return(await RequestUrlAsync(UseSsl?BeaconUrlSsl : BeaconUrl, parameters, eventTracking.UserAgent ?? UserAgent));
}
public ActionResult UpdateEventProgress(ProgressDetail details)
{
var track = new EventTracking {
CustomerId = User.Identity.GetUserId(), EventId = details.Id, EventStatus = details.EventStatus, Date = DateTime.Now
};
db.EventTrackings.Add(track);
db.SaveChanges();
return(View(GetProgressDetail(details.Id)));
}
internal static void InitializeIfNeeded()
{
if (sIsInitialized)
{
return;
}
sIsInitialized = true;
PlasticAPI = new PlasticAPI();
PlasticWebRestApi = new PlasticWebRestApi();
ConfigureLogging();
GuiMessage.Initialize(new UnityPlasticGuiMessage());
RegisterExceptionHandlers();
InitLocalization();
ThreadWaiter.Initialize(new UnityThreadWaiterBuilder());
ServicePointConfigurator.ConfigureServicePoint();
CertificateUi.RegisterHandler(new ChannelCertificateUiImpl());
SetupFsWatcher();
EditionManager.Get().DisableCapability(
EnumEditionCapabilities.Extensions);
ClientHandlers.Register();
PlasticGuiConfig.SetConfigFile(
PlasticGuiConfig.UNITY_GUI_CONFIG_FILE);
sEventSenderScheduler = EventTracking.Configure(
PlasticApp.PlasticWebRestApi,
AssetsPath.IsRunningAsUPMPackage() ?
ApplicationIdentifier.UnityPackage :
ApplicationIdentifier.UnityAssetStorePlugin,
IdentifyEventPlatform.Get());
if (sEventSenderScheduler != null)
{
sPingEventLoop = new PingEventLoop();
sPingEventLoop.Start();
sPingEventLoop.SetUnityVersion(Application.unityVersion);
CollabPlugin.GetVersion(pluginVersion => sPingEventLoop.SetPluginVersion(pluginVersion));
}
PlasticMethodExceptionHandling.InitializeAskCredentialsUi(
new CredentialsUiImpl());
ClientEncryptionServiceProvider.SetEncryptionPasswordProvider(
new MissingEncryptionPasswordPromptHandler());
}
public static async Task <TrackingResult> TrackEventAsync(this SimpleTracker tracker, string category, string action, string label, long value = 1)
{
var eventTrackingParameters = new EventTracking
{
Category = category,
Action = action,
Label = label,
Value = value,
CacheBuster = tracker.AnalyticsSession.GenerateCacheBuster()
};
return(await tracker.TrackAsync(eventTrackingParameters));
}
public static async Task <TrackingResult> TrackEventAsync(this SimpleTracker tracker, string category, string action, string label, IDictionary <int, string> customDimensions, long value = 1)
{
var eventTrackingParameters = new EventTracking
{
Category = category,
Action = action,
Label = label,
Value = value,
};
eventTrackingParameters.SetCustomDimensions(customDimensions);
return(await tracker.TrackAsync(eventTrackingParameters));
}
public static async Task <TrackingResult> TrackEventAsync(this SimpleTracker tracker, string category, string action, string label, IDictionary <int, string> customDimensions, long value = 1)
{
var eventTrackingParameters = new EventTracking
{
Category = category,
Action = action,
Label = label,
Value = value,
DocumentHostName = tracker.Hostname,
CacheBuster = tracker.AnalyticsSession.GenerateCacheBuster()
};
eventTrackingParameters.SetCustomDimensions(customDimensions);
return(await tracker.TrackAsync(eventTrackingParameters));
}
public void Configure()
{
Mapper.AddMap <EventTracking, EventTrackingViewModel>((source) =>
{
var result = new EventTrackingViewModel();
result.InjectFrom(source);
return(result);
});
Mapper.AddMap <EventTrackingViewModel, EventTracking>((source) =>
{
var result = new EventTracking();
result.InjectFrom(source);
return(result);
});
}
public static void TrackEventAsync(string category, string action, string label, int value = 1)
{
if (!IsEnabled)
{
return;
}
var pageView = new EventTracking
{
Category = category,
Action = action,
Label = label,
Value = value
};
FillParameters(pageView);
instance.TrackEventAsync(pageView);
}
public EventTracking Create(EventTracking entity)
{
using (var connection = _dbConnectionFactory.CreateConnection())
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
var parameters = new DynamicParameters();
parameters.Add("@Name", entity.Name, DbType.String);
parameters.Add("@docId", entity.docId, DbType.Int64);
parameters.Add("@docDate", entity.docDate, DbType.DateTime2);
parameters.Add("@clientNumber", entity.clientNumber, DbType.Int64);
parameters.Add("@resultComplete", entity.resultComplete, DbType.Boolean);
// Configure outputs
parameters.Add("@EntityId", dbType: DbType.Int32, direction: ParameterDirection.Output);
parameters.Add("@ErrorMessage", dbType: DbType.String, size: 1000, direction: ParameterDirection.Output);
// Execute query
int result = connection.Execute(
sql: EventTrackingInsert_Proc,
commandType: CommandType.StoredProcedure,
transaction: transaction,
param: parameters
);
// Check for errors
string errorMessage = parameters.Get <string>("@ErrorMessage");
if (!string.IsNullOrEmpty(errorMessage))
{
throw new RepositoryException(errorMessage);
}
// Set the id
entity.Id = parameters.Get <int>("@EntityId");
transaction.Commit();
return(entity);
}
}
}
public async Task TrackEventAsync(Exception ex)
{
var eventTrackingParameters = new EventTracking
{
Category = "Errors",
Action = ex.Message,
Label = GetRelativeUrl(),
Value = ex.HResult,
DocumentHostName = _context.Request.Uri.Host,
UserAgent = _context.Request.Headers["User-Agent"],
UserLanguage = _context.Request.Headers["Accept-Language"],
DocumentReferrer = _context.Request.Headers["Referrer"],
IpOverride = _context.Request.Environment["server.RemoteIpAddress"] != null ? _context.Request.Environment["server.RemoteIpAddress"].ToString() : null,
UserId = _context.Authentication.User.Identity.Name
};
await TrackAsync(eventTrackingParameters);
}
public async Task TakeAllEvents_ThereIsNoTrackingForLastEventNumberYet()
{
var api = new TestEventApi();
api.SetupTestResource(
resourceName: "resource",
newTestEvents: new List <TestResourceCreatedEvent>
{
new TestResourceCreatedEvent
{
Id = new Guid("0683f052-40f0-4bff-879e-f4bea94c0ed0")
},
new TestResourceCreatedEvent
{
Id = new Guid("C471D99B-2C72-44F6-898F-F0BABCBAC9D7")
},
new TestResourceCreatedEvent
{
Id = new Guid("6843FE44-3029-47D3-A9B9-C21A3BAB4397")
}
});
var eventTrackingRepository = new ListEventTrackingRepository(new List <EventTracking>
{
EventTracking.Preset("resource", MessageNumber.New(1))
});
var eventMonitor = new EventMonitor(api, eventTrackingRepository);
var handler = new OnAnyEventRecordInListEventHandler <TestResourceCreatedEvent>();
eventMonitor.Subscribe <TestResourceCreatedEvent>("resource", handler);
await eventMonitor.Poll();
Assert.Equal(1, handler.Events.Count);
Assert.Equal(new Guid("6843FE44-3029-47D3-A9B9-C21A3BAB4397"), handler.Events[0].Id);
var lastMessageNumber = await eventTrackingRepository.GetLastMessageNumber("resource");
Assert.Equal(2, lastMessageNumber.Value);
}
private async Task <TrackingResult> TrackEventAsync(Session session, string cid, string category, string action, string label, GACustomDimensions gd, long value = 1)
{
var eventTrackingParameters = new EventTracking
{
Category = category,
Action = action,
Label = label,
Value = value,
};
eventTrackingParameters.ClientId = cid;
eventTrackingParameters.SetCustomDimensions(new System.Collections.Generic.Dictionary <int, string> {
{ 1, gd.productVersion },
{ 2, gd.sessionID },
{ 3, gd.uiLevel },
{ 4, gd.installMode },
});
return(await this._tracker.TrackAsync(eventTrackingParameters));
}
public static async Task <TrackingResult> TrackEventAsync(this SimpleTracker tracker, string category, string action, string label, long value = 1)
{
var eventTrackingParameters = new EventTracking
{
ClientId = Analytics.GUID,
UserId = Analytics.GUID,
ApplicationName = "FTAnalyzer",
ApplicationVersion = Analytics.AppVersion,
Category = category,
Action = action,
Label = label,
Value = value,
ScreenName = category,
CacheBuster = tracker.AnalyticsSession.GenerateCacheBuster(),
ScreenResolution = Analytics.Resolution,
CustomDimension1 = Analytics.DeploymentType,
CustomDimension2 = Analytics.OSVersion,
CustomDimension3 = Analytics.GUID,
GoogleAdWordsId = "201-455-7333",
UserLanguage = CultureInfo.CurrentUICulture.EnglishName
};
return(await tracker.TrackAsync(eventTrackingParameters).ConfigureAwait(false));
}
public ActionResult UpdateEventProgress(ProgressDetail details)
{
var currentTrack = db.EventTrackings.Where(e => e.BookingId == details.BookingId).OrderByDescending(e => e.Id).FirstOrDefault();
if (currentTrack != null && currentTrack.EventStatus == details.EventStatus)
{
return(View(GetProgressDetail(details.BookingId)));
}
var track = new EventTracking {
CustomerId = User.Identity.GetUserId(), BookingId = details.BookingId, EventId = details.EventId, EventStatus = details.EventStatus, Date = DateTime.Now
};
db.EventTrackings.Add(track);
var booking = db.Bookings.Where(b => b.Id == details.BookingId).FirstOrDefault();
if (booking != null)
{
booking.BookingStatus = ((EventStatus)details.EventStatus).ToString();
}
db.SaveChanges();
ViewBag.Updated = true;
return(View(GetProgressDetail(details.BookingId)));
}
public async Task TrackEventAsync(string category, string action, int value)
{
// If no HTTP context available, bail out...
if (_contextAccessor.HttpContext == null)
{
return;
}
var eventTrackingParameters = new EventTracking
{
Category = category,
Action = action,
Label = GetRelativeUrl(),
Value = value,
DocumentHostName = _contextAccessor.HttpContext.Request.Host.Value,
UserAgent = _contextAccessor.HttpContext.Request.Headers["User-Agent"],
UserLanguage = _contextAccessor.HttpContext.Request.Headers["Accept-Language"],
DocumentReferrer = _contextAccessor.HttpContext.Request.Headers["Referrer"],
IpOverride = Environment.GetEnvironmentVariable("server.RemoteIpAddress"),
UserId = _contextAccessor.HttpContext.User.Identity.Name
};
await TrackAsync(eventTrackingParameters);
}
public DPDActionResult Go()
{
DPDActionResult dpdresult = new DPDActionResult();
dpdresult.IsOk = false;
dpdresult.Message = " ";
// Удаляем временные данные после последнего сеанса
_eventtrackingRepository.DeleteAll();
_eventtrackingtypeRepository.DeleteAll();
_eventtrackingparameterRepository.DeleteAll();
_eventtrackingunitloadRepository.DeleteAll();
_stateparcelsRepository.DeleteAll();
_stateRepository.DeleteAll();
_stateparcelsunitedRepository.DeleteAll();
DPDWebService dpd = new DPDWebService();
eventTackingResponse responseEventModel = null;
do
{
try
{
responseEventModel = dpd.GetDPDEvents();
}
catch (Exception ex)
{
dpdresult.IsOk = false;
dpdresult.Message = ex.Message;
return(dpdresult);
}
EventTracking entityEventTracking = new EventTracking();
if (responseEventModel != null)
{
//1
entityEventTracking = Mapper.Map <EventTracking>(responseEventModel);
entityEventTracking = _eventtrackingRepository.Create(entityEventTracking);
if (responseEventModel.@event != null)
{
foreach (eventType evettype in responseEventModel.@event)
{
//2
EventTrackingType entityEventTrackingType = new EventTrackingType();
entityEventTrackingType = Mapper.Map <EventTrackingType>(evettype);
entityEventTrackingType.EventTrackingId = entityEventTracking.Id;
entityEventTrackingType = _eventtrackingtypeRepository.Create(entityEventTrackingType);
int typeId = entityEventTrackingType.Id;
//UNITED/////////////////////////////////////////////
//IEnumerable<StateUnited> stateUnitedsAll11 = _stateunitedRepository.GetAll();
//StateUnited stateunited11 = stateUnitedsAll11.Where(x => x.dpdOrderNr == entityEventTrackingType.dpdOrderNr).FirstOrDefault();
StateUnited stateunitedUPDATE = _stateunitedRepository.GetByDPDParam(entityEventTrackingType.dpdOrderNr);
StateUnited stateunitedCREATE = new StateUnited();
if (stateunitedUPDATE == null) // Create
{
//entityStateUnited = Mapper.Map<StateUnited>(state);
stateunitedCREATE.dpdOrderNr = entityEventTrackingType.dpdOrderNr;
stateunitedCREATE.Count = 1;
stateunitedCREATE.EventName = entityEventTrackingType.eventName;
stateunitedCREATE.EventReason = entityEventTrackingType.reasonName;
stateunitedCREATE = _stateunitedRepository.Create(stateunitedCREATE);
}
else // Update
{
stateunitedUPDATE.Count = stateunitedUPDATE.Count + 1;
stateunitedUPDATE.EventName = entityEventTrackingType.eventName;
stateunitedUPDATE.EventReason = entityEventTrackingType.reasonName;
if (entityEventTrackingType.eventCode == "OrderProblem" ||
entityEventTrackingType.eventCode == "OrderDeliveryProblem")
{
stateunitedUPDATE.ProblemName = entityEventTrackingType.eventName;
IEnumerable <Event> calendarEvents = _eventsRepository.GetAll();
Event calendarEventUpdate = calendarEvents.Where(x => x.StateUnitedId == stateunitedUPDATE.Id).FirstOrDefault();
if (calendarEventUpdate != null) // Update Calendar
{
calendarEventUpdate.StartDate = new DateTimeOffset(DateTime.Now);
calendarEventUpdate.EndDate = new DateTimeOffset(DateTime.Now.AddHours(1));
calendarEventUpdate.Color = "#ff8243";
calendarEventUpdate.Description = "Проблема";
_eventsRepository.Update(calendarEventUpdate);
}
else // Create Calendar Event
{
Event calendarEvent = new Event
{
StateUnitedId = stateunitedUPDATE.Id,
StartDate = new DateTimeOffset(DateTime.Now),
EndDate = new DateTimeOffset(DateTime.Now.AddHours(1)), //new DateTimeOffset(stateunitedUPDATE.planDeliveryDate),
Color = "#ff7033",
Description = stateunitedUPDATE.newState,
Name = stateunitedUPDATE.dpdOrderNr,
AllDay = true
};
_eventsRepository.Create(calendarEvent);
}
}
stateunitedUPDATE.Name = stateunitedUPDATE.Name + "1";
_stateunitedRepository.Update(stateunitedUPDATE);
}
if (evettype.parameter != null)
{
foreach (parameterType parametertype in evettype.parameter)
{
//3
EventTrackingParameter entityEventTrackingParameter = new EventTrackingParameter();
entityEventTrackingParameter = Mapper.Map <EventTrackingParameter>(parametertype);
entityEventTrackingParameter.EventTrackingTypeId = entityEventTrackingType.Id;
entityEventTrackingParameter.Name = entityEventTrackingType.dpdOrderNr;
entityEventTrackingParameter = _eventtrackingparameterRepository.Create(entityEventTrackingParameter);
StateUnited stateunitedUPDATE_PARAM = new StateUnited();
if (stateunitedCREATE != null)
{
stateunitedUPDATE_PARAM = stateunitedCREATE;
}
else
{
stateunitedUPDATE_PARAM = stateunitedUPDATE;
}
if (stateunitedUPDATE_PARAM != null) // PARAMETERS UPDATE
{
switch (entityEventTrackingParameter.paramName)
{
case "DeliveryAddress":
stateunitedUPDATE_PARAM.DeliveryAddress = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "DeliveryCity":
stateunitedUPDATE_PARAM.DeliveryCity = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "DeliveryVariant":
stateunitedUPDATE_PARAM.DeliveryVariant = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "DeliveryPointCode":
stateunitedUPDATE_PARAM.DeliveryPointCode = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "DeliveryInterval":
stateunitedUPDATE_PARAM.DeliveryInterval = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "PickupAddress":
stateunitedUPDATE_PARAM.PickupAddress = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "PickupCity":
stateunitedUPDATE_PARAM.PickupCity = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "PointCity":
stateunitedUPDATE_PARAM.PointCity = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "Consignee":
stateunitedUPDATE_PARAM.Consignee2 = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "Consignor":
stateunitedUPDATE_PARAM.Consignor = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "ReasonName":
stateunitedUPDATE_PARAM.ReasonName = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "RejectionReason":
stateunitedUPDATE_PARAM.RejectionReason = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "OrderType":
stateunitedUPDATE_PARAM.OrderType = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
case "MomentLocZone":
stateunitedUPDATE_PARAM.MomentLocZone = entityEventTrackingParameter.valueString;
_stateunitedRepository.Update(stateunitedUPDATE_PARAM);
break;
default:
break;
}
}
if (parametertype.value != null)
{
foreach (eventTrackingUnitLoad unitload in parametertype.value)
{
//4
EventTrackingUnitLoad entityEventTrackingUnitLoad = new EventTrackingUnitLoad();
entityEventTrackingUnitLoad = Mapper.Map <EventTrackingUnitLoad>(unitload);
entityEventTrackingUnitLoad.EventTrackingParameterId = entityEventTrackingParameter.Id;
entityEventTrackingUnitLoad = _eventtrackingunitloadRepository.Create(entityEventTrackingUnitLoad);
}
}
}
}
}
}
}
/////// Подтверждаем, что получили статусы по эвентам
try
{
dpd.EventConfirm(entityEventTracking.docId);
}
catch (Exception ex)
{
dpdresult.IsOk = false;
dpdresult.Message = ex.Message + " ПОВТОРИТЕ ЗАПРОС ЧЕРЕЗ 5 МИН.";
return(dpdresult);
}
} while (!responseEventModel.resultComplete);
BG.DPDServices.BGDPDServiceTracing.stateParcels responseParcelsModel = null;
do
{
try
{
responseParcelsModel = dpd.GetDPDStates();
}
catch (Exception ex)
{
dpdresult.IsOk = false;
dpdresult.Message = ex.Message;
return(dpdresult);
}
StateParcels entityStateParcels = new StateParcels();
if (responseParcelsModel != null)
{
//5
entityStateParcels = Mapper.Map <StateParcels>(responseParcelsModel);
entityStateParcels = _stateparcelsRepository.Create(entityStateParcels);
if (responseParcelsModel.states != null)
{
foreach (BG.DPDServices.BGDPDServiceTracing.stateParcel state in responseParcelsModel.states)
{
//6
State entityState = new State();
entityState = Mapper.Map <State>(state);
entityState.StateParcelsId = entityStateParcels.Id;
entityState = _stateRepository.Create(entityState);
}
}
}
// UNITED & HISTORY ////////////////////////////////////////////////////////////////////////////////////////////////////
if (responseParcelsModel.states != null)
{
foreach (BG.DPDServices.BGDPDServiceTracing.stateParcel state in responseParcelsModel.states)
{
StateHistory entityStateHistory = new StateHistory();
entityStateHistory = Mapper.Map <StateHistory>(state);
entityStateHistory = _statehistoryRepository.Create(entityStateHistory);
StateUnited stateunited = _stateunitedRepository.GetByDPDParam(state.dpdOrderNr);
if (stateunited == null) // Create
{
StateUnited entityStateUnited = new StateUnited();
entityStateUnited = Mapper.Map <StateUnited>(state);
entityStateUnited.Count = 1;
entityStateUnited = _stateunitedRepository.Create(entityStateUnited);
if (entityStateUnited.newState == "Problem")
{
Event calendarEvent = new Event
{
StateUnitedId = entityStateUnited.Id,
StartDate = new DateTimeOffset(DateTime.Now),
EndDate = new DateTimeOffset(DateTime.Now.AddHours(1)), //new DateTimeOffset(entityStateUnited.planDeliveryDate),
Color = "#ff0000",
Description = entityStateUnited.newState,
Name = entityStateUnited.dpdOrderNr,
AllDay = true
};
_eventsRepository.Create(calendarEvent);
}
}
else // Update
{
if (state.transitionTime > stateunited.transitionTime) // если Статус свежее, тогда обновляем
{
stateunited.Count = stateunited.Count + 1;
stateunited.Name = stateunited.Name + "2";
stateunited.clientOrderNr = state.clientOrderNr;
stateunited.clientParcelNr = state.clientParcelNr;
stateunited.dpdParcelNr = state.dpdParcelNr;
stateunited.pickupDate = state.pickupDate;
stateunited.planDeliveryDate = state.planDeliveryDate;
stateunited.isReturn = state.isReturn;
stateunited.isReturnSpecified = state.isReturnSpecified;
stateunited.planDeliveryDateSpecified = state.planDeliveryDateSpecified;
stateunited.newState = state.newState;
stateunited.transitionTime = state.transitionTime;
stateunited.terminalCode = state.terminalCode;
stateunited.terminalCity = state.terminalCity;
stateunited.incidentCode = state.incidentCode;
stateunited.incidentName = state.incidentName;
stateunited.consignee = state.consignee;
_stateunitedRepository.Update(stateunited);
IEnumerable <Event> calendarEvents = _eventsRepository.GetAll();
Event calendarEventUpdate = calendarEvents.Where(x => x.StateUnitedId == stateunited.Id).FirstOrDefault();
if (calendarEventUpdate != null)
{
if (stateunited.newState == "Delivered")
{
calendarEventUpdate.StartDate = new DateTimeOffset(DateTime.Now);
calendarEventUpdate.EndDate = new DateTimeOffset(DateTime.Now.AddHours(1)); //new DateTimeOffset(stateunited.transitionTime);
calendarEventUpdate.Color = "#008c95";
calendarEventUpdate.Description = "Доставлено";
_eventsRepository.Update(calendarEventUpdate);
}
else if (stateunited.newState == "Problem")
{
calendarEventUpdate.StartDate = new DateTimeOffset(DateTime.Now);
calendarEventUpdate.EndDate = new DateTimeOffset(DateTime.Now.AddHours(1)); //new DateTimeOffset(stateunited.transitionTime);
calendarEventUpdate.Color = "#ff0000";
calendarEventUpdate.Description = "Проблема";
_eventsRepository.Update(calendarEventUpdate);
}
}
else
{
if (stateunited.newState == "Problem")
{
Event calendarEvent = new Event
{
StateUnitedId = stateunited.Id,
StartDate = new DateTimeOffset(DateTime.Now),
EndDate = new DateTimeOffset(DateTime.Now.AddHours(1)), //new DateTimeOffset(stateunited.planDeliveryDate),
Color = "#ff0000",
Description = stateunited.newState,
Name = stateunited.dpdOrderNr,
AllDay = true
};
_eventsRepository.Create(calendarEvent);
}
}
}
}
}
}
////// Подтверждаем, что получили статусы по посылкам
try
{
dpd.StatesConfirm(responseParcelsModel.docId);
}
catch (Exception ex)
{
dpdresult.IsOk = false;
dpdresult.Message = ex.Message + " ПОВТОРИТЕ ЗАПРОС ЧЕРЕЗ 5 МИН.";
return(dpdresult);
}
} while (!responseParcelsModel.resultComplete);
dpdresult.IsOk = true;
dpdresult.Message = "СТАТУСЫ ОБНОВЛЕНЫ !!!";
return(dpdresult);
}
