In this project, ınstruction numbers from a c program are counted with pin and c++.

The Output:

Total Count (Task1) 721299

Task2

Branch Count: 68083

Memory Count: 340091

Arithmetic Count: 313125

Task3

Freqquency Of RAX 1498

Freqquency Of RBX 388

Freqquency Of RCX 477

Freqquency Of RDX 713

Freqquency Of RSI 556

Freqquency Of RDI 681

Freqquency Of RSP 2403

Freqquency Of RBP 308

Freqquency Of R8 156

Freqquency Of R9 115

Freqquency Of R10 162

Freqquency Of R11 70

Freqquency Of R12 235

Freqquency Of R13 188

Freqquency Of R14 188

Freqquency Of R15 153

General Explanation:

Firstly, I downloaded matmul.c, matmul.h and matmul.sh files from the link. After that I downloaded the pin that a binary instrumentation tool. I customized some settings for pin with the following lines:

set env INTEL_JIT_PROFILER32 /ia32/bin/libpinjitprofiling.so

set env INTEL_JIT_PROFILER64 /intel64/bin/libpinjitprofiling.so

make all TARGET=intel64

Then, I opened new folder in pin/source/tools folder and run the c code in this folder. Also I put my cpp codes for pin instrumentation in this folder. After I run the matmul code , I used the output file to count instructions.

TASK -1:

In task 1, the total number of instructions were wanted. Therefore, I used a manual example from pin files which is inscount0.cpp. I used to following methods to calculate total numbers of instructions.

VOID dototalcount() { total++; }

This method just changing the number of total variable.

INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)dototalcount, IARG_END);

This method calls instructions and dototalcount method.

Also, PIN is a CISC architecture but it tries to use advantages of RISC architecture.

TASK-2:

In this task, the number of instructions wanted according to their types. I just used if conditions to find memory and branch instructions like following lines:

if (INS_IsBranch(ins)) {

INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)dobranchcount, IARG_END);

}

for (UINT32 memOp = 0; memOp < memOperands; memOp++)

{

if (INS_MemoryOperandIsWritten(ins,memOp) || INS_MemoryOperandIsRead(ins,memOp)) {

INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)domemcount, IARG_END);

}

}

However, in the memory instructions I checked if an instruction is written to memory or read from memory. If it is one of them I changed counter by 1.

Also, to calculate the arithmetic instructions I used this formula:

total-(branchcount+memcount)

TASK-3:

In this task the frequencies of usage of register in pin were asked. I just used again if conditions to calculate this for each register with different counters(c,c1,c2,c3,…….).

if (INS_RegWContain(ins,REG_RBX)) {

c2++;

}

This module will rotate the aws iam api key for supplied {{iam_username}} variable set for Windows or Linux. It uses the awscli commands to create a new key, and then updates the key on the server. A requirement is the {{iam_username}} only has 1 active key, or the 2nd key is set to INACTIVE. It creates a new key when there is only 1. If there are 2 active keys (max allowed on aws account) the playbook will fail. The playbook will delete an inactive key to make room on the account supplied in {{iam_username}}.

• Windows credentials location: C:\Users\{{aws_cli_user}}\.aws
• Linux credentials are determined from the ENV of {{aws_cli_user}} and stored in the home directory of that user.

The awscli needs to be configured on the Ansible server running the playbook. Ensure that you have correct permissions to reset and generate new IAM api keys from the account that runs the Ansible playbook.

Please define the following variables in host_vars for your server.

• iam_username
  • AWS account that is has an IAM API key generated.
• aws_cli_user
  • The account on the OS that has aws CLI configured.
• aws_region
  • AWS region in use, I.E. us-east-1
• aws_cloudfront
  • Enter true/false if you need access to AWS Cloudfront cli commands.
• notify_service (OPTIONAL)
  • Only needed if you need to restart a service after key is rotated.
• set_environment_vars (OPTIONAL)
  • Set to Yes or No. AWS API key and secret will be set in environment variables for the server. (potential security risk)

Example host_vars file:

iam_username: bouncingsoles  
aws_cli_user: user1
aws_region: us-east-1
aws_cloudfront: true
##Optional
notify_service: httpd
set_environment_vars: "Yes"

• aws-cli
  — Need to be configured on the ansible server running the playbook.
  — Correct permissions to reset and generate new IAM api keys.

- name: Rotate keys used in AWS for hosts that use api keys.
  hosts: xxxx
  roles:
     - bouncingsoles.aws-rotate-iam-key

BSD

Patrick Durante

Did you know you can embed “raw” data into an HTML <script> tag? The HTML5
spec calls them data blocks.

They look like this…

<script type="application/ld+json">
{
  "@context": "http://schema.org/",
  "type": "SoftwareApplication",
  "name": "data block extractor",
  "alternateName": "data-block-extractor"
}
</script>

This little command-line script takes a URL or a file, and extracts the content
from any data blocks found in that file.

Currently, it just dumps them to standard out and only looks for
application/ld+json, but it’s a start anyway!

For now, you have to npm i -g from inside a clone of this repository. At
somepoint, we’ll get this up on NPM for easier re-use.

However, once you’ve done that, you can run data-block-extractor anywhere to
use this awesomeness!

$ data-block-extract http://bestbuy.com/

Three results are (currently) found at BestBuy, which
looks like this in the output:

{"@context" : "http://schema.org","@type" : "WebSite","name" : "Best Buy","url" : "http://www.bestbuy.com/"}

{"@context": "http://schema.org","@type": "Organization","name": "Best Buy","url": "http://www.bestbuy.com/","sameAs": ["http://www.facebook.com/bestbuy","https://twitter.com/BestBuy","https://plus.google.com/+BestBuy","https://www.instagram.com/bestbuy/","https://www.youtube.com/user/bestbuy","https://www.linkedin.com/company/best-buy","https://pinterest.com/BestBuy"],"contactPoint": [{"@type": "ContactPoint","telephone": "+1-888-237-8289","contactType": "customer service","contactOption": "TollFree","availableLanguage": ["English","Spanish"]}, {"@type": "ContactPoint","telephone": "+1-888-574-1301","contactType": "credit card support","contactOption": "TollFree","availableLanguage": ["English","Spanish"]}]}

{"@context":"http://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"item":{"@id":"https://www-ssl.bestbuy.com/","name":"Best Buy"}}]}

At the moment there is no additional parsing, but that’s coming!

MIT

Get footy notifications about your favorite teams (via sms message)

This script uses TWILIO, a free sms-messaging gateway. Visit twilio.com, create an account, and get a twilio phone number! Once this is done, copy the twilio phone number, ACCOUNT SID, and AUTH TOKEN into the sportsCaster.py script.

Add all phone numbers that you wish to receive footy notifications to the TARGET_PHONE list.

1. Visit https://www.espn.com/soccer/scoreboard
2. Hit ctrl+u to see the source code
3. Search for ‘slug’ with ctrl+f to find leagues
4. Look for a league that you wish to add the the LEAGUE_CLUBS dictionary by searching through the instances of ‘slug’
5. Add your league’s slug value to the dictionary
6. Search for ‘shortDisplayName’ with ctrl+f to find clubs
7. Add club’s shortDisplayName value to their appropriate leagues list

Automate notifications by using crontab. On the pi cmd window enter ‘crontab -e’ and at the bottom of the list that appears enter the time and date to execute a command. The format for adding items is as follows:

min hour day month day-of-the-week command

For example:

0 9 * * * sudo python3 sportsCaster.py      # notifies you every day at 9:00 am

In the morning the scripts sends the fixtures for the day and the time the games occur.

In the afternoon the script sends results of the games of that day

Laravel is a web application framework with expressive, elegant syntax. We believe development must be an enjoyable and creative experience to be truly fulfilling. Laravel takes the pain out of development by easing common tasks used in many web projects, such as:

• Simple, fast routing engine.
• Powerful dependency injection container.
• Multiple back-ends for session and cache storage.
• Expressive, intuitive database ORM.
• Database agnostic schema migrations.
• Robust background job processing.
• Real-time event broadcasting.

Laravel is accessible, powerful, and provides tools required for large, robust applications.

Laravel has the most extensive and thorough documentation and video tutorial library of all modern web application frameworks, making it a breeze to get started with the framework.

You may also try the Laravel Bootcamp, where you will be guided through building a modern Laravel application from scratch.

If you don’t feel like reading, Laracasts can help. Laracasts contains thousands of video tutorials on a range of topics including Laravel, modern PHP, unit testing, and JavaScript. Boost your skills by digging into our comprehensive video library.

We would like to extend our thanks to the following sponsors for funding Laravel development. If you are interested in becoming a sponsor, please visit the Laravel Partners program.

• Vehikl
• Tighten Co.
• WebReinvent
• Kirschbaum Development Group
• 64 Robots
• Curotec
• Cyber-Duck
• DevSquad
• Jump24
• Redberry
• Active Logic
• byte5
• OP.GG

Thank you for considering contributing to the Laravel framework! The contribution guide can be found in the Laravel documentation.

In order to ensure that the Laravel community is welcoming to all, please review and abide by the Code of Conduct.

If you discover a security vulnerability within Laravel, please send an e-mail to Taylor Otwell via taylor@laravel.com. All security vulnerabilities will be promptly addressed.

The Laravel framework is open-sourced software licensed under the MIT license.

• Overview
  • Core Functionalities
  • Key Features
  • Benefits
• Basic Usage
• Installation
• Dependency Packages
  • Initialization and Configuration
    • Initialization
    • Configuration
• Utilization
  • Request functions from server
    • Passed Arguments: Request functions from server
    • Returned Object: Request functions from server
  • Retrieve functions from collections
  • Create collection record function
  • Remove collection record functions
  • Push collection record function
• Collection Records: Properties and Functions
• Root Scope: Functions
• Utility Functions
  • Data Retrieval and Manipulation
  • Data Validation and Comparison

ARM (API Resource Manager) is a JavaScript library designed to centralize data management and simplify interactions with APIs. By providing a structured approach to handling and storing fetched data, ARM promotes efficient and flexible data usage throughout your application.

• Centralized Data Storage: Organizes fetched data into easily accessible collections, acting as a single source of truth for your application’s data.
• API Interactions: Manages API requests and responses, providing methods for common HTTP operations (GET, POST, PUT, DELETE).
• Caching: Optimizes performance by caching frequently accessed data, reducing API calls and improving response times.
• Request Management: Tracks ongoing requests to prevent redundancy and manages their state.
• Utility Functions: Offers helper functions for data manipulation, filtering, sorting, and other common operations.
• Root Scope: An object that can be used to store and manage global state.

• Collections: Stores fetched data in collections for efficient retrieval and management.
• Record Management: Provides methods to create, update, delete, and retrieve individual records within collections.
• Reactive Data: Employs observable patterns (likely through a library like Mobx) to enable real-time updates and dependency tracking.
• Asynchronous Operations: Handles API interactions asynchronously using Promises for non-blocking operations.
• Error Handling: Manages errors gracefully and provides informative feedback.
• Configurability: Allows customization of API endpoints, headers, and request behavior.
• Extensibility: Can be integrated with other libraries and frameworks to fit various application architectures.

• Centralized Data Access: Provides a single source of truth for application data, ensuring consistency and reducing data duplication.
• Improved Performance: Caching and optimized request management enhance application speed.
• Enhanced Developer Experience: Simplifies data management and reduces boilerplate code.
• Flexibility: Can be used across different components and parts of an application.
• Maintainability: Promotes code organization and reduces potential inconsistencies.

By centralizing data management and offering flexible access to it, ARM empowers developers to build more efficient, scalable, and maintainable applications.

// Example usage in ReactJS

import { observer } from 'mobx-react'
import { ARM } from '@components/arm-config-wrapper'

const App = observer(() => {
  const { isLoading, isError, data: address } = ARM.findRecord(
    'addresses',
    123456,
    { include: 'user' },
    { alias: 'customerAddress' }
  )

  return (
    <div className="App">
      {isLoading && <span>Loading...</span>}
      {!isLoading && (
        <div className="form">
          <label>Address1 </label>
          <input
            value={address.get('attributes.address1')}
            onChange={(event) =>
              address.set('attributes.address1', event.target.value)
            }
          />
          &nbsp;
          <button
            onClick={() => {
              address
                .save()
                .then((result) => console.log(result))
                .catch((error) => console.log(error))
            }}
          >
            {address.get('isLoading') ? 'Saving' : 'Save'}
          </button>
        </div>
      )}
    </div>
  )
})

export default App

npm install arm-js-library --save

npm install mobx-react --save

Create arm-config-wrapper component that will store the new ARM instance.

• Store it on component wrapper src/components/arm-config-wrapper/index.js here’s an example

  // Tag component wrapper as client for NextJS specific only
  'use client'
  
  // Create a new instance of ARM
  import ApiResourceManager from 'arm-js-library'
  
  // Create an array of collections to initialize
  const collections = ['addresses', 'users']
  
  // Export new instance of ARM for later utilization
  export const ARM = new ApiResourceManager(collections)
  
  // Main config wrapper
  const ARMConfigWrapper = ({ children }) => {
    return <>{children}</>
  }
  
  export default ARMConfigWrapper

• For NextJS project, wrap root layout src/app/layout.js with arm-config-wrapper component here’s an example

  import dynamic from 'next/dynamic'
  
  const ARMConfigWrapper = dynamic(
    () => import('../components/arm-config-wrapper'),
    { ssr: false }
  )
  
  export default function RootLayout({ children }) {
    return (
      <html lang="en">
        <body>
          <ARMConfigWrapper>{children}</ARMConfigWrapper>
        </body>
      </html>
    )
  }

• For non NextJS project, wrap root app src/index.js with arm-config-wrapper component.

  import ARMConfigWrapper from '@components/arm-config-wrapper'
  import ReactDOM from 'react-dom/client'
  import App from './App'
  
  const root = ReactDOM.createRoot(document.getElementById('root'))
  root.render(
    <ARMConfigWrapper>
      <App />
    </ARMConfigWrapper>
  )

Configure stored ARM instance from where you stored it, to be able to use it on your application.

Required configurations

• setHost(value)

  // Set API endpoint host URL
  // By default host is set to window.location.origin
  ARM.setHost('https://www.test-demo.com')

• setHeadersCommon(key, value)

  // Set common request headers required on calling API endpoints
  // ie. Authoization, Content-Type, etc.
  ARM.setHeadersCommon('Authorization', `${token}`)
  ARM.setHeadersCommon('Content-Type', 'application/vnd.api+json')
  ARM.setHeadersCommon('X-Client-Platform', 'Web')

• setNamespace(value)

  // Set namespace for API endpoint host URL
  // By default namespace is set to 'api/v1'
  ARM.setNamespace('api/v1')

Optional configurations

• setGlobal(value)

  // Set ARM instace to global
  // This will make ARM instance available on browser window object via window.ARM
  // Example:
  //  console.log(window.ARM)
  ARM.setGlobal()

• setPayloadIncludeReference(value)

  // Set payload included reference key
  // Payload included reference key serve as mapper to determine what collection
  // the data received belongs to
  // Example:
  //  {
  //    data: [...],
  //    included: [ { id: 1, type: 'addresses' } ]
  //  }
  ARM.setPayloadIncludeReference('type')

To be able to use ARM features. You have to import the stored ARM instance from arm-config-wrapper component.

// ARM instance is stored on src/components/arm-config-wrapper/index.js
import { ARM } from '@components/arm-config-wrapper'

• query(resource, params, config)
  • Querying multiple records from the server.
  • Support query params. – required
  • Support config. – optional

  ARM.query(
    'addresses',
    {
      sort: '-id',
      include: 'user',
    },
    {
      alias: 'customerAddresses',
    }
  )

• queryRecord(resource, params, config)
  • Querying for a single record from the server.
  • Support query params. – required
  • Support config. – optional

  ARM.queryRecord(
    'addresses',
    {
      id: 123456,
      sort: '-id',
      include: 'user',
    },
    { alias: 'customerAddress' }
  )

• findAll(resource, config)
  • Retrieving multiple records from the server.
  • Support config. – optional

  ARM.findAll('addresses', {
    alias: 'customerAddresses',
  })

• findRecord(resource, id, params, config)
  • Retrieving single record from the server.
  • Params ID by default. – required
  • Support query params. – required
  • Support config. – optional

  ARM.findRecord(
    'addresses',
    123456,
    { include: 'user' },
    {
      alias: 'customerAddress',
    }
  )

    // Example: https://www.test-demo.com/api/v1/addresses/1?include=user
    ARM.findRecord('addresses', 123456,
      { 
        include: 'user' 
      },
      {
        skip: true,
        alias: 'customerAddress',
      }
    )

• resource – String
  • https://www.test-demo.com/api/v1/ addresses /1?include=user
  • Endpoint resource name.
  • Serve as collection name defined on the collection intialization of ARM instance.
• id – Number
  • https://www.test-demo.com/api/v1/addresses/ 1?include=user
  • Endpoint id parameter.
• params – Object
  • https://www.test-demo.com/api/v1/addresses/1? include=user
  • Endpoint query string parameters.
• config – Object
  • Contains request config such as (skip, alias, autoResolve, ignorePayload, override) which are currently available.

    {
      // Skip serve as request go signal to proceed 
      // if Request B has dependency on Request A
      skip: true,
  
      // Alias serve as identifier for the records obtain from the server.
      // Can be used anywhere in your application through ARM.getAlias('customerAddress')
      alias: 'customerAddress' ,
  
      // Auto resolve serve as flag if the request functions will return 
      // 1. Promise Function
      //  - To handle success and errors on manual resolve) if autoResolve is set to false
      // 2. Observable/Reactive Data
      //  - To handle success and errors on auto resolve) if autoResolve is set to true 
      // Note: autoResolve is only available on query, queryRecord, findAll, findRecord functions.
      // By default autoResolve is set to true.
      autoResolve: false,
  
      // Ignore payload serve as list of keys to be omitted on request payload.
      ignorePayload: ['attributes.address2', 'attributes.address1'],
  
      // Override serve as request override for the default configuration of axios current request.
      // Currently support host, namespace, path and headers for the meantime.
      // Example:
      // Before override: https://www.test-demo.com/api/v1/users/1
      // After override: https://www.another-test-demo.com/api/v2/update-users/1
      override: {
        host: 'https://www.another-test-demo.com',
        namespace: 'api/v2',
        path: `update-users/${user.get('id')}`,
        headers: {
          'X-Client-Platform': 'Symbian',
        }
      }
    }

• isLoading – Boolean
  • Current loading state of the request.
  • By default set to true.
  • Set to true once the request is initiated and set to false once request is done.
• isError – Boolean
  • Current error state of the request.
  • By default set to false.
  • Set to true if the request received/encountered an error and set to false if none.
• isNew – Boolean
  • Identifier if the request is newly created.
  • By default set to true.
  • Set to true if the request is already initiated once and set to false once it is already intiated before. Request functions are built with optimization, it does not repeatedly executing API request. Since it is optimized, it can be override using skip from request configuration.
• data – Array || Object
  • Contains the request returned payload.
  • By default has value of an empty array or object depending on the request function used.
• error – Object || String
  • Contains the request returned error.
  • By default has value of a null.
• included – Array
  • Contains the request returned payload property included.
  • Specifically for JSON API.
• meta – Object
  • Contains the request returned payload property meta.
  • Specifically for JSON API.
• reload – Function
  • Allows for re-execution of a request and automatic update of the request hash object and relevant collections.

// Returned object data properties are observable
// It will automatically update once the request is already done
{
  isLoading: true,
  isError: false,
  isNew: true,
  data: [],
  error: null,
  included: [],
  meta: {},
  reload: function
}

• peekAll(collectionName)
  • Retrieving multiple records from collection.

  ARM.peekAll('addresses')

• peekRecord(collectionName, collectionRecordId)
  • Retrieving single record from collection.
  • Params ID by default. – required

  ARM.peekRecord('addresses', 123456)

• getCollection(collectionName)
  • Retrieving all records from collection.

  ARM.getCollection('addresses')

• getAlias(collectionName, collectionFallbackRecord)
  • Retrieving records from aliased request results.
  • Support collectionFallbackRecord. – optional

  const addresses = ARM.getAlias('customerAddresses', [])
  
  ARM.findAll('addresses', { alias: 'customerAddresses' })
  
  <ul>
    {addresses.map((address, index) => (
      <li key={index}>{address.get('id')}</li>
    ))}
  </ul>

• createRecord(collectionName, collectionRecord, collectionRecordRandomId)
  • Create new collection record.
  • By default collectionRecord params is set to empty object if omitted – required
  • By default collectionRecordRandomId params is set to true – optional

  // Usage #1
  // Can ommit collectionRecord on createRecord initialization
  const newAddress = ARM.createRecord('addresses')
  newAddress.set('attributes.kind', 'school')
  newAddress.set('attributes.label', 'My school')
  
  // Usage #2
  // Can ommit collectionRecord on createRecord initialization
  const newAddress = ARM.createRecord('addresses', {
    attributes: { kind: 'school', label: 'My school' }
  })
  
  // Persist collection record to server.
  // Will call POST /addresses
  newAddress.save()

• unloadRecord(collectionRecord)
  • Remove record from collection only.

  // Collection record to be remove collection.
  const address = ARM.peekRecord('addresses', 123456)
  
  // This will remove the record from collection and will not
  // remove permanently from the server.
  ARM.unloadRecord(address)

• clearCollection(collectionName)
  • Clears a specified collection and unloads related records from aliases and request hashes.

  ARM.clearCollection('addresses')

• pushPayload(collectionName, collectionRecords)
  • Push raw collection record/records to respective collections.

  // Retrieve raw data with barebone ajax/fetch function.
  ARM.ajax({
    method: 'get',
    url: 'addresses/12345'
  }).then(results => {
    // Will add/update collection records.
    ARM.pushPayload('addresses', results.data.data)
  })

// Example response data from API
// See available properties, getter and  setter functions and request functions below.
{
  "id": 123456,
  "type": "addresses",
  "attributes": {
    "address1": "Test Address 1",
    "address2": "1718729541222",
    "kind": "office",
    "label": "Anabu Hills",
    "latitude": "14.394261",
    "longitude": "120.940783"
  }
}

• State Properties
  • isLoading – Boolean
    • Current loading state of the record.
    • By default set to false.
    • Set to true once request functions (save, reload, destroyRecord) are initiated and set to false once done.

    address.get('isLoading')

  • isError – Boolean
    • Current error state of the record.
    • By default set to false.
    • Set to true once request functions (save, reload, destroyRecord) received an error and set to false if none.

    address.get('isError')

  • isPristine – Boolean
    • Current pristine state of the record.
    • By default set to true.
    • Set to false if the record is modified and set to true once reverted.

    address.get('isPristine')

  • isDirty – Boolean
    • Current dirty state of the record.
    • By default set to false.
    • Set to true if the record is modified and set to false once reverted.

    address.get('isDirty')

• Getter and Setter Functions
  • get(key)
    • Single property getter function.
    • Passed arguments:
      • key – String

    // Returned value 123456
    address.get('id') 
    
    // Returned value 'office'
    address.get('attributes.label') 

  • set(key, value)
    • Single property setter function.
    • Passed arguments:
      • key – String
      • value – Primitive

    // Returned value 'office'
    address.get('attributes.kind')
    
    // Set property label of attributes
    address.set('attributes.kind', 'school')
    
    // Returned value 'office'
    address.get('attributes.kind')

  • setProperties(value)
    • Multiple properties setter function.
    • Passed arguments:
      • value – Object

    // Returned value 'office'
    address.get('attributes.kind')
    // Returned value 'Anabu Hills'
    address.get('attributes.label')
    
    // Set properties label and kind of attributes
    address.setProperties({
      attributes: { kind: 'school', label: 'My School' }
    })
    
    // Returned value 'school'
    address.get('attributes.kind')
    // Returned value 'My School'
    address.get('attributes.label')

• Request Functions
  • save(collectionConfig)
    • Persist collection record changes to server.
    • Create a new record to server only if it doesn’t already exist in the database.
      • Will call POST method: POST /addresses
    • Update existing record to server.
      • Will call PUT method: PUT /addresses/123456
    • Support collectionConfig. – optional
      • Available collectionConfig (skip, alias, autoResolve, ignorePayload, override)

    // Returned promise
    // Without collectionConfig
    address.save()
    
    // With collectionConfig
    address.save({ ignorePayload: ['attributes.address2'] })

  • reload()
    • Refresh collection record changes from server.
      • Will call GET method: GET /addresses/123456
    • Support collectionConfig. – optional
      • Available collectionConfig (skip, alias, autoResolve, ignorePayload, override)

    // Returned promise
    address.reload()
    
    // With collectionConfig
    address.reload({ 
       override: {
           namespace: 'api/v2',
       }
    })

  • destroyRecord(collectionConfig)
    • Remove collection record permanently from server.
      • Will call GET method: DELETE /addresses/123456
    • Support collectionConfig. – optional
      • Available collectionConfig (skip, alias, autoResolve, ignorePayload, override)

    // Returned promise
    // Without collectionConfig
    address.destroyRecord()
    
    // With collectionConfig
    address.destroyRecord({
      override: {
        host: 'https://ww7.test-demo.com',
        namespace: 'api/v2',
        path: `destroy-addresses/${address.get('id')}`,
      }
    })

  • getCollection(collectionName, collectionConfig)
    • Retrieve records from server automatically if async option value is set to true true on collectionConfig.
    • Retrieve records that are already loaded on collection if async option value is set to false on collectionConfig.
    • Passed arguments:
      • collectionName – String
      • collectionConfig – Object
        • referenceKey – String
          • Collection record property mapping.
        • async – Boolean
          • Flag for invoking request function on resolving not yet loaded records on collection.
        • filterBy – Object
          • Filter return collection records based on passed filter properties.
        • sortBy – Array
          • Sort returned collection records based on passed array of sort criteria.
        • config – Object
          • Contains request config such as (skip, alias, autoResolve, ignorePayload, override) which are currently available.

    // Get user record from the server but don't preload addresses records.
    const { isLoading, data: user } = ARM.findRecord(
      'users',
      123456,
      {
        // include: 'user'
      },
      { alias: 'currentUser' }
    )
    
    // The getCollection function will populate records from collection
    // and server depending on passed collectionConfig.
    {!isLoading && (
      <ul>
        {user
          .getCollection('addresses', {
            referenceKey: 'relationships.addresses.data',
            async: true,
            sortBy: ['id:desc'],
            filterBy: {
              attributes: {
                'label': 'Test'
              }
            },
            override: {
              namespace: 'api/v2',
            }
          })
          .map((address, index) => (
            <li key={index}>{address.get('id')}</li>
          ))}
      </ul>
    )}

The root scope is an object that can be used to store and manage global state. The Root Scope Functions provide a way to manage and access it.

• setRootScope(rootScopeProperty, rootScopeValue)

  • Sets a value on the root scope.
  • Passed arguments:
    • rootScopeProperty – String
    • rootScopeValue – Any

  // Set root scope property 'fullName' to 'John Doe'
  ARM.setRootScope('fullName', 'John Doe')

• getRootScope(rootScopeProperty)

  • Retrieves a value from the root scope.
  • Passed arguments:
    • rootScopeProperty – String

  // Returns value 'John Doe'
  ARM.getRootScope('fullName')

Collection of utility functions that leverage Lodash for common data manipulation tasks. These functions primarily focus on searching, filtering, sorting, and validating data within objects or arrays.

// Example response data from API
const addresses = [
   {
     "id": 1,
     "attributes": {
       "kind": "office",
       "label": "My Office",
     }
   },
   {
     "id": 2,
     "attributes": {
       "kind": "school",
       "label": "My School",
     }
   },
   {
     "id": 3,
     "attributes": {
       "kind": "school",
       "label": "My Brother's School",
     }
   }
 ]

• findBy(objects, findProperties)

  • Finds the first element in the given array of objects that satisfies the provided find properties.

  // Return record with id 1
  ARM.findBy(addresses, { id: 1 })

• findIndexBy(objects, findIndexProperties)

  • Returns the index of the first element in the given array of objects that satisfies the provided find properties.

  // Return index number of record with id 1
  ARM.findIndexBy(addresses, {
    attributes: { kind: 'office' }
  })

• filterBy(objects, filterProperties)

  • Creates a new array with all elements from the given array of objects that pass the filter test implemented by the provided filter properties.

  // Returns records with ids 2 and 3
  ARM.filterBy(addresses, {
    attributes: { kind: 'school' }
  })

• uniqBy(objects, uniqByProperty)

  • Removes duplicate objects from an array based on a unique property.

  // Returns records with ids 1 and 2
  ARM.uniqBy(addresses, 'attributes.kind')

• uniq(values)

  • Removes duplicate values from an array.

  // Returns array with 1,2,3
  ARM.uniq([1, 2, 2, 3, 3, 3])

• groupBy(objects, groupByProperty)

  • Incorrectly uses uniqBy instead of grouping objects by the specified property.

  // Returns { school: [{ id: 2 }, { id: 3 }], office: [{ id: 1 }]} 
  ARM.groupBy(addresses, 'attributes.kind')

• mapBy(objects, mapByProperty)

  • Maps an array of objects, extracting a specific property from each.

  // Returns ['office', 'school', 'school']
  ARM.mapBy(addresses, 'attributes.kind')

• firstObject(objects)

  • Returns the first element from the given array of objects. If the array is empty, it returns undefined.

  // Return record with id 1
  ARM.firstObject(addresses)

• lastObject(objects)

  • Returns the last element from the given array of objects. If the array is empty, it returns undefined.

  // Return record with id 3
  ARM.lastObject(addresses)

• mergeObjects(objects, otherObjects)

  • Combines two arrays of objects into one, removing duplicates.

  ARM.mergeObjects(addresses, otherAddresses)

• chunkObjects(objects, chunkSize)

  • Splits an array of objects into smaller arrays of a given size.

  ARM.chunkObjects(addresses, 2)

• sortBy(objects, sortProperties)

  • Sorts the given array of objects by the specified sort properties.

  // Returns records order by ids 1,2,3
  ARM.sortBy(addresses, ['id:asc'])
  
  // Returns records order by ids 3,2,1
  ARM.sortBy(addresses, ['id:desc'])

• ajax(config)

  • Axios instance under the hood with default ARM config.
  • Config accepts all properties that can be passed on axios.request config.

  // Return promise
  ARM.ajax({
    method: 'get',
    baseURL: 'https://other-api.test-demo.com',
    url: '/api/v1/addresses'
  })
  .then(results => console.log(results))
  .catch(errors => console.log(errors))

• isEmpty(value)
  • Checks if a value is considered empty (null, undefined, empty string, empty array, or empty object).

  // Return boolean value
  ARM.isEmpty(value)

• isPresent(value)
  • Returns the opposite of isEmpty.

  // Return boolean value
  ARM.isPresent(value)

• isEqual(value, other)
  • Performs a deep comparison between two values to determine if they are equal.

  // Return boolean value
  ARM.isEqual(value, other)

• isNumber(value)
  • Checks if a value is a number.

  // Return boolean value
  ARM.isNumber(value)

• isNil(value)
  • Checks if a value is null or undefined.

  // Return boolean value
  ARM.isNil(value)

• isNull(value)
  • Checks if a value is null.

  // Return boolean value
  ARM.isNull(value)

• isGte(value, other)
  • Checks if the first value is greater than or equal to the second value.

  // Return boolean value
  ARM.isGte(value, other)

• isGt(value, other)
  • Checks if the first value is greater than the second value.

  // Return boolean value
  ARM.isGt(value, other)

• isLte(value, other)
  • Checks if the first value is less than or equal to the second value.

  // Return boolean value
  ARM.isLte(value, other)

• isLt(value, other)
  • Checks if the first value is less than the second value.

  // Return boolean value
  ARM.isLt(value, other)

Voice Logger is an application the uses Microsoft’s Kinect (V1) for recording voice logs that can then be exported to a ZIP file for storage or sharing. The idea was instead of putting comments in the code for myself to refer back to after a weekend of coding I could record voice logs instead. I used the Kinect as it was a prize I won in a recent university competition and I was excited to use it.

The application was written in C# and uses the Kinect SDK for voice recognition and NAudio for audio file creation. The UI is WPF based with help from the Metro UI framework which helps give the app modern styling to look more professional. The application uses the built in voice recognition technology found in the Kinect so interaction with the GUI isn’t necessary and instead commands can be issued via voice saving time and means the app doesn’t get in the way of coding.

• Voice commands
• Archive exporting
• Modern UI

• Screenshot feature
• Microphone backup
• MVVM refactor

Apache 2.0

Original Thread can be found here: https://forum.kodi.tv/showthread.php?tid=210625

This theme was originally made by Toyota12303. Subsequently, the download links for the theme and sound theme hosted by Toyota12303 (hosted on Google Drive) was invalid.

Later on, another user (SZNX) on the Kodi Forums uploaded a copy of the sound theme, but it didn’t seem to work properly.

Delving into the XML file (sounds.xml), there were a few issues, causing the theme to not work. (It would work fine on Windows since windows does not care about case sensitivity of file names)

I have corrected issues in the XML regarding the filenames and fixed the indentation to make it more readable. Tested it successfully on Kodi 21.1 (Omega)

• Download this repository and zip the resource.uisounds.PlayStation directory
  • The directory must be zipped with a .zip extension.
  • Use Store compression
• Open Kodi and go to Settings -> File Manager
• Select Install from ZIP file
• Locate this zip file and follow on screen prompts.
• Once installed, go to Settings -> System -> Audio
• In that, you’ll find an option called UI Sounds or something similar
• Select it and choose the PlayStation 4 UI Sounds

• I don’t plan to update this by adding more sounds for different actions and whatnot. I may fix it if future versions of Kodi changes something.
• Please do not request me to make new sound themes inspired from newer Xbox or PlayStation devices.

Check out our github pages at: https://sccapstone.github.io/WaitList/

Application available at: http://uofscwaitlist.meteorapp.com

Login for admin page

email: redmonc2@email.sc.edu

password: asdfasdf

Any number should be able to receive messages as long as the “opt in for text” box is checked on submission.

If you need to test this application, please contact either either Cory Redmond (redmonc2@email.sc.edu) or Eddie Pace (paceea@email.sc.edu) member and we will deploy it. We do not keep it deployed all the time because we pay by the hour for it to be up

For testing the “forgot password” function. Send us one of your emails and we will change the admin account email to match it. The password will remain “asdfasdf”. This web application only uses one account as per clients request.

This is the page that will be displayed for all students who wish to add themselves to the waitlist.

Sign-in – drop menu to sign in to the admin account using the valid e-mail and password. a “forgot password” funciton is also provided to send to the valid admin e-mail account.

Check Wait Time – A prompt to enter a phone number. If the phone number is currently attributed to a student in the wait list, it will return their current estimated remaining time.

Name – (Required field)

Phone Number – (Required field) – will only accept properly formatted numbers of 10-digits with no white-space or non-integer values.

USC ID – (Required field) – USC ID is 9-digits/characters long.(foun on back of student ID cards).

Reason for Visit – (Required field) – 3 drop-down options as per client request.

Current Major – (Required field) – A list of all majors offered at UofSC-Columbia. This list will auto-complete and show a list of majors that match what you currenty have typed in for you to select.

Intended Major – (Optional) – Same as Current Major.

Comments – (Optional) – A text field to allow students to write anything they wish the Advisor to see before entering the appointment.

Text service radio buttion – Checking this button to opt in for texting services will send text notifications to the phone number inputed in Phone Number field. This will first alert you that you have been added to the list. You can respond with either “Time” to get your current estimated remaining wait time or respond “Remove” to be removed form the waitlist.

Submit – submits form to database

This is the page for the administrator who will be advising during drop in hours.

The header will be similar to that of the Sign up page, but will just contain the dropdown for signing out or changing the password while logged in as an admin. It will also have a download archive button

Download Archive – This will download a csv file of every person saved in an archive when they are removed from the wait list.

This page contains a table with all people currently on the wait list. It is sorted based off of who submitted their information first.

This has each row show (Name, Phone number, USCID, Button selections, and current status).

Expand button – This is the button with a plus sign on the left side of each row. If this button is pressed the row will expand and show a hidden row within the table that will show (Reason for visit, Current major, Intended major, and any submitted comments). This can be pressed again to hide the row.

Edit button – This button will bring a modal with a form similar to that of the sign in page (excludes comments and opt in for text radio button). It will populate the field with the selected students information and if any of that information is changed on submission it will then change in the table.

Delete button – This will bring up a modal for confirmation of deleting the selected student from the wait list.

Move button – This button is the one with a down arrow. This will move the specific student to the botton of the wait list and will reorder all wait times.

Check-in button – This is a button that will change the current status field to “In Advisement” if pressed. If you wish to change the status back to “Waiting” double click on the check-in buttons (this is for accidental clicks on the check-in button). This is meant to be a check for the advisor to help keep track of who is in advisement if there are multiple advisors advising at one time.

Check-out buttons – Basically the same thing as the delete button. It will bring up a modal for confirmation that the student has completed their advisement. If selected as done then the student will be removed from the list. This is meant to be a clarification button for the adminstrative user to try and reduce confusion of what to do once the person is done with advisement.

After the students sumbit the form, it will route to this secret page automatically. It will show the students their wait time on the screen. Also, the students can refer back to the page and check their wait time when they add their phone number after the “https://github.com/” in the URL. The wait time will update automatically.

Sign-in – drop menu to sign in to the admin account using the valid e-mail and password. a “forgot password” funciton is also provided to send to the valid admin e-mail account.

Check Wait Time – A prompt to enter a phone number. If the phone number is currently attributed to a student in the wait list, it will return their current estimated remaining time.

Back to Sign Up Page Button – This button act as a home button for the students. It will route back to Sign Up page when a new student try to sumbit a form after others.

Cory Redmond, Eddie Pace, Ryan Morvay, Bao Li, Run Liang