Proyectos de Subversion LeadersLinked - Services

Rev

Rev 283 | Rev 590 | Ir a la última revisión | Mostrar el archivo completo | | | Autoría | Ultima modificación | Ver Log |

Rev 283 Rev 587
Línea 9... Línea 9...
9 
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
 9 
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
10 
use Laminas\Db\Sql\Expression;
 10 
use Laminas\Db\Sql\Expression;
11 
use Laminas\Paginator\Paginator;
 11 
use Laminas\Paginator\Paginator;
12 
use Laminas\Db\ResultSet\HydratingResultSet;
 12 
use Laminas\Db\ResultSet\HydratingResultSet;
13 
use Laminas\Paginator\Adapter\DbSelect;
 13 
use Laminas\Paginator\Adapter\DbSelect;
14 
 
 - 
 
- 
 
 14 
use Laminas\Db\Sql\Select;
Línea 15... Línea 15...
15 
 
 15 
 
16 
class MicrolearningSlideMapper extends MapperCommon
 16 
class MicrolearningSlideMapper extends MapperCommon
17 
{
 17 
{
Línea 18... Línea 18...
18 
    const _TABLE = 'tbl_microlearning_slides';
 18 
    const _TABLE = 'tbl_microlearning_slides';
19
- 
 
20 
    /**
 19
21 
     *
 20 
    /**
22 
     * @var MicrolearningSlideMapper
 21 
     * @var MicrolearningSlideMapper
Línea 23... Línea 22...
23 
     */
 22 
     */
24 
    private static $_instance;
 - 
 
25
23 
    private static $_instance;
26 
    /**
 24
27 
     *
 25 
    /**
28 
     * @param AdapterInterface $adapter
 26 
     * @param AdapterInterface $adapter
29 
     */
 27 
     */
30 
    private function __construct($adapter)
 28 
    private function __construct($adapter)
Línea 31... Línea 29...
31 
    {
 29 
    {
32 
        parent::__construct($adapter);
 - 
 
33 
    }
 30 
        parent::__construct($adapter);
34
31 
    }
35 
    /**
 32
36 
     *
 33 
    /**
37 
     * @param AdapterInterface $adapter
 34 
     * @param AdapterInterface $adapter
38 
     * @return MicrolearningSlideMapper
 35 
     * @return MicrolearningSlideMapper
39 
     */
 36 
     */
40 
    public static function getInstance($adapter)
 37 
    public static function getInstance($adapter)
41 
    {
 38 
    {
42 
        if(self::$_instance == null) {
 39 
        if(self::$_instance == null) {
43 
            self::$_instance = new MicrolearningSlideMapper($adapter);
 - 
 
44 
        }
 - 
 
45 
        return self::$_instance;
 - 
 
46 
    }
 - 
 
47
- 
 
48 
    /**
 - 
 
49 
     *
 - 
 
50 
     * @param int $company_id
 - 
 
51 
     * @param int $topic_id
 - 
 
52 
     * @param int $capsule_id
 - 
 
53 
     * @return int
 - 
 
54 
     */
 - 
 
55 
    public function fetchTotalCountByCompanyIdAndTopicIdAndCapsuleId($company_id, $topic_id, $capsule_id)
 - 
 
56 
    {
 - 
 
57 
        $select = $this->sql->select();
 - 
 
58 
        $select->columns(['total' => new Expression('COUNT(*)')]);
 - 
 
59 
        $select->from(self::_TABLE);
 - 
 
60 
        $select->where->equalTo('company_id', $company_id);
 - 
 
61 
        $select->where->equalTo('topic_id', $topic_id);
 - 
 
62 
        $select->where->equalTo('capsule_id', $capsule_id);
 - 
 
63
- 
 
64 
        $record = $this->executeFetchOneArray($select);
 - 
 
65 
        return $record['total'];
 - 
 
66 
    }
 - 
 
67
- 
 
68 
    /**
 - 
 
69 
     *
 - 
 
70 
     * @param int $company_id
 - 
 
71 
     * @param int $topic_id
 - 
 
72 
     * @return int
 - 
 
73 
     */
 - 
 
74 
    public function fetchTotalCountByCompanyIdAndTopicId($company_id, $topic_id)
 - 
 
75 
    {
 - 
 
76 
        $select = $this->sql->select();
 - 
 
77 
        $select->columns(['total' => new Expression('COUNT(*)')]);
 - 
 
78 
        $select->from(self::_TABLE);
 - 
 
79 
        $select->where->equalTo('company_id', $company_id);
 - 
 
80 
        $select->where->equalTo('topic_id', $topic_id);
 - 
 
81
- 
 
82
- 
 
83 
       // echo $select->getSqlString($this->adapter->platform) . PHP_EOL;
 - 
 
84
- 
 
85 
        $record = $this->executeFetchOneArray($select);
 - 
 
86 
        return $record['total'];
 - 
 
87 
    }
 - 
 
88
- 
 
89
- 
 
90 
    /**
 - 
 
91 
     *
 - 
 
92 
     * @param int $company_id
 - 
 
93 
     * @param int $quiz_id
 - 
 
94 
     * @return int
 - 
 
95 
     */
 - 
 
96 
    public function fetchTotalCountByCompanyIdQuizId($company_id, $quiz_id)
 - 
 
97 
    {
 - 
 
98 
        $select = $this->sql->select();
 - 
 
99 
        $select->columns(['total' => new Expression('COUNT(*)')]);
 - 
 
100 
        $select->from(self::_TABLE);
 - 
 
101 
        $select->where->equalTo('company_id', $company_id);
 - 
 
102 
        $select->where->equalTo('quiz_id', $quiz_id);
 - 
 
Línea 103... Línea -...
103
- 
 
104 
        $record = $this->executeFetchOneArray($select);
 40 
            self::$_instance = new MicrolearningSlideMapper($adapter);
105 
        return $record['total'];
 41 
        }
106 
    }
 42 
        return self::$_instance;
107 
 
 43 
    }
108
44 
 
109 
    /**
 45 
    /**
110 
     *
 46 
     * Fetch a slide by its ID
111 
     * @param int $id
 47 
     * @param int $id
112 
     * @return MicrolearningSlide
 - 
 
113 
     */
 48 
     * @return MicrolearningSlide|null
114 
    public function fetchOne($id)
 49 
     */
115 
    {
 - 
 
116 
        $prototype = new MicrolearningSlide();
 50 
    public function fetchOne($id)
117
51 
    {
118 
        $select = $this->sql->select(self::_TABLE);
 52 
        $prototype = new MicrolearningSlide();
119 
        $select->where->equalTo('id', $id);
 53 
        $select = $this->sql->select(self::_TABLE);
120
54 
        $select->where->equalTo('id', $id);
121 
        return $this->executeFetchOneObject($select, $prototype);
 55 
        return $this->executeFetchOneObject($select, $prototype);
122 
    }
 56 
    }
123
57 
 
124 
    /**
 58 
    /**
125 
     *
 59 
     * Fetch a slide by its UUID
126 
     * @param int $uuid
 60 
     * @param string $uuid
127 
     * @return MicrolearningSlide
 61 
     * @return MicrolearningSlide|null
128 
     */
 62 
     */
129 
    public function fetchOneByUuid($uuid)
 - 
 
130 
    {
 63 
    public function fetchOneByUuid($uuid)
131 
        $prototype = new MicrolearningSlide;
 64 
    {
132 
        $select = $this->sql->select(self::_TABLE);
 65 
        $prototype = new MicrolearningSlide();
133 
        $select->where->equalTo('uuid', $uuid);
 66 
        $select = $this->sql->select(self::_TABLE);
- 
 
 67 
        $select->where->equalTo('uuid', $uuid);
- 
 
 68 
        return $this->executeFetchOneObject($select, $prototype);
- 
 
 69 
    }
134
70 
 
- 
 
 71 
    /**
- 
 
 72 
     * Fetch slides by company ID
- 
 
 73 
     * @param int $company_id
- 
 
 74 
     * @return MicrolearningSlide[]
- 
 
 75 
     */
- 
 
 76 
    public function fetchAllByCompanyId($company_id)
- 
 
 77 
    {
- 
 
 78 
        $prototype = new MicrolearningSlide();
- 
 
 79 
        $select = $this->sql->select(self::_TABLE);
- 
 
 80 
        $select->where->equalTo('company_id', $company_id);
- 
 
 81 
        $select->order(['order', 'name']);
135 
        return $this->executeFetchOneObject($select, $prototype);
 82 
        return $this->executeFetchAllObject($select, $prototype);
136 
    }
 - 
 
137
83 
    }
138 
    /**
 84 
 
139 
     *
 85 
    /**
140 
     * @param int $company_id
 86 
     * Fetch slides by company ID and capsule ID
141 
     * @param int $topic_id
 87 
     * @param int $company_id
142 
     * @param int $capsule_id
 88 
     * @param int $capsule_id
143 
     * @return MicrolearningSlide[]
 - 
 
144 
     */
 89 
     * @return MicrolearningSlide[]
145 
    public function fetchAllByCompanyIdAndTopicIdAndCapsuleId($company_id, $topic_id, $capsule_id)
 90 
     */
146 
    {
 - 
 
147 
        $prototype = new MicrolearningSlide();
 91 
    public function fetchAllByCompanyIdAndCapsuleId($company_id, $capsule_id)
148
92 
    {
149 
        $select = $this->sql->select(self::_TABLE);
 - 
 
150 
        $select->where->equalTo('company_id', $company_id);
 93 
        $prototype = new MicrolearningSlide();
151 
        $select->where->equalTo('topic_id', $topic_id);
 94 
        $select = $this->sql->select(self::_TABLE);
152 
        $select->where->equalTo('capsule_id', $capsule_id);
 - 
 
153 
        $select->order(['order', 'name']);
 95 
        $select->where->equalTo('company_id', $company_id);
154
96 
        $select->where->equalTo('capsule_id', $capsule_id);
155 
        return $this->executeFetchAllObject($select, $prototype);
 97 
        $select->order(['order', 'name']);
156 
    }
 98 
        return $this->executeFetchAllObject($select, $prototype);
157
- 
 
158
99 
    }
159 
    /**
 100 
 
160 
     *
 101 
    /**
161 
     * @param int $company_id
 102 
     * Fetch first slide by company ID and capsule ID
162 
     * @param int $topic_id
 103 
     * @param int $company_id
163 
     * @param int $capsule_id
 104 
     * @param int $capsule_id
164 
     * @return MicrolearningSlide
 - 
 
165 
     */
 105 
     * @return MicrolearningSlide|null
166 
    public function fetchFirstByCompanyIdAndTopicIdAndCapsuleId($company_id, $topic_id, $capsule_id)
 106 
     */
167 
    {
 - 
 
168 
        $prototype = new MicrolearningSlide();
 107 
    public function fetchFirstByCompanyIdAndCapsuleId($company_id, $capsule_id)
169
108 
    {
170 
        $select = $this->sql->select(self::_TABLE);
 - 
 
171 
        $select->where->equalTo('company_id', $company_id);
 - 
 
172 
        $select->where->equalTo('topic_id', $topic_id);
 109 
        $prototype = new MicrolearningSlide();
173 
        $select->where->equalTo('capsule_id', $capsule_id);
 110 
        $select = $this->sql->select(self::_TABLE);
174 
        $select->order(['order']);
 111 
        $select->where->equalTo('company_id', $company_id);
175
112 
        $select->where->equalTo('capsule_id', $capsule_id);
176
- 
 
177 
        return $this->executeFetchOneObject($select, $prototype);
 113 
        $select->order(['order']);
178 
    }
 - 
 
179
114 
        return $this->executeFetchOneObject($select, $prototype);
180 
    /**
 - 
 
181 
     *
 - 
 
182 
     * @param int $companyId
 - 
 
183 
     * @param int $capsuleId
 - 
 
184 
     * @param string $search
 115 
    }
185 
     * @param int $page
 - 
 
186 
     * @param int $records_per_page
 116 
 
187 
     * @param string $order_field
 117 
    /**
188 
     * @param string $order_direction
 118 
     * Fetch slides by type
189 
     * @return Paginator
 119 
     * @param string $type
190 
     *
120 
     * @return MicrolearningSlide[]
191 
     */
 - 
 
192 
    public function fetchAllDataTableByCompanyIdAndCapsuleId($companyId, $capsuleId,  $search, $page = 1, $records_per_page = 10, $order_field= 'name', $order_direction = 'ASC')
 121 
     */
193 
    {
 - 
 
194 
        $prototype = new MicrolearningSlide();
 - 
 
195 
        $select = $this->sql->select(self::_TABLE);
 - 
 
196 
        $select->where->equalTo('company_id', $companyId);
 - 
 
197 
        $select->where->equalTo('capsule_id', $capsuleId);
 122 
    public function fetchAllByType($type)
198
- 
 
199 
        if($search) {
 - 
 
200 
            $select->where->like('name', '%' . $search . '%');
 - 
 
201 
        }
 - 
 
202 
        $select->order($order_field . ' ' . $order_direction);
 123 
    {
203
- 
 
204 
        //echo $select->getSqlString($this->adapter->platform); exit;
 - 
 
205
- 
 
206 
        $hydrator   = new ObjectPropertyHydrator();
 - 
 
207 
        $resultset  = new HydratingResultSet($hydrator, $prototype);
 - 
 
208
- 
 
209 
        $adapter = new DbSelect($select, $this->sql, $resultset);
 - 
 
210 
        $paginator = new Paginator($adapter);
 - 
 
211 
        $paginator->setItemCountPerPage($records_per_page);
 124 
        $prototype = new MicrolearningSlide();
212 
        $paginator->setCurrentPageNumber($page);
 125 
        $select = $this->sql->select(self::_TABLE);
- 
 
 126 
        $select->where->equalTo('type', $type);
- 
 
 127 
        $select->order(['order', 'name']);
- 
 
 128 
        return $this->executeFetchAllObject($select, $prototype);
- 
 
 129 
    }
- 
 
 130 
 
- 
 
 131 
    /**
- 
 
 132 
     * Fetch slides by quiz ID
- 
 
 133 
     * @param int $quiz_id
- 
 
 134 
     * @return MicrolearningSlide[]
- 
 
 135 
     */
- 
 
 136 
    public function fetchAllByQuizId($quiz_id)
- 
 
 137 
    {
- 
 
 138 
        $prototype = new MicrolearningSlide();
213
139 
        $select = $this->sql->select(self::_TABLE);
214
140 
        $select->where->equalTo('quiz_id', $quiz_id);
- 
 
 141 
        $select->order(['order', 'name']);
- 
 
 142 
        return $this->executeFetchAllObject($select, $prototype);
- 
 
 143 
    }
215 
        return $paginator;
 144 
 
- 
 
 145 
    /**
- 
 
 146 
     * Get total count of slides by company ID
- 
 
 147 
     * @param int $company_id
- 
 
 148 
     * @return int
- 
 
 149 
     */
- 
 
 150 
    public function fetchTotalCountByCompanyId($company_id)
- 
 
 151 
    {
- 
 
 152 
        $select = $this->sql->select();
- 
 
 153 
        $select->columns(['total' => new Expression('COUNT(*)')]);
- 
 
 154 
        $select->from(self::_TABLE);
- 
 
 155 
        $select->where->equalTo('company_id', $company_id);
- 
 
 156 
        $record = $this->executeFetchOneArray($select);
- 
 
 157 
        return (int)$record['total'];
- 
 
 158 
    }
- 
 
 159 
 
- 
 
 160 
    /**
- 
 
 161 
     * Get total count of slides by company ID and capsule ID
- 
 
 162 
     * @param int $company_id
- 
 
 163 
     * @param int $capsule_id
- 
 
 164 
     * @return int
- 
 
 165 
     */
- 
 
 166 
    public function fetchTotalCountByCompanyIdAndCapsuleId($company_id, $capsule_id)
- 
 
 167 
    {
- 
 
 168 
        $select = $this->sql->select();
- 
 
 169 
        $select->columns(['total' => new Expression('COUNT(*)')]);
- 
 
 170 
        $select->from(self::_TABLE);
- 
 
 171 
        $select->where->equalTo('company_id', $company_id);
- 
 
 172 
        $select->where->equalTo('capsule_id', $capsule_id);
- 
 
 173 
        $record = $this->executeFetchOneArray($select);
- 
 
 174 
        return (int)$record['total'];
- 
 
 175 
    }
- 
 
 176 
 
- 
 
 177 
    /**
- 
 
 178 
     * Get total count of slides by company ID and quiz ID
- 
 
 179 
     * @param int $company_id
- 
 
 180 
     * @param int $quiz_id
- 
 
 181 
     * @return int
- 
 
 182 
     */
- 
 
 183 
    public function fetchTotalCountByCompanyIdAndQuizId($company_id, $quiz_id)
- 
 
 184 
    {
- 
 
 185 
        $select = $this->sql->select();
- 
 
 186 
        $select->columns(['total' => new Expression('COUNT(*)')]);
- 
 
 187 
        $select->from(self::_TABLE);
- 
 
 188 
        $select->where->equalTo('company_id', $company_id);
- 
 
 189 
        $select->where->equalTo('quiz_id', $quiz_id);
- 
 
 190 
        $record = $this->executeFetchOneArray($select);
216 
    }
 191 
        return (int)$record['total'];
217
192 
    }
218
193 
 
219 
    /**
 194 
    /**
220 
     *
 195 
     * Insert a new slide
221 
     * @param MicrolearningSlide $slide
 196 
     * @param MicrolearningSlide $slide
222 
     * @return boolean
 197 
     * @return bool
223 
     */
 198 
     */
224 
    public function insert($slide)
 199 
    public function insert($slide)
225 
    {
 200 
    {
226 
        $hydrator = new ObjectPropertyHydrator();
 201 
        $hydrator = new ObjectPropertyHydrator();
Línea 227... Línea 202...
227 
        $values = $hydrator->extract($slide);
 202 
        $values = $hydrator->extract($slide);
228 
        $values = $this->removeEmpty($values);
 203 
        $values = $this->removeEmpty($values);
229
204
230 
        $insert = $this->sql->insert(self::_TABLE);
 205 
        $insert = $this->sql->insert(self::_TABLE);
231 
        $insert->values($values);
 206 
        $insert->values($values);
232 
 
 207 
 
233 
        $result = $this->executeInsert($insert);
 208 
        $result = $this->executeInsert($insert);
234 
        if($result) {
 209 
        if($result) {
235 
            $slide->id = $this->lastInsertId;
 210 
            $slide->id = $this->lastInsertId;
236 
        }
 211 
        }
237 
        return $result;
 212 
        return $result;
238 
    }
 213 
    }
239
214 
 
240 
    /**
 215 
    /**
241 
     *
 - 
 
242 
     * @param MicrolearningSlide $slide
 216 
     * Update an existing slide
243 
     * @return boolean
 217 
     * @param MicrolearningSlide $slide
244 
     */
 218 
     * @return bool
Línea 245... Línea 219...
245 
    public function update($slide)
 219 
     */
246 
    {
 220 
    public function update($slide)
247 
 
 221 
    {
248 
        $hydrator = new ObjectPropertyHydrator();
 - 
 
Línea 249... Línea 222...
249 
        $values = $hydrator->extract($slide);
 222 
        $hydrator = new ObjectPropertyHydrator();
250 
        $values = $this->removeEmpty($values);
 223 
        $values = $hydrator->extract($slide);
251
224 
        $values = $this->removeEmpty($values);
252 
        $update = $this->sql->update(self::_TABLE);
 225
253 
        $update->set($values);
 226 
        $update = $this->sql->update(self::_TABLE);
254 
        $update->where->equalTo('id', $slide->id);
 227 
        $update->set($values);
255
228 
        $update->where->equalTo('id', $slide->id);
256 
 
 229 
 
257 
        return $this->executeUpdate($update);
 230 
        return $this->executeUpdate($update);
258 
    }
 231 
    }
259
232 
 
260 
    /**
 233 
    /**
261 
     *
 - 
 
262 
     * @param MicrolearningSlide $slide
 234 
     * Delete a slide
263 
     * @return boolean
 235 
     * @param MicrolearningSlide $slide
264 
     */
 - 
 
Línea -... Línea 236...
- 
 
 236 
     * @return bool
- 
 
 237 
     */
- 
 
 238 
    public function delete($slide)
- 
 
 239 
    {
- 
 
 240 
        $delete = $this->sql->delete(self::_TABLE);
- 
 
 241 
        $delete->where->equalTo('id', $slide->id);
- 
 
 242 
        return $this->executeDelete($delete);
- 
 
 243 
    }
- 
 
 244 
 
- 
 
 245 
    /**
- 
 
 246 
     * Fetch slides for datatable with pagination
- 
 
 247 
     * @param int $companyId
- 
 
 248 
     * @param int $capsuleId
- 
 
 249 
     * @param string $search
- 
 
 250 
     * @param int $page
- 
 
 251 
     * @param int $records_per_page
- 
 
 252 
     * @param string $order_field
265 
    public function delete($slide)
 253 
     * @param string $order_direction
- 
 
 254 
     * @return Paginator
- 
 
 255 
     */
- 
 
 256 
    public function fetchAllDataTableByCompanyIdAndCapsuleId($companyId, $capsuleId, $search, $page = 1, $records_per_page = 10, $order_field = 'name', $order_direction = 'ASC')
- 
 
 257 
    {
- 
 
 258 
        $prototype = new MicrolearningSlide();
- 
 
 259 
        $select = $this->sql->select(self::_TABLE);
- 
 
 260 
        $select->where->equalTo('company_id', $companyId);
- 
 
 261 
        $select->where->equalTo('capsule_id', $capsuleId);
- 
 
 262
- 
 
 263 
        if($search) {
- 
 
 264 
            $select->where->like('name', '%' . $search . '%');
- 
 
 265 
        }
- 
 
 266
- 
 
 267 
        $select->order($order_field . ' ' . $order_direction);
- 
 
 268
- 
 
 269 
        $hydrator = new ObjectPropertyHydrator();
266 
    {
 270 
        $resultset = new HydratingResultSet($hydrator, $prototype);
267 
        $delete = $this->sql->delete(self::_TABLE);
 271