// Remove class from body tag
function alpha_body_class($classes){
unset($classes[array_search('class-one', $classes)]);
unset($classes[array_search('class-two', $classes)]);
unset($classes[array_search('class-three', $classes)]);
return $classes;
}
add_filter('body_class', 'alpha_body_class');
# //almost identical to doubly linked list but
# //every node has another pointer to previous node
# //Advantages: able to access list at end instead of going from start
# //Disadvantages: takes up more memory
class Node:
def __init__(self, value, next=None, previous=None):
self.value = value
self.next = next
self.previous = previous
class DoublyLinkedList:
def __init__(self, head=None, tail=None, length=0):
self.head = head
self.tail = tail
self.length = length
#add to end of list
def append(self, value):
new_node = Node(value)
#if there is no head (list is empty), set head and tail to be new_node
if self.head == None:
self.head = new_node
self.tail = new_node
#otheriwse, set next property on tail to be new node and set tail to be newly created node
else:
self.tail.next = new_node
new_node.previous = self.tail
self.tail = new_node
#increment length and return
self.length += 1
return self
#removes last element of list
def pop(self):
if self.head == None:
return None
#current will eventually be the last elemeent and will be removed
current = self.head
#variable right before end
new_tail = current
#while loop to traverse to end
while current.next:
new_tail = current
current = current.next
#sets new tail
self.tail = new_tail
#cuts off old tail and current previous property
self.tail.next = None
current.previous = None
#decrement list
self.length -= 1
#to account when list will be destroyed
if self.length == 0:
self.head = None
self.tail = None
return current
#removes elememnt at head. Note in python, shift doesn't exist, it would be .pop(0) or you can use remove which is defined later
def shift(self):
if self.head == None:
return None
#current_head will be removed and returned
current_head = self.head
self.head = current_head.next
#severs new self.head previous property
self.head.previous = None
self.length -= 1
#to account when list will be destroyed
if self.length == 0:
self.tail = None
#severs current_head. Note previous is already set to None
current_head.next = None
return current_head
#adds to start of list and replaces head. I included shift/unshift because this is what makes linked list special in terms of reducing big O
def unshift(self, value):
new_node = Node(value)
#edge case to account if list is originally empty
if self.head == None:
self.head = new_node
self.tail = self.head
else:
temp = self.head
self.head = new_node
self.head.next = temp
temp.previous = self.head
self.length += 1
#travels to node at index and returns node
def traverse(self, index):
if index < 0 or index >= self.length:
raise IndexError('index out of range')
counter = 0
current = self.head
#since this is doubly linked list, you can also approach from tail and go backwards
while counter != index:
current = current.next
counter += 1
return current
#travels to node at index and returns node's value
def get(self, index):
#to accomodate normal python function, where if you give index = -1 in a get(), it will return last index and so on
if index < 0:
index = self.length + index
node = self.traverse(index)
return node.value
#replaces value at index
def set(self, index, value):
found_node = self.traverse(index)
if found_node:
found_node.value = value
return True
else:
return False
#insert value at index and adds 1 to length, returns boolean if successful
def insert(self, index, value):
if index < 0 or index > self.length:
raise IndexError('index out of range')
if index == self.length:
#not not is similar to !! in javascript and it's so it returns a boolean if successful
return not not self.append(value)
if index == 0:
return not not self.unshift(value)
else:
new_node = Node(value)
previous_node = self.traverse(index - 1)
after_node = previous_node.next
#creating relations before new_node
previous_node.next = new_node
new_node.previous = previous_node
#creating relations after new_node
new_node.next = after_node
after_node.previous = new_node
#increment length
self.length += 1
return self
def remove(self, index):
if index < 0 or index > self.length:
return indexError('index out of range')
if index == self.length - 1:
return self.pop()
if index == 0:
return self.shift()
else:
#need to get previous node and after node to create relationships
previous_node = self.traverse(index - 1)
#removed_node will be removed and returned
removed_node = previous_node.next
after_node = removed_node.next
#unlink removed_node
previous_node.next = removed_node.next
after_node.previous = previous_node
#sever removed_node next
removed_node.next = None
removed_node.previous = None
self.length -= 1
return removed_node
#common interview question
def reverse(self):
#switching head and tail
current = self.head
self.head = self.tail
self.tail = current
next, previous = None, None
#to show for loop is possible in LL. Could use while loop as well
for i in range(0, self.length):
#think of this as creating the block
next = current.next
current.next = previous #initially None
current.previous = next
#think of this as connecting head/previous to the block
previous = current
current = next
return self
# # // [100. 201, 250, 350, 999]
# # // first part
# # // NODE NEXT
# # // 100 -> null
# # // second part (for loop and beyond)
# # // PREV NODE NEXT
# # // line 154( prev = current; ) specifically:
# # // 201 -> 100 -> null
# # // line 155 (current = next;):
# # // PREV NODE NEXT
# # // 250 -> 201 -> 100
#useful to visualize reverse() or any other function works
def print_linkedlist_to_list(self):
result = []
current = self.head
while current:
result.append(current.value)
current = current.next
print(result)
# l = DoublyLinkedList()
# l.append(1)
# l.append(2)
# l.pop()
# l.shift()
# l.unshift(3)
# l.append(4)
# l.traverse(0)
# l.get(-2)
# l.set(2, 7)
# l.insert(0, 99)
# l.remove(2)
# l.print_linkedlist_to_list()
# l.reverse()
# l.print_linkedlist_to_list()
# y = l.length
# print(y)
# // Insertion:
# // O(1)
# // Removal: recall in SL it depends
# // O(1)
# // Searching:
# // O(N) but optimized bc you can start from head or tail (but more memory)
# // Access:
# // Same as searching
class Node:
def __init__(self, value, next=None):
self.value = value
self.next = next
class SinglyLinkedList:
def __init__(self, head=None, tail=None, length=0):
self.head = head
self.tail = tail
self.length = length
#add to end of list
def append(self, value):
new_node = Node(value)
#if there is no head (list is empty), set head and tail to be new_node
if self.head == None:
self.head = new_node
self.tail = self.head
#otheriwse, set next property on tail to be new node and set tail to be newly created node
else:
self.tail.next = new_node
self.tail = self.tail.next
#increment length and return
self.length += 1
return self
#removes last element of list
def pop(self):
if self.head == None:
return None
#current will eventually be the last elemeent and will be removed
current = self.head
#variable right before end
new_tail = current
#while loop to traverse to end
while current.next:
new_tail = current
current = current.next
#sets new tail
self.tail = new_tail
#cuts off old tail
self.tail.next = None
#decrement list
self.length -= 1
#to account when list will be destroyed
if self.length == 0:
self.head = None
self.tail = None
return current
#removes elememnt at head. Note in python, shift doesn't exist, it would be .pop(0) or you can use remove which is defined later
def shift(self):
if self.head == None:
return None
current_head = self.head
self.head = current_head.next
self.length -= 1
#to account when list will be destroyed
if self.length == 0:
self.tail = None
return current_head
#adds to start of list and replaces head. I included shift/unshift because this is what makes linked list special in terms of reducing big O
def unshift(self, value):
new_node = Node(value)
#edge case to account if list is originally empty
if self.head == None:
self.head = new_node
self.tail = self.head
else:
temp = self.head
self.head = new_node
self.head.next = temp
self.length += 1
#travels to node at index and returns node
def traverse(self, index):
if index < 0 or index >= self.length:
raise IndexError('index out of range')
counter = 0
current = self.head
while counter != index:
current = current.next
counter += 1
return current
#travels to node at index and returns node's value
def get(self, index):
#to accomodate normal python function, where if you give index = -1 in a get(), it will return last index and so on
if index < 0:
index = self.length + index
node = self.traverse(index)
return node.value
#replaces value at index
def set(self, index, value):
found_node = self.traverse(index)
if found_node:
found_node.value = value
return True
else:
return False
#insert value at index and adds 1 to length, returns boolean if successful
def insert(self, index, value):
if index < 0 or index > self.length:
raise IndexError('index out of range')
if index == self.length:
#not not is similar to !! in javascript and it's so it returns a boolean if successful
return not not self.append(value)
if index == 0:
return not not self.unshift(value)
else:
new_node = Node(value)
previous_node = self.traverse(index - 1)
temp = previous_node.next
#set next property of previous node to be new_node
previous_node.next = new_node
#set new_node next to be old next of previous
#you can also write this as previous_node.next.next = temp
new_node.next = temp
self.length += 1
return True
def remove(self, index):
if index < 0 or index > self.length:
return indexError('index out of range')
if index == self.length - 1:
return self.pop()
if index == 0:
return self.shift()
else:
#need to get previous node to create relationships
previous_node = self.traverse(index - 1)
#removed_node will be removed and returned
removed_node = previous_node.next
#unlink removed_node
previous_node.next = removed_node.next
#sever removed_node next
removed_node.next = None
self.length -= 1
return removed_node
#common interview question
def reverse(self):
#switching head and tail
current = self.head
self.head = self.tail
self.tail = current
next, previous = None, None
#to show for loop is possible in LL. Could use while loop as well
for i in range(0, self.length):
#think of this as creating the block
next = current.next
current.next = previous #initially None
#think of this as connecting head/previous to the block
previous = current
current = next
return self
# // [100. 201, 250, 350, 999]
# // first part
# // NODE NEXT
# // 100 -> null
# // second part (for loop and beyond)
# // PREV NODE NEXT
# // line 154( prev = current; ) specifically:
# // 201 -> 100 -> null
# // line 155 (current = next;):
# // PREV NODE NEXT
# // 250 -> 201 -> 100
#useful to visualize reverse() works
def print_linkedlist_to_list(self):
result = []
current = self.head
while current:
result.append(current.value)
current = current.next
print(result)
l = SinglyLinkedList()
l.push(1)
l.push(2)
l.pop()
l.shift()
l.unshift(3)
l.push(4)
l.traverse(0)
l.get(-2)
l.set(2, 7)
l.insert(0, 99)
l.remove(2)
l.print_linkedlist_to_list()
l.reverse()
l.print_linkedlist_to_list()
y = l.length
print(y)
# //Big O:
# //Insertion: O(1)
# //Removal: depends O(1) if start or O(N) at end
# //Above 2 are main advantages vs. arrays esp at start
# //Searching: O(N)
# //Access: O(N)
# //Recall with array implenetation, insertion and removal is not constant
{
"swagger": "2.0",
"basePath": "/",
"info": {
"version": "1.0",
"title": "External Service for demo bank",
"description": "### External Service for demo bank",
"x-vcap-service-name": "DemoBankRestServices"
},
"securityDefinitions": {
"basicAuth": {
"type": "basic"
}
},
"security": [{
"basicAuth": []
}],
"tags": [{
"name": "DemoBankRestServices"
}],
"paths": {
"/accounts/{accountName}": {
"get": {
"operationId": "getAccount",
"summary": "Retrieves an account",
"description": "Retrieves the account with specific name",
"consumes": ["text/plain"],
"produces": ["application/json"],
"parameters": [{
"name": "accountName",
"in": "path",
"required": true,
"type": "string",
"description": "Name of the account"
}],
"responses": {
"200": {
"description": "The response when system finds an account with given name",
"schema": {
"$ref": "#/definitions/accountDetails"
}
},
"400": {
"description": "Error response if the account name parameter is less than minimum characters",
"schema": {
"$ref": "#/definitions/errorModel"
}
},
"404": {
"description": "Error response if the account is not supported by service or account is not found",
"schema": {
"$ref": "#/definitions/errorModel"
}
}
}
},
"delete": {
"operationId": "DeleteAccount",
"summary": "Deletes an account",
"description": "Deletes the account with specific name",
"consumes": ["text/plain"],
"produces": ["application/json"],
"parameters": [{
"name": "accountName",
"in": "path",
"required": true,
"type": "string",
"description": "Name of the account"
}],
"responses": {
"204": {
"description": "The response when system finds an account with given name",
"schema": {
"type": "string"
}
},
"400": {
"description": "Error response if the account name parameter is less than minimum characters",
"schema": {
"$ref": "#/definitions/errorModel"
}
},
"404": {
"description": "Error response if the account is not supported by service or account is not found",
"schema": {
"$ref": "#/definitions/errorModel"
}
}
}
},
"post": {
"operationId": "addAccount",
"summary": "Add an account",
"description": "Add an account to the database",
"consumes": ["text/plain"],
"produces": ["application/json"],
"parameters": [{
"name": "accountName",
"in": "path",
"required": true,
"type": "string",
"description": "Name of the account"
}, {
"name": "accountType",
"in": "query",
"required": true,
"type": "string",
"description": "The type of account"
}],
"responses": {
"201": {
"description": "The response when the account does not already exist and we can create one",
"schema": {
"$ref": "#/definitions/accountDetails"
}
},
"409": {
"description": "The response when the account already exists and we cannot create one",
"schema": {
"$ref": "#/definitions/accountDetails"
}
},
"400": {
"description": "Error response if the account name parameter is less than minimum characters",
"schema": {
"$ref": "#/definitions/errorModel"
}
},
"404": {
"description": "Error response if the account is not supported by service or account is not found",
"schema": {
"$ref": "#/definitions/errorModel"
}
}
}
},
"put": {
"operationId": "updateAccount",
"summary": "Updates an account",
"description": "Updates the account with specified name",
"consumes": ["text/plain"],
"produces": ["application/json"],
"parameters": [{
"name": "accountName",
"in": "path",
"required": true,
"type": "string",
"description": "Name of the account"
}, {
"name": "accountType",
"in": "query",
"required": true,
"type": "string",
"description": "The type of account"
}],
"responses": {
"200": {
"description": "The response when system finds an account with given name",
"schema": {
"$ref": "#/definitions/accountDetails"
}
},
"400": {
"description": "Error response if the account name parameter is less than minimum characters",
"schema": {
"$ref": "#/definitions/errorModel"
}
},
"404": {
"description": "Error response if the account is not supported by service or account is not found",
"schema": {
"$ref": "#/definitions/errorModel"
}
}
}
}
}
},
"definitions": {
"accountDetails": {
"required": ["id", "name", "type", "availableBal"],
"properties": {
"id": {
"type": "string",
"description": "id"
},
"name": {
"type": "string",
"description": "name"
},
"type": {
"type": "string",
"description": "type"
},
"availableBal": {
"type": "string",
"description": "availableBal"
}
}
},
"errorModel": {
"required": ["errorCode", "errorMessage"],
"properties": {
"errorCode": {
"type": "string",
"description": "A service-specific error code."
},
"errorMessage": {
"type": "string",
"description": "A service-specific error code."
}
}
}
}
}
public class Sale {
public String messageId;
public String eventId;
public Decimal eventSchemaVersion;
public String eventInstanceOriginationDateTime;
public SaleEventData eventData;
}
public class SaleEventData {
public Integer siteId;
public Integer saleId;
public String purchasingClientId;
public List<PaymentDetails> payments;
public String saleDateTime;
public String soldById;
public String soldByName;
public Integer locationId;
public Integer totalAmountPaid;
public List<SaleItemDetails> items;
}
public class PaymentDetails {
public Integer paymentId;
public Integer paymentMethodId;
public String paymentMethodName;
public String paymentAmountPaid;
public Integer paymentLastFour;
public String paymentNotes;
}
public class SaleItemDetails {
public Integer itemId;
public String type;
public String name;
public Integer amountPaid;
public Integer amountDiscounted;
public Integer quantity;
public String recipientClientId;
public Integer paymentReferenceId;
}
Sale mbSale = (Sale)JSON.deserialize(jsonInput, Sale.class);
// Remove class from body tag
function alpha_body_class($classes){
unset($classes[array_search('class-one', $classes)]);
unset($classes[array_search('class-two', $classes)]);
unset($classes[array_search('class-three', $classes)]);
return $classes;
}
add_filter('body_class', 'alpha_body_class');
Comments