1: <?php
2: namespace NGS\Client;
3:
4: require_once(__DIR__.'/../Utils.php');
5: require_once(__DIR__.'/../Name.php');
6: require_once(__DIR__.'/RestHttp.php');
7: require_once(__DIR__.'/../Patterns/Repository.php');
8: require_once(__DIR__.'/QueryString.php');
9:
10: use InvalidArgumentException;
11: use NGS\Converter\ObjectConverter;
12: use NGS\Name;
13: use NGS\Patterns\Repository;
14: use NGS\Utils;
15:
16: 17: 18: 19: 20:
21: class StandardProxy
22: {
23: const STANDARD_URI = 'Commands.svc';
24: const APPLICATION_URI = 'RestApplication.svc';
25:
26: protected $http;
27:
28: protected static $instance;
29:
30: 31: 32: 33: 34: 35:
36: public function __construct(RestHttp $http = null)
37: {
38: $this->http = $http !== null ? $http : RestHttp::instance();
39: }
40:
41: 42: 43: 44: 45:
46: public static function instance()
47: {
48: if(self::$instance === null)
49: self::$instance = new StandardProxy();
50: return self::$instance;
51: }
52:
53: 54: 55: 56: 57: 58:
59: public function insert(array $aggregates)
60: {
61: if(empty($aggregates))
62: return array();
63: $response = $this->persist('POST', $aggregates);
64: return RestHttp::parseResult($response);
65: }
66:
67: private static function invalidate(array $aggregates)
68: {
69: $uris = array();
70: foreach($aggregates as $root) {
71: $uris[] = $root->URI;
72: }
73: Repository::instance()->invalidate(get_class($aggregates[0]), $uris);
74: }
75:
76: 77: 78: 79: 80:
81: public function update(array $aggregates)
82: {
83: if(!empty($aggregates)) {
84: $this->persist('PUT', $aggregates);
85: self::invalidate($aggregates);
86: }
87: }
88:
89: 90: 91: 92: 93: 94: 95:
96: public function delete(array $aggregates)
97: {
98: if(empty($aggregates))
99: return ;
100: if(!is_object($aggregates[0]))
101: throw new InvalidArgumentException("Could not delete aggregates. First element was not an object.");
102: $class = get_class($aggregates[0]);
103: foreach($aggregates as $index => $item) {
104: if (!$item instanceof $class) {
105: throw new InvalidArgumentException('Could not delete aggregates. Element with index "'.$index.'" was not an instance of "'.$class.'", type was "'.Utils::getType($item).'"');
106: }
107: if ($item->URI === null) {
108: throw new InvalidArgumentException('Could not delete aggregate element "'.$class.'" with index "'.$index.'". Aggregate URI was null');
109: }
110: }
111: $converter = ObjectConverter::getConverter($class, ObjectConverter::JSON_TYPE);
112: $body = array(
113: 'RootName' => Name::full($class),
114:
115: 'ToDelete' => $converter::toJson($aggregates)
116: );
117: $body = json_encode($body);
118:
119: $result = $this->http->sendRequest(
120: self::APPLICATION_URI.'/PersistAggregateRoot',
121: 'POST',
122: $body,
123: array(200, 201));
124: self::invalidate($aggregates);
125: return $result;
126: }
127:
128: private function persist($method, array $aggregates)
129: {
130: $class = get_class($aggregates[0]);
131: $name = Name::full($class);
132: $values = array_map(function($it) { return $it->toArray(); }, $aggregates);
133: return
134: $this->http->sendRequest(
135: self::STANDARD_URI.'/persist/'.rawurlencode($name),
136: $method,
137: json_encode($values),
138: array(200));
139: }
140:
141: 142: 143: 144: 145:
146: public function olapCubeWithSpecification(
147: $cube,
148: $specification,
149: array $dimensions,
150: array $facts,
151: array $order = array())
152: {
153: $cube = Name::full($cube);
154: $name = Name::base($specification);
155: $fullName = Name::full($specification);
156: if(strncmp($fullName, $cube, strlen($cube)) != 0)
157: $name = substr($fullName, 0, strlen($fullName) - strlen($name) - 1).'+'.$name;
158: $arguments = QueryString::prepareCubeCall($dimensions, $facts, $order);
159: $response =
160: $this->http->sendRequest(
161: self::STANDARD_URI.'/olap/'.rawurlencode($cube).'?specification='.rawurlencode($name).'&'.$arguments,
162: 'PUT',
163: $specification->toJson(),
164: array(201));
165: return RestHttp::parseResult($response);
166: }
167:
168: 169: 170:
171: public function olapCube(
172: $cube,
173: array $dimensions,
174: array $facts,
175: array $order = array())
176: {
177: $cube = Name::full($cube);
178: $arguments = QueryString::prepareCubeCall($dimensions, $facts, $order);
179: $response =
180: $this->http->sendRequest(
181: self::STANDARD_URI.'/olap/'.rawurlencode($cube).'?'.$arguments,
182: 'GET',
183: null,
184: array(201));
185: return RestHttp::parseResult($response);
186: }
187:
188: 189: 190: 191: 192:
193: public function execute(
194: $service,
195: $body=null
196: )
197: {
198: if(is_array($body))
199: $body = json_encode($body);
200: if(!is_string($body) && $body!==null)
201: throw new InvalidArgumentException("Execute body must be array or string");
202:
203: $response =
204: $this->http->sendRequest(
205: self::STANDARD_URI.'/execute/'.rawurlencode($service),
206: 'POST',
207: $body,
208: array(200, 201));
209: return RestHttp::parseResult($response);
210: }
211: }
212: