private long AddSubscriptionHistory(StoreObject store)
{
try
{
var expiryDate = DateTime.Today.AddDays(store.Duration);
var subHistory = new StoreSubscriptionHistoryObject
{
StoreId = store.StoreId,
SubscriptionPackageId = store.SubscriptionPackageId,
DateSubscribed = DateTime.Today,
Duration = store.Duration,
SubscriptionExpiryDate = expiryDate,
};
if (store.PaymentMethodId > 0)
{
subHistory.PaymentId = store.PaymentMethodId;
}
return(new StoreSubscriptionServices().AddStoreSubscription(subHistory));
}
catch (Exception)
{
return(0);
}
}
// Token: 0x06000AB9 RID: 2745 RVA: 0x00045FBC File Offset: 0x000441BC
private void ProcessMailbox(MailboxInfo mailbox, MailboxSession session, StoreObject item)
{
ADUser aduser;
UMDialPlan umdialPlan;
bool flag;
bool flag2;
if (this.TryReadUserConfiguration(mailbox, out aduser, out umdialPlan, out flag, out flag2))
{
mailbox.DialPlanGuid = aduser.UMRecipientDialPlanId.ObjectGuid;
mailbox.UMExtension = aduser.UMExtension;
mailbox.DisplayName = aduser.DisplayName;
ExTraceGlobals.MWITracer.TraceDebug <MailboxInfo, UMSubscriberType, MapiEvent>((long)this.GetHashCode(), "MwiAssistant.ProcessMailbox: User:{0}. SubsType:{1} MapiEvent:{2}", mailbox, umdialPlan.SubscriberType, mailbox.MapiEvent);
if (flag2)
{
this.ProcessMailboxForMWI(mailbox, session, item, umdialPlan);
}
else
{
ExTraceGlobals.MWITracer.TraceDebug <string>((long)this.GetHashCode(), "MwiAssistant.ProcessMailbox: Skip ProcessMailboxForMWI because UMMailboxPolicy.AllowMessageWaitingIndicator is false for User {0}}", aduser.DistinguishedName);
}
if (flag)
{
this.ProcessMailboxForSMS(mailbox, session, item, aduser, umdialPlan);
return;
}
ExTraceGlobals.MWITracer.TraceDebug <string>((long)this.GetHashCode(), "MwiAssistant.ProcessMailbox: Skip ProcessMailboxForSMS because UMMailboxPolicy.AllowSMSNotification is false for User {0}}", aduser.DistinguishedName);
}
}
private GenericValidator ValidateTrial(StoreObject store)
{
var gVal = new GenericValidator();
if (store == null)
{
gVal.Code = -1;
gVal.Error = message_Feedback.Fatal_Error;
return(gVal);
}
if (string.IsNullOrEmpty(store.StoreName))
{
gVal.Code = -1;
gVal.Error = message_Feedback.Store_Name_Error_1;
return(gVal);
}
if (string.IsNullOrEmpty(store.CustomerEmail))
{
gVal.Code = -1;
gVal.Error = message_Feedback.Customer_Email_Empty;
return(gVal);
}
if (string.IsNullOrEmpty(store.DefaultCurrency))
{
gVal.Code = -1;
gVal.Error = message_Feedback.Billing_Cycle_Selection_Error;
return(gVal);
}
gVal.Code = 5;
return(gVal);
}
public DisplayShelf displayShelf; // Part of the checkout counter
void Awake()
{
StoreObject storeObj = GetComponent <StoreObject>();
objectID = storeObj.objectID;
subID = storeObj.subID;
}
public void AddObject(FacilityValue.FacilityInfo Info)
{
if (Info.ObjectActCall.Info.Type == "EnergyStorage")
{
StoreObject newObject = new StoreObject();
newObject.FacilityInfo = Info;
newObject.EnergyStoreActCall = Info.Object.GetComponent <EnergyStorageAct>();
StoreList.Add(newObject);
TotalStorableAmount += newObject.EnergyStoreActCall.StorableElectricity;
StoreObjectCount++;
}
else
{
UsageInfo newUsage = new UsageInfo();
newUsage.FacilityInfo = Info;
UsageList.Add(newUsage);
}
BlackOutTimer = BlackOutTimeLimit;
if (CompanyValueCall.CompanyName == CompanyManagerCall.PlayerCompanyName)
{
PanelControllerCall.UpdateFactoryInfo("Electricity", TotalUsage, AvailableElectricityAmount);
}
}
public void UseStoreObject(StoreObject storeObject)
{
if (purchasedStoreObjects.ContainsKey(storeObject))
{
purchasedStoreObjects[storeObject]--;
}
}
// Token: 0x060007AD RID: 1965 RVA: 0x00036BD8 File Offset: 0x00034DD8
internal void DeleteMessage(StoreSession itemStore, StoreObject item)
{
bool flag = false;
string arg = null;
if (item is MeetingForwardNotification)
{
flag = true;
arg = ((MeetingMessage)item).Subject;
}
AggregateOperationResult aggregateOperationResult = itemStore.Delete(DeleteItemFlags.MoveToDeletedItems, new StoreId[]
{
item.Id
});
if (aggregateOperationResult.OperationResult == OperationResult.Succeeded)
{
CalendarAssistantPerformanceCounters.MeetingMessagesDeleted.Increment();
if (flag)
{
string info = string.Format("MFN with subject {0} was moved to deleted items.", arg);
MfnLog.LogEntry((MailboxSession)itemStore, info);
return;
}
}
else if (flag)
{
string info = string.Format("MFN with subject {0} failed to be moved to deleted items. Error = {1}", arg, aggregateOperationResult);
MfnLog.LogEntry((MailboxSession)itemStore, info);
}
}
public void Load()
{
if (File.Exists(Application.dataPath + "/save.txt"))
{
string json = File.ReadAllText(Application.dataPath + "/save.txt");
string jsonPM = File.ReadAllText(Application.dataPath + "/savePM.txt");
saveObj = JsonUtility.FromJson <SaveObject>(json);
player.transform.position = saveObj.playerPos;
PlayerManager pm = player.GetComponent <PlayerManager>();
StoreObject obj = new StoreObject();
obj.inv = pm.inventoryMenu;
obj.pause = pm.pauseMenu;
obj.logText = pm.logText;
JsonUtility.FromJsonOverwrite(jsonPM, pm);
pm.inventoryMenu = obj.inv;
pm.pauseMenu = obj.pause;
pm.logText = obj.logText;
Debug.Log("LOADED");
PlayerPrefs.SetInt("STATUS", 1);
}
else
{
PlayerPrefs.SetInt("STATUS", 0);
}
}
// Token: 0x060000BF RID: 191 RVA: 0x00005000 File Offset: 0x00003200
public void HandleEvent(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item)
{
using (new GuidTraceFilter(base.DatabaseInfo.Guid, mapiEvent.MailboxGuid))
{
string value = (item != null) ? item.ClassName : mapiEvent.ObjectClass;
if (!string.IsNullOrEmpty(value) || mapiEvent.ItemType == ObjectType.MAPI_STORE || mapiEvent.ItemType == ObjectType.MAPI_FOLDER)
{
EventBasedAssistant.Tracer.TraceDebug <EventBasedAssistant, long, IExchangePrincipal>((long)this.GetHashCode(), "{0}: Started handling event {1} for mailbox {2}.", this, mapiEvent.EventCounter, itemStore.MailboxOwner);
List <KeyValuePair <string, object> > list = new List <KeyValuePair <string, object> >();
IActivityScope currentActivityScope = ActivityContext.GetCurrentActivityScope();
Guid activityId = Guid.Empty;
if (currentActivityScope != null)
{
activityId = currentActivityScope.ActivityId;
}
AssistantsLog.LogStartProcessingMailboxEvent(activityId, this, mapiEvent, itemStore.MailboxGuid);
TraceContext.Set(itemStore);
try
{
this.HandleEventInternal(mapiEvent, itemStore, item, list);
goto IL_103;
}
finally
{
TraceContext.Reset();
AssistantsLog.LogEndProcessingMailboxEvent(activityId, this, list, itemStore.MailboxGuid, string.Empty, null);
EventBasedAssistant.Tracer.TraceDebug <EventBasedAssistant, long, IExchangePrincipal>((long)this.GetHashCode(), "{0}: Ended handling event {1} for mailbox {2}.", this, mapiEvent.EventCounter, itemStore.MailboxOwner);
}
}
EventBasedAssistant.Tracer.TraceDebug <IExchangePrincipal>((long)this.GetHashCode(), "{0}: Event not processed because we are unable get the ObjectClass on the item.", itemStore.MailboxOwner);
IL_103 :;
}
}
public void DeselectObject()
{
if (colorModifierPanel != null)
{
Destroy(colorModifierPanel.gameObject);
}
colorModifierPanel = null;
if (modelsModifierPanel != null)
{
Destroy(modelsModifierPanel.gameObject);
}
modelsModifierPanel = null;
if (shelvesModifierPanel != null)
{
Destroy(shelvesModifierPanel.gameObject);
}
shelvesModifierPanel = null;
if (addonsModifierPanel != null)
{
Destroy(addonsModifierPanel.gameObject);
}
addonsModifierPanel = null;
foreach (ObjectSelectionRoundButton button in buttons)
{
Destroy(button.gameObject);
}
buttons.Clear();
selectedObject = null;
Main_OffScreen();
}
public StoreObject Obtain(Unit Self)
{
StoreObject temp = (StoreObject)Copy();
temp.Init(Self);
return(temp);
}
internal void SaveDataToXso(StoreObject storeObject, ReadOnlyCollection <XsoDriverPropertyDefinition> ignoredProperties)
{
if (storeObject == null)
{
throw new ArgumentNullException("storeObject");
}
foreach (PropertyDefinition propertyDefinition in this.Schema.AllProperties)
{
if (propertyDefinition is XsoDriverPropertyDefinition)
{
XsoDriverPropertyDefinition xsoDriverPropertyDefinition = (XsoDriverPropertyDefinition)propertyDefinition;
if (!xsoDriverPropertyDefinition.IsReadOnly && (ignoredProperties == null || !ignoredProperties.Contains(xsoDriverPropertyDefinition)) && (PropertyFlags.ReadOnly & xsoDriverPropertyDefinition.StorePropertyDefinition.PropertyFlags) == PropertyFlags.None && base.IsChanged(xsoDriverPropertyDefinition))
{
object obj = null;
this.propertyBag.TryGetField((ProviderPropertyDefinition)propertyDefinition, ref obj);
if (obj != null)
{
storeObject[xsoDriverPropertyDefinition.StorePropertyDefinition] = obj;
}
else
{
storeObject.Delete(xsoDriverPropertyDefinition.StorePropertyDefinition);
}
}
}
}
}
public Int32 UpdateStore(StoreObject store)
{
try
{
if (store == null)
{
return(-2);
}
var duplicates = _repository.Count(m => m.StoreName.Trim().ToLower().Equals(store.StoreName.Trim().ToLower()) || m.StoreAlias.Trim().ToLower().Equals(store.StoreAlias.Trim().ToLower()) || m.CompanyName.Trim().ToLower().Equals(store.StoreAlias.Trim().ToLower()) && m.StoreId != store.StoreId);
if (duplicates > 0)
{
return(-3);
}
var storeEntity = ModelCrossMapper.Map <StoreObject, Store>(store);
if (storeEntity == null || storeEntity.StoreId < 1)
{
return(-2);
}
_repository.Update(storeEntity);
_uoWork.SaveChanges();
return(5);
}
catch (Exception ex)
{
ErrorLogger.LogError(ex.StackTrace, ex.Source, ex.Message);
return(-2);
}
}
// Token: 0x06000B0B RID: 2827 RVA: 0x00047C18 File Offset: 0x00045E18
private void ProcessEvent(ADUser user, MailboxSession mailboxSession, StoreObject item)
{
Exception ex = null;
StringBuilder stringBuilder = new StringBuilder();
UMPartnerMessageAssistant.UMPartnerMessageRpcTargetPicker instance = UMPartnerMessageAssistant.UMPartnerMessageRpcTargetPicker.Instance;
IADSystemConfigurationLookup iadsystemConfigurationLookup = ADSystemConfigurationLookupFactory.CreateFromOrganizationId(user.OrganizationId);
ProcessPartnerMessageRequest processPartnerMessageRequest = new ProcessPartnerMessageRequest();
processPartnerMessageRequest.MailboxGuid = mailboxSession.MailboxGuid;
processPartnerMessageRequest.TenantGuid = iadsystemConfigurationLookup.GetExternalDirectoryOrganizationId();
processPartnerMessageRequest.ItemId = item.Id.ToBase64String();
LocalizedString partnerMessageDescription = UMPartnerMessageAssistant.GetPartnerMessageDescription(item);
int num = 0;
int num2 = 0;
for (;;)
{
IVersionedRpcTarget versionedRpcTarget = instance.PickNextServer(user.UMRecipientDialPlanId.ObjectGuid, out num);
if (versionedRpcTarget == null)
{
break;
}
try
{
ex = null;
versionedRpcTarget.ExecuteRequest(processPartnerMessageRequest);
UMPartnerMessageAssistant.LogMessageProcessingSuccessEvent(partnerMessageDescription, user, versionedRpcTarget);
UMPartnerMessageAssistant.SafeDeleteItem(mailboxSession, item.Id);
goto IL_151;
}
catch (RpcException ex2)
{
ex = ex2;
UMPartnerMessageAssistant.Tracer.TraceWarning <string, RpcException>(0L, "UMPMA.ProcessEvent({0}): {1}", versionedRpcTarget.Name, ex2);
stringBuilder.AppendLine(Strings.UMRpcError(versionedRpcTarget.Name, ex2.ErrorCode, ex2.Message));
if (UMErrorCode.IsPermanent(ex2.ErrorCode))
{
throw new SkipException(Strings.descUMServerFailure(versionedRpcTarget.Name, partnerMessageDescription, user.DistinguishedName), ex2);
}
if (UMErrorCode.IsNetworkError(ex2.ErrorCode))
{
instance.ServerUnavailable(versionedRpcTarget);
}
}
if (++num2 >= num)
{
goto IL_151;
}
}
UMPartnerMessageAssistant.LogNoServersAvailableEvent(partnerMessageDescription, user);
throw new TransientMailboxException(Strings.descUMServerNotAvailable(partnerMessageDescription, user.DistinguishedName), null, UMPartnerMessageAssistant.RetrySchedule);
IL_151:
if (ex != null)
{
UMPartnerMessageAssistant.LogMessageProcessingFailedEvent(partnerMessageDescription, user, stringBuilder.ToString());
throw new TransientMailboxException(Strings.descUMAllServersFailed(partnerMessageDescription, user.DistinguishedName), ex, UMPartnerMessageAssistant.RetrySchedule);
}
}
public void OnPlace()
{
DispensaryManager dm = GetStoreObject().dm;
RaycastHit[] hits = Physics.RaycastAll(transform.position + new Vector3(0, 2, 0), Vector3.down);
string component = string.Empty;
int subGridIndex = -1;
if (hits.Length > 0)
{
foreach (RaycastHit hit in hits)
{
if (hit.transform.tag == "Floor")
{
FloorTile tile = hit.transform.GetComponent <FloorTile>();
component = tile.gameObject.name;
StoreObject storeObj = GetStoreObject();
storeObj.gridIndex = new Vector2(tile.gridX, tile.gridY);
subGridIndex = tile.subGridIndex;
}
}
}
if (component == string.Empty)
{
component = dm.dispensary.GetSelected();
}
StoreObject obj = GetStoreObject();
switch (component)
{
case "MainStore":
case "MainStoreComponent":
dm.dispensary.Main_c.AddStoreObject(obj);
obj.grid = dm.dispensary.Main_c.grid.GetSubGrid(subGridIndex);
break;
case "Storage0":
case "StorageComponent0":
dm.dispensary.Storage_cs[0].AddStoreObject(obj);
obj.grid = dm.dispensary.Storage_cs[0].grid.GetSubGrid(subGridIndex);
break;
case "Storage1":
case "StorageComponent1":
dm.dispensary.Storage_cs[1].AddStoreObject(obj);
obj.grid = dm.dispensary.Storage_cs[1].grid.GetSubGrid(subGridIndex);
break;
case "Storage2":
case "StorageComponent2":
dm.dispensary.Storage_cs[2].AddStoreObject(obj);
obj.grid = dm.dispensary.Storage_cs[2].grid.GetSubGrid(subGridIndex);
break;
}
foreach (BoxCollider col in gameObject.transform.GetComponents <BoxCollider>())
{
col.gameObject.layer = 19;
}
}
// Token: 0x06000024 RID: 36 RVA: 0x000030E0 File Offset: 0x000012E0
public void HandleEvent(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item)
{
MailboxTransportSubmissionAssistant.IdentifyProbeMessage(mapiEvent);
Thread currentThread = Thread.CurrentThread;
try
{
Interlocked.Increment(ref this.concurrentEvents);
this.SubmissionsInProgress[currentThread] = new SubmissionsInProgress.Entry(ExDateTime.UtcNow, this.databaseInfo.Guid, mapiEvent);
using (new SenderGuidTraceFilter(this.databaseInfo.Guid, mapiEvent.MailboxGuid))
{
bool flag = true;
MailboxTransportSubmissionAssistant.LatencyRecord latencyRecord;
LatencyTracker latencyTracker;
if (MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.TryGetValue(mapiEvent.EventCounter, out latencyRecord))
{
MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.Remove(mapiEvent.EventCounter);
latencyTracker = latencyRecord.LatencyTracker;
LatencyTracker.EndTrackLatency(latencyRecord.LatencyComponent, latencyTracker, true);
flag = false;
}
else
{
latencyTracker = LatencyTracker.CreateInstance(LatencyComponent.MailboxTransportSubmissionService);
LatencyTracker.TrackPreProcessLatency(LatencyComponent.SubmissionAssistant, latencyTracker, mapiEvent.CreateTime);
}
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker);
string text = this.FormatMapiEventInfo(mapiEvent);
this.LogMapiEventIntoCrimsonChannelPeriodically(text);
this.SubmissionsInProgress[Thread.CurrentThread].LatencyTracker = latencyTracker;
if (MailboxTransportSubmissionAssistant.ShouldLogNotifyEvents && (flag || MailboxTransportSubmissionAssistant.ShouldLogTemporaryFailures))
{
LatencyFormatter latencyFormatter = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, mapiEvent.CreateTime, mapiEvent.CreateTime, true, false, false);
MsgTrackMapiSubmitInfo msgTrackInfo = new MsgTrackMapiSubmitInfo(text, null, string.Empty, StoreDriverSubmission.LocalIPAddress, Components.Configuration.LocalServer.TransportServer.Name, string.Empty, string.Empty, MailboxTransportSubmissionAssistant.ItemEntryId(mapiEvent), latencyFormatter.FormatAndUpdatePerfCounters(), null, false, true);
MessageTrackingLog.TrackNotify(msgTrackInfo, false);
}
MSExchangeSubmission.PendingSubmissions.Increment();
new HashSet <string>();
DateTime createTime = mapiEvent.CreateTime;
MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePfdPass <int, Guid, long>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "PFD EMS {0} SubmitMail for mailbox {1} at entry {2}", 22427, mapiEvent.MailboxGuid, mapiEvent.EventCounter);
LatencyFormatter latencyFormatter2 = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, createTime, createTime, false, true, false);
bool isPublicFolder = mapiEvent.ExtendedEventFlags.HasFlag(MapiExtendedEventFlags.PublicFolderMailbox);
LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker);
ISubmissionProvider submissionProvider = (ISubmissionProvider)Components.StoreDriverSubmission;
MailSubmissionResult mailSubmissionResult = submissionProvider.SubmitMessage(Components.Configuration.LocalServer.TransportServer.ExchangeLegacyDN, mapiEvent.MailboxGuid, this.databaseInfo.Guid, this.databaseInfo.DatabaseName, mapiEvent.EventCounter, mapiEvent.ItemEntryId, mapiEvent.ParentEntryId, Components.Configuration.LocalServer.TransportServer.Fqdn, new IPAddress(StoreDriverSubmission.LocalIPAddress.GetAddressBytes()), mapiEvent.CreateTime, isPublicFolder, (mapiEvent.TenantHint == null) ? null : TenantPartitionHint.FromPersistablePartitionHint(mapiEvent.TenantHint), latencyFormatter2.FormatAndUpdatePerfCounters(), MailboxTransportSubmissionService.QuarantineHandler, MailboxTransportSubmissionService.SubmissionPoisonHandler, latencyTracker);
MailSubmissionResult result = mailSubmissionResult;
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker);
LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker);
this.LogAndUpdateCounters(mapiEvent, latencyTracker, createTime, result);
this.HandleEventError(mapiEvent, result, latencyTracker, text);
}
}
finally
{
MSExchangeSubmission.PendingSubmissions.Decrement();
Interlocked.Decrement(ref this.concurrentEvents);
this.SubmissionsInProgress.Remove(currentThread);
}
}
public int GetNoOfStoreObjectPurchased(StoreObject storeObject)
{
if (purchasedStoreObjects.ContainsKey(storeObject))
{
return(purchasedStoreObjects[storeObject]);
}
return(0);
}
// Token: 0x06003054 RID: 12372 RVA: 0x0011B110 File Offset: 0x00119310
internal void ApplyPolicyTag(StoreObject itemOrFolder, Guid policyGuid)
{
if (itemOrFolder == null)
{
throw new ArgumentNullException("itemOrFolder");
}
this.SetPolicyTag(itemOrFolder, false, new Guid?(policyGuid));
}
public int AddRandomStoreObject()
{
int rand = UnityEngine.Random.Range(1, 6);
StoreObject storeObj = (StoreObject)rand;
AddStoreObject(storeObj);
return(rand);
}
// Token: 0x06001475 RID: 5237 RVA: 0x0007637E File Offset: 0x0007457E
public override void Bind(StoreObject item)
{
base.Bind(item);
if (this.xsoBodyProperty != null)
{
this.xsoBodyProperty.Bind(item);
}
}
// Token: 0x06003053 RID: 12371 RVA: 0x0011B0E4 File Offset: 0x001192E4
internal void ClearPolicyTag(StoreObject itemOrFolder)
{
if (itemOrFolder == null)
{
throw new ArgumentNullException("itemOrFolder");
}
this.SetPolicyTag(itemOrFolder, true, null);
}
// Token: 0x060013CB RID: 5067 RVA: 0x00071D06 File Offset: 0x0006FF06
public virtual void Bind(StoreObject item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
this.XsoItem = item;
}
public StoreAEForm(StoreObject obj)
{
this.store = obj;
InitializeComponent();
this.bindingSource.DataSource = this.store;
}
internal void LoadDataFromXso(ADObjectId mailboxOwnerId, StoreObject storeObject)
{
if (storeObject == null)
{
throw new ArgumentNullException("storeObject");
}
PropertyDefinition[] allDependentXsoProperties = this.Schema.AllDependentXsoProperties;
this.LoadDataFromXsoRows(mailboxOwnerId, storeObject.GetProperties(allDependentXsoProperties), allDependentXsoProperties);
}
public override bool Equals(object other)
{
StoreObject otherStoreObject = (StoreObject)other;
if (otherStoreObject.uniqueID == uniqueID)
{
return(true);
}
return(false);
}
public bool CheckAgainstList(StoreObject obj)
{
foreach (StoreObject storeObject in storeObjects)
{
if (storeObject.uniqueID == obj.uniqueID)
{
return(true);
}
}
return(false);
}
public int AddRandomStoreObject(bool AddImmediate)
{
int rand = UnityEngine.Random.Range(1, 6);
StoreObject storeObj = (StoreObject)rand;
if (AddImmediate)
{
AddStoreObject(storeObj);
}
return(rand);
}
public string UpdateStore(string storeId, StoreObject store)
{
try
{
return(_storeService.SaveStore(store));
}
catch (Exception ex)
{
throw new WebFaultException <string>(ex.Message, HttpStatusCode.InternalServerError);
}
}
public void DeleteObject(FacilityValue.FacilityInfo Info)
{
if (Info.ObjectActCall.Info.Type == "EnergyStorage")
{
StoreObject Target = null;
foreach (var Supply in StoreList)
{
if (Supply.FacilityInfo == Info)
{
Target = Supply;
break;
}
}
if (Target != null)
{
StoreList.Remove(Target);
}
else
{
Debug.Log("Cannot Find " + Info.Object.name);
}
}
else
{
UsageInfo Target = null;
foreach (var Usage in UsageList)
{
if (Usage.FacilityInfo == Info)
{
Target = Usage;
break;
}
}
if (Target != null)
{
UsageList.Remove(Target);
}
else
{
Debug.Log("Cannot Find " + Info.Object.name);
}
}
BlackOutTimer = BlackOutTimeLimit;
if (CompanyValueCall.CompanyName == CompanyManagerCall.PlayerCompanyName)
{
PanelControllerCall.UpdateFactoryInfo("Electricity", TotalUsage, AvailableElectricityAmount);
}
}
void Start()
{
score = GameObject.FindGameObjectWithTag("Score").GetComponent <ScoreBoard>();
myTruck = GetComponentInChildren <StoreObject>();
audSrc = GetComponent <AudioSource>();
dest = myTruck.transform.localPosition;
displayLights = GetComponentInChildren <OrderLight>();
counter.text = "-";
SetSpawnCounter();
CreateFloatText();
}
public void Open(StoreObject storeObject)
{
if (db == null)
{
Start();
}
mainPanel.gameObject.SetActive(true);
currentScreenshot = db.GetStoreObjectScreenshot(storeObject.objectID, storeObject.subID);
screenshotImage.sprite = currentScreenshot;
nameText.text = storeObject.name + " Preview";
}