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);
            }
        }
Exemple #2
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;
    }
Exemple #5
0
    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);
        }
    }
Exemple #6
0
 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);
        }
    }
Exemple #9
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();
 }
Exemple #11
0
    public StoreObject Obtain(Unit Self)
    {
        StoreObject temp = (StoreObject)Copy();

        temp.Init(Self);
        return(temp);
    }
Exemple #12
0
 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);
                 }
             }
         }
     }
 }
Exemple #13
0
        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);
            }
        }
Exemple #15
0
    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;
        }
    }
Exemple #16
0
        // 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);
            }
        }
Exemple #17
0
 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));
 }
Exemple #19
0
    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);
 }
Exemple #22
0
 // 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;
 }
Exemple #23
0
        public StoreAEForm(StoreObject obj)
        {
            this.store = obj;

            InitializeComponent();

            this.bindingSource.DataSource = this.store;
        }
Exemple #24
0
 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);
 }
Exemple #25
0
    public override bool Equals(object other)
    {
        StoreObject otherStoreObject = (StoreObject)other;

        if (otherStoreObject.uniqueID == uniqueID)
        {
            return(true);
        }
        return(false);
    }
Exemple #26
0
 public bool CheckAgainstList(StoreObject obj)
 {
     foreach (StoreObject storeObject in storeObjects)
     {
         if (storeObject.uniqueID == obj.uniqueID)
         {
             return(true);
         }
     }
     return(false);
 }
Exemple #27
0
    public int AddRandomStoreObject(bool AddImmediate)
    {
        int         rand     = UnityEngine.Random.Range(1, 6);
        StoreObject storeObj = (StoreObject)rand;

        if (AddImmediate)
        {
            AddStoreObject(storeObj);
        }
        return(rand);
    }
Exemple #28
0
 public string UpdateStore(string storeId, StoreObject store)
 {
     try
     {
         return(_storeService.SaveStore(store));
     }
     catch (Exception ex)
     {
         throw new WebFaultException <string>(ex.Message, HttpStatusCode.InternalServerError);
     }
 }
Exemple #29
0
    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);
        }
    }
Exemple #30
0
 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";
 }